Affecter les éléments d’une séquence à plusieurs variables

Vous avez un tuple ou une séquence de N éléments que vous souhaitez décomposer dans une collection de N variables. N’importe quelle séquence (ou objet itérable) peut être décomposée en variables à l’aide d’une simple opération d’affectation. La seule condition est que le nombre de variables et la structure correspondent à ceux de la séquence. Par exemple :

# Exemple avec un tuple
coordonnees = (10, 20, 30)

x, y, z = coordonnees

print(x)  # 10
print(y)  # 20
print(z)  # 30

S’il y a un décalage dans le nombre d’éléments, vous obtiendrez une erreur. Par exemple :

p = (4, 5)
x, y, z = p  # Erreur : pas assez de valeurs à dépaqueter (3 attendues, 2 reçues)

Le dépaquetage fonctionne en réalité avec n’importe quel objet itérable, pas seulement les tuples ou les listes. Cela inclut les chaînes de caractères, les fichiers, les itérateurs et les générateurs. Lors du dépaquetage, il se peut que vous souhaitiez parfois ignorer certaines valeurs. Python ne propose pas de syntaxe spéciale pour cela, mais vous pouvez simplement utiliser un nom de variable que vous n’allez pas réutiliser. En pratique, on utilise souvent _ comme variable « jetable » .

coordonnees = (10, 20, 30)

x, _, z = coordonnees  # On ignore la valeur 20

print(x)  # 10
print(z)  # 30

Cependant, assurez-vous que le nom de variable que vous choisissez n’est pas déjà utilisé pour autre chose.

Utiliser les expressions étoile pour dépaqueter des séquences de longueur variable

Vous devez dépaqueter N éléments depuis un itérable, mais cet itérable peut être plus long que N éléments, ce qui provoque une exception « trop de valeurs à dépaqueter ».

Les « expressions étoile » de Python peuvent être utilisées pour résoudre ce problème. Par exemple, supposons que vous donniez un cours et que, à la fin du semestre, vous décidiez de ne pas prendre en compte les notes du premier et du dernier devoir, et de ne faire la moyenne que des autres. S’il n’y a que quatre devoirs, vous pouvez simplement dépaqueter les quatre, mais que faire s’il y en a 24 ? Une expression étoile facilite cela :

def drop_first_last(grades):
    first, *middle, last = grades
    return avg(middle)

Autre cas d’usage : supposons que vous ayez des enregistrements utilisateurs composés d’un nom et d’une adresse e-mail, suivis d’un nombre arbitraire de numéros de téléphone. Vous pouvez dépaqueter ces enregistrements ainsi :

# Enregistrements utilisateurs : nom, email, puis plusieurs numéros de téléphone
user_record = ("Alice Dupont", "alice@example.com", "0123456789", "0987654321", "0147258369")

# Dépaquetage avec expression étoile pour récupérer les numéros de téléphone
name, email, *phone_numbers = user_record

print(f"Nom : {name}")
print(f"E-mail : {email}")
print("Numéros de téléphone :")
for number in phone_numbers:
    print(f" - {number}")

Il est important de noter que la variable phone_numbers sera toujours une liste, quel que soit le nombre de numéros de téléphone dépaquetés (même s’il n’y en a aucun). Ainsi, tout code utilisant phone_numbers n’aura pas à gérer le cas où ce ne serait pas une liste, ni à effectuer de vérifications supplémentaires de type.

La variable étoilée (*) peut également être placée en début de liste lors du dépaquetage. Par exemple, supposons que vous disposiez d’une séquence contenant les chiffres de vente de votre entreprise pour les huit derniers trimestres. Si vous souhaitez comparer le chiffre du trimestre le plus récent avec la moyenne des sept trimestres précédents, vous pouvez écrire ceci :

# Exemple de dépaquetage avec une variable étoilée en première position
*trailing_qtrs, current_qtr = sales_record

# Calcul de la moyenne des sept derniers trimestres
trailing_avg = sum(trailing_qtrs) / len(trailing_qtrs)

# Comparaison entre la moyenne et le chiffre du trimestre actuel
return avg_comparison(trailing_avg, current_qtr)

Le dépaquetage étendu est spécialement conçu pour dépaqueter des itérables dont la longueur est inconnue ou variable. Souvent, ces itérables contiennent un composant ou un schéma connu dans leur construction (par exemple, « tout ce qui suit l’élément 1 est un numéro de téléphone »). Le dépaquetage avec l’étoile (*) permet au développeur de tirer parti facilement de ces schémas, sans avoir à faire des manipulations compliquées pour accéder aux éléments pertinents.

Il est important de noter que la syntaxe étoile est particulièrement utile lorsqu’on itère sur une séquence de tuples de longueurs variables. Par exemple, une séquence de tuples tagués :

# Exemple de séquence de tuples tagués
records = [
    ("info", "Alice", 30, "Paris"),
    ("contact", "Bob", "bob@example.com", "0123456789", "9876543210"),
    ("info", "Charlie", 25),
    ("contact", "Diana", "diana@example.com")
]

for record_type, *data in records:
    if record_type == "info":
        name, age, *location = data
        location = location[0] if location else "Inconnu"
        print(f"Info - Nom: {name}, Âge: {age}, Lieu: {location}")
    elif record_type == "contact":
        name, email, *phones = data
        print(f"Contact - Nom: {name}, Email: {email}, Téléphones: {phones}")

Dans cet exemple, chaque tuple commence par un tag qui indique le type d’enregistrement, comme « info » ou « contact ». Le reste des éléments est capturé dans une liste grâce au dépaquetage étoile (« *data »). Ensuite, selon le type d’enregistrement, on dépaquette cette liste en variables spécifiques. Cette approche permet de gérer facilement des tuples de longueurs variables, notamment pour récupérer un nombre indéfini d’éléments, comme plusieurs numéros de téléphone, sans compliquer le code avec des indices ou des boucles supplémentaires.

Publié le

me contacter

* champ obligatoire