TP5 : Les fonctions

python

Exercice 1
1) Écrire une fonction Python listAleaInt(n, a, b) qui retourne une liste de n entiers aléatoires dans
[a .. b] en utilisant la fonction randint(a, b) du module random.
2) Dans le programme principal :
a. Construire une liste en appelant la fonction listAleaInt() ;
b. Déterminer l'index de la case qui contient le minimum ;
c. Echangez le premier élément du tableau avec son minimum.
Exercice 2
1) Ecrire une fonction Python appelé differences(L) qui prend en entré une liste L, de
réels, et qui retourne la liste M des différences successives des nombres de la liste L.

Exemple : L = [2,7,10,23,27] donne M = [5,3,13,4] : Le kième élément de M doit être la

différence entre (K+1)ième et kième éléments de L

2) Ecrire une fonction Python itere(L ,n) qui prend en entrée une liste L et un entier naturel
n et qui retourne le nième itéré de la fonction differences appliquée à L.

Exemple : si L est comme dans la question précédente, on a :

itere(L,0) = L,
itere(L ,1)=differences(L)=M et
itere(L,2)=differences(M)=[-2, 10 ,-9]

Exercice 3
On suppose qu’on dispose d’un texte constitué d’une longue chaine de caractères sans les
symboles de ponctuation.
Ecrire une fonction Python text_to_index(txt) prenant en entrée un texte txt et renvoyant un
dictionnaire indexé par les mots du texte et dont les valeurs sont les listes d’occurrences
correspondantes.
Exemple : txt : « ceci est un texte un exemple de texte », on doit obtenir le dictionnaire
suivant :
{ceci :[0],est : [1], un : [2 ,4], texte : [3,7], exemple : [5], de : [6]}

1/4
TP5 : Les fonctions

Exercice 4
Un polynôme de degré n de la forme a0+a1X+a2X2+a3X3+……..+anXn où an est non nul.
Les réels a0, a1,….. ,an sont les coefficients du polynôme. Le terme de degré K est akXk.
L’exposant du terme de degré le plus élevé donne le degré du polynôme (le coefficient de
ce terme est non nul)

Exemple : le polynôme 2X+6.2X2+3X5 est de degré 5.

Nous proposants de stocker un polynôme dans une liste contenant les coefficients en
ordre croissant des exposants : [a0 ,a1, …….,an]

Exemple : le polynôme 2X+6.2X2+3X5 sera stocké dans la liste [0,2,6.2,0,0,3].

Une liste représentant un polynôme doit contenir au moins une valeur, éventuellement
nulle (exemple : [0])

1. Ecrire une fonction Python polyvaleur(listpoly, x) prenant en paramètre une liste de

coefficients(listpoly) d’un polynôme P ainsi qu’une valeur numérique x et retourne
l’évaluation numérique du polynôme en x, càd la valeur numérique de P(x).

Exemple : l’appel polyvaleur ([1,0,2,3], 2) doit retourner 33

2. Ecrire une fonction Python polyaddition(listpoly1, listpoly2) prenant en

paramètres deux listes de coefficients correspondant à deux polynômes et retourne la
liste des coefficients du polynôme somme de listpoly1 et listpoly2

Exemple : print(polyaddition([1,2,5],[3,4]))

# résultat afficher : [4,6,5]

#P1=1+2X+5X^2 P2=3+4X P1+P2=4+6X+5X^2

3. Ecrire une fonction Python polyaffiche(listpoly) prenant en paramètre une liste de

coefficients d’un polynôme et retourne une chaine de caractère lisible facilement

Exemple : print(polyaffiche ([3,0,4,0,2]))

#3+4X^2+2X^4

Exercice 5
Un programme principal saisit une chaîne d'ADN valide et une séquence d'ADN valide
(valide signifie qu'elles ne sont pas vides et sont formées exclusivement d'une combinaison
arbitraire de "a", "t", "g" ou "c").

2/4
 TP5 : Les fonctions

1) Écrire une fonction valide qui renvoie vrai si la saisie est valide, faux sinon.

2) Écrire une fonction saisie qui effectue une saisie valide et renvoie la valeur saisie sous
forme d'une chaîne de caractères.

3) Écrire une fonction proportion qui reçoit deux arguments, la chaîne et la séquence et qui
retourne la proportion de séquence dans la chaîne (c'est-à-dire son nombre
d'occurrences).

4) Ecrire le programme principal qui appelle la fonction saisie pour la chaîne et pour la
séquence et affiche le résultat.

Exemple : d'affichage :
Chaine : attgcaatggtggtacatg
Séquence : ca
Il y a 2 ˝ca˝ dans votre chaine.

Exercice 6
Pour vérifier si une chaine de caractères est bien parenthésé ; c’est-à-dire qu’elle possédé
autant de parenthèses ouvrantes que de parenthèses fermantes et ceci dans le bon ordre, on
utilise une pile

N.B on désigne par le terme « parenthèse », une parenthèse, un crochet ou une accolade.

L’analyse de la chaine de caractères se fera caractère après caractère. On utilisera une pile
contenant les parenthèses ouvrantes.

Toute parenthèse fermante rencontrée doit être associée dans la pile à la parenthèse (qui doit
donc exister) ouvrante de même nature située au sommet de la pile.

Pour chaque caractère, de la chaine passer en argument, il Ya trois possibilités :

Le caractère n’est pas une parenthèse : dans ce cas, on ne fait rien et on traite
l’éventuel caractère suivant.

Le caractère est une parenthèse ouvrante : dans ce cas, la parenthèse ouvrante est
empilée dans la pile.

Le caractère est une parenthèse fermante, on doit vérifier :

• Que la pile des parenthèse ouvrantes est non vide.

• Que le sommet de la pile est une parenthèse ouvrante de même nature que la
parenthèse fermante rencontrée

Si ces deux conditions sont vérifiées, on dépile

3/4
 TP5 : Les fonctions
A la fin du parcours, il faut que la pile soit vide pour dire que l’expression est bien
parenthésée.

1) Ecrire une fonction parouverte (c) qui retourne True si « c » est une parenthèse ouverte et
False sinon

2) Ecrire une fonction parfermee(c) qui retourne True si « c » est une parenthèse fermante et
False sinon

3) Ecrire une fonction Parassocie(p) qui retourne pour une parenthèse fermante « p » la
parenthèse ouvrante qui lui est associé

4) Ecrire une fonction verifpar(c) qui affiche un message signalant si une chaine de
caractères est bien parenthésée

NB : pour les traitements des piles on demande d’utiliser les fonctions suivantes :

cree_pile_vide() ; Empiler(p,e) ; depiler(p,e) ; est_vide(p) ; sommet(p)

*****************************
def cree_pile_vide():
return []
*****************************
def taille(p):
return len p
*****************************
def est_vide(p):
return p==[]
***************************
def sommet(p):
return p[-1]
***********************
def depiler(p):
return p.pop()
*****************************
def empiler(p,v):
p.append(v) return p

4/4