Python




Python

Ce document bla bla bla ...

© G. Landa, LAAS - CNRS

<georges.landa@laas.fr>

Eléments de Python

Démarrage de Python

  • Dans un terminal lancer la commande "python"
  • pour quitter : quit()

Utiliser Python comme une calculatrice

Calculer : 3/7 et 3/7.

Importer des modules

Calcul de la racine de 6 :

from math import sqrt
print(sqrt(6))

Calcul du log(10) :

import math
print(math.log(10))
	

Les variables chez Python ...

Définition d'une variable : on définit les variables à la volée, par exemple
  • x = 3
  • variable chaîne : a = "toto"
  • b = "ceci " + "et" + " cela !" affectera la chaîne 'ceci et cela !' à b

Les listes

  • jours = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]
  • les indices commencent à 0 : jours[3] donne 'jeudi'
  • jours[-1] donne 'dimanche'
  • jours[-2] donne 'samedi'
  • fonction utile : range(10), range(0, 100, 3)
  • les listes Python peuvent mélanger les types de données : mixte = ['lundi',3,0.505]
  • longueur d'une liste : len(liste)
  • remarque : help(commande) utile !

Notion de boucle

Attention !
Pour Python les "indentations" sont importantes, elles délimitent le début et la fin des objets, structures etc...>

Exemple de boucle

for j in jours:
	print("c'est le jour "+j)
	
remarques :
  • on peut itérer sur une chaîne :

    for i in b:
    	print(i)
    			
  • on peut extraire une sous-chaîne :

    b[0:2], b[-2:]
  • On peut compléter une liste :

    jours.append("jojo")
  • pour enlever un élément d'une liste :

    pour oter le dernier élément de la liste jours : del jours[-1] ou jours.pop()

Délimitation des blocs

le caractère ":" et l'indentation (ou tabulation) "TAB" sont les clefs de délimitation des blocs (fonctions, boucles, tests, ...)

exemple d'une boucle :

for i in range(20):

\tab print "Le carré de ",i," est ",i*i

Faire des tests

Comment faire des tests ?
for j in jours:
	message = "Aujourd'hui : " + j
	print(message)
	if j == "dimanche":
		print(" Dormir ...")
	elif j == "samedi":
		print(" Faire les corvées ...")
	else:
		print(" Va bosser !")
	

Suite de Fibonacci

n = 20
sequence = [0,1]
for i in range(2,n):
	sequence.append(sequence[ i-1]+sequence[ i-2])
	print(sequence)

Tuples et dictionnaires

Les tuples

  • les tuples sont des listes non-modifiables
zz = (1,2,34)

Les dictionnaires

  • les dictionnaires sont des structures du type clefs:valeurs
ages = {"Anne":23,"Marie":23,"jojo":61}
print(ages["jojo"])
  • on peut compléter le dictionnaire :
ages = dict(ages,Mathusalem=666)

Un exemple de programme python quasi-complet ...

Quelques commentaires

Interpréteur utilisé

#!/usr/bin/env python3

Utilisation du codage utf-8

# -*- coding: UTF8 -*-

Un entête comprenant les infos générales

""" Exemple de programme python générique
"""
#   Pour creer un fichier htlm avec la documentation:
#   pydoc -w PythonGenerique
__authors__ = ("Georges Landa")
__contact__ = ("georges.landa@laas.fr")
__version__ = "1.0"
__copyright__ = "G. Landa"
__date__ = "01/02/2021"

Les bibliothèques importées

import sys
import numpy as np

A quoi sert le : if __name__ == '__main__': ...

En fait, si on structure le code comme indiqué, il peut être directement interprété par python comme programme principal,
mais il peut aussi être importé dans un autre programme auquel cas les fonctions seront importées comme bibliothèque et exécutées au fur et à mesure des besoins.

Le programme complet

#!/usr/bin/env python3
# -*- coding: UTF8 -*-
""" Exemple de programme python générique
"""
#   Pour creer un fichier htlm avec la documentation:
#   pydoc -w PythonGenerique
__authors__ = ("Georges Landa")
__contact__ = ("georges.landa@laas.fr")
__version__ = "1.0"
__copyright__ = "G. Landa"
__date__ = "01/02/2021"

import sys
import numpy as np

# Création d'une classe d'objets
class MaClasse:
    """ Quelques mots sur la classe """
    def __init__(self, Nom, Valeur):
        self.Nom = Nom
        self.Valeur = Valeur
    def GetMaClasseNom(self):
        """Quelques mots sur cette propriété"""
        return self.Nom
    def GetMaClasseValeur(self):
        """Quelques mots sur cette propriété"""
        return self.Valeur

# Fonction d'utilisation
def Usage():
    """ Les consignes d'utilisation """
    print("USAGE:  %s N (N est un entier) " % sys.argv[0])
    return()

# Création d'une fonction
def Fonction(x):
    """ Infos sur la fonction """
    return(np.sin(x), np.cos(x))

# Fonction principale
def Main():
    """ Ce programme fait ceci cela ... """
    if len(sys.argv) != 2:
        print("Mauvais nombre d'arguments.\n")
        Usage()
        sys.exit()

    N = int(sys.argv[1])
    x = 1.
    y = 1.
    z = 1.

    print("Nombre de points : %d" % N)

    print("Affichage :")
    for i in range(N):
        x = float(i)*np.pi/N
        y, z = Fonction(x)
        print("Valeur de i : %d\t\tCoord. : %8.3f %8.3f %8.3f\t " %\
                (i, x, y, z))

    # Utilisation de la classe
    x = MaClasse("jojo", 61)
    print(x.GetMaClasseNom())
    print(x.GetMaClasseValeur())


if __name__ == '__main__':
    Main()

Quelques bibliothèques

L'objectif est de remplacer tous les logiciels "classiques" comme Scilab, Matlab, Comsol ...

Il existe une très grande variété de bibliothèques couvrant à peu près tous les domaines !

Calculs en général

  • Numpy
  • Scipy
  • Matplotlib

Calcul différentiel

  • Fipy

Utilisation de Numpy

Création d'un tableau

import numpy as np
a=np.zeros(10)
a
	

Propriété d'un objet

la commande :

dir(a)

permet d'avoir toutes les méthodes définies pour l'objet a

Modification de la forme d'un tableau

on peut modifier la forme d'un tableau avec l'instruction reshape

import numpy as np
a=np.zeros(10)
print(a)
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
b=a.reshape(2,5)
print(b)
[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]

Racines d'une équation

import matplotlib.pyplot as plt
import numpy as np
def f(x):
    return (x**3)-2*(x**2)

x=np.linspace(-1,3,100)
plt.plot(x,f(x))

from scipy.optimize import newton
x1=newton(f,x0=1.)
x2=newton(f,x0=3.)
print(x1)
print(x2)
plt.annotate('racine1',xy=(x1,0), xytext=(x1,2),arrowprops=dict(facecolor='black',shrink=0.05),)
plt.annotate('racine2',xy=(x2,0), xytext=(x2,2),arrowprops=dict(facecolor='black',shrink=0.05),)
plt.show()

On obtient :

Tracer une fonction

#!/usr/bin/env python
# -*- coding: utf8 -*-
import numpy as np
import matplotlib.pyplot as pl
# on définit ici le vecteur des abscisses x
x = np.linspace(0,2*np.pi,100)
# on définit ici le 1er vecteur des ordonnées
y1 = np.cos(x)
# on définit ici le 2nd vecteur des ordonnées
y2 = np.sin(x)
# On définit la figure
fig = pl.figure(figsize=(6, 3), dpi=150)
# on réalise le tracé de cosinus en bleu
pl.plot(x,y1,"b",label="cos(x)")
pl.plot(x,y2,"g" ,label="sin(x)") # on réalise le tracé de sinus en vert
pl.legend() # on demande à Python d"afficher les légendes sur la courbe
pl.show() # on demande à Python d"afficher les courbes à l"écran
fig.savefig("mafigure.jpg") # on enregistre la figure dans le dossier courant
	

On obtient :

Dériver une fonction

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from scipy.misc import derivative
import numpy as np
import matplotlib.pyplot as plt

f = lambda x : np.exp(-x)*np.sin(x)
x = np.arange(0,10, 0.1)
first = derivative(f,x,dx=1,n=1)
second = derivative(f,x,dx=1,n=2)

fig, ax = plt.subplots(3,1,sharex = True)
ax[0].plot(x,f(x))
ax[0].set_ylabel(r'$f(x)$')
ax[1].plot(x,first)
ax[1].set_ylabel(r'$f\/\prime(x)$')
ax[2].plot(x,second)
ax[2].set_ylabel(r'$f\/\prime\prime(x)$')
ax[2].set_xlabel(r'$x$')
plt.show()

On obtient :

Un peu de géométrie ...

#! /usr/bin/python
# -*- coding: utf8 -*-
import math
class Point(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return "Point({}, {})".format(self.x, self.y)

    def distance(self, other):
        return math.sqrt((self.x-other.x)**2 + (self.y-other.y)**2)

# Créer une classe mère Polygone permet de factoriser les attributs et méthodes en commun.
class Polygone(object):
    def __init__(self, points):
        self.points = list(points)
        # fait une copie de la liste

    def get_nb_sommets(self):
        return len(self.points)

    def perimetre(self):
        res = 0
        if(self.get_nb_sommets() > 0):
            for i in range(self.get_nb_sommets()-1):
                res += self.points[i].distance(self.points[(i+1)])
            res += self.points[-1].distance(self.points[0])
        return res
    
    def aire(self):
        return     # Calcul d'aire indisponible à ce niveau

# Nos types Triangle et Carre peuvent maintenant hériter du type Polygone pour profiter du code factorisé
class Triangle(Polygone):
    def __init__(self, p1, p2, p3):
        super().__init__([p1, p2, p3])

class Carre(Polygone):
    def __init__(self, p1, p2, p3, p4):
        super().__init__([p1, p2, p3, p4])

# On sait calculer l’aire d’un triangle et d’un carré, on peut donc surcharger cette méthode

class Triangle(Polygone):

    def aire(self):
        ''' Calcul d aire par la formule de Héron '''
        (a, b, c) = (self.points[i].distance(self.points[(i+1) % 3]) for i in range(3))
        s = (a + b + c)/2
        return math.sqrt(s * (s-a) * (s-b) * (s-c))


class Carre(Polygone):

    def aire(self):
        print self.points[0],self.points[2]
        return 0.5*self.points[0].distance(self.points[2])**2

A = Point(0,0)
B = Point(2,0)
C = Point(2,2)
D = Point(0,2)
print "point A",A.__str__()
print "point B",B.__str__()
print "point C",C.__str__()
print "point D",D.__str__()
print "distance A,B",A.distance(B)
print "distance A,C",A.distance(C)
print "distance A,D",A.distance(D)
print "distance B,D",B.distance(D)
print "Triangle"
tri = Triangle([A,B,D])
print "sommets",tri.get_nb_sommets()
print "périmètre",tri.perimetre()
print "aire",tri.aire()

print "Carré"
carre = Carre([A,B,C,D])
print "sommets",carre.get_nb_sommets()
print "périmètre",carre.perimetre()
print "aire",carre.aire()