Explication détaillée d'exemples de connecteurs ( , =) en Python

Avant-propos

Cet article présente les connecteurs ( , =) en Python en détail à travers les problèmes trouvés dans un exemple de code. Pas grand chose à dire ci-dessous, jetons un œil à l'introduction détaillée.

Supposons qu'il y ait le morceau de code suivant :

a = [1, 2, 3, 4]
b = [5, 6, 7, 8, 9]
c = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
 
for item in (a, b, c):
 item += [0] * (10 - len(item))
 
print a
print b
print c

La signification de ce code est qu'il y a trois listes et que des 0 doivent être remplis à la fin. fin des listes dont la longueur n'est pas 10, Que sa longueur soit 10.

Le résultat est le suivant :

[1, 2, 3, 4, 0, 0, 0, 0, 0, 0]
[5, 6, 7, 8, 9, 0, 0, 0, 0, 0]
[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

Il n'y a pas de problème ici, tout est normal. Cependant, les exigences ont maintenant changé et nous devons remplir le début de la liste avec une longueur autre que 10 avec des zéros.

Ensuite, nous essayons d'apporter les modifications suivantes :

a = [1, 2, 3, 4]
b = [5, 6, 7, 8, 9]
c = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
 
for item in (a, b, c):
 item = [0] * (10 - len(item)) + item
 
print a
print b
print c

Regardez directement la sortie :

[1, 2, 3, 4]
[5, 6, 7, 8, 9]
[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

Le résultat n'est pas celui que nous avions imaginé. Si vous ne voyez pas le problème, continuez à lire. Bien sûr, si vous avez déjà vu les indices, inutile de perdre du temps ici.

Selon notre réflexion inhérente, la méthode ci-dessus est réalisable, comme l'exemple suivant :

>>> l = [1, 2, 3, 4, 5]
>>> l = [0]*5 + l
>>> l
[0, 0, 0, 0, 0, 1, 2, 3, 4, 5]

Une telle opération permet à la liste d'obtenir ce que nous attendons . Changement.

Mais et si nous ajoutions quelques étapes supplémentaires :

>>> l = [1, 2, 3, 4, 5]
>>> id(l)
139935500860952
>>> l = [0]*5 + l
>>> l
[0, 0, 0, 0, 0, 1, 2, 3, 4, 5]
>>> id(l)
139935500783272

À ce stade, avez-vous vu le problème ? Comme vous pouvez le voir sur le résultat de la méthode id(), le "l" à l'arrière n'est plus le "l" à l'avant.

Regardez à nouveau l'exemple suivant :

>>> l = [1, 2, 3, 4, 5]
>>> id(l)
139935500861024
>>> l += [0]*5
>>> l
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
>>> id(l)
139935500861024

Lorsque vous utilisez =, il y en a un avant et après "l". À ce stade, nous devons comprendre que l’exemple du début de l’article n’est pas inexplicable, mais a une raison.

Ne vous inquiétez pas, reprenons l'exemple :

>>> t = (1, 2, 3, 4, 5)
>>> id(t)
139935501840656
>>> t += (0,)*5
>>> t
(1, 2, 3, 4, 5, 0, 0, 0, 0, 0)
>>> id(t)
139935502151336

Comme vous pouvez le constater, lorsqu'on remplace la liste par un tuple, le le résultat change à nouveau.

Et si nous utilisons l'opération sur les tuples :

>>> t = (1, 2, 3, 4, 5)
>>> id(t)
139935501081200
>>> t = (0,)*5 + t
>>> t
(0, 0, 0, 0, 0, 1, 2, 3, 4, 5)
>>> id(t)
139935502151336

C'est le même que le résultat de la liste, pas différent.

Alors, regardons la chaîne :

>>> s = "hello"
>>> id(s)
139935500909712
>>> s += "world"
>>> s
'helloworld'
>>> id(s)
139935500909664

Le résultat est comme un tuple, "s" est épissé en un caractère utilisant = Une fois la chaîne réaffectée, ce n'est plus la variable précédente. Reflété dans la mémoire, "s" a été ouvert un espace de stockage supplémentaire pour stocker la valeur.

Ici, le connecteur Python dont nous allons parler est et =. Il convient de noter que ces deux symboles ont des significations différentes en Python. L’un est l’opération d’addition utilisée en mathématiques et l’autre est la fonction d’épissage utilisée sur les types séquences. Cependant, lorsqu'il est utilisé comme opérateur d'addition, il suit également les règles d'utilisation décrites dans cet article. Parce que discuter de ces deux symboles revient essentiellement à discuter des types immuables et mutables de Python, c'est-à-dire des types variables et des types immuables. Pour les types mutables, nous pouvons modifier la variable en place, ce qui signifie que son espace de stockage est lisible et inscriptible, comme une liste ; pour les types immuables, son espace de stockage est en lecture seule, il ne peut pas être modifié si vous en avez besoin. effectuez certaines opérations sur le type immuable pour obtenir un nouveau résultat, vous devez créer un nouvel espace de stockage pour stocker le résultat nouvellement généré.

Des exemples listés ci-dessus, nous pouvons tirer les conclusions suivantes :

Pour les types de variables :

: représente une opération de connexion dont le résultat va créer un nouvel objet.

= : Représente l'opération d'ajout, c'est-à-dire l'opération sur place, qui ajoute le contenu d'un autre objet à l'objet en place.

Pour les types immuables : et = représentent tous deux des opérations de connexion ou de sommation. Il n'y a pas de différence entre les deux. Le résultat de l'opération produira un nouvel objet.

Analysons l'exemple au début de l'article Puisque pour itération équivaut à affectation, par souci de simplicité, nous analysons uniquement a, comme suit :

>>> a = [1, 2, 3, 4]
>>> t = a
>>> id(a)
139712695835400
>>> id(t)
139712695835400
>>> t += [0]*6
>>> t
[1, 2, 3, 4, 0, 0, 0, 0, 0, 0]
>>> id(t)
139712695835400
>>> id(a)
139712695835400
>>> a
[1, 2, 3, 4, 0, 0, 0, 0, 0, 0]
>>>
>>>
>>> a = [1, 2, 3, 4]
>>> t = a
>>> id(a)
139712695835464
>>> id(t)
139712695835464
>>> t = [0]*6 + t
>>> t
[0, 0, 0, 0, 0, 0, 1, 2, 3, 4]
>>> a
[1, 2, 3, 4]
>>> id(a)
139712695835464
>>> id(t)
139712695835400

Ici, t est une référence à a, qui équivaut à l'élément de l'exemple au début de l'article. Utiliser = pour opérer sur t opère en fait sur a, et = est une opération sur place, donc lorsque t est modifié, a change également si vous utilisez = pour opérer sur t et attribuez le résultat à t, alors à ce moment-là ; t ne pointe plus vers a, mais pointe vers [0]*6 t, donc a n'a pas été modifié.

Résumé

Ce qui précède représente l'intégralité du contenu de cet article. Ce qui est discuté ici n'est qu'un problème simple, mais j'ai passé tellement de temps à parler de ce problème, donc je veux le faire. Le problème est que si vous ne comprenez pas complètement ces petits problèmes, ils peuvent vous causer des problèmes pendant le processus de programmation.

Pour des exemples plus détaillés de connecteurs ( , =) en Python et des articles connexes, veuillez faire attention au site Web PHP chinois !