Open In Colab

Mickaël Tits CETIC [email protected]

Chapitre 1 - Introduction au langage de programmation Python

Pourquoi Python ?

  1. 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 plus particulièrement, des algorithmes d'analyse de données.

  2. 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 repré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).

  3. Python est open source: et donc gratuit pour tout le monde, y compris les entreprises.

  4. 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.

Texte alternatif…

(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 où 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.

Instructions

  • Les instructions permettent de commander l'interpréteur Python, c'est-à-dire un système qui comprend les instructions et les traduit en traitements sur des données binaires, représentées sous forme d'objets informatiques.
  • Par défaut, chaque ligne de code correspond à une instruction
  • Les instructions sont interprétées séquentiellement par l'interpréteur Python.
  • Il existe différents types d'instructions, telles que des assignations de variables, des opérations, des appels de fonctions, des conditions, des boucles, etc. que nous allons voir ci-dessous.
In [0]:
#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)
In [0]:
#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)
In [0]:
#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)
In [0]:
prix2 = 250000
print(prix + \
     prix2)
In [0]:
prix2

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 !, @, #, $, %.

In [0]:
_variable = 1
#Oups: ces identifiants sont invalides => l'interpréteur renvoie un message d'erreur.
2variable = 1
v@[email protected] = 1

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.

In [0]:
#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")
In [0]:
#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")
In [0]:
#Oups, j'ai utilisé un mot-clé comme nom de variable
del = 1

Types de données de base

On identifie généralement quatre types de données de base en Python.

Trois sont des données numériques:

  • Booléen (bool): True, False
  • Nombre entier (int): -42, 0, 1, 42, 250000
  • Nombre décimal à virgule flottante (float): 42.0, 3.14, -0.01

La dernière permet de représenter du texte:

  • Chaîne de caractères (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.

Assignation dynamique

  • Pas besoin de définir le type d'une variable, l'interpréteur Python comprend tout seul :
In [0]:
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
In [0]:
my_int, my_float, my_bool, my_string
  • La fonction "type" permet de vérifier le type d'une variable :
In [0]:
type(my_string)
  • On peut également modifier dynamiquement le type des variables :
In [0]:
my_string = 5.0
type(my_string)
In [0]:
my_int1 = 2
my_int2 = 2
my_float1 = 4.2
my_bool = True
my_string1 = "Rue de Bruxelles"
my_string2 = ' 61'
my_string3 = " Namur"
  • La commande "whos" permet de visualiser l'ensemble des variables actuellement présentes dans le programme :
In [0]:
whos

Conversion de types (casting)

  • Lorsque c'est possible, un type de données peut être converti vers un autre type de données.
    • convertir un int en str: str(4) => "4"
    • convertir un str en int: int("4") => 4
    • convertir un float en int: int(4.8) => 4
    • conversion en bool: bool(""), bool(0.0), bool(0) => False. Tout le reste renvoie True
In [0]:
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)
In [0]:
int(4.9), float("3.5"), str(3.5), bool(4.2), bool(-2), bool(0)

Opérations de base

Opérations arithmétiques

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:

  • Les int, float et bool peuvent être additionnés (+), multiplés (*), divisés (/), ou soustraits (-) entre eux.
  • L'opérateur ** et un opérateur de puissance (exposant): 2**10 => 1024
  • L'opérateur % et un modulo (reste de la division entière): 11%3 => 2
In [0]:
#Operations sur un seul type de donnée
print(  my_int1+my_int2,   111-69,   6*7,   (my_int1 + my_int2) * 10 + 2)
In [0]:
#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)
In [0]:
#Exposant
print(2 ** 42)
#Modulo
print(11%3)
In [0]:
#La division entière renvoie un float (contrairement au langage C)
8/3

Opérations sur des string

Les string peuvent être additionnés entre eux (+), ou multiplés par un entier (*):

  • Deux string peuvent être additionnés, ce qui résulte en une concaténation: "hell" + "o" => "hello"
  • Un string peut être multiplié par un entier, ce qui résulte en une concaténation multiple du string: "hi"*3 => "hihihi"
In [0]:
#Les opérations sur les strings sont des concaténation
address = my_string1 + my_string2 + my_string3
print(address)
print("hi" * 3)
  • Les opérations invalides (telle qu'additionner un string avec une variable numérique), renvoient une erreur:
In [0]:
my_int1 + my_string1
In [0]:
string = '4'
string + str(my_int1)
In [0]:
my_int1 + int(string)

Opérateurs spéciaux: +=, *=, -=, /=, **=, %=

  • Les opérateurs spéciaux +=, *=, -=, /= permettent à la fois de réaliser une opération arithmétique et une assignation.

    L'instruction "toto += 1" est équivalente à "toto = toto + 1"

In [0]:
#Self-operation
toto = 1
toto += 100
toto *= 2
toto -= 76
toto /= 3
toto
In [0]:
hi = 11
hi %= 3
hi

Opérateurs de tests

  • test d'égalité: ==
  • test d'inégalité: !=
  • test de supériorité et infériorité stricte: > et <
  • inférieur/supérieur ou égal: <= et >=
  • le mot-clé is est équivalent à l'opérateur ==
  • le mot-clé 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).

In [0]:
#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

Opérateurs logiques

  • and: "et", * logique: True and False = False (1 * 0 = 0)
  • 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).

In [0]:
print(not True)

print((a > 41) and (a < 43))

print((a == 42) or (a == 43))

Contrôle du flux des instructions

Certaines instructions permettent de contrôler le flux du code:

  • Les conditions permettent de réaliser un bloc d'instructions, ou de l'éviter, ou encore de choisir un bloc d'instructions parmi plusieurs.
  • Les boucles permettent de repasser plusieurs fois, de manière itérative, par le même bloc d'instructions
  • Pour différencier les différents blocs d'instructions, on utilise l'indentation (en utilisant des Tab, ou des Whitespace)

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.

In [0]:
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

Conditions

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 est 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 est réalisé
  • "else:": si toutes les conditions précédentes étaient fausses, le bloc indenté suivant est réalisé
  • Attention à l'indentation et au symbole ":" ! C'est le bloc indenté après le symbole ":" qui dépend de la condition
  • Si on veut spécifier un bloc d'instruction qui n'exécute rien, on peut utiliser le mot-clé pass
In [0]:
#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!")
In [0]:
prix_maison = 150000

condition = prix_maison < 200000
#condition = a == 43

if condition:
  print("C'est pas cher!")
else:
  print("C'est cher!")
In [0]:
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!")

Boucles

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 condition
  • for variable in variable_set:: on exécute le bloc d'instructions itérativement sur un ensemble d'éléments
In [0]:
count = 0
while count < 5:
	print("Je suis dans une boucle while depuis " + str(count) + " itérations")
	count += 1
In [0]:
for i in range(0, 5):

  print("Je suis à l'itération", i)
In [0]:
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)
In [0]:
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
  
In [0]:
#Boucle infinie
while True:
  pass

Bonus - Exemple minimaliste: un petit programme mathématique

Approximation de $\pi$:

$\pi = 4\sum_{n=0}^{\infty} \cfrac {(-1)^n}{2n+1} = 4\left( \frac11- \frac13+ \frac15- \frac17+- \cdots\right)$

  • On estime itérativement pi, avec une série de fractions de plus en plus longue
  • On définit une condition pour sortir de la boucle d'itération: lorsque la nouvelle estimation ne change presque plus, on considère qu'on est assez proche de la solution

(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)

In [0]:
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)

Attention à la syntaxe et à l'indentation !

Exercice: corrigez ce code

In [0]:
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

Solutions des exercices ici

Récapitulatif des mots-clés et types de données de base

In [0]:
#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