Feuille d’exercices 3

Feuille d’exercices 3#

Objectifs

  • Compléments sur les listes

  • Ensembles et dictionnaires

  • Mot-clefs all et any

Exercice 1 : listes par compréhension#

Question 1 : En utilisant une déclaration de liste par compréhension, écrire la liste des puissances de \(2\) comprises entre \(2^1\) et \(2^{20}\).

[ 2**i for i in range(1, 21) ]

[2,
 4,
 8,
 16,
 32,
 64,
 128,
 256,
 512,
 1024,
 2048,
 4096,
 8192,
 16384,
 32768,
 65536,
 131072,
 262144,
 524288,
 1048576]

Question 2 : En utilisant une déclaration de liste par compréhension, donner la liste des caractères de la chaîne « Université Paris 8 Vincennes Saint-Denis » qui ne sont pas des espaces.

chaine = "Université Paris 8 Vincennes Saint-Denis"
L = [ c for c in chaine if c != " " ]
print(L)

['U', 'n', 'i', 'v', 'e', 'r', 's', 'i', 't', 'é', 'P', 'a', 'r', 'i', 's', '8', 'V', 'i', 'n', 'c', 'e', 'n', 'n', 'e', 's', 'S', 'a', 'i', 'n', 't', '-', 'D', 'e', 'n', 'i', 's']

Question 3 : En utilisant une déclaration de liste par compréhension, donner le nombre d’entiers compris entre \(1000\) et \(2000\), qui sont à la fois divisibles par \(2\) et \(7\).

L = [ i for i in range(1000, 2001) if (i % 2 == 0 and i % 7 == 0) ]
print(len(L))

71

Question 4 : En utilisant une déclaration de liste par compréhension, écrire une fonction diviseurs(n) qui retourne la liste des diviseurs d’un entier n.

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

D6 = diviseurs(6)
print(" Les diviseurs de 6 sont :", D6)

D48 = diviseurs(48)
print(" Les diviseurs de 48 sont :", D48)

 Les diviseurs de 6 sont : [1, 2, 3, 6]
 Les diviseurs de 48 sont : [1, 2, 3, 4, 6, 8, 12, 16, 24, 48]

Exercice 2 : mots-clefs any et all#

Un palindrome est un mot ou une phrase qui se lit identiquement dans les deux sens. Par exemple, les mots « radar », « kayak » ou « naan » sont des palindromes.

Question 1 : En utilisant le mot clef all, écrire une fonction est_palindrome(mot) qui teste si la chaîne de caractère mot est (ou non) un palindrome. Pour cela, on pourra utiliser le mot-clef all.

def est_palindrome(mot):
    n = len(mot)
    return all(mot[i] == mot[n-1-i] for i in range(n//2))

print(est_palindrome("radar"))
print(est_palindrome("palindrome"))

True
False

Question 2 : En utilisant le mot clef any, écrire une fonction contient_palindrome(L) qui prend en entrée une liste de chaînes de caractères L, et qui teste si au moins une de ces chaînes est un palindrome.

def contient_palindrome(L):
    return any( est_palindrome(x) for x in L)

print(contient_palindrome(["université", "paris", "8"]))
print(contient_palindrome(["saint", "denis"]))

True
False

Exercice 3 : ensembles#

Question 1 : Écrire une fonction caracteres(texte) qui prend en entrée une chaîne de caractères texte, et qui retourne l’ensemble des caractères de la chaîne.

def caracteres(texte):
    return { c for c in texte }

print(caracteres("texte"))
print(caracteres("aaaaaaaaaaaaaaaa"))

{'x', 't', 'e'}
{'a'}

Exercice 4 : dictionnaires#

Question 1 : Écrire une fonction compte_caracteres(texte) qui prend en entrée une chaîne de caractères texte, et qui retourne le dictionnaire ayant :

  • pour clés les caractères de la chaîne texte

  • pour valeur correspondant au caractère c, le nombre de fois que c apparaît dans texte.

Par exemple, pour la chaîne « calcul », on obtient le dictionnaire { 'c': 2, 'a': 1, 'l': 2, 'u': 1}.

def compte_caracteres(texte):
    D = {}
    for c in texte:
        if c in D:
            D[c] += 1
        else:
            D[c] = 1
    return D

print(compte_caracteres("calcul"))
print(compte_caracteres("aaaaaaaaaaaaaaaa"))

{'c': 2, 'a': 1, 'l': 2, 'u': 1}
{'a': 16}

Exercice 5 : somme de puissances#

Question 1 : Créer une fonction liste_puissances(n, p) qui prend en entrée deux paramètres paramètres n et p, et qui retourne la liste des entiers de la forme \(x^p\), pour \(x\) compris entre \(1\) et \(n\). Par exemple, pour \(n = 4\) et \(p = 3\), on obtient la liste [1, 8, 27, 64]. Votre fonction devra utiliser une déclaration de liste par compréhension.

def liste_puissances(n, p):
    return [ i**p for i in range(1, n+1) ]
    
liste_puissances(4, 3)

[1, 8, 27, 64]

Question 2 : Créer une fonction récursive somme_liste(L) qui retourne la somme des éléments d’une liste L. Si la liste L est vide, la fonction doit retourner \(0\).

def somme_liste(L):
    if L == []:
        return 0
    x = L.pop()
    return x + somme_liste(L)

Question 3 : À l’aide du mot-clef all et des questions précédentes, vérifier que l’identité

\[ \sum_{i=1}^n i^3 = \left(\sum_{i=1}^n i \right)^2 \]

est satisfaite pour les entiers \(n\) compris entre \(1\) et \(100\).

all(somme_liste(liste_puissances(n, 3)) == somme_liste(liste_puissances(n, 1))**2 for n in range(1, 101))

True

Exercice 6 : corriger des erreurs#

Question 1 : Dans la cellule suivante, une fonction a été écrite dnas le but d’inverser l’ordre des lettres d’un mot. Cette fonction contient plusieurs erreurs. Exécutez la cellule, puis observez ce qui est affiché. Essayez ensuite de corriger les erreurs pour obtenir le bon résultat.

def ma_fonction(mot)
    renverse = ""
    n = len(mot)
    for i in range(1, n):
        renverse = mot(i) + renverse
    return renverse

ma_fonction("calcul")

  Cell In[17], line 1
    def ma_fonction(mot)
                        ^
SyntaxError: expected ':'

Il y a trois erreurs :

  1. à la ligne 1, il manque un : à la déclaration de la fonction

  2. à la ligne 5, la syntaxe pour accéder à un caractère doit être avec des crochets (mot[i])

  3. enfin, le résultat est erroné car à la ligne 4, on ne parcourt pas le premier caractère du mot (pour i = 0).

def ma_fonction_corrigee(mot):
    renverse = ""
    n = len(mot)
    for i in range(0, n):
        renverse = mot[i] + renverse
    return renverse

ma_fonction_corrigee("calcul")

'luclac'

Exercice 7 : doublon dans les listes#

Question 1 : Écrire une fonction doublon(L) qui prend en entrée une liste L, et qui teste si la liste L contient au moins deux fois le même élément.

Une première version :

def doublon(L):
    n = len(L)
    for i in range(n):
        for j in range(n):
            if i != j and L[i] == L[j]:
                return True
    return False

print(doublon([1, 2, 5, 3, 0, 2]))
print(doublon([1, "a", 5, 3, 0, 2]))

True
False

Voici maintenant une version un peu plus efficace :

def doublon(L):
    n = len(L)
    for i in range(n):
        for j in range(i):
            if L[i] == L[j]:
                return True
    return False

print(doublon([1, 2, 5, 3, 0, 2]))
print(doublon([1, "a", 5, 3, 0, 2]))

True
False

Question 2 : Si ce n’est pas déjà fait, reprendre la question 1, en utilisant le mot-clef any, ainsi qu’une syntaxe par compréhension.

def doublon(L):
    n = len(L)
    return any( L[i] == L[j] for i in range(n) for j in range(i) )

print(doublon([1, 2, 5, 3, 0, 2]))
print(doublon([1, "a", 5, 3, 0, 2]))

True
False
Contenu