Exemples
Voyons quelques exemples supplémentaires pour renforcer les concepts que nous avons appris :
Exemple 1 : Fonction avec un argument par défaut mutable
Évitez d'utiliser des objets mutables comme arguments par défaut dans les fonctions :
def bad_append(new_item, a_list=[]):
a_list.append(new_item)
return a_list
print(bad_append('one'))
Sortie :
['one']
Cela semble correct, mais si nous appelons cette fonction à nouveau :
print(bad_append('two'))
Sortie :
['one', 'two']
Le problème ici est que la valeur par défaut de a_list
est évaluée au moment de la définition de la fonction. Ainsi, chaque fois que vous appelez la fonction, vous obtenez la même valeur par défaut. La bonne manière est de la créer au moment de l'exécution, à l'intérieur de la fonction.
def append_to_list(item: int, a_list: list = None) -> list:
"""Ajoute un élément à une liste et renvoie la liste mise à jour."""
if a_list is None:
a_list = []
a_list.append(item)
return a_list
list_a = append_to_list(1, [1, 2, 3])
print(list_a)
Sortie :
[1, 2, 3, 1]
Exemple 2 : Copie d'objets mutables
Utilisez le module copy
pour créer un nouvel objet lorsque vous voulez travailler avec une copie d'un objet mutable :
import copy
## Montre l'utilisation du module copy.
original_list = [1, 2, 3]
copied_list = copy.copy(original_list)
copied_list.append(4)
print("original_list:", original_list)
print("copied_list:", copied_list)
Sortie :
original_list: [1, 2, 3]
copied_list: [1, 2, 3, 4]
Dans cet exemple, copied_list
est un nouvel objet qui est une copie de original_list
. Lorsque nous ajoutons 4
à copied_list
, original_list
reste inchangé.
Exemple 3 : Copie profonde d'objets mutables
Pour les objets mutables imbriqués, utiliser la fonction copy
ne fonctionne pas :
## votre exemple de copie ici
original_nested_list = [[1, 2], [3, 4]]
copied_nested_list = copy.copy(original_nested_list)
copied_nested_list[0].append(5)
print("original_nested_list:", original_nested_list)
print("copied_nested_list:", copied_nested_list)
Sortie :
original_nested_list: [[1, 2, 5], [3, 4]]
copied_nested_list: [[1, 2, 5], [3, 4]]
Nous pouvons voir que lorsque nous ajoutons 5
à copied_nested_list
, original_nested_list
ajoute également 5
. Donc, vous devriez utiliser la fonction deepcopy
à la place :
## votre exemple de deepcopy ici
original_nested_list = [[1, 2], [3, 4]]
deep_copied_list = copy.deepcopy(original_nested_list)
deep_copied_list[0].append(5)
print("original_nested_list:", original_nested_list)
print("deep_copied_list:", deep_copied_list)
Sortie :
original_nested_list: [[1, 2], [3, 4]]
deep_copied_list: [[1, 2, 5], [3, 4]]
Dans cet exemple, la fonction deepcopy
copie original_nested_list
de manière récursive, tandis que la fonction copy
crée un objet de référence pour les données de premier niveau de original_nested_list
.