Les ensembles

Une collection sans doublons

Un ensemble (set) contient chaque valeur au plus une fois et n'a pas de position : {"AAPL", "MSFT", "GOOG"}. Ajouter une valeur déjà présente ne change rien. set(items) transforme n'importe quel itérable en ensemble, ce qui est le moyen le plus rapide de supprimer les doublons, et len compte alors les valeurs distinctes. Comme un ensemble n'a pas d'ordre, on ne peut pas l'indexer, et l'ordre affiché ne doit pas servir de référence. Un ensemble vide s'écrit set() : {} est un dictionnaire vide.

symbols = ["AAPL", "MSFT", "AAPL", "GOOG", "MSFT"]

# set() removes repeats
unique = set(symbols)
print(len(symbols), len(unique))      # 5 3

# Adding something already there changes nothing
unique.add("AAPL")
unique.add("TSLA")
print(len(unique))                    # 4

# {} is a dict; an empty set is set()
print(type({}), type(set()))          # <class 'dict'> <class 'set'>

Des tests d'appartenance rapides

x in some_set répond presque instantanément, même avec des millions de valeurs, car un ensemble trouve une valeur par son hachage au lieu de balayer. Le même test sur une liste examine les éléments un par un et ralentit quand la liste grandit. Si vous posez souvent in sur la même collection, par exemple pour vérifier chaque ordre entrant contre une liste de symboles interdits, transformez cette collection en ensemble une seule fois. Les membres d'un ensemble doivent être hachables, comme les clés d'un dictionnaire.

# Membership: a set is the fast structure for "is it in there?"
banned = {"GME", "AMC", "BBBY"}
orders = ["AAPL", "GME", "MSFT", "AMC"]

allowed = [symbol for symbol in orders if symbol not in banned]
print(allowed)                       # ['AAPL', 'MSFT']

# Sets only keep hashable values
try:
    {["AAPL"]}
except TypeError as error:
    print("not hashable:", error)

L'arithmétique des ensembles

Les ensembles se combinent comme en mathématiques. a | b est l'union (dans l'un ou l'autre), a & b l'intersection (dans les deux), a - b la différence (dans a mais pas dans b) et a ^ b la différence symétrique (dans un seul). Chacune existe aussi comme méthode, par exemple a.union(b), qui accepte n'importe quel itérable. Toutes renvoient un nouvel ensemble et laissent a et b intacts. C'est exactement ce qu'il faut pour comparer deux univers de symboles ou deux listes de positions.

# Comparing yesterday's and today's universe
yesterday = {"AAPL", "MSFT", "GOOG", "IBM"}
today = {"AAPL", "MSFT", "TSLA"}

print(sorted(yesterday | today))   # ['AAPL', 'GOOG', 'IBM', 'MSFT', 'TSLA']
print(sorted(yesterday & today))   # ['AAPL', 'MSFT']
print(sorted(today - yesterday))   # ['TSLA']   (new listings)
print(sorted(yesterday - today))   # ['GOOG', 'IBM']   (dropped)
print(sorted(yesterday ^ today))   # ['GOOG', 'IBM', 'TSLA']

Modifier un ensemble et garder l'ordre

add(x) insère une valeur, update(items) en insère plusieurs, discard(x) retire une valeur si elle est présente (sans bruit), et remove(x) la retire mais lève KeyError si elle est absente. Un ensemble oublie l'ordre : quand l'ordre compte, il faut une liste. sorted(some_set) donne une liste triée, et pour supprimer les doublons en gardant l'ordre de première apparition, parcourez les valeurs en mémorisant dans un ensemble ce que vous avez déjà vu (seen). Ce test est rapide parce que c'est un ensemble.

# Remove repeats and keep the first-seen order
symbols = ["MSFT", "AAPL", "MSFT", "GOOG", "AAPL"]
seen = set()
ordered = []
for symbol in symbols:
    if symbol not in seen:
        seen.add(symbol)
        ordered.append(symbol)
print(ordered)             # ['MSFT', 'AAPL', 'GOOG']

# discard is quiet, remove is strict
seen.discard("TSLA")
try:
    seen.remove("TSLA")
except KeyError:
    print("TSLA was not in the set")

• set(items) : garder chaque valeur une fois ; len(set(items)) compte les valeurs distinctes.
• x in s est rapide ; a | b, a & b, a - b, a ^ b construisent de nouveaux ensembles.
• Les ensembles n'ont pas d'ordre : utilisez sorted(s) quand il faut une liste.

À suivre : lire et écrire des fichiers texte, pour que vos programmes conservent des données d'une exécution à l'autre.

Lab : ce qui est noté

• Compter les symboles différents avec distinct_count25 pts
• Repérer les symboles apparus avec new_listings25 pts
• Trouver le recoupement de deux portefeuilles avec common_symbols25 pts
• Supprimer les doublons en gardant l'ordre avec dedupe_keep_order25 pts