J'ai une liste, ls = [0 1 2 3 4] et je suis en cours d'exécution suivantes:En python, pourquoi une liste n'est-elle pas la même chose que la liste [:]?
print(ls is ls[:])
Je reçois la sortie comme False. Pourquoi ne sont-ils pas la même liste? Lorsque j'imprime les deux versions, la même liste est imprimée.
[:] crée une copie superficielle de ls, qui détruit la référence d'origine de la nouvelle liste à ls. Gardez à l'esprit, toutefois, que les listes imbriquées ne sont pas affectées par [:] et que, par conséquent, copy.deepcopy est requis.
Exemple:
s = [5, 6, 2, 4]
=>s
[5, 6, 2, 4]
new_s = s
new_s.append(100)
=>new_s
[5, 6, 2, 4, 100]
=>s
[5, 6, 2, 4, 100]
Utilisation de deepcopy:
s = [5, 6, [5, 6, 2, 4], 4]
new_s = s[:]
new_s[2].append(45)
=>s
[5, 6, [5, 6, 2, 4, 45], 4] #both sublists are still being referenced
=>new_s
[5, 6, [5, 6, 2, 4, 45], 4]
import copy
s1 = [5, 6, [5, 6, 2, 4], 4]
new_s1 = copy.deepcopy(s1)
new_s1[2].append(100)
=>new_s1
[5, 6, [5, 6, 2, 4, 100], 4]
=>s1
[5, 6, [5, 6, 2, 4], 4]
Je ne pense pas que l'exemple soit le plus clair, en utilisant une méthode de type mutable. – Adirio
ls références un objet en mémoire; ls[:] crée un nouveaulist objet utilisant les mêmes références contenues dans le premier.
>>> ls = [0, 1, 2, 3, 4]
>>> new_ls = ls[:]
>>> id(ls) == id(new_ls)
False
>>> id(ls[0]) == id(new_ls[0])
True
Faites attention à cela, 'id (ls [0]) == id (0)'. Les nombres faibles sont des singletons dans certaines implémentations Python pour améliorer la vitesse et l'utilisation de la mémoire. – Adirio
Je ne pense pas que cela distrait trop du point de vue, mais vous pouvez certainement remplacer 'ls = [object(), object(), object(), object(), object()]' sans changer le résultat . Ce serait un problème plus important si vous attendiez que [0, 0, 0, 0, 0] 'soit une liste de 5 références distinctes. – chepner
Juste, juste le signaler. – Adirio
Ceci est essentiellement un double de
String comparison in Python: is vs. ==
Vous savez, il na pas.
== et is vérifiez deux choses différentes.
== demandes sont ces deux chose la même valeur.
is demandes sont ces deux choses la même chose c'est-à-dire le même objet.
a[:] copie la liste en créant une nouvelle liste avec la même valeur.
ainsi
a == a[:]
>> True
a is a[:]
>> False
[:] indique le découpage d'une liste (tranche du début jusqu'à la fin) qui crée une copie superficielle de votre objet itérable. Pour démontrer plus: Lorsque vous créez une liste a = [1] et faire b = a, ici vous simplement Réaffectation nom d'un à b où a et b deux points o même adresse mémoire
>>> a = [1,2]
>>> b = a
>>> id(a)
140177107790232
>>> id(b)
140177107790232
>>> b.remove(1)
>>> a
[2]
Mais si vous le faites avec découpage en tranches :
>>> a = [1,2]
>>> b = a[:]
>>> id(a)
140177107873232
>>> id(b)
140177107873304
>>> b.remove(1)
>>> a
[1, 2]
>>>
'ls [:]' fait une copie complète de 'ls', donc ce n'est pas le même objet. Ils sont égaux, cependant: 'ls == ls [:]' – alexis
Le découpage crée une copie –
Pourquoi une copie de liste aurait-elle le même identifiant? Ensuite, ils se référeront toujours à la même liste ... –