Introduction à Python
Python est un langage de programmation dont l'ambition est de proposer une syntaxe claire et peu rebutante tout en offrant des outils adaptés au traitement de problèmatiques diverses. Désormais Python est un langage très populaire, répandu et largement diffusé dans l'industrie, le monde universitaire et chez les pédagogues.
C'est un langage à la syntaxe simple :
- typé dynamiquement
- multiplateforme
- placé souslicence libre
- doté d'outils dehaut niveau
Le but de ce TD est de proposer un initiation à la programmation sous Python sans prérecquis particuliers (même pour des débutants en programmation). Les notions de programmation, ainsi que les particularités au langage Python seront introduites au fur et à mesure, ponctuées de mises en situation, et de cas pratiques. Les énonces bleus sont des exercices d'application direct. Les énoncés verts sont des exercices "fil rouge" sur lesquels on reviendra plusieurs fois dans le TD afin de produire un programme un peu plus complet.
IPrésentation de l'environnement Spyder
Nous utiliserons l'environnement de développement Spyder pour pratiquer la programmation Python.
Lancer Spyder (Sur le bureau, dossier Disciplinaire, ISN ou Math, Anaconda). La fenêtre qui s'ouvre est divisée en trois parties :
- La partie en bas à droite est la console : elle permet d'exécuter des commandes simples en Python, tenant généralement sur une ligne. C'est utile pour tester des petites parties indépendantes d'un programme.
- La partie en haut à droite est l'aide : n'hésitez pas à l'utiliser sur les commandes que nous allons découvrir. Si vous sélectionner dans Spyder un mot à la souris et que vous faites Ctrl+I une aide détaillée s'affichera.
- La partie la plus importante à gauche est l'éditeur de scripts : il permet d'écrire des programme complexes sur plusieurs lignes (contrairement à la console) et de les enregistrer. Lorsqu'on exécute un programme, le résultat s'affiche dans la console.
Commençons par découvrir la console. Vous pouvez exécuter quelques calculs pour vous familiariser avec son utilisation (valider avec Entrée). :
- 2+3
- 2.4*2
- 2**3
- 5/2
- 5//2 et 5%2 .
Chaque calcul s'écrit à côté d'un In et chaque résultat est affiché à côté d'un Out : c'est un dialogue.
En Python, la puissance est
**
et non pas
^
(qui correspond au 'ou exclusif').
Pour créer notre premier véritable programme en Python, il faudra créer un fichier premier_programme.py contenant des lignes de code en Python. Pour celà, dans la barre de menu :
- Vous pouvez écrire dans l'éditeur. Si il y a déjà un script ouvert : cliquez sur Fichier puis Nouveau Fichier. Un onglet s'ouvre : c'est ici que vous allez écrire votre programme.
- Ecrivez la ligne de code print ("Hello world !")
- Sauvegardez avec Fichier > Enregistrer sous ou avec le raccourci Ctrl+S et appelez le premier_programme.py
-
Exécutez le programme avec le bouton
, ou dans le menu Exécution ou avec le raccourci F5
- Observez le résultat sur la console.
print (message)
permet d'afficher un message dans la console. Il sera largement utilisé lorsque l'on "débugue" un programme.
IIVariables, Entrées et Sorties
1Variables
En programmation, on utilise des variables pour stocker temporairement des valeurs numériques :
Une variable associe un nom (l'identifiant) à une valeur. L'identifiant doit être unique.
De manière symbolique, on peut représenter une case nommée contenant une valeur. Ci-dessous la variable
a
a pour valeur
12
et la variable
b
a pour valeur la chaîne de caractères
"bonjour"
.
Donner une valeur à une variable s'appelle "affecter une variable". En Python, l'affectation s'écrit naturellement :
nom_de_la_variable = valeur
Attention, Python est sensible à la casse, c'est à dire qu'il fait la différence entre majuscule et minuscule. Par exemple les variables
a
et
A
sont différentes.
- Dans la console, affectez la valeur 5 à la variable a , puis la chaîne "bonjour" à la variable b .
- Taper a+10 puis a à nouveau. La valeur de a change-t-elle ?
Attention, l’affectation remplace la valeur précédente de la variable par la nouvelle.
Dans un programme, on ne sait pas toujours quelles valeurs contiennent nos variables
a
et
b
. En agissant comme si vous ne connaissiez pas ces valeurs :
- Ecrivez une affectation permettant d'incrémenter la variable a .
- Ecrivez dans la console des affectations permettant d'échanger les valeurs des variables a et b .
- La valeur de a vaut a+1 ...
- Pour ne pas perdre la valeur d'une variable, on peut toujours la "sauvegarder" temporairement dans une troisième variable
Le langage Python propose souvent des syntaxes abrégées rendant le code plus concis.
- Pour ajouter une valeur val à une variable a en Python on peut écrire a+=val .
- Pour effectuer plusieurs affectations en une seule ligne on peut aussi écrire a , b = valeur1 , valeur2
- Pour échanger les valeurs de deux variables, Python permet d'écrire a , b = b , a
2Entrées, Sorties
Un programme peut souvent avoir besoin de demander des informations à l'utilisateur qu'il traitera par la suite. Dans l'échange avec l'utilisateur, une information extérieure transmise au programme est une Entrée.
Pour demander une chaîne de caractère à l'utilisateur, il faut utiliser la fonction
input ()
. On peut donner en argument de cette fonction le message à afficher avant de rendre la main à l'utilisateur.
L'instruction suivante affichera le message "Quel est votre nom ?" puis stockera la chaîne de caractères donnée par l'utilisateur dans la variable
nom
:
nom=input ("Quel est votre nom ?")
Dans l'échange avec l'utilisateur, une information transmise par le programme est une Sortie.
On sait déjà que :
- pour afficher une chaîne de caractères dans la console il faut taper print ("un message très important") .
- pour afficher la valeur d'une variable var , il faut taper print (var) sans les guillemets.
- pour afficher plusieurs messages séparés par des espaces, il faut donner plusieurs arguments à la commande print (a, b, c, ...) (où a , b , c , etc. sont des variables ou chaînes de caractères).
On peut vérifier le fonctionnement de print () sur les exemples suivants :
a=12
b=3.14
c="bonjour"
print ("a")
print (a)
print ("la première variable vaut",a)
print ("la deuxième variable vaut",b)
print ("la troisième variable vaut",c)
print ("les trois variables valent",a,",",b,"et",c)
b=3.14
c="bonjour"
print ("a")
print (a)
print ("la première variable vaut",a)
print ("la deuxième variable vaut",b)
print ("la troisième variable vaut",c)
print ("les trois variables valent",a,",",b,"et",c)
Reprenez et modifiez le fichier premier_programme.py pour qu'il réalise les étapes suivantes :
- saluer l'utilisateur et lui demander son nom.
- afficher un message textuel répondant à l'utilisateur en l'appelant par son nom.
- Utiliser une fonction d'entrée input () et affecter son résultat à une variable nom .
- Afficher un message avec une commande de sortie print () prenant plusieurs arguments.
- Attention, l'age donné par le input est une chaîne de caractères "str", il faut la convertir en "int" avec int ()
IIITypes de variables
1Les types de base : int, float, bool, string et list
Les valeurs d'un programme en Python sont toutes "typées". C'est à dire qu'elles appartiennent à une classe particulière. Les cinq types de base sont :
- le type int qui désigne les entiers comme \(-2,0,5,\)etc.
- le type float qui désigne les nombres flottants comme \(3.14 , -2.5 ,\) etc.
- le type bool qui désigne les booléens, c'est à dire les valeurs de vérité True (vrai) et False (faux).
- le type string qui désigne les chaînes de caractère comme "Bonjour" , "Python est super !!!" ou "ドラゴンボール超" .
- le type list désigne les listes qui sont des objets pouvant en contenir d'autres comme [1,2,3] , [-1, True, 'du texte'] ou [[1,0],[0,1]] .
Attention, en informatique, un nombre à virgule s'écrit avec un point (comme chez les anglo-saxons).
Pour connaître le type d'une certaine valeur, vous pouvez utiliser l'instruction :
type (valeur)
Dans la console, utiliser type () pour vérifier les types de quelques valeurs :
- 2
- -3.1
- 2-3.1
- "Je s'appelle Groot"
- print ("hello")
- input ("Quel est votre âge ?")
- print () n'a aucune valeur, elle ne fait qu'afficher un texte. Pas de valeur, pas de type (ou plus exactement un type NoneType et une valeur None)
- input () considère la réponse de l'utilisateur comme une chaîne de caractère.
Les types peuvent sembler peu utile, mais parfois, oublier que chaque valeur a un type précis peut être source d'erreur et de confusion. Les profs de math disent souvent qu'on n'additionne pas tomates et des courgettes. Un informaticien dira plutôt qu'on additionne pas des int et des string.
Que se passe-t-il si on on additionne un int et un string ?
Reprenez et modifiez le fichier premier_programme.py pour qu'il réalise les étapes suivantes :
- saluer l'utilisateur et lui demander son nom.
- lui demander son âge.
- afficher un message textuel d'adressant à l'utilisateur par son nom et lui annonçant dans combien d'années il sera centenaire.
- Affecter l'age à renvoyé par l'utilisateur à une variable age .
- En cas de message d'erreur, demandez vous quel est le type de la variable age .
- Pensez à convertir la variable age en entier pour pouvoir faire une soustraction (avec la fonction int () ).
2Opérations sur les nombres entiers et flottants
Les principales opérations et fonctions concernant valeurs de type int et float sont compatibles :
- Les opérations arithmétique : addition + , soustraction - , multiplication * , division / et puissance ** .
- La division entière // et le reste par la division %
- La fonction int () peut transformer un nombre flottant en entier.
- La fonction float () peut transformer un nombre entier en flottant.
Que se passe-t'il si j'ajoute un entier et un flottant ? Une division entière entre deux flottant ?
Les types qu'accèptent ces opérations sont similaires aux notions d'ensembles de définition en mathématique. Dans l'analogie avec les ensembles, le type int peut être vu comme un "sous-ensemble" du type "float"...
Il est possible de comparer des entiers et des flottants à l'aide des opérations de comparaison :
- inférieur strict < , supérieur strict > , inférieur ou égal <= , supérieur ou égal >=
- égal == , différent !=
- Comparer quelques valeurs. Comment Python répond-il à ces comparaisons ?
- Un nombre flottant et un nombre entier peuvent-ils être considérés comme égaux ?
- Les opérateurs de comparaison peuvent-être vues commes fonctions à deux argument numériques à valeurs dans l'ensemble Bool = {True, False}
- Même si d'un point de vue formel 1 et 1.0 ne sont pas égaux (s'ils l'étaient la fonction type () donnerait le même résultat pour les deux), d'un point de vue pratique, cette largesse permet d'éviter certains écueils. Un programmeur qui souhaite créer un programme s'arrêtant lorsqu'une certaine valeur est nulle ne devrait pas à avoir à se demander si il s'agit d'un entier ou d'un flottant.
3Opérations sur les valeurs booléennes
Les valeurs de vérité True et False peuvent être combinées via les opérateurs logiques :
- Et : and .
- Ou : or .
- Ou exclusif : ^ .
- Vérifiez les opérations booléennes classiques dans la console (vrai ET vrai = vrai, faux OU vrai = vrai,...)
- Les opérations arithmétiques propres aux nombres fonctionnent-elles ? L'opération or et l'opération + sont-elles équivalentes ? Même question pour and et *
En fait, les booléens peuvent être vus comme une restriction des entiers 0 et 1. Cette largesse est encore une fois très pratique. Les opérations booléennes sont également compatibles avec les entiers et les flottants.
Les opérations de comparaisons sont également compatibles avec les booléens :
Tapez les commandes suivantes :
- 1==True
- (2 < 1)==False
- (True==False)==False
4Opérations sur les chaînes de caractères
Les chaînes de caractères sont assez différentes des types numériques précédents. Les manipulations utiles en pratique sur les chaînes sont les suivantes :
- Une valeur d'un des types précédent peut être transformé en chaîne de caractères : str (valeur) .
- mesurer la longueur : len (chaine) .
- concaténer deux chaînes : chaine1 + chaine2 .
- accéder au i-ème élément : chaine[i] .
- extraire la sous-chaîne du i-ème au j-ème caractère (exclu) : chaine[i:j] .
La chaîne de caractères vide est
""
ou
''
.
Taper dans la console :
c="Bonjour"
puis
a=30
- Que taper pour obtenir le premier caractère de c ?
- Que taper pour obtenir le dernier caractère de c (même si on change la valeur de c ) ?
- Que taper pour extraire la sous-chaîne commençant au 3ème caractère jusqu'à la fin ?
- Essayer de concaténer c et a . Quelle solution proposer ?
- L'indice du premier caractère est 0, et pas 1.
- L'indice du dernier caractère de c n'est pas len (c)
- Il est possible d'utiliser len (c) , mais on peut aussi taper c[3:]
- L'opération + ne fait pas la même chose pour les int et les string . Il faut convertir l'entier a en chaîne de caractères avec la fonction str (a) .
Il est possible de comparer des chaînes de caractères entre elles avec les opérations de comparaison
<
,
>
,
<=
,
>=
,
==
,
!=
.
- Comparez les chaînes de caractères Barry et Alvin avec <
- Comparez les chaînes de caractères Dupont et Dupond .
- Quel semble-être le critère de comparaison ?
Il s'agit simplement de l'ordre alphabétique. Les majuscules sont inférieures aux minuscules car les codes ascii sont comparés.
Si la valeur de
c
est la chaîne
"Bonjour"
, taper une seule commande permettant d'affecter à
a
le début de la chaîne jusqu'au 3ème caractère et dans
b
la fin de la chaîne.
Créer un nouveau fichier appelé second_degré.py. Ce fichier contiendra un programme qui :
- demandera à l'utilisateur d'entrer trois valeurs \(a\), \(b\) et \(c\) d'un polynôme du second degré \(a x^2 + b x + c\)
- calculera le discriminant
- informera l'utilisateur de la valeur du discriminant par une phrase.
En cas d'erreur dans votre programme, prenez bien le temps de lire les messages d'erreur avant d'aller voir les indices.
- Utiliser input () trois fois et stocker chaque résultat dans des variables a , b et c .
- Attention, les trois variables sont des chaînes de caractères. Il faut les convertir en nombres pour les utiliser dans un calcul.
- Stocker la valeur du discriminant dans une variable d
5Opérations sur les listes
Les listes sont des objets très similaires aux chaînes de caractères car elles sont suite d'objets indicés par des entiers commençant à 0. Elles peuvent contenir n'importe quel type d'objets (pas que des caractères contrairement aux chaînes), y compris des listes. Les manipulations utiles en pratique sur les listes sont les suivantes :
- compter le nombre d'éléments : len (chaine) .
- concaténer deux listes : L1 + L2 .
- accéder au i-ème élément : L[i] .
- extraire la sous-liste du i-ème au j-ème élément (exclu) : L[i:j] .
La liste vide est
[]
.
IVFonctions
Dans la partie précédente, nous avons vu des fonctions prédéfinies. Il est tout à fait possible de définir ses propres fonctions. L'intérêt est bien sûr de pouvoir les réutiliser en les appelant simplement par leur nom.
La syntaxe pour définir une fonction est la suivante :
def
mafonction
(arguments):
...étapes...
...encore des étapes...
return valeur_finale
où on a : ...étapes...
...encore des étapes...
return valeur_finale
- mafonction est le nom de la fonction
- arguments est la liste des arguments, c'est à dire des variables utilisées dans les étapes de calcul de la fonction
- valeur_finale est la variable que renverra la fonction lorsqu'elle sera appelée
Les espaces qui décalent chaque ligne de la fonction sont appelés indentations. Les programmeurs ont l'habitude d'indenter leur code pour le rendre plus lisible (avec la touche Tabulation). Python oblige le programmeur à indenter : si il ne le fait pas correctement une erreur sera générée. Dans le fichier Python, le code situé après la fonction n'est plus indenté.
Les fonctions peuvent avoir un, plusieurs ou aucun arguments et ne renvoie pas forcément une valeur :
La fonction suivante prend deux nombres entiers en arguments et retourne une liste de deux éléments formés du quotient et du reste par la division euclidienne :
def
division_euclidienne
(a, b):
q=a//b
r=a%b
return [q,r]
En exécutant le programme, la fonction est déclarée. Pour l'utiliser il faudra par exemple taper la commande
division_euclidienne (7,2)
qui renverra
[3,1]
.
q=a//b
r=a%b
return [q,r]
Une fonction, comme en math, ne peut pas renvoyer deux valeurs. Quand une fonction calcule plusieurs valeurs, elle peut les renvoyer à l'aide d'une liste comme dans l'exemple précédent.
La fonction suivante ne prend aucun argument et ne renvoie aucune valeur :
def
hello
():
print ("Hello !")
Pour déclarer et appeler une fonction sans argument, il faut tout de même mettre les parenthèses vides.
print ("Hello !")
Dans une fonction, on évite en général d'utiliser la fonction d'entrée
input ()
qui stoppe l'exécution. Reprendre le fichier second_degré.py et modifier de la manière suivante :
- Déclarer une fonction discriminant () qui prend trois argument correspondant aux coefficients d'un polynôme du second degré et renvoie la valeur de son discriminant
- Ne plus utiliser les fonctions input () et print () et tester la fonction discriminant () dans la console sur quelques exemples connus de polynômes.
Python est un langage de programmation permettant d'effectuer des traitement numériques, mais pas de calcul algébrique. Par exemple Python ne sait pas ce que sont les fractions, ni leurs règles de calcul. Nous allons ici créer des fonctions permettant de compenser cette lacune.
Créer un nouveau fichier fractions.py. Dans ce programme, nous représenterons une fractions \(\frac{a}{b}\) par une liste deux deux nombres [a,b] .
- Créer une fonction produit () prenant deux arguments f1 et f2 (représentant deux fractions \(\frac{a}{b}\) et \(\frac{c}{d}\) ) et renvoyant une liste représentant le produit des deux fractions \(\frac{a c}{b d}\).
- Créer une fonction quotient () prenant deux arguments f1 et f2 (représentant deux fractions et renvoyant une liste représentant leur quotient.
- Créer une fonction somme () prenant deux arguments f1 et f2 (représentant deux fractions et renvoyant une liste représentant leur somme.
- Créer une fonction difference () prenant deux arguments f1 et f2 (représentant deux fractions et renvoyant une liste représentant leur différence.
- Tester les fonctions créees sur des calculs tels que \(\frac{5}{2} (\frac{1}{2} + \frac{1}{3})\)
- Cette représentation présente quelques défauts. Lesquels ?
- Si L est une liste à deux éléments représentant une fraction \(\frac{a}{b}\), le numérateur est représenté par L[0] et le dénominateur par L[1] .
- Quelques défauts : un dénominateur nul est accepté, même s'il donne un résultat absurde. Les fractions ne sont pas toujours irréductibles. Un simple nombre en argument aurait un sens dans la plupart des cas, mais encore faut-il en tenir compte. etc.
VTests et conditions
Pour exécuter des instructions si une condition est remplie, la syntaxe est la suivante :
if condition :
instructions
On peut ajouter des instructions s'exécutant si la condition n'est pas remplie : instructions
if condition :
instructions1
else :
instructions2
Si il y a plus de deux cas : instructions1
else :
instructions2
if condition1:
instructions1
elif condition2:
instructions2
elif condition3:
instructions3
else:
instructions0
instructions1
elif condition2:
instructions2
elif condition3:
instructions3
else:
instructions0
Attention, l'indentation permet à Python de limiter le bloc conditionnel (avec la touche Tabulation). Si elle n'est pas respectée, il y aura des erreurs. Les ':' à la fin d'une condition sont obligatoires.
Le test suivant vérifie l'année :
if
a <= 2017:
print ("C'est du passé !")
else :
print ("C'est du futur !")
print ("C'est du passé !")
else :
print ("C'est du futur !")
La série de tests suivants permet de d'informer sur le tarif en fonction de l'âge :
if
age < 6:
prix = 0
elif age < 12:
prix = 10
elif age < 25:
prix = 20
elif age < 60:
prix = 40
else :
prix = 20
print ("Le prix vaut %i" % prix)
prix = 0
elif age < 12:
prix = 10
elif age < 25:
prix = 20
elif age < 60:
prix = 40
else :
prix = 20
print ("Le prix vaut %i" % prix)
L'opérateur ternaire permet de résumer un test en une seule ligne avec la syntaxe suivante :
La variable
var
prendre la valeur
valeur1
si la condition est satisfaite, et la valeur
valeur2
sinon.
var = condition ? valeur1 : valeur2
Les deux exemples suivant affectent à la variable
signe
les valeurs 1 ou -1 selon le signe de
n
:
if
n < 0:
signe = -1
else :
signe = 1
Plus simplement avec l'opérateur ternaire : signe = -1
else :
signe = 1
x = n < 0 ? -1 : 1
Nous allons modifier le fichier second_degré.py :
- créer une fonction racines () qui prend en arguments les coefficients a , b et c d'un polynôme du second degré et renvoie une liste contenant les racines réelles du polynôme.
-
créer une fonction factorise () qui prend en arguments les coefficients a , b et c d'un polynôme du second degré et renvoie une chaîne de caractères représentant la forme factorisée.
Par exemple, factorise (1,0,-1) doit renvoyer la chaîne de caractères "(x-1)(x+1)" et factorise (1,2,1) doit renvoyer la chaîne "(x+1)²" (l'afficher dans la console).
- Ces fonctions devront utiliser la fonction discriminant () .
- Penser à convertir les valeurs numériques avec str () pour les concaténer à une chaîne.
- Penser à différencier les cas où les racines sont positives ou négatives pour ajouter un signe '+' ou '-' si nécessaire
- La fonction valeur absolue est abs () .
- Coller une chaîne de caractères c2 à une autre c1 peut se faire avec c1=c1+c2 ou c1+=c2 .
Nous allons modifier le fichier fractions.py pour prendre en compte les fonctions déjà programmées soient compatibles avec des arguments numériques. Par exemple, on souhaite être capable de calculer la somme \(a + \frac{b}{c}\).
Tester les types des arguments de chaque fonction pour tenir compte des opération entre :
- une fraction et un nombre (entier ou flottant)
- un nombre (entier ou flottant) et une fraction
- deux fractions
- deux nombres
- Pour tester si une variable est de type entier, on peut utiliser la condition type (var)==type (1) ou code (isinstance (var, int)) (float, str, list, bool pour les autres types).
-
Si les arguments ne correspondent à aucun type prévu, vous pouvez toujours générer une erreur vous même comme ceci :
raise ValueError ("Message d'erreur bien détaillé")
Il serait également possible de tenir compte des dénominateurs nuls et de créer une erreur dans ce cas précis.
VIBoucles
1Boucle for
Pour faire parcourir à une variable
i
des valeurs entières depuis une valeur de départ, sur une certaine longueur et avec un certain pas, la syntaxe est la suivante :
for i in range (départ, longueur):
instructions
Pour définir un pas, il faut l'ajouter
range (départ, longueur, pas)
instructions
Pour sortir prématurément d'une boucle, il faut utiliser le mot
break
. Pour sauter une itération, il faut utiliser
continue
L'exemple basique suivant affiche tous les nombres pairs jusqu'à 100 :
for
i
in
range
(0,100,2):
print (i)
print (i)
Ecrire une suite d'instructions qui permet de calculer \(\sum_{k=0}^{100}{k}\).
- Initialiser une variable S à 0
- Dans une boucle faisant varier un indice k de 0 à 100, ajouter k à la variable S
La suite d'instructions suivantes part d'une liste
L
et la modifie à l'aide d'une boucle. Commenter ligne à ligne et déterminer l'objectif du programme.
N=
len
(L)
d=L[N-1]
for i in range (1,N):
L[i]=L[i-1]
L[0]=d
d=L[N-1]
for i in range (1,N):
L[i]=L[i-1]
L[0]=d
- N vaut la longueur de la liste L
- d reçoit la dernière valeur de la liste L
- Dans la boucle, du deuxième élément (i=1) au dernier (i=N), le i-ème élément de la liste est remplacé par son prédécesseur (L[i-1])
- A la sortie de la boucle, tous les éléments de la liste ont été remplacé par le prédécesseur sauf le premier élément (indice 0), qui reçoit donc l'ancien dernier élément d.
En Python, de la même manière, une boucle peut parcourir les éléments de n'importe quelle liste, ou de n'importe quelle chaîne de caractères :
for e in L:
instructions
Si
L
est une liste,
e
prend les valeurs de ses éléments. Si
L
est une chaîne de caractères,
e
prend les valeurs des lettres qui la compose.
instructions
L'exemple basique suivant affiche toutes les lettres d'un mot les uns après les autres :
for
c
in
C
:
print (c)
print (c)
Téléchargez le fichier palindrome.py et éditez le dans Idle.
Ce fichier contient déjà une fonction nettoyer () qui prend en argument une chaîne de caractère, et retourne une chaîne similaire en minuscule sans accents et sans espaces.
Le but est d'ajouter les fonctions suivantes :
- Une fonction renverse () qui prend en argument une chaîne de caractères et renvoie la chaîne inversée.
- Une fonction palindrome () qui prend en argument une chaîne de caractères et renvoie True si la chaîne est un palindrome, False sinon. Vous pouvez la tester sur quelques-uns de es palindromes .
- L'indice "miroir" de i dans un mot de longueur N est N-i .
- Une autre solution consiste à utiliser un pas négatif pour reculer dans le mot.
- Afin de sortir d'une boucle avant la fin, il est possible d'utiliser le mot break; , ou utiliser un return à l'intérieur de la boucle.
2Boucle while
Pour parcourir une partie du code en boucle tant qu'une condition n'est pas réalisée, la syntaxe est la suivante :
while condition:
instructions
instructions
Attention, utiliser une boucle while doit toujours se faire en réfléchissant sur la condition d'arrêt. Elle doit être validée pour une itération sous peine de créer une boucle infinie :
i=1
while i>0:
i=i+1
while i>0:
i=i+1
La fonction suivant calcule le logarithme entier base
k
de
x
:
def
log (x,k):
n=0
while x>1:
x=x/2
n=n+1
return n
n=0
while x>1:
x=x/2
n=n+1
return n
Nous allons modifier le fichier fractions.py. Le but est d'ajouter deux fonctions :
- La fonction pgcd () qui prend en arguments deux entiers \(a\) et \(b\) et qui renvoie une liste composée de trois entiers \(d, a'\) et \(b'\) tels que \(d\) est le plus grand commun diviseur de \(a\) et \(b\), \(a=d a'\) et \(b=d b'\)
- La fonction simplifier () qui prend en argument une liste représentant une fraction et retourne sa forme irréductible. la fonction ne doit pas générer d'erreur si on lui passe un nombre en argument.
- Modifier les fonctions existantes pour que le résultat se fasse toujours sous forme irréductible.