Tuples et déballage

Un groupe fixe de valeurs

Un tuple ressemble à une liste qui ne peut plus changer après sa création. On le crée avec des virgules, généralement entre parenthèses : ("AAPL", 184.25, 184.5). Il convient à un petit enregistrement dont les parties ont un sens fixe, comme une cotation ou une transaction. On le lit par indice comme une liste, mais assigner à une position lève une TypeError. Un tuple d'un élément exige une virgule finale, (5,), car (5) n'est que le nombre 5.

quote = ("AAPL", 184.25, 184.5)

# Reading works like a list
print(quote[0], len(quote))  # AAPL 3

# Changing does not
try:
    quote[1] = 185.0
except TypeError as error:
    print("tuples are fixed:", error)

# One item needs a trailing comma
print(type((5,)), type((5)))  # <class 'tuple'> <class 'int'>

Le déballage : donner un nom à chaque partie

Le déballage affecte d'un coup les parties d'un tuple (ou de toute séquence) à plusieurs noms : symbol, bid, ask = quote. Le nombre de noms doit correspondre au nombre d'éléments, sinon Python lève une ValueError. Comparés à quote[0], quote[1] et quote[2], les noms disent ce que chaque partie signifie : déballer est donc généralement plus clair qu'indexer. Cela donne aussi l'échange classique sans variable temporaire : a, b = b, a.

# Unpack a quote into named parts
quote = ("AAPL", 184.25, 184.5)
symbol, bid, ask = quote
print(symbol, round(ask - bid, 2))  # AAPL 0.25

# Swap two values without a temporary
bid, ask = ask, bid
print(bid, ask)                     # 184.5 184.25

# The count must match
try:
    symbol, bid = quote
except ValueError as error:
    print("wrong count:", error)

Prendre le reste avec *

Placez un * devant un nom pour qu'il récupère tout ce qui reste, sous forme de liste : first, *rest = prices ou first, *middle, last = prices. Un seul nom avec étoile est permis, et les noms simples réclament chacun un élément. Utilisez _ pour une partie dont vous n'avez pas besoin, par exemple first, *_, last = prices.

# * collects what is left, as a list
prices = [184.0, 185.0, 183.2, 186.1]

first, *rest = prices
print(first, rest)         # 184.0 [185.0, 183.2, 186.1]

first, *_, last = prices
print(first, last)         # 184.0 186.1

Déballage dans les boucles, les retours et le tri

Le déballage fonctionne partout où un nom est affecté : dans une boucle for (for symbol, price in quotes), dans les compréhensions, et sur le résultat d'une fonction qui renvoie plusieurs valeurs avec return a, b, ce qui renvoie en réalité un seul tuple. Les tuples se comparent aussi élément par élément, premier contre premier puis, en cas d'égalité, second contre second : trier une liste de tuples (price, symbol) ordonne donc par prix et départage les égalités par symbole.

# Return several values, unpack them in the caller
def spread_and_mid(bid, ask):
    return ask - bid, (bid + ask) / 2

spread, mid = spread_and_mid(184.25, 184.5)
print(spread, mid)  # 0.25 184.375

# Tuples sort by the first item, then the second
quotes = [("AAPL", 184.5), ("MSFT", 410.2), ("GOOG", 171.0)]
by_price = sorted((price, symbol) for symbol, price in quotes)
print(by_price)     # [(171.0, 'GOOG'), (184.5, 'AAPL'), (410.2, 'MSFT')]

for price, symbol in by_price:
    print(symbol, price)

• (a, b, c) : un groupe fixe ; on le lit, on ne le modifie pas.
• x, y = pair : déballer dans des noms ; les nombres doivent correspondre.
• first, *rest = items : le nom avec étoile récupère le reste sous forme de liste.

À suivre : les dictionnaires, qui retrouvent des valeurs par un nom plutôt que par une position.

Lab : ce qui est noté

• Déballer une cotation avec quote_stats25 pts
• Prendre les deux extrémités avec first_last25 pts
• Classer des cotations par prix avec ranked25 pts
• Trouver la place la moins chère avec best_ask25 pts