Examen Python 01

EXAMEN EN PYTHON

PANDACODEUR.COM

Examinateur : Mr JoëlYk  Durée : 2h00  Document et machines interdits.

Exercice 01 : Interprétation d’un Code Python 6pts

Pour chacun des programmes suivants, expliquez brièvement et indiquez quel message affiche chacun des codes :

CODE_A

def  foo(str1):

    dict = { }

    for n in str1:

        keys = dict.keys()

        if n in keys:

            dict[n] += 1

        else:

            dict[n] = 1

    return dict

print( foo('PANDACODEUR'))

Code_B

a = [50,80,3,50,80,2,3,3,50,200,1]

 

d = set()

u = [ ]

for x in a:

    if x not in d:

        u.append(x)

        d.add(x)

 

print(d)

 

Code_C

n=int(input("Input a number "))
d = dict()
 
for x in range(1,n+1):
    d[x]=x*x
 
print(d)

 

Code_D

for bisous in range(8):
    if bisous % 3 == 0 and bisous % 5 == 0:
        print("bisous")
        continue
    elif bisous % 3 == 0:
        print("zouzou")
        continue
    elif bisous % 5 == 0:
        print("zouzou")
        continue
    print(bisous)

           

Exercice 02 : Ecrire un Code en Python 4pts

  • Ecrire une fonction Python qui Déterminer si un nombre est un nombre Parfait ou pas. Principe : Un nombre égal à la somme de ses diviseurs propres est parfait. Exemple : 6 Est Parfait car en effet 1, 2 et 3 sont les diviseurs propres de 6 et la somme de 1+2+3 = 6. 2pts
  • Ecrire une fonction Paire_Impaire en Python qui détermine si un nombre est paire ou impaire. 2pts

Problème : Les Listes en Python 10pts

Une liste (souvent appelée tableau dans d’autres langages de programmation) est une séquence modifiable de données ordonnées. Cela signifie que chaque élément de la liste est associé à une position (un index). Le premier élément d’une liste possède l’index 0 et le dernier élément possède l’index n - 1 pour une liste contenant n éléments. Henzo étudiant du GROUPE GENIUS souhaite apprendre plus sur les listes et se livre répondre aux questions suivantes avec des propositions correctes aider Henzo dans la correction de cet exercice : (8 * 2pts)

  1.  Ecrire un programme Python qui définit une liste (nommée myList) contenant les valeurs {23,67,90,92,-1,3,4,89,400,7,-1,0,-2,23,50,3}, et qui effectue ensuite une boucle afin d’afficher les valeurs de cette liste.
  2. Ecrire une fonction nommée (dansListe) qui prend en argument une liste et une valeur et qui retourne 1 si la valeur est présente dans la liste, 0 sinon.
  3. Ecrire une fonction nommée (supEgaListe) qui prend en argument une liste et une valeur et qui retourne tous les éléments de la liste supérieures ou égaux a cette valeur.
  4. Ecrire une fonction nommée (maxListe) qui prend en argument une liste et qui retourne la valeur maximale de la liste.
  5. Ecrire une fonction nommée (indMaxListe) qui prend en argument une liste et qui retourne un indice de la liste contenant la valeur maximale de la liste.
  6. Ecrire une fonction nommée (inverseListe) qui prend en argument une liste et qui retourne une nouvelle liste contenant les mêmes éléments mais dans l’ordre inverse.
  7. Ecrire une fonction nommée (moyListe) qui prend en argument une liste et qui retourne la valeur moyenne de la liste.
  8. Soit la liste myList =[23,67,90,92,-1,3,4,89,400,7,-1,0,-2,23,50,3] donner le résultat pour :
  • print(myList[ : ])
  • print(myList[ -6: ])
  • print(myList[4:9])
  • print(myList[4:4])
  • print(myList[4:-12 ])
  • print(myList[1:14:3])

Correction :

Exercice 01 : Interprétation d’un Code Python

CODE_A

La fonction "foo" prend en argument une chaine de caractères "str1". Elle initialise un dictionnaire vide et itère sur chaque caractère de la chaine de caractères. Pour chaque caractère, elle vérifie si ce caractère est une clé dans le dictionnaire. Si oui, elle incrémente la valeur associée à cette clé, sinon elle ajoute une nouvelle clé avec la valeur 1. La fonction retourne le dictionnaire.

L'appel de la fonction "foo" avec l'argument 'PANDACODEUR' affiche le dictionnaire {'P': 1, 'A': 2, 'N': 1, 'D': 2, 'C': 1, 'O': 2, 'E': 1, 'U': 1, 'R': 1}.

CODE_B

Le code initialise une liste "a" contenant des entiers. Il initialise également un ensemble "d" et une liste vide "u". Le code itère sur chaque élément de la liste "a". Pour chaque élément, si cet élément n'est pas dans l'ensemble "d", alors il est ajouté à la liste "u" et à l'ensemble "d".

L'appel de la fonction print(d) affiche l'ensemble {1, 2, 3, 50, 80, 200}.

CODE_C

Le code demande à l'utilisateur d'entrer un nombre et stocke la valeur dans la variable "n". Ensuite, il initialise un dictionnaire vide "d". Le code itère sur chaque nombre de 1 à n inclus, et pour chaque nombre, il ajoute une nouvelle clé au dictionnaire avec la valeur du carré de ce nombre.

Lorsqu'on exécute ce code avec une entrée de 5, il affiche le dictionnaire {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}.

CODE_D

Le code itère sur les nombres de 0 à 7. Pour chaque nombre, il vérifie si le nombre est divisible par 3 et 5, divisible seulement par 3, divisible seulement par 5, ou ni par 3 ni par 5. Si le nombre est divisible par 3 et 5, il affiche "bisous". Si le nombre est divisible seulement par 3, il affiche "zouzou". Si le nombre est divisible seulement par 5, il affiche "zouzou". Si le nombre n'est divisible ni par 3 ni par 5, il affiche le nombre lui-même.

Lorsqu'on exécute ce code, il affiche : bisous 1 2 zouzou 4 zouzou zouzou 7

Exercice 02 : Solution

# Fonction pour déterminer si un nombre est parfait
def est_parfait(n):
    diviseurs = [i for i in range(1, n) if n % i == 0]  # Liste des diviseurs de n
    return sum(diviseurs) == n  # Renvoie True si la somme des diviseurs est égale à n, False sinon

# Fonction pour déterminer si un nombre est pair ou impair
def paire_impaire(n):
    if n % 2 == 0:
        return "pair"
    else:
        return "impair"

La première fonction est_parfait prend un nombre entier n en argument et renvoie True si ce nombre est parfait, c'est-à-dire si la somme de ses diviseurs propres est égale à n, et False sinon. Pour ce faire, on utilise une liste en compréhension pour générer la liste des diviseurs de n, en excluant n lui-même. Ensuite, on calcule la somme des diviseurs à l'aide de la fonction sum de Python, et on compare cette somme à n pour déterminer si le nombre est parfait ou non.

La deuxième fonction paire_impaire prend un nombre entier n en argument et renvoie la chaîne de caractères "pair" si n est pair, et "impair" sinon. On utilise ici l'opérateur modulo % qui permet de calculer le reste de la division euclidienne de n par 2. Si ce reste est égal à 0, alors n est pair, sinon il est impair. On retourne ensuite la chaîne de caractères correspondante.

Exercice 03 : Solution

1) Programme pour définir une liste et afficher ses valeurs :

myList = [23, 67, 90, 92, -1, 3, 4, 89, 400, 7, -1, 0, -2, 23, 50, 3]
for valeur in myList:
    print(valeur)

2) Fonction pour vérifier si une valeur est présente dans une liste :

def dansListe(liste, valeur):
    if valeur in liste:
        return 1
    else:
        return 0

3) Fonction pour retourner tous les éléments d'une liste supérieurs ou égaux à une valeur donnée :

def supEgaListe(liste, valeur):
    supEgaList = []
    for element in liste:
        if element >= valeur:
            supEgaList.append(element)
    return supEgaList

4) Fonction pour retourner la valeur maximale d'une liste :

def maxListe(liste):
    maxVal = liste[0]
    for element in liste:
        if element > maxVal:
            maxVal = element
    return maxVal

5) Fonction pour retourner l'indice de la valeur maximale d'une liste :

def indMaxListe(liste):
    maxVal = liste[0]
    indMax = 0
    for i in range(len(liste)):
        if liste[i] > maxVal:
            maxVal = liste[i]
            indMax = i
    return indMax

6) Fonction pour retourner une nouvelle liste contenant les mêmes éléments mais dans l'ordre inverse :

def inverseListe(liste):
    inverse = []
    for i in range(len(liste) - 1, -1, -1):
        inverse.append(liste[i])
    return inverse

7) Fonction pour retourner la valeur moyenne d'une liste :

def moyListe(liste):
    somme = 0
    for element in liste:
        somme += element
    moy = somme / len(liste)
    return moy

8) Résultats des instructions donnés sur la liste myList :

# Afficher toute la liste
print(myList[:]) # [23, 67, 90, 92, -1, 3, 4, 89, 400, 7, -1, 0, -2, 23, 50, 3]

# Afficher les 6 derniers éléments de la liste
print(myList[-6:]) # [0, -2, 23, 50, 3]

# Afficher les éléments de la liste allant de l'indice 4 à l'indice 9 (non inclus)
print(myList[4:9]) # [-1, 3, 4, 89, 400]

# Afficher une liste vide car les indices de début et de fin sont les mêmes
print(myList[4:4]) # []

# Afficher une liste vide car l'indice de fin est inférieur à l'indice de début
print(myList[4:-12]) # []

# Afficher tous les éléments de la liste en sautant 3 indices à chaque fois, en partant de l'indice 1

Le slicing avec l'expression myList[1:14:3] permet de récupérer une partie de la liste myList en utilisant une étape (step) de 3. Voici le détail :

1: c'est l'indice de départ pour le slicing, donc on commence à récupérer les éléments à partir de 67 (qui se trouve à l'indice 1).

14: c'est l'indice de fin pour le slicing, donc on arrête de récupérer les éléments juste avant l'indice 14 (qui correspond à la valeur 23).

3: c'est la taille de l'étape pour le slicing, donc on récupère les éléments tous les 3 indices.

Ainsi, myList[1:14:3] renvoie [67, -1, 89, -2].

1 vote. Moyenne 5 sur 5.

Ajouter un commentaire

Anti-spam