Le Néerlandais Guido van Rossum proposait en 1991 la première version du Python, un langage de programmation :
Avantages et inconvénients :
Comme la plupart des langages de haut niveau, le Python comporte 5 sortes d'instructions :
Instruction
...
Bloc 1 :
instruction
…
Bloc 2 :
instruction
...
Instruction
...
Instruction
...
| : | :à la fin d'une ligne définit le début d'un bloc d’instructions |
| Indentation | Deux espaces ou une tabulation matérialisent un bloc d’instructions :
|
| # Commentaire | Commentaire sur une ligne |
| """ Commentaire Suite du commentaire """ | Commentaire multiligne |
La fin d'une instruction se définit :
L'affectation consiste à attribuer une valeur à une variable.
a = 83 b = 9.23 c1 = "Un deux trois" c2 = "Un \"deux\" trois" c3 = "Un deux\ntrois"
Le type de la valeur que contient une variable se retrouve avec la fonction type()
.
| int | 83 0 -23 2 | Entier |
| float | 9.23 0.0 -1.7e-6 | Nombre à virgule |
| str | "Un deux" 'Un deux' "L'avion" | Chaîne de caractères |
| list | ["3", 3, 3.0] | Liste |
| range | range(20) range(3,20) range(3,20,5) | Suite arithmétique d'entiers |
| bool | True False | Booléen |
Diverses fonctions permettent de changer le type d'une variable.
int("15") # 15
int(-15.56) # -15 (troncature)
float(-15) # -15.0
float("-2e-3") # -0.002
str(15) # "15"
str(-0.002) # "-0.002"
Souvent, lors des opérations sur deux types différents, un type est modifié automatiquement pour rendre l'opération possible.
var=3/2 print(var,type(var)) var=3.0+2 print(var,type(var)) var=3*True print(var,type(var)) var=3*(2>1) print(var,type(var)) var="3"+2 print(var,type(var))
Résultat :
1.5 <class 'float'> 5.0 <class 'float'> 3 <class 'int'> 3 <class 'int'> TypeError
Même nom mais deux variables différentes :
a = 15 # variable globale def plusUn() : a = 0 # variable locale à la fonction plusUn() a = a + 1 print(a) plusUn() # 1 print(a) # 15
Programme qui ne fonctionne pas :
a = 15 # variable globale def plusUn() : a = a + 1 # erreur car a n’est pas initialisée print(a) plusUn() print(a)
Variable globale dans une fonction ou procédure :
a = 15 # variable globale def plusUn() : global a a = a + 1 print(a) plusUn() # 16 print(a) # 16
input()
Saisie d’une chaîne de caractères :
nom = input("Quel est votre nom ?")
Saisie d’un entier :
n = int(input("Nombre de frères et sœurs"))
Saisie d’un nombre à virgule :
x = float(input("Température à 12h00"))
print()
Cette fonction affiche :
print(15)
print("Bonjour !")
print()
message = "Bonjour !"
print(message)
print()
a = 15
print(3*a)
print()
def saluer(nom) :
return "Bonjour "+nom+"!"
print(saluer("Julie"))
Résultat :
15 Bonjour ! Bonjour ! 45 Bonjour Julie!
a = -3
print("Le carré de ", a," est " , a * a)
Variante :
a = -3
print("Le carré de ", end = " ") # end = " " évite le retour à la ligne
print(a, end = " ")
print(" est ", end = " ")
print(a*a)
Résultat :
Le carré de -3 est 9
| + | Addition |
| - | Soustraction |
| * | Multiplication |
| / | Division |
| // | Division entière |
| % | Reste de la division |
| ** | Puissance |
a = 2 print(a + 3) # 5 print(a - 3) # -1 print(3 * a) # 6 print(15 / 6) # 2.5 print(15 // 6) # 2 print(15 % 6) # 3 print(3 ** a) # 9 print(a ** 0.5) # 1.4142135623730951
Quelques fonctions mathématiques sont toujours disponibles.
print(round(3.815164, 2)) # 3.82 print(int(3.815164)) # 3 print(abs(2.3)) # 2.3 print(abs(-2.3)) # 2.3 print(max(2,4,6)) # 6
La plupart des fonctions mathématiques nécessitent d'importer une bibliothèque,
comme math
, numpy
, scipy
ou sympy
(calcul formel).
from math import * print(sqrt(16)) # 4.0 print(sin(pi/4)) # 0.7071067811865475 print(acos(0.5)) # 1.0471975511965979 print(pi/3) # 1.0471975511965979
Les fonctions random()
, choice()
et randint()
appartiennent à la bibliothèque random
.
from random import * a = random() # nombre aléatoire dans [0; 1[ - exemple : 0.8365827741773375 L = [7, 3, 8, 5, 6] a = choice(L) # élément au hasard dans la liste L - exemple : 5 a = randint(5, 10) # entier aléatoire dans [5; 10] - exemple : 7
a = "Je dis " # guillemets simples ou doubles, au choix b = 'bla ' print(a + b) # concaténation print(5 * b) # répétition print(len(a)) # nombre de caractères de la chaîne
Affichage :
Je dis bla bla bla bla bla bla 7
\
txt='"Bonjour !", dit−elle.\n"Bonjour", répondit−il.' print(txt)
Affichage :
"Bonjour !", dit-elle. "Bonjour", répondit-il.
Remarques :
nb = "123456789" print(nb[1:3]) print(nb[0:len(nb)-2]) print(nb[:-2]) print(nb[2:len(nb)]) print(nb[2:])
Affichage :
23 1234567 1234567 3456789 3456789
ch = "Constance" print(ch[0], ch[4], ch[8])
Affichage :
Cte
Une liste est une suite ordonnée d'éléments (valeurs ou variables) séparées par des virgules, l'ensemble étant encadré entre crochets. A chaque élément de la liste correspond un indice (ou index). L'indice du premier élément est 0.
a = ["ab", "cd"] b = [0] print(a + b) # ajout print(5 * b) # répétition print(len(a)) # nombre d'éléments de la liste
Affichage :
['ab', 'cd', 0] [0, 0, 0, 0, 0] 2
Autres opérations :
liste = ["a", "b", 20, 30, "cd"]
print(liste[0], liste[2], liste[4]) # a 20 cd
print(liste.index("b")) # 1
liste[0] = "e" # ["e", "b", 20, 30, "cd"]
del(liste[3]) # ["e", "b", 20, "cd"]
liste.append("a") # ["e", "b", 20, "cd", "a"] équivaut à liste+=["a"]
liste.remove("b") # ["e", 20, "cd", "a"]
liste = [1, 3, 2, 4]
min(liste) # 1
max(liste) # 4
liste.reverse() # [4, 2, 3, 1]
liste.sort() # [1, 2, 3, 4]
liste.sort(reverse=True) # [4, 3, 2, 1]
La fonction range()
définit une suite arithmétique de nombres entiers, positifs ou négatifs.
Elle prend 1 à 3 paramètres.
La fonction list()
convertit le type range
en type list
.
list(range(5)) # [0, 1, 2, 3, 4] list(range(2,5)) # [2, 3, 4] list(range(0,5,2)) # [0, 2, 4] list(range(2,-3,-2)) # [2, 0, -2]
Remarque : range(5) définit 5 valeurs mais la première valeur est 0 donc la dernière est 4.
La méthode split()
sectionne une chaîne de caractères pour former une liste.
Chaque élément de la liste est une chaîne de caractères.
Cette méthode prend pour paramètre le séparateur, par défaut un espace.
texte='Salut à tous!'
texte.split() # ['Salut', 'à', 'tous!']
IPv4="192.168.45.67"
IPv4.split(".") # ['192', '168', '45', '67']
if
nombre = -10
if nombre>0 :
print("Le nombre choisi est positif")
print("Fin du programme")
Affichage :
Fin du programme
if ... else
nombre = 10
if nombre>0 :
print("Le nombre choisi est positif")
else :
print("Le nombre choisi est négatif ou nul")
print("Fin du programme")
Affichage :
Le nombre choisi est positif Fin du programme
n = 10
if n<0 :
print("Le nombre est négatif")
elif n==0 :
print("Le nombre est égal à zéro")
else :
print("Le nombre est positif")
Affichage :
Le nombre est positif
| if n==0 : | n est égal à zéro |
| if n>=0 : | n est supérieur ou égal à 0 |
| if n!=34 : | n est différent de 34 |
| if (0<10) and (n<10) : | n est compris strictement entre 0 et 10 |
| if 0<n<10 : | |
| if (n<0) or (n>10) : | n est négatif ou strictement supérieur à 10 |
| if n%5==0 : | n est divisible par 5 |
Différences entre =, == et != :
n = 10 # affectation n == 0 # False # test d'égalité n = 0 # affectation n == 0 # True # test d'égalité n != 0 # True # test d'inégalité
for ... in
Avec une suite arithmétique d'entiers :
for n in range(3) :
print("Entier", n)
Affichage :
Entier 0 Entier 1 Entier 2
Avec une liste :
for n in ["Paul", "Alice", "Julie"] :
print("Bonjour", n)
Affichage :
Bonjour Paul Bonjour Alice Bonjour Julie
while
Le nombre d’itérations n'est pas toujours connu à l’avance.
gagne = 0
while gagne == 0 :
n=int(input("Entrer un nombre"))
if n == 10 :
gagne = 1
print("Gagné")
return
Une fonction prend éventuellement un ou plusieurs paramètres et retourne une ou plusieurs valeurs :
def puissance(x,n) : y = x**n return y print(puissance(3,2)) # 9
Exemple avec plusieurs valeurs :
def test(): return 3,"5" a,b = test() print(a*b) # 555
return
La fonction exécute la suite d'instructions,
en retournant la valeur None
supprimée par l'interpréteur,
sauf en utilisant la fonction print()
:
def table7() :
for i in range(1,11) :
print(7*i)
table7() # 7 14 21 28 35 42 49 56 63 70
print(table7()) # None
Exemple avec un paramètre :
def table(base) :
for i in range(1,11) :
print(base*i)
table(8) # 8 16 24 32 40 48 56 64 72 80
Une bibliothèque (library en anglais) s'importe de trois manières différentes.
A réserver aux programmes simples.
from numpy import * print(sqrt(9)) print(sin(2))
Il est possible d'importer seulement les fonctions désirées.
from numpy import sqrt, sin print(sqrt(9)) print(sin(2))
Evite les conflits de variable ou de fonction.
import numpy print(numpy.sqrt(9)) print(numpy.sin(2))
Donne un nom plus court à la bibliothèque.
import numpy as np print(np.sqrt(9)) print(np.sin(2))
En Python, on évite les mots tableau
ou vecteur
qui prêtent à confusion, ou alors on précise de quoi il s'agit.
Un n-uplet (tuple en anglais) est une suite non modifiable d'éléments.
t = (1, "a", 2.3) print(len(t)) print(t[1]) t[1] = "b" # Erreur, les éléments d'un n-uplet ne peuvent se modifier
Résultat :
3 a TypeError: 'tuple' object does not support item assignment
e1 = {"moineau", "couleuvre", "renard", "renard"}
e2 = {"moineau", "gardon", "lion"}
e3 = {"moineau"}
print(e1) # "renard" ne compte qu'une fois
print(len(e1))
for p in e1:
print(p)
print(e1 | e2) # Union
print(e1 & e2) # Intersection
print(e1 - e3) # Différence
Résultat :
{'renard', 'moineau', 'couleuvre'}
3
renard
moineau
couleuvre
{'lion', 'renard', 'couleuvre', 'moineau', 'gardon'}
{'moineau'}
{'couleuvre', 'renard'}
d = {"oiseau":"moineau", "reptile":"couleuvre", "mammifere":"renard"}
print(d["reptile"])
for p in d:
print(d[p])
d["poisson"] = "gardon" # Ajout d'un élément
del d["reptile"] # Retrait d'un élément
d["oiseau"] = "pinson" # Modification d'un élément
print(d)
Résultat :
couleuvre
moineau
couleuvre
renard
{'oiseau': 'pinson', 'mammifere': 'renard', 'poisson': 'gardon'}