PYTHON
1\ Opérations de base :
- / + - * : opérations arithmétiques
- // : division entière
- ** : puissance
- And = &&
- or = ||
- not = !
Incrémentation : i +=1
Décrémentation : i -= 1
Les f-string :
C'est une manière plus simple d'incorporer des variables et des
expressions directement dans une chaîne de caractères
Exemple :
a=1
b=2
print (f "l’addition de {a} et {b} = {a+ b} ")
Affichage : l'addition de 1 et 2 = 3
2\ Structures conditionnelles :
- if condition :
traitement …
Elif condition :
traitement …
Else :
traitement ...
3\ Les boucles :
Boucle for :
For i in [1,7,4,9] : for i in "python" :
Print(i) Print(i)
Affichage : 1 7 4 9 Affichage : p y t h o n
for i in range(5) :
Print ("test")
Affichage : test test test test test
3 façons d'utiliser range :
1- range (stop)
2- range (start, stop)
3- range (start, stop, step)
Boucle while :
r = 'o'
while r == 'o' :
print("Test")
print("Voulez vous continuer ? o/n")
r = input("Votre réponse : ")
Instruction continue :
Cette instruction est utilisée pour passer à l'itération suivante
sans exécuter le reste du code à l'intérieur de la boucle
Exemple :
liste = [ "19","Messi","10", "the", "30","goat" ]
for i in liste :
if [Link]() :
continue
print(i)
Affichage : Messi the goat
Instruction break :
Cette instruction permet une sortie prématurée de la boucle en
fonction d'une certaine condition.
Exemple :
liste = [ "Manchester" , "City" , "4" , "0" , "Real" , "Madrid"]
for i in liste :
if [Link]() :
break
print(i)
Affichage : Manchester City
4\ Méthodes et fonctions :
- " ".lower() : convertir la chaine en minuscule
- " ".uper() : convertir la chaine en majuscule
- " ".capitalize() : Maj la première lettre
- " ".title() : maj toutes le premières lettres des mots
- "bonjour".replace("jour","soir") : bonsoir
- "Bonjour".strip( ujor) : bon : commence à enlever depuis les
côtés
- rstrip ou lstrip : pour enlever à gauche ou à droite
- " ".split() : renvoie la chaine " " sous forme de liste
- " ".join(" ") : l'inverse de split
- "17".zfill(4) : 0017
- "Bonjour".istitle() = True
- "Bonjour".islower() = False
- "19".isdigit() = True
- "19a".isdigit() = False
- "aMbcM".count("M") = 2 : nombre d'occurrences d'une chaine
dans une chaine de caractères
- "abcd".find("d") = 5 : renvoie la position de la première
occurrence, si la chaine n'existe pas elle renvoie -1
"abcd".index("d") : même chose que find mais à la place de
renvoyer -1 elle afficher une erreur
- "abcd".rfind("d") : pour commencer à chercher de la droite
- "[Link]".endswith(".png") = True
- "[Link]".startswith("image") = True
Quelques fonctions :
- Id(x) : renvoie l'adresse de la variable x
- print() : pour afficher à l'écran
- input() : pour saisir depuis le clavier
Remarque : La fonction input retourne toujours un string donc
si on a saisi deux nombres a et b qu'on veut afficher a+b il faut
mettre print(int(a)+int(b)) sinon il va juste concaténer a et b
Autre solution : a = int(input(...))
- type(x) : retourne le type de la variable x
- reversed(" ") : inverse la chaine " "
- len() : renvoie le nombre de caractères d'une chaine ou le
nombre d'élément d'une liste, cette fonction peut être utile pour
vérifier les mots de passe
Exemple :
x = len("python") y = len([4,"fee",True,19])
print(x) print(y)
Affichage : 6 Affichage : 4
- Round() : pour arrondir un nombre décimale
Exemple :
Round(2.2) = 2
Round(3.7) = 4
- Min(liste) : renvoie le minimum de la liste
- Max(liste) : renvoie le maximum de la liste
Remarque : Min et Max marchent aussi avec les chaines de
caractères
Sum(liste) : retourne la somme de la liste
Différence entre méthode et fonction :
Une méthode agit directement sur l'objet et le modifie, ce n'est
pas le cas des fonctions
Exemple fonction : Exemple méthode :
Liste = [5, 3, 1] Liste = [5, 3, 1]
Sorted(liste) [Link]()
Print(liste) Print(liste)
Affichage : [5, 3, 1] Affichage : [1, 3, 5]
Les fonctions Lambda :
C'est des fonctions qui sont définies sans nom, elles sont
généralement utilisées pour créer de petites fonctions simples
qui sont utilisées uniquement à l'endroit spécifique où elles sont
déclarées, la syntaxe d'une fonction lambda est la suivante :
lambda arguments : expression
Exemple :
5\ Modules :
C’est un ensemble de fonctions, méthodes et classes
regroupées, c'est l'équivalent des packages en Java, il existe
plusieurs façons d'importer un module :
- Import nom_module
- From nom_module import *
- From nom_module import nom_fonction
- From nom_module import nom_fonction_1, nom_fonction_2
Package : c'est un ensemble de modules regroupés dans le
même dossier, un package doit contenir un fichier _init_.py pour
que python le considère comme un package, _init_.py peut
simplement être un fichier vide
Quelques modules :
Random :
- [Link](0,20) : 0 , 5 , 7 , , 17 , 20
- [Link](0,20) : 0.16 , 8,19 16,03 , 20.45
- [Link](5) : 0 , 1 , 2 , 3 , 4
sys :
print("Je suis étudiant en "+[Link][1]+" et je m'appelle
"+[Link][2])
Quelques Fonctions pour les modules :
- dir(nom_du_module) : affiche toutes les fonctions de ce
module
- help([Link]) : affiche ce que fait la fonction
- callable() : fonction booléenne qui retourne si cette l'argument
peut être appelée ou non
6\ Types d'objets :
il existe 2 types d’objets : muable et immuable
Les objets muables sont les objets qu'on peut modifier comme
ajouter ou enlever les éléments d'une liste, par contre les
chaines de caractères ne peuvent pas être modifier directement
car ce sont des immuables il faut créer une nouvelle chaine ou
l'on va stocker l'ancienne chaine modifiée ou alors écraser le
contenu de l'ancienne variable
Muable : listes - dictionnaires - sets …
Immuable : chaînes de caractères - nombres - tuples …
Exemple 1 : x = "ab cd ef"
[Link]() x = [Link]()
print(x) print(x)
Affichage : ab cd ef Affichage : Ab Cd Ef
Exemple 2 : x = "15"
int(x) x = int(x)
print(x + x) print(x + x)
Affichage : 1515 Affichage : 30
7\ Les listes :
C'est des tableaux dynamiques qui peuvent stocker n'importe
quel type d'objet
Exemple : Liste = [250,"python",True]
Fonctions pour les listes :
- [Link]([ , , ]) : pour ajouter autant d'élément que l'on
souhaite transmis sous forme de liste
- [Link](5) : ajouter 5 à la liste, append ne peut ajouter
qu'un élément à la fois
- del liste[i] : supprime le i+1 -ème élément de la liste
- [Link](5) : supprimer 5 de la liste, remove ne supprime
qu'un seul élément et ne supprime que sa première occurrence
- Liste[2] : retourne le 3e élément
- Liste[-1] : retourne le premier élément à partir de la droite
- x = [Link]("a") : renvoie l'index (position) de "a"
- x = [Link]("a") : renvoie le nombre d'occurrences de "a"
- [Link]() : pour trier la liste
- [Link]() : pour inverser la liste
- [Link](index) : pour supprimer l'élément a la position index
par exemple pour supprimer le dernier élément on fait :
[Link](-1)
- x = [Link](index) : pour sauvegarder l'élément qu'on a pop
- [Link]() : supprimer tous les éléments de la liste
- x = " ".join(liste) : pour ajouter " " entre chaque élément de la
liste, cette fonction est très utile pour ajouter des _ aux noms
des dossiers par exemple
- " " in liste : fonction booléenne pour déterminer si " "
Appartient à liste, " " in " " marche aussi
Compréhension de liste : c'est une syntaxe concise et
puissante permettant de créer facilement des listes à partir
d'autres listes ou d'itérables en une seule ligne de code, la
syntaxe générale d'une compréhension de liste est la suivante :
nom_liste = [expression for element in iterable if condition]
Exemple 1 :
liste = [35,2,-1,0,1,2,3]
positif = [i for i in liste if i > 0]
print("la liste des nombres positifs : \n",positif)
Affichage : La liste des nombres positifs : [35, 2, 1, 2, 3]
Exemple 2 :
nombres = range(5)
nombres_doubles = [i*2 for i in nombres]
print(nombres_doubles)
Affichage : [0, 2, 4, 6, 8]
Les slices :
C'est une syntaxe permettant d'accéder à une portion
spécifique d'une séquence, telle qu'une liste, une chaine de
caractères ou un tuples, les slices permettent de récupérer des
sous-ensembles de données en spécifiant un début, une fin et
un pas qui est optionnel, voici quelques exemples :
- print(liste[0:1]) : affiche le premier élément
- print(liste[1:3]) : affiche le 2e et le 3e élément
- print(liste[1:]) : affiche à partir du 2e élément
- print(liste[:-1]) : affiche jusqu'à l'avant dernier élément
- print(liste[:]) : affiche tous les éléments de la liste
- print(liste[: : 2]) : affiche un élément sur deux
- print(liste[: : -1]) : affiche l'inverse de la liste
- Print(liste[: : -1]) : affichage des éléments de la liste à l'envers
- print(liste[1][0]) : pour afficher le 1 élément du 2e élément de
liste (listes imbriquées)
- print(liste[0][0:2]) : afficher les 2 premiers éléments du premier
élément de liste
deque :
C'est une structure de données qui représente une file à double
entrées, le mot "deque" est l'abréviation de "double-ended
queue", Pour l'utiliser il faut d'abord importer la classe deque du
module collections : From collections import deque, les deque
possède quelques méthodes en plus par rapport aux listes :
appendleft(x) : Ajoute un élément x au début de la deque
popleft() : supprime et renvoie l'élément du début de la deque
Exemple :
t = deque([1,2,3,4])
[Link](8)
print(t)
Affichage : deque([8, 1, 2, 3, 4])
x = [Link]()
print(x)
Affichage : 8
8\ Les dictionnaires :
Un dictionnaire est une structure de données qui permet de
stocker des paires clé-valeur, où chaque clé est unique et
associée à une valeur correspondante, les éléments du
dictionnaire sont ordonnés, modifiables et n'autorisent pas les
doublons.
Exemple :
Dico = {} : déclaration d’un dictionnaire vide
dico["arbre"] = "vert"
dico["pneu"] = 5
dico["bleu"] = "ciel"
print(dico)
Affichage : { 'arbre' : 'vert', 'pneu': 5 , 'bleu' : 'ciel' }
Méthodes et fonctions des dictionnaires :
- print([Link]() : Pour afficher les clés du dictionnaire
- print([Link]()) : Pour afficher les valeurs du dictionnaire
- Items() : méthode qui retourne les couples (clé,valeur) d’un
dictionnaire.
-.update() : pour mettre à jour le dictionnaire avec les éléments
de l'argument donné.
- get(key) : fonction qui retourne la valeur de la clé
- del dico["key"] : pour supprimer un élément du dictionnaire
-pop('key') : supprime l'élément avec le nom de clé spécifié
9\ Les tuples :
Un tuple est une structure de
données immuable et
ordonnée qui peut contenir
un ensemble d'éléments de
différents types, un tuple est
une liste qui ne peut plus
être modifiée, ils sont définis
en utilisant des ( ) et les éléments sont séparés par des ,
Méthodes sur les tuples :
10\ Les fichiers :
On utilise la fonction open pour ouvrir un fichier et close pour le
fermer, les types d'ouverture sont :
r : pour une ouverture en mode lecture (READ)
w : pour une ouverture en mode écriture (WRITE)
a : pour une ouverture en mode ajout (APPEND)
Remarque : à chaque ouverture d'un fichier en mode écriture le
contenu du fichier est écrasé.
read() : renvoie une chaîne de caractères contenant l’intégralité
du fichier, le paramètre end = "" supprime le saut de ligne
généré par défaut par la fonction print()
readlines() : renvoie une liste contenant l’intégralité du fichier
readline() : renvoie une chaîne de caractères « str » contenant
une seule ligne du fichier
Boucler sur un objet « file » :
La boucle for parcourt chaque ligne du fichier et affiche son
contenu à l’écran
Les exceptions try / except / finally :
try : est utilisé pour entourer le code potentiellement
problématique
except : est utilisé pour gérer les exceptions qui se produisent
finally : est utilisé pour spécifier du code qui doit toujours être
exécuté
Lecture depuis l’entrée standard [Link] :
rstrip() : supprime le saut de
ligne généré lors de la saisie
end=" : supprime le saut de
ligne généré par défaut par la
fonction print()
stdin (standard input) : entrée standard/flux d’entrée.
len() : pour afficher la longueur
de la chaîne saisie
Lecture depuis l’entrée standard input() :
a = input()
print(a)
Ecriture dans la sortie standard [Link] (standard
output) :
Manipulation des répertoires :
listdir(path) : c'est une fonction intégrée au module os, elle est
utilisée pour obtenir la liste des fichiers et répertoires présents
dans un répertoire spécifié par le chemin path
Exemple :
print([Link]([Link][1]))
Affichage : ['[Link]', '[Link]', 'TEST2']
isdir(path): permet de vérifier si un chemin (path) est un
répertoire existant
Exemple :
print([Link]([Link][1]))
Affichage : True
Remarque : avec la méthode isfile(path) du module « path » on
vérifie si un chemin est un fichier
11\ Les expressions régulières :
Les expressions régulières sont un outil puissant pour
manipuler des chaînes de caractères en Python, elles
permettent de rechercher des motifs dans une chaîne de
caractères et de remplacer ces motifs par d’autres chaînes.
. : n'importe quel caractère.
^ : début du segment mais
signifie aussi "contraire de"
$ : fin du segment
[xy] : Une liste de segment
possible, par exemple [abc]
équivaut à : a, b ou c
(x|y) : Indique un choix multiple
type (ps|ump) équivaut à "ps"
ou "ump"
\d : le segment est composé
uniquement de chiffre, ce qui
équivaut à [0-9]
\D : le segment n'est pas
composé de chiffre, ce qui
équivaut à [^0-9]
\s : Un espace, ce qui équivaut à [ \t\ n \r \f \v ]
\S : Pas d'espace, ce qui équivaut à [^ \t \n \r \f \v ]
\w : caractère alphanumérique, ce qui équivaut à [a-zA-Z0-9_]
\W : Pas de présence alphanumérique [^a-zA-Z0-9_].
\ : Est un caractère d'échappement
* : répète le caractère précédent 0 fois ou plus "he.*o"
+ : répète le caractère précédent 1 fois ou plus "he.+o"
? : répète le caractère précédent 0 fois ou 1 fois "he.?o"
{} : répète le caractère précédent exactement le nombre
d'occurrences spécifié "he.{2}o"
| : Soit ou "tombe|reste"
() : capturer et regrouper
match() : Détermine si l’expression régulière correspond au
début de la chaîne.
search() : Recherche la première occurrence de l’expression
régulière dans la chaîne, cette méthode retourne « None » si
aucune correspondance n’est trouvée.
findall() : Renvoie les éléments, qui correspondent (toutes les
correspondances) dans une liste, cette méthode retourne une
liste vide si aucune correspondance n’est trouvée
group() : Renvoie la chaîne de caractères correspondant à
l'expression régulière
start() : Renvoie la position de début de la correspondance
end() : Renvoie la position de fin de la correspondance
span() : Renvoie un n-uplet contenant les positions (début, fin)
de la correspondance
Exemple : Le motif utilisé est (\d+)\.(\d+), qui correspond à un
ou plusieurs chiffres (\d+), suivi d'un point décimal (.), suivi de
nouveau par un ou plusieurs chiffres (\d+). groups() renvoie un
tuple contenant les parties correspondantes du motif
Flags (arguments optionnels) :
re.I : recherche insensible à la casse, ignorer la distinction
entre majuscules et minuscules lors de la recherche
re.S : traiter la chaîne comme une ligne simple
Remarque : Avec l’argument optionnel re.S, le caractère .
reconnaît aussi les sauts de ligne
12\ Structures de données multidimensionnelles :
Python permet de manipuler des listes multidimensionnelles
(listes de listes) et des dictionnaires multidimensionnels
(dictionnaires de dictionnaires)
Une liste de liste par exemple : liste = [ [1, 2] , [3, 4] , [5, 6] ]
Alimentation et affichage d’une liste à deux dimensions :
Alimentation et affichage d’un dictionnaire de dictionnaires :
for a in dico:
print("clé ==> ",a,"valeur ==>",[Link](a))
#Affiche les sous_dic :
for a in dico:# ou for a in [Link]()
for b in [Link](a):
#affiche valeurs des sous_dic :
print("clé ==> ",b,"valeur ==> ",dico[a][b]) #ou bien
print("clé ==> ",b,"valeur ==>",[Link](a).get(b))