Scribd
Importer
14 vues2 pages

Subtilités Python des variables mutables

Le document explore les subtilités de l'utilisation des variables mutables en Python, en se concentrant sur l'affichage et la concaténation de listes. Il illustre comment les fonctions modifient les listes et comment ces modifications affectent les résultats affichés lors de l'évaluation des expressions. Des exemples de code démontrent les effets des appels de fonction et de la concaténation sur les listes mutables.

Transféré par

llinku442
Copyright
© All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd
14 vues2 pages

Subtilités Python des variables mutables

Le document explore les subtilités de l'utilisation des variables mutables en Python, en se concentrant sur l'affichage et la concaténation de listes. Il illustre comment les fonctions modifient les listes et comment ces modifications affectent les résultats affichés lors de l'évaluation des expressions. Des exemples de code démontrent les effets des appels de fonction et de la concaténation sur les listes mutables.

Transféré par

llinku442
Copyright
© All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

# Subtilités Python pour variables mutables.

py

01| ## Question 1 sur l'affichage associé à un tuple de variables mutables


02| # Les fonctions sont d'abord évaluées de gauche à droite. Leur résultat est mis
dans le programme principal et pointe toujours sur la même liste. L'affichage est
ensuite effectuée de gauche à droite. Voir ci-dessous.
03| def f(l):
04| [Link](2)
05| return l
06|
07| def g(l):
08| [Link](5)
09| return l
10|
11| t = [0]
12| print(t, f(t)) # Python évalue f(t) et renvoie au programme principal un nom avec
une adresse qui pointe sur t; une fois le résultat obtenu, il affiche toutes les
variables : [0, 2] [0, 2]
13|
14| t = [0]
15| print(f(t), t) # Python évalue f(t) et renvoie au programme principal un nom avec
une adresse qui pointe sur t; une fois le résultat obtenu, il affiche toutes les
variables : [0, 2] [0, 2]
16|
17| t = [0]
18| print(t, f(t), g(t)) # Python évalue f(t) et renvoie au programme principal un
nom avec une adresse qui pointe sur t; ensuite il évalue g(t) (dans cet ordre de
gauche à droite) et renvoie au programme principal un nom avec une adresse qui pointe
sur t; une fois les résultats obtenus, il affiche toutes les variables : [0, 2, 5]
[0, 2, 5] [0, 2, 5]
19|
20| t = [0]
21| print(t, g(t), f(t), g(t)) # [0,5,2,5] [0,5,2,5] [0,5,2,5] [0,5,2,5]
22|
23|
24| ## Question 2 sur la concaténation associée à un tuple de variables mutables
25| # t + l + m = (t + l) + m. Si les variables sont le résultat de fonctions, elles
sont évaluées progressivement de gauche à droite. La concaténation se fait au fur et
à mesure. On rappelle que la concaténation crée une nouvelle liste issue de la copie
de 2 listes. Voir ci-dessous.
26|
27| def f(l):
28| [Link](2)
29| return l
30|
31| def g(l):
32| [Link](5)
33| return l
34|
35| t = [0]
36| print(t + f(t)) # Python évalue f(t) et renvoie au programme principal un nom
avec une adresse qui pointe sur t; puis concatène avec t (qui a donc changé, ce qui
donne [0, 2, 0, 2])
37|
38| t = [0]
39| print(f(t) + t) # Python évalue f(t) et renvoie au programme principal un nom
avec une adresse qui pointe sur t; puis concatène avec t (qui a donc changé, ce qui
donne [0, 2, 0, 2])
40|
41| t = [0]
42| print(f(t) + t + g(t)) # Python l'interprète comme-suit : print((f(t) + t) +
g(t)). Ainsi, f(t) est évalué, la concaténation est effectuée, g(t) est évalué et
concaténé avec ce qui précède, ce qui donne [0, 2, 0, 2, 0, 2, 5]
43|
44| t = [0]
45| print(t + f(t) + g(t)) # Python l'interprète comme-suit : print((t + f(t)) +
g(t)). Ainsi, f(t) est évalué, la concaténation est effectuée, g(t) est évalué et

1
concaténé avec ce qui procède, ce qui donne [0, 2, 0, 2, 0, 2, 5]
46|
47| t = [0]
48| print(f(t) + g(t) + t) # Python l'interprète comme-suit : print((f(t) + g(t)) +
t). Ainsi, Python évalue f(t) et renvoie au programme principal un nom avec une
adresse qui pointe sur t (maintenant [0,2]); Python évalue g(t) et renvoie au
programme principal un nom avec une adresse qui pointe sur t (maintenant [0,2,5]);
puis la concaténation est effectuée; enfin le résultat est concaténé avec t, ce qui
donne [0, 2, 5, 0, 2, 5, 0, 2, 5]
49|
50| t = [0]
51| print(f(t) + g(t) + t + g(t)) # Python l'interprète comme-suit : print(((f(t) +
g(t)) + t) + g(t)). On obtient: [0, 2, 5, 0, 2, 5, 0, 2, 5, 0, 2, 5, 5].

Vous aimerez peut-être aussi