Affichage
Fonction print()
- Affiche l'argument passé
- Insère un retour à la ligne (par défaut)
- Si on ne souhaite pas afficher le retour à la ligne: on peut utiliser l’argument par mot-clé "end"
print ("Bonjour Tout le monde !")
print ("Après 1")
print ("Bonjour Tout le monde !" , end = "-")
print("Après 2")
print ("Hello","world!")
print ("Hello", end =" ") ; print ("world!")
Afficher le contenu d’une variable quel que soit son type.
# Exemple ( pour un entier ) :
var = 3
print ( var )
Afficher le contenu de plusieurs variables (quel que soit leur type) en les séparant par des virgules :
x = 22
nom = "Ahmed"
print (nom , "a", x, "ans")
Afficher sur une seul ligne sans séparateurs:
x = 23
nom = "Ahmed"
print (nom , "a", x , "ans")
print (nom , "a", x , "ans" , sep=" ")
print (nom , "a", x , "ans" , sep="*")
Écriture formatée :
- Depuis Python 3.6 : f-string ,
- comment ?
- Précéder la chaine de caractère par la lettre f
- Utilisation des {} pour afficher le contenu des variables (dans l'ordre respectif )
prixHT = 200;
prixTTC = 1.2 * prixHT
print (f"Le prix HT est : {prixHT}, et le prix TTC est : {prixTTC}" )
Une variable peut être utilisée plusieurs fois pour une même f-string :
var = "to"
print (f"{ var } et { var } font { var }{ var }")
On peut mettre entre les accolades des valeurs numériques ou des chaînes de caractères :
print (f"Afficher l'entier {10} et le float {2.340876:.2f}")
print (f"Afficher l'entier 10 et le float 2.34")
print (f"Afficher la chaine "Classe "")
# print (f"Afficher la chaine {"Classe "}")
# print ("Afficher la chaine "Classe "") # sans formatage
print("\"Classe API\" !")
# print("""Afficher "Classe API" !""")
# print (f"Afficher la chaine {'Classe API'}") #guillemets simple à l'intérieur des accolades
ch = "Classe "
print (f"Afficher la chaine {ch}") #guillemets simple à l'intérieur des accolades
Écriture formatée : Spécification de format de l'affichage des variables :
méthode .format()
prixHT = 100;
# print(prixHT);
prixTTC = 1.2 * prixHT
ch = "Le prix HT est : {}, et le prix TTC est : {}"
print(ch.format(prixHT , prixTTC))
G = 4500; C = 2575; total = 14800
prop_GC = (4500 + 2575) / 14800
print (" La proportion de GC est ", prop_GC ) # par défaults 16 chiffres après la virgule
Trop de décimales (seize dans le cas présent). Pour un résultat lisible, spécifier le format de l'affichage entre les accolades {}
print (f"La proportion de GC est { prop_GC :.2f}")
print (f"La proportion de GC est { prop_GC :.3f}")
# Formater en entier :d (decimal integer) :
nb = 8
x = nb/4 # division non entière
print (f"le quart de {nb} est {x:d} ")
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
Cell In[3], line 4
2 nb = 8
3 x = nb/4 # division non entière
----> 4 print (f"le quart de {nb} est {x:d} ")
ValueError: Unknown format code 'd' for object of type 'float'Alignement et largeur :
- À droite : >
- À gauche : <
- Centré : ˆ
print ('@',10,'@', sep="") ; print ('@',1000,'@', sep="")
print (f"@{10:>6d}@") ; print (f"@{1000:>6d}@")
print (f"@{10:<6d}@") ; print (f"@{1000:<6d}@")
print (f"@{10:^6d}@") ; print (f"@{1000:^6d}@")
print (f"@{10:*^6d}@") ; print (f"@{1000:*^6d}@")
print (f"@{99:0>6d}@") ; print (f"@{7777:0>6d}@")
Écriture formatée : Largeur et alignement / string:
print ("@Filiere API2@") ; print ("@Sections ABC@")
print (f"Filiere @{'API2':>6s}@") ; print (f"Sections @{'ABC':>6s}@") # largeur appliquée à l'interieur de {}
Écriture des accollades : il faut les doubler pour éviter mauvaise interprétation
# print (f"Reamarque : accolades sans variable {")
# print (f"Reamarque : accolades sans variable }")
print (f"Reamarque : accolades sans variable \{")
# print (f"Reamarque : accolades sans variable \}")
# print (f"Reamarque : accolades sans variable {}")
print(f"Afficher accolade Ouvrante : {{")
print(f"Afficher accolade Fermante : }}")
print(f"Afficher les deux accolades : {{ du texte ici }}")
Écriture formatée : appel à fonction ou expression dans {}
print (f"Le résultat de 5 * 5 vaut {5 * 5}")
print (f"Résultat d'une opération avec des floats : {(4.1 * 6.7)}")
print (f"Le minimum est { min (1, -2, 4)}")
entier = 2
print (f"Le type de { entier }")
Tests Retour ⭡
if (else)
a = 5
if a == 5:
print("égalité")
else:
print("Difference")
égalité
if (elif) (else)
a = 5
if a == 5:
print("égalité")
elif a < 5:
print("Inferieur")
else:
print("Supérieur")
égalité
# Rappel : double test
x = 10
if 8 < x <= 9:
print("T")
else:
print("F")
F
a = 7 ; b = 4
# a = 111
# b = 100
# a = 10; b = False
print("a ^ b : " , a ^ b)
print("a & b : ", a & b)
print("a and b : " , a and b)
print("a or b : ", a or b)
print("a | b : ", a | b)
a ^ b : 3 a & b : 4 a and b : 4 a or b : 7 a | b : 7
import sys
print(sys.version)
3.10.9 | packaged by conda-forge | (main, Jan 11 2023, 15:15:40) [MSC v.1916 64 bit (AMD64)]
# ------------------------------------------------------
# ------------------------------------------------------
# # MARCHE UNIQUEMENT A PARTIR DE Python 3.10
# # ou sur un site web approprié
# ------------------------------------------------------
# ------------------------------------------------------
# Print a message, depending on the day of the week
day = "Monday"
match day:
case "Monday":
print("It's Monday!")
case "Tuesday":
print("It's Tuesday!")
case "Wednesday":
print("It's Wednesday!")
case _:
print("It's not Monday, Tuesday, or Wednesday.")
It's Monday!
Boucles Retour ⭡
Boucle for
- itère sur les éléments d'une séquence ( liste, chaîne de caractères…),
- dans l'ordre dans lequel ils apparaissent dans la séquence.
Exemple : la séquence est une liste de chaines
X = ["A", "B", "C", "D", "E", "F"]
words_API = ['cat', 'window', 'peace', 'University']
for wpk in words_API:
print(wpk)
print("Fin de la boucle for")
cat window peace University Fin de la boucle for
Exemple : la séquence est une chaine
mot = "XYZ"
for lettre in mot:
print(lettre)
X Y Z
Exemple de séquence : liste d'entiers
for i in [10, 2, 3]:
print(i)
10 2 3
Exemple de séquence : Tranche de liste
words = ['cat', 'window', 'peace', 'University']
for w in words[1:3]:
print(w)
window peace
Exemple : la séquence est une plage d'entiers (range)
- Attention : il faut respecter l'indentation au cas de plusieurs instructions !
r = range(10)
print(r)
type(r)
range(0, 10)
range
for i in range(5):
a = 2*i
print(a)
0 2 4 6 8
for i in range(1,5):
a = 2*i
print(a)
2 4 6 8
Boucle while
- while (condition):
instuction 1
instuction 2
...
- s'exécute tant que la condition est Vrai
i = 10
while (i):
print(i, end = " ")
i //= 4
print("\nFin Boucle while")
10 2 Fin Boucle while
Instruction break
- Termine la boucle la plus imbriquée, sans compléter l'itération en cours.
- Ne peut apparaître qu'à l'intérieur d'une boucle for ou while,
- mais pas dans une définition de fonction à l'intérieur de cette boucle:
#break
for n in range(61,71):
print(f"n : {n} ")
if n % 7 == 0:
print(f"Enfin, {n} Multiple de 7")
break
print("ap Break, Interieur if")
print(f"Apres break : {n} n'est pas multiple de 7")
n : 61 Apres break : 61 n'est pas multiple de 7 n : 62 Apres break : 62 n'est pas multiple de 7 n : 63 Enfin, 63 Multiple de 7
Instruction continue
- fait passer la boucle à l'itération suivante, en sautant le reste de l'itération actuelle
# continue
for num in range(2, 6):
print("\niterer : ",num)
if num % 2 == 0:
print(f"{num} est un nombre Pair")
continue
print(f"Après Continue, num : {num}")
print("Nombre Impair : ", num)
iterer : 2 2 est un nombre Pair iterer : 3 Après Continue, num : 3 Nombre Impair : 3 iterer : 4 4 est un nombre Pair iterer : 5 Après Continue, num : 5 Nombre Impair : 5
Partie 04. Listes Retour ⭡
- Définition :
- Une liste est une structure de données contenant un ensemble d'éléments pas nécessairement du même type
- Permet une grande flexibilité.
- Une liste est déclarée et initialisée par une série de valeurs, entre crochets [ ], séparées par des virgules.
- "Tableau Dynamique"
Exemples : (L'affichage d'une liste, se fait telle qu’elle a été saisie)
animaux = ["girafe", "tigre", "Lion", "Chat"]
Nombres = [5, 2 , 1 , 15]
mixte = ["girafe ", 5, " Chat ", 15]
print(animaux) ; print(Nombres) ; print(mixte)
print(animaux[0])
['girafe', 'tigre', 'Lion', 'Chat'] [5, 2, 1, 15] ['girafe ', 5, ' Chat ', 15] girafe
- Utilisation :
- Pour une liste L de n éléments : indices de 0 à n-1 (n > 0)
- Accèder au 1er élément de la liste : L[0]
- Accèder au 2ème élément de la liste (s'il existe) : L[1]
…
- Accèder au nème élément de la liste : L[n-1]
- Attention au débordement : géré par Python (≠ Langage C )
print(animaux[0]) ; print(animaux[3]) ; print(animaux[9]) ;
girafe Chat
--------------------------------------------------------------------------- IndexError Traceback (most recent call last) Cell In[22], line 1 ----> 1 print(animaux[0]) ; print(animaux[3]) ; print(animaux[9]) IndexError: list index out of range
Fonction len() : longueur ou nombre d'éléments de la liste
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(len(x))
10
Listes : Opérateur concaténation +
L1 = [" girafe ", " tigre "]
L2 = [" singe ", " souris "]
print((L1 + L2))
[' girafe ', ' tigre ', ' singe ', ' souris ']
Listes : Opérateur de reproduction : multiplication par entier *
print((L1 + L2)*2)
print(L1*3)
print(L1 + L2*3)
[' girafe ', ' tigre ', ' singe ', ' souris ', ' girafe ', ' tigre ', ' singe ', ' souris '] [' girafe ', ' tigre ', ' girafe ', ' tigre ', ' girafe ', ' tigre '] [' girafe ', ' tigre ', ' singe ', ' souris ', ' singe ', ' souris ', ' singe ', ' souris ']
# Attention !!
print(L1*L2)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[26], line 2
1 # Attention !!
----> 2 print(L1*L2)
TypeError: can't multiply sequence by non-int of type 'list'Listes : Opérations
Opérateur ajout à la fin (queue) : + ou méthode .append()
a = []
# ajout par + :
a = a + [15] ; a = a + [ -5]
print(a)
[15, -5]
# puis avec la méthode .append() :
a.append (13)
a.append ( -3)
print(a)
[15, -5, 13, -3]
Listes : indice négatif
#indice negatif
L = ["A", "B", "C", "D", "E", "F"]
print(L[-1])
F
print(L[-2])
print(L[-3])
E D
Listes : Tranches : [m : n] :: de l'indice m à l'indice (n-1) # indice n exclu
# tranches
L = ["A", "B", "C", "D", "E", "F"]
print(L[0:2])
['A', 'B']
print(L[:2])
['A', 'B']
print(L[1:])
print(L[1:len(L)])
['B', 'C', 'D', 'E', 'F'] ['B', 'C', 'D', 'E', 'F']
print(L[0:])
['A', 'B', 'C', 'D', 'E', 'F']
print(L[:])
['A', 'B', 'C', 'D', 'E', 'F']
print(L)
['A', 'B', 'C', 'D', 'E', 'F']
print(L[1:-1])
print(L[1:-2])
['B', 'C', 'D', 'E'] ['B', 'C', 'D']
print(L[-2:])
print(L[-2:1:-1])
['E', 'F'] ['E', 'D', 'C']
Tranches : parcours avec pas ≠ 1
x = [100, 10, 20, 30, 40, 50, 60, 70, 80, 90]
print(x[0:len(x)]) # x[deb:fin] avec indice fin exclu
[100, 10, 20, 30, 40, 50, 60, 70, 80, 90]
print(x[0:len(x):1]) # x[deb:fin:pas] avec indice fin exclu
[100, 10, 20, 30, 40, 50, 60, 70, 80, 90]
print(x[0:9:2])
[100, 20, 40, 60, 80]
print(x[0:9:3])
# print(x[0::3])
[100, 30, 60] [100, 30, 60, 90]
print(x[::1])
print(x[::2])
print(x[::3])
[100, 10, 20, 30, 40, 50, 60, 70, 80, 90] [100, 20, 40, 60, 80] [100, 30, 60, 90]
Fonction list() : permet de créer une liste
print(list('a bc'))
['a', ' ', 'b', 'c']
Fonction range() : génèrer des nombres entiers compris dans un intervalle
a = list(range(10))
print(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Fonction range() : génèrer des nombres entiers compris dans un intervalle
L = list(range(15, 20))
print(L)
[15, 16, 17, 18, 19]
# ordre INVERSE
L = list(range(10,0,-1))
print(L)
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
print(list(range(10,-1,-1)))
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
print(list(range(10,0,-2)))
print(list(range(10,-1,-2)))
[10, 8, 6, 4, 2] [10, 8, 6, 4, 2, 0]
# plage d'entiers uniquement
print(list(range(0.5,2,0.5)))
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[35], line 2
1 # plage d'entiers uniquement
----> 2 print(list(range(0.5,2,0.5)))
TypeError: 'float' object cannot be interpreted as an integerAutres Exemples :
L = list(range(0, 1000, 200)) # pas de 200
print(L)
[0, 200, 400, 600, 800]
L = list(range(2, -2, -1)) # ordre inverse : pas = -1
print(L)
[2, 1, 0, -1]
#------------------------------------
#-------------------------- ATTENTION
#------------------------------------
L = list(range(10,0)) # pas par défaut = 1,
print(L)
[]
Liste de Listes
#liste de liste
mod_0_3 = [21, 3, 6, 9]
mod_1_3 = [31, 4, 7, 10]
# mod_1_3 = [31, 4, 7]
mod_2_3 = [21, 2, 8, 11]
LL = [mod_0_3 , mod_1_3, mod_2_3]
print(f"{'LL ':10s}:",LL)
LL : [[21, 3, 6, 9], [31, 4, 7, 10], [21, 2, 8, 11]]
print(f"{'LL[1][3]':10s}:",LL[1][3])
LL[1][3] : 10
print(f"{'LL[1] ':10s}:", LL[1])
LL[1] : [31, 4, 7, 10]
print(LL)
[[21, 3, 6, 9], [31, 4, 7, 10], [21, 2, 8, 11]]
# Tri d'une liste de listes (2D)
LL.sort()
print(LL)
[[21, 2, 8, 11], [21, 3, 6, 9], [31, 4, 7, 10]]
Liste : Min, Max, Sum :
liste = list(range(10))
print(liste)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(sum(liste))
# 45
print(min(liste))
# 0
print(max(liste))
# 9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 45 0 9
- méthodes : .insert() , .extend() , .reverse()
# Rappel
a = [10, 20, 30]
a.append(9)
a
[10, 20, 30, 9]
- .insert( pos , elem )
a = [7, 5, 13]
a
[7, 5, 13]
# insert()
pos = 1
elem = 2
a.insert(pos,elem)
print(a)
[7, 2, 5, 13]
# Erreur: il faut preciser les deux paramètres
a.insert(,elem)
print(a)
Cell In[47], line 1
a.insert(,elem)
^
SyntaxError: invalid syntax
a.insert(0,-9)
print(a)
[-9, 7, 2, 5, 13]
a.insert(35 , 11)
print(a)
[-9, 7, 2, 5, 13, 11]
a = [10, 20, 30]
a.insert(-1 , 99)
print(a)
[10, 20, 99, 30]
a.insert(-1 , 199)
print(a)
[10, 20, 99, 199, 30]
#initialisation oar zéros
b = [0 for i in range(5)]
print(b)
[0, 0, 0, 0, 0]
#initialisation oar i
b = [i for i in range(5)]
print(b)
[0, 1, 2, 3, 4]
# extend
a.extend(b)
print(a)
[10, 20, 99, 199, 30, 0, 1, 2, 3, 4]
LAnim = ["girafe ", "tigre " , "singe ", "fourmis "]
LAnim.extend(['AA','BB'])
print(LAnim)
['girafe ', 'tigre ', 'singe ', 'fourmis ', 'AA', 'BB']
Listes : affectation et copie
# affectation de listes
a = [10, 20, 30]
li = a
li.append(99)
print(li)
[10, 20, 30, 99]
print(a)
[10, 20, 30, 99]
a = [10, 20, 30]
d = a.copy()
d.append(11)
print(d)
[10, 20, 30, 11]
print(a)
[10, 20, 30]
# methode 2
x = [10, 20, 30]
y = x[:]
y.append(12)
print(y)
print(x)
[10, 20, 30, 12] [10, 20, 30]
# reverse
n = 9
Ln = [i for i in range(n)]
print(Ln)
Ln.reverse()
print(Ln)
[0, 1, 2, 3, 4, 5, 6, 7, 8] [8, 7, 6, 5, 4, 3, 2, 1, 0]
# reverse
n = 9
Ln = [i for i in range(n)]
print(Ln)
Ln = Ln[::-1]
print(Ln)
[0, 1, 2, 3, 4, 5, 6, 7, 8] [8, 7, 6, 5, 4, 3, 2, 1, 0]
# trier
LAnim = ["girafe ", "tigre " , "singe ", "fourmis "]
LAnim.sort()
print(LAnim)
['fourmis ', 'girafe ', 'singe ', 'tigre ']
# tri decroissant
AgeAnim = [2, 3, 0.1, 1.5]
AgeAnim.sort(reverse = True)
print(AgeAnim)
[3, 2, 1.5, 0.1]
# trier
LAnim_ = ["girafe ", 1, "tigre " , "singe ", "fourmis "]
LAnim_.sort()
print(LAnim_)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[88], line 3
1 # trier
2 LAnim = ["girafe ", 1, "tigre " , "singe ", "fourmis "]
----> 3 LAnim.sort()
4 print(LAnim)
TypeError: '<' not supported between instances of 'int' and 'str'Parcours de Listes
- Parcours Simple
LAnim = ["girafe ", "tigre " , "singe ", "fourmis "]
LAnim.sort()
print(LAnim)
for elm in LAnim:
print(elm)
['fourmis ', 'girafe ', 'singe ', 'tigre '] fourmis girafe singe tigre
- Parcours parallèle de 2 listes : zip
print(f"{'Animal':11} : Age")
print("------------------")
for anim, ageA in zip(LAnim,AgeAnim):
print(f"{anim:11}",":",ageA)
Animal : Age ------------------ fourmis : 3 girafe : 2 singe : 1.5 tigre : 0.1
- Si une liste est plus courte que l'autre, la boucle for s'arrete a la liste la plus courte
AgeAnim = [2, 3, 0.1, 1.5]
LAnim = ["girafe ", "tigre " , "singe ", "fourmis "]
AgeAnim.append(15)
print(LAnim)
print(AgeAnim,"\n")
print(f"{'Animal':11} : Age")
print("------------------")
for anim, ageA in zip(LAnim,AgeAnim):
print(f"{anim:11}",":",ageA)
['girafe ', 'tigre ', 'singe ', 'fourmis '] [2, 3, 0.1, 1.5, 15] Animal : Age ------------------ girafe : 2 tigre : 3 singe : 0.1 fourmis : 1.5
x = zip(LAnim,AgeAnim)
print(type(x))
<class 'zip'>
- Parcours via enumerate
La fonction enumerate est tres utile pour sortir a la fois les éléments d'une liste et leurs index. C'est une fonction tres utilisée en datascience
for index, element in enumerate(LAnim):
print(index, element)
0 girafe 1 tigre 2 singe 3 fourmis
Exercices
- Devinez la valeur de "a" après la séquence du code ci-dessous :
a = 2
a = a**2+a+2
- Devinez la valeur de « a », « b », « c » après la séquence ci-dessous :
a, b, c = 1, 2, 3
a, b, c = b, c, a
a, b, c = c, a, b
- qu'affiche la séquence (Associativité Gauche-Droite):
print(6*2**3/4)
print(1 + 2**3/4*5)
- qu'affiche la séquence ?
t = True ; f = False
not((t or f) and f) != f
- qu'affiche la séquence ?
t = False ; f = True
not((t or f) and f) != f
-
écrire un programme python qui calcule Fn : l'ordre n de la suite de Fibonacci,
- Rappel : Fb0 = 0 , Fb1 = 1, Fbn = Fbn-1 + Fbn-2 pour n>1
- On suppose que n > 1
1- En utilisant une liste
2- Sans utilisation de liste - Rappel : Fb0 = 0 , Fb1 = 1, Fbn = Fbn-1 + Fbn-2 pour n>1
# En utilisant une liste
n = 12
LF = [0 for i in range(n+1)]
# Solution:
# Sans utilisation de liste
# Solution:
- Types Immuable , Mutable Retour ⭡
Type immuable : int, float, bool , str , tuple
- a = 5 est une reference vers le nombre 5 (5 est immuable)
- a += 2 est une reference vers le nombre 7 (7 est immuable)
- L'identifiant en mémoire d'une variable a est id(a)
# L'identifiant en mémoire d'une variable a est id(a)
a = 7
print("id (a) :" , id(a))
print("id (7) :" , id(7))
id (a) : 1346457070064 id (7) : 1346457070064
b = a
print("id (a) :" , id(a))
print("id (b) :" , id(b))
print("")
id (a) : 1346457070064 id (b) : 1346457070064
# a = 7
a += 2
print(" ")
print("a:",a, "id (a) :" , id(a))
print("id (9) :" , id(9))
print("")
print("id (7) :" , id(7))
print("id (b) :" , id(b))
a: 9 id (a) : 1346457070128 id (9) : 1346457070128 id (7) : 1346457070064 id (b) : 1346457070064
prenom = "Patrick"
print("prenom :", prenom, " \nid :", id(prenom)%1000000)
print("id de \"Patrick\" :", id("Patrick")%1000000)
prenom = "Patricke"
print("prenom Patricke :", id(prenom)%1000000)
print("")
prenom = "Patrick"
prenom += 'e'
print("id de ", prenom, ":", id(prenom)%1000000)
prenom : Patrick id : 158256 id de "Patrick" : 158256 prenom Patricke : 842224 id de Patricke : 158960
prenom[0] = 'p'
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[100], line 1 ----> 1 prenom[0] = 'p' TypeError: 'str' object does not support item assignment
Type Mutable : Liste
list_1 = [1, 2]
print(list_1)
# print("id list_1 av :", id(list_1)%1000000)
print("id list_1 av :", id(list_1))
list_1.append(31)
print(list_1)
# print("id list_1 ap :", id(list_1)%1000000)
print("id list_1 ap :", id(list_1))
[1, 2] id list_1 av : 1344423417984 [1, 2, 31] id list_1 ap : 1344423417984
Différence entre affectation ' = ' ET ' .copy() '
list_1 = [10, 20]
print("id list_1 av :", id(list_1))
# Affectation
list_2 = list_1
print("id list_2 av :", id(list_2))
id list_1 av : 1344422027840 id list_2 av : 1344422027840
list_1.append(113)
print("id list_1 ap :", id(list_1))
print("id list_2 ap :", id(list_2))
id list_1 ap : 1344422027840 id list_2 ap : 1344422027840
print("\nL1 :", list_1)
print("L2 :", list_2)
L1 : [10, 20, 113] L2 : [10, 20, 113]
list_1 = [100, 200]
list_3 = list_1.copy()
print("L1 Av :",list_1)
print("L3 Av :",list_3)
L1 Av : [100, 200] L3 Av : [100, 200]
print("\n- L1.append()\n")
list_1.append(9999)
print("L1 Ap :",list_1)
print("L3 Ap :",list_3)
- L1.append() L1 Ap : [100, 200, 9999, 9999] L3 Ap : [100, 200]
print("id list_1 ap :", id(list_1)%1000000)
print("id list_3 ap :", id(list_3)%1000000)
id list_1 ap : 128128 id list_3 ap : 835136