types containers

# on crée une liste avec des [ ]
homogene = [0, 12]
homogene

# on peut mélanger
# les types
heterogene = [2.3, "abc"]
heterogene

# des listes dans des listes
groupe = [True, homogene,
          "chaine", heterogene]
groupe

type(groupe)

groupe

# comme avec les chaines
# on peut accéder au i-ème élément
# les indices commencent à 0

# le premier élément est
# donc le booléen
groupe[0]

# on peut remplacer un élément
groupe[1] = '-'
groupe

# et le dernier
groupe[-1]

# est heterogene
groupe[-1] == heterogene

# le slicing s'applique aussi
# comme sur les chaines de caractère
groupe[::2] # du début à la fin avec un pas de 2

# on peut ajouter deux listes,
# ça les concatène
[1, 2, 3] + [4, 5, 6]

# la comparaison est
# lexicographique

[1, 2, 3] <= [1, 2, 4]

# l'opérateur d'appartenance
'chaine' in groupe

# et sa négation
'tutu' not in groupe

for item in groupe:
    print(item)

tutu = []

# on n'a pas encore vu le for
# mais vous pouvez deviner ce que ça fait
for c in 'abc':
    tutu.append(c)
    print(tutu)

# et à l'envers
while tutu:
    c = tutu.pop()
    print(c)

# ressemble à une liste, mais s'écrit avec des ()

paquet = (12, "abc")
paquet

# on ne peut plus y toucher
# paquet[0] = 15 n'est pas autorisé
# ni paquet.append(0)

# pour créer un ensemble
ensemble = {12, "abc"}
ensemble

# méthode add() pour ajouter
ensemble.add(True)
ensemble

# pas de doublon
ensemble.add("abc")
ensemble

# la recherche est rapide
# bien sûr, c'est surtout intéressant
# sur des grosses données

12 in ensemble

# on peut mettre un tuple dans un ensemble
ensemble.add((2, 3))
ensemble

# et pour enlever
ensemble.remove(12)
ensemble

for item in ensemble:
    print(item)

# la syntaxe pour créer
# un dictionnaire en clair
annuaire = {'alice': 25, 'bob': 32}

# les clés sont ici les 2 chaines
# 'alice', 'bob'

annuaire

# on ne peut plus accéder par indice
# annuaire[0] ne veut rien dire!

# par contre on peut accéder par clé
annuaire['bob']

# pareil pour écrire
# si la clé est inconnue on l'ajoute

annuaire['eve'] = 40
annuaire

# si la clé existe déjà
# on écrase la valeur associée
annuaire['alice'] = 50
annuaire

# pour effacer une clé  
del annuaire['eve']
annuaire

annuaire

# la recherche d'une clé est aussi rapide
# que la recherche dans les ensembles

'alice' in annuaire

# plutôt que de faire
a = 10
b = 20

print(f"a={a}, b={b}")

# on peut faire en Python
a, b = 10, 20

print(f"a={a}, b={b}")

# et ainsi on peut par exemple
# échanger deux variables
a, b = b, a

print(f"a={a}, b={b}")

for cle, valeur in annuaire.items():
    print(f"{cle} → {valeur}")

# en décomposant un peu pour bien comprendre
for couple in annuaire.items():
    cle, valeur = couple # on appelle cela de l'unpacking
    print(f"{cle} → {valeur}")

# parfois on a envie qu'une fonction puisse
# accepter un nombre variable d'arguments

def foo(fixe, *variable):
    """
    fixe reçoit le premier argument
    variable reçoit un tuple avec tous les autres arguments de l'appel
    """
    print(f"premier argument: {fixe}")
    print(f"les autres: {variable} - de type {type(variable)}")
    for item in variable:
        print(f"item {item}")

foo(1)

foo(1, 2)

foo(1, 2, 3)

# par exemple j'ai une liste
args = [1, 2, 3]

# et en fait je veux appeler
# foo(1, 2, 3)
#
# je pourrais faire
# foo(args[0], args[1], arg[2])
#
# mais bien sûr ça ne marchera
# que si args contient 3 objets

# dans ce cas on peut utiliser à nouveau
# l'étoile, et faire plutôt
foo(*args)

# vérifions que c'est bien
# ce qu'on voulait
foo(1, 2, 3)