PYTHON
Table des matières
I. Commande terminal (Git Bash):............................................................................................3
II. Python:.................................................................................................................................3
i. Les types natifs:................................................................................................................3
ii. Fonction de conversion :..................................................................................................3
iii. Cours :.............................................................................................................................3
iv. Recherche :.....................................................................................................................3
v. Différentes affectations:...................................................................................................3
vi. Fonction de variable :......................................................................................................3
vii. Chaîne de caractère:......................................................................................................4
viii. Opérateur mathématiques:............................................................................................4
ix. Utiliser les maths sur python:..........................................................................................5
x. Équivalence :...................................................................................................................5
xi. Relation d’ordre totale :...................................................................................................5
xii. Structure conditionnelle :................................................................................................6
xiii. Les opérateurs logiques (or, and et not) :.....................................................................6
Variable les règles à suivre:
ne peut pas commencer par un chiffre
ne peut pas contenir d’espace
ne peut contenir que des caractères alphanumériques (A-z, 0-9) et le tiret du bas (_)
certains mots sont réservés (print, True, break…)
I. Commande terminal (Git Bash):
ls (permet de connaître tous les documents d’un environnement)
ls -la (permet de connaître tous les fichiers d’un environnement ainsi que ceux qui sont
cachés)
cd *insère nom du document*/ (permet de rentrer dans les document d’un
environnement)
cd .. (permet de revenir au document de l’environnement précédent)
pwd (affiche le chemin exact de l’environnement)
mkdir *insérer nom du document* (permet de créer un document dans
l’environnement)
touch *insérer nom du fichier*.py (permet de créer un fichier)
rm *insérer nom du fichier*/ (permet de supprimer un fichier)
rm -r *insérer nom du dossier*/ (permet de supprimer un dossier)
code (lance visual studio code)
II. Python:
i. Les types natifs:
Les chaînes de mots (string)
Les nombres (float=décimal et integer=entier)
Les booléens (True=1 et False=0)
ii. Fonction de conversion :
str(je suis une chaine de mots) = ”je suis une chaine de mots”
int(5) = 5
float(5.0) = 5.0
bool(1) = True
iii. Cours :
Garbage collector (capacité à détruire les variables inutile)
Concaténation (additionner des termes)
Singleton (objet unique avec le même id (ex: de -5 à 256 ou booléen))
iv. Recherche :
Id(*insérer objet*) (permet de connaître la place en mémoire d’un objet)
Type(*insérer objet*) (permet de connaître le type natif d’un objet)
v. Différentes affectations:
Affectation simple (nom = objet (ex: a = 5))
Affectation parallèle (si a=5 et b=2 on peut le définir comme a,b=5,2)
Affectation multiple (a=b=c=5)
vi. Fonction de variable :
input() (permet de questionner l’utilisateur par des variables (ex: a=input(“question”))
vii. Chaîne de caractère:
[Link]() (permet de passer un objet en majuscule)
[Link]() (permet de passer un objet en minuscule)
[Link]() (permet de mettre une majuscule en début de phrase)
[Link]() (permet de mettre une majuscule à chaque début de mot)
[Link](*insérer caractère à changer*, *insérer nouveau caractère*) (permet de
remplacer un caractère par un autre)
[Link](*insérer objet à supprimer*) (supprime les objets en balayant du début les
caractère puis de la fin
[Link](*insérer objet à supprimer*) (supprime les objets en balayant de la droite)
[Link](*insérer objet à supprimer*) (supprime les objets en balayant de la gauche)
[Link](*insérer objet à dissocier*) (permet de dissocier des élément)
[Link](*insérer objet à joindre) (permet de joindre des éléments)
[Link](*insérer nombre*) (permet de rajouter des 0 à un nombre ou un chiffre,
permet d’avoir des séquence de même longeur)
[Link](objet) (compte les occurence)
La méthode “is”:
[Link]() (permet de savoir si un objet est constitué que de chiffres)
[Link](“objet”) (compte le nombre de caractère avant de tomber sur la chaîne de
caractère (renvoie -1 si il n’y en a pas)(existre rfind pour lire depuis la fin)
[Link](“objet”) (compte le nombre de caractère avant de tomber sur la chaîne de
caractère (renvoie “erreur” si il n’y en a pas)
“[Link]”.endswith(“.png”) (renvoie un booléen pour chercher si il fini par ça)
“[Link]”.startswith(“image”) (renvoie un booléen pour chercher si la chaine de
caractère commence par ça)
viii. Opérateur mathématiques:
addition (+)
multiplication(*)
division(/)
modulo % (récupère le reste d’une division)
division entière // (donne le résultat avec un entier naturel)
puissance ** (puissance)Utiliser les maths sur python:
Import math : permet d’importer des fonctions mathématiques.
[Link](-4.7) : entier immédiatement supérieur, donne ici -4.
[Link](2) : exponentielle.
[Link](5) : factorielle 5, donc 120 ici (fonctionne uniquement pour les entiers
positifs).
[Link](-4.7) : partie entière, donne ici -5.
[Link](x) : teste si x est infini (inf) et renvoie True si c'est le cas.
[Link](2) : logarithme en base naturelle.
[Link](8, 2) : log de 8 en base 2.
math.log10(2) : logarithme en base 10.
[Link](2, 3) : 2 puissance 3 (peut aussi s'écrire 2 ** 3).
[Link](16) : racine carrée, donne ici 4.
fonctions trigonométriques : [Link], [Link], [Link], [Link], [Link],
[Link] (argument en radians).
fonctions hyperboliques : [Link], [Link], [Link], [Link], [Link],
[Link].
[Link](x) : convertit de radians en degrés.
[Link](x) : convertit de degrés en radians.
Les constantes :
[Link] (3.14159...)
math.e (2.71828...)
ix. Équivalence :
i += 1 == i=i+1
i += 1
i -=1
i *= 1
i /= 1
i %= 1
i //= 1
i **= 1
x. Relation d’ordre totale :
> plus grand que
< plus petit que
>= plus grand ou égal
<= plus petit ou égal
== égal à
!= différent de
is (même addresse en mémoire)
f-string
xi. Structure conditionnelle :
Condition If (si) : il faut forcément mettre : à la fin d’une ligne contenant If.
Elif : Permet de vérifier plusieurs conditions au sein d’une même condition (ne peut pas
exister sans un If au préalable).
Else (sinon) : gère tous les cas de figures autre que celui autorisé et est donc la dernière
variable du code (ne peut pas exister sans un If au préalable).
Quelques exemples ici.
xii. Les opérateurs logiques (or, and et not) :
And (et) : il faut que toutes les conditions soient remplies pour que la structure
conditionnelle soit vraie (est le plus fort donc étudié en premier(possible de changer
avec des parenthèses)).
Or (ou) : il faut que toutes les conditions soient fausses pour que la structure
conditionnelle soit fausse (est le plus faible donc pas étudié en premier (possible de
changer avec des parenthèses)).
Not (pas) : renvoie l’inverse de ce que l’on demande.
xiii. Les différents types d’erreur en python :
Erreur de syntaxe :
>>> For i in range(10)
Fichier et ligne où se trouve l’erreur → File « <stdin> », line 1
For i in range(10) :
indique endroit jusqu’où l’interpréteur est allé→ ^
SyntaxError : invalid syntax
Erreur à l’exécution :
Très nombreuses et englobe les « NameError » et type « Error »
Erreur sémantique :
Erreur de logique, ne rend pas forcément le code faux.
xiv. Module :
On doit utiliser la fonction « import » pour s’en servir. Puis utiliser la fonction comme
module.
Ex :
Import Random
[Link](0, 1)
Les modules :
Module random :
Générer un entier naturel au hasard :(inclusif)
import random
r = [Link](0, 99)
print(r)
Générer un nombre réel au hasard :(inclusif)
import random
r = [Link](0, 99)
print(r)
Générer un entier naturel au hasard avec 0 automatique en premier terme:(exclusif)
import random
r = [Link](999)
print(r)
Possibilité de faire des pas :(10 dans notre exemple)
import random
r = [Link](0, 999, 10)
print(r)
xv. Fonction pour aider à comprendre un module :
Fonction « dir » : permet de faire de l’introspection ainsi elle nous donne toutes les
fonctions utilisables du module (certaine fonctions sont inutilisable par l’utilisateur,
elles sont notifié par un tiret bas)
import random
print(dir(random))
Fonction « help » : permet de donner des informations sur une fonction précise.
import random
help([Link])
Callable : Objet « appelable » soit les objet du type print() ou randint() mais pas os ou
random, on peut savoir si un objet est callable grace à la fonction callable() :
import random
print(callable([Link]))
xvi. Les Listes :
Une liste est notamment définie par le fait de mettre des crochets pour la délimitée :
Ex : a = [1, 2, 3, 4, 5]
On peut aussi passer par des tuples, ils sont plus rapide et prennent moins de
mémoires mais on ne peut ni retirer ni ajouter de terme :
ex : a = (1, 2, 3, 4, 5)
Il est possible de convertir un tuple en liste et inversement grâce au fonction list() et
tuple() :
ex : a = [1, 2, 3, 4, 5]
a = tuple(a)
Pour ajouter un élément à une liste on utilise la méthode append :
Ex :
a = [1, 2, 3, 4, 5]
[Link](6) (ajoute 6 à la liste)
Pour ajouter PLUSIEURS éléments on utilise extend :
a = [1, 2, 3, 4, 5]
[Link]([6, 7, 8, 9, 10])
Si l’on veut retirer un éléments on utilise la méthode remove qui ne retire que la
PREMIÈRE occurrence de la liste :
a = [1, 2, 3, 4, 5]
[Link](5)
Pour récupérer un élément dans une liste on utilise un indice, on peut compter de
manière positive 0, 1, 2, 3 ou négative -1, -2, -3, -4 (le nombre qui correspond à
l’élément) (sur python on commence à compter à partir de 0!!!!) :
ex : 0 1 2
[« python », « C++ », « Java »]
-3 -2 -1
Ensuite il suffit de faire a[2] ou a[-1] pour récupérer le terme Java.
Ex :
a=[1,2,3,4,5]
print(a[-2])
A savoir que l’on peut faire des listes dans des listes et y récupérer des éléments :
Ex :
a=[1,2,3,["python", "C++", "java" ],5]
print(a[3][1])
Si on veut récupérer uniquement une partie d’une liste on utilise les slices, un slice
est exclusif du dernier terme :
liste = ["Java", "Python", "C++"]
print(liste[0:2])
Si on veut tout le début de la liste mais pas certain de terme de fin alors on met :2, si
c’est le contraire alors 0: !!!( on peut aussi récupérer qu’un élément sur deux grâce
à ::2)
Si on veut connaître la position exacte d’un terme on peut utilise la fonction index :
liste = ["Maxime", "Martine", "Christopher", "Carlos", "Michael", "Eric"]
a = [Link]("Carlos")
print(a)
Si on veut compter le nombre d’occurence d’un terme on utilise count :
liste = ["Maxime", "Martine", "Christopher", "Carlos", "Michael", "Eric", "Carlos"]
a = [Link]("Carlos")
print(a)
Si on veut ranger dans l’ordre alphabétique ;
liste = ["Maxime", "Martine", "Christopher", "Carlos", "Michael", "Eric", "Carlos"]
[Link]()
print(liste)
Si on veut la ranger dans le sens inverse :
liste = ["Maxime", "Martine", "Christopher", "Carlos", "Michael", "Eric", "Carlos"]
[Link]()
print(liste)
Retirer un élément d’une liste à partir d’un indice :
liste = ["Maxime", "Martine", "Christopher", "Carlos", "Michael", "Eric", "Carlos"]
[Link](-1)
print(liste)
Afficher ce qu’il y a dans la liste sans [] :
liste = ["Maxime", "Martine", "Christopher", "Carlos", "Michael", "Eric", "Carlos"]
résultat = " ".join(liste)
print(résultat)
Matplotlib (bibliothèque python) :