Codage et Représentation de l’information, année 2019

L’ensemble des scripts peuvent être téléchargés ici.

Rappel d’utilisation de Python

Dans la suite, tous les scripts sont à écrire avec un éditeur comme atom et à enregistrer dans un fichier avec une extension .py dans le répertoire TD6. Pour lancer votre script enregistré dans un fichier pgm.py exécutez la commande

python3 pgm.py

Boucles simples et chaînes de caractères

Boucle avec un accumulateur entier

Dans un fichier exo1.py ajoutez les lignes suivantes:

accu = 0
taille = 20
for i in range(taille):
    accu = accu + i
print("Résultat:", accu)

Indiquez dans le fichier réponses ce que fait ce programme.
Dans un fichier exo1b.py créez une fonction_exo1 qui prend en argument la variable taille exécute la boucle, et qui retourne la variable accu. Attention, elle ne doit pas contenir de print.
N’oubliez pas d’ajouter la documentation à votre fonction.
Ajoutez dans le script exo1b.py des exemples d’utilisation de votre fonction.

Corrections:

Le script exo1.py affiche la somme de tous les entiers entre 0 et 20.
On le modifie ainsi:

def fonction_exo1(taille):
    """
    Fonction qui retourne la sommes des entiers
    entre 0 et taille (non inclus). 

    Arguments: 
        taille (entier)

    Retournes: 
        un entier

    """
    accu = 0 # Initialisation de l'accumulateur
    for i in range(taille):
        accu = accu + i
    return accu

print(fonction_exo1(2))
# Affiche 1
print(fonction_exo1(20))
# Affiche 190
print(fonction_exo1(21))
# Affiche 210

Les exemples doivent effectivement avoir été testés.

Question 2

Rappel: la factorielle, notée n! est le produit des entiers de 1 à n. En vous aidant de la page wikipedia à propos des arrangements et combinaisons

Dans un fichier exo1c.py, répondez aux questions suivantes. (Dans aucune définition de ces fonctions, on ne doit trouver de d’appel à print.)

Écrire une fonction prod qui prend en argument deux nombres et calcule le produit des nombres entiers compris entre ces deux nombres. Afficher le résultat de prod pour 10 et 20, 5 et 120.
Écrire une fonction arrangements qui prend en argument deux nombres \(n\) et \(p\) et calcule le nombre d’arrangements de \(p\) éléments pris parmi \(n\). Afficher le résultat de arrangements pour 10 et 20, 5 et 120.
Écrire une fonction combinaisons qui prend en argument deux nombres \(n\) et \(p\) et calcule le nombre de combinaisons de \(p\) éléments pris parmi \(n\). Afficher le résultat de combinaisons pour 10 et 20, 5 et 120.

Corrections:

Il existe plusieurs manières d’écrire la fonction prod comme très souvent en programmation. Dans le fichier exo1c.py vous en trouverez deux.

Quelques point importants qu’il faut bien comprendre:

Il est possible d’utiliser une fonction dans la définition d’une autre fonction (prod est utilisé par arrangements qui est utilisé par combinaisons).

La division de deux nombres s’écrit nombre1/nombre2 et retourne un nombre qui n’est pas forcément un entier. Il est possible d’utiliser la division entière nombre1//nombre2 qui retourne le quotient de la division (c’est-à-dire l’arrondi).

3/5 # retourne 0.6
3//5 # retoune 0
10//2 # retourne 5
10/2 # retourne 5.0 (i.e. 5 mais de type float)

Une utilisation de la fonction combinaisons peut être trouvé dans le fichier pascal.py. Essayez donc de l’exécuter. Vous trouverez des explications supplémentaires en regardant la page Wikipédia ici.

Chaînes de caractères

Dans un fichier exo2.py ajoutez les lignes suivantes:

lettres = "abcdefghijklmnopqrstuvwxyz"
print(lettres)
print(lettres+lettres)
print(lettres[10])
print(lettres[3])
print(lettres[-4])
print(lettres[:10])
print(lettres[3:12])
print(lettres[-10:])
print(lettres[-20:-10])

En vous aidant éventuellement d’Internet, proposez une explication sur le fonctionnement de l’opérateur [..].

Dans le fichier exo2b.py, écrire une fonction plus_court qui prend en argument une chaîne de caractères et qui retourne une version raccourcie contenant uniquement les six caractères de début, de fin et “…” au milieu.

Par exemple, plus_court(lettres) doit retourner "abcdef...uvwxyz".

N’oubliez pas d’ajouter une documentation. Illustrez le bon fonctionnement sur quelques exemples (abracadabrantesquement et d’exemples de votre choix).

Corrections:

L’opérateur [..] (slice en anglais) agit sur des chaînes de caractères pour en extraire soit un morceau en fonction des indices. L’indice signifie ici le numéro qui indique la position dans la chaîne. La première position commence au numéro 0. Par exemple, lettres[3:12] affiche les lettres entre la 4ème lettre (d) et la 13ème lettre (l) de la chaîne (la suite des lettres de l’alphabet dans cet exemple). Lorsqu’on utilise un nombre négatif, l’indice considéré est compté en partant de la fin. Par exemple lettres[-10] est la 10ème lettre de l’alphabet en partant de la fin (q).

La fonction plus_court est très facilement réalisable avec une simple utilisation de la concaténation (+) et de l’opérateur [..] (slice).

def plus_court(chaine):
    """
    Fonction qui n'affiche que le début et 
    la fin de la chaîne de caractères passée en argument. 
    
    Arguments:
        chaine (str)

    Retourne:
        Une chaine de caractères


    """
    return chaine[:6]+"..."+chaine[-6:]
print(plus_court("Python est un langage de haut niveau"))
# retourne "Python...niveau"

Chaînes de caractères et boucles

Ajoutez dans un fichier exo3.py les lignes suivantes

cocotte_minute = "Le python est un langage de programmation de haut niveau"
oeuf = len(cocotte_minutes)
poelle_a_frire = ""
for pilon_de_poulet in range(oeuf): 
    if pilon_de_poulet % 2 == 0:
        poelle_a_frire = poelle_a_frire + cocotte_minute[pilon_de_poulet]
print(poelle_a_frire)

Indiquez les variables qui apparaissent dans ces lignes ainsi que leur type.
Proposez une explication sur ce que fait ce programme dans le fichier réponses.

Dans un fichier exo3b.py modifier le nom des variables pour que leur nom illustre mieux leur rôle dans le programme.

Écrire une fonction dans un fichier exo3c.py un_sur_deux qui prend en argument une chaîne de caractères et qui retourne une chaîne de caractères qui ne contient qu’un caractère sur deux de l’argument.

Par exemple, un_sur_deux("Coucou") doit retourner la chaîne de caractère "Cuo".

Vérifier à l’aide d’exemples dans exo3c.py que la fonction réalise bien ce qui est spécifié.

Correction:

Variable qui apparaissent dans le programme exo3.py:

cocotte_minute de type str
oeuf de type int
poelle_a_frire de type str
pilon_de_poulet de type int

Ce programme n’affiche qu’un caractère sur deux de la chaîne de caractère présente dans cocotte_minute

On propose de renommer les variables ainsi (mais beaucoup d’autres propositions seraient tout aussi correctes):

chaine = "Le python est un langage de programmation de haut niveau"
longueur_chaine  = len(chaine)
accumulateur = ""
for position in range(longueur_chaine): 
    if position % 2 == 0:
        accumulateur = accumulateur + chaine[position]
print(accumulateur)

Un étudiant attentif aura remarqué que la fonction un_sur_deux doit juste réutiliser le code ci-dessus en l’encapsulant dans une fonction.

Cela donne donc:

def un_sur_deux(chaine): 
    """
    Fonction qui prend en argument une chaine de caractère 
    et retourne une chaine de caractère ayant un caractère sur deux 
    d'effacer par rapport à l'argument. 
    
    Arguments:
        chaine (str)

    Retourne:
        chaine (str)
    """
    longueur_chaine  = len(chaine)
    accumulateur = ""
    for position in range(longueur_chaine): 
        if position % 2 == 0:
            accumulateur = accumulateur + chaine[position]
    return accumulateur

print(un_sur_deux("Coucou"))
# Affiche "Cuo"
print(un_sur_deux("Python est un langage de haut niveau"))
# Affiche 'Pto s nlnaed atnva'

Une boucle avec un accumulateur str

Dans un fichier exo4.py ajoutez les lignes suivantes:

chaine = ""
taille = 20
for i in range(taille):
    chaine = chaine + " + " +str(i) 
print(chaine)

Comme pour l’exercice 1, créez dans un fichier exo4b.py une fonction fonction_exo4 qui prend en argument la variable taille et qui retourne la chaîne de caractères après la boucle. Ajoutez une documentation et des exemples d’utilisation de cette fonction.

Dans un fichier exo4c.py ajoutez les lignes:

from exo1c import fonction_exo1 
from exo2c import plus_court
from exo4b import fonction_exo4
print("Résultat de", plus_court(fonction_exo3(10)), "=", fonction_exo1(10))

Dans le fichier réponses:

Proposez une explication sur le rôle de la construction from ... import ....
Expliquez le fonctionnement de ce script.

Corrections:

def fonction_exo4(taille):
    """
        Fonction qui retourne la chaine de caractères
        "0 + 1 + *....* + n". 

        Arguments:
            taille (int)

        Retourne:
            chaine (str)

    """
    chaine = "0"
    for i in range(1, taille):
        chaine = chaine + " + " +str(i) 
    return chaine

print(fonction_exo4(3))
# retourne "0 + 1 + 2"
print(fonction_exo4(5))
# retourne "0 + 1 + 2 + 3 + 4"

La construction from ... import ... présente dans le fichier exo4c.py permet d’importer des fonctions définies dans un autre fichier. Cela évite d’avoir à ré-écrire une fonction à chaque fois qu’on souhaite l’utiliser.

Le script importe donc les fonctions plus_court, fonction_exo1 et fonction_exo4 et affiche le résultat de la somme des entiers entre 0 et 10 avec une description facilement compréhensible.

Attention: Les scripts des fichiers importés sont également exécutés

Un programme un peu compliqué

Téléchargez le fichier fable.py et exécutez le. Indiquez dans le fichier réponses ce que fait la fonction mystere.

Attention: On attend une réponse précise sur son fonctionnement et pas uniquement un commentaire sur ce qu’elle produit.

Corrections:

La fonction mystere affiche dans un premier temps tous les caractères de la chaîne en argument qui sont à des positions paires, puis tous les caractères qui sont à des positions impaires.

Compiled the: dim. 07 janv. 2024 23:18:52 CET