Première partie : Premier contact avec python : les variables , les types , les boucles.
Il sera toujours judicieux d’écrire un algorithme en langage naturel puis de le réécrire en python en utilisant l’éditeur EDUPYTHON.
Un algorithme permet de résoudre un problème ou de réaliser une tâche et cela quelles que soient les valeurs des données.
Voici un exemple : Retourner au sommaire
Variables
N est un entier naturel,
A et U sont des nombres réels
Initialisation
N prend
la valeur 0
U prend la valeur 1
Entrée
Saisir
la valeur de A
Traitement
Tant que
U < A
U prend la valeur U2+1
N prend la valeur N +1
Fin tant que
Sortie
Afficher
N
Des questions qui sont des questions d’algorithmique pourront
être :
Que fait cet algorithme ?
Pourquoi cet algorithme s’arrête ?
Voilà ce que cela donne en python :
Attention : il s’agit de python 3.3 qui
présente quelques différences avec python 2.7
1 n=0 #la variable n est initialisée à 0 et est un entier et
c’est la première instruction
2 u=1 #la variable u est initialisée et est un entier
3 A=float(input("Donner la valeur du réel A"))
4 while
u<A:
5 n=n+1
6 u=u**2+1
7 print(n)
Quand on exécute ce programme une
fenêtre nous demandera de saisir le réel A
puis une valeur s’affichera en bas.
Les préliminaires :
Le mode interactif de Python pourra être utilisé : il
permet de tester instruction par instruction.
Quand on exécute le programme puis quand on le sauvegarde avec
un nom donné , un fichier d’extension py est généré.
Ce fichier qui est en fait un fichier texte sera interprété par
python , si python est sur votre machine.
Vous pourrez donc lire le code python en l’ouvrant avec un
éditeur de textes comme notepad+.
Après un ‘#’ vous
pourrez mettre des commentaires : ils seront ignorés lors de l’exécution.
Les variables sont de type dynamique, c'est-à-dire leur type
peut changer en cours d’exécution.
Le type est alors défini à chaque affectation.
IMPORTANT : une
variable est d’un type donné et
c’est l’affectation qui permet de le
connaître.
La première affectation est l’initialisation.
En python il faut en même temps déclarer et initialiser par une
instruction du type :
nom_variable=valeur_variable.
par exemple
x=3
En java ce n’est pas nécessaire mais par contre le type de la
variable doit être précisé
et ne peut pas être changé.
Par exemple
int x ;
x=3 ;
Une expression est une suite de symboles qui sera
évaluée.
Par exemple
a=0 # a est un entier
qui vaut 0
a=0.0 # a devient un réel qui vaut 0.0
a=a**2 +1 # le membre de droite est
une expression qui sera évaluée ici 1.0 ; ainsi a est un réel qui vaut 1.0
Pour connaître le type d’une variable on peut ajouter
l’instruction :
print(type(ma_variable))
# la fonction print permet d’afficher la valeur d’une
variable
ou plus simplement en écrivant dans
le mode interactif :
ma_variable=mon_expression
type(ma_variable)
Essayez avec comme variable
a=1
a=1.0
a= « bonjour »
a=3==3
Vous trouverez :
int
pour entier
float pour réel à virgule flottante
str pour string ou chaîne de
caractères
bool pour booléen (
vrai ou faux)
Attention : en mémoire 3 et 3.0 sont
représentés de façon différente.
Il est possible de convertir un type en un autre, c’est ce que
fait la ligne 3) du programme.
En effet la fonction input affiche une fenêtre de saisie et
renvoie une chaîne de caractères.
Elle est convertie en un réel qui sera la valeur de la variable
A.
Ensuite dans le programme
intervient une boucle « tant que »
while condition :
instruction1
instruction2
…
else :
instruction3
instruction4
Commentaires
« condition » est un booléen
c'est-à-dire est vraie ou fausse.
C’est l’indentation
qui délimite le bloc d’instructions du while ou du else.
Attention :Les
instructions d’un même bloc doivent être bien alignés verticalement.
Voilà un autre exemple :
while condition1 :
instruction1
instruction2
while
condition2 :
if condition3 :
instruction3
instruction4
elif condition4:
instruction5
else:
instruction6
instruction7 (Fin du deuxième while)
instruction8 (Fin du premier while)
instruction9 (Fin du programme)
Les boucles « pour »
for i in t :
instruction1
instruction2
…
Commentaires :
i est une variable qui va décrire les éléments de l’ensemble t.
Les éléments de t peuvent être de types différents , dans ce
cas i changera de type.
Un cas simple sera i in
range(n) où range(n) est l’ensemble des entiers {0, … , n-1}
i in range(4)
signifie que i prendra successivement les valeurs 0 1 2 3 (i sera une variable
de type int)
Exercices :
Ecrire un programme qui n’affiche que les multiples de 3 de 1 à n.
Ecrire un programme qui n’affiche que les voyelles d’une chaîne de caractères.
Réécrire les programmes du cours de maths.
Afficher un tableau triangulaire de la forme :
1
11
111
etc... avec n lignes
Remarques : sur les modules Retourner au sommaire
Certaines fonctions se trouvent dans des modules qui sont des fichiers .py ou des répertoires contenant ces fichiers.
Ces fichiers eux-mêmes contiennent des fonctions et leur définition.
Par exemple la fonction exponentielle se trouve dans le module math.
Au début de son propre module ou programme il faudra écrire
Soit import math
puis après math.exp(3) sera une expression comprise par python
Soit from math import exp
il suffira d’écrire exp(3)
seule la fonction exp() de ce module pourra être utilisée
Soit from math import *
toutes les fonctions du module math pourront être utilisées et pour les connaître
il suffira d’écrire import math puis help(math) en mode interactif ou import math puis print(help(math))
dans le programme.
Les modules math , time , random seront utiles.
Deuxième partie : Les tableaux et les fonctions.
Les tableaux
En python il y a plusieurs structures de données (types structurés) disponibles
Les listes ou tableaux dynamiques (list)
Les tuples
Les tableaux (array)
Nous utiliserons de préférence les premières.
par exemple :
l1=[0,1,2,3]
l2=list(range(4))
Vérifier avec type(l1)
et print(l1)
Les éléments d’une liste peuvent être de types différents.
Une liste peut être modifiée , on dit qu’elle est mutable.
Les tuples s’écrivent avec des parenthèses et sont non mutables.
Nous verrons plus tard l’effet en mémoire de cette propriété.
Attention : Les éléments sont numérotés (on parle d’indice) à partir de 0.
t=[‘a’,0,’ou’]
Ainsi t[0] est le premier de t soit ‘a’, t[1] le deuxième soit 0 etc…
len(t) renvoie la taille de t c'est-à-dire le nombre d’éléments de t.
On peut concaténer 2 listes t1 et t2 par t1+t2.
Voici quelques méthodes sur les listes :
li.append(e) : ajoute à la fin de la liste li l’élément e
li.extend(lis) : rajoute à la fin de la liste li la liste lis
li.remove(e) : enlève la première valeur de la liste li égale à e
li.reverse() : renverse les éléments de la liste li
li.sort() range dans l’ordre croissant ou alphabétique les éléments de la liste li
Voir aussi dans le document de 74 pages aux pages 40 et 43
Exercices
Comment créer un tableau nxm avec des 0 seulement?
Comment créer un tableau triangulaire nxn avec des 0 seulement sauf sur
la diagonale où il y a des 1?
Créer un tableau t où t est :
1
2 3
4 5 6
etc...
Les fonctions Retourner au sommaire
Commençons par un petit programme :
def ma_fonction(x) :
return exp(x)+1
def mon_tableau(n) :
t=list(range(n))
for i in t :
t[i]=ma_fonction(i)
return t
def affiche(t) :
for i in range(len(t)) :
print(t[i],”
“,end=””)
affiche(mon_tableau(4))
Que fait ce programme (commenter ligne par ligne)?
Comment déclare-t-on une fonction? Quels sont les paramètres (entrées)
Quelle est la différence entre les 2 dernières fonctions?
Comment utilise-t-on une fonction?
Que se passe t-il si on change l’ordre des fonctions ou si la dernière instruction
est placée avant les fonctions?
Attention : Les fonctions peuvent être définies dans l’ordre que l’on veut mais leur utilisation(appel à celles-ci)
doit se faire après.
A retenir Une fonction s’écrit de la manière suivante
def
le-nom-de_ma_fonction(paramètre1,paramètre2,..) :
instructions
qui constituent le corps de la fonction
return ..(si la fonction retourne quelque chose)
Une fonction peut ne rien retourner
def bonjour() :
print(« bonjour »)
def estpair(n) :
if n%2==0 :
print(n,” est un entier pair”)
else :
print(n, « est un
entier impair »)
Une fonction peut retourner plusieurs valeurs
def nom_prenom-age() :
x=input(« Donner
votre nom »)
y=input(« Donner
votre prénom »)
z=int(input(« donner
votre âge »))
return x,y,z
Le nom des fonctions comme des paramètres doivent être assez explicites.
Le rajout de commentaires qui expliquent ce que fait la fonction est essentiel.
Par exemple
#La fonction estpair a pour paramètre un entier n et affiche un texte
pour dire s’il est pair ou impair
Exercices :
Créer une fonction de paramètre t qui dit si oui ou non il y a des entiers dans t.
Créer une fonction de paramètres x et t qui renvoie le premier indice de x
dans le tableau t ou -1 si x n’est pas dans t.
Créer une fonction de paramètres x et t qui renvoie le nombre d’occurrences
de x dans le tableau t.
Créer une fonction de paramètre n qui renvoie un tableau nxn avec des 0 seulement.
Créer une fonction qui affiche les éléments d’un tableau.
Créer une fonction de paramètre n qui renvoie le triangle de Pascal de n lignes.
Troisième partie : Le cas du module turtle . Retourner au sommaire
On l’importe par
l’instruction
from turtle import *
Il utilise le module Tkinter permettant la création d’interfaces
graphiques.
Au départ la tortue est au centre de la fenêtre dont les coordonnées en pixels sont (0 ;0)
Et elle se déplace à droite.
Voiçi une liste de fonctions pour faire des dessins :
forward(integer) # avance
le crayon sur la distance donnée
backward(integer) # recule
le crayon sur la distance donnée
circle(radius) # dessine un cercle de rayon donné
width(integer) # largeur du
trait
up() # leve la main dans ce mode ci quand vous vous deplacer vous n'écrivez plus
down() # descend la main pour pouvoir écrire
color(str) # couleur du
crayon
write(str) # écrit le texte
à la position du curseur
position() # retourne les coordonnées de votre crayon
setx(integer) # se déplace
à la coordonnée x spécifiée
sety(integer) # se déplace
à la coordonnée y spécifiée
left(integer) # tourne la
main de nombre de degré vers la gauche
right(integer) # tourne la main de nombre de degré
vers la droite
reset() ou clear() # efface votre dessin
window_width() # retourne la dimension de longueur de
la fenêtre Tk
window_height() # retourne la dimension de hauteur de
la fenêtre Tk
Et voici un exemple
from turtle import *
u=3
up()
goto(10,-10)
down()
right(45)
x,y = position()
while x<305 and x>-305 and y<300 and y>-300:
forward(u)
right(45)
forward(u)
left(135)
u=u+3
x,y
= position()
exitonclick()
Quatrième
partie : Les classes et les objets . Retourner au sommaire
Donnons un exemple :
class Fraction :
def __init__(self,n=0,d=1) :
self.numerateur=n
self.denominateur=d
def affiche(self):
print(self.numerateur)
print(“----“)
print(self.denominateur)
fr1=Fraction(3,7)
fr2=Fraction(3)
fr1.affiche()
fr2.affiche()
fr1 est une variable de type Fraction et le « =Fraction(3,7) » est une instanciation
de la classe Fraction qui correspond à une affectation dans le cas d’un type primitif.
Cet instanciation crée ce que l’on appelle un objet .
Au moment de l’instanciation d’une classe , Python réserve (alloue) de la place mémoire.
Il ne fait pas que cela !
Il crée un espace de noms et de valeurs liés à la variable fr1.
numérateur et dénominateur sont des appelés attributs de la classe
La fonction __init__ est un constructeur , c’est celle qui est utilisée au moment
de l’instanciation.
Les autres fonctions créées dans le corps de la classe sont appelées méthodes
et s’utilisent avec un point.
L’accès aux attributs se fait par fr1.numerateur ou fr1.denominateur.
La mémoire est gérée entièrement par Python , en particulier pour libérer de l’espace.
On a accès au numéro de la case mémoire par la fonction id().
En python tout est objet et pour vous en convaincre écrivez (avec un point) :
int.
str.
boo.
Fraction.
list.
ou encore :
fr1.
etc…
Vous verrez alors une fenêtre s’ouvrir avec l’ensemble des attributs et des méthodes.
Par exemple vous pouvez faire
ch=input().upper()
print(ch.__sizeof__())
D’abord input() s’effectue en renvoyant la chaîne de caractères saisie par l’utilisateur
puis sur cette chaîne on applique la méthode upper() qui renvoie la chaîne en majuscule.
On affiche cette chaîne en majuscules puis la taille en octets qu’elle utilise en mémoire.
x=3 ou x=int(3)
print(x.bit_length())
print(xprint(x.__sizeof__()))
On crée une variable de type int qui prend la valeur 3 puis
on applique à x la méthode bit_length() qui renvoie le nombre de bits
nécessaires pour coder x et on affiche le résultat.
Ensuite on affiche le nombre d’octets utilisée par la mémoire pour x
avec la méthode __sizeof__()
Cinquième partie : Portée des variables et passage des arguments.
Portée des variable
Commençons par écrire les
instructions
i=i+2
print(i)
Que se passe-t-il ?
Maintenant écrivons
i=0
i=i+1
print(i)
Il n’y a plus de problème.
Essayons ces différents
scripts ;
def plus():
k=0
print(k)
k=k+1
plus()
def plus():
k=0
k=k+1
print(k)
plus()
def plus():
print(k)
k=0
plus()
def plus():
k=k+1
print(k)
k=0
plus()
def plus():
global k
k=k+1
print(k)
k=0
plus()
Attention : Une variable n’est visible que dans le bloc ou corps
d’instructions
où elle est déclarée, elle est dite locale.
Si elle en dehors de tout
bloc elle est visible partout et elle
est dite globale.
Une variable globale peut
être modifiée à l’intérieur d’une fonction grâce à l’utilisation
du mot clef :global
Types mutables et
immutables :
Essayez ces 3 scripts
x=1
y=x
x=3
print(x)
print(y)
x=[1,2]
y=x
x[0]=3
print(x[0])
print(y[0])
x= « ab »
y=x
x= « cd »
print(x[0])
print(y[0])
Que remarque-t-on ?
Passage des arguments
lors de l’appel à une fonction
Vous allez créer 3
fonctions :
La première qui a comme
paramètres 2 entiers x et y et qui consiste à
échanger les valeurs de x
et y.
La deuxième qui a comme
paramètre un tableau d’entiers et qui échange
les 2 premiers éléments de
ce tableau.
La troisième qui a comme
paramètre une chaîne s et qui change s en « ab ».
Appliquez ces 3 fonctions
sur des variables globales et affichez la valeur de ces variables.
Attention
Soit une instruction du
type x=a où x est une variable de type mutable comme les listes ou les classes.
1)Considérons l’instruction y=x
Alors tout changement sur
x se répercute sur y.
2)Considérons
l’instruction f(x) où f est une fonction.
Alors tout changement du
paramètre de la fonction dans le corps de cette fonction
se répercute sur x.
Par exemple si on
considère ce script :
def f(x) :
y=x
y[0]=0
return y
t1=[3,6]
t2=f(t1)
On aura alors t1=t2=[0,6]
Autrement dit on perd
l’état initial de t1 et le script précédent équivaut alors à celui-ci :
def f(x) :
x[0]=0
t=[3,6]
f(t)