Introduction du langage Python en cours de
LIF1
Auteur: Jacques Bonneville
Version: 0.1 - 12/7/2011 - création en restructured text (xml non portable)
1 Préface
Courte présentration du langage Python pour les étudiants inscrits à l’UE LIF1 (INF1001L) pour préparer l’utilisation du logiciel SAGE utilisé dans les en-seignements de Mathématiques. Cette courte intervention est constituée d’un CM de 1h30 et de 1 ou 2 TP de 3H avec l’outil Quenlig et les acquis seront évalués lors de la dernière séance pratiques. Les prérequis sont les notions de base de la programmation :
∙ variable : liaison d’une valeur à un nom
∙ type : domaine de valeur et opérations associées ∙ expression et affectation
∙ instructions de contrôle (alternatives, boucles) ∙ fonctions, passage de paramètres, retour de valeur(s)
2 Présentation rapide du langage Python
2.1 Pourquoi cette introduction ?
Pour utiliser la plate-forme SAGE qui a choisi Python comme langage pivot; c’est un langage interprèté facile d’utilisation et allègeant les déclarations, notem-ment pour les variables. Dans ce cours introductif, nous n’aborderons pas toutes les possibilités du langage, en particulier nous n’aborderons que brièvement la notion de classe, car elle est utilisée dans SAGE, mais qui sera étudiée ultérieure-ment (LIF14). De toutes les manières, les notions algorithmiques déjà abordées (acquises ?) restent valides et serviront de bases de référence dans ce cours. Nous commencerons par une description générale du langage en présentant rapi-dement les principaux éléments aux programmes; dans un deuxième temps, nous nous attarderons sur les éléments nouveaux et spécifiques au langage Python. Ensuite, nous attacherons à présenter la traduction en Python des éléments déjà vus en langage algorithmique et en C. pour terminer enfin par quelques exem-ples conséquents, voire un démarage de SAGE. Ce cours est une facilité offerte
en plus des documents d’introduction qui peuvent être trouvés soit sur le site du langage Python ou sur le site de SAGE, notamment l’introduction pour les non programmeurs.
Nous indiquerons les sites de références utilisés. Il y a par exemple un cours complet et bien fait comme Apprendre à programmer avec Python (http://python.developpez.com/cours/TutoSwinnen/?page=sommaire) par Gérard Swinnen. Comme la plupart des références fournies, ce cours va bien au delà des objectifs de cette rapide présentation, mais il y a de nombreux petits exercices (certains déjà vus en C et bien d’autres).
2.2 Langage Python utilisé
Il existe actuellement 2 versions maintenues en parallèle :
∙ Version 2.5.x ou 2.6.x que nous utiliserons et qui ne présentent que peu de différences; SAGE utilise la Version 2.6.x (en 2009)
∙ Version 3.x, avec des modifications plus notables.
Le site officiel où vous trouverez tout pour l’installation et les ouvrages de documentation (qui vont bien au delà des objectifs de cette introduction) : Python Programming Language -- Offical Website (http://www.python.org). Vous pourrez y apprendre, en autre, que le nom fait référence à un fameux cirque volant.
Pour démarrer :
∙ Sous Linux (Debian), il suffit de lancer la commande python ou ipython et le prompt apparaît : (trouver comment insérer une capture d’écran) ∙ Mais en mode interactif, il est préférable d’utiliser la commande ipython,
voire ipythonx qui intègrent l’aide et la documentation en ligne, comme dans l’environnement SAGE.
∙ Sous windows, il suffit de cliquer de droite de gauche en espèrant...
2.3 Qu’est ce que SAGE
Comme indiqué sur la page officielle SAGE : Open Source Mathematics Soft-ware (http://www.sagemath.org), c’est un logiciel open-source d’outils mathé-matiques qui vous seront mieux présentés dans les cours d’algèbre et d’analyse. Vous y trouverez notamment des documents pour des non programmeurs. Il y aussi d’autres sites détaillant des utilisations/applications de cet outil. Vos enseignants de mathématiques vous indiqueront les sites qui vous seront le plus utile pour réaliser vos travaux.
3 À quoi ressemble un programme Python ?
Nous allons commencer par une reprise des exemples vus précédemment en LIF1 avant les généralités.
3.1 Le célèbre “Hello world”
Considérons le fichier HW.py ci-dessous
print "hello world" # le commentaire : mettre des () en version 3 print ("hello world - bis repetita") # comme ceci
Nous conseillerons d’utiliser autant que possible la syntaxe de la version 3. Les éléments sont :
∙ print : commande pour écrire, l’argument suit
∙ “hello word” : la chaîne de caractères en argument; ceci est l’une des formes simples.
∙ # commentaire : il est recommandé de mettre les commentaires en fin d’instruction, sauf dans certains cas ...(que nous verrons plus loin)
3.2 Une première boucle : Fibonacci version 1
#repris du Python tutorial a, b = 0, 1
while b < 1000 : print b, a,b = b, a+b Éléments importants :
∙ Pas de type précisé lors des déclarations de variables; c’est le type de la valeur affectée qui détermine le type de la variable. Attention, celui-ci peut donc varier : il ne faut pas faire n’importe quoi!
∙ Affectation multiple : les expressions (à droite) sont toutes évaluées avant les affectations
∙ Bloc d’instructions : introduit par le symbole : et déterminé par le niveau d’indentation. 4 espaces sont recommandés pour 1 niveau d’indentation. La mise en page est donc essentielle et primordiale.
∙ La boucle while permet de répéter une instruction (qui peut être sur la même ligne) ou sur la ligne suivante (cas des blocs); dans ce dernier cas, le symbole : signifie à l’interpréteur que l’instruction continue... Tous les blocs d’instructions commenceront donc ainsi.
∙ La virgule à la fin de l’instruction print signifie simplement de ne pas écrire de saut de ligne (newline).
3.3 Fibonacci revisité (2 fois)
#repris du Python tutorial
def fib(n) : # write Fibonacci series up to n a, b = 0, 1
print b, a, b = b, a+b
def fib2(n) : # return Fibonacci series up to n result = [] a, b = 0, 1 while b < n : result.append(b) a, b = b, a+b return result Éléments importants :
∙ Définitions de 2 fonctions fib et fib2 ayant chacune un seul paramètre formel nommé n.
∙ Seule fib2 renvoie une valeur définie par l’instruction return; Notons aussi que la valeur retournée est ici un tableau ( result ).
∙ result est donc un tableau; à noter l’initialisation en tableau vide. Contrairement au langage C, les tableaux sont naturellement de taille variable; l’opération append du type tableau permet d’ajouter un élément en fin.
∙ En réalité, les tableaux Python n’existent pas, ce sont des listes (List) qui sont utilisées. Cependant, comme il est possible d’accèder aux élé-ments directement (opérateur []), cela ne change pas la conception des algorithmes, mais cela nécessitera, dans un premier temps, d’être attentif aux initialisations et à la conservation des longueurs.
3.4 Utilisons les fonctions définies : pour fib
print ("fib(1000)") fib(1000) print ("\n a1 = fib(100) ") a1 = fib(100) print ("\n a1 =",) print (a1) print ("fib2(1000)") fib2(1000) print ("\n a2 = fib2(100) ") a2 = fib2(100) print ("\n a2 =",) print (a2) Cela donnera : fib(1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 a1 = fib(100) 1 1 2 3 5 8 13 21 34 55 89 a1 = None
fib2(1000) a2 = fib2(100)
a2 = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] Éléments importants :
∙ fib affiche bien les valeurs de la suite plus petites que n, mais n’a pas de valeur de retour, c’est une procédure; ceci explique l’absence de contenu de a1. Aucune erreur n’est signalée !
∙ A contrario, l’exécution de fib2 ne génère pas d’affichage, mais le résultat doit être sauvegardé dans une variable (a2 ) pour pouvoir être exploité (sinon il est perdu). C’est une fonction.
3.5 Résumé du chapitre
Points à retenir de la présentation rapide :
∙ type des variables déterminé lors des affectations ∙ structure de bloc par indentation et introduite par : ∙ affectation, éventuellement multiple
∙ tableau dynamique à initialiser
∙ une fonction retourne une valeur avec return (sinon c’est une procédure) ∙ Python peut être utilisé en mode interactif ou sous forme de script.
4 Expressions arithmétiques - chaînes de
carac-tères
Les langages interprètés supportent souvent des structures de données dynamiques comme les listes (ou tableaux de tailles variables) comme nous l’avons vu précédem-ment. En effet, les soucis d’optimisation en temps et en espaces ne sont pas une priorité comme c’est le cas pour d’autres langages comme C ou C++ dans une moindre mesure. Le programmeur alloue explicitement la mémoire pour les be-soins de son algorithme, mais la libération est laissée à la charge de l’interpréteur par l’intermédiaire de son ramasse-miettes ou garbage-collector. Nous ver-rons aussi une approche intéressante et plus simple pour définir les itérations et les énumérations. Nous avons repris ici l’ordre du tutoriel.
4.1 Arithmétique en Python et manipulation des nombres
complexes
Python permet d’écrire des entiers (sur 32 bits), des entiers long (limite mé-moire), des flottants ou float (format sur 64 bits, détail en LIF5), et des nombres imaginaires (la valeur absolue est codée sur un float) en utilisant le symbole j ou J. Un nombre complexe sera écrit comme l’addition d’un flottant et d’un imaginaire, ce qui est illustré ci-dessous. C’est l’interpréteur qui choisit le type et la représentation des valeurs manipulées.
>>> a=11111111111111111111111111111111j >>> a.real 0.0 >>> a.imag 1.1111111111111112e+31 >>> b=2+3j >>> b (2+3j) >>> b.real 2.0 >>> b.imag 3.0
>>> float(b) ## pas de sens
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can’t convert complex to float; use abs(z) >>> abs(b) ## sqrt(b.real**2+b.imag**2)
3.6055512754639891 >>> from math import *
>>> sqrt(b.real**2+b.imag**2) 3.6055512754639891
Attention, dans SAGE, les symboles i ou I sont utilisés pour indiquer la partie imaginaire. Les règles de conversions sont celles en usage, à savoir, dans une expression, tous les opérandes sont convertis dans le type le plus général, au sens de l’inclusions des ensembles : l’ensemble des des nombres entiers est inclus dans l’ensemble des nombres réels qui est lui même inclus dans l’ensemble des nombres complexes.
Par exemple, pour une division avec 2 opérandes entier, le résultat est entier :
>>> 3/2 1
Pour anticiper une des évolutions du langage, vous pouvez aussi utiliser la notation suivante (Pyhon 3.x), testée sur la version 2.5.x :
>>> 3//2 1 >>> 3/2 1 >>> 3.0//2 1.0 >>> 3.1/2 1.55 >>> 3.1//2
1.0 ## partie entiere, mais en virgule flottante !
Si l’un des 2 opérandes est flottant, les opérandes entiers sont convertis en représentation flottante avant le calcul :
>>> 3./2 1.5
Si l’un des 2 opérandes est de type complexe, l’autre opérande est convertit en un nombre complexe ayant une partie imaginaire nulle.
>>> c=b+2 >>> c (4+3j)
Pour les opérateurs usuels et fonctions arithmétques courantes :
Des questions ? éléments de réponses (en anglais)http://docs.python.org/tutorial/introduction.html#numbers. Pour mémoire, nous présentons la table des opérateurs binaires, celle des
opérateurs unaires : + addition - soustraction * multiplication / division // division seuillée % reste de division + plus - moins
Nous avons omis les opérateurs bitwise comme nous l’avons déjà fait lors de la présentation du langage C.
4.2 Les comparaisons et les expressions booléennes
Les opérateurs de comparaisons sont : == égalité != ou <> inégalité
<= , < inférieur ou égal, inférieur strictement >= , > supérieur ou égal, supérieur strictement in est dans (ensemble, dictionnaire- non traités) is vrai si les 2 objets sont en fait le même (ne
sera pas utilisé - non détaillé)
Pour les expressions booléennes, nous retrouvons les 3 opérateurs classiques :
or ou (inclusif) and et
not non
Les passionnés trouveront aussi dans la documentation l’expression condi-tionnelle (pas présentée non plus en C ).
4.3 Les chaines de caractères
C’est beaucoup plus simple qu’avec C ! L’exemple repris du tutoriel ci-dessous montre différentes formes syntaxiques possibles.
>>> ’spam eggs’ ’spam eggs’ >>> ’doesn\’t’ "doesn’t" >>> "doesn’t" "doesn’t" >>> ’"Yes," he said.’ ’"Yes," he said.’ >>> "\"Yes,\" he said." ’"Yes," he said.’
>>> ’"Isn\’t," she said.’ ’"Isn\’t," she said.’
>>> hello = "This is a rather long string containing\n\ ... several lines of text just as you would do in C.\n\
... Note that whitespace at the beginning of the line is\ ... significant."
>>> print hello
This is a rather long string containing
several lines of text just as you would do in C.
Note that whitespace at the beginning of the line is significant. >>>
Encadrées par “ ou ’ avec \ comme caractère d’échappement, elles suivent des règles proches de celles utilisées en langage C. Les principales différences sont dans les facilités de manipulations (par opérateurs) comme nous allons le voir ci-après.
4.4 Concaténation et répétition
L’opérateur + est utilisé pour la concaténation, l’opérateur * pour la répétition d’un motif.
>>> ’LIF’+str(1) ## str() : pour convertir en string ’LIF1’
>>>t=’LIF’+str(1) >>>t + ’ j\’adore !’ "LIF1 j’adore !"
>>> t*5
’LIF1LIF1LIF1LIF1LIF1’ >>> (t + ’ ’)*5
’LIF1 LIF1 LIF1 LIF1 LIF1 ’
4.5 Sous-chaines, indexation
Une chaîne de caractères peut aussi être considérée comme une séquence de crac-tères; il est donc possible de lire un caractère à une position donnée (indexation) :
>>> ’AbCdEfGhIjKL’[1] ## le premier caractère à la position 0 ’b’>>> c=’AbCdEfGhIjKL’
>>> len(c) ## longueur 12
>>> c[0] ’A’
>>> c[1]=’a’ ## mais ATTENTION, ce n’est pas du C ! Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: ’str’ object does not support item assignment >>>
Une nouveauté est l’indexation négative qui définit la position à partir de la fin de chaîne : la position -1 est celle du dernier caractère (len(c)-1 ).
>>> c[-len(c)] ## ou en négatif, à partir de la fin ’A’
Alors, que donnent ? >>> c[-0] >>> c[len(c)]
Un petit tableau pour bien savoir où nous sommes :
A b C d E f G h I j K L
0 1 2 3 4 5 6 7 8 9 10 11
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
Mais en plus, il est possible de représenter une sous-chaine : >>> c[2:9]
’CdEfGhI’
>>> c[-3:-1] ##pour avoir le pénultième et l’antepénultième ’jK’
>>>
Les bornes de l’interval peuvent être omises; la borne gauche sera remplacée par 0, la droite par -1 :
>>> c[:-3] ## tout sauf les 3 derniers ’AbCdEfGhI’
>>> c[3:] ## tout sauf les 3 premiers ’dEfGhIjKL’
>>> c[:] ## tout ’AbCdEfGhIjKL’
>>> c[1:-1] ## qu’obtient-on ? Voici un petit tableau pour s’y retrouver
Nous ne parlerons pas ici des raw string ni des codages Unicode et raw Unicode; nous utiliserons le codage par défaut qui est encore le code ASCII.
Mais contrairement au langage C, le type caractère (char) n’existe pas ! >>> ’a’+ 1 ## cela n’a donc pas de sens (chaine + entier !) Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate ’str’ and ’int’ objects D’autres fonctions ou procédures de manipulation des chaînes sont déjà définies; nous notons ici les plus courantes (pour une liste exhaustive) :
4.6 Résumé du chapitre
Points à retenir de la présentation rapide :
∙ Règles de conversions arithmétiques identiques à celles du langage C ∙ Quelques opérateurs arithmétiques en plus ( **, // )
∙ Pas de type caractère, mais des chaînes de caractères plus simple à ma-nipuler
∙ Concaténation ou répétition de chaînes avec les opérateurs + et *, la
fonc-tion len, et plusieurs méthodes décrites http://docs.python.org/library/stdtypes.html#string-methods.
∙ adressage de sous-chaînes [:]
5 Les listes
C’est le premier type composé que nous voyons : dans SAGE, il sera redéfini pour la représentation des vecteurs et des matrices sous forme de liste de listes (la modification est seulement syntaxique), cas particulier où tous les éléments sont de même type (ou assimilé).
Dans le cas générale, une liste peut contenir des valeurs de type quelconque, y compris des liste :
>>> a = [ 42, ’the answer’, 3./5, ’volume’, [ ’une’, ’liste’, 3]] >>> a
Il est possible aussi de concaténer les listes, de les répéter : >>> [3,]+[4,5] [3, 4, 5] >>> [3]+[4,5] [3, 4, 5] >>> []+[3,4] [3, 4] >>> >>> [3]*4 [3, 3, 3, 3] >>> [ 2,[1]*2] [2, [1, 1]]
Notons la notation pour la liste vide (et remarquons 2 notations possibles pour une liste à un seul élément).
Non seulement, il est aussi possible d’accèder à un élément d’une liste ou à une sous-liste, comme pour les chaînes de caractères, mais aussi de changer la valeur d’un ou plusieurs éléments, ce qui n’était pas possible avec les chaînes de caractères.
Dans la terminologie Python, les types composés (comme les listes) qui au-torisent de modifier les valeurs d’un ou plusieurs éléments sont dit mutable; ceux qui ne l’autorisent pas (comme les chaînes de caractères) sont qualifiés de immutable. Quelques exemples :
>>> a = [ 42, ’the answer’, 3./5, ’volume’] >>> a[-1] ’volume’ >>> a[1:2] [’the answer’] >>> a[1:3] [’the answer’, 0.59999999999999998] >>> a[1:9]
[’the answer’, 0.59999999999999998, ’volume’] >>> a[2]=’3/5’
>>> a
[42, ’the answer’, ’3/5’, ’volume’] >>> a=a+[’HHGTTG’]
>>> a
[42, ’the answer’, ’3/5’, ’volume’, ’HHGTTG’] >>> a=2*a+["don’t PANIC !"]
>>> a
[42, ’the answer’, ’3/5’, ’volume’, ’HHGTTG’, 42, ’the answer’, ’3/5’, ’volume’, ’HHGTTG’, "don’t PANIC !"] Où cela devient intéressant, c’est qu’il est possible de faire des
affecta-tions par tranche de liste. Nous noterons aussi dans les exemples ci-dessous l’utilisation de la fonction len ou de l’opération append.
>>> a[0:5]=[] ## pour retirer les 5 premiers éléments >>> a
>>> b=a[:1]+a[-1:] ## avoir le premier et le dernier >>> b
[42, "don’t PANIC !"]
>>> a[:]=[0]*len(a) ## RAZ d’un vecteur >>> a [0, 0, 0, 0, 0, 0] >>>a.append(1) >>> a [0, 0, 0, 0, 0, 0, 1] >>> m=[ a, a, a, a, a] ## liste de listes
>>> m ## matrice 5 lignes 6 colonnes
[[0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1]]
>>> m[1][0]=2
>>> m ### Attention avec les objets mutables
[[2, 0, 0, 0, 0, 0, 1], [2, 0, 0, 0, 0, 0, 1], [2, 0, 0, 0, 0, 0, 1], [2, 0, 0, 0, 0, 0, 1], [2, 0, 0, 0, 0, 0, 1]]
>>>
>>> m= [ a[:], a[:], a[:], a[:], a[:] ] ## pour faire de que nous souhaitions >>> m [[0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1]] >>> m[1][0]=2 >>> m [[0, 0, 0, 0, 0, 0, 1], [2, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1]]
Comme nous pouvons le constater, les manipulations des listes et notamment les affectations peuvent réserver quelques surprises! De nombreux exercices seront nécessaires pour maîtriser tout cela.
5.1 Listes en compréhension
Python permet aussi de définir des listes en compréhension. Pour cela, il existe notamment la fonction range permettant de créer des listes :
>>> range(3) [0, 1, 2] >>> range(2,3) [2] >>> range(2,4) [2, 3] >>> range(0, -10, -1) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] >>> [ x for x in range(0, -10, -1) if x %2 == 0] [0, -2, -4, -6, -8]
Par exemple pour définir l’ensemble des 11 premières puissances de 2 : >>> [2**p for p in range(0,11)]
ou pour avoir les couples (p,2**p) un peu plus facile à lire : >>> [(p,2**p) for p in range(0,11)]
[(0, 1), (1, 2), (2, 4), (3, 8), (4, 16), (5, 32), (6, 64), (7, 128), (8, 256), (9, 512), (10, 1024)]
Entre () nous découvrons la notion de tuples*, objet **immutable à ne pas confondre avec les listes (mutable). Nous ne parlerons pas plus des tuples qui, à ma connaissance, ne sont pas nécessaires pour travailler avec SAGE.
Ce formalisme est très pratique et permet d’écrire simplement (et sans faire de boucle comme en C ) des opérations complexe comme la somme de 2 vecteurs, soit directement, soit dans une fonction :
>>> v1=[1,2,3] >>> v2=[4,5,6]
>>> v3=[ v1[i]+v2[i] for i in range(len(v1))] >>> v3
[5, 7, 9]
>>> def sommeVect(v1, v2) :
... return [ v1[i]+v2[i] for i in range(len(v1))] ...
>>> sommeVect(v1,v2) [5, 7, 9]
>>> sommeVect([1,2,3,4,5],[6,7,8,9,10]) [7, 9, 11, 13, 15]
5.2 Quelques fonctions et méthodes
Nous citons ci-dessous quelques fonction définies utiles sur les listes : ∙ len pour avoir la longueur
∙ reverse pour l’inversé ∙ zip : par l’exemple
>>> a=[ "a", "b", "c"] >>> b=[1,2,3] >>> z=zip(a,b) >>> z [(’a’, 1), (’b’, 2), (’c’, 3)] >>> zip(*[[1., 0.],[0., 1.],[0.5,0.5]]) ## transposition [(1.0, 0.0, 0.5), (0.0, 1.0, 0.5)] ∙ sorted >>> sorted([ 3, 2, 4, 1, 6, 5 ]) [1, 2, 3, 4, 5, 6]
∙ Pour les autres fonctions ou méthodes sur les listes, nous renvoyons à la documentation
5.3 Résumé du chapitre
∙ les listes doivent être initialisées (ceci est vrai pour tous les types construits)
∙ Il est possible d’accèder à un élément ou une sous-liste [:]
∙ la fonction range() (en combinaison avec for et if ) permet de décrire simplement une suite ou une sous-suite de valeurs
∙ Il est possible de définir une liste en compréhension ou par transformation d’une autre ou plusieurs listes (for)
∙ Le programmeur ne gère pas la mémoire !
6 Le type array
Sans rentrer dans les détails, le langage Python permet de définir de nouveaux types (classes); l’un d’eux permet une implantation des tableaux compatibles avec les autres langages de programmation tel que C. Dans un tableau de type array, tout les éléments sont de même type, celui-ci étant défini à la création. Pour pouvoir l’utiliser, il faut utiliser l’un des modules prédéfinis :
>>> from array import * >>> a=array(’i’, [1,2, 3, 4]) >>> a[2:3] array(’i’, [3]) >>> a[1:3] array(’i’, [2, 3]) >>> v1=[1,2,3] >>> a=array(’i’,v1) >>> a array(’i’, [1, 2, 3])
>>> #mais attention aux types des elements ...
>>> v2=[1,’a’,3] >>> b=array(’i’,v2)
Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: an integer is required
Hormis la contrainte sur le codage des valeurs, la manipulation est identique à celle des listes, c’est pourquoi nous ne détaillerons pas plus et nous renvoyons à la documentation.
6.1 À retenir :
∙ les bibliothèques doivent être importées : from <module> import ... ∙ ce type est utile si des fonctions ecrites dans un lagage comme C sont
utilisés (souvent pour des raisons de performances)
∙ peut-être initialisée à partir d’une liste ( si les types sont compatibles)
7 Un mot sur le contrôle de flot
7.1 l’alternative if
La forme basique : >>> def signe(x) : ... if x < 0 : ... print ("negatif") ... else :... print ("positif ou nul") ... >>> signe(-1) negatif >>> signe(2) positif ou nul >>> signe(0) positif ou nul ou mieux : >>> def signe(x) : ... if x < 0 : ... print ("négatif") ... elif x > 0 : ... print ("positif") ... else : ... print("nul") ... >>> signe(-1) négatif >>> signe(0) nul >>> signe(2) positif
7.2 boucles
Nous avons déjà vu la boucle while (dans fib) qui itère sur une condition. La boucle for permet d’itérer sur une énumération (plus ou moins complexe) :
>>> a=[ "pierre", "paul", "jacques" ] >>> for x in a : ... print x ... pierre paul jacques
>>> for i in range(len(a)) : ... print i, a[i] ... 0 pierre 1 paul 2 jacques
Ils existent des formes plus complexes (avec break, continue, else :) que nous ne traiterons pas ici.
7.3 un petit mot sur les fonctions
Un système d’auto-documentation des fonctions peut être utilisé (extrait de : <http://docs.python.org/tutorial/controlflow.html>)
>>> def my_function():
... """Do nothing, but document it. ...
... No, really, it doesn’t do anything. ... """
... pass ...
>>> print my_function.__doc__ Do nothing, but document it.
No, really, it doesn’t do anything.
7.4 pass
L’instruction qui ne fait rien.
8 Les opérateurs fonctionnels
8.1 map
Cet opérateur permet d’appliquer la même fonction à tous les éléments d’une liste. Par un exemple :
>>> a=[1,2,3]
>>> def inc(x) : return x + 1 ... >>> map(inc, a) [2, 3, 4] >>> a [1, 2, 3]
8.2 reduce
Il permet de réduire une liste par l’application successive d’une fonction à 2 arguments aux éléments d’une liste : * reduce(f,[1,2,3,4]) = f ( f( f(1,2),3), 4) *
>>> def add(a,b) : return a + b ...
>>> reduce(add,[1, 2, 3, 4]) 10
Le cacul est exécuté ainsi : add ( add ( add ( 1, 2), 3), 4 ).
8.3 Remarque
Ces opérateurs seront vus plus en détail lors du cours de LIF3 (”programmetion fonctionnelle et récursive (en langage Scheme)“) avec Mme Guin. Nous les avons présentés ici uniquement si leur utilisation est nécessaire dans les TPs SAGE prévus.
9 Un exemple un peu plus complexe
En C, nous avions écrit le produit d’un vecteur par une matrice (à une trans-position près) :
void matrice_vecteur (float v [4], float m [5][4], float r[5]) { /* donnees : v, m resultat : r */ float s ; int i, j ; for ( i = 0; i < 5; i++ ) { s = 0. ; for ( j = 0; j < 4 ; j++ ) { s = s + m[i][j] + v[j] ; } r[i] = s ; } }
Une version en Python, déjà plus générale car les tailles ne sont pas fixées : >>> def add(x,y): return x+y
...
>>> def vectMat(v,m) : ... r = []
... for i in range(len(m)) :
... r.append( reduce(add,[ m [i][j] * v[j] for j in range(len(v)) ]) ) ... return r
...
>>> vectMat([1./2,2],[[1., 0.],[0., 1.],[0.5,0.5]]) [0.5, 2.0, 1.25]
Une autre version pourrait aussi être (en considérant que pour chaque colonne de la matrice nous effectuons un produit scalaire avec le vecteur) :
>>> def add( x, y ) : return x + y ...
>>> def produitScalaire( v1, v2 ) :
... return ( reduce ( add, [ v1 [ i ] * v2 [ i ] \
... for i in range ( len ( v1 ) ) ] ) ) ...
>>> def vectMat ( v, m ) : ... r = []
... for i in range ( len ( m ) ) :
... r . append ( produitScalaire ( v, m [ i ] ) ) ... return r
...
>>> vectMat([1./2,2],[[1., 0.],[0., 1.],[0.5,0.5]]) [0.5, 2.0, 1.25]
Noter le symbole \ utlisé pour continuer la ligne.
Une autre version sans boucle et dans la 2ème version l’énumération des lignes de m :
>>> def vectMat2 (v, m) :
... return [ produitScalaire ( v, m [ i ] ) for i in range(len(m)) ] ...
>>> vectMat2([1./2,2],[[1., 0.],[0., 1.],[0.5,0.5]]) [0.5, 2.0, 1.25]
>>>
>>> def vectMat2b (v, m) :
... return [ produitScalaire ( v, row ) for row in m ] ...
>>> vectMat2b([1./2,2],[[1., 0.],[0., 1.],[0.5,0.5]]) [0.5, 2.0, 1.25]
Pour les puriste, en une seule fonction : >>> def vectMat3 (v, m) :
... return [reduce (add, [v [j] * r [j] for j in range ( len ( v ) ) ])\ ... for r in m]
...
>>> vectMat3([1./2,2],[[1., 0.],[0., 1.],[0.5,0.5]]) [0.5, 2.0, 1.25]
9.1 Ce qu’il faut retenir :
Pour les programmeurs habitués aux langages procéduraux, il peuvent continuer à écrire leurs algorithmes de manières usuelles, mais ce n’est pas forcément la méthode la plus aisée. Pour les autres, la notation proposée permet de définir de nombreuses séquences (listes, vecteurs, matrices) en compréhension sous une forme plus proche de la notation mathématique (ce qui est souvent plus simple). Donc, ce qui ne change pas, c’est qu’il vaut mieux réfléchir avant de programmer !
10 Ce que nous ne traiterons pas
Nous n’avons pas présenté toutes les richesses du langage Python; volontaire-ment, nous avons omis les présentations des types et des fonctionnalités suivants
:
∙ tuples et les sequences (bien que nous en ayons dit un mot) ∙ sets (les ensembles)
∙ dictionaries ( associations clé:valeurs) ∙ les fonctions récursives
∙ les modules (pour faire des bibliothèques, mais SAGE utilise ses propres bibliothèques)
∙ entrées/sorties : lecture/écriture ainsi que les manipulations de fichiers ∙ le traitement des erreurs et les exceptions
∙ les classes
∙ les expressions lambda
Mais ces éléments ne sont pas nécessaires pour pouvoir manipuler la plate-forme SAGE et vont donc au-delà des objectifs de cette présentation.
11 Conclusions
∙ Nous savons faire des affectations, des boucles, des alternatives, des fonc-tions, utiliser des variables : il ne manque plus grand chose pour pouvoir refaire le monde...
∙ Cependant, nous n’avons fait qu’une présentation rapide sans : – la liste des mots clefs
– les fonctions dites built_in – les méthodes des types présentés
Tous ces points se retrouvant sans problèmes dans les documentations existantes.
∙ L’évaluation sera faite lors des séances de TP.
12 Netographie :
http://docs.python.org/:
∙ ”Tutorial“ c○Copyright 1990-2011, Python Software Foundation.
∙ ”Library Reference“ c○Copyright 1990-2011, Python Software Foundation.
http://www.sagemath.org/help.html#SageStandardDoc:
∙ ”Turoriel SAGE“ c○Copyright 2005--2011, The Sage Development Team. ∙ ”Non-Programmer’s Tutorial for Python“ — from Wikibooks, the open-content textbooks collection, offspring of Wikipedia and probably the eas-iest introduction of all
