QCM

Rappel

Les questions ci-dessous sont là pour vous aider à contrôler ce que vous avez retenu.
Si vous ne répondez pas à toutes les questions sans hésitation, c'est sans doute qu'il faut retravailler les pages précédentes.

Pour chaque question, il faut trouver la (ou les) bonne(s) réponse(s).

QCM 1

On utilise à nouveau le fichier personnes.csv.

On rappelle le contenu de ce fichier ci-dessous :

contenu du fichier

id_personne,nom,prenom,annee_naissance  
1,Labrosse,Adam,2000  
2,Gemlamorte,Adèle,1985  
3,Auboisdormant,Abel,2001  
4,Etpan,Ahmed,1975  
5,Térieur,Alain,1999  
6,Térieur,Alex,1976  
7,Proviste,Alain,2000  
8,Verse,Alain,1970    
9,Ception,Alex,2001  
10,Ainé,Ali,1975  
11,Gator,Ali,2001   
12,Bistraux,Alonzo,2001   
13,Patamob,Alphonse,1970   
14,Ficulté,Andy,1980   
15,Rectdustade,Andy,2000   
16,Verserre,Annie,2001  
17,Boréal,Aurore,1985  
18,Nor,Paul,1985  
19,Dejeu,Bernadette,2001  
20,Dajeun,Bruno,1984  
21,Hiple,Candice,2000

Le code ci-dessous :

from fonctions_csv import *

table_personnes = importe_csv('personnes.csv')

table_apres_2000 = [dico for dico in table_personnes if dico['annee_naissance'] > 2000]

# test
for dico in table_apres_2000:
    print(dico)

• est correct
• n'est pas correct

Réponse

• est correct
• n'est pas correct

On cherche à comparer les données dico['annee_naissance'], qui sont chargées en tant que chaîne de caractères, avec la valeur 2000 qui est un entier.
On obtient l'erreur:

TypeError: '>' not supported between instances of 'str' and 'int'

Il faut penser à convertir (transtyper) la donnée. Par exemple en utilisant la fonction attributs_entiers() du module fonctions_csv :

from fonctions_csv import *

table_personnes = importe_csv('personnes.csv')
attributs_entiers(table_personnes, ['annee_naissance'])

table_apres_2000 = [dico for dico in table_personnes if dico['annee_naissance'] > 2000]

# test
for dico in table_apres_2000:
    print(dico)

On obtient :

{'id_personne': '3', 'nom': 'Auboisdormant', 'prenom': 'Abel', 'annee_naissance': 2001}
{'id_personne': '9', 'nom': 'Ception', 'prenom': 'Alex', 'annee_naissance': 2001}
{'id_personne': '11', 'nom': 'Gator', 'prenom': 'Ali', 'annee_naissance': 2001}
{'id_personne': '12', 'nom': 'Bistraux', 'prenom': 'Alonzo', 'annee_naissance': 2001}
{'id_personne': '16', 'nom': 'Verserre', 'prenom': 'Annie', 'annee_naissance': 2001}
{'id_personne': '19', 'nom': 'Dejeu', 'prenom': 'Bernadette', 'annee_naissance': 2001}

QCM 2

On utilise le fichier villes.csv.

Avec le code suivant:

from fonctions_csv import *

table_villes = importe_csv('villes.csv')
attributs_entiers(table_villes, ['2016'])

tab = []
for ville in table_villes:
    if ville['2016'] > 90000 and ville['2016'] < 100000:
        tab.append(ville['Nom'])

# test
print(tab)

on obtient :

• une erreur
• ['Tourcoing ', 'Roubaix ', 'Nanterre ', 'Vitry-sur-Seine ', 'Avignon ']
• ['Paris ', 'Marseille ', 'Lyon ', 'Toulouse ', 'Nice ', 'Nantes ', 'Montpellier ', 'Strasbourg ', 'Bordeaux ', 'Lille19 ', 'Rennes ', 'Reims ', 'Saint-Étienne ', 'Le Havre ', 'Toulon ', 'Grenoble ', 'Dijon ', 'Angers ', 'Nîmes ', 'Villeurbanne ', 'Saint-Denis ', 'Aix-en-Provence ', 'Le Mans ', 'Clermont-Ferrand ', 'Brest ', 'Tours ', 'Amiens ', 'Limoges ', 'Annecy20 ', 'Perpignan ', 'Boulogne-Billancourt ', 'Metz ', 'Besançon ', 'Orléans ', 'Saint-Denis ', 'Argenteuil ', 'Rouen ', 'Mulhouse ', 'Montreuil ', 'Saint-Paul ', 'Caen ', 'Nancy ', 'Tourcoing ', 'Roubaix ', 'Nanterre ', 'Vitry-sur-Seine ', 'Avignon ', 'Créteil ', 'Dunkerque22 ', 'Poitiers ']
• [{'Nom': 'Tourcoing '}, {'Nom': 'Roubaix '}, {'Nom': 'Nanterre '}, {'Nom': 'Vitry-sur-Seine '}, {'Nom': 'Avignon '}]

Réponse

• une erreur
• ['Tourcoing ', 'Roubaix ', 'Nanterre ', 'Vitry-sur-Seine ', 'Avignon ']
• ['Paris ', 'Marseille ', 'Lyon ', 'Toulouse ', 'Nice ', 'Nantes ', 'Montpellier ', 'Strasbourg ', 'Bordeaux ', 'Lille19 ', 'Rennes ', 'Reims ', 'Saint-Étienne ', 'Le Havre ', 'Toulon ', 'Grenoble ', 'Dijon ', 'Angers ', 'Nîmes ', 'Villeurbanne ', 'Saint-Denis ', 'Aix-en-Provence ', 'Le Mans ', 'Clermont-Ferrand ', 'Brest ', 'Tours ', 'Amiens ', 'Limoges ', 'Annecy20 ', 'Perpignan ', 'Boulogne-Billancourt ', 'Metz ', 'Besançon ', 'Orléans ', 'Saint-Denis ', 'Argenteuil ', 'Rouen ', 'Mulhouse ', 'Montreuil ', 'Saint-Paul ', 'Caen ', 'Nancy ', 'Tourcoing ', 'Roubaix ', 'Nanterre ', 'Vitry-sur-Seine ', 'Avignon ', 'Créteil ', 'Dunkerque22 ', 'Poitiers ']
• [{'Nom': 'Tourcoing '}, {'Nom': 'Roubaix '}, {'Nom': 'Nanterre '}, {'Nom': 'Vitry-sur-Seine '}, {'Nom': 'Avignon '}]

QCM 3

On utilise à nouveau le fichier villes.csv.

Avec le code suivant:

from fonctions_csv import *

table_villes = importe_csv('villes.csv')
attributs_entiers(table_villes, ['1990', '1999', '2006', '2011', '2016'])

tab = []
for ville in table_villes:
    annees = [ville[an] for an in ('1990', '1999', '2006', '2011', '2016')]
    if max(annees) != int(ville['2016']):
        tab.append(ville['Nom'])


# test
print(tab)

on obtient:

• une erreur
• la ville ayant le plus grand nombre d'habitants en 2016
• les villes n'ayant pas leur plus grand nombre d'habitants en l'année 2016
• un tableau vide

Réponses

• une erreur
• la ville ayant le plus grand nombre d'habitants en 2016
• les villes n'ayant pas leur plus grand nombre d'habitants en l'année 2016
• un tableau vide

Le tableau obtenu :

['Paris ', 'Nice ', 'Reims ', 'Saint-Étienne ', 'Le Havre ', 'Angers ', 'Le Mans ', 'Brest ', 'Tours ', 'Amiens ', 'Limoges ', 'Metz ', 'Besançon ', 'Rouen ', 'Mulhouse ', 'Caen ', 'Nancy ', 'Roubaix ', 'Avignon ', 'Créteil ', 'Dunkerque22 ', 'Poitiers ']

Poitiers par exemple avait plus d'habitants en 2006 qu'en 2016 d'où sa présence dans la liste.

QCM 4

Avec le code:

def mystere(dico):
    return max(dico.values())-min(dico.values())


##----- Programme principal -----##
notes = [ {"C1": 8, "C2": 12, "C3": 9}, 
          {"C1": 2,"C2": 18,"C3": 15}, 
          {"C1": 14,"C2": 13,"C3": 17}, 
          {"C1": 10,"C2": 11,"C3": 12}
         ]

notes.sort(key=mystere)
print(notes)

on obtient:

• [{'C1': 8, 'C2': 12, 'C3': 9}, {'C1': 10, 'C2': 11, 'C3': 12}, {'C1': 14, 'C2': 13, 'C3': 17}, {'C1': 2, 'C2': 18, 'C3': 15}]
• [{'C1': 10, 'C2': 11, 'C3': 12}, {'C1': 8, 'C2': 12, 'C3': 9}, {'C1': 14, 'C2': 13, 'C3': 17}, {'C1': 2, 'C2': 18, 'C3': 15}]
• [{'C1': 10, 'C2': 11, 'C3': 12}, {'C1': 14, 'C2': 13, 'C3': 17}, {'C1': 8, 'C2': 12, 'C3': 9}, {'C1': 2, 'C2': 18, 'C3': 15}]
• [{'C1': 10, 'C2': 11, 'C3': 12}, {'C1': 8, 'C2': 12, 'C3': 9}, {'C1': 14, 'C2': 13, 'C3': 17}, {'C1': 2, 'C2': 18, 'C3': 15}]

Réponses

• [{'C1': 8, 'C2': 12, 'C3': 9}, {'C1': 10, 'C2': 11, 'C3': 12}, {'C1': 14, 'C2': 13, 'C3': 17}, {'C1': 2, 'C2': 18, 'C3': 15}]
• [{'C1': 10, 'C2': 11, 'C3': 12}, {'C1': 8, 'C2': 12, 'C3': 9}, {'C1': 14, 'C2': 13, 'C3': 17}, {'C1': 2, 'C2': 18, 'C3': 15}]
• [{'C1': 10, 'C2': 11, 'C3': 12}, {'C1': 14, 'C2': 13, 'C3': 17}, {'C1': 8, 'C2': 12, 'C3': 9}, {'C1': 2, 'C2': 18, 'C3': 15}]
• [{'C1': 10, 'C2': 11, 'C3': 12}, {'C1': 8, 'C2': 12, 'C3': 9}, {'C1': 14, 'C2': 13, 'C3': 17}, {'C1': 2, 'C2': 18, 'C3': 15}]

Le tri se fait suivant l'ordre croissant des amplitudes (différence entre la plus grande et la plus petite valeur).

On pourrait avoir un doute entre les propositions 3 et 4 car les deux tableaux centraux présentent la même amplitude. Rappelez vous que dans ce cas, Python conserve l'ordre initial des éléments.
Puisque le dictionnaire {"C1": 8, "C2": 12, "C3": 9} est avant {"C1": 14,"C2": 13,"C3": 17} dans le tableau initial, il reste avant dans le tableau final car le critère de tri choisi ne permettant pas de les ordonner.

QCM 5

A partir du code:

personnes = []
personnes.append({'Nom': 'Torvalds', 'Prénom': 'Linus', 'naissance':  1969})
personnes.append({'Nom': 'Gates', 'Prénom': 'Bill', 'naissance':   1955})
personnes.append({'Nom': 'Knuth', 'Prénom': 'Donald', 'naissance':   1938})
personnes.append({'Nom': 'Van Rossum', 'Prénom': 'Guido', 'naissance':   1956})
personnes.append({'Nom': 'Eich', 'Prénom': 'Brendan', 'naissance':   1961})
personnes.append({'Nom': 'Lerdorf', 'Prénom': 'Rasmus', 'naissance':   1968})
personnes.append({'Nom': 'Berners-Lee', 'Prénom': 'Tim', 'naissance':   1955})


realisation = []
realisation.append({'Nom': 'Torvalds', 'oeuvre': 'Linux'})
realisation.append({'Nom': 'Gates', 'oeuvre': 'Microsoft'})
realisation.append({'Nom': 'Knuth', 'oeuvre': 'TeX'})
realisation.append({'Nom': 'Eich', 'oeuvre': 'JavaScript'})
realisation.append({'Nom': 'Lerdorf', 'oeuvre': 'PHP'})
realisation.append({'Nom': 'Berners-Lee', 'oeuvre': 'HTML'})

on veut fabriquer le tableau « fusion » T suivant :

[{'nom': 'Torvalds', 'né en': 1969, 'père de': 'Linux'},  
{'nom': 'Gates', 'né en': 1955, 'père de': 'Microsoft'},  
{'nom': 'Knuth', 'né en': 1938, 'père de': 'TeX'},  
{'nom': 'Eich', 'né en': 1961, 'père de': 'JavaScript'},  
{'nom': 'Lerdorf', 'né en': 1968, 'père de': 'PHP'},  
{'nom': 'Berners-Lee', 'né en': 1955, 'père de': 'HTML'}]

Parmi les programmes suivants, lesquels conviennent ?

• def fusion(individu, realise):
      return {'nom': individu['Nom'], 
              'né en': individu['naissance'], 
              'père de': realise['oeuvre']}
  
  
  ##----- Programme principal -----##
  T = [ fusion(p, r)  for p in personnes 
                      for r in realisation if p['Nom'] == r['Nom'] ]
  

• def fusion(individu, realise):
      return {'nom': individu['Nom'], 
              'né en': individu['naissance'], 
              'père de': realisation['oeuvre']}
  
  
  ##----- Programme principal -----##
  T = [ fusion(p, r)  for p in personnes 
                      for r in realisation if p['Nom'] == r['Nom'] ]
  

• def fusion(individu, realise):
      return {'nom': individu['Nom'], 
              'né en': individu['naissance'], 
              'père de': realise['oeuvre']}
  
  
  ##----- Programme principal -----##
  T = [ fusion(p, r)  for p in personnes 
                      for r in realisation if personnes['Nom'] == realisation['Nom'] ]
  

• def fusion():
      tab = []
      for p in personnes:
          for r in realisation:
              if p['Nom'] == r['Nom']:
                  tab.append({  'nom': p['Nom'], 
                                  'né en': p['naissance'], 
                                  'père de': r['oeuvre']})
      return tab
  
  
  ##----- Programme principal -----##
  T = fusion()
  

Réponse

• def fusion(individu, realise):
      return {'nom': individu['Nom'], 
              'né en': individu['naissance'], 
              'père de': realise['oeuvre']}
  
  
  ##----- Programme principal -----##
  T = [ fusion(p, r)  for p in personnes 
                      for r in realisation if p['Nom'] == r['Nom'] ]
  

• def fusion(individu, realise):
      return {'nom': individu['Nom'], 
              'né en': individu['naissance'], 
              'père de': realisation['oeuvre']}
  
  
  ##----- Programme principal -----##
  T = [ fusion(p, r)  for p in personnes 
                      for r in realisation if p['Nom'] == r['Nom'] ]
  

• def fusion(individu, realise):
      return {'nom': individu['Nom'], 
              'né en': individu['naissance'], 
              'père de': realise['oeuvre']}
  
  
  ##----- Programme principal -----##
  T = [ fusion(p, r)  for p in personnes 
                      for r in realisation if personnes['Nom'] == realisation['Nom'] ]
  

• def fusion():
      tab = []
      for p in personnes:
          for r in realisation:
              if p['Nom'] == r['Nom']:
                  tab.append({  'nom': p['Nom'], 
                                  'né en': p['naissance'], 
                                  'père de': r['oeuvre']})
      return tab
  
  
  ##----- Programme principal -----##
  T = fusion()