[PDF] Langage Python cours de base avec exemples | Formation informatique

Développement rapide en Python

Stefano Facchini

Présentation du cours

●

10 séances

–

5 séances : CM + TD/TP

4 séances : CM + projet

–

1 séance : examen + discussion projet

Python

●

Première version 1989 par Guido van Rossum

Développé par la Python Software Foundation.

Open source.

●

Semi-interpreté (bytecode) multiplateformes.

Portable.

●

Orienté objet (mais aussi : impérative, fonctionnel)

Dynamique

4

Python

Portable

Linux

MacOS

Windows

Solaris

Python

Dynamique en deux sens :

●

« extensibilité » d'un programme au moment de

l'exécution (run-time)

●

typage dynamique (le type d'une expression est

déterminé au moment de l'exécution)

VS

6

Extensibilité

On peut « injecter » du nouveau code au moment

de l'exécution, et l'évaluer.

Cas extrême (et en général dangereux)

:

on pourrait demander à l'utilisateur d'entrer du code

arbitraire, et l'exécuter.

Typage dynamique

Python a un système de typage dynamique fort.

●

dynamique

= variables non déclarées, non typées

(les types sont inférés au moment de l'exécution)

●

fort

= absence de conversion implicite des types

8

Syntaxe

●

simple, claire, minimale, explicite, uniforme

préférences pour des mots (anglais) vs

Implémentations

Comme pour C on a plusieurs compilateurs,

de même pour Python on a plusieurs implémentations

●

CPython (implémentation de référence)

Jython

●

IronPython

PyPy

10

CPython

●

Implémentation de référence, par GvR et la PSF

Programmée en C

●

Interpréteur

●

La nouvelles caractéristiques du Python sont

normalement introduite dans CPython

Jython

●

Implémentation en Java

●

exécuté sur la Java Virtual Machine :

Python → Java bytecode

●

Interopérabilité avec modules Java

12

IronPython

●

Implémentation en C#.

●

Interopérabilité avec les librairies des

plateformes .NET et Mono

PyPy

●

Implémentation en (sous-ensemble de) Python

●

Très innovante, rapide, basée sur un compilateur

Just-In-Time (JIT)

www.pypy.org

14

PyPI

PyPI = Python Package Index

une collection de packages (>90000) pour Python

Python : 2.x vs 3.x

version 2 :

● version courante : Python 2.7.14

● non développée, « bugfixing mode »

version 3 :

● version courante : Python 3.6.4 ● activement développée

16

Dans ce cours nous utiliserons principalement :

●

CPython

version 3

Deux mode d'usage :

●

mode interactif

script

Mode interactif

R

E

P

L

Boucle REPL

18

Mode interactif

$ python3

Python 3.5.2 (default, Sep 14 2016, 11:28:32) [GCC 6.2.1 20160901 (Red Hat 6.2.1-1)] on linux

Type "help", "copyright", "credits" or "license" for more information. >>> 5+5 10 >>> 3==3 True >>> print('Hello') Hello >>>

R

E

P

Mode interactif

Le résultat des instructions est immédiatement visible

(sans phase de compilation etc...)

20

Mode interactif

Prompt primaire :

>>>

Prompt secondaire (pour instructions sur plusieurs lignes) :

...

On peut couper une instruction longue avec un antislash

\

>>> 5 + 3 * (9

... + 7) / 2

29

>>>

>>> 5 + 3 +

\

... 2 + 1

11

>>>

Script

Script = fichier avec séquence d'instructions

Exemple 1 : fichier « test1.py »

print(5 + 5) print("Hello world") print("Ciao") % python3 test1.py 10 Hello world Ciao % test1.py

22

Script

Exemple 2 : fichier exécutable « test2 »

#!/usr/bin/env python3 print(5 + 5) print("Hello world") print("Ciao") test2 % chmod +x test2 % ./test2 10 Hello world Ciao %

Script

En

Python 2

, pour utiliser le caractères accentués, il

faut spécifier l'encodage Unicode (normalement utf-8):

#!/usr/bin/env python2 # coding: utf-8

-*-print u"Je peux utiliser des caractères accentués" test_unicode.py

% chmod +x test_unicode.py % ./test_unicode.py

Je peux utiliser des caractères accentués %

24 ●

python3 -c "print(5)"

exécuter une commande et sortir

●

python3 -i monscript.py

passer en mode interactif après exécution d'un

script

Commentaires

Les commentaires commencent par un dièse #, jusqu'à la fin

de la ligne.

>>> x = 5

#

Affectation

>>>

27

Variables

Une variable est créée et définie par affectation. Une variable est effacée par l'opérateur del.

>>> x = 30 >>> x 30 >>> x = 'hello' >>>x 'hello' >>> del x >>> x

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

29

Variables

Nom des variable (et tous les identificateur) : lettres

minuscules (a à z), lettres majuscules (A à Z), chiffres (0 à

9), caractère souligné (_)

En

Python 3

: certains caractères Unicode sont permis

(caractères accentués, alphabets grec et arabe, etc...)

Attention

:

●

un nom de variable ne doit pas débuter par un chiffre

python est sensible à la casse : foo ≠ Foo

Objets et variables

Variable = étiquette rattachée à un objet.

a = 1

vs C, C++, Java... variable = boite

int a;

a = 1;

31

Objets et variables

int a;

a = 1;

a = 2;

int b;

b = a;

Objets et variables

a = 1

a = 2

33

Types

Le système des types en Python est très riche. Types de haut niveau. Les principaux :

– Booléens (bool)

– Numériques (int, float, complex) – Chaînes (str, bytes)

– Séquences (list, tuple, ...)

– Dictionnaires, a.k.a. « Tableaux associatifs » (dict) – Ensembles (set)

Le type d'un objet est donné par la fonctionne type. Notion de mutabilité. It ér ab le s

Booléens

Deux constantes, True et False

(attention aux majuscules !)

>>> x = True

>>> type(True)

<class 'bool'>

>>> type(x)

<class 'bool'>

>>> 3 > 5

False

35

Types numériques

●

Entiers (int), avec précision arbitraire

●

Floating point (float), équivalent de « double » en C

Complexes (complex)

En

Python 2

:

●

long (= int du Python 3)

int (précision finie)

Types numériques

>>> 10 # int 10

>>> 0.6 # float 0.6

>>> 3.5e-25 # float, notation scientifique 3.5e-25

>>> 3 + 5j # complex (3+5j)

>>> 1j * 1j # Attention, 1j et non pas j (-1+0j)

37

Types numériques

Les opérations principales :

+ addition - soustraction * multiplication / division ** puissance // division entière % modulo

Types numériques

Le nom d'un type est souvent aussi une

fonction de conversion :

>>> x = int(6.66)

>>> x

6

>>> x = float(2)

>>> x

2.0

39

Détour : les attributs

Python est orienté objet : tout est un objet, même les nombres.

Un objet peut avoir des attributs = des donnés qui appartiennent à l'objet. Les attributs sont accessibles avec la notation :

nom_objet.nom_attribut >>> x = 3.1 + 5.2j

>>> type(x)

<class 'complex'>

>>> x.imag # Attribut 'imag' de x 5.2

>>> type(x.imag) <class 'float'>

Chaînes

Les chaînes (str) sont un type immuable.

Chaîne = séquence de caractères.

>>> s1 = 'spam' >>> s2 = "foo" >>> s3 = '''longue phrase ... sur plusieurs ... lignes''' >>> s3

'longue phrase\nsur plusieurs\nlignes' >>> s4 = """une autre

41

Chaînes

Les caractères d'échappement : pour introduire des

caractères spéciaux

.

>>> print('J

\'

ai faim')

J'ai faim

Autres séquences : \t pour la tabulation, \n pour newline,

etc...

>>> print('

\t

Septembre

\n\t

Octobre')

Septembre

Chaînes

Les chaînes aussi ont des attributs. Certains sont des fonctions : >>> s = 'spam' >>> s.upper() 'SPAM' >>> s.capitalize() 'Spam' >>> s.find('a') 2

43

Chaînes formatées

Équivalent de la fonction C printf. On a une chaîne de contrôle à formater, où certaines balises sont remplacées par des valeurs. Ancienne méthode :

Les séquences sont introduites par le caractère % Les arguments suivent l'opérateur « modulo » % : >>> "Hello %s" % "Alice"

'Hello Alice'

>>> "%s a %i ans" % ("Luc", 20) 'Luc a 20 ans'

>>> "La valeur de PI est %.2f" % 3.14159 'La valeur de PI est 3.14'

Chaînes formatées

Nouvelle méthode :

Le séquence sont du genre {n}, avec n un entier. Les arguments apparaissent dans la fonction format :

>>> "{0} a {1} ans".format("Luc", 20) 'Luc a 20 ans'

>>> print("{0} {1} {0} {1} {0}\n{2}".format('une rose', 'est', 'Gertrude Stein'))

une rose est une rose est une rose Gertrude Stein

Beaucoup d'options disponibles (décimales, alignement, ...), voir https://docs.python.org/3/library/string.html

46

Listes

Collection (mutable) d'éléments de type arbitraire, construite avec des crochets et des virgules:

>>> liste = ['bleu', 'rouge', 'vert', 'jaune']

Accès aux éléments par indice : >>> liste[0] 'bleu' >>> liste[2] 'vert' >>> liste[-1] 'jaune' >>> liste[-2] 'vert'

Listes

La même syntaxe permet de modifier les

éléments d'une liste :

>>> a = [1, 2, 3]

>>> a[0] = 99

>>> a

48

Listes

Pour l'extraction d'une sous-liste on utilise la syntaxe liste[début:fin], qui génère une nouvelle liste avec les éléments compris entre les indices début et fin-1 :

>>> liste = ['bleu', 'rouge', 'vert', 'jaune'] >>> liste[0:2]

['bleu', 'rouge']

On peut omettre les indices : >>> liste[2:]

['vert', 'jaune'] >>> liste[:2]

['bleu', 'rouge']

>>> liste[:] # idiome courante pour copier une liste ['bleu', 'rouge', 'vert', 'jaune']

Listes

Attention

à la différence :

>>> liste = [10, 20, 30, 40, 50]

>>> liste[1] # un élément

20

>>> liste[1:2] # une liste

[20]

50

Listes

Concaténation avec l'opérateur « + » :

>>> a = ['lundi', 'mardi']

>>> b = ['mercredi', 'jeudi']

>>> a

+

b

Listes

Opérations qui modifient la liste :

>>> a = [1, 2, 3, 4, 5, 6, 7]

>>> a.append(8) # ajoute un élément au fond >>> a

[1, 2, 3, 4, 5, 6, 7, 8]

>>> # renvoie le dernier élément et l'efface de la liste >>> a.pop()

8

>>> a

52

Listes

La fonction list.insert(pos, element) ajoute un élément à la position pos :

>>> a.insert(3, 99) >>> a

[1, 2, 3, 99, 4, 5, 6, 7]

Autres fonctions : reverse, sort, extend ... >>> a.reverse(); a [7, 6, 5, 4, 99, 3, 2, 1] >>> a.sort(); a [1, 2, 3, 4, 5, 6, 7, 99] >>> a.extend([-1, -2, -3]); a [1, 2, 3, 4, 5, 6, 7, 99, -1, -2, -3]

Listes

Attention !

L'affectation ne copie pas une liste (étiquettes et objets) :

>>> x = [1, 2, 3]

>>> y = x

>>> x[0] = 99

>>> y

54

Tuples

Les tuples sont des listes immuables, définis par des

parenthèses et virgules :

>>> t =

(

20

,

30

,

40

)

>>> t = () # Tuple vide

Tuples

L'accès aux éléments et l'extraction de sous-tuples suit la même syntaxe que les listes :

>>> t = (20, 30, 40) >>> t[0]

20

Mais :

>>> t[0] = 99

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'tuple' object does not support item assignment

56

Tuples

Extraction d'un sous-tuple :

>>> t = (20, 30, 40, 50, 60)

>>> t[1:3]

Listes et tuples

Conversion entre listes et tuples : >>> t = (20, 30, 40, 50) >>> liste = list(t) >>> liste [20, 30, 40, 50] >>> t2 = tuple(liste) >>> t2 (20, 30, 40, 50)

58

Structures de contrôle

Tests

Les instructions conditionnelles sont introduites par les mots réservés

if...else :

x = 5

# Il n'y a pas de parenthèses autour de la condition

if x == 5: # Notez le « : »

print('Vrai') print(x)

else: # Notez le « : »

60

Tests à plusieurs cas

Pour les tests à plusieurs cas, on utilise if...elif...else

if x < 0:

print('Nombre negatif')

elif x == 0:

print('Zero')

elif x % 2 == 0:

print('Nombre positif pair')

else:

Comparaisons

Les principaux opérateurs de comparaisons sont :

< inférieur à <= inférieur ou égal à > supérieur à >= supérieur ou égal à == égal à != différent de in appartenance

62

Comparaisons

Les connecteurs logiques sont des mots : and, or, not Pas de symboles ! && || !

>>> 0 == 0 and 3 < 5 True >>> -1 > 0 or 'foo' == 'foo' True >>> not True False >>> not 1 in [1, 2, 3] False

>>> 1 not in [1, 2, 3] # plus lisible False

Bloc d'instructions

Les blocs sont définis par l'indentation, qui fait donc partie

de la syntaxe de Python.

Dans chaque bloc, l'indentation est arbitraire mais

constante.

64

Bloc d'instructions

# Valide, mais pas conseillé !

if x == 5: print('vrai') print(x) else: print('faux') print('blah')

Normalement, 4 espaces

(

https://www.python.org/dev/peps/pep-0008/#indentation

)

Bloc d'instructions

Blocs imbriqués :

# Un point a coordonnées (x,y) print 'Le point est dans :'

if y > 0:

if x > 0:

print('le quadrant I')

print('le demi-plan supérieur')

elif y < 0:

if x < 0:

print('le quadrant III')

66

Boucles

En Python on a la boucle for, mais il est un peu différent de ce qu'on trouve normalement ailleurs.

Avec for on peut itérer sur les éléments d'un objet itérable (e.g. list, tuple, dict, ...) = un objet qui peut lister ses éléments l'un après l'autre .

people = ['Françoise', 'Marc', 'Elodie', 'Jean']

for person in people:

68

Boucles

Pour reproduire le for traditionnel on peut itérer sur une liste d'entiers :

# Print the squares 0, 1, 4, ... 81

for x in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:

print(x**2)

Heureusement, il y a une fonction range(n) qui génère une liste de nombres entiers entre 0 et n-1:

for x in range(10):

Boucles

La boucle while :

x = 0

while x < 10:

print(x)

x = x + 1

70

Boucles

Pour passer à la prochaine itérations : continue

for n in range(10):

if n % 2 == 0:

continue

Boucles

Pour sortir d'une boucle : break...else n = 21 for x in range(2, n): if n % x == 0: print('{} = {} * {}'.format(n, x, n/x)) break else:

print('{} est un nombre premier'.format(n)) print('FIN')

72

pass

L'instruction pass ne fait strictement rien.

Elle est utilisée quand la syntaxe requiert une instruction, mais vous ne voulez rien exécuter (ou ne savez pas encore que faire).

pass est l'équivalent pythonique d'un bloc vide { } en C

for x in range(10): pass

if x == 3: pass

Interaction avec l'utilisateur

On peut utiliser la fonction input pour demander à

l'utilisateur d'entrer une chaîne :

>>> s = input()

bonjour

>>> s

74

Interaction avec l'utilisateur

La fonction input accepte un argument facultatif, utilisé

comme « prompt » :

>>> s = input('Entrez un mot : ')

Entrez un mot : bonjour

>>> s

76

Fonctions

On peut définir des nouvelles fonctions par le mot-clé def:

def hello_world():

print('Hello, world')

Fonctions

Les fonctions acceptent des arguments :

def hello(name):

print('Salut {}, bienvenue'.format(name)) hello('Jean')

def affiche_somme(x, y):

print(x + y)

78

Fonctions

On peut renvoyer des valeur avec return :

def calcul_produit(x, y):

return x * y

Fonctions

def affiche_introduction():

print('Bienvenu')

print('Le programme calcule le carré d\'un nombre entier')

def obtiens_un_nombre():

x = int(input('Entrez un nombre entier : ')) return x

def affiche_carre(x):

print(x**2)

affiche_introduction() n = obtiens_un_nombre()

80

Fonctions

Une fonction qui ne « return » pas, renvoie quand-même quelque chose !

L'objet None (de type NoneType). Source fréquente de problèmes : def f(x):

x += 1

# On oublie de renvoyer le résultat ... # return x