Python : listes, tuples, chaînes et dictionnaires

L = [1, 2, 3]
N = L[:]
print(L == N, L is N)

L = [1, 2, 3]
M = L
M.append(4)
print(L, M, L is M)

L = [3, 1, 4, 1, 5]
print(len(L), L[0], L[4], L[-1], L[-5])

L = [3, 1, 4, 1, 5]
print(L[1:4])
print(L[:2], L[3:], L[:])
print(L[::2], L[::-1])
print(L[2:100])

L = [3, 1, 4]
L.append(1)
L.insert(1, 9)
x = L.pop()
print(L, x)
print(L.append(7))
print(L)

L = [3, 1, 2]
L2 = sorted(L)
print(L, L2)

carres = [k * k for k in range(1, 6)]
multiples = [k for k in range(20) if k % 3 == 0]
print(carres)
print(multiples)

def carres_des_pairs(L):
    """L est une liste d'entiers. Renvoie la liste des carrés de ses éléments pairs,
    dans leur ordre d'apparition."""
    resultat = []
    for x in L:
        if x % 2 == 0:
            resultat.append(x * x)
    return resultat


def carres_des_pairs_bis(L):
    """Même spécification, écrite en compréhension."""
    return [x * x for x in L if x % 2 == 0]

L = [3, 4, 7, 10, 1]
print(carres_des_pairs(L), carres_des_pairs_bis(L))
print(carres_des_pairs(L) == carres_des_pairs_bis(L))

L = [1, 2, 3]
M = L
M.append(4)
print(L, M, L is M)
N = L[:]
N.append(5)
print(L, N, L is N, L == N)

M = [[1, 2], [3, 4]]
superficielle = M[:]
superficielle[0][0] = 99
print(M)
profonde = [ligne[:] for ligne in M]
profonde[1][1] = 77
print(M, profonde)

def copie_matrice(M):
    """M est une liste de listes. Renvoie une nouvelle matrice de mêmes coefficients,
    dont aucune ligne n'est partagée avec M."""
    return [ligne[:] for ligne in M]

M = [[1, 2], [3, 4]]
N = copie_matrice(M)
N[0][0] = 99
print(M, N)
mauvaise = M[:]
mauvaise[0][0] = 55
print(M, mauvaise)

def ajouter_zero(L):
    """Ajoute un 0 à la fin de la liste L. Modifie L en place et ne renvoie rien."""
    L.append(0)


def avec_zero(L):
    """Renvoie une nouvelle liste : les éléments de L suivis d'un 0. Ne modifie pas L."""
    return L + [0]


donnees = [1, 2]
ajouter_zero(donnees)
print(donnees)
autre = avec_zero(donnees)
print(donnees, autre)

def inverser_en_place(L):
    """Renverse l'ordre des éléments de la liste L. Modifie L et renvoie None."""
    n = len(L)
    for i in range(n // 2):
        L[i], L[n - 1 - i] = L[n - 1 - i], L[i]


def inverse(L):
    """Renvoie une nouvelle liste contenant les éléments de L dans l'ordre inverse.
    Ne modifie pas L."""
    return L[::-1]

L = [1, 2, 3, 4]
print(inverser_en_place(L), L)
M = [1, 2, 3, 4]
print(inverse(M), M)

L = [1, 2, 2, 3, 2]
for x in L:
    if x == 2:
        L.remove(x)
print(L)

L = [1, 2, 2, 3, 2]
L = [x for x in L if x != 2]
print(L)

notes = [12, 8, 17]
noms = ["Ada", "Blaise", "Camille"]
for i, note in enumerate(notes):
    print(i, note)
for nom, note in zip(noms, notes):
    print(nom, note)
print(list(zip([1, 2, 3], ["a", "b"])))

def positions(L, x):
    """Renvoie la liste, par indices croissants, des i tels que L[i] soit égal à x."""
    indices = []
    for i, element in enumerate(L):
        if element == x:
            indices.append(i)
    return indices

print(positions([3, 1, 4, 1, 5], 1))
print(positions([3, 1, 4], 9))

eleves = [("Ada", 12), ("Blaise", 17), ("Camille", 12)]
print(sorted(eleves, key=lambda couple: couple[1]))
print(sorted(eleves, key=lambda couple: -couple[1]))
L = [3, 1, 2]
print(L.sort(), L)
print(sorted("craie"))

def classement(eleves):
    """eleves est une liste de couples (nom, note). Renvoie une nouvelle liste triée
    par note décroissante, et à note égale par ordre alphabétique des noms."""
    return sorted(eleves, key=lambda couple: (-couple[1], couple[0]))

eleves = [("Camille", 12), ("Blaise", 17), ("Ada", 12)]
print(classement(eleves))
print(eleves)

print(type((5)), type((5,)))

t = (3, 1, 4)
a, b, c = t
a, b = b, a
print(t, a, b, c, len(t), t[0])

s = "craie"
print(len(s), s[0], s[-1], s[1:4], s[::-1])
for lettre in "abc":
    print(lettre, end=" ")
print()

s = "craie"
s.upper()
print(s)
s = s.upper()
print(s)

s = "  Coup de craie  "
print(repr(s.strip()))
print(s.strip().split())
print("-".join(["a", "b", "c"]))
print(s.strip().lower(), s.count("c"), s.find("de"))
print(s.strip().replace("craie", "plume"))
print(len("abc"), "abc"[1], "abc"[::-1])

def initiales(phrase):
    """Renvoie la chaîne des premières lettres des mots de la phrase, en majuscules,
    séparées par des points et suivies d'un point. Les mots sont les morceaux séparés
    par des espaces."""
    lettres = []
    for mot in phrase.split():
        lettres.append(mot[0].upper())
    return ".".join(lettres) + "."

print(initiales("coup de craie"))
print(initiales("  travaux  diriges  "))
print(repr(initiales("")), repr(initiales("craie")))

effectifs = {"MPSI": 48, "PCSI": 44}
effectifs["PTSI"] = 32
effectifs["MPSI"] = effectifs["MPSI"] + 1
print(effectifs)
print("PCSI" in effectifs, "MP2I" in effectifs)
print(effectifs.get("MP2I", 0))
for classe, n in effectifs.items():
    print(classe, n)
print(list(effectifs.keys()), list(effectifs.values()))
del effectifs["PTSI"]
print(effectifs, len(effectifs))

effectifs = {"MPSI": 49, "PCSI": 44}
for classe in effectifs:
    print(classe, effectifs[classe])

effectifs = {"MPSI": 49, "PCSI": 44}
if "MP2I" in effectifs:
    print(effectifs["MP2I"])
print(effectifs.get("MP2I", 0))

distances = {}
distances[(0, 0)] = 0
distances[(1, 2)] = 5
print(distances, distances[(1, 2)])

A = {1, 2, 3, 3, 2}
B = set([3, 4, 5])
print(A, len(A))
print(A | B, A & B, A - B)
print(3 in A, A <= {1, 2, 3, 4})
A.add(10)
print(sorted(A))

def par_concatenation(n):
    L = []
    for k in range(n):
        L = L + [k]
    return L


def par_append(n):
    L = []
    for k in range(n):
        L.append(k)
    return L

def table_des_notes(eleves):
    """eleves est une liste de couples (nom, note). Renvoie le dictionnaire qui associe
    à chaque nom sa note. Si un nom figure deux fois, la dernière note l'emporte."""
    table = {}
    for nom, note in eleves:
        table[nom] = note
    return table

eleves = [("Ada", 12), ("Blaise", 17), ("Camille", 12)]
notes = table_des_notes(eleves)
print(notes["Blaise"], notes.get("Zoé", None), "Ada" in notes)

def mots_communs(mots_a, mots_b):
    """Renvoie la liste triée des mots présents à la fois dans mots_a et dans mots_b,
    sans répétition."""
    presents = set(mots_b)
    communs = set()
    for mot in mots_a:
        if mot in presents:
            communs.add(mot)
    return sorted(communs)

a = ["craie", "tableau", "craie", "eponge"]
b = ["eponge", "cahier", "craie"]
print(mots_communs(a, b))

n, p = 2, 3
M = [[0] * p for _ in range(n)]
M[0][2] = 7
print(M, len(M), len(M[0]))
for ligne in M:
    print(ligne)

M = [[0] * 3] * 2
M[0][0] = 1
print(M)

def transposee(M):
    """M est une matrice non vide, liste de n lignes de p coefficients chacune.
    Renvoie une nouvelle matrice à p lignes et n colonnes dont le coefficient
    d'indices (j, i) vaut celui d'indices (i, j) de M."""
    n = len(M)
    p = len(M[0])
    T = [[0] * n for _ in range(p)]
    for i in range(n):
        for j in range(p):
            T[j][i] = M[i][j]
    return T

M = [[1, 2, 3], [4, 5, 6]]
print(transposee(M))
print(transposee(transposee(M)) == M)

pile = []
pile.append("a")
pile.append("b")
print(pile.pop(), pile)

from collections import deque

file = deque()
file.append("a")
file.append("b")
print(file.popleft(), list(file))

def parenthesage_correct(s):
    """Renvoie True si les parenthèses de la chaîne s sont correctement appariées,
    False sinon. Les autres caractères sont ignorés."""
    pile = []
    for caractere in s:
        if caractere == "(":
            pile.append(caractere)
        elif caractere == ")":
            if pile == []:
                return False
            pile.pop()
    return pile == []

print(parenthesage_correct("(a(b)c)"))
print(parenthesage_correct("(()"))
print(parenthesage_correct(")("))