Chap1 2 Python
Chap1 2 Python
Chapitre 1
Introduction
Le choix de python
Pourquoi développer en python ? Parce que c’est un langage d’une grande souplesse, qui
permet rapidement d’écrire des codes qui fonctionnent. C’est un langage pour lequel il existe
une communauté très active de développeurs avec des forums où vous pourrez trouver la
solution à de nombreux problèmes et des sites où sont accessibles de nombreux cours et
tutoriaux gratuits et bien faits. Python permet de programmer selon plusieurs paradigmes :
programmation impérative structurée, programmation orientée objet, programmation
fonctionnelle.
C’est un langage Open Source, libre et gratuit. Il est largement utilisé dans la communauté
bioinformatique et il existe des bibliothèques BioPython comportant de nombreuses fonctions
de traitement des données biologiques. De nombreuses autres bibliothèques Python existent :
NumPy ou SciPy pour le calcul numérique, Tkinter pour les interfaces GUI, Matplotlib pour
les graphiques 2D, gnuplot-py pour l’interfaçage avec gnuplot). C’est un langage libre et
ouvert pour lequel on trouve facilement des supports gratuits et disponibles.
Compilation et interprétation
Le code inscrit dans un fichier à l’aide d’un éditeur de texte est appelé programme source. Il
existe deux modes de traduction d’un tel programme source en code binaire exécutable par la
machine : l’interprétation et la compilation.
La compilation consiste à traduire l’intégralité du code source en langage binaire en une seule
fois. Un programme objet est généré par le logiciel compilateur. Le code binaire peut
désormais être exécuté indépendamment du compilateur et du code source. C’est un fichier
exécutable qui peut être conservé (et diffusé) tel quel. Le compilateur n’intervient pas à
chaque exécution du programme, il a été compilé une fois pour toutes.
On ne peut pas générer de binaire compilé ou natif en python. Il n’y a pas ou peu
d’optimisations automatiques de la part de l’interpréteur. Il n’y a pas de vérification statique
du typage.
Chapitre 2
Syntaxe du langage
Lancement de Affichage du
l’interpréteur résultat
python
Fichier source
prog.py
2. Deuxième méthode
#8/usr/bin/python
Mode iteractif :
python
>>> print ‘hello world !’ Instruction python passée à l’interpréteur
hello world ! Résultat affiché
On appelle une fonction en utilisant l’opérateur (). Le passage des arguments se fait par
référence. Une fonction renvoie toujours une valeur en python (comme en C). Les noms de
fonction sont en minuscules, peuvent être composés de plusieurs mots, chacun commençant
par une majuscule (convention).
>>> y = sin(x)
>>> myFuncScreen()
• Affectation simple
>>> a = 10
>>> txt = ‘Quelle belle journée’
Les deux identifiants a et txt sont créés lors de l’affectation. En effet python va évaluer
leur type, réserver la place mémoire nécessaire et faire pointer l’identifiant sur cette zone, et
ceci de manière complètement transparente pour le programmeur.
• Affectation dynamique
Expression Opération
-x Opposé de x
x%y Reste de la division entière de x par y
x/y Division de x et y
x // y Division entière de x par y
x*y Produit de x et y
x–y Différence de x et y
x+y Somme de x et y
x ** y x puissance y
Expression Opération
x < y, x <= y x inférieur (ou égal) à y
x > y, x >= y x supérieur (ou égal) à y
x == y x égal à y
x<> y , x != y x différent de y
x or y, x and y OU et ET logique
not x NON logique
Type Description
Entier : int Utilise le type C long, minimum 32 bits
32 ou -10 ou 0xAF21
Entier long : long Précision illimitée
125L ou 0x10000000000000L
Réel : float Utilise le type C double
3.1416 ou 1.48e25
Complexe : complex 3 + 2j ou 5.1 + 4j
complex(re,im) re + im * j
float(x) Conversion de x en réel
int(x) Conversion de x en entier
long(x) Conversion de x en entier long
De nombreuses autres fonctions sont disponibles dans le module math (fonctions trigonomé-
triques, fonctions exponentielle (exp) et logarithme (log), fonctions d’arrondis (ceil et
floor), racine carré (sqrt) … ainsi que les constantes mathématiques e, pi …).
Pour python, une chaîne de caractères (type string) est une suite de caractères délimitée soit
par des apostrophes ‘hello world !’ soit par des guillemets "hello world !". En
général on utilise des apostrophes sauf si la chaîne contient des apostrophes auquel cas on
utilisera des guillemets pour délimiter la chaîne. Les guillemets triple sont aussi autorisés et
ils permettent d’utiliser des retours à la ligne dans la chaîne, nous les retrouverons pour la
documentation en ligne des code python.
Opération Résultat
x in s Vrai si x ∈ s, faux sinon (x char ou str)
x not in s Vrai si x ∉ s, faux sinon (x char ou str)
s+t Concaténation de s et t (s et t str)
s * n ou n * s Concaténation de s, n fois (n int)
s[i] iième élément de s
s[0] Premier élément de s
s[i:j] Tranche située entre i et j dans s (j exclu)
s[i:j:p] Tranche de i à j par pas de p (i,j,p int)
s[:] Recopie la séquence en entier
len(s) La longueur de s
min(s) Le plus petit élément de s
max(s) Le plus grand élément de s
<, >, ==, != Comparaison alphanumérique
Exemples :
>>> txt= """Ceci est un exemple
...de chaine sur
...plusieurs lignes."""
>>> txt
Le type booléen
Le type bool a été introduit depuis Python 2.3, les constantes True et False avec python
2.2, avant 0 (faux) et 1 (vrai). Le type booléen dérive donc du type int pour des raisons de
compatibilités.
Les séquences
Les séquences sont des données composites c’est à dire une collection de données de type de
base. En python il existe deux grands types de séquences : les séquences modifiables et les
séquences non modifiables.
• Les chaînes de caractères et les tuples sont des séquences non modifiables.
• Les listes sont des séquences modifiables.
• Toutes les opérations sur les listes non modifiables sont disponibles pour les
séquences modifiables.
Nous venons de voir ces méthodes pour les chaînes de caractères (min, max, len, accès aux
éléments d’une séquence, concaténation, x in s …), elles sont donc applicables aux autres
séquences.
Les tuples
Les tuples sont des séquences non modifiables, ils sont notés entre parenthèses où les valeurs
sont séparées par des virgules (les parenthèses sont facultatives mais recommandées).
>>> a = (1,2,3)
>>> type (a)
<type 'tuple'>
>>> a
(1, 2, 3)
Pour définir un tuple à un élément il faut impérativement mettre la virgule après l’élément.
>>> a=(1) # les parenthèses sont facultatives…
>>> type(a)
<type 'int'>
>>> a = 1, # … et la virgule est obligatoire
>>> type(a)
<type ‘tuple’>
>>> a
(1,)
Les listes
Ce sont des séquences modifiables, elles sont notées entre crochets et les valeurs sont
séparées par des virgules. Comme pour les tuples on peut mettre une virgule après le dernier
élément. On accédera aux éléments d’une liste grâce aux fonctions accessibles aux séquences.
Exemple :
>>> l = [1,(2,3),'Toto']
>>> l
[1, (2, 3), 'Toto']
>>> len(l)
3
>>> jour = [‘lundi’, ’mardi’, ’mercredi’, ’jeudi’, ‘vendredi’,
’samedi’, ’dimanche’]
>>> jour[2]
‘mercredi’
Exemple :
>>> del(jour[6])
>>> jour
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi']
>>> append.jour(‘DIMANCHE’)
>>> jour
['lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi',
'DIMANCHE']
Il n’existe que deux types de boucle en python : la boucle for et la boucle while (la boucle do
while n’existe pas ; pas plus que la boucle do until.
La boucle while
Pour itérer tant qu’une condition est vérifiée
while condition :
# bloc d’instructions corps de la boucle
Il existe deux façons de sortir prématurément d’une boucle (quelque soit son type)
break : permet de sortir de la boucle,
Continue : permet de passer immédiatement à l’itération suivante
La boucle for
Pour itérer sur les valeurs d’une séquence.
Exercices du TD1