Python 2

Filière Cycle d'Ingénieur : Sciences des
données, Big Data & IA
M123-2:
Langage Python
Pr.Mouhssine EL ATILLAH samedi, 11 mai 24

Historique de Python
▪ Python est un langage de programmation apparu officiellement en 1991. Guido van

Rossum l’a conçu à la fin des années 1980 à l’institut national de recherche en
mathématique et informatique aux Pays-Bas.
▪ Le nom du langage étant inspiré de la série Monty Python, cela donne une idée de la
philosophie derrière Python : la programmation doit être un plaisir.
▪ Python est un langage de programmation puissant portable, avec une bibliothèque

standard très importante.
▪ Python a des similarités avec des langages de script comme Perl ainsi qu’avec d’autres
langages comme Java et C.
Caractéristiques de base de Python
▪ Python est portable sur différents environnements tels que Unix et Windows.
▪ Logiciel libre.
▪ La syntaxe du langage est simple.
▪ Python gère lui-même l’espace mémoire disponible. Il est doté d’un typage dynamique car il n’y a
pas de déclaration explicite de variables ni de spécification de types; le type d’une variable est
déterminé à l’exécution seulement de même que l’allocation de l’espace mémoire.
▪ Il offre des possibilités pour la programmation orientée objets. Une approche « jeu de construction »
pour concevoir des programmes.
▪ Il possède une bibliothèque très riche (interfaces graphiques, bases de données, protocoles
Internet, …).
Avantages du langage Python
▪ Universel : non orienté vers un domaine d’applications particulières.

▪ Intégration : On peut utiliser Python sur une plate-forme JAVA et Python peut contenir du code C ou
C++ par exemple.
▪ Ouvert : C’est un langage Open Source. Il peut de ce fait être librement utilisé et distribué.
▪ Simplicité : la syntaxe claire et lisible facilite considérablement la création de programmes et leur mise
au point. Renferme peu de mots-clés.
▪ Portable : on peut utiliser le même programme sur presque tous les systèmes d’exploitation
(Linux/UNIX, Windows, MacOS, …).
▪ Extensible : le langage possède un ensemble de librairies d’outils, notamment dans le domaine de
l’accès aux bases de données, les interfaces graphiques, le développement pour le WEB, etc. Permet de
compléter ou d’adapter leurs outils afin d’être plus productifs.
Téléchargement et installation de Python
▪ Les différentes versions de Python (pour Windows, Unix, etc.), son tutoriel original, son
manuel de référence, la documentation des bibliothèques de fonctions, etc. sont disponibles
gratuitement, à partir du site officiel: http://www.python.org .
▪ On peut alors télécharger et installer Python à partir de cet emplacement en tenant compte
de la plate-forme utilisée.
▪ Par exemple, sous Windows, vous devez télécharger le fichier python-3.x.msi à partir du
site officiel et l’exécuter pour installer Python. Le dossier d’installation est dans C:\Python,
puis les fichiers de la bibliothèque standard dans C:\Python\Lib.
▪ Vous pouvez alors utiliser Python à partir de l’environnement de programmation IDLE.
Qu’est-ce qu’un langage interprété
▪ Un langage de programmation permet d’écrire des programmes dans des langages mieux
adaptés aux humains, mais nécessite une étape de traduction.
▪ Comme pour une langue étrangère, il nous faut un traducteur ou un interprète…

- Le traducteur va lire le texte et en produire une version dans la langue étrangère.
- L’interprète va lire le texte, et pendant sa lecture, effectuer la traduction en direct.
▪ Pour un langage informatique, c’est quasiment pareil, nous avons des compilateurs et des
interpréteurs
- Les compilateurs, traduisent tout le code source en langage binaire utilisable directement
par le CPU.
- L’interpréteur lit une partie du code source et exécute directement les instructions
binaires qui correspondent et passe à la suite.
Qu’est-ce qu’un langage interprété
Exécution de Python
Trois façons différentes de démarrer Python :
▪ Lancer l’interpréteur en mode interactif, en saisissant à chaque fois une seule ligne de
Python pour l’exécuter directement.
- Sous Windows, dans le menu Démarrer on presse sur la touche Exécuter puis, on saisit
au clavier la commande python.
▪ Exécuter un script écrit en Python en appelant l’interpréteur avec le nom du script.
- On lance l’invite de commandes CMD et on saisit au clavier la commande python
suivie du nom du script (un fichier avec l’extension .py) renfermant un programme
Python.
Ex.: python E:\essai.py
- On peut aussi cliquer deux fois sur le fichier directement afin de l’éditer.
▪ Lancer l’interpréteur à partir d’une interface graphique dans un environnement de développem
ent qui offre des outils additionnels tels qu’un débogueur intégré, un éditeur de texte, etc.
Les bases de Python
Python 3: print( "hello" )
Il existe quelques différences entre la syntaxe de Python 2.x et
Python 3.
▪ print est une fonction dans Python 3, qui utilise des
parenthèses:
Python 3.x:
print("hello")
Python 2.x:
print "hello"
Python 3.x:
print "hello"
NNNSyntaxError: Missing parentheses in call to 'print'
Hello, Word!
C#
using System;
class Hello
{
static void Main()
{
Console.WriteLine("Hello, World");
}
}
Python
print("Hello, World")
Variables
Variable est une référence à un objet
▪ Pas une valeur
▪ Plus d'une variable peut se référer
au même objet
Types numériques
▪ Entier
✓ Généralement signé, 32 bits
Entier compris entre -2 147 483 648 et 2 147 483 647
(codage sur 32 bits soit 4 octets)
▪ Entier Long: Entier compris entre -infini et -
2 147 483 647 ou entre 2 147 483 648 et +infini
✓ Taille illimitée
▪ Float
✓ nombre flottant qui a la précision d'un double.
▪ Complexe
✓ Format: <real>+<imag>j
✓ Exemple: 6+3j
Opérations de base
Affectation
Chaînes de caractères (Strings)
▪ Une suite des caractères délimitée par des guillemets 3 types de guillemets :
'guillemets simples’
"guillemets Double"
"""guillemets Triple """ ou '''guillemets triple'‘’
– Les guillemets triples peuvent s'étendre sur plusieurs lignes.
– Exemples
>>> print('This string may contain a "')
This string may contain a "
>>> print("A ' is allowed")
A ' is allowed
>>> print("""Either " or ' are OK""")
Either " or ' are OK
Opérations arithmétiques
▪ Opérateurs : + - * / // ** % abs
Exemples:
>>> 5 + 3 # Addition
8
>>> 2 ** 8 # Exponentiation
256
>>> 13 / 4 # Division réelle
3.25
>>> 13 // 4 # Division entière (troncature)
3
>>> 13 % 4 # Reste
1
>>> abs(-3.5) # Valeur absolue
3.5
Comparaisons booléennes
▪ Comparaison : < <= > >= == !=
Résultats 1 (true) or 0 (false)
Exemple
>>> 4 > 1.5
1
>>> 'this' != 'that’
1
>>> 4+3j == 4-2j
0
>>> '5' == 5
0
>>> 0 < 10 < 20
1
Opérations booléennes
▪ Opérateurs : and or not
Algèbre booléenne
A B Not A A and B A or B
1 1 1 1
0
1 0 0 1
0 1 0 1
1
0 0 0 0
Table de priorité des opérateurs
Ordre Opérateurs Ordre Opérateurs
1 or 5 +,-
2 and 6 *,/
3 not
4 < , <= , > , >= , != et ==

Expressions booléennes
>>> 1 == 1 and 2 >= 3

False
>>> 1 == 1 or 2 >= 3
True
>>> not 5.3 != 2.2 # pareil que: not (5.3 != 2.2)
False
Exercice 1
A B not A and B not A or B not A or A not A and A
1 1
1 0
0 1
0 0
Exercice 2
Évaluez les expressions logiques suivantes :
A = (18 - 13 < 2) or (13 >= 14 - 1*2) and (5<2)

B = not(True or False) and ( True and False)
C = not(True) or not(False)
D = not(True) and not(False) or (13 < 13*2)
Donnée Valeur Type

A
B
C
D
Chaînes de caractères : opérations
Les opérateurs sur les chaînes permettent de concaténer, filtrer ou extraire des parties des
chaînes de caractères entres elles
Synatxe Sémantique
len(s) Longueur de la chaîne s
s1 + s2 Concaténation de s1 et s2
s*n Répétition ’n’ fois de la chaîne ’s’
s in t Teste si la chaîne ’s’ est présente dans ’t’.
s[n] Extraction du n-ième caractère en partant du début de la chaîne
s[-n] Extraction du n-ième caractère en partant de la fin de la chaîne
s[n:m] Extraction des caractères se trouvant entre le n-ième et le m-ième
s[:n] Extraction des ’n’ premiers caractères de la chaîne
s[n:] Extraction des derniers caractères de la chaîne à partir du n-ème
s[-n:] Extraction des caractères des ’n’ derniers caractères de la chaîne

Chaînes de caractères : opérations
• Exemple
txt="cours python"
print(len(txt)) #12
print(txt[2]) #u
print(txt[-2]) #o
print(txt[2:7]) #urs p
print(txt[:7]) #cours p
print(txt[4:]) #s python
print(txt[-4:]) #thon
txt2="math"
print(txt+txt2) #cours pythonmath
txt2=txt*2
print(txt2) #cours pythoncours python
print("ou" in txt) #True
Chaînes de caractères : Fonctions
s = '''Hello world''' Multi-line strings (triple quote)
s.lower() to lowercase
s.upper() to uppercase
index of first occurrence, throw exception if substring
s.index('e')
not found
s.count(‘o') count occurrences
s[1:10] slice, just like list slice
s.replace(“Hello",“Hi") replace substring.
>>> "Hello".ljust(8)
Left justify to given length.
"Hello "
>>> "Hello".rjust(8)
Right justify.
" Hello"
>>> "Hello".center(8)
Center, of course.
" Hello "
Conversion entre types
• La conversion de types permet de passer d’un type à l’autre
• La règle générale est de se servir du nom du type avec des parenthèses
Syntaxe Sémantique
bool(var) Converti ’var’ en un booléen
int(var) Converti ’var’ en un entier
float(var) Converti ’var’ en un flottant
str(var) Converti ’var’ en une chaîne de caractères
• Exemple
print() / input()
• print(msg) : imprime à l’écran une chaîne de caractères donnée en argument.
• input(msg): permet de récupérer une chaîne de caractères tapée par l’utilisateur
(retourne une chaine).
• Exemples
En résumé
• Les variables utilisées jusqu'ici sont en réalité des objets.

• Les types de données utilisés jusqu'ici sont en fait des classes. Chaque objet
est modelé sur une classe.
• Chaque classe définit certaines fonctions, appelées méthodes, qui seront
accessibles depuis l'objet grâce à objet.methode(arguments).
• On peut directement accéder à un caractère d'une chaîne grâce au code
suivant : chaine[position_dans_la_chaine].
• Il est tout à fait possible de sélectionner une partie de la chaîne grâce au code
suivant : chaine[indice_debut:indice_fin].
Structures de contrôle
du flux
Les structures conditionnelles
• Exemple 1
• Syntaxe
if <condition1>:
<blocs d'instructions 1>
elif <condition2>:
else:
Les structures conditionnelles
• Exemple 2
• Remarque
Il n’existe pas de switch en python et par conséquent on peut utilise
if … elif…else
Conditions
Types évaluant à faux :
• None
• False
• Tous les zéros : 0 , 0. , 0j
• Les listes/dictionnaires/chaines vides : [] , () , '' '', {}
• Tout objet dont la méthode bool() retourne False
condition = 5 -> True
• Tout objet dont la méthode len() retourne 0 condition = None -> False
Exemple condition = 0 -> False
condition = ‘’ -> False
condition = [] -> False
condition = () -> False
condition = {} -> False
Boucle for
• En Python, for est un itérateur sur des collections d’objets. Il est utilisé pour parcourir, dans l’ordre s’il
y en a un, les éléments de la collection
• Syntaxe:
for elem in iterable :
Instructions
iterable est souvent:

✓ range(debut,fin,[step=1])
✓ une liste
✓ n’importe quel objet itérable
Remarque : la fonction range(start, stop, step)permet de créer une collection de nombres pour itérer
dessus
• Exemples
Boucle for
• Exemples
Boucle while
• Syntaxe
while <condition1>: while <condition1>:

<blocs d'instructions 1> <blocs d'instructions 1>
if <condition2>: break
if <condition3>: continue
else:
✓ break : sort de la boucle sans <blocs d'instructions 2>
passer par else
✓ continue : remonte au début de la boucle
✓ pass : ne fait rien
✓ else : lancé si et seulement si la boucle se termine normalement
• Exemple
Boucle infinie
Boucle while
• Exemples
Conteneurs standards
▪ Listes
▪ Tuples
▪ Ensembles
▪ Dictionnaires
Listes
• Les listes servent à stocker des collections ordonnées d’éléments avec possibilité
de les étendre ou de les manipuler facilement
Initialisation
• L1=[]; L2=list() #Listes vides
• L1= [1, 2, 3, 4, 5]; L2= ['point', 'triangle', ‘rectangle']
• L=[1, 4, ‘ali', 4, ‘laila', ['point', 6]]
• L=[3]*6 # L=[3, 3, 3, 3, 3, 3]
Concaténation
Manipulation des listes
Syntaxe Sémantique
len(L) Nombre d’éléments dans la liste
del(L[n]) Détruit l’élément ‘n’ de la liste ‘L’
L1 + L2 Concaténation de ‘L1’ et ‘L2’
L*n Répétition ’n’ fois de la liste ‘L’
L[n] Extraction du n-ième élément en partant du début de la liste
L[-n] Extraction du n-ième élément en partant de la fin de la liste
L[n:m] Extraction des éléments qui sont entre ‘n’ et ‘m’
L[:n] Extraction des ‘n’ premiers éléments de la liste
L[n:] Extraction des éléments ‘n’ à la fin de la liste
L[-n:] Extraction des ‘n’ derniers éléments de la liste

Syntaxe Sémantique
L.clear() Vide la liste ‘L’
L.copy() Renvoie une copie de la liste ‘L’
L.append(e) Ajoute l’élément 'e' à la fin de la liste 'L'
L.insert(n, e) Insère l’élément 'e' à la position 'n' dans la liste 'L'
L.sort() Trie la liste L
L.reverse() Inverse la liste L
L.index(e) Rechercher l’élément 'e' dans la liste L
L.remove(e) Retirer l’élément 'e' de la liste L
L.pop() Retirer le dernier élément de la liste L
L.pop(ind) Retirer l’élément qui est dans la position ' ind' de la liste L
Exemples
cours=['Hist','Math','Phy','Ar','Sc']
print(cours) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
print(len(cours)) #5
print(cours[1]) #Math
print(cours[-2]) # Ar
print(cours[1:3]) #['Math', 'Phy']
print(cours[:2]) #['Hist', 'Math']
print(cours[2:]) #['Phy', 'Ar', 'Sc']
cours.append('Fr'); print(cours) #['Hist', 'Math', 'Phy', 'Ar', 'Sc', 'Fr']
p=cours.pop(); print(cours) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
print(p) #Fr
cours.insert(1,'Art');
print(cours) # ['Hist', 'Art', 'Math', 'Phy', 'Ar', 'Sc']
cours=['Hist','Math','Phy','Ar']
cours2=['Ang','Fr']
cours.insert(1,cours2); print(cours) # ['Hist', ['Ang', 'Fr'], 'Math', 'Phy', 'Ar']
#insertion en tant que liste et non en tant que valeurs
cours.remove(cours2); print(cours) # ['Hist', 'Math', 'Phy', 'Ar']
cours.extend(cours2); print(cours) # ['Hist', 'Math', 'Phy', 'Ar', 'Ang', 'Fr']
Exemples
cours =['Hist','Math','Phy','Ar','Sc']
cours.reverse(); print(cours) #['Sc', 'Ar', 'Phy', 'Math', 'Hist']
cours.sort(); print(cours) #['Ar', 'Hist', 'Math', 'Phy', 'Sc']
cours.sort(reverse=True);
print(cours) #['Sc', 'Phy', 'Math', 'Hist', 'Ar']
cours =['Hist','Math','Phy','Math',‘Ar']
coursTrié=sorted(cours)
print(coursTrié) #['Ar', 'Hist', 'Math', 'Math', 'Phy']
print(cours) # ['Hist', 'Math', 'Phy', 'Math', 'Ar']
print(cours.index('Math')) #1
print(cours.index('FR')) #Erreur
print('Hist' in cours) #True
txt=' - '.join(cours)
print(txt) # Hist - Math - Phy - Math - Ar
cours2=txt.split(' - ')
print(cours2) # ['Hist', 'Math', 'Phy', 'Math', 'Ar']
Exemples
cours =['Hist','Math','Phy']
for matiere in cours: print(matiere) #Hist Math Phys
for i,matiere in enumerate(cours): #
print(i,matiere)
for i,matiere in enumerate(cours,start=1): #

print(i,matiere)
L=[4,2,6,1]
L.sort(reverse=True)
print(L) # [6, 4, 2, 1]
print(min(L)) #1
print(sum(L)) #13
L=[2,5,7]
L1=3*L; print(L1) # [2, 5, 7, 2, 5, 7, 2, 5, 7]
L2=[3*x for x in L]; print(L2) # [6, 15, 21]
print([3*x for x in L if x>2]) # [15, 21]
Suppression d’un élément
• remove: Retire la première occurrence d’un élément de la liste
Exemple: L=[1, 2, 4, 2]
L.remove(2)
print(L) # [1, 4, 2]
• del: supprime un élément de la liste à partir de son indice
Exemple: L=[1, 2, 4, 2]
del(L[2])
print(L) #[1, 2, 2]
• pop: supprime un élément à partir de son indice et le retourne
Exemple: L=[1, 2, 4, 2]
x=L.pop(2)
print(x) #4
print(L) # [1, 2, 2]
Copie d’une liste
L =['Hist','Math','Phy','Ar','Sc']
T=L
print(L) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
print(T) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
T[2]="Fr"
print(T) #['Hist', 'Math', 'Fr', 'Ar', 'Sc']
print(L) #['Hist', 'Math', 'Fr', 'Ar', 'Sc']
L =['Hist','Math','Phy','Ar','Sc']
T=L[:] #T=L.copy()
T[2]="Fr"
print(T) #['Hist', 'Math', 'Fr', 'Ar', 'Sc']
print(L) #['Hist', 'Math', 'Phy', 'Ar', 'Sc']
Remarque:
Les listes sont mutables: ils peuvent subir des modifications
Tuples
• Ils permettent de grouper des éléments de différentes natures pour créer une structure
qui les englobe
Initialisation
• T1=(); T2=tuple() # Tuples vides
• T= 'a', 'b', 'c', 'd' # T=('a', 'b', 'c', 'd')
• T= ('a', 'b', 'c', 'd')
• T= (1, 2)*3 # T=(1, 2, 1, 2, 1, 2)
Concaténation
T1,T2=(1,2),("ali","laila")
print("T1=",T1) # T1= (1, 2)
print("T2=",T2) # T2= ('ali', 'laila')
print("T1+T2=",T1+T2) # T1+T2= (1, 2, 'ali', 'laila')
Tuples
• Les tuples ne sont pas modifiables: Il sont immuables
Exemple
t =('Hist','Math','Phy','Ar','Sc')
print(t) #('Hist', 'Math', 'Phy', 'Ar', 'Sc')
print(t[2]) #Phy
print(t[2:]) #('Phy', 'Ar', 'Sc')
print(t[-2]) #Ar
t2=t
print(t2) #('Hist', 'Math', 'Phy', 'Ar', 'Sc')
t2[0]='Art' #Error: 'tuple' object does not support item assignment
print(t2)
print(t)
Ensembles
• Un ensemble est une collection d'objets sans répétition et sans ordre (donc sans numérotage).
Ce n'est pas une séquence
• On les note comme en maths avec des accolades {...}. Les éléments sont de types quelconques
Initialisation
• S=set() # Ensembles vides

• S={"rouge","vert","noir"}
• S= {5,'foo',(3,-2),7.4}
Remarque
• S={} crée un dictionnaire et non pas un ensemble

Opérations
• Les seules opérations que l’on peut faire sur les ensembles sont toutes les opérations
ensemblistes (appartenance, intersection, union, …)
Ensembles
Opérations
Syntaxe Sémantique Syntaxe Sémantique
len(s) Taille de l’ensemble 's' e in s 'e' ∈ 's'
s.add(e) Ajoute 'e' à 's' e not in s 'e' ∉ 's'
s1 == s2 's1' égal 's2'

s.remove(e) Retire 'e' de 's' (erreur si ’e’ ∉ 's')
s1 != s2 's1' différent de 's2'
s.discard(e) Retire 'e' de 's'
s1 < s2 's1' est inclus (strict) dans 's2'
s.clear() Vide l’ensemble 's'
s1 <= s2 's1' est inclus ou égal à 's2'
s1 | s2 Union de ’s1’ et ’s2’
s1 > s2 ’s2’ inclus (strict) dans 's1'
s1 & s2 Intersection de ’s1’ et ’s2’
s1 >= s2 's2' inclus ou égal à 's1'
s1 ^ s2 Différence exclusive de ’s1’ et ’s2’
s1.issubset(s2) 's1' inclus dans 's2'
s1.issuperset(s2) 's1' inclus 's2'

Ensembles
Exemples
color1={'rouge','vert','bleu','noir'}
print(color1) #{'bleu', 'noir', 'vert', 'rouge'} Affichage change à
chaque exécution
color1={'rouge','vert','bleu','noir','vert'}
print(color1) #{'bleu', 'noir', 'vert', 'rouge'} n’accepte pas les
doublons
print(color1[1]) #Error: 'set' object does not support indexing
print(len(color1)) #4
print('vert' in color1) #True
print('belu' not in color1) #True
color2={'rose','vert'}
c=color1|color2; print(c) #{'bleu', 'rose', 'vert', 'noir', 'rouge'}
print(color1.union(color2)) #{'bleu', 'rose', 'vert', 'noir', 'rouge'}
c=color1 & color2; print(c) #{'vert'}
print(color1.intersection(color2)) #{'vert'}
print(color1^color2) #{'bleu', 'rose', 'noir', 'rouge'}
print(color2.issubset(color1)) #False
print({'rouge','bleu'}.issubset(color1)) #True
Dictionnaires
• Un dictionnaire est une collection non numérotée de couples var:val où var est un objet non
mutable (la clé) et où val est n'importe quelle valeur
• On peut accéder à un élément d’un dictionnaire à partir d’une clé
• Les clés d’un dictionnaires doivent être distinctes et ne peuvent pas être modifiées
Initialisation
• D={}; Dc=dict() #Dictionnaire vide
• stock={"pomme":40,"orange":30}
• etudiant={'nom':'ali','age':20,'cours':['Math','Phys']}
Insertion/Modification
On peut modifier la valeur associée à une clé, ou rajouter un nouveau couple clé/valeur :
➢ stock={"pomme":40,"orange":30}
➢ stock["kiwi"]=60 #stock={'pomme': 40, 'orange': 30, 'kiwi': 60}
➢ stock['orange']='cent' # stock={'pomme': 40, 'orange': 'cent', 'kiwi': 60}
Dictionnaires
Accès à un élément
• On peut rapidement accéder à la valeur associée à une clé. C'est le principal
intérêt des dictionnaires
Exemple
• La clé doit être non mutable. Donc essentiellement des chaînes et des nombres
mais pas de listes. On peut utiliser des tuples comme clés à condition qu'ils ne
contiennent aucun objet mutable
• Il est aussi possible de demander si la clé existe, avec l'opérateur in
Exemple
Dictionnaires
Principales méthodes
Syntaxe Sémantique
len(d) Nombre d’éléments du dictionnaire
del(d[k]) Détruit l’entrée 'k' du dictionnaire
d.clear() Supprime tous les éléments du dictionnaire 'd'
d.copy() Renvoie une copie du dictionnaire 'd'
d.keys() Renvoie la liste des clés utilisées dans le dictionnaire
d.values() Renvoie la liste des valeurs utilisées dans le dictionnaire 'd'
d.has_key(k) Renvoie True si la clé passée en paramètre existe, False sinon
d.items() Renvoie une liste équivalente de tuples à partir du dictionnaire 'd'
d.pop(cle, val) Supprime et retourne d[cle] si la clé est présente sinon retourne val
d.update(d1) Ajoute les paires clé-valeur de 'd1' à 'd'
sorted(d) Retourne une liste ordonnée des clés du dictionnaire d
Dictionnaires
Exemple
etud={'nom':'ali','age':20,'cours':['math','phys']}
print(etud) #{'nom': 'ali', 'age': 20, 'cours': ['math', 'phys']}
print(len(etud)) #3
print(etud['nom']) # ali
print(etud['tel']) # Erreur
print(etud['cours']) # ['math', 'phys']
print(etud.get('nom')) # ali
print(etud.get('tel')) # None
print(etud.get('tel','clé inexistante')) # clé inexistante
etud['adresse']='agadir‘
etud['nom']='imad'
print(etud) # {'nom': 'imad', 'age': 20, 'cours': ['math', 'phys'], 'adresse': 'agadir'}
etud2={'nom':'laila','pays':'maroc'}
etud.update(etud2)
print(etud) # {'nom': 'laila', 'age': 20, 'cours': ['math', 'phys'], 'adresse': 'agadir',
'pays': 'maroc'}
del(etud[‘cours'])
print(etud) # {'nom': 'laila', 'age': 20, 'adresse': 'agadir', 'pays': 'maroc'}
Dictionnaires
Exemple
x=etud.pop('nom','clé inexistante')
print(x) #ali
print(etud) #{'age': 20, 'cours': ['math', 'phys']}
print(etud.pop('tel',-1)) #-1
print(etud.keys()) #dict_keys(['nom', 'age', 'cours'])
print(etud.values()) #dict_values(['ali', 20, ['math', 'phys']])
for i in etud: #
print(i,":",etud[i])
for cle,val in etud.items(): #

print (cle,val)
En résume
Test d'appartenance
Container Itérable Ordonné Indexable Modifiable
et fonction len()
Liste oui oui oui oui oui
Tuple oui oui oui oui non
Dictionnaire oui oui sur les clés oui non oui
Set oui oui non non oui

Les fonctions
▪ Définition
▪ Arguments d’une fonction
▪ Fonctions variadiques
▪ Portée d’une variable
Définition
• Les fonctions servent à rendre un programme modulaire et à éviter de
répéter plusieurs fois le même code
Définition:
def <nom_fonction>(arg1, arg2,... argN):
bloc d'instructions
return <valeur(s)>
Exemple:
1.
2.
3.
Exemples
• Les parenthèses sont obligatoires pour appeler une fonction
Exemple:
• Définition d’une fonction qui ne fait rien

Exemple:
• Remarque: Une fonction qui n'a pas de return renvoie par défaut None
Arguments d’une fonction
• Les arguments d'une fonction ne sont pas typés a priori mais sont substitués
dynamiquement dans le code de la fonction lors de l’exécution
• On peut inverser les arguments lors d’un appel si on les nomme
Exemple:
def puissance(a, b):
return a**b
print(puissance(2,3)) #affiche 8
x=puissance(b=3, a=2)
print(x) #affiche 8
Arguments nommés
• Les arguments nommés permettent de donner des noms et des valeurs par défaut à certains
arguments d’une fonction
• Les arguments nommés deviennent optionnels lors de l’appel à la fonction
• Exemples
1. def afficher(msg,nom="ali"):
return "{} {}".format(msg,nom)
print(afficher("bonjour")) #bonjour ali
print(afficher("bonjour","laila")) #bonjour laila
2. def F(a,b,c=0,d=2):
return a+b-c*d
x=F(10,5); print(x) #15
y=F(5,10,d=3); print(y) #15
z=F(5,10,d=1,c=2); print(z) #13
• Les arguments non-nommés doivent être placés, toujours dans le même ordre, au début de
la fonction et les arguments nommés toujours à la fin
Fonction variadique
• Une fonction variadique est une fonction dont le nombre d’arguments est variable et donc on
peut y mettre le nombre d’arguments que l’on veut
• L’opérateur * convertit des arguments non nommés en tuple
• Exemple 2. def sum(*args):
s=0
1. def afficher(*args):
for x in args: s+=x
print(args)
return s
afficher('pomme','orange’) #('pomme', 'orange')
print(sum(2,4)) #6
afficher('laila',30,True,'salut') #('laila', 30, True, 'salut')
print(sum(2,3,10,5,4)) #24
• On utilise l'opérateur * pour transformer une liste en arguments d’une fonction

Exemple:
L=[2,5,9,4]
print(sum(L)) #Error: unsupported operand type(s) for +=: 'int' and 'list'
print(sum(*L)) # 20 =>l’opérateur * "déliste" L en arguments
Fonction variadique
• On peut avoir un nombre variable d’arguments nommés, utile quand on a beaucoup
d’arguments optionnels ayant une signification différente
• L’opérateur ** convertit des arguments nommés en dictionnaire
Exemple
1. def afficher(**args):
print(args)
afficher(nom="ali",age=30) #{'nom': 'ali', 'age': 30}
2. def test(**args):
for k in args:
print(k," : ",args[k])
test(nom='ali',age=30,adresse='agadir')
etudiant={'nom':'laila','age':20,'cours':['Math','Phys']}
test(**etudiant)
Fonction variadique
Exemple
def afficher(*args,**kargs):
print(args)
print(kargs)
#('Math', 'Phys’)
afficher('Math','Phys',nom='ali',age=30)
{'nom': 'ali', 'age': 30}
cours=['Math','Pys']
info={'nom':'ali','age':30}
# (['Math', 'Pys'], {'nom': 'ali', 'age': 30})
afficher(cours,info)
{}
afficher(*cours,**info) #('Math', 'Pys’)
{'nom': 'ali', 'age': 30}

Fonction variadique
Exemple
nbr_jours=[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
def is_leap(annee):
return annee%4==0 and (annee%100!=0 or annee%400==0)
def nbrJour(mois,annee):
""" Retourne le nombre de jours dans le mois et l’année spécifiés"""
if not 1<=mois<=12: return 'mois invalide'
elif mois==2 and is_leap(annee): return 29
else: return nbr_jours[mois-1]
print(nbrJour(2,2000)) #29
print(nbrJour(2,2017)) #28
Portée d’une variable
Variable locale/globale
• La portée d’une variable correspond à l’ensemble des lignes dans lesquelles la variable peut être appelée
• Lorsqu’on est en dehors de la portée d’une variable et que l’on fait appel à elle, le programme provoque
une erreur
• Une variable est dite “globale” si sa portée recouvre l’ensemble du programme
• Une variable est dite “locale” si sa portée recouvre seulement une partie du programme
• Exemple
x="salut" def test(): x="salut"

def test(): x="bonjour" def test():
x="bonjour" print(x) global x
print(x) test() #bonjour x="bonjour"
test() #bonjour print (x) #Erreur print(x)
print (x) #salut #x inconnu à l’exterieur test() #bonjour
de la fonction test print (x) #bonjour
Variable locale/globale 4. x='global x'
1. x='global x ' def test():
def test(): x='local x'
y='local y' print(x)
print(y) test() #local x
test() #local y print(x) #global x
2. x='global x' 5. x='global x'

def test(): def test():
y='local y' global x #on déclare travailler avec la
print(x) variable globale
test() #global x x='local x'
print(x)
3. x='global x' test() #local x
def test(): print(x) #local x
y='local y'
print(x)
x='abc'
test() #Erreur
# local variable 'x' referenced
before assignment
Variable locale/globale
enumerate() / zip()
• Les fonctions enumerate() et zip() sont utiles pour les itérations sur des structures
➢ enumerate() : Associe un index sur la structure lorsqu’il n’y en a pas
➢ zip() : Permet d’itérer deux structures en parallèle
• Exemple
➢ myset = {'a','w','d'}
for index,item in enumerate(myset):
print(index,item)
➢ mylist1 = [5, 3, 9, 4, 1]
mylist2 = ['a','w','d','e']
for index,char in zip(mylist1,mylist2):
print (index ,char)
Les modules
▪ Importer un module
▪ Créer un module
▪ Chemin de recherche d’un module
▪ Modules standards
Importer un module
• Les modules Python permettent de grouper et de rendre facilement réutilisable
du code Python
• Différentes manières d'importer un module
➢ import module1 , module2 # Importe les modules
➢ import module1 as md1 #Importe un module en lui donnant un
nom
➢ from module import func1,func2 # Importe les fonctions
➢ from module import * # Importe toutes les fonctions du module
• Exemple
Créer un module
Écrire et utiliser un module
• Créer un module revient à créer un fichier au nom du module que l’on désire
créer (suivi de ’.py’), puis d’y inclure les fonctions désirées
• Exemple
#Fichier my_module.py import my_module

cours=['math','phys','arabe','Histoire']
txt='test string' indice=my_module.find_index(cours,'phys')
def find_index(L,val): print(indice)
"""Trouver l'indice d'une valeur import my_module as md

cours=['math','phys','arabe','Histoire']
dans une sequence""" indice=md.find_index(cours,'phys')
for i, value in enumerate(L): print(indice)
if value==val : from my_module import find_index
return i cours=['math','phys','arabe','Histoire']
indice=find_index(cours,'phys')
return -1 print(indice)
Chemin de recherche d'un module
• Par défaut, l’interpréteur Python cherche le module dans le répertoire où il exécute les scripts,
puis dans les endroits “habituels”
• Si un module se trouve dans un autre répertoire, il faut l'ajouter dans sys.path
Exemple:
import sys
sys.path.append('/Users/amazal/Desktop/Exemples_python')
from my_module import find_index,txt
cours=['math','phys','arabe','Histoire']; indice=find_index(cours,'p
hys')
print(indice)
print(txt)
• Remarque: si du code Python se trouve en dehors de toute fonction dans le module, il sera exécuté
à son chargement. Pour éviter que cela se produise, il faut “protéger” le code avec :
#Fichier my_module.py
if __name__=="__main__":
# code exécuté seulement si on lance le fichier '.py ',
# pas si on l’ importe dans un autre fichier .
Modules standards
• Quelques modules standards:
✓ String
✓ Math
✓ Time
✓ Sys
✓ Os
• module sys: Informations système (version de python), options du système

sys.path:
✓ donne le python path où sont recherchés les modules lors de l'utilisation d'import
✓ sys.path est une liste pour ajouter un élément : sys.path.append('...')
✓ Le premier élément est le répertoire courant
sys.exit: permet de quitter un script python
La méthode open()
La méthode open()
La méthode open() est une fonction intégrée à Python qui permet d'ouvrir un fichier pour
effectuer des opérations de lecture, d'écriture ou d'ajout. Cette fonction prend plusieurs
arguments, le plus important étant le nom du fichier et le mode d'ouverture.
▪ Syntaxe de open()
La syntaxe de la méthode open() est la suivante :
File = open(file, mode='r’)
• file: le nom ou le chemin du fichier à ouvrir.

• mode: le mode d'ouverture ('r', 'w', 'a', 'x', 'b', '+').
Modes d'ouverture
Les différents modes d'ouverture définissent les actions possibles sur le fichier. Voici les
principaux modes et leurs fonctions :
• 'r' : Lecture. Ouvre un fichier pour lire. Le fichier doit exister, sinon une exception est levée.
• 'w' : Écriture. Ouvre un fichier pour écrire. Si le fichier existe, il est effacé. Si le fichier n'existe pas, il
est créé.
• 'a' : Ajout. Ouvre un fichier pour ajouter du contenu à la fin. Si le fichier n'existe pas, il est créé.
• 'x' : Écriture exclusive. Crée un nouveau fichier et l'ouvre en écriture. Si le fichier existe, une exception
est levée.
• 'b' : Mode binaire. Utilisé conjointement avec les modes ci-dessus ('rb', 'wb', 'ab', 'xb') pour lire ou
écrire des fichiers binaires (images, vidéos, etc.).
• '+' : Lecture/Écriture. Permet de lire et écrire dans le fichier (utilisé en combinaison avec 'r', 'w', 'a', 'b').
Modes d'ouverture
▪ Lecture : 'r'
Sans with Avec with
file = open('fichier.txt', 'r’) with open('fichier.txt', 'r') as file:

contenu = file.read() contenu = file.read()
print("Contenu du fichier :") print("Contenu du fichier :")
print(contenu) print(contenu)
file.close()
NB : Lorsque vous ouvrez un fichier sans utiliser with, vous devez gérer l'ouverture et la
fermeture du fichier.
Modes d'ouverture
▪ Écriture : 'w' ▪ Ajout : 'a'
with open('fichier.txt', 'w') as file: with open('fichier.txt', 'a') as file:

file.write('Bonjour, monde!') file.write('\nAjout de texte.')
▪ Lecture/Écriture : 'r+'
with open('fichier.txt', 'r+') as file:
contenu = file.read()
print("Contenu initial :")
print(contenu)
file.write('\nAjout de texte.')
Méthodes de lecture
▪ file.readline([size])
• Lit une ligne du fichier.

• size (optionnel) spécifie le nombre maximum de caractères à lire de la ligne.
• Si size est fourni, la méthode lit jusqu'à size caractères ou jusqu'à la fin de la ligne, selon ce
qui se produit en premier.
• Exemple :
with open('fichier.txt', 'r') as file:

ligne = file.readline() # Lit la première ligne du fichier
print(ligne)
Méthodes d'écriture
▪ file.readlines()
• Lit toutes les lignes du fichier et les retourne sous forme de liste.
• Chaque élément de la liste est une ligne du fichier.
• Exemple :

lignes = file.readlines() # Lit toutes les lignes du fichier
for ligne in lignes:
print(ligne.strip()) # Affiche chaque ligne
Méthodes de lecture
▪ file.writelines(lines)
• Écrit une liste de lignes dans le fichier.
• lines est une liste contenant les lignes à écrire.
• Chaque élément de la liste est écrit dans le fichier sans ajout automatique de saut de ligne (\n).
• Exemple :
lignes = ['Première ligne.\n', 'Deuxième ligne.\n’]

with open('fichier.txt', 'w') as file:
file.writelines(lignes)
Position du fichier
▪ file.tell()
• Retourne la position actuelle dans le fichier, en nombre d'octets à partir du début du fichier.
• Exemple :

print(f"Position initiale : {file.tell()}")
file.read(10)
print(f"Position après lecture de 10 caractères : {file.tell()}")
Position du fichier
▪ file.seek(offset, whence=0)
• Modifie la position actuelle dans le fichier.
• offset spécifie le nombre d'octets à se déplacer.
• whence (optionnel) indique la référence à partir de laquelle l'offset est calculé :
• 0: Début du fichier (valeur par défaut).
• 1: Position actuelle dans le fichier.
• 2: Fin du fichier.
• Exemple :

file.seek(10) # Se déplace à la position 10
print(file.read()) # Lit à partir de la position 10
L’utilisation d’Open() avec Split()
▪ La méthode split() est une méthode de la classe str en Python qui permet de
diviser une chaîne de caractères en une liste de sous-chaînes en fonction d'un séparateur
spécifié. Si aucun séparateur n'est spécifié, split() utilise par défaut les espaces
blancs (espaces, tabulations ou nouvelles lignes) comme séparateur.
▪ Dans le contexte de l'ouverture de fichiers avec open(), vous pouvez utiliser
split() pour diviser les lignes lues dans un fichier en différentes parties en fonction
d'un séparateur spécifique. Par exemple, dans un fichier CSV (valeurs séparées par des
virgules), split(',') peut être utilisé pour diviser chaque ligne en différentes
valeurs.
L’utilisation d’Open() avec Split()
# Ouvrir le fichier en mode lecture
with open(fichier, 'r') as file:
# Lire chaque ligne du fichier
F for ligne in file:
# Diviser la ligne en une liste de valeurs en utilisant la virgule comme séparateur
valeurs = ligne.strip().split(',’) # `strip()` supprime les espaces superflus
# Afficher les valeurs divisées
print(valeurs)
Le module OS
Le module os
Le module os en Python fournit une variété de fonctions pour interagir avec le
système d'exploitation. Cela inclut des fonctionnalités pour gérer les fichiers et
les répertoires, interagir avec le système d'exploitation, et obtenir des
informations sur le système.
Importation du module os
Pour utiliser le module os, vous devez l'importer au début de votre script :
import os
Gestion des répertoires
▪ Obtenir le chemin du répertoire courant
La fonction os.getcwd() retourne le chemin du répertoire courant :
import os
chemin_courant = os.getcwd()
print(f"Chemin du répertoire courant : {chemin_courant}")
Résultat : Par exemple, /chemin/du/repertoire.

Le module os offre de nombreuses fonctions pour gérer les répertoires :
▪ Lister le contenu d'un répertoire

La fonction os.listdir() liste le contenu d'un répertoire donné. Dans l'exemple suivant, nous listons
le contenu du répertoire courant (.) :
import os
contenu = os.listdir('.’)
Print (contenu)
Résultat : Une liste des fichiers et répertoires dans le répertoire courant, par exemple
: ['fichier1.txt', 'dossier1', 'fichier2.py']
▪ Changer de répertoire
La fonction os.chdir() permet de changer le répertoire courant. Voici un exemple où
nous changeons le répertoire à /chemin/du/repertoire :
import os
os.chdir('/chemin/du/repertoire’)
print("Nouveau répertoire courant :", os.getcwd())
Résultat : Affiche le nouveau répertoire courant : Nouveau répertoire courant :

/chemin/du/repertoire
▪ Créer un nouveau répertoire
La fonction os.mkdir() crée un nouveau répertoire. Voici un exemple où nous créons

un répertoire nommé nouveau_repertoire :
import os
os.mkdir('nouveau_repertoire’)
print("Répertoire créé : 'nouveau_repertoire'")
Résultat : Le répertoire nouveau_repertoire est créé, mais il n'affiche pas de message

d'erreur si le répertoire existe déjà.
▪ Créer une structure de répertoire
Vous pouvez utiliser os.makedirs() pour créer une structure de répertoires, y compris
les sous-répertoires :
import os os.makedirs('dossier/ss_dossier1/ss_dossier2’)
print("Structure de répertoires créée : dossier/ss_dossier1/ss_dossier2")
Résultat : Crée la structure de répertoires spécifiée.

▪ Supprimer un répertoire vide
La fonction os.rmdir() supprime un répertoire vide. Voici un exemple où nous
supprimons un répertoire nommé repertoire_a_supprimer :
import os
os.rmdir('repertoire_a_supprimer’)
print("Répertoire supprimé : 'repertoire_a_supprimer'")
Résultat : Le répertoire repertoire_a_supprimer est supprimé s'il est vide, sinon

une exception est levée.
Gestion des fichiers
▪ Supprimer un fichier
La fonction os.remove() supprime un fichier. Voici un exemple où nous supprimons

un fichier nommé fichier_a_supprimer.txt :
import os
os.remove('fichier_a_supprimer.txt’)
print("Fichier supprimé : 'fichier_a_supprimer.txt'")
Résultat : Le fichier fichier_a_supprimer.txt est supprimé. S'il n'existe pas, une

exception est levée.
▪ Renommer un fichier
La fonction os.rename() permet de renommer un fichier. Voici un exemple où nous

renommons ancien_nom.txt en nouveau_nom.txt :
import os
os.rename('ancien_nom.txt', 'nouveau_nom.txt’)
print("Fichier renommé : 'ancien_nom.txt' en 'nouveau_nom.txt'")
Résultat : Le fichier ancien_nom.txt est renommé en nouveau_nom.txt.

▪ Déplacer un fichier
La fonction os.replace() permet de déplacer ou renommer un fichier. Voici un exemple
où nous déplaçons fichier_a_deplacer.txt vers /nouveau/chemin/ :
import os
os.replace('fichier_a_deplacer.txt', '/nouveau/chemin/fichier_a_deplacer.txt’)
print("Fichier déplacé : 'fichier_a_deplacer.txt' vers '/nouveau/chemin/fichier_a_deplacer.txt'")
Résultat : Le fichier est déplacé ou renommé selon les chemins donnés.

Informations sur le système
▪ Obtenir le nom du système d'exploitation
La variable os.name retourne le nom du système d'exploitation en cours :
import os
nom_os = os.name
print(f"Nom du système d'exploitation : {nom_os}")
Résultat : Par exemple, 'posix' pour les systèmes de type Unix/Linux ou 'nt' pour les systèmes
Windows.
Manipulation de chemins
▪ Joindre des parties de chemin
La fonction os.path.join() permet de joindre des parties de chemin :
import os
chemin_complet = os.path.join('/chemin', 'vers', 'dossier’)
print(f"Chemin complet : {chemin_complet}")
Résultat : Par exemple, /chemin/vers/dossier.

▪ Séparer un chemin en deux parties
La fonction os.path.split() sépare un chemin en chemin et nom de fichier :
import os
chemin, nom_fichier = os.path.split('/chemin/vers/fichier.txt’)
print(f"Chemin : {chemin}, Nom du fichier : {nom_fichier}")
Résultat : Par exemple, Chemin : /chemin/vers, Nom du fichier : fichier.txt.

▪ Obtenir l'extension d'un fichier
La fonction os.path.splitext() retourne le nom de fichier sans extension et son extension :
import os
nom_fichier, extension = os.path.splitext('/chemin/vers/fichier.txt’)
print(f"Nom du fichier : {nom_fichier}, Extension : {extension}")
Résultat : Par exemple, Nom du fichier : /chemin/vers/fichier, Extension : .txt.

▪ Lister les fichiers récursivement
Vous pouvez lister les fichiers de manière récursive dans un répertoire en utilisant os.walk().
Cette fonction parcourt un répertoire donné, y compris ses sous-répertoires, et retourne les
noms de fichiers et de répertoires.
import os
for chemin_racine, repertoires, fichiers in os.walk('.’):
print(f"Chemin racine : {chemin_racine}")
print(f"Répertoires : {repertoires}")
print(f"Fichiers : {fichiers}")
print("-" * 20)
Résultat : Affiche les fichiers et répertoires trouvés dans le répertoire courant et ses sous-répertoires.
L’utilisation d’os avec open()
import os
repertoire_donnees = 'données'
nom_fichier = 'fichier.txt'
chemin_fichier = os.path.join(repertoire_donnees, nom_fichier)
with open(chemin_fichier, 'r') as file:
for ligne in file:
print(ligne.strip())
L’utilison de os.path.join() pour construire le chemin. Cela garantit que le chemin est
correctement formaté pour le système d'exploitation, rendant le code plus portable et robuste.

Python 2

Transféré par

Droits d'auteur :

Formats disponibles

Python 2

Transféré par

Informations du document

Titre original

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

Python 2

Transféré par

Droits d'auteur :

Formats disponibles

Filière Cycle d'Ingénieur : Sciences des

données, Big Data & IA

Pr.Mouhssine EL ATILLAH samedi, 11 mai 24

▪ Python est un langage de programmation apparu officiellement en 1991. Guido van

▪ Python est un langage de programmation puissant portable, avec une bibliothèque

▪ La syntaxe du langage est simple.

déterminé à l’exécution seulement de même que l’allocation de l’espace mémoire.

pour concevoir des programmes.

▪ Universel : non orienté vers un domaine d’applications particulières.

▪ Comme pour une langue étrangère, il nous faut un traducteur ou un interprète…

– Les guillemets triples peuvent s'étendre sur plusieurs lignes.

Résultats 1 (true) or 0 (false)

Ordre Opérateurs Ordre Opérateurs

4 < , <= , > , >= , != et ==

>>> 1 == 1 and 2 >= 3

A B not A and B not A or B not A or A not A and A

A = (18 - 13 < 2) or (13 >= 14 - 1*2) and (5<2)

Donnée Valeur Type

len(s) Longueur de la chaîne s

s*n Répétition ’n’ fois de la chaîne ’s’

s in t Teste si la chaîne ’s’ est présente dans ’t’.

s[n] Extraction du n-ième caractère en partant du début de la chaîne

s[-n] Extraction du n-ième caractère en partant de la fin de la chaîne

s[n:m] Extraction des caractères se trouvant entre le n-ième et le m-ième

s[:n] Extraction des ’n’ premiers caractères de la chaîne

s[n:] Extraction des derniers caractères de la chaîne à partir du n-ème

s[-n:] Extraction des caractères des ’n’ derniers caractères de la chaîne

s.replace(“Hello",“Hi") replace substring.

• Les variables utilisées jusqu'ici sont en réalité des objets.

iterable est souvent:

while <condition1>: while <condition1>:

len(L) Nombre d’éléments dans la liste

del(L[n]) Détruit l’élément ‘n’ de la liste ‘L’

L1 + L2 Concaténation de ‘L1’ et ‘L2’

L*n Répétition ’n’ fois de la liste ‘L’

L[n] Extraction du n-ième élément en partant du début de la liste

L[-n] Extraction du n-ième élément en partant de la fin de la liste

L[n:m] Extraction des éléments qui sont entre ‘n’ et ‘m’

L[:n] Extraction des ‘n’ premiers éléments de la liste

L[n:] Extraction des éléments ‘n’ à la fin de la liste

L[-n:] Extraction des ‘n’ derniers éléments de la liste

L.copy() Renvoie une copie de la liste ‘L’

L.append(e) Ajoute l’élément 'e' à la fin de la liste 'L'

L.insert(n, e) Insère l’élément 'e' à la position 'n' dans la liste 'L'

L.sort() Trie la liste L

L.reverse() Inverse la liste L

L.index(e) Rechercher l’élément 'e' dans la liste L

L.remove(e) Retirer l’élément 'e' de la liste L

L.pop() Retirer le dernier élément de la liste L

for i,matiere in enumerate(cours,start=1): #

• T1=(); T2=tuple() # Tuples vides

• T= 'a', 'b', 'c', 'd' # T=('a', 'b', 'c', 'd')

• T= ('a', 'b', 'c', 'd')

• T= (1, 2)*3 # T=(1, 2, 1, 2, 1, 2)

• S=set() # Ensembles vides

• S={} crée un dictionnaire et non pas un ensemble

len(s) Taille de l’ensemble 's' e in s 'e' ∈ 's'

s.add(e) Ajoute 'e' à 's' e not in s 'e' ∉ 's'

s1 == s2 's1' égal 's2'