Affectation et référence en Python

Introduction

Dans ce laboratoire, nous allons aborder les bases de l'affectation et des références en Python. Nous explorerons la manière dont Python gère les affectations, comment créer des références et comment travailler avec des objets mutables et immuables.

Skills Graph

Introduction aux affectations en Python

En Python, l'affectation est le processus consistant à lier un nom à un objet. Les instructions d'affectation ont la forme générale suivante :

variable = expression

L'expression située à droite est évaluée, et sa valeur est affectée à la variable située à gauche.

Examillons un exemple simple :

Test simple

Ouvrez le Terminal et tapez la commande suivante dans le terminal.

python3

Ensuite, entrez le code suivant.

## Affectez la valeur 42 à la variable 'x' et imprimez-la.
x = 42
print(x)

Sortie :

42

Ici, nous affectons x à la variable 42 à l'aide de l'opérateur =. Ensuite, nous imprimons les valeurs de x.

Comprendre les références

En Python, les variables sont des références à des objets. Lorsque vous affectez une valeur à une variable, vous créez en fait une référence à l'objet qui représente la valeur.

Voici un exemple pour illustrer ce concept :

## Illustrer les références Python.
x = [1, 2, 3]
y = x
y.append(4)

print("x:", x)
print("y:", y)

Sortie :

x: [1, 2, 3, 4]
y: [1, 2, 3, 4]

Dans cet exemple, x et y se réfèrent au même objet de liste. Lorsque nous modifions la liste via la référence y en ajoutant 4, le changement est répercuté sur x et y.

Objets mutables et immuables

Python a deux types d'objets : mutables et immuables.

Les objets mutables peuvent être modifiés après leur création. Les listes, les dictionnaires et les ensembles sont des exemples d'objets mutables.

Les objets immuables ne peuvent pas être modifiés une fois créés. Les entiers, les flottants, les chaînes de caractères et les tuples sont des exemples d'objets immuables.

Examillons un exemple qui illustre la différence entre les objets mutables et immuables :

## Exemple d'objet mutable
mutable_list = [1, 2, 3]
another_mutable_list = mutable_list
another_mutable_list.append(4)
print("mutable_list:", mutable_list)

Sortie :

mutable_list: [1, 2, 3, 4]

mutable_list ajoute un 4 à la fin de la liste car il s'agit d'un objet mutable, mais les objets immuables ne peuvent pas être modifiés une fois créés.

## Exemple d'objet immuable
immutable_string = "hello"
another_immutable_string = immutable_string
another_immutable_string = another_immutable_string.upper()
print("immutable_string:", immutable_string)

Sortie :

immutable_string: hello

Il n'y a pas de changement, et si nous voulons modifier immutable_string comme suit, l'interpréteur Python générera une erreur TypeError :

immutable_string[0] = '1'

Sortie :

TypeError: 'str' object does not support item assignment

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.

Récapitulatif

Dans ce tutoriel de programmation Python, nous avons abordé les bases de l'affectation et des références en Python. Nous avons exploré la manière dont Python gère les affectations, comment créer des références et comment travailler avec des objets mutables et immuables. En comprenant ces concepts, vous serez mieux équipé pour écrire du code Python efficace et correct.