Introduction à Python

Introduction à Python Marc de Falco Maths/Info en MPSI Centre International de Valbonne 7 mai 2013

A propos de cette présentation Cette présentation reprend le poly co-écrit avec Laurent Chéno et Judicaël Courant. Dans la mesure du possible, le code présenté est compatible avec Python 2.X et Python 3.Y. Syntaxe de Python sur la partie au programme Un point sur les erreurs classiques

Présentation de Python Python est un langage interprété faiblement typé à l exécution orienté objet très généraliste et disposant de nombreuses bibliothèques assez répandu open source The Zen of Python : import this

Première manipulation avec l interprète Python dispose de deux modes d évaluation : Un mode interactif se comportant comme une calculatrice >>> 6 * 7 42 Un mode exécution de script, qui exécute un programme depuis un fichier. Ici nous utiliserons le premier mode.

Les entiers Les opérations standards sur les entiers sont définies : + - * // % ** (addition, soustraction, multiplication, quotient, reste, exponentiation). précision arbitraire >>> 2 ** 128 340282366920938463463374607431768211456 >>> 37 // 3 12 >>> 37 % 3 1

Les flottants Les opérations sur les flottants sont + - * / ** >>> 3.2 + 1.1 4.3 >>> 2.0 ** 0.5 1.4142135623730951 précision, en général, 64-bits. les nombres sont flottants (au programme de l IPT) >>> 0.1 + 0.1 + 0.1-0.3 5.551115123125783e-17 >>> format(0.1, 1.55 ) # 55 decimales 0.100000000000000005551115123125 7827021181583404541015625

Opérations mixtes entier flottant flottant >>> 2 ** 600-0.1 4.149515568880993e+180 la division simple / entre entiers En Python 2 : quotient >>> 1 / 2 0 En Python 3 : division flottante >>> 1 / 2 0.5

Fonctions mathématiques Les fonctions mathématiques sont dans le module math Deux possibilités d accès : Import du module et accès depuis le module >>> import math >>> math.sqrt(2.0) 1.4142135623730951 Import spécifique de la fonction et accès direct >>> from math import sqrt >>> sqrt(2.0) 1.4142135623730951

Fonctions mathématiques Listing des fonctions et constantes : >>> import math >>> dir(math) [ doc, file, name, package, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, copysign, cos, cosh, degrees, e, erf, erfc, exp, expm1, fabs, factorial, floor, fmod, frexp, fsum, gamma, hypot, isfinite, isinf, isnan, ldexp, lgamma, log, log10, log1p, modf pi, pow, radians, sin, sinh, sqrt, tan, tanh trunc ] Il y a de l introspection sur les modules.

Aide embarquée Un doute sur une fonction? >>> help(math.ceil) Help on built-in function ceil in module math: ceil(...) ceil(x) Return the ceiling of x as an int. This is the smallest integral value >= x. On peut même le faire directement sur le module pour avoir toute l aide : >>> help(math) Ce n est pas réservé aux modules/fonctions fournis.

Variables Les variables ne se déclarent pas. Définition à la première affectation : >>> x = 42 >>> x 42 >>> y Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name y is not defined Opérations d incrémentation : >>> x = x + 1 >>> x += 1 # plus Pythonesque Possible avec tous les autres opérateurs binaires.

Booléens Deux valeurs True et False opérateurs logiques and or not >>> False or not (True and False) True Relations de comparaisons ==!= < > <= >= >>> 1 == (3-2) True >>> 1 > 2 ** 0.5 False

Les chaînes de caractères Entre guillemets simples ou doubles. Pas de distinction caractère/chaîne Opérations : concaténation +, longueur len(s), i-ème caractère s[i] Immuables >>> Bonjour Bonjour >>> "Luminy" "Luminy" >>> s = Bonjour >>> s + Luminy Bonjour Luminy >>> len(s) 7 >>> s[0] B >>> s[0] = A [...] str object does not support item assignment

Types et conversions Pour récupérer le type : >>> type(2) <class int > >>> type(3.2) <class float > Ces valeurs sont manipulables : >>> type(2) == type(3.2) False >>> t = type( a ) >>> t <class str > Pour convertir une valeur dans un autre type : >>> str(3.14) 3.14 >>> int( 42 ) 42

Print l instruction print est un grand changement de Python 3. Sauf cas particulier, en écrivant : >>> print( Essai ) Essai cela marche dans les deux Python Il y a une conversion automatique des arguments en str.

Les tuples Pratiques pour regrouper des données Hétérogènes Accès aléatoire Déconstruction Concaténation Immuables >>> (True, 42) (True, 42) >>> t = (1, 2, 3) >>> t[0] 1 >>> x, y = 2, 3 >>> x, y = y, x >>> x 3 >>> (1, 2) + (3, 4) (1, 2, 3, 4)

Les listes Définies comme les tuples mais avec des [ ] Hétérogènes Accès aléatoire, en arrière Modifiable >>> l = [1,True,3] # heterogen >>> l[0] = 42 >>> l [42, True, 3] >>> len(l) 3 >>> l + [4, 5] [42, True, 3, 4, 5] >>> l[-1] 3 >>> l[-2] True

Les listes en tant qu objets Une liste est un objet. Opérations de manipulation : méthodes. >>> l.append(4) >>> l [42, True, 3, 4] >>> l.pop() 4 >>> l [42, True, 3] Comme pour les modules : >>> dir(l) # renvoie la liste des methodes et attributs >>> help(l.append) # la documentation d une methode

Les cauchemards commencent : Références implicites Les listes, commes les autres valeurs qui ne sont pas des types de bases, sont manipulées par référence. Version int >>> x = 3 >>> y = x >>> x += 1 >>> x 4 >>> y 3 Version liste >>> x = [3] >>> y = x >>> x.append(1) >>> x [3,1] >>> y [3,1] Les deux variables pointent vers la même liste. Pour copier y = copy.copy(x) après un import copy

Les slices (1/2) Les slices permettent d accèder à des sous listes par copie! >>> l = [0,1,2,3,4,5,6,7,8,9] >>> l[3:5] # l[debut:fin exclue] [3, 4] >>> l[:5] # debut = 0 [0, 1, 2, 3, 4] >>> l[7:] # fin = len(l) [7, 8, 9] >>> l[:] # toute la liste, mais c est une copie!!! [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> l[0:8:2] # pas [0, 2, 4, 6] >>> l[::-1] # pas negatif il inverse debut/fin [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Les slices (2/2) On peut s en servir pour faire des affectations >>> l = [0,1,2,3,4,5,6,7,8,9] >>> l[3:5] = l[7:9] >>> l [0, 1, 2, 7, 8, 5, 6, 7, 8, 9] # Tour de magie Pythonesque, que se passe t il? >>> l = [0,1,2,3,4,5,6,7,8,9] >>> l[::2], l[1::2] = l[1::2], l[::2] >>> l # a ne surement pas montrer aux eleves ;-) De l intêret des slices : c est la brique de base de numpy/scipy.

La minute complexité Les listes Python n en sont pas. Ce sont des tableaux dynamiques. Accès (lecture/écriture) : O(1) Ajout, Suppression à la fin : O(1) amorti Insertion, Suppression ailleurs : O(n)

Instruction conditionnelle (1/2) if <ma condition>: <bloc d instructions si verifiee> else: <bloc d instructions sinon> Le point clé ici c est l identation du bloc. C est elle qui le délimite. Le else est optionnel. x = 3 if x % 2 == 1: x += 1 x *= 2 # sur le meme niveau d indentation x -= 1 # niveau en dessous donc en dehors du if

Instruction conditionnelle (1/2) Tests imbriqués : if x == 1: x += 1 else: if x == 2: x -= 1 else: x *= 2 qui peut s écrire : if x == 1: x += 1 elif x == 2: x -= 1 else: x *= 2 Oui, l indentation peut déclencher des syntax error...

Blocs et portée Des erreurs classiques : Pas de scope pour les blocs. Une variable peut-être définie conditionnellement if x < 0: y = -x print(y) Erreur à l exécution si x >= 0.

Expression conditionnelle { n/2 si n pair x = 3n + 1 sinon Version instruction if n % 2 == 0: x = n // 2 else: x = 3 * n + 1 Version expression : x = n//2 if n % 2 == 0 else 3*n+1 asymétrique car correspond à un x = mavaleur if pasderreur else rattrapage

Boucle conditionnelle while <ma condition>: <bloc d instructions a executer> Exemple n = 1 f = 1 while n < 5: f *= n n += 1

Boucle inconditionnelle for <variable> in <iterable>: <bloc d instructions a executer> Qu est-ce qu un itérable? Liste, tuple, chaîne : s = 0 for e in [1,2,3]: s += e for c in abc : print(c)

Range Pour faire une simple boucle allant de debut à fin par incrément de step, on utilise l itérable range(debut,fin,step). En Python 2 c est une liste, en Python 3 il faut la convertir. >>> list(range(1,10,1) [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(1,10,2) [1, 3, 5, 7, 9] >>> list(range(5)) # debut = 0, step = 1 [0, 1, 2, 3, 4] Avantage d un itérable non liste? >>> range(0,100000000000000000000000000000,5)[50] 250

Gestion du flot de contrôle break, continue for i in range(5): if 2 * i == 2 + i: print(i) break attention, la variable du for n existe plus après Avec les erreurs liées à la portée des blocs... for i in range(1,5): if i % 10 == 0: v = i / 10 break print(v)

Fonctions Syntaxe : def mafonction(arg1,..., argn): < corps de la fonction > Pour renvoyer une valeur : return 42. Exemple : def somme(l): s = 0 for e in l: # le reste de la liste s += e return s (on peut aussi faire sum(l)... ) Pour appeler une fonction mafonction(v1,..., vn).

Fonctions et portée (1/3) Les fonctions définissent un scope. def f(x): y = x + 2 return y y # n est pas defini ici C est le comportement usuel.

Fonctions et portée (2/3) Pas de clôtures : >>> x = 3 >>> def f(y):... return x + y... >>> f(3) 6 >>> x = 4 >>> f(3) 7

Fonctions et portée (3/3) Les variables globales sont : accessibles en lecture inaccessibles en assignation si non déclarées par défaut une assignation déclare la variable locale dans TOUT le bloc (rétroactif) x = 3 def f(): return x + 1 print(f()) # affiche 4 def g(): x = 5 return x + 1 print(g()) # affiche 6 print(x) # affiche 3 def h(): global x x = 5 return x + 1 print(h()) # affiche 6 print(x) # affiche 5

Next? Ici, nous n avons couvert que la partie au programme Dans la suite logique : les dictionnaires (tables de hachage) les structures de données fournies dans la bibliothèque standard import collections (des vraies listes!) les objets (c est le cœur de Python) les itérateurs...