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):
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.
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):
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')
def tous_distincts(chaine):
test_tous_distincts()
def test_filtre2():
def filtre2(liste_mots):
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'. Attention de bien découper la tâche en plusieurs fonctions, de bien penser également à écrire les fonctions de tests adéquates, et de renseigner les chaînes de documentation.
def test_filtre3():
def filtre3(liste_mots):
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(tab)-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].
"""
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 à leurs suivants dans liste.
"""
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 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.
"""
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.
"""
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)
siginifiant que la personne identifiée a réalisé le film:
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 réalisation) ) réalisés après l'an 2000.
Créer la liste des acteurs (sous la forme (nom, prénom)) ayant joué dans un film nommé "Dune".
Créer la liste des couples (nom du film, date de réalisation) dans lesquels l'acteur Ronny Cox a un rôle.