PYTHON



Pour commencer:
1) Télécharger edupython ICI et installer-le.
Ce logiciel proposé par l'académie d'Amiens comprend python version 3.3 , pyscripter qui est un éditeur et plusieurs modules comme numpy turtle sympy tkinter .
2)Un document et un site pourront vous aider:
LE DOCUMENT : Une référence en 360 pages par le belge Gérard Swinnen, très complet.
LE SITE : mathprepa.fr.



Sommaire

Retour vers la page d'accueil

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 :  Retourner au sommaire

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 »  Retourner au sommaire

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.  Retourner au sommaire

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.  Retourner au sommaire

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 :  Retourner au sommaire

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  Retourner au sommaire

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)

 

 

 

 

 

 

 

 

 

 

 

 

   

 

 

 

 

 

 

 

 

 

 

 

Retour vers la page d'accueil