Feuille 4 : Listes en compréhension

Exercice 1

Indiquer le contenu de la variable li suite à l’exécution du code suivante :

li = [x**2 for x in range(10) if x % 2 == 0]

Exercice 2

Réécrire les codes ci-dessous en utilisant des listes en compréhension :

multiples = []
for n in range(1,16):
    multiples.append(n*5)

pairs = []
for n in range(1, 21):
    if n % 2 == 0:
        pairs.append(n)

[n*5 for n in range(1, 16)]

[n for n in range(1, 21) if n % 5 == 0]

Exercice 3 : Liste de zéros

En utilisant les listes en compréhension, écrire la fonction liste_0(n:int) -> list qui prend un entier n en paramètre et renvoie une liste contenant n 0.

Exemple : liste_0(8) doit renvoyer [0, 0, 0, 0, 0, 0, 0, 0].

def liste_0(n:int) -> list:
    return [0 for _ in range(n)]

Exercice 4 : Uniquement les positifs

En utilisant les listes en compréhension, écrire d’une fonction qui prend une liste de nombres en paramètre et renvoie une liste ne contenant que les nombres strictement positifs de la première liste.

def liste_positifs(l:list) -> list:
    return [elt for elt in l if elt > 0]

Exercice 5 : Liste des lettres de l’alphabet

On rappelle que chr(65) renvoie "A".

En utilisant les listes en compréhension, écrire une fonction qui renvoie la liste des lettres de l’alphabet.

def alphabet() -> list:
    return [chr(i) for i in range(65,65+26)]

Exercice 6 : Nombres premiers

1) En utilisant les listes en compréhension, écrire une fonction qui prend un nombre entier en paramètre et renvoie la liste des diviseurs de ce nombre.

2) En utilisant la fonction précédente, écrire une fonction est_premier(n) qui prend un nombre entier en paramètre et renvoie True si ce nombre est premier et False dans le cas contraire.

3) Écrire une fonction qui prend un entier n en paramètre et renvoie la liste des nombres premiers de 1 à n.

def diviseurs(n:int) -> list:
    return [i for i in range(1, n+1) if n % i == 0]

def est_premier(n:int) -> bool:
    if len(diviseurs(n)) == 2:
        return True
    else:
        return False

def liste_premiers(n:int) -> list:
    liste = []
    for i in range(1, n+1):
        if est_premier(i):
            liste.append(i)
    return liste

Exercice 7 (*) : Éléments communs à deux listes

En utilisant les listes en compréhension, écrire une fonction qui prend deux listes en paramètres et renvoie la liste des éléments communs aux deux listes.

def communs(l1:list, l2:list) -> list:
    return [elt for elt in l1 if elt in l2]

Exercice 8 (*) : Liste en compréhension avec deux variables

On souhaite créer la variable nommée paquet32, de type list list, contenant les 32 cartes d’un jeu de cartes.

Une carte sera implémentée par une liste contenant sa valeur et sa couleur. Par exemple ["9", "♥"].

Les listes des couleurs et des valeurs sont données par les deux variables suivantes :

• t_valeurs = ["7", "8", "9", "10", "V", "D", "R", "A"].
• t_couleurs = [ "♠", "♣", "♥", "♦"]

En utilisant les listes en compréhension, écrire l'instruction qui permet de créer paquet32.

t_couleurs = [ "♠", "♣", "♥", "♦"]
t_valeurs = ["7", "8", "9", "10", "V", "D", "R", "A"]

paquet32 = [[couleur, valeur] for couleur in t_couleurs for valeur in t_valeurs]
print(paquet32)

Exercice 9 (*) : Liste de listes de zéros

En utilisant les listes en compréhension, écrire la fonction lili_0(n:int, m:int) -> list qui prend deux entiers n et m en paramètres et renvoie une liste de listes de taille n sur m contenant uniquement des 0.

Exemple : liste_0(4,2) doit renvoyer [[0, 0, 0, 0], [0, 0, 0, 0]].

def lili_0(n:int, m:int) -> list:
    return [[0 for _ in range(n)] for _ in range(m)]

print(lili_0(4, 2))