Le code Python utilisé pour définir vos fonctions doit obligatoirement se limiter à ce que l'on trouve dans le cours. Il est parfaitement interdit d'aller chercher des fonctions "magiques" ici ou là qui feront une partie du travail. Un tel code serait évalué par la note minimale. Savoir se servir de la documentation d'un langage, savoir utiliser les bibliothèques du langage sont des capacités à acquérir sur le long terme lorsqu'on apprend à programmer, mais ce n'est pas du tout l'objectif de ce début d'année: vous devez d'abord apprendre à maîtriser les instructions de base, à maîtriser le contenu du cours (ce qui est déjà un travail conséquent !)
Bien entendu, les fonctions de tests ne doivent pas renvoyer d'erreur d'assertion.
Et évidemment, il ne doit y avoir aucune erreur de syntaxe dans votre code !
Rappelons également que le code déjà écrit dans l'énoncé ne doit en aucun cas être modifié.
L'objectif (exercices 1 à 5) est ici de définir des fonctions prenant en paramètre une liste et renvoyant une sous-liste de cette liste (une sous-liste est une liste constituée de certains éléments de la liste initiale).
Définir un corps possible pour la fonction plus_de_voyelles prenant en entrée une chaîne de caractères (un mot) et renvoyant en sortie True si cette chaîne contient plus de voyelles (strictement) que de consonnes (et False sinon).
Pour simplifier la suite, on pourra supposer que les mots utilisés en entrée pour la fonction sont tous écrits avec les lettres de l'alphabet, minuscules, sans accent.
def test_plus_de_voyelles():
assert plus_de_voyelles('eau')
assert not plus_de_voyelles('canard')
assert plus_de_voyelles('oiseau')
def plus_de_voyelles(chaine):
"""
chaine: de type str (supposée écrite en minuscule, sans accent)
renvoie True si la chaîne contient plus de voyelles que de consonnes.
"""
voyelles = "aeiouy"
consonnes = "bcdfghjklmnpqrstvwxyz"
nb_voyelles = len([c for c in chaine if c in voyelles])
nb_consonnes = len([c for c in chaine if c in consonnes])
return nb_voyelles > nb_consonnes
test_plus_de_voyelles()
On suppose disposer de listes de mots (écrits en minuscules sans accent). Par exemple:
L = ['eau', 'oie', 'fondre', 'oui', 'aboya', 'informatique', 'oiseau', 'chanter']
Ecrire une fonction prenant en entrée une telle liste de mots liste_mots et renvoyant en sortie la sous-liste ne contenant que les mots de la liste d'entrée qui contiennent plus de voyelles que de consonnes. La liste de sortie sera créée en compréhension.
def test_filtre1():
assert filtre1(['eau', 'oie', 'fondre', 'oui', 'aboya', 'informatique', 'oiseau', 'chanter']) == ['eau', 'oie', 'oui', 'aboya','oiseau']
assert filtre1(['', 'gaz', 'foule']) == ['foule']
def filtre1(liste_mots):
"""
liste_mots: liste de chaînes de caractères.
renvoie une sous-liste de liste_mots, ne contenant que les chaînes ayant plus de voyelles que de consonnes.
"""
return [mot for mot in liste_mots if plus_de_voyelles(mot)]
test_filtre1()
Ecrire une fonction prenant en paramètre une chaîne de caractères (constituée ici encore uniquement de minuscules de l'alphabet, sans accent) et renvoyant True si la chaîne ne contient que des lettres distinctes (et False sinon).
def test_tous_distincts():
assert tous_distincts('calin')
assert not tous_distincts('bagarre') # False car présence de deux 'a'
assert tous_distincts('e')
assert tous_distincts('')
def plusdunefois(chaine,caractere):
"""
chaine: type str
caractere: type str, caractère
renvoie True si caractere est présent plus d'une fois dans chaine, False sinon
"""
dejavu = False
for carac in chaine:
if carac == caractere:
if not dejavu: # si on n'a pas encore vu le caractère avant carac
dejavu = True # on marque l'avoir vu
else: # sinon, on l'a déjà vu et il est donc présent plus d'une fois
return True
return False # cas de 0 ou 1 rencontre de caractere dans le parcours précédent
def tous_distincts(chaine):
"""
chaine: de type str (en minuscule, sans accent)
renvoie True si tous les caractères de chaine sont distincts deux à deux, renvoie False
si chaine contient au moins deux caractères égaux.
"""
for carac in chaine:
if plusdunefois(chaine,carac):
return False
return True
Une autre version:
def tous_distincts(chaine):
"""
chaine: de type str (en minuscule, sans accent)
renvoie True si tous les caractères de chaine sont distincts deux à deux, renvoie False
si chaine contient au moins deux caractères égaux.
"""
for i, c in enumerate(chaine):
for j in range(i+1, len(chaine)):
if chaine[j] == c:
return False
return True
Une autre version:
def tous_distincts(chaine):
caracteres_deja_vus = ""
for carakter in chaine:
if carakter in caracteres_deja_vus:
return False
else:
caracteres_deja_vus += carakter
return True
test_tous_distincts()
def test_filtre2():
assert filtre2(['hasard', 'chaos']) == ['chaos']
def filtre2(liste_mots):
"""
liste_mots: liste de chaînes de caractères.
renvoie une sous-liste de liste_mots, ne contenant que les chaînes ne contenant pas de caractère répété.
"""
return [mot for mot in liste_mots if tous_distincts(mot)]
test_filtre2()
Ecrire une fonction prenant en paramètre une liste de mots et renvoyant en sortie la sous-liste ne contenant que les mots de la liste initiale ne contenant pas la lettre 'e'.
def test_sans_e():
assert not sans_e('gabuzomeu')
assert sans_e('pataclic')
def sans_e(chaine):
"""
chaine: chaîne de caractères
renvoie True si la chaîne ne contient pas la lettre 'e'. Renvoie False sinon.
"""
for c in chaine:
if c == 'e':
return False
return True
Pythn permet la version plus brève suivante:
def sans_e(chaine):
"""
chaine: chaîne de caractères
renvoie True si la chaîne ne contient pas la lettre 'e'. Renvoie False sinon.
"""
return 'e' not in chaine
test_sans_e()
def test_filtre3():
assert filtre3(['casimir','bertrand']) == ['casimir']
def filtre3(liste_mots):
"""
liste_mots: liste de chaînes de caractères.
renvoie une sous-liste de listes_mots, ne contenant que les chaînes sans lettre 'e'.
"""
return [mot for mot in liste_mots if sans_e(mot)]
test_filtre3()
Ecrire le corps de la fonction inferieur_aux_suivants ci-dessous.
def test_inferieur_aux_suivants():
assert not inferieur_aux_suivants([7,8,5,9,12], 0)# False car l'élément tab[0] est plus grand que tab[2]
assert inferieur_aux_suivants([7,8,5,9,12], 2)#True car l'élément tab[2] est inférieur aux suivants
assert not inferieur_aux_suivants([10,9], 0)
assert inferieur_aux_suivants([10,9], 1)# True car il n'existe pas d'éléments < tab[1] après tab[1]
assert not inferieur_aux_suivants([9,9,10], 0)
assert inferieur_aux_suivants([9,9,10], 1)
def inferieur_aux_suivants(tab, k):
"""
tab: liste d'entiers
k: entier entre 0 et len(liste)-1
renvoie True si l'élément tab[k] est inférieur strictement à tous les éléments de tab qui
ont un indice supérieur à k (k+1, k+2, ...). Renvoie False s'il existe un élément d'indice > k
qui est inférieur ou égal à tab[k].
"""
reference = tab[k]
for indice in range(k+1, len(tab)):
if tab[indice] <= reference:
return False
return True
test_inferieur_aux_suivants()
Ecrire le corps de la fonction filtre4 spécifiée par sa chaîne de documentation ci-dessous.
def test_filtre4():
assert filtre4([2,3,1]) == [1]
assert filtre4([7,8,5,9,12]) == [5,9,12]
assert filtre4([9,9,10]) == [9,10]
assert filtre4([45, 46, 33, 72, 36, 88]) == [33, 36, 88]
def filtre4(tab):
"""
tab: liste d'entiers
renvoie la sous-liste des éléments qui sont inférieurs strictement à tous leurs suivants dans liste.
"""
return [x for i,x in enumerate(tab) if inferieur_aux_suivants(tab, i)]
test_filtre4()
Ecrire un corps pour la fonction est_triée ci-dessous.
def test_est_triée():
assert est_triée([2, 7, 9, 12])
assert not est_triée([2, 1, 9, 12])
assert not est_triée([2, 15, 9, 12])
assert est_triée([42])
def est_triée(tab):
"""
tab: liste d'entiers
renvoie True si les éléments de tab sont triés en ordre croissant, renvoie False sinon.
"""
for i in range(0,len(tab)-1):
if tab[i] > tab[i+1]:
return False
return True
test_est_triée()
def test_filtre5():
A = [[1,2,3],
[42, 33, 76],
[32, 33, 89, 90]]
B = [[1,2,3],
[32, 33, 89, 90]]
assert filtre5(A) == B
def filtre5(tab):
"""
tab: liste de listes d'entiers
renvoie une sous-liste de tab, ne contenant que les listes triées.
"""
return [liste for liste in tab if est_triée(liste)]
test_filtre5()
Dans cette question, vous créerez quelques listes en compréhension (sans création de fonction).
On dispose d'une liste films de tuples de la forme: (identifiant, nom de film, année de réalisation):
films = [(1, 'King Kong', 1933), (2, 'King Kong', 2005), (3, 'King Kong', 1976), (4, 'Total Recall', 2012),
(5, 'Total Recall', 1990), (6, 'Dune', 1984), (7, 'Dune', 2021), (8, 'La guerre des boutons', 1962),
(9, 'La guerre des boutons', 2011), (10, 'RoboCop', 1987), (11, 'RoboCop', 2014), (12, 'Les Misérables', 1982),
(13, 'Les Misérables', 1958)]
Remarque: ce que l'on appelle ici identifiant est simplement un numéro créé en créant la table, chaque numéro correspond à un et un seul film et permet donc d'identifier le film sans ambiguïté.
Lorsqu'on crée une base de données, on crée très souvent de tels identifiants car les attributs renseignés pour l'objet ne permettent souvent pas de le distinguer à coup sûr d'un autre (par exemple: deux films ont le même titre...).
La suite de ce commentaire, pour ceux qui continueront NSI, dans le cours de base de données de terminale.
Les tuples de la liste personnes : (identifiant, nom, prénom, année de naissance).
personnes = [(1, 'Cooper', 'Merian', 1893), (2, 'Schoedsack', 'Ernest', 1893), (3, 'Jackson', 'Peter', 1961),
(4, 'Guillermin', 'John', 1925), (5, 'Wiseman', 'Len', 1973), (6, 'Verhoeven', 'Paul', 1938),
(7, 'Lynch', 'David', 1946), (8, 'Villeneuve', 'Denis', 1967), (9, 'Robert', 'Yves', 1920),
(10, 'Samuel', 'Yann', 1965), (11, 'Padilha', 'José', 1967), (12, 'Hossein', 'Robert', 1927),
(13, 'Gabin', 'Jean', 1904), (14, 'Le Chanois', 'Jean-Paul', 1909), (15, 'Ventura', 'Lino', 1919),
(16, 'Bouquet', 'Michel', 1925), (17, 'Weller', 'Peter', 1947), (18, 'Ferrer', 'Miguel', 1955),
(19, 'Kinnaman','Joel', 1979), (20, 'Jackson', 'Samuel', 1948),
(21, 'Schwarzenegger', 'Arnold', 1947),
(22, 'Stone', 'Sharon', 1958), (23, 'Cox', 'Ronny', 1938), (24, 'Chalamet', 'Timothée', 1995),
(25, 'Ferguson', 'Rebecca' , 1983) , (26, 'von Sydow', 'Max', 1929) ,
(27, 'MacLachlan', 'Kyle', 1959)
]
Les tuples de la liste réalisation sont des couples (identifiant du film, identifiant de la personne réalisateur):
realisation = [(1, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 6),
(11, 11), (12,12), (13, 14),
]
Les tuples de la liste acteurs sont des couples (identifiant d'un film, identifiant d'une personne), signifiant que la personne joue un rôle dans le film.
acteurs = [(13, 13), (12, 15), (12, 16), (10, 17), (10, 18), (11, 19), (11, 20), (5,21),(5,22), (5,23), (10,23),
(7, 24), (7, 25), (6, 26), (6, 27)]
Créer la liste des films (sous la forme: liste des couples (nom du film, année de tournage) ) tournés après l'an 2000.
[(nom, année) for (_, nom, année) in films if année > 2000]
[('King Kong', 2005),
('Total Recall', 2012),
('Dune', 2021),
('La guerre des boutons', 2011),
('RoboCop', 2014)]
Créer la liste des acteurs (sous la forme (nom, prénom)) ayant joué dans un film nommé "Dune".
[(nom_pers, prénom) for (id_pers, nom_pers, prénom, année) in personnes
for (id_film, nom_film, _) in films
for (idf, idp) in acteurs
if id_film == idf and id_pers == idp
and nom_film == 'Dune'
]
[('Chalamet', 'Timothée'),
('Ferguson', 'Rebecca'),
('von Sydow', 'Max'),
('MacLachlan', 'Kyle')]
Créer la liste des couples (nom du film, date de réalisation) dans lesquels l'acteur Ronny Cox a un rôle.
[(nom_film, date_film) for (id_film, nom_film, date_film) in films
for (id_pers, nom_pers, prénom_pers, _) in personnes
for (idf, idp) in acteurs
if idf == id_film and idp == id_pers and (nom_pers, prénom_pers) == ('Cox', 'Ronny')
]
[('Total Recall', 1990), ('RoboCop', 1987)]