Mickaël Tits CETIC mickael.tits@cetic.be
C'est un langage interprété: lorsqu'on écrit une instruction, on peut directement l'exécuter. A l'opposé, un langage compilé nécessite l'écriture (et la compilation) d'un programme entier avant de pouvoir le tester. Un langage interprété permet de programmer plus facilement, de manière interactive, de tester facilement un morceau de code. C'est donc un langage idéal pour rapidement développer et tester des prototypes, ou puls particulièrement, des algorithmes d'analyse de données.
C'est un langage haut-niveau: une seule ligne de code permet dans certains cas de réaliser des processus complexe, en cachant les détails liés notamment à la gestion ou la réprésentation des données dans la mémoire de l'ordinateur, ou les opérations arithmétiques ou binaires de bas-niveau. Un langage de haut-niveau rend plus facile le développement d'un programme, et augmente donc la productivité (généralement au détriment de la vitesse d'exécution).
Python est open source: et donc gratuit pour tout le monde, y compris les entreprises.
C'est un langage populaire: la communauté de développeurs est très active, et on trouve facilement sur internet de la documentation et de très nombreux exemples d'utilisation dans tout type d'application. De plus, la communauté développe et maintient de très nombreuses librairies développées et/ou compatibles avec Python, permettant d'augmenter la productivité lors de l'écriture d'un programme, particulièrement dans les domaines des mathématiques et des sciences des données.
(source: https://stackoverflow.blog/2017/09/06/incredible-growth-python/)
Python est donc le langage idéal pour développer et tester facilement et rapidement un algorithme. Le désavantage principal est sa lenteur: l'exécution d'un langage haut-niveau et interprété est généralement plus lente que celle d'un langage compilé.
Dans un contexte ou la vitesse d'exécution est cruciale (e.g. pour des systèmes embarqués, ou traitement de données en temps réel, des programmes réactifs), Python n'est pas le langage idéal. A l'inverse, dans un contexte où la vitesse de développement est cruciale (développement de prototypes, d'applications business concurrentes), la productivité offerte par le langage Python en fait un bon choix.
#Assignation d'une variable, dont l'identifiant est "prix"
prix = 300000
#Appel d'une fonction de base, "print", qui permet d'imprimer la variable dans la console
print(prix)
300000
#On peut écrire plusieurs instructions sur une seule ligne, en les séparant avec le symbole ;
a = 100000; b = 200000; c = 300000
#On peut écrire Une instruction sur plusieurs lignes, en la découpant avec le symbole \
print(a + b \
+ c)
600000
#Oups, la variable prix2 n'existe pas: l'interpréteur ne comprend donc pas l'instruction et renvoie un message d'erreur pour le signaler. Il faut bien sûr assigner une variable avant de l'utiliser.
print(prix + \
prix2)
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-3-f252c2930f2b> in <module>() ----> 1 print(prix + prix2) NameError: name 'prix2' is not defined
prix2 = 250000
print(prix + \
prix2)
550000
prix2
250000
Les identifiants d'une variable s'écrivent en un mot, peuvent contenir des lettres, des nombres, et "_", mais ne peuvent pas commencer par un nombre. Ils ne peuvent pas contenir de symboles spéciaux tels que !, @, #, $, %.
_variable = 1
#Oups: ces identifiants sont invalides => l'interpréteur renvoie un message d'erreur.
2variable = 1
v@ri@ble = 1
File "<ipython-input-6-512037641b49>", line 3 2variable = 1 ^ SyntaxError: invalid syntax
Certains mots-clés ne peuvent pas être utilisés comme identifiants, car ils ont une signification bien précise pour l'interpréteur python. C'est par exemple le cas de del
qui est une instruction en soi, et qui permet en l'occurrence de supprimer une variable.
Pour éviter tout risque de confusion, il est également préférable d'éviter d'utiliser comme identifiant ceux définissant déjà des fonctions de base de Python, tel que print
.
#Oups, j'ai redéfini une fonction de base. L'interpréteur ne comprend plus alors l'appel à la fonction.
print = 1
print("Rue de Bruxelles 61, Namur")
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-7-8be82683882c> in <module>() 1 print = 1 ----> 2 print("Rue de Bruxelles 61, Namur") TypeError: 'int' object is not callable
#Supprimons la variable créée avec le mot-clé "del"
del print
#La fonction de base fonctionne de nouveau
print("Rue de Bruxelles 61, Namur")
Rue de Bruxelles 61, Namur
#Oups, j'ai utilisé un mot-clé comme nom de variable
del = 1
File "<ipython-input-9-521f61ecd265>", line 1 del = 1 ^ SyntaxError: invalid syntax
On identifie généralement quatre types de données de base en Python.
Trois sont des données numériques:
bool
): True, False
int
): -42, 0, 1, 42, 250000
float
): 42.0, 3.14, -0.01
La dernière permet de représenter du texte:
string
): "Hello World!"
ou 'Hello World!'
On définit un string
en entourant le texte des symboles "double quote" ou 'simple quote'. Ainsi, 4 représente un int
, mais "4" représente un string
.
my_int = 250000
my_float = 1.23
my_bool = True
my_string = "Rue de Bruxelles 61, Namur"
#Veuillez notez les guillements pour définir le string
my_int, my_float, my_bool, my_string
(250000, 1.23, True, 'Rue de Bruxelles 61, Namur')
type(my_string)
str
my_string = 5.0
type(my_string)
float
my_int1 = 2
my_int2 = 2
my_float1 = 4.2
my_bool = True
my_string1 = "Rue de Bruxelles"
my_string2 = ' 61'
my_string3 = " Namur"
whos
Variable Type Data/Info ------------------------------- a int 100000 b int 200000 c int 300000 my_bool bool True my_float float 1.23 my_float1 float 4.2 my_int int 250000 my_int1 int 2 my_int2 int 2 my_string float 5.0 my_string1 str Rue de Bruxelles my_string2 str 61 my_string3 str Namur prix int 300000 prix2 int 250000
int
en str
: str(4)
=> "4"str
en int
: int("4")
=> 4float
en int
: int(4.8)
=> 4bool
: bool(""), bool(0.0), bool(0)
=> False
. Tout le reste renvoie True
print(bool(""), bool(0.0), bool(0))
print(bool("0"), bool(-1.2), bool(-10), bool("hi"))
str(True), str(False), int(True), int(False), float(True), float(False)
False False False True True True True
('True', 'False', 1, 0, 1.0, 0.0)
int(4.9), float("3.5"), str(3.5), bool(4.2), bool(-2), bool(0)
(4, 3.5, '3.5', True, True, False)
Les opérations de base peuvent se faire entre différents types de données numériques, en réalisant des conversions implicites de types si nécessaire:
#Operations sur un seul type de donnée
print( my_int1+my_int2, 111-69, 6*7, (my_int1 + my_int2) * 10 + 2)
4 42 42 42
#Opération compatibles entre types différents (entier, float, booléen)
print(my_int1 + my_float1,\
my_float1 + my_bool,\
(my_int1 + my_int2 - 3.5) * 5 / 2)
6.2 5.2 1.25
#Exposant
print(2 ** 42)
#Modulo
print(11%3)
4398046511104 2
#La division entière renvoie un float (contrairement au langage C)
8/3
2.6666666666666665
Les string peuvent être additionnés entre eux (+), ou multiplés par un entier (*****):
#Les opérations sur les strings sont des concaténation
address = my_string1 + my_string2 + my_string3
print(address)
print("hi" * 3)
Rue de Bruxelles 61 Namur hihihi
my_int1 + my_string1
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-23-4f5a116eafab> in <module>() ----> 1 my_int1 + my_string1 TypeError: unsupported operand type(s) for +: 'int' and 'str'
string = '4'
string + str(my_int1)
'42'
my_int1 + int(string)
6
+=
, *=
, -=
, /=
permettent à la fois de réaliser une opération arithmétique et une assignation.L'instruction "
toto += 1
" est équivalente à "toto = toto + 1
"
#Self-operation
toto = 1
toto += 100
toto *= 2
toto -= 76
toto /= 3
toto
42.0
hi = 11
hi %= 3
hi
2
is
est équivalent à l'opérateur ==
is not
est équivalent à l'opérateur !=
Ces opérateurs sont généralement utilisés avec les conditions: if, elif, ..., elif, else (voir plus loin).
#assignation de variable
a = 42
# l'opérateur de test d'égalité "==" renvoie un booléen, ne doit surtout pas être confondu avec l'opération d'assignation "=" (c'est une source fréquente de bugs dans les conditions)
a == 42 ,\
a != 42 ,\
a > 3 ,\
a <= 42 ,\
a is 42 ,\
a is not 42
(True, False, True, True, True, False)
and
: "et", *
logique: True and False = False (1 * 0 = 1)or
: "ou", +
logique: True or False = True (1 + 0 = 1)Remarque: en logique, 1 + 1 = 1 (True or True = True)
Ces opérateurs sont généralement utilisés avec les opérateurs de tests, pour vérifier des conditions multiples (voir plus loin).
print(not True)
print((a > 41) and (a < 43))
print((a == 42) or (a == 43))
False True True
Certaines instructions permettent de contrôler le flux du code:
En Python, l'indentation de chaque ligne de commande est donc très importante, puisque c'est elle qui définit le flux des instructions.
a = 1
b = 2
#On ne peut pas changer d'indentation sans définir un comportement
#pour ce nouveau bloc de code (avec une condition ou une boucle)
c = 3
d = 4
File "<ipython-input-30-cf34d701e9fd>", line 5 c = 3 ^ IndentationError: unexpected indent
Les mot-clés if
, elif
, et else
permettent de définir un flux conditionnel d'instructions:
if condition:
" : si la condition est vraie (True
), le bloc d'instruction indenté sous cette condition et réaliséelif condition2:
": si la condition précédente était fausse (dans le if
précédent), et que cette condition2 est vraie, le bloc d'instruction indenté sous cette condition et réaliséelse:
": si toutes les conditions précédentes étaient fausses, le bloc indenté suivant est réalisépass
#condition = True
a = 42
condition = a == 43
if condition:
print("C'est vrai!")
if condition == True:
print("C'est vraiment vrai!")
if condition == False:
print("C'est faux!")
if not condition:
print("Ce n'est pas vrai!")
C'est faux! Ce n'est pas vrai!
prix_maison = 150000
condition = prix_maison < 200000
#condition = a == 43
if condition:
print("C'est pas cher!")
else:
print("C'est cher!")
C'est pas cher!
PER = 35 #price_earning_ratio
if PER < 0:
pass #il ne se passe rien
elif PER < 10:
print("J'achète!")
elif PER <= 30:
print("Hodl!")
else:
print("Je vends!")
Je vends!
Les boucles permettent de définir un flux itératif d'instructions:
while condition:
: on éxécute le même bloc d'instructions itérativement tant qu'on respecte une conditionfor variable in variable_set:
: on exécute le bloc d'instructions itérativement sur un ensemble d'élémentscount = 0
while count < 5:
print("Je suis dans une boucle while depuis " + str(count) + " itérations")
count += 1
Je suis dans une boucle while depuis 0 itérations Je suis dans une boucle while depuis 1 itérations Je suis dans une boucle while depuis 2 itérations Je suis dans une boucle while depuis 3 itérations Je suis dans une boucle while depuis 4 itérations
for i in range(0, 5):
print("Je suis à l'itération", i)
Je suis à l'itération 0 Je suis à l'itération 1 Je suis à l'itération 2 Je suis à l'itération 3 Je suis à l'itération 4
for year in range(9,50):
if year % 4 == 0:
print("Année bissextile!")
continue #continuer directement la suite de la boucle
if year == 18:
print("Adulte!")
break #sortie d'une boucle
print(year)
9 10 11 Année bissextile! 13 14 15 Année bissextile! 17 Adulte!
prix = 100000
mine = False
while True:
#la condition est toujours vraie, c'est une boucle infinie;
#il faut donc au moins inclure un "break"
#dans le bloc d'instruction pour permettre une sortie de la boucle
#(sinon il faut arrêter le programme manuellement)
prix += 20000
print(prix)
if prix > 150000 and prix < 200000 and mine == False:
print("j'achète")
mine = True
elif prix > 200000 and mine:
print("Je revends")
mine = False
break
120000 140000 160000 j'achète 180000 200000 220000 Je revends
#Boucle infinie
while True:
pass
--------------------------------------------------------------------------- KeyboardInterrupt Traceback (most recent call last) <ipython-input-38-648a2bab0435> in <module>() 1 while True: ----> 2 pass KeyboardInterrupt:
Approximation de $\pi$:
$\pi = 4\sum_{n=0}^{\infty} \cfrac {(-1)^n}{2n+1} = 4\left( \frac11- \frac13+ \frac15- \frac17+- \cdots\right)$
(Remarque: ce n'est pas la meilleure méthode d'estimation mais elle est facile à coder, ce qui en fait un bon exemple de programme mathématique)
k=3
series=1
previous_pi = 0
new_pi = 10
epsilon = 10**-5
while abs(new_pi - previous_pi) > epsilon:
previous_pi = new_pi
series = series - 1/k + 1/(k+2)
k+=4
#estimations successives de pi
new_pi = 4*series
#afficher le résultat toutes les 5 itérations
if (k-3)%20 == 0:
#afficher le résultat sur la même ligne
print(new_pi, end = ' ')
print('')
print(new_pi)
3.232315809405594 3.189184782277596 3.1738423371907505 3.1659792728432157 3.1611986129870506 3.157984995168666 3.155676462307475 3.1539378622726155 3.1525813328751204 3.1514934010709914 3.150601479819498 3.149856975293274 3.1492261301786892 3.1486847629938386 3.1482150975379377 3.1478037738120017 3.147440556810415 3.147117473309498 3.1468282198062982 3.1465677471829556 3.1463319634705034 3.1461175173068994 3.1459216376375845 3.1457420133232326 3.1455767015256 3.145424057153498 3.1452826779291465 3.145151361183851 3.145029069561572 3.1449149035588526 3.144808079362397 3.1447079108290805 3.1446137947323693 3.14452519860463 3.1444416506576474 3.1443627313783775 3.144288066483858 3.1442173209855673 3.1441501941646153 3.144086415298761 3.1440257400132237 3.143967947151556 3.1439128360821247 3.1438602243710556 3.1438198223201614
prix = 100000
mine = False
while True:
prix += 20000
print(prix)
if prix > 150000 and prix < 200000 and mine == False
print("j'achète")
mine = True
elif prix > 200000 and mine:
print("Je
revends")
mine = False
break
prix = 100000
mine = False
while True:
prix += 20000
print(prix)
if prix > 150000 and prix < 200000 and mine == False:
print("j'achète")
mine = True
elif prix > 200000 and mine:
print("Je revends")
mine = False
break
#Types de base
250000 #entier
0.12 #float
'42' ou "42" #string
True False #booléens
#Opérateurs de test
is
in
not
and
or
#Boucles
for
while
#Conditions
if
elif
else
pass #Instruction nulle (il ne se passe rien)
break #Sortie de boucle
continue #On passe à l'itération suivante dans une boucle
#Quelques fonctions de base
print
range
type
abs
#Fonctions de conversion de type (casting)
int
float
bool
str
Maintenant que vous connaissez les bases du Python, vous pouvez passer au Chapitre 2: Les collections d'objets Python