del

ast <ast@invalid> writes:

bonjour

Bonjour !

>>> lst = [0, 1, 2]
>>> del lst[:]
>>> lst
[]
normalement lst[:] est une copie de lst, donc
détruire lst[:] ne devrait pas modifier lst,
or si, lst a été vidée. Pourquoi ?

La délétion d'un slicing est généralement équivalente Í 
l'attribution d'un slicing vide du bon type. Et lst[:]
est un slicing (il contient le deux-points).

|>>> list=[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
|>>> del list[ 3 : 6 ]
|>>> list
|[0, 1, 2, 6, 7, 8, 9]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

>>> lst = [0, 1, 2]
>>> lst2 = lst[:]
>>> del lst2
>>> lst
[0, 1, 2]
lÍ  c'est OK. Tout ce que j'ai fait est de donner
un nom Í  lst[:]

lst2 n'est pas un slicing (il ne contient pas de
deux-points).

ast <ast@invalid> writes:

lst = [0, 1, 2]
del lst[:]
lst

[]

normalement lst[:] est une copie de lst, donc
détruire lst[:] ne devrait pas modifier lst,
or si, lst a été vidée. Pourquoi ?

Non, ce n'est pas une copie. La doc de "del" dit :

| Deletion of a name removes the binding of that name [...]
|
| Deletion of attribute references, subscriptions and slicings is passed
| to the primary object involved |...]

(https://docs.python.org/3/reference/simple_stmts.html#grammar-token-python-grammar-del_stmt)

Donc l'instruction "del" est juste une syntaxe spéciale. Dans ton cas :

del lst[:]

revient Í  appeler quelque chose comme :

lst.__delitem__ (slice (None, None, None))

En bref : del est une instruction, elle ne fait pas une évaluation comme
le ferait un appel de fonction ; ce qui suit "del" n'est pas une
expression (tu ne peux pas écrire "del x+y"), mais une "target", c'est
de la même nature que ce que tu peux mettre Í  gauche de "=" pour
l'affectation.

(https://docs.python.org/3/reference/simple_stmts.html#grammar-token-python-grammar-target)

(Pour ceux qui connaissant un peu de compilation, on appelle cela une
"lvalue" en général. J'imagine que quelqu'un a cru inventer quelque
chose et a choisi un autre nom pour une notion en fait archi-connue.)

lst = [0, 1, 2]
lst2 = lst[:]
del lst2
lst

[0, 1, 2]

lÍ  c'est OK. Tout ce que j'ai fait est de donner
un nom Í  lst[:]

En fait, tu crées (avec "lst[:]") un nouvel objet liste qui est une
copie de "lst", que tu lies au nom "lst2". Ensuite, tu supprimes le nom
"lst2" (et donc ici aussi la copie de liste que tu viens de créer).

La différence ici c'est que "lst[:]" est une expression, parce qu'elle
est Í  droite de "=". Puisque c'est une expression, sa valeur est
calculée. Donc il y a copie de la liste.

(Techniquement, ici "lst[:]" est une "rvalue" -- "r" signifie "right"
comme "l" signifiait "left" plus haut, des positions par rapport au
symbole d'affectation.)

-- Alain.

Le 12/09/2022 Í  20:15, ast a écrit :

bonjour

>>> lst = [0, 1, 2]
>>> del lst[:]
>>> lst
[]

normalement lst[:] est une copie de lst, donc
détruire lst[:] ne devrait pas modifier lst,
or si, lst a été vidée. Pourquoi ?


>>> lst = [0, 1, 2]
>>> lst2 = lst[:]
>>> del lst2
>>> lst
[0, 1, 2]

lÍ  c'est OK. Tout ce que j'ai fait est de donner
un nom Í  lst[:]

Quel est l'intérêt de faire del (lst[:]) et pas simplement del (lst) ou
lst2=lst [:] ?