Cours Python

CPGE TETOUAN Filière :MP/TSI
Programmation en Python
Prof:Yassine KHARCHACHI 1 Année Scolaire: 2020/2021

Présentation du langage Python

 Python est un langage interprété, c’est-à-dire que chaque ligne
de code est lue puis interprétée afin d’être exécutée par
l’ordinateur
 Python est un langage portable, dynamique, gratuit, qui
permet une approche modulaire et orientée objet de la
programmation.
 Python est un langage faiblement typé

Calculer avec Python

 Python présente la particularité de pouvoir être utilisé de plusieurs
manières différentes. Vous allez d’abord l’utiliser en mode interactif.
>>> 5+3
8
>>> 2 – 9 # les espaces sont optionnels
-7
>>> 7 + 3 * 4 # la hiérarchie des opérations mathématiques est-elle respectée ?
19
>>> (7+3)*4
40
>>> 20 / 3 #division réelle
6.666666666666667
>>> 20 // 3 #division entière (euclidienne)
6
>>> 5**2 # 5 à la puissance 2
25
>>>abs(3 - 20) # valeur absolue
17

Les types numériques: int, float, complex

 Le type int
Le type int n’est pas limité en taille que par la mémoire de la
machine.
Les entiers littéraux sont décimaux par défaut, mais on peut aussi
utiliser les bases suivantes
Exemple
>>> 2009 # décimal
2009
>>> 0b11111011001 # binaire
2009
>>> 0o3731 # octal
2009
>>> 0x7d9 # hexadecimal
2009


 Le type bool
Deux valeurs possibles : False, True.
Opérateurs de comparaison : = =, !=, >, >=, < et <= :
Exemple
>>> 2 > 8
False
>>> 2 <= 8 < 15
True


 Le type float
Un float est noté avec un point décimal ou en notation
exponentielle
Exemple
2.718
.02
3e8
6.023e23


 Le type complex
Les complexes sont écrits en notation cartésienne
formée de deux flottants.
La partie imaginaire est suffixée par j :
Exemple
1j # 1j
(2+3j) + (4-7j) # (6-4j)
(9+5j).real # 9.0
(9+5j).imag # 5.0
abs(3+4j) # 5.0 : module

Données et variables
 Variable = référence désignant une adresse mémoire.
 Une variable Python est un triplé (nom, type, valeur).
 Affectation (ou assignation) désignent l’opération par laquelle on
établit un lien entre le nom de la variable et sa valeur. En Python comme
dans de nombreux autres langages, l’opération d’affectation est
représentée par le signe égal (=).
 Déclaration des variables se fait par l’affectation d’une valeur à un
identificateur
>>> x = 2
>>> x
2
>>> n = 7 # définir la variable n et lui donner la valeur 7
>>> msg = "Quoi de neuf ?" # affecter la valeur "Quoi de neuf ?" à la variable msg
>>> pi = 3.14159 # assigner la valeur 3.14159 à la variable pi

 L’affectation n’a pas de valeur (on ne peut pas l’utiliser dans une
expression).
Exemple
>>> a = 2
>>> x = (a = 3) + 2
SyntaxError: invalid syntax
 La comparaison a une valeur utilisable dans une expression mais
n’a pas d’effet (l’automate interne représentant l’évolution du
programme n’est pas modifié)
Exemple
>>> x = (a == 3) + 2
>>> x
2

 On peut aussi utiliser les formes suivantes :
 affectation simple
v=4
 affectation augmentée
v += 2
 affectation de droite à gauche
c = d = 8 # cibles multiples
 affectations parallèles d’une séquence
e, f = 2.7, 5.1 # tuple
g, h, i = [’G’, ’H’, ’I’] # liste

Les entrées-sorties
 La fonction input permet de lire des données au clavier.
 Syntaxe
Variable=input(‘message pour l’utilisateur’)
 La fonction standard input() effectue toujours une saisie
en mode texte (la saisie est une chaîne) dont on peut
ensuite changer le type.
int() pour convertir en entier;
float() pour convertir en flottant;
complex() pour convertir en complexe;
str() pour convertir sous forme de chaîne de caractère

 En mode « calculatrice », Python lit-évalue-affiche, mais la
fonction print() reste indispensable aux affichages dans les
scripts (programmes) :
Exemple
a, b = 2, 5
print(a, b) # 2 5
print(”Somme :”, a + b) # Somme : 7
print(a - b, ”est la différence”) # -3 est la différence
print(”Le produit de”, a, ”par”, b, ”vaut :”, a * b)
# Le produit de 2 par 5 vaut : 10

 L’affichage formaté
 La méthode format() permet de contrôler finement la création
de chaînes formatées.
 Remplacements simples :
print(”{} {} {}”.format(”zéro”, ”un”, ”deux”)) # zéro un deux
print(”{2} {0} {1}”.format(”zéro”, ”un”, ”deux”)) # deux zéro
un
print(”Je m’appelle {}”.format(”Bob”)) # Je m’appelle Bob
print(”Je m’appelle {{{}}}”.format(”Bob”)) # Je m’appelle {Bob}
print(”{}”.format(”-”*10)) # ----------

 Remplacements avec champs nommés :
a, b = 5, 3
print(”The story of {c} and {d}”.format(c=a+b, d=a-b))
# The story of 8 and 2
 Formatages à l’aide de liste :
stock = [’papier’, ’enveloppe’, ’chemise’, ’encre’, ’buvard’]
print(”Nous avons de l’{[3]} et du {[0]} en stock”.format(stock))
# Nous avons de l’encre et du papier en stock

Les instructions composées

 Une instruction composée se compose :
 d’une ligne d’en-tête terminée par deux-points
 d’un bloc d’instructions indenté par rapport à la ligne d’en-tête.
Attention
Toutes les instructions au même niveau d’indentation
appartiennent au même bloc.

Structure de choix
 En Python
 toute valeur différente de zéro est vraie ;
 n’importe quoi avec une longueur différente de zéro est vrai ;
 zéro est faux ;
 les séquences (liste, dictionnaire, ensemble, tuple) vides sont fausses.
 if - [elif] - [else]
syntaxe
if expression_logique :
instruction1
instruction2
….
instructionN
elif expression_logique :
bloc d’instruction
else :
autre_bloc_instructions
Remarque : Il peut y avoir plusieurs clauses elif, mais une seule clause
else

Structure de choix
Exemple (if … elif….else)
if x < 0:
print(”x est négatif”)
elif x > 0:
print(”x est positif ”)
else:
print(”x est nul”)
 Syntaxe compacte d’une alternative
Syntaxe
variable= valeur1 if condition else valeur2
Affecte valeur1 à variable si la condition est vraie, valeur2 sinon.
Exemple
plus_petit = x if x < y else y
print(”Plus petit : ”, plus_petit)

La fonction range
 La fonction range() génère une séquence de nombres entiers.
 range(limite supérieure):liste d’entiers de 0 à limite supérieure moins un
par palier de 1.
 range(limite inférieure, limite supérieure):liste d’entiers de la limite
inférieure à la limite supérieure moins un par palier de 1.
 range(limite inférieure, limite supérieure, pas) : liste d’entiers de la
limite inférieure à la limite supérieure moins un avec le palier défini.
Exemple
>>> list(range(5,13))
[5, 6, 7, 8, 9, 10, 11, 12]
>>> list(range(4,0,-1))
[4, 3, 2, 1]
>>> list(range(3,16,3))
[3, 6, 9, 12, 15]
>>> liste(range(4))
[0, 1, 2, 3]
18
Structures répétitives (Boucles)

La boucle Tant que (while)
 Syntaxe
while condition:
instruction1
instruction2
….
instructionN
 Exemple
a=0
while (a < 7): # (n’oubliez pas le double point !)
print(a) # (n’oubliez pas l’indentation !)
a=a+1 #0 1 2 3 4 5 6


 La boucle pour : Parcours une séquence :
Le parcours d’une séquence est une opération très fréquente en
programmation. Pour en faciliter l’écriture, Python vous propose
une structure de boucle plus appropriée que la boucle while, basée
sur le couple d’instructions for ... in ...
 Syntaxe
for i in sequence :
traitement de l’élément i dans la séquence sequence
 Remarque Une séquence peur être une chaîne de caractères et il

en sera de même pour les tuples, ensembles, dictionnaires et les
listes étudiés plus loin.

Algorithmique Python
Pour i valeur_initiale jusqu’à valeur_finale Pas P faire Cas de pas positif
Instructions for i in range(VI,VF+1,P)
Fin pour instructions
Cas de pas negatif
for i in range(VF,VI-1,P)
instructions
Exemples
for i in range(1,5): for i in [1,2,3,4]: for i in (1,2,3,4):

print(i) print(i) print(i)

Ruptures de séquences
 Interrompre une boucle : break
Sort immédiatement de la boucle for ou while en cours
contenant l’instruction
Exemple
for x in range(1, 11): # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
if x == 5:
break
print(x, end=” ”)
print(”\n Boucle interrompue pour x =”, x)
# affiche :
#1234
# Boucle interrompue pour x = 5

Ruptures de séquences
 Court-circuiter une boucle : continue
 Passe immédiatement à l’itération suivante de la boucle for ou while
en cours contenant l’instruction ; reprend à la ligne de l’en-tête de
la boucle
Exemple
for x in range(1, 11): # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
if x == 5:
continue
print(x, end=” ”)
print(”\n La boucle a sauté la valeur 5”)
# affiche :
# 1 2 3 4 6 7 8 9 10
# La boucle a sauté la valeur 5

Syntaxe complète des boucles

 while - else
Les boucles while et for peuvent posséder une clause else qui ne s’exécute
que si la boucle se termine normalement, c’est-à-dire sans interruption :
Exemple
y = int(input(”Entrez un entier positif : ”))
while not(y > 0):
y = int(input(’Entrez un entier positif, S.V.P. : ’))
x = y // 2
while x > 1:
if y % x == 0:
print(”{} a pour facteur {}”.format(y, x))
break # voici l’interruption !
x -= 1
else:
print(y, ”est premier.”)

Syntaxe complète des boucles

for – else
Un exemple avec le parcours d’une liste :
Le programme suivant permet de chercher l’indice d’une valeur
dans une liste. Si la valeur n’existe pas dans la liste alors on met
dans la variable indice None.
une_sequence = [2, 5, 9, 7, 11]
valeur = int(input(”Entrez un entier : ”))
indice=0
for i in une_sequence:
if i == valeur:
break
else :
indice+=1
else:
indice=None

Les chaînes de caractères

 Le type de données non modifiable str représente une séquence
de caractères Unicode.
 Non modifiable signifie qu’une donnée, une fois créée en mémoire,

ne pourra plus être changée. En d’autres termes, vous ne pouvez
pas utiliser l’opérateur [ ]dans la partie gauche d’une instruction
d’affectation.

Les chaînes de caractères :
opérations
 s = ”abcde”
 len(s) # 5 # Longueur
 s1 = ”abc”
 s2 = ”defg”
 s3 = s1 + s2 # ’abcdefg’ Concaténation
 s4 = ”Fi! ”
 s5 = s4 * 3 # ’Fi! Fi! Fi! ’ Répétition

opérations
 indexation simple
 Extraction de sous-chaînes

méthodes
 isupper() et islower() : retournent True si ch ne contient
respectivement que des majuscules/minuscules
 print(”cHAise basSe”.isupper()) # False
 istitle() : retourne True si seule la première lettre de chaque

mot de ch est en majuscule
 print(”Chaise Basse”.istitle()) # True
 isalnum(), isalpha(), isdigit() et isspace() : retournent

True si ch ne contient respectivement que des caractères
alphanumériques, alphabétiques, numériques ou des espaces :
 print(”3 chaises basses”.isalpha()) # False

 print(”54762”.isdigit()) # True
méthodes
 lower(), upper(), capitalize() et swapcase() : retournent
respectivement une chaîne en minuscule, en majuscule, en
minuscule commençant par une majuscule, ou en casse
inversée :
s = ”cHAise basSe”
print(s.lower()) # chaise basse
print(s.upper()) # CHAISE BASSE
print(s.capitalize()) # Chaise basse
print(s.swapcase()) # ChaISE BASsE

Les listes
 Collection ordonnée et modifiable d’éléments éventuellement
hétérogènes
Il est possible de changer les éléments individuels d’une liste :
 Syntaxe
Éléments séparés par des virgules, et entourés de crochets.
Exemple
>>> L=[1,2,3,4]
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> print(jour)
['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> print(jour[2])
mercredi
>>> print(jour[4])
20.357

Les listes
>>> jour[3]= jour[3]+4
>>> print(jour[3])
1804
>>> jour[3]= ‘Juillet’
>>> print(jour)
['lundi', 'mardi', 'mercredi', ‘Juillet’, 20.357, 'jeudi', 'vendredi']

Les listes
 Les listes: les fonctions et les méthodes
 Len(): le nombre d’éléments dans la liste.
 del() : permet de supprimer un éléments dans la liste.
 append() : permet d’ajouter un élément à la fin da la liste.
 extend (): permet d’ajouter une liste à une autre.
 remove (): permet de supprimer la première occurrence

d’une valeur dans la liste.
 pop(i) : cette méthode permet de retirer l’élément figurant à

l’indice i da la liste et de le retourner.
Les listes
 insert (pos, e) : permet d’insérer l’élément e à la position pos.
 index(e) : Renvoie l'index du premier élément dont la valeur est 'e'.
 count(e) : Cette méthode vous renvoie le nombre d'occurrences de

la valeur 'e'.
 reverse() : Cette méthode vous permet d'inverser une liste.
 sort() : cette méthode permet de trier une liste par ordre croissant
ou dans l'ordre alphabétique, selon le type des données de la liste.

Les listes
>>> liste.pop()
 >>> liste=[1,2,3,4,5,6]
7
 >>> len(liste)
>>> liste.index(1)
 6
4
 >>> liste.append(7)
>>> liste.reverse()
 >>> liste
>>> liste
 [1, 2, 3, 4, 5, 6, 7]
[6, 1, 5, 4, 3, 2]
 >>> liste.insert(5,1)
>>> liste.sort()
 >>> liste
>>> liste
 [1, 2, 3, 4, 5, 1, 6, 7]
[1, 2, 3, 4, 5, 6]
 >>> liste.remove(1)
>>> liste.extend([9,3])
 >>> liste
>>> liste
 [2, 3, 4, 5, 1, 6, 7]
[1, 2, 3, 4, 5, 6, 9, 3]

Les listes
 Les listes: Manipulation des tranches
mots = [’poisson’, ’sel’, ’miel’, ’confiture’, ’thé’]
mots[2:4] = [] # effacement par affectation d’une liste vide
print(mots) # ➔ [’poisson’, ’sel’, ’thé’]
mots[1:3] = [’salade’]
print(mots) # ➔ [’poisson’, ’salade’]
mots[1:] = [’mayonnaise’, ’poulet’, ’tomate’]
print(mots) # ➔ [’poisson’, ’mayonnaise’, ’poulet’, ’tomate’]
mots[2:2] = [’miel’] # insertion en 3è position
print(mots) # ➔ [’poisson’, ’mayonnaise’, ’miel’, ’poulet’, ’tomate’]

Les listes
 {x2 / x  [2; 10]} ➔ [x**2 for x in range(2, 11)]
Exemple
valeurs_s = [”12”, ”78”, ”671”]
conversion d’une liste de chaînes en liste d’entier
valeurs_i = [int(i) for i in valeurs_s] # [12, 78, 671]
calcul de la somme de la liste avec la fonction intégrée sum
print(sum([int(i) for i in valeurs_s])) # ➔761
Initialisation d’une liste 2D
multi_liste = [[0]*2 for ligne in range(3)]
print(multi_liste) # [[0, 0], [0, 0], [0, 0]]

Les tuples
 Définition
Collection ordonnée et non modifiable d’éléments
éventuellement hétérogènes. Contrairement à une liste, ils
ont une taille fixée (aucune méthode ne peut ajouter une
coordonnée en place). On peut accéder à une coordonnée
par indexation, mais pas la modifier :
 Syntaxe
Éléments séparés par des virgules, et entourés de
parenthèses.
 Exemple
mon_tuple = (’a’, 2, [1, 3])

Les tuples
Principales opérations et méthodes applicables à un tuple
len(U) nombre de coordonnées
U+V retourne la concaténation
n * U ou U * n concaténation répétée n fois
U.count(a) retourne le nombre d’occurrences de a
U.index(a) retourne le premier indice de a, ou une
erreur si a n’est pas un attribut
a in U teste l’appartenance de a à U

Les dictionnaires
 Définition Un tableau associatif est un type de données permettant
de stocker des couples clé : valeur, avec un accès très rapide à la
valeur à partir de la clé, la clé ne pouvant être présente qu’une seule
fois dans le tableau.
 Il possède les caractéristiques suivantes :
l’opérateur d’appartenance d’une clé (in) ;
la fonction taille (len()) donnant le nombre de couples stockés ;
on peut le parcourir mais n’est pas ordonné.
 Python propose le type standard dict.
 Les dictionnaires (dict)
Comme un dictionnaire de traduction français-anglais par exemple,
les dictionnaires Python fonctionnent par couple clé :valeur
 Syntaxe
Collection de couples clé : valeur entourée d’accolades.

Les dictionnaires
 insertion de clés/valeurs une à une
 d1 = {} # création d’un dictionnaire vide
 d1[”nom”] = ‘’SABER" #le stockage d’une valeur à l’aide d’une
certaine clé
 d1["prenom"]= ‘’Hasan"
 d1[”taille”] = 1.78
 print(d1) # ➔ {'taille': 1.78, 'prenom': ‘Hasan', 'nom': ‘SABER'}
 l’extraction de la valeur en donnant la clé
 print(d1["nom"]) # ➔ SABER
 définition en extension
 d2 = { 'nom': ‘SABER','prenom': ' Hasan ','taille': 1.78}
 print(d2) # ➔{'taille': 1.78, 'prenom': ' Hasan ', 'nom': ‘SABER'}

Les dictionnaires
 d3 = {x: x**2 for x in (2, 4, 6)}
 print(d3) # ➔{2: 4, 4: 16, 6: 36}
 utilisation de paramètres nommés
 d4=dict(nom= ‘SABER’,prenom= ' Hasan ',taille= 1.78)
 print(d4) # ➔{'prenom': ' Hasan 'taille': 1.78, 'nom': ‘SABER}
 utilisation d’une liste de couples clés/valeurs
 d5=dict([('nom', ‘SABER'),('prenom', ' Hasan '),('taille', 1.78)])
 print(d5) # ➔{'taille': 1.78, 'prenom': ' Hasan ', 'nom': ‘SABER'}

Les dictionnaires
 d4=dict(nom= ‘SABER',prenom= ‘Hasan',taille= 1.78)
 d4.pop(taille) # ➔1.78 # supprime et renvoie la valeur correspondant à la
clé donnée en argument
 print(d4) # ➔{'prenom': ‘Hasan', 'nom': ‘SABER'}
 tel = {’k1’: 4098, ’k2’: 4139}
 tel[’k3’] = 4127 #insertion
 print(tel) # ➔ {'k2': 4139, 'k3': 4127, 'k1': 4098}
 del tel[’k2’] # la suppression de couple (’k2’: 4139)
 tel[’k4’] = 4127 # insertion de couple (’k4’: 4127)
 print(tel) # ➔ {'k3': 4127, 'k1': 4098, 'k4': 4127}
 print(list(tel.keys())) # ➔ ['k3', 'k1', 'k4'] # afficher la liste des clés
 print(sorted(tel.keys())) # ➔ ['k1', 'k3', 'k4']#afficher la liste des clés
triée
 print(sorted(tel.values())) # ➔ [4098, 4127, 4127]# afficher la liste
des valeurs triée

Les ensembles (set)

 Python comporte un type de données pour représenter
des ensembles. Un set est une collection (non ordonnée)
sans éléments dupliqués. Les emplois basiques sont le test
d’appartenance et l’élimination des entrées dupliquées.
Les objets ensembles supportent les opérations
mathématiques comme
 l’union avec l’opérateur '|'
 l’intersection avec l’opérateur '&'
 la différence avec l’opérateur '-'
 la différence symétrique avec l’opérateur '^'
(définie par A∆B = A  B - A B)

Les ensembles (set)

 Définition
La structure d’ensemble (set) ressemble à celle de liste, mais
sans ordre défini sur les ensembles, et sans répétition possible
des éléments.
 Exemple
X, Y = set(’abcd’), set(’sbds’)
print(”X =”, X) # X = {’a’, ’c’, ’b’, ’d’}
print(len(X)) # 4
print(”Y =”, Y) # Y = {’s’, ’b’, ’d’} : un seul élément ’s’
print(’c’ in X) # True
print(’a’ in Y) # False
print(X - Y) # {’a’, ’c’}
print(Y - X) # {’s’}
print(X | Y) # {’a’, ’c’, ’b’, ’d’, ’s’}
print(X & Y) # {’b’, ’d’}
print(X^Y) # {'c', 's', 'a'}

Piles
La pile est une structure de données qui ne permet que deux
opérations :
empiler un élément, qui consiste à ajouter un élément à la

pile.
dépiler un élément, qui consiste à retirer le dernier

élément empilé.
Pour représenter l'état de la pile à un instant donné, on la

considère comme un tableau à une dimension. Le sommet de
la pile est le dernier élément ajouté.
Piles
Une pile est à comparer à une pile d'assiettes par
exemple. Les concepts associés aux piles sont : LIFO
(Last in, first out), Premier arrivé, dernier servi.
Opérations sur les piles

La pile est-elle vide ?
Ajouter un élément sur la pile
Consulter le sommet de la pile
Retirer l'élément au sommet de la pile

Piles
Les listes Python permettent de simuler les piles :
len(p) permet de savoir si la pile est vide
p.append(v) ajoute v en sommet de pile
p[-1] est l'élément au sommet de la pile
p.pop() retire l'élément au sommet de la pile

Piles
créer une pile vide et ajouter un premier élément :
pile = []
pile.append(5)
La fonction attachée à la pile qui permet d'empiler un

élément est append. Ajoutons trois autres éléments :
pile.append(10)
pile.append(20)
pile.append(30)
print(pile) --> [5, 10, 20, 30]

Piles
Pour dépiler un élément, on utilise la fonction pop, qui
enlève le dernier élément ajouté et le renvoie :
a = pile.pop()
print(a)
--> «30
print(pile)
--> [5, 10, 20]

Utilisation de piles
Traitements de texte : Historique des modifications (Ctrl-Z)
Navigateurs : Historique de navigation
Algorithmes récursifs : Pile d'appels

Files
La File est une structure de données qui ne permet que deux
opérations :
enfiler un élément, qui consiste à ajouter un élément à la

file.
défiler un élément, qui consiste à retirer le premier

élément enfilé.
Une file est à comparer à une file d'attente .

Files
Les concepts associés aux files sont : FIFO (First in, first
out), Premier arrivé, premier servi.
Opérations sur les files

La file est-elle vide ?
Enfiler un élément
Défiler un élément (et récupérer sa valeur). Cet élément
sera le premier a avoir été enfilé.
Ces opérations doivent être faites en temps constant.

Files
Les listes Python ne simulent pas correctement des files.
En effet, les objets ne peuvent être enfilés en temps
constant qu'en fin de liste. Ils doivent donc être défilés
en début de liste. Or l'insertion en début de liste ne se
fait pas en temps constant (car Python décale les autres
valeurs).

Files
Il existe un type supplémentaire : deque, dans le
module collections permettant de simuler les files
(queue en anglais) :
from collections import deque pour utiliser le module
d=deque() : création d'une file vide
d=deque( (4,5,6) ) : création d'une file à partir d'un tuple
len(d) permet de savoir si la file est vide
d.pop() renvoie l'élément de tête de file
d.appendleft(v) ajoute un élément au début de la
file

Utilisation de files
les impressions dans un système d’exploitation sont
gérées par une file.
dans une simulation d’un guichet, on modélisera

généralement l’arrivée des clients par une file.

Programmation modulaire(fonction )
 Une fonction est un algorithme destiné à être utilisé par
d′autres algorithmes ou fonctions.
 Une fonction peut être assimilée à une boîte noire (un
composant) qui a des entrées et des sorties.
Entrées Fonction Résultat

Modalités d’appel
Algorithme
Fonction 1
Début
Instruction 1 Fonction 2
Début
.
.
.
. Début
.
. .
Instruction k
Instruction d’appel .
Instruction d’appel
. .
Instruction k+2
.
.
. Fin
.
.
Fin
Instruction n
Fin

Définition et Appel d'une fonction

La syntaxe pour définir une fonction :
def nomdefonction(liste_de_parametres) :
bloc_instructions
Le bloc instructions effectue les calculs pour réaliser les

tâches confiées a la fonction définie. Les calculs peuvent
produire de nouvelles valeurs que l'on peut renvoyer
dans une expression (affecter a variable, utiliser comme
arguments d'une autre fonction).
Pour cela, on utilise l'instruction return valeur

Définition et Appel d'une fonction

Exemple 1 : Une fois une fonction est définiée, pour
l'utiliser on l'appelle avec des arguments
def max_list(L) :
adéquats :
k = len(L) Appels de max list avec une liste de nombres
max, x = L[0], 0 comme argument.
i=1
print max_list([4,5,6,9,12,5,10,3,18,5,6,7])
while i < k :
couple = max_list([4,5,6,9,12,5,10,3,18,5,6,7])
if max < L[i]: print ('Max de L est ', couple[0])
max = L[i] print ('et se trouve a la position ', couple[1])
x=i
affectation a une variable :
i=i+1
return max, x couple = max_list('totovaaumarche')
print ('Max de L est ', couple[0])
print ('et se trouve a la position ', couple[1])

Fonction simple sans paramètres

>>> def table7():
... n=1
... while n <11 :
... print n * 7,
... n = n+1
Pour utiliser la fonction que nous venons de définir, il suffit de l'appeler par son
nom. Ainsi :
>>> table7()
Provoque l'affichage de :
7 14 21 28 35 42 49 56 63 70

Fonction avec paramètres

La fonction table() telle que définie ci-dessous utilise le paramètre base pour
calculer les dix premiers termes de la table de multiplication de base.
>>> def table(base):

n=1
while n <11 :
print n * base,
n = n +1
Pour tester cette nouvelle fonction, il nous suffit de l'appeler avec un argument.
>>> table(13)
13 26 39 52 65 78 91 104 117 130
>>> table(9)
9 18 27 36 45 54 63 72 81 90

Fonction avec plusieurs paramètres
>>> def tableMulti(base, debut, fin):

print( 'Fragment de la table de multiplication par', base, ': ')
n = debut
while n <= fin :
print n, 'x', base, '=', n * base
n = n +1
>>> tableMulti(8, 13, 17)

Fragment de la table de multiplication par 8 :
13 x 8 = 104
14 x 8 = 112
15 x 8 = 120
16 x 8 = 128
17 x 8 = 136

Utilisation des fonctions dans un script
def cube(n):
return n**3
def volumeSphere(r):
return 4 * 3.1416 * cube(r) / 3
r = input('Entrez la valeur du rayon : ')

Print( 'Le volume de cette sphère vaut', volumeSphere(r))

Avantages des fonctions

 Les fonctions permettent de ne pas répéter plusieurs fois
une même séquence d’instructions au sein du
programme.
 La mise au point du programme est plus rapide en
utilisant des procédures et des fonctions. En effet, elle
peut être réalisée en dehors du contexte du programme.
 Une fonction peut être intégrée à un autre programme,
ou elle pourra être rangée dans une bibliothèque d’outils
ou elle pourra être utilisée par n’importe quel
programme.

Fonction lambda
 Une des particularités de Python est les fonctions
déclarées à la volée aussi appelées fonctions lambda. Ces
fonctions seront en fait déclarées en plein milieu de votre
code et seront anonymes. Pour les déclarer, le mot clé
def ne sera pas nécessaire, vous devrez utiliser le mot clé
lambda.
 La syntaxe générale d'une fonction lambda :
lambda arg1, arg2 ... : instructions
 Exemple
 Puissance = lambda nombre, puissance : nombre**puissance
 print(Puissance(2,4))

La récursivité
 Une application très intéressante des fonctions est ce que l'on appelle la
récursivité. une fonction est dite récursive lorsqu'elle fait appel à elle-
même.
 Exemple
def factoriel(nombre) :
"""
Cette fonction retourne le factoriel d'un nombre.
nombre : Le nombre dont on veut le factoriel.
return : nombre!
"""
if nombre == 1 or nombre == 0 :
return 1
else :
return nombre * factoriel(nombre - 1)

La récursivité
Calcul x**n:
def puissanc:e ( x , n):

if n>0:
return x * puissance (x,n-1)
else : return 1
print puissance (2,10)

Variable globale et variable locale

 Lorsque nous définissons des variables à l'intérieur du corps
d'une fonction, ces variables ne sont accessibles qu'à la
fonction elle-même. On dit que ces variables sont des
variables locales à la fonction. C'est par exemple le cas des
variables base, debut, fin et n dans l’exemple suivant.
>>> def tableMulti(base, debut, fin): >>> tableMulti(8, 13, 17)
... print 'Fragment de la table de Fragment de la table de multiplication par 8 :
multiplication par', base, ':' 13 x 8 = 104
... n = debut 14 x 8 = 112
... while n <= fin : 15 x 8 = 120
... print n, 'x', base, '=', n * base 16 x 8 = 128
... n = n +1 17 x 8 = 136


 Les variables définies à l'extérieur d'une fonction sont des
variables globales. Leur contenu est « visible » de l'intérieur d'une
fonction, mais la fonction ne peut pas le modifier.
 Exemple :
def f(): #déclaration de la fonction f()
a=10 # modification de la variable globale a
print("à l'intérieur de la fonction a={} b={}".format(a,b))
a,b=3,20 # déclaration de deux variables
f() # appel à la fonction
print("à l'extérieur de la fonction a={} b={}".format(a,b))
 Résultat d’exécution
à l'intérieur de la fonction a=10 b=20
à l'extérieur de la fonction a=3 b=20
# la fonction f() n’a pas modifier la valeur de a


 Pour pouvoir modifier une variable globale à l’intérieur d’une fonction, il
vous suffira d'utiliser l'instruction global. Cette instruction permet
d'indiquer - à l'intérieur de la définition d'une fonction - quelles sont les
variables à traiter globalement.
 Exemple :
def f(): #déclaration de la fonction f()
global a,b
a=10 # modification de la variable globale a
print("à l'intérieur de la fonction a={} b={}".format(a,b))
a,b=3,20 # déclaration de deux variables
f() # appel à la fonction
print("à l'extérieur de la fonction a={} b={}".format(a,b))
 Résultat d’exécution
à l'intérieur de la fonction a=10 b=20
à l'extérieur de la fonction a=10 b=20

Modules complémentaires
De nombreuses fonctions sont définies dans des modules
spécialisées. Pour utiliser une fonction d’un module mod, il faut
importer cette fonction, ou le module entier
Avant l’utilisation de cette fonction. Cela peut se faire de 3
manières :
Import simple du module
import mod
Import d’une fonction d’un module
from mod import fonct
Import de toutes les fonctions d’un module
from mod import *

Le module math
e constante e, base de l’exponentielle
exp(x) exponentielle de x
log(x) logarithme népérien
log10(x) logarithme en base 10
pi le nombre pi
cos(x) cosinus
sin(x) sinus
tan(x) tangente
acos(x) arccos
asin(x) arcsin
atan(x) arctan

Le module math
cosh(x) cosinus hyperbolique
sinh(x) sinus hyperbolique
tanh(x) tangente hyperbolique
floor(x) partie entière au sens mathématique
ceil(x) partie entière par excès
sqrt(x) racine carrée
factorial(x) factorielle (pour x entier)

Le module numpy (calcul numérique)

La structure array (np.array): tableau multidimensionnel
array(liste) : transforme une liste en tableau En imbriquant
des listes dans des listes, on peut obtenir des
tableaux multidimensionnels
Exemples
array([1,2,3]) tableau a 3 entrées (matrice ligne)
array([[1,2],[3,4]]) matrice 2x2 de première ligne (1,2)
seconde ligne (3,4)
array([[1],[2],[3]]) matrice colonne
shape(A) format du tableau (nombre de lignes, de
colonnes..., sous forme d’un tuple
rank(A) profondeur d’imbrication (dimension spatiale)


ones(n) Cree une matrice ligne de taille n constituée de 1.
ones((n1,n2)) matrice de taille n1 x n2, constituee de 1
zeros(n) Cree une matrice ligne de taille n constituée de 0.
zeros((n1,n2)) matrice de taille n1 x n2, constituee de 0
eye(n) matrice identité d’ordre n (des 1 sur la diagonale)
diag([d0,...,dn]) matrice diagonale de coefficients diagonaux d1,...,d_n
linspace(a,b,n) matrice ligne constituée de n valeurs régulièrement
reparties entre a et b
arange(a,b,p) matrice ligne des valeurs de a a b en progressant de pas p
fromfunction(f,(n,)) matrice ligne remplie des valeurs f(k) pour k de 0 a n-1


A+B Somme de deux matrices
a*M Multiplication par un scalaire
A*B Produit coefficient par coefficient
dot(A,B) Produit matriciel
linalg.det(A) déterminant
transpose(A) transposée
power(A,n) A puissance n
linalg.inv(A) inverse de A
linalg.eigvals(A) valeurs propres de A


random.randint(a) génère aléatoirement un entier de 0 a a-1 inclus,
de façon uniforme
random.randint(a,b) génère aléatoirement un entier de a a b-1 inclus,
de façon uniforme
random.random(a,b,n) génère un tableau 1 x n d’entiers aléatoirement
choisis uniformément entre a et b-1
random.random() génère aléatoirement un réel de [0,1[ de façon
uniforme
random.sample(n) génère un np.array 1 ligne n colonnes rempli
aléatoirement par des réels de [0,1[ choisis
uniformément
random.sample(tuple) de même pour un tableau multidimensionnel de
taille définie par le tuple

Le module scipy (calcul scientifique)

scipy.integrate.quad(f,a,b) intégrale de f de a a b
scipy.optimize.newton(f,a,g) résolution d’équation par la
méthode de Newton initialisée au
point a g doit être égal a f’
scipy.optimize.newton(f,a) de même par la méthode
de la sécante
scipy.integrate.odeint(f,y0,T) Résolution de l’ED y’=f(y,t)
y0 est la valeur initial (t minimal) T est
un tableau des temps auquel calculer
les valeurs de y

Le module matplotlib (tracé de courbes)

plt.plot(L1,L2, label=’nom’)
trace la ligne brisée entre les points dont les abscisse sont dans la
liste L1 et les ordonnées dans la liste L2 Le label sert à identifier la
courbe
plt.title("titre")
plt.grid()
plt.legend(loc = ...)
plt.show()

Module time
time.perf_counter()
donne une valeur d’horloge correspondant à l’instant en
cours en seconde.
Cette fonction sera utilisée comme suit :
import time
debut = perf_counter()
instructions
fin = perf_counter()
temps_execution = fin - debut

Module sqlite3
connection = sql.connect(’base.db’)
crée un objet de connexion vers la base base.db
cur = connection.cursor()
crée un curseur qui permettra des modifications de la base
cur.execute("instruction SQL")
Exécute l’instruction donnée, dans la syntaxe SQL, dans la
base pointée par le curseur

Les Fichiers
Dans tous les langages de programmation, on utilise la
notion de fichier. Qui désigne un ensemble
d'informations enregistré sur un support (CD-Rom,
disque dur, etc.).
Les principales manipulations sur un fichier sont :
L'ouverture du fichier
La lecture ou l’écriture d'un élément dans un fichier
La fermeture du fichier.

Les Fichiers
Tout fichier doit être ouvert avant de pouvoir accéder à
son contenu en lecture et/ou écriture.
L’ouverture d’un fichier est réalisée par la fonction open
selon la syntaxe suivante :
Identificateur_fichier=open(nom_fichier,mode_ouverture)

Les Fichiers
Les principaux modes d’ouverture sont :
"r" comme read (lire) : ouverture en lecture uniquement (le
fichier doit exister !)
"w" comme write (écrire) : ouverture en écriture uniquement
(crée le fichier, l'efface préalablement s'il existe déjà)
"a" comme append (ajouter) : ouverture en mise à jour (crée le
fichier, écrit à partir de la fin du fichier s'il existe déjà)
Tout programme manipulant un fichier doit donc être
encadré par les deux appels de fonctions open() et
close().

Les Fichiers
L’écriture
L’écriture dans un fichier se fait avec la méthode write()
en mode écriture. Cette fonction permet d’écrire une
chaîne de caractères dans le fichier.
Syntaxe
Fichier.write(chaîne de caractères)
Exemple
fichier = open("test.txt","w")
fichier.write("Salut ! J'essaye d'écrire dans un fichier !")
fichier.close()

Les Fichiers
Pour écrire dans un fichier, il existe aussi la fonction
appelée writelines qui permet d'écrire tous les
éléments d'une liste dans un fichier.
Exemple
liste = ["Pour écrire dans un fichier on utilise :\n","1) write\n",
"2)writelines\n"]
fichier = open("test.txt","w")
fichier.writelines(liste)
fichier.close()

Les Fichiers
Lecture
Apres avoir ouvrir le fichier, le langage Python permet
plusieurs méthodes d’accès à un fichier :
read(n) : lit au plus n caractères dans le fichier s’il reste
encore plus de n caractères de la position courante à la fin de
fichier.
Syntaxe
Chaine=fichier.read(n)
Exemple
fichier = open("test.txt","r")
chaine=fichier.read(4)
print(chaine)
fichier.close()

Les Fichiers
L’utilisation de la méthode read() sans paramètre
permet de lire tout le fichier.
Exemple
chaine=fichier.read()
print(chaine)
fichier.close()

Les Fichiers
readline(n) lit au plus n caractères dans le fichier s’il
reste encore plus de n caractères de la position courante
à la fin de la ligne courante.
Exemple
chaine=fichier.readline(12)
print(chaine)
chaine=fichier.readline(100)
print(chaine)
fichier.close()

Les Fichiers
L’utilisation de la méthode readline() sans paramètre
permet de lire tous les caractères contenant entre la
position courante et la fin de la ligne.
Exemple
chaine=fichier.readline()
print(chaine)
print(chaine)
print(chaine)
fichier.close()

Les Fichiers
readlines() : cette méthode permet de récupérer
l'ensemble de contenu de fichier et de le mettre dans
une liste qui sera en suite retournée.
Exemple
liste = fichier.readlines()
print(liste[0])
print(liste[1])
print(liste[2])
fichier.close()

Les Fichiers
En Python, un fichier est en fait une séquence, Vous
pouvez donc facilement parcourir les lignes en utilisant
une boucle for.
Exemple
for ligne in fichier :
print(ligne)
fichier.close()

Les Fichiers
Le déplacement dans un fichier
La question qui se pose est comment un programme fait
pour savoir où l'on en est dans le fichier lorsqu'on lui
demande d'appliquer la fonction readline...
La position actuelle dans le fichier est accessible via la
fonction tell qui retourne la position actuelle du
programme dans le fichier.
Il est ensuite possible de déplacer le curseur de lecture
du fichier à l'aide de la fonction seek (chercher).

Les Fichiers
La fonction seek accepte deux arguments. Le premier
indique le nombre d'octet dont on souhaite se déplacer.
Le second indique la position à partir de laquelle on
souhaite se déplacer (0 pour commencer du début du
fichier).
Exemple
Fichier.tell()
fichier.seek(42,0)
ligne=fichier.readline()
print(ligne)
fichier.close()

Cours Python

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Python

Transféré par

Droits d'auteur :

Formats disponibles

CPGE TETOUAN Filière :MP/TSI

Prof:Yassine KHARCHACHI 1 Année Scolaire: 2020/2021

Présentation du langage Python

Prof:Yassine KHARCHACHI 2 Année Scolaire: 2020/2021

Calculer avec Python

Prof:Yassine KHARCHACHI 3 Année Scolaire: 2020/2021

Les types numériques: int, float, complex

Prof:Yassine KHARCHACHI 4 Année Scolaire: 2020/2021

Les types numériques: int, float, complex

Prof:Yassine KHARCHACHI 5 Année Scolaire: 2020/2021

Les types numériques: int, float, complex

Prof:Yassine KHARCHACHI 6 Année Scolaire: 2020/2021

Les types numériques: int, float, complex

Prof:Yassine KHARCHACHI 7 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 8 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 9 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 10 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 11 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 12 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 13 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 14 Année Scolaire: 2020/2021

Les instructions composées

Prof:Yassine KHARCHACHI 15 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 16 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 17 Année Scolaire: 2020/2021

Structures répétitives (Boucles)

Prof:Yassine KHARCHACHI 19 Année Scolaire: 2020/2021

Structures répétitives (Boucles)

 Remarque Une séquence peur être une chaîne de caractères et il

Prof:Yassine KHARCHACHI 20 Année Scolaire: 2020/2021

Structures répétitives (Boucles)

for i in range(1,5): for i in [1,2,3,4]: for i in (1,2,3,4):

Prof:Yassine KHARCHACHI 21 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 22 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 23 Année Scolaire: 2020/2021

Syntaxe complète des boucles

Prof:Yassine KHARCHACHI 24 Année Scolaire: 2020/2021

Syntaxe complète des boucles

Prof:Yassine KHARCHACHI 25 Année Scolaire: 2020/2021

Les chaînes de caractères

 Non modifiable signifie qu’une donnée, une fois créée en mémoire,

Prof:Yassine KHARCHACHI 26 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 27 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 28 Année Scolaire: 2020/2021

 print(”cHAise basSe”.isupper()) # False

 istitle() : retourne True si seule la première lettre de chaque

 print(”Chaise Basse”.istitle()) # True

 isalnum(), isalpha(), isdigit() et isspace() : retournent

 print(”3 chaises basses”.isalpha()) # False

Prof:Yassine KHARCHACHI 30 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 31 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 32 Année Scolaire: 2020/2021

 Len(): le nombre d’éléments dans la liste.

 del() : permet de supprimer un éléments dans la liste.

 append() : permet d’ajouter un élément à la fin da la liste.

 extend (): permet d’ajouter une liste à une autre.

 remove (): permet de supprimer la première occurrence

 pop(i) : cette méthode permet de retirer l’élément figurant à

 index(e) : Renvoie l'index du premier élément dont la valeur est 'e'.

 count(e) : Cette méthode vous renvoie le nombre d'occurrences de

 reverse() : Cette méthode vous permet d'inverser une liste.

Prof:Yassine KHARCHACHI 34 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 35 Année Scolaire: 2020/2021

Prof:Yassine KHARCHACHI 36 Année Scolaire: 2020/2021