Programmer en Python (Le résumé)

Programmer en Python le résumé du résumé

Expressions

Constantes numeriques

Une constante litterale est l’expression ecrite d’une valeur connue ; exemples : 12, -5, 3.5, 0, etc.
La donnee representee par une constante a toujours un type qui determine ses proprietes formelles (comme : quelles operations la donnee peut-elle subir ?) et materielles (comme : combien d’octets la donnee occupe-t-elle dans la memoire de l’ordinateur ?). La maniere la plus simple et la plus able de conna^tre le type d’une expression consiste a poser la question a Python. Exemple d’une session de telles questions et reponses :
>>> type(0) <type ’int’>
>>> type(-5) <type ’int’>
>>> type(2000000000) <type ’int’>
>>> type(3000000000) <type ’long’>
>>> type(-5.0) <type ’float’>
>>> type(6.0221417e+023) <type ’float’>
>>>
En ignorant la presentation biscornue <type ’un type’> des reponses, le dialogue precedent nous apprend, ou du moins nous suggere, que { sans surprise, des constantes comme 0, -5 ou 2000000000 representent des nombres entiers (type int), { lorsqu’un nombre entier est trop grand pour ^etre represent comme un entier ordinaire, Python le code automatiquement comme un entier long (type long) ; c’est tres pratique, mais il faut savoir que les operations arithmetiques sur de tels nombres sont moins rapides que celles sur les entiers ordinaires, { des qu’une constante numerique comporte un point, qui joue le r^ole de virgule decimale, Python comprend qu’il s’agit d’un nombre decimal, on dit plut^ot ottant, et le represente en machine comme tel (type float), { lorsque les nombres decimaux sont tres grands ou tres petits on peut employer la « notation scienti que » bien connue ; par exemple, la constante 6.0221417e+023 represente le nombre 6; 0221417 1023 ou encore 602214170000000000000000, { le caractere ottant d’un nombre est « contagieux » : si une operation arithmetique a un operande entier et un operande ottant, alors pour e ectuer l’operation l’entier est d’abord converti en ottant et l’operation est faite selon les regles des nombres ottants ; exemple : le resultat de la multiplication 1.0 * 5 est le nombre ottant 5.0.

Variables

Un identi cateur est une suite de lettres et chi res qui commence par une lettre et n’est pas un mot reserv (comme if, else, def, return, etc.). Le caractere _ est consider comme une lettre. Exemples : prix, x, x2, nombre_de_pieces, vitesseDuVent, etc. Majuscules et minuscules n’y sont pas equivalentes : prix, PRIX et Prix sont trois identi cateurs distincts.
Une variable est constituee par l’association d’un identi cateur a une valeur. Cette association est creee lors d’une a ectation, qui prend la forme variable = valeur
A la suite d’une telle a ectation, chaque apparition de la variable ailleurs qu’a gauche d’une autre a ectation represente la valeur en question… jusqu’a ce qu’une nouvelle a ectation associe une autre valeur a la variable. On confond parfois le nom de la variable (c.-a-d. l’identi cateur) et la variable elle-m^eme (l’association du nom a une valeur) ; c’est sans gravite.
Si un identi cateur n’a pas et a ect (en toute rigueur il n’est donc pas un nom de variable) son emploi ailleurs qu’au membre gauche d’une a ectation est illegale et provoque une erreur. Session Python de demonstration :
>>> nombre
Traceback (most recent call last):
File « <stdin> », line 1, in ?
NameError: name ’nombre’ is not defined
>>> nombre = 10
>>> nombre
10
>>> nombre = 20.5
>>> nombre
20.5
>>>
Comme on le voit sur cet exemple, en Python :
1. Les variables n’ont pas besoin d’^etre declarees (c’est-a-dire prealablement annoncees), la premiere a ec-tation leur tient lieu de declaration.
2. Les variables ne sont pas liees a un type (mais les valeurs auxquelles elles sont associees le sont forcement) : la m^eme variable nombre a et associee a des valeurs de types di erents (un int, puis un float).

Cha^nes de caracteres

Une donnee de type cha^ne de caracteres est une suite de caracteres quelconques. Une constante cha^ne de ca-racteres s’indique en ecrivant les caracteres en question soit entre apostrophes, soit entre guillemets : ’Bonjour’ et « Bonjour » sont deux ecritures correctes de la m^eme cha^ne.
Si la cha^ne doit contenir un des caracteres ’ ou  » cela fournit un critere pour choisir l’une ou l’autre maniere de l’ecrire : ’ »Oui » dit-il’ ou « L’un ou l’autre ». Une autre maniere d’eviter les problemes avec le caractere d’encadrement consiste a l’inhiber par l’emploi de \, comme dans la cha^ne ’Il n\’a pas dit « oui »’.
L’encadrement par de triples guillemets ou de triples apostrophes permet d’indiquer des cha^nes qui s’etendent sur plusieurs lignes :
>>> s = «  » »Ceci est une cha^ne comportant plusieurs lignes. Notez que les blancs en t^ete de ligne sont conserves » » »
>>> s
’Ceci est une cha^ne\ncomportant plusieurs lignes. Notez que\n les blancs en t^ete de ligne\nsont conserves’
>>>
L’a chage basique d’une telle cha^ne est decevant (voir ci-dessus) mais montre bien que les ns de ligne, representes par le signe \n, ont et conserves. L’a chage a l’aide de la fonction print est plus esthetique :
>>> print s
Ceci est une cha^ne comportant plusieurs lignes. Notez que les blancs en t^ete de ligne sont conserves
>>> Concatenation. L’operateur + applique a deux cha^nes de caracteres produit une nouvelle cha^ne qui est la concatenation (c’est-a-dire la mise bout-a-bout) des deux premieres :
>>> ’Nabucho’ + ’donosor’ ’Nabuchodonosor’
>>>  Acces a un caractere individuel. On accede aux caracteres d’une cha^ne en considerant celle-ci comme une sequence indexee par les entiers : le premier caractere a l’indice 0, le second l’indice 1, le dernier l’indice n 1, n etant le nombre de caracteres. Exemples :
>>> s = ’Bonjour’
>>> s[0]
’B’
>>> s[6]
’r’
>>> s[-1]
’r’
>>>
Le nombre de caracteres d’une cha^ne s est donne par l’expression len(s). Pour acceder aux caracteres a la n d’une cha^ne il est commode d’employer des indices negatifs : si i est positif, s[-i] est la m^eme chose que s[len(s) – i].
Tranches. On peut designer des tranches dans les cha^nes ; la notation est cha^ne[debut: n] ou debut est l’indice du premier caractere dans la tranche et n celui du premier caractere en dehors de la tranche. L’un et l’autre de ces deux indices peuvent ^etre omis, et m^eme les deux. De plus, ce mecanisme est tolerant envers les indices trop grands, trop petits ou mal places :
>>> s = ’Bonjour’
>>> s[3 :5]
’jo’
>>> s[3 :]
’jour’
>>> s[ :5]
’Bonjo’
>>> s[ :] ’Bonjour’
>>> s[6 :3]
’’
>>> s[-100 :5] ’Bonjo’
>>> s[3 :100] ’jour’
>>>
Les cha^nes de caracteres sont immuables : une fois creees il ne peut rien leur arriver. Pour modi er des caracteres d’une cha^ne on doit construire une nouvelle cha^ne qui, si cela est utile, peut remplacer la precedente. Par exemple, proposons-nous de changer en ’J’ le ’j’ (d’indice 3) de la cha^ne precedente :
>>> s
’Bonjour’
>>> s[3] = ’J’
Traceback (most recent call last):
File « <stdin> », line 1, in ?
TypeError: object doesn’t support item assignment
>>> s = s[ :3] + ’J’ + s[4 :]
>>> s
’BonJour’
>>>

Operateurs

Operateurs arithmetiques.
+, -, * : addition, soustraction, multiplication. Ces operateurs obeissent a la regle dite « du plus fort » : si un des operandes est ottant, l’autre operande est converti si necessaire en ottant et l’operation et le resultat sont ottants. Si, au contraire, les deux operandes sont entiers, l’operation et le resultat sont entiers.
/ : division. Obeit a la m^eme regle que les trois precedents, mais on prendra garde au fait que cela peut ^etre surprenant : 3/2 vaut 1 et 2/3 vaut 0.
Pour obtenir un resultat ottant il faut se debrouiller pour qu’au moins un des operandes soit ottant : 3.0/2 ou float(3)/2 valent bien 1.5.
Attention : float(3/2) vaut 1.0, car la conversion en float intervient apres la perte des decimales.
% : reste de la division euclidienne, celle qu’on apprend a l’ecole elementaire 3 : si a et b sont entiers alors a/b est le quotient et a%b le reste de la division de a par b.
En toute rigueur cette operation ne devrait ^etre de nie que pour deux operandes entiers, mais Python se debrouille pour la faire marcher m^eme avec des operandes ottants.
** : puissance : a**b vaut ab, c’est-a-dire a aa si b est entier, eb log a sinon.
Priorite des operateurs. Les operateurs multiplicatifs *, / et % ont une priorite superieure a celle des operateurs additifs + et -. Cela signi e, par exemple, que l’expression a b + c exprime une addition (dont le premier terme est le produit a b). L’emploi de parentheses permet de contourner la priorite des operateurs. Par exemple, l’expression a (b + c) represente bien une multiplication (dont le second facteur est l’addition b + c).
3. Etant donnes deux nombres entiers a et b, avec b > 0, faire la division euclidienne de a par b consiste a determiner deux nombres entiers q et r veri ant a = b q + r et 0 r < b. On dit alors que q est le quotient et r le reste de la division de a par b. En Python on a donc a/b = q et a%b = r.
Heureusement, ce qu’il faut savoir en programmation a propos de la priorite des operateurs co ncide avec la pratique constante en algebre (rappelez-vous « une expression est une somme de termes, un terme est un produit de facteurs ») ; c’est pourquoi nous ne developperons pas davantage cette question ici.
Operateurs de comparaison.
==, != : egal, non egal.
<, <=, >, >= : inferieur, inferieur ou egal, superieur, superieur ou egal.
La regle du plus fort vaut aussi pour les comparaisons : les deux operandes sont amenes a un type commun avant l’evaluation de la comparaison.
Conformement a l’habitude repandue, la priorite des operateurs de comparaison est inferieure a celle des ope-rateurs arithmetiques. Ainsi, l’expression a == b + c signi e bien a == (b + c).
Booleens et operateurs booleens. Le resultat d’une comparaison comme a == b est de type booleen ; ce type ne possede que deux valeurs, False (faux) et True (vrai).
A certains endroits, comme les conditions des instructions if ou while, le langage prescrit la presence d’ex-pressions dont le resultat doit ^etre de type booleen. Par une tolerance ancienne, maintenant decouragee, on peut mettre a la place une expression quelconque ; elle fonctionnera comme un booleen a l’aide de la convention suivante :
{ seront tenus pour faux : False, None, le zero de n’importe quel type numerique (0, 0L, 0.0), la cha^ne de caracteres vide et toute structure de donnees vide (liste, ensemble, table associative, etc.),
{ toute autre valeur sera tenue pour vraie.
Les connecteurs logiques sont { not (negation) : not a est vraie si et seulement si a est fausse,
{ and (conjonction) : a and b est vraie si et seulement si a et b sont toutes deux vraies, { or (disjonction) : a or b est vraie si et seulement si au moins une deux expressions a, b est vraie.
Notez que les operateurs and et or sont « optimises » de la maniere suivante : le premier operande est evalu d’abord ; si sa valeur permet de predire le resultat de l’operation (c.-a-d. si a est faux dans a and b ou vrai dans a or b) alors le second operande n’est m^eme pas evalue. Cela permet d’ecrire des expressions dont le premier terme « protege » le second, comme (rappelez-vous que diviser par zero est une erreur qui plante le programme) :
if (y != 0) and (x / y > M) …

Structures de controle

Python et l’indentation. L’indentation (c’est-a-dire la marge blanche laissee a gauche de chaque ligne) joue un r^ole syntaxique et permet d’economiser les accolades f…g et les begin…end d’autres langages. En contrepartie, elle obeit a des regles strictes :
1. Une sequence d’instructions (instructions consecutives, sans subordination entre elles) est faite d’instruc-tions ecrites avec la m^eme indentation.
2. Dans une structure de contr^ole (instruction if, for, def) une sequence d’instructions subordonnees doit avoir une indentation superieure a celle de la premiere ligne de la structure de contr^ole. Toute ligne ecrite avec la m^eme indentation que cette premiere ligne marque la n de la sequence subordonnee.

Instruction conditionnelle

Syntaxe :
if condition1 :
instruction1
…
instructionp
elif condition2 :
instructionp+1
…
instructionq
else :
instructionq+1
…
instructionr
L’organigramme de la gure 2 explique l’execution de l’instruction conditionnelle.

1 Mise en place 
1.1 Obtenir Python
1.2 Utiliser Python
1.3 Se faire aider par eclipse
2 Expressions 
2.1 Constantes numeriques
2.2 Variables
2.3 Cha^nes de caracteres
2.4 Operateurs
3 Structures de contr^ole 
3.1 Instruction conditionnelle
3.2 Boucle tant que
3.3 Boucle pour
3.4 Break et else dans les boucles
4 Structures de donnees 
4.1 Tuples
4.2 Listes
4.3 Ensembles
4.4 Dictionnaires
4.5 Tableaux
5 Fonctions 
5.1 Notions et syntaxe de base
5.2 Variables locales et globales
5.3 Plus sur les parametres formels
5.4 Fonctions recursives
5.5 Forme lambda et list comprehension
5.6 Cha^ne de documentation
6 Entrees-sorties 
6.1 Acquisition de donnees au clavier
6.2 Achage de donnees mises en forme
6.3 Fonctions pour les chiers
6.4 Exemples de traitement de chiers
7 Annexes 
7.1 Operations sur les sequences
7.2 Les scripts donnes en exemple