Première partie : Premier contact avec python : les variables , les

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
Pyscripter.
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 :
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(mais il y a plusieurs types d’entiers)
float pour réel à virgule flottante(il y a plusieurs types de réels)
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
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 python
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.
Dans le document de 74 pages aux pages 40 et 43 vous aurez 2 tableaux indiquant
les différentes opérations sur les listes (ajouter , enlever , trier etc...)
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
23
456
etc...
Les fonctions
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.
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 : Les classes et les objets .
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__()
Quatriè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)
Cinquième partie :
La récursivité.