Exercice Corrigé: Python Avancé – Partie 1

# Créer un tuple contenant les nombres de 1 à 7
nbrs = (1, 2, 3, 4, 5, 6, 7)

print("Liste originale: ", nbrs)

# Utilisez la fonction map pour appliquer une fonction lambda qui triple chaque élément de 'nbrs'.
res = map(lambda x: x + x + x, nbrs)

print("\nTriple de ces nombres sur la liste:")
print(list(res))

Sortie:

Liste originale: (1, 2, 3, 4, 5, 6, 7)

Triple de ces nombres sur la liste:
[3, 6, 9, 12, 15, 18, 21]

# Créer trois listes avec des éléments entiers.
nbrs1 = [1, 2, 3]
nbrs2 = [4, 5, 6]
nbrs3 = [7, 8, 9]

print("Liste originale:")
print(nbrs1)
print(nbrs2)
print(nbrs3)

# Utiliser la fonction map pour appliquer une fonction lambda
# qui ajoute les éléments correspondants à partir de
# nbrs1, nbrs2 et nbrs3 et créer une nouvelle liste
res = map(lambda x, y, z: x + y + z, nbrs1, nbrs2, nbrs3)

print("\nNouvelle liste après addition des 3 listes:")
print(list(res))

Sortie:

Liste originale:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

Nouvelle liste après addition des 3 listes:
[12, 15, 18]

# Create a list containing strings representing names
names = ['Alex', 'Bob', 'Ali']
	
print("Liste originale:")
print(names)

print("\nAprès l'opération, la liste des chaînes de caractères est:")

# Utiliser la fonction map pour appliquer la fonction list à chaque élément de 'names'.
res = list(map(list, names))

print(res)

Sortie:

Liste originale:
['Alex', 'Bob', 'Ali']

Après l'opération, la liste des chaînes de caractères est:
[['A', 'l', 'e', 'x'], ['B', 'o', 'b'], ['A', 'l', 'i']]

nbrs = [10, 20, 30, 40, 50]
index = [1, 2, 3, 4, 5]

print("Nombres de base et index:")
print(nbrs)
print(index)

print("\nPuissance exprimé en base correspondant à l'index:")

# Utiliser la fonction map pour appliquer la fonction pow aux paires d'éléments correspondants
# à partir de 'nbrs' et 'index' et créer une nouvelle liste de résultats
res = list(map(pow, nbrs, index))

print(res)

Sortie:

Nombres de base et index:
[10, 20, 30, 40, 50]
[1, 2, 3, 4, 5]

Puissance exprimé en base correspondant à l'index:
[10, 400, 27000, 2560000, 312500000]

def calculer_car(n):
    return n * n

nbrs = [2, 1, 3, 4]

print("Liste originale: ", nbrs)

# Utiliser la fonction map pour appliquer la fonction calculer_car à chaque élément de 'nbrs'.
res = map(calculer_car, nbrs)

print("Mettre au carré les éléments de cette liste:")

print(list(res))

Sortie:

Liste originale:  [2, 1, 3, 4]
Mettre au carré les éléments de cette liste:
[4, 1, 9, 16]

def change_cases(s):
    return str(s).upper(), str(s).lower()

# Créer un ensemble(set)
ch = {'a', 'B', 'a', 'a', 'C'}

print("Caractères originaux:\n", ch)

# Utilisez la fonction map pour appliquer la fonction change_cases à chaque caractère de 'ch'.
res = map(change_cases, ch)

print("\nAprès avoir converti les caractères en majuscules et minuscules et éliminé les lettres en double:")

# Affichez le résultat sous la forme d'un ensemble, en éliminant les lettres en double.
print(set(res))

Sortie:

Caractères originaux:
 {'C', 'B', 'a'}

Après avoir converti les caractères en majuscules et minuscules et éliminé les lettres en double:
{('C', 'c'), ('B', 'b'), ('A', 'a')}

def addition_soustraction(x, y):
    return x + y, x - y

nbrs1 = [3, 2, 5, 9]
nbrs2 = [0, 1, 2, 7]

print("Listes originales:")
print(nbrs1)
print(nbrs2)

# Utiliser la fonction map pour appliquer la fonction addition_soustraction 
# aux paires d'éléments correspondants à partir de 'nbrs1' et 'nbrs2'
# et créer une nouvelle liste de tuples contenant les résultats.
res = map(addition_soustraction, nbrs1, nbrs2)

print("\nRésultat:")

print(list(res))

Sortie:

Listes originales:
[3, 2, 5, 9]
[0, 1, 2, 7]

Résultat:
[(3, 3), (3, 1), (7, 3), (16, 2)]

my_list = [1, 2, 3, 4]
my_tuple = (5, 6, 7, 8)

print("Liste et tuple originaux:")
print(my_list)
print(my_tuple)

# Utilisez la fonction map pour convertir chaque élément de 'my_liste' en une chaîne de caractères et créer une nouvelle liste.
res_list = list(map(str, my_list))

# Utilisez la fonction map pour convertir chaque élément de 'my_tuple' en une chaîne de caractères et créer un nouveau tuple.
res_tuple = tuple(map(str, my_tuple))

print("\nListe des chaînes de caractères:")
print(res_list)

print("\nTuple des chaînes de caractères:")
print(res_tuple)

Sortie:

Liste et tuple originaux:
[1, 2, 3, 4]
(5, 6, 7, 8)

Liste des chaînes de caractères:
['1', '2', '3', '4']

Tuple des chaînes de caractères:
('5', '6', '7', '8')

# Importer la classe 'array' du module 'array'.
from array import array

def array_sum(nbrs):
    sum_n = 0
    # Parcourir chaque élément de 'nbrs' et l'ajouter à 'sum_n'.
    for n in nbrs:
        sum_n += n
    # Renvoie la somme des éléments du tableau
    return sum_n

# Créer un tableau nums de type 'i' (entier signé) avec les éléments spécifiés.
nums = array('i', [1, 2, 3, 4])

print("Tableau original:", nums)

# Convertir 'nums' en une liste et la stocker dans 'nbrs'.
nbrs = list(map(int, nums))

# Appeler la fonction 'array_sum' avec 'nbrs' comme argument et stocker le résultat dans 'result'
result = array_sum(nbrs)

print("Somme de tous les éléments du tableau:")
print(result)

Sortie:

Tableau original: array('i', [1, 2, 3, 4])
Somme de tous les éléments du tableau:
10

# Importer la fonction 'eq' du module 'operator'.
from operator import eq

def count_paire(nbrs1, nbrs2):
    # Utilisez la fonction 'map' avec 'eq' pour créer une liste de valeurs True/False pour les éléments correspondants dans 'nbrs1' et 'nbrs2'
    # Additionner les valeurs True pour obtenir le nombre de paires avec des éléments égaux
    result = sum(map(eq, nbrs1, nbrs2))
    return result
	
nbrs1 = [1, 2, 3, 4, 5]
nbrs2 = [1, 2, 3, 7, 6]

print("Listes originales:")
print(nbrs1)
print(nbrs2)

print("\nNombre de paires identiques est:")
print(count_paire(nbrs1, nbrs2))

Sortie:

Listes originales:
[1, 2, 3, 4, 5]
[1, 2, 3, 7, 6]

Nombre de paires identiques est:
3