One place for hosting & domains


      How To Use the sqlite3 Module in Python 3

      The author selected the COVID-19 Relief Fund to receive a donation as part of the Write for DOnations program.


      SQLite is a self-contained, file-based SQL database. SQLite comes bundled with Python and can be used in any of your Python applications without having to install any additional software.

      In this tutorial, we’ll go through the sqlite3 module in Python 3. We’ll create a connection to a SQLite database, add a table to that database, insert data into that table, and read and modify data in that table.

      For this tutorial, we’ll be working primarily with an inventory of fish that we need to modify as fish are added to or removed from a fictional aquarium.


      To get the most out of this tutorial, it is recommended to have some familiarity with programming in Python and some basic background with SQL.

      You can review these tutorials for the necessary background information:

      Step 1 — Creating a Connection to a SQLite Database

      When we connect to a SQLite database, we are accessing data that ultimately resides in a file on our computer. SQLite databases are fully featured SQL engines that can be used for many purposes. For now, we’ll consider a database that tracks the inventory of fish at a fictional aquarium.

      We can connect to a SQLite database using the Python sqlite3 module:

      import sqlite3
      connection = sqlite3.connect("aquarium.db")

      import sqlite3 gives our Python program access to the sqlite3 module. The sqlite3.connect() function returns a Connection object that we will use to interact with the SQLite database held in the file aquarium.db. The aquarium.db file is created automatically by sqlite3.connect() if aquarium.db does not already exist on our computer.

      We can verify we successfully created our connection object by running:


      If we run this Python code, we will see output like:



      connection.total_changes is the total number of database rows that have been changed by connection. Since we have not executed any SQL commands yet, 0 total_changes is correct.

      If, at any time, we find we want to start this tutorial again, we can delete the aquarium.db file from our computer.

      Note: It is also possible to connect to a SQLite database that resides strictly in memory (and not in a file) by passing the special string ":memory:" into sqlite3.connect(). For example, sqlite3.connect(":memory:"). A ":memory:" SQLite database will disappear as soon as your Python program exits. This might be convenient if you want a temporary sandbox to try something out in SQLite, and don’t need to persist any data after your program exits.

      Step 2 — Adding Data to the SQLite Database

      Now that we have connected to the aquarium.db SQLite database, we can start inserting and reading data from it.

      In a SQL database, data is stored in tables. Tables define a set of columns, and contain 0 or more rows with data for each of the defined columns.

      We will create a table named fish that tracks the following data:

      name species tank_number
      Sammy shark 1
      Jamie cuttlefish 7

      The fish table will track a value for name, species, and tank_number for each fish at the aquarium. Two example fish rows are listed: one row for a shark named Sammy, and one row for a cuttlefish named Jamie.

      We can create this fish table in SQLite using the connection we made in Step 1:

      cursor = connection.cursor()
      cursor.execute("CREATE TABLE fish (name TEXT, species TEXT, tank_number INTEGER)")

      connection.cursor() returns a Cursor object. Cursor objects allow us to send SQL statements to a SQLite database using cursor.execute(). The "CREATE TABLE fish ..." string is a SQL statement that creates a table named fish with the three columns described earlier: name of type TEXT, species of type TEXT, and tank_number of type INTEGER.

      Now that we have created a table, we can insert rows of data into it:

      cursor.execute("INSERT INTO fish VALUES ('Sammy', 'shark', 1)")
      cursor.execute("INSERT INTO fish VALUES ('Jamie', 'cuttlefish', 7)")

      We call cursor.execute() two times: once to insert a row for the shark Sammy in tank 1, and once to insert a row for the cuttlefish Jamie in tank 7. "INSERT INTO fish VALUES ..." is a SQL statement that allows us to add rows to a table.

      In the next section, we will use a SQL SELECT statement to inspect the rows we just inserted into our fish table.

      Step 3 — Reading Data from the SQLite Database

      In Step 2, we added two rows to a SQLite table named fish. We can retrieve those rows using a SELECT SQL statement:

      rows = cursor.execute("SELECT name, species, tank_number FROM fish").fetchall()

      If we run this code, we will see output like the following:


      [('Sammy', 'shark', 1), ('Jamie', 'cuttlefish', 7)]

      The cursor.execute() function runs a SELECT statement to retrieve values for the name, species, and tank_number columns in the fish table. fetchall() retrieves all the results of the SELECT statement. When we print(rows) we see a list of two tuples. Each tuple has three entries; one entry for each column we selected from the fish table. The two tuples have the data we inserted in Step 2: one tuple for Sammy the shark, and one tuple for Jamie the cuttlefish.

      If we wanted to retrieve rows in the fish table that match a specific set of criteria, we can use a WHERE clause:

      target_fish_name = "Jamie"
      rows = cursor.execute(
          "SELECT name, species, tank_number FROM fish WHERE name = ?",

      If we run this, we will see output like the following:


      [('Jamie', 'cuttlefish', 7)]

      As with the previous example, cursor.execute(<SQL statment>).fetchall() allows us to fetch all the results of a SELECT statement. The WHERE clause in the SELECT statement filters for rows where the value of name is target_fish_name. Notice that we use ? to substitute our target_fish_name variable into the SELECT statement. We expect to only match one row, and indeed we only see the row for Jamie the cuttlefish returned.

      Warning: Never use Python string operations to dynamically create a SQL statement string. Using Python string operations to assemble a SQL statement string leaves you vulnerable to SQL injection attacks. SQL injection attacks can be used to steal, alter, or otherwise modify data stored in your database. Always use the ? placeholder in your SQL statements to dynamically substitute values from your Python program. Pass a tuple of values as the second argument to Cursor.execute() to bind your values to the SQL statement. This substitution pattern is demonstrated here and in other parts of this tutorial as well.

      Step 4 — Modifying Data in the SQLite Database

      Rows in a SQLite database can be modified using UPDATE and DELETE SQL statements.

      Let’s say, for example, that Sammy the shark was moved to tank number 2. We can change Sammy’s row in the fish table to reflect this change:

      new_tank_number = 2
      moved_fish_name = "Sammy"
          "UPDATE fish SET tank_number = ? WHERE name = ?",
          (new_tank_number, moved_fish_name)

      We issue an UPDATE SQL statement to change the tank_number of Sammy to its new value of 2. The WHERE clause in the UPDATE statement ensures we only change the value of tank_number if a row has name = "Sammy".

      If we run the following SELECT statement, we can confirm our update was made correctly:

      rows = cursor.execute("SELECT name, species, tank_number FROM fish").fetchall()

      If we run this, we will see output like the following:


      [('Sammy', 'shark', 2), ('Jamie', 'cuttlefish', 7)]

      Notice that the row for Sammy now has the value of 2 for its tank_number column.

      Let’s say that Sammy the shark was released into the wild and no longer held by the aquarium. Since Sammy no longer lives at the aquarium, it would make sense to remove the Sammy row from the fish table.

      Issue a DELETE SQL statement to remove a row:

      released_fish_name = "Sammy"
          "DELETE FROM fish WHERE name = ?",

      We issue a DELETE SQL statement to remove the row for Sammy the shark. The WHERE clause in the DELETE statement ensures we only delete a row if that row has name = "Sammy".

      If we run the following SELECT statement, we can confirm our deletion was made correctly:

      rows = cursor.execute("SELECT name, species, tank_number FROM fish").fetchall()

      If we run this code, we will see output like the following:


      [('Jamie', 'cuttlefish', 7)]

      Notice that the row for Sammy the shark is now gone, and only Jamie the cuttlefish remains.

      Step 5 — Using with Statements For Automatic Cleanup

      In this tutorial, we’ve used two primary objects to interact with the "aquarium.db" SQLite database: a Connection object named connection, and a Cursor object named cursor.

      In the same way that Python files should be closed when we are done working with them, Connection and Cursor objects should also be closed when they are no longer needed.

      We can use a with statement to help us automatically close Connection and Cursor objects:

      from contextlib import closing
      with closing(sqlite3.connect("aquarium.db")) as connection:
          with closing(connection.cursor()) as cursor:
              rows = cursor.execute("SELECT 1").fetchall()

      closing is a convenience function provided by the contextlib module. When a with statement exits, closing ensures that close() is called on whatever object is passed to it. The closing function is used twice in this example. Once to ensure that the Connection object returned by sqlite3.connect() is automatically closed, and a second time to ensure that the Cursor object returned by connection.cursor() is automatically closed.

      If we run this code, we will see output like the following:



      Since "SELECT 1" is a SQL statement that always returns a single row with a single column with a value of 1, it makes sense to see a single tuple with 1 as its only value returned by our code.


      The sqlite3 module is a powerful part of the Python standard library; it lets us work with a fully featured on-disk SQL database without installing any additional software.

      In this tutorial, we learned how to use the sqlite3 module to connect to a SQLite database, add data to that database, as well as read and modify data in that database. Along the way, we also learned about the risks of SQL injection attacks and how to use contextlib.closing to automatically call close() on Python objects in with statements.

      From here we can learn more about SQL databases in SQLite vs MySQL vs PostgreSQL: A Comparison Of Relational Database Management Systems.

      Source link

      Comment installer la distribution Anaconda pour Python sur Ubuntu 20.04


      Anaconda est un gestionnaire de paquets open-source, un gestionnaire d’environnement et une distribution des langages de programmation Python et R. Il est couramment utilisé pour la science des données, l’apprentissage machine, le traitement des données à grande échelle, le calcul scientifique et l’analyse prédictive.

      Proposant une collection de plus de 1 000 packages de science des données, Anaconda est disponible en version entreprise gratuite et payante. La distribution d’Anaconda est livrée avec l’utilitaire de ligne de commande conda. Vous pouvez en apprendre davantage sur Anaconda et conda en lisant la documentation officielle d’Anaconda.

      Ce tutoriel vous guidera dans l’installation de la version Python 3 d’Anaconda sur un serveur Ubuntu 20.04.

      Conditions préalables

      Avant de commencer ce guide, vous devez avoir un non root user avec des privilèges sudo configurés sur votre serveur.

      Vous pouvez remplir cette condition préalable en suivant notre guide de configuration initiale du serveur Ubuntu 20.04.

      Installation d’Anaconda

      La meilleure façon d’installer Anaconda est de télécharger le dernier script bash de l’installateur Anaconda, de le vérifier, puis de l’exécuter.

      Recherchez la dernière version d’Anaconda pour Python 3 sur la page des téléchargements d’Anaconda. Au moment où nous écrivons ces lignes, la dernière version est la 2020.02, mais vous devriez utiliser une version stable ultérieure si elle est disponible.

      Ensuite, allez dans le répertoire /tmp sur votre serveur. C’est un bon répertoire pour télécharger des éléments éphémères, comme le script Anaconda bash, dont nous n’aurons pas besoin après l’avoir exécuté.

      Utilisez curl pour télécharger le lien que vous avez copié du site web d’Anaconda. Nous le transférerons dans un fichier appelé pour une utilisation plus rapide.

      • curl --output

      Nous pouvons maintenant vérifier l’intégrité des données de l’installateur grâce à la vérification du hachage cryptographique, par le biais de la somme de contrôle SHA-256. Nous utiliserons la commande sha256sum, ainsi que le nom de fichier du script :

      Vous obtiendrez un résultat qui ressemble à ceci :



      Vous devez vérifier la sortie par rapport aux hachages disponibles sur la page Anaconda avec Python 3 sur Linux 64 bits pour votre version d’Anaconda. Tant que votre sortie correspond au hachage affiché dans la ligne sha2561, tout est bon.

      Nous pouvons maintenant exécuter le script :

      Vous recevrez la sortie suivante :


      Welcome to Anaconda3 2020.02 In order to continue the installation process, please review the license agreement. Please, press ENTER to continue >>>

      Appuyez sur ENTER pour continuer et appuyez ensuite sur ENTER pour lire la licence. Une fois que vous aurez fini de lire la licence, vous serez invité à approuver les termes de la licence :


      Do you approve the license terms? [yes|no]

      Si vous acceptez, tapez yes.

      À ce stade, vous serez invité à choisir l’emplacement de l’installation. Vous pouvez appuyer sur ENTER pour accepter l’emplacement par défaut, ou spécifier un autre emplacement pour le modifier.


      Anaconda3 will now be installed into this location: /home/sammy/anaconda3 - Press ENTER to confirm the location - Press CTRL-C to abort the installation - Or specify a different location below [/home/sammy/anaconda3] >>>

      Le processus d’installation se poursuivra. Notez qu’il peut prendre du temps.

      Une fois l’installation terminée, vous recevrez le résultat suivant :


      ... Preparing transaction: done Executing transaction: done installation finished. Do you wish the installer to initialize Anaconda3 by running conda init? [yes|no] [no] >>>

      Tapez oui pour pouvoir initialiser Anaconda3. Vous recevrez un résultat qui indique les modifications apportées dans les différents répertoires. Une des lignes que vous recevrez vous remerciera d’avoir installé Anaconda.


      ... Thank you for installing Anaconda3! ...

      Vous pouvez maintenant activer l’installation en vous récupérant le fichier ~/.bashrc :

      Une fois que vous aurez fait cela, vous serez placé dans l’environnement de programmation de base par défaut d’Anaconda, et votre invite de commande changera comme suit :

      Bien qu’Anaconda soit livré avec cet environnement de programmation de base par défaut, vous devez créer des environnements séparés pour vos programmes et les garder isolés les uns des autres.

      Vous pouvez également vérifier votre installation en utilisant la commande conda, par exemple avec list :

      Vous recevrez une sortie de tous les packages disponibles dans l’installation d’Anaconda :


      # packages in environment at /home/sammy/anaconda3: # # Name Version Build Channel _ipyw_jlab_nb_ext_conf 0.1.0 py37_0 _libgcc_mutex 0.1 main alabaster 0.7.12 py37_0 anaconda 2020.02 py37_0 ...

      Maintenant qu’Anaconda est installé, nous pouvons passer à la configuration des environnements d’Anaconda.

      Configuration des environnements d’Anaconda

      Les environnements virtuels d’Anaconda vous permettent de garder les projets organisés par versions Python et les paquets nécessaires. Pour chaque environnement Anaconda que vous créez, vous pouvez spécifier la version de Python à utiliser et vous pouvez conserver tous vos fichiers de programmation connexes dans ce répertoire.

      Tout d’abord, nous pouvons vérifier quelles versions de Python sont disponibles pour notre utilisation :

      Vous recevrez une sortie avec les différentes versions de Python que vous pouvez cibler, y compris les versions Python 3 et Python 2 Puisque nous utilisons Anaconda avec Python 3 dans ce tutoriel, vous n’aurez accès qu’aux versions de Python 3 des packages.

      Créons un environnement en utilisant la version la plus récente de Python 3. Nous pouvons le faire en assignant la version 3 à l’argument python. Nous appellerons l’environnement my_env, mais vous préférerez sans doute utiliser un nom plus explicite pour votre environnement, surtout si vous utilisez des environnements qui vous permettent d’accéder à plusieurs version de Python.

      • conda create --name my_env python=3

      Nous recevrons une sortie avec des informations sur ce qui est téléchargé et sur les paquets qui seront installés, puis nous serons invités à poursuivre avec y ou n. Si vous êtes d’accord, tapez y.

      L’utilitaire conda va maintenant récupérer les paquets pour l’environnement et vous faire savoir quand ce sera terminé.

      Vous pouvez activer votre nouvel environnement en tapant ce qui suit :

      Une fois votre environnement activé, le préfixe de votre invite de commande indiquera que vous n’êtes plus dans l’environnement de base, mais dans le nouvel environnement que vous venez de créer.

      Dans l’environnement, vous pouvez vérifier que vous utilisez la version de Python que vous aviez prévue pour utiliser :


      Python 3.8.2

      Lorsque vous êtes prêt à désactiver votre environnement Anaconda, vous pouvez le faire en tapant :

      Notez que vous pouvez remplacer le mot source par . pour obtenir les mêmes résultats.

      Pour cibler une version plus spécifique de Python, vous pouvez passer une version spécifique à l’argument python, comme 3.5, par exemple :

      • conda create -n my_env35 python=3.5

      Vous pouvez inspecter tous les environnements que vous avez configurés avec cette commande :


      # conda environments: # base * /home/sammy/anaconda3 my_env /home/sammy/anaconda3/envs/my_env my_env35 /home/sammy/anaconda3/envs/my_env35

      L’astérisque indique l’environnement actif actuel.

      Chaque environnement que vous créez avec conda create sera livré avec plusieurs paquets par défaut :

      • _libgcc_mutex
      • ca-certificates
      • certifi
      • libedit
      • libffi
      • libgcc-ng
      • libstdcxx-ng
      • ncurses
      • openssl
      • pip
      • python
      • readline
      • setuptools
      • sqlite
      • tk
      • wheel
      • xz
      • zlib

      Vous pouvez ajouter des paquets supplémentaires, tels que numpy par exemple, avec la commande suivante :

      • conda install --name my_env35 numpy

      Si vous savez, vous souhaitez un environnement numpy lors de la création, vous pouvez le cibler dans votre commande conda create :

      • conda create --name my_env python=3 numpy

      Si vous ne travaillez plus sur un projet spécifique et si vous n’avez plus besoin de l’environnement associé, vous pouvez le supprimer. Pour ce faire, tapez ce qui suit :

      • conda remove --name my_env35 --all

      Maintenant, lorsque vous tapez la commande conda info --envs, l’environnement que vous avez supprimé ne sera plus repertorié.

      Mettre à jour Anaconda

      Vous devriez régulièrement vous assurer qu’Anaconda est à jour afin de travailler avec toutes les dernières versions du package.

      Pour ce faire, vous devez d’abord mettre à jour l’utilitaire conda :

      Lorsque vous y êtes invité, tapez y pour procéder à la mise à jour.

      Une fois que la mise à jour de conda est terminée, vous pouvez mettre à jour la distribution Anaconda :

      Une fois encore, lorsque vous y êtes invité, tapez y pour continuer.

      Cela vous garantira que vous utilisez les dernières versions de conda et d’Anaconda.

      Désinstallation d’Anaconda

      Si vous n’utilisez plus Anaconda et que vous devez le désinstaller, vous devez commencer par le module anaconda-clean, qui supprimera les fichiers de configuration pour la désinstallation d’Anaconda.

      • conda install anaconda-clean

      Tapez y lorsque vous y êtes invité.

      Une fois installé, vous pouvez exécuter la commande suivante. Vous serez invité à répondre à y avant de supprimer chacun d’entre eux. Si vous préférez ne pas être invité à répondre, ajoutez --yes à la fin de votre commande :

      Cela créera également un dossier de sauvegarde appelé .anaconda_backup dans votre répertoire d’origine :


      Backup directory: /home/sammy/.anaconda_backup/2020-05-06T024432

      Vous pouvez maintenant supprimer tout votre répertoire Anaconda en entrant la commande suivante :

      Pour finir, vous pouvez supprimer la ligne PATH de votre fichier .bashrc qu’Anaconda a ajouté. Pour ce faire, ouvrez d’abord un éditeur de texte comme nano :

      Ensuite, faites défiler vers le bas jusqu’à la fin du fichier (s’il s’agit d’une installation récente) ou tapez CTRL + W pour rechercher Anaconda. Supprimez ou commentez ce bloc Anaconda :


      # >>> conda initialize >>>
      # !! Contents within this block are managed by 'conda init' !!
      __conda_setup="$('/home/sammy/anaconda3/bin/conda' 'shell.bash' 'hook' 2> /dev/null)"
      if [ $? -eq 0 ]; then
          eval "$__conda_setup"
          if [ -f "/home/sammy/anaconda3/etc/profile.d/" ]; then
              . "/home/sammy/anaconda3/etc/profile.d/"
              export PATH="/home/sammy/anaconda3/bin:$PATH"
      unset __conda_setup
      # <<< conda initialize <<<

      Lorsque vous avez fini de modifier le fichier, tapez CTRL + X pour quitter et y pour enregistrer les modifications.

      Anaconda est maintenant retiré de votre serveur. Si vous n’avez pas désactivé l’environnement de programmation de base, vous pouvez quitter le serveur et y revenir pour le supprimer.


      Ce tutoriel vous a guidé à travers l’installation d’Anaconda, le travail avec l’utilitaire en ligne de commande conda, la mise en place d’environnements, la mise à jour d’Anaconda et la suppression d’Anaconda si vous n’en avez plus besoin.

      Vous pouvez utiliser Anaconda pour vous aider à gérer les charges de travail pour la science des données, le calcul scientifique, l’analyse et le traitement des données à grande échelle. De là, vous pouvez consulter nos tutoriels sur l’analyse des données et l’apprentissage automatique pour en savoir plus sur les différents outils disponibles et les projets que vous pouvez mener à bien.

      Nous avons également un livre électronique gratuit sur l’apprentissage automatique, Python Machine Learning Projects, que vous pouvez télécharger.

      Source link

      Comment utiliser le module des collections dans Python 3

      L’auteur a choisi le COVID-19 Relief Fund pour recevoir un don dans le cadre du programme Write for DOnations.


      Python 3 possède un certain nombre de structures de données intégrées, notamment des tuples, des dictionnaires et des listes. Les structures de données nous fournissent un moyen d’organiser et de stocker les données. Le module de collections nous aide à remplir et à manipuler les structures de données de manière efficace.

      Dans ce tutoriel, nous allons passer en revue trois classes des collections pour vous aider à travailler avec des tuples, des dictionnaires et des listes. Nous utiliserons namedtuples pour créer des tuples avec des champs nommés, defaultdict pour regrouper de manière concise les informations dans les dictionnaires, et deque pour ajouter efficacement des éléments de chaque côté d’un objet de type liste. 

      Pour ce tutoriel, nous travaillerons principalement avec un inventaire de poissons que nous devons modifier au fur et à mesure que des poissons sont ajoutés ou retirés d’un aquarium fictif.

      Conditions préalables

      Pour tirer le meilleur parti de ce tutoriel, il est recommandé de se familiariser avec le tuple, le dictionnaire et les types de données de liste que ce soit en ce qui concerne leur syntaxe que de la manière d’en extraire des données. Vous pouvez consulter ces tutoriels pour obtenir les informations de base nécessaires :

      Ajouter des champs nominatifs aux tuples

      Les tuples de Python sont une séquence d’éléments immuables, ou inchangeables, ordonnés. Les tuples sont fréquemment utilisés pour représenter des données en colonnes ; par exemple, les lignes d’un fichier CSV ou les lignes d’une base de données SQL. Un aquarium peut garder une trace de son inventaire de poissons sous la forme d’une série de tuples.

      Un tuple de poissons individuel :

      ("Sammy", "shark", "tank-a")

      Ce tuple est composé de trois éléments de chaîne caractères.

      Bien qu’utile à certains égards, ce tuple n’indique pas clairement ce que représente chacun de ses champs. En réalité, l’élément 0 est un nom, l’élément 1 est une espèce, et l’élément 2 est le réservoir de stockage. 

      Explication des champs de tuples de poissons :

      name species tank
      Sammy shark tank-a

      Ce tableau montre clairement que chacun des trois éléments du tuple a une signification claire.

      namedtuple du module collections vous permet d’ajouter des noms explicites à chaque élément d’un tuple pour rendre ces significations claires dans votre programme Python.

      Utilisons namedtuple pour générer une classe qui nomme clairement chaque élément du tuple de poisson :

      from collections import namedtuple
      Fish = namedtuple("Fish", ["name", "species", "tank"])

      from collections import namedtuple donne à votre programme Python l’accès à la fonction d’usine namedtuple. L’appel de la fonction namedtuple() renvoie une classe qui est liée au nom Fish. Le namedtuple() a deux arguments : le nom souhaité de notre nouvelle classe "Fish" et une liste d’éléments nommés ["name", "species", "tank"]. 

      Nous pouvons utiliser la classe Fish pour représenter le tuple de poissons de tout à l’heure :

      sammy = Fish("Sammy", "shark", "tank-a")

      Si nous exécutons ce code, nous obtiendrons le résultat suivant :


      Fish(name="Sammy", species="shark", tank='tank-a')

      sammy est instancié à l’aide de la classeFish. sammy est un tuple avec trois éléments clairement nommés. 

      Les champs de sammy sont accessibles par leur nom ou avec un index tuple traditionnel :


      Si nous lançons ces deux appels d’impression, nous obtiendrons le résultat suivant :


      shark shark

      L’accès à .species a la même valeur que l’accès au deuxième élément de sammy en utilisant [1]. 

      Utiliser namedtuple du module collections rend votre programme plus lisible tout en conservant les propriétés importantes d’un tuple (à savoir qu’ils sont immuables et ordonnés). 

      De plus, la fonction d’usine namedtuple ajoute plusieurs méthodes supplémentaires aux instances de Fish.

      Utilisez ._asdict() pour convertir une instance en dictionnaire :


      Si nous lançons print, vous verrez des résultats comme ceux qui suivent :


      {'name': 'Sammy', 'species': 'shark', 'tank': 'tank-a'}

      Appeler .asdict() sur sammy renvoie un dictionnaire mettant en correspondance les noms de chacun des trois champs avec leurs valeurs correspondantes. 

      Les versions de Python plus anciennes que 3.8 pourraient produire cette ligne de manière légèrement différente. Vous pourriez, par exemple, voir un OrderedDict au lieu du simple dictionnaire présenté ici. 

      Note : Dans Python, les méthodes avec des traits de soulignement en tête sont généralement considérées comme « privées ». Les méthodes supplémentaires fournies par namedtuple (comme _asdict(), ._make(), ._replace(), etc.), sont toutefois publiques.

      Rassembler des données dans un dictionnaire

      Il est souvent utile de collecter des données dans les dictionnaires Python. defaulttdict du module de collections peut nous aider à rassembler les informations dans les dictionnaires de manière rapide et concise. 

      defaultdict ne soulève jamais une KeyError. Si une clé n’est pas présente, defaulttdict se contente d’insérer et de renvoyer une valeur de remplacement à la place : 

      from collections import defaultdict
      my_defaultdict = defaultdict(list)

      Si nous exécutons ce code, nous obtiendrons le résultat suivant :



      defaultdict insère et renvoie une valeur de remplacement au lieu de lancer une KeyError. Dans ce cas, nous avons spécifié la valeur de remplacement sous forme de liste.

      Les dictionnaires ordinaires, en revanche, lancent une KeyError sur les clés manquantes :

      my_regular_dict = {}

      Si nous exécutons ce code, nous obtiendrons le résultat suivant :


      Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'missing'

      Le dictionnaire habituel my_regular_dict soulève une KeyError lorsque nous essayons d’accéder à une clé qui n’est pas présente. 

      defaulttdict se comporte différemment d’un dictionnaire ordinaire. Au lieu de soulever une KeyError sur une clé manquante, defaultdict appelle la valeur de remplacement sans argument pour créer un nouvel objet. Dans ce cas, list() pour créer une liste vide. 

      Pour continuer avec notre exemple d’aquarium fictif, disons que nous avons une liste de tuples de poissons représentant l’inventaire d’un aquarium :

      fish_inventory = [
          ("Sammy", "shark", "tank-a"),
          ("Jamie", "cuttlefish", "tank-b"),
          ("Mary", "squid", "tank-a"),

      Trois poissons existent dans l’aquarium – leur nom, leur espèce et leur bac de rétention sont notés dans ces trois tuples.

      Notre objectif est d’organiser notre inventaire par réservoir – nous voulons connaître la liste des poissons présents dans chaque réservoir. En d’autres termes, nous voulons un dictionnaire qui cartographie "tank-a". à ["Jamie", "Mary"] et "tank-b" à ["Jamie"].

      Nous pouvons utiliser defaulttdict pour regrouper les poissons par bassin :

      from collections import defaultdict
      fish_inventory = [
          ("Sammy", "shark", "tank-a"),
          ("Jamie", "cuttlefish", "tank-b"),
          ("Mary", "squid", "tank-a"),
      fish_names_by_tank = defaultdict(list)
      for name, species, tank in fish_inventory:

      En exécutant ce code, nous obtiendrons le résultat suivant :


      defaultdict(<class 'list'>, {'tank-a': ['Sammy', 'Mary'], 'tank-b': ['Jamie']})

      fish_names_by_tank est déclaré comme un paramètre par défaut qui consiste par défaut à insérer list() au lieu de lancer une KeyError.  Comme cela garantit que chaque clé dansfish_names_by_tank pointera sur une liste, nous pouvons librement appeler .append() pour ajouter des noms à la liste de chaque réservoir.

      defaultdict vous aide ici car il réduit le risque d’erreurs inattendues de KeyErrors. Réduire lesKeyErrors inattendues signifie que votre programme peut être écrit plus clairement et avec moins de lignes. Plus concrètement, l’idiome defaultdict permet d’éviter d’instancier manuellement une liste vide pour chaque réservoir.

      Sans défaultdict, le corps de la boucle for aurait pu ressembler davantage à ceci :

      More Verbose Example Without defaultdict

      fish_names_by_tank = {}
      for name, species, tank in fish_inventory:
          if tank not in fish_names_by_tank:
            fish_names_by_tank[tank] = []

      L’utilisation d’un simple dictionnaire (au lieu d’un defaultdict) signifie que le corps de la boucle for doit toujours vérifier l’existence du tank donné dans fish_names_by_tank. Ce n’est qu’après avoir vérifié que tank est déjà présent dans fish_names_by_tank, ou vient d’être initialisé avec un [], qu’on peut ajouter le nom du poisson.

      defaultdict peut aider à réduire le nombre de codes passe-partout lors du remplissage des dictionnaires car il ne provoque jamais de KeyError.

      Utilisation de deque pour ajouter efficacement des éléments de chaque côté d’une collection

      Les listes Python sont une séquence d’éléments ordonnée, mutable ou modifiable. Python peut ajouter des listes en temps constant (la longueur de la liste n’a aucun effet sur le temps qu’il faut pour l’ajout), mais l’insertion au début d’une liste peut être plus lente (le temps nécessaire augmente à mesure que la liste s’agrandit).

      En termes de notation Big O, l’ajout à une liste est une opération O(1) à temps constant. L’insertion au début d’une liste, en revanche, est plus lente avec O(n) performance. 

      Note : Les informaticiens mesurent souvent la performance des procédures en utilisant ce qu’on appelle la notation « Big O ». Lorsque la taille d’une entrée n’a aucun effet sur le temps nécessaire pour exécuter une procédure, on dit qu’elle se déroule en temps constant ou O(1) (“Big O of 1”). Comme vous l’avez appris plus haut, Python peut s’ajouter aux listes à performance temporelle constante, autrement dit O(1). 

      Parfois, la taille d’une entrée a une incidence directe sur le temps nécessaire à l’exécution d’une procédure. L’insertion au début d’une liste Python, par exemple, est d’autant plus lente qu’il y a plus d’éléments dans la liste. La notation Big O utilise la lettre n pour représenter la taille de l’entrée. Cela signifie que l’ajout d’éléments au début d’une liste Python se fait en « temps linéaire » ou O(n) (“Big O of n”). 

      En général, les procédures O(1) sont plus rapides que les procédures O(n).

      On peut l’insérer au début d’une liste Python :

      favorite_fish_list = ["Sammy", "Jamie", "Mary"]
      # O(n) performance
      favorite_fish_list.insert(0, "Alice")

      Si nous exécutons ce qui suit, nous obtiendrons le résultat suivant :


      ['Alice', 'Sammy', 'Jamie', 'Mary']

      La méthode .insert (index, objet) sur list nous permet d’insérer "Alice" au début de favorite_fish_list. Toutefois, il est à noter que l’insertion au début d’une liste a O(n) performance. Comme la durée de favorite_fish_list augmente, le temps nécessaire pour insérer un poisson au début de la liste augmentera proportionnellement et prendra de plus en plus de temps.

      deque (prononcé « deck ») du module collections est un objet de type liste qui nous permet d’insérer des éléments au début ou à la fin d’une séquence avec une performance à temps constant (O(1)).

      Insérez un élément au début d’un deque: 

      from collections import deque
      favorite_fish_deque = deque(["Sammy", "Jamie", "Mary"])
      # O(1) performance

      En exécutant ce code, nous obtiendrons le résultat suivant :


      deque(['Alice', 'Sammy', 'Jamie', 'Mary'])

      Nous pouvons instancier un deque en utilisant un ensemble d’éléments préexistants, en l’occurrence une liste de trois noms de poissons favoris. L’appel de la méthode appendleft de favorite_fish_deque nous permet d’insérer un élément au début de notre collection avec la performance O (1). O(1) performance signifie que le temps nécessaire pour ajouter un élément au début de favorite_fish_deque n’augmentera pas, même si favorite_fish_deque a des milliers ou des millions d’éléments. 

      Note : Bien que deque ajoute des entrées au début d’une séquence plus efficacement qu’une liste, deque n’effectue pas toutes ses opérations plus efficacement qu’une liste. Par exemple, l’accès à un article aléatoire dans un deque a une performance O(n), mais l’accès à un élément aléatoire d’une liste a une performance O(1). Utilisez deque lorsqu’il est important d’insérer ou de retirer rapidement des éléments de chaque côté de votre collection. Une comparaison complète des performances temporelles est disponible sur le wiki de Python.


      Le module des collections est une partie puissante de la bibliothèque standard Python qui vous permet de travailler avec des données de manière concise et efficace.  Ce tutoriel couvrait trois des cours fournis par le module des collections comprenant namedtuple, defaultdict, et deque. 

      D’ici, vous pouvez utiliser la documentation du module de collecte pour en savoir plus sur les autres classes et utilités disponibles. Pour en savoir plus sur Python en général, vous pouvez lire notre Série de tutoriels Comment coder en Python 3. 

      Source link