Ajouter des éléments à vos listes sur place – Real Python

.ajouter() Ajoute un seul élément

Avec .ajouter(), vous pouvez ajouter un nombre, une liste, un tuple, un dictionnaire, un objet défini par l'utilisateur ou tout autre objet à une liste existante. Cependant, vous devez garder à l'esprit que .ajouter() n'ajoute qu'un seul élément ou objet à la fois:

>>> X = [[[[1, 2, 3, 4]
>>> y = (5, 6)

>>> X.ajouter(y)
>>> X
[1, 2, 3, 4, (5, 6)]

Ce qui se passe ici, c'est que .ajouter() ajoute l'objet tuple y à la fin de votre liste de cibles, X. Et si vous souhaitez ajouter chaque élément dans y à la fin de X en tant qu'article individuel et obtenez [1, 2, 3, 4, 5, 6]? Dans ce cas, vous pouvez utiliser .étendre():

>>> X = [[[[1, 2, 3, 4]
>>> y = (5, 6, sept)
>>> X.étendre(y)
>>> X
[1, 2, 3, 4, 5, 6, 7]

>>> X = [[[[1, 2, 3, 4]
>>> y = (5, 6, sept)
>>> # Equivalent à x.extend (y)
>>> X[[[[len(X):] = y
>>> X
[1, 2, 3, 4, 5, 6, 7]

.étendre() prend un itérable comme argument, décompresse ses éléments et les ajoute à la fin de votre liste cible. Cette opération équivaut à X[len(x):] = y, qui est la même technique que vous avez vue dans la section précédente.

.ajouter() Retour Aucun

En pratique, .ajouter() fait son travail sur place en modifiant et en augmentant la liste sous-jacente. Cela signifie que .ajouter() ne renvoie pas une nouvelle liste avec un nouvel élément supplémentaire à la fin. Il retourne Aucun:

>>> X = [[[[1, 2, 3, 4]
>>> y = X.ajouter(5)
>>> y est Aucun
Vrai
>>> X
[1, 2, 3, 4, 5]

Comme avec plusieurs méthodes similaires, .ajouter() modifie la liste sous-jacente en place. Essayer d'utiliser la valeur de retour de .ajouter() est une erreur courante lorsqu'il s'agit d'apprendre comment fonctionnent les types de séquences mutables. Garder ce comportement de .ajouter() à l'esprit vous aidera à éviter les erreurs dans votre code.

En utilisant .ajouter()

Un cas d'utilisation courant de .ajouter() consiste à remplir complètement une liste vide en utilisant un pour boucle. À l'intérieur de la boucle, vous pouvez manipuler les données et utiliser .ajouter() pour ajouter des résultats successifs à la liste. Supposons que vous deviez créer une fonction qui prend une séquence de nombres et renvoie une liste contenant la racine carrée de chaque nombre:

>>> importer math

>>> def racine carrée(Nombres):
...     résultat = []
...     pour nombre dans Nombres:
...         résultat.ajouter(math.sqrt(nombre))
...     revenir résultat
...

>>> Nombres = [[[[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> racine carrée(Nombres)
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

Ici, vous définissez racine carrée(), qui prend une liste de Nombres comme argument. À l'intérieur racine carrée(), vous créez une liste vide appelée résultat et commencer un pour boucle qui itère sur les éléments de Nombres. Dans chaque itération, vous utilisez math.sqrt () pour calculer la racine carrée du nombre actuel, puis utilisez .ajouter() pour ajouter le résultat à résultat. Une fois la boucle terminée, vous renvoyez la liste résultante.

Cette façon de remplir les listes est assez courante en Python. Cependant, le langage fournit des constructions pratiques qui peuvent rendre le processus beaucoup plus efficace et pythonique. Une de ces constructions est une compréhension de liste, que vous verrez en action dans la section suivante.

Utilisation d'une compréhension de liste

En pratique, vous remplacez souvent .ajouter() avec un compréhension de liste lors de la création d'une liste à partir de zéro et de son remplissage. Avec une compréhension de liste, vous pouvez réimplémenter racine carrée() comme ça:

>>> importer math

>>> def racine carrée(Nombres):
...     revenir [[[[math.sqrt(nombre) pour nombre dans Nombres]
...

>>> Nombres = [[[[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> racine carrée(Nombres)
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

La compréhension de la liste à l'intérieur racine carrée() crée une liste contenant la racine carrée de nombre pour chaque nombre dans Nombres. Cela se lit presque comme un anglais ordinaire. Aussi, cette nouvelle implémentation sera plus efficace en termes de temps de traitement que l'implémentation qui utilise .ajouter() avec un pour boucle.

Tourner .ajouter() dans une liste de compréhension, il vous suffit de mettre son argument suivi de l'en-tête de la boucle (sans les deux points) à l'intérieur d'une paire de crochets.

Revenir à .ajouter()

Même si la compréhension de liste peut être plus lisible et efficace que .ajouter() pour le remplissage de listes, il peut y avoir des situations où .ajouter() est un meilleur choix.

Supposons que vous ayez besoin racine carrée() pour fournir à vos utilisateurs des informations détaillées sur la progression du calcul de la racine carrée de la liste de nombres d'entrée. Pour signaler la progression de l'opération, vous pouvez utiliser impression():

>>> importer math

>>> def racine carrée(Nombres):
...     résultat = []
...     n = len(Nombres)
...     pour je, nombre dans énumérer(Nombres):
...         impression(F"Numéro de traitement: nombre")
...         résultat.ajouter(math.sqrt(nombre))
...         impression(F"Terminé: int((je + 1) / n * 100)% ")
...     revenir résultat
...

>>> Nombres = [[[[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> racine carrée(Nombres)
Numéro de traitement: 1
Terminé: 11%
...
Numéro de traitement: 81
Terminé: 100%
[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]

Pensez maintenant à la façon dont vous pouvez transformer le corps de racine carrée() dans une compréhension de liste. En utilisant impression() à l'intérieur d'une liste, la compréhension ne semble pas cohérente ni même possible à moins que vous n'enveloppiez une partie du code dans une fonction d'assistance. Donc, dans cet exemple, en utilisant .ajouter() est le bon choix.

La morale derrière l'exemple ci-dessus est qu'il y a des situations dans lesquelles vous ne pouvez pas remplacer .ajouter() avec une compréhension de liste ou avec toute autre construction.

Implémentation d'une pile

UNE empiler est une structure de données qui stocke les éléments les uns sur les autres. Les articles entrent et sortent de la pile dans un Dernier entré, premier sorti (LIFO) mode. En règle générale, une pile implémente deux opérations principales:

1. pousser ajoute un élément en haut ou à la fin de la pile.
2. pop supprime et renvoie l'élément en haut de la pile.

Dans une liste, .ajouter() équivaut à un pousser opération, vous pouvez donc l'utiliser pour pousser des articles sur la pile. Les listes fournissent également .pop(), qui prend éventuellement un index entier comme argument. Il renvoie l'élément à cet index dans la liste sous-jacente et supprime également l'élément:

>>> Nombres = [[[[1, 2, 3]
>>> Nombres.pop(1)
2
>>> Nombres
[1, 3]

>>> Nombres.pop()
3
>>> Nombres
[1]

>>> Nombres.pop()
1
>>> Nombres
[]

>>> Nombres.pop()
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
    Nombres.pop()
IndexError: pop de la liste vide

Si vous fournissez un index entier comme argument pour .pop(), la méthode retourne et supprime l'élément à cet index dans la liste. Appel .pop() sans argument renvoie le dernier élément de la liste. Notez que .pop() supprime également l'élément de la liste sous-jacente. Enfin, si vous appelez .pop() sur une liste vide, alors vous obtiendrez un IndexError.

Avec ces connaissances, vous êtes prêt à mettre en œuvre une pile en utilisant .ajouter() et .pop(). Voici une classe qui définit une pile. La classe fournit .pousser() et .pop() opérations:

classe Empiler:
    def __init__(soi):
        soi._articles = []

    def pousser(soi, article):
        soi._articles.ajouter(article)

    def pop(soi):
        essayer:
            revenir soi._articles.pop()
        sauf IndexError:
            impression("Pile vide")

    def __len__(soi):
        revenir len(soi._articles)

    def __repr__(soi):
        revenir F"Empiler(soi._articles) "

Dans Empiler, vous initialisez d'abord l'attribut d'instance ._articles. Cet attribut contient une liste vide que vous utiliserez pour stocker les éléments dans la pile. Ensuite, vous codez .pousser(), qui implémente le pousser opération utilisant .ajouter() sur ._articles.

Vous implémentez également le pop opération en appelant .pop() sur la liste sous-jacente, ._articles. Dans ce cas, vous utilisez un essayer et sauf bloc pour gérer le IndexError qui se produit lorsque vous appelez .pop() sur une liste vide.

La méthode spéciale .__ len __ () fournit la fonctionnalité requise pour récupérer la longueur de la liste interne ._articles. La méthode spéciale .__ repr __ () vous permet de fournir une représentation sous forme de chaîne de la pile lors de l'impression de la structure de données à l'écran.

Voici quelques exemples d'utilisation Empiler en pratique:

>>> empiler = Empiler()

>>> # Poussez les objets sur le dessus de la pile
>>> empiler.pousser(1)
>>> empiler.pousser(2)

>>> # Format d'impression convivial
>>> empiler
Empiler([1, 2])
>>> impression(empiler)
Empiler([1, 2])

>>> # Récupérer la longueur de la pile
>>> len(empiler)
2

>>> # Objets pop du haut de la pile
>>> empiler.pop()
2
>>> empiler.pop()
1
>>> empiler.pop()
Pile vide
>>> empiler
Empiler([])

C'est ça! Vous avez codé une structure de données de pile qui implémente le pousser et pop opérations. Il fournit également des fonctionnalités pour obtenir la longueur de la liste sous-jacente et pour imprimer la pile entière de manière conviviale.

Implémentation d'une file d'attente

Les files d'attente sont des structures de données qui gèrent généralement leurs éléments dans un Premier entré, premier sorti (FIFO) mode. Les files d'attente fonctionnent comme un tuyau dans lequel vous insérez de nouveaux éléments à une extrémité et les anciens éléments sortent de l'autre extrémité.

L'ajout d'un élément à la fin d'une file d'attente est appelé mettre en file d'attente opération, et la suppression d'un élément de l'avant ou du début d'une file d'attente est appelée retirer la file d'attente opération.

Vous pouvez mettre des éléments en file d'attente à l'aide de .ajouter() et retirez-les en utilisant .pop(). Cette fois, vous devez fournir 0 comme argument pour .pop() juste pour lui faire récupérer le premier élément de la liste au lieu du dernier élément. Voici une classe qui implémente une structure de données de file d'attente à l'aide d'une liste pour stocker ses éléments:

classe Queue:
    def __init__(soi):
        soi._articles = []

    def mettre en file d'attente(soi, article):
        soi._articles.ajouter(article)

    def retirer la file d'attente(soi):
        essayer:
            revenir soi._articles.pop(0)
        sauf IndexError:
            impression("File d'attente vide")

    def __len__(soi):
        revenir len(soi._articles)

    def __repr__(soi):
        revenir F"Queue(soi._articles) "

Cette classe est assez similaire à votre Empiler. La principale différence est que .pop() prend 0 comme argument pour retourner et supprime le première élément de la liste sous-jacente, ._articles, plutôt que le dernier.

Le reste de l'implémentation est presque identique mais utilise des noms appropriés, tels que .enqueue () pour ajouter des éléments et .dequeue () pour les supprimer. Vous pouvez utiliser Queue de la même manière que vous avez utilisé Empiler dans la section ci-dessus: il suffit d'appeler .enqueue () pour ajouter des éléments et .dequeue () pour les récupérer et les supprimer.

array.append ()

Python array.array () fournit une structure de données de type séquence qui peut représenter de manière compacte un tableau de valeurs. Ces valeurs doivent être identiques Type de données, qui est limité aux types de données de style C, tels que les caractères, les nombres entiers et les nombres à virgule flottante.

array.array () prend les deux arguments suivants:

La documentation de tableau fournit des informations complètes sur tous les codes de type autorisés que vous pouvez utiliser lors de la création de tableaux. L'exemple suivant utilise le "je" tapez du code pour créer un tableau de nombres entiers:

>>> de tableau importer tableau

>>> # Tableau de nombres entiers
>>> int_array = tableau("je", [[[[1, 2, 3])
>>> int_array
tableau ('i', [1, 2, 3])
>>> int_array[[[[0]
1
>>> int_array[:[:[:[:2]
tableau ('i', [1, 2])
>>> int_array[[[[2] = 4
>>> int_array
tableau ('i', [1, 2, 4])

Pour créer un tableau, vous devez fournir un code à un seul caractère pour définir le type de données des valeurs du tableau. Vous pouvez également fournir une liste facultative de valeurs avec le type approprié pour initialiser le tableau.

Les tableaux prennent en charge la plupart des opérations de liste, telles que trancher et indexage. Comme des listes, array.array () fournit également une méthode appelée .ajouter(). Cette méthode fonctionne de la même manière que son homologue de liste, en ajoutant une valeur unique à la fin du tableau sous-jacent. Cependant, la valeur doit avoir un type de données compatible avec les valeurs existantes dans le tableau. Sinon, vous obtiendrez un Erreur-type.

Par exemple, si vous avez un tableau avec des nombres entiers, vous ne pouvez pas utiliser .ajouter() pour ajouter un nombre à virgule flottante à ce tableau:

>>> de tableau importer tableau

>>> une = tableau("je", [[[[1, 2, 3])
>>> une
tableau ('i', [1, 2, 3])

>>> # Ajouter un nombre à virgule flottante
>>> une.ajouter(1,5)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
    une.ajouter(1,5)
Erreur-type: Argument entier attendu, obtenu float

Si vous essayez d'ajouter un nombre à virgule flottante à une, puis .ajouter() échoue avec un Erreur-type. C'est parce que Python ne peut pas convertir automatiquement un nombre à virgule flottante en un nombre entier sans perdre d'informations.

En revanche, si vous avez un tableau avec des nombres à virgule flottante et que vous essayez d'y ajouter des nombres entiers, votre opération réussira:

>>> de tableau importer tableau

>>> float_array = tableau("F", [[[[1.0, 2.0, 3.0])
>>> float_array
tableau ('f', [1.0, 2.0, 3.0])

>>> # Addition et nombre entier
>>> float_array.ajouter(4)
>>> float_array
tableau ('f', [1.0, 2.0, 3.0, 4.0])

Ici, vous utilisez .ajouter() pour ajouter un nombre entier à un tableau de nombres à virgule flottante. C’est possible, car Python peut convertir automatiquement des nombres entiers en nombres à virgule flottante sans perdre d’informations au cours du processus.

deque.append () et deque.appendleft ()

collections.deque () est une autre structure de données qui implémente une variation de .ajouter(). UNE deque est une généralisation d'une pile et d'une file d'attente spécialement conçues pour prendre en charge rapide et efficace en mémoire ajouter et pop opérations des deux côtés. Donc, si vous avez besoin de créer une structure de données avec ces fonctionnalités, envisagez d'utiliser un deque au lieu d'une liste.

collections.deque () prend les deux arguments facultatifs suivants:

Si vous fournissez une valeur à Maxlen, alors votre deque ne stockera que jusqu'à Maxlen articles. Une fois que la deque est pleine, l'ajout d'un nouvel élément entraînera automatiquement la suppression de l'élément à l'extrémité opposée de la deque. En revanche, si vous ne fournissez pas de valeur à Maxlen, alors le deque peut atteindre un nombre arbitraire d'éléments.

À deques, .ajouter() ajoute également un élément unique à la fin, ou à droite, de la structure de données sous-jacente:

>>> de collections importer deque

>>> ré = deque([[[[1, "une", 3.0])
>>> ré
deque ([1, 'a', 3.0])

>>> ré.ajouter("b")
>>> ré
deque ([1, 'a', 3.0, 'b'])

Comme les listes, les deques peuvent contenir différents types d'éléments, de sorte que .ajouter() ajoute des éléments arbitraires à la fin de la deque. En d'autres termes, avec .ajouter(), vous pouvez ajouter n'importe quel objet à un deque.

outre .ajouter(), deques fournissent également .appendleft (), qui ajoute un seul élément au début, ou à gauche, d'un deque. De même, les deques fournissent .pop() et .popleft () pour supprimer des éléments du côté droit et gauche du deque, respectivement:

>>> de collections importer deque

>>> ré = deque([[[[1, "une", 3.0])
>>> ré.appendleft(-1.0)
>>> ré
deque ([-1.0, 1, 'a', 3.0])

>>> ré.pop()
3.0

>>> ré.popleft()
-1,0

>>> ré
deque ([1, 'a'])

L'appel à .appendleft () ajoute -1,0 sur le côté gauche de ré. D'autre part, .pop() renvoie et supprime le dernier élément de ré, et .popleft () renvoie et supprime le premier élément. À titre d'exercice, vous pouvez essayer d'implémenter votre propre pile ou file d'attente en utilisant un deque au lieu d'une liste. Pour ce faire, vous pouvez tirer parti des exemples que vous avez vus dans la section Créer des piles et des files d’attente avec .append () de Python.