
Memento Python
Voici une liste des différents codes source et syntaxes courantes utilisés en Python.
Ce fichier est un canevas qui s'étoffera au fur et à mesure de mes expérimentations sur ce langage et son éco système .
Références/Sources:
- openclassrooms: démarrez votre projet avec python
- Automate the Boring Stuff with Python Programming
- pluralsight: Core Python: Getting Started
- Installing packages using pip and virtual environments
- Doc virtualfish
- Doc virtualenvwrapper
Syntaxe de Base
-
exemple de script
my_integer = 1 my_float = 1.3 group="ACDC" year=1982 still_together=True founding_members=("moi","toi") print(founding_members[0]) songs={"first":(1972,"YEAYEA"),"second":(1985,"YOYO")} print(songs['second'])
Les variables et les types simples
- pas besoin de typage spécifique pour les types simples
- Python permet également d'écrire un texte sur plusieurs lignes en utilisant des triple guillemets ou des triple apostrophes
Les conditions et les boucles
-
pass: ne sert pas à quitter un programme. A utiliser quand aucune action n'est requise mais qu'une ligne est nécessaire pour éviter une erreur, par exemple dans une fonction ou une condition sans ligne de code.
-
exemple
if user_answer == "B" and my_var == 1: # leave the condition pass elif user_answer == "C" or my_int = 5: print("C pas la bonne réponse ! Et G pas d'humour, je C...") else: # show another quote while user_answer != 'B': print(get_random_item_in(program['quotes'])) for quote in quotes: quote.capitalize() var y = [1,2,3,4] for x in y: print(x) for x in range(8): print(x) def fonctionvide() pass
Les méthodes (fonctions)
-
Pour rendre un paramètre optionnel, il suffit de lui affecter une valeur par défaut. Les arguments optionnels doivent être définis après les arguments obligatoires.
-
Il est possible de nommer les argument lors de l'appel d'une fonction. Dans ce cas leur positionnement est libre (pas d'ordre à suivre).
-
NOTES:
- une instruction def est exécutée UNE SEULE fois pour tout le programme, incluant l'affectation des valeurs par défaut (qui auront donc toujours la valeur du 1er appel)
- les valeurs par défaut sont des références donc elles sont conservées entre chaque appel et peuvent donc être modifiées implicitement.
- Pour éviter cela, il est conseillé d'utiliser des valeurs par défaut IMMUABLES (cad, ne jamais modifier une valeur par défaut (QUI EST DONC UNE REFERENCE) dans la fonction)
-
Pour appliquer une méthode sur un nombre, on l'entoure par ()
-
exemple
print((2.5).is_integer()) quotes=("first","second") def get_random_item_in(li): # TODO: get a random number item = li[0] # get a quote from a list print(item) # show the quote in the interpreter return "program is over" # returned value print(get_random_item_in(quotes))
Les types complexes
tuple
-
Un tuple est une structure ordonnée dont les éléments sont immutables.
-
Un tuple est immutable.
-
La position du premier élément d'un tuple est le 0
-
exemple
paris = (48.856578, 2.351828) p=(1,2,3,5,6,7) p=1,2,3,5,6,7 # equivalent
-
remarque:
- i=(11) -> i est un int
- t=(11,) -> t est un tuple
-
destructuration d'un tuple: les divers élements d'un tuple peuvent être assignés comme des objets indépendants
a,b,c,d=p # a=1, b=2, c=3... (a,(b,(c,d)))= (1,(2,(3,4))) # a=1, b=2, c=3... a='ONE' b='TWO' a,b=b,a # b='ONE' a='TWO'
Méthodes sur les tuples
tu = ("Alvin et les Chipmunks", "Babar", "Betty Boop", "Calimero", "Casper", "Le chat potté", "Kirikou")
# Connaître le nombre d'éléments
len(tu)
# Accéder au 4e élément d'une tuple
tu[3]
# prendre une partie de la tuple
tu[3:6]
tu[1:-1] # tout sauf le 1er et le dernier élement
tu[:2] # les 2 premiers élements
# Accéder au dernier élément d'une liste
tu[-1]
for index,elt in enumerate(tu):
print(f"{index}=>{elt}")
les listes
- Une liste est une succession ordonnée de plusieurs objets mutables.
- Une liste est mutable.
- La position du premier élément d'une liste est le 0
-
exemple
li = ["Alvin et les Chipmunks", "Babar", "Betty Boop", "Calimero", "Casper", "Le chat potté", "Kirikou"] print(li[0]) # Les listes peuvent également contenir d'autres valeurs de liste. spam = [['cat', 'bat'], [10, 20, 30, 40, 50]] print (spam[0]) # ['cat', 'bat'] print (spam[0][1]) # 'bat'
Méthodes sur les Listes
# Connaître le nombre d'éléments
len(li)
# Accéder au 4e élément d'une liste
li[3]
# prendre une partie de la liste
li[3:6]
li[1:-1] # tout sauf le 1er et le dernier élement
li[:2] # les 2 premiers élements
# Accéder au dernier élément d'une liste
li[-1]
# faire une copie d'une liste
# note :
# c'est une "shallow copy", cad que si des élements de la liste sont des objets, alors SEULE LEUR REFERENCES SERONT COPIEES
# li_copy=li permet juste d'assigner une nouvelle référence
li_copy=li[:]
li_copy=li.copy()
li_copy=list(li) # à utiliser de préférence car plus claire et permet de créer des listes de manière plus générique
li = ["Alvin et les Chipmunks", "Babar", "Betty Boop", "Calimero", "Casper", "Le chat potté", "Kirikou"]
# Trouver l'index d'une valeur de liste
li.index("Babar")
# Ajouter un élément à la fin de la liste
li.append("Mowgli")
# Ajouter un élément à un certain index.
li.insert(4, "Balou")
# Modifier un élément
li[1] = "La Fée Clochette"
li[li.index("Mowgli")]="Balou"
# Supprimer le dernier élément et le renvoie
li.pop()
# Supprimer l'élément à l'index 4 et le renvoie
li.pop(4)
# Supprimer un élément sans renvoyer sa valeur
li.remove("Mowgli")
# Supprimer un élément sans renvoyer sa valeur
del li["Mowgli"]
# iteration simple
for elt in li:
print (elt))
# iteration avec index
for index,elt in enumerate(li):
print(f"{index}=>{elt}")
# multiplication
c=[2,3]
d=c*3 # d= [2,3,2,3,2,3]
c=[0]*3 # c=[0,0,0]
# addition / extension
c=[2,3]
d=[4,5]
e=c+d # e=[2,3,4,5]
d+=[6,7,8] # d=[4,5,6,7,8]
c.extend([4,5]) # c=[2,3,4,5]
# tri
c.sort() # modifie c
d=sorted(c) # ne modifie pas c
# inversion
c.reverse() # modifie c
d=reversed(c) # iterateur inversé
les chaînes de caractères
-
une chaîne est traitée comme une liste de caractères UNICODE.
-
Une chaîne est immutable.
-
concaténation
- la concaténation (ou toute modification d'une chaîne) crée un nouvel objet
- l'utilisation de la méthode join est à préférer à celle de '+'
print("TOTO"+"TATA")
-
ne pas interpréter les caratères spéciaux: faire précéder la chaîne avec la lettre r
# les \ n'ont pas besoin d'être doublés path=r"c:\windows\system32\test.ini"
-
utiliser une chaîne formatée contenant des variables: faire précéder la chaîne avec la lettre f
# on ecrit les variables entre accolades directement dans la chaîne path=f"mon prenom est {prenom} et j'ai {age} ans"
-
créer une chaîne d'octets au lieu d'unicode: faire précéder la chaîne avec la lettre b
s=b"data0" print(s[1]) # affiche 97: la valeur en octet de la lettre a
-
convertir une chaîne d'octets en chaîne unicode (ie standard)
str=bytes_str.decode('utf8')
(note:'utf8' est facultatif) -
convertir une chaîne unicode en chaîne d'octets:
str=bytes_str.encode('utf8')
(note:'utf8' est facultatif) -
exemple de chaînes de formatage
import math # utilisation de format character="Babar" message="Tout n'est pas cirrhose dans la vie, comme dit l'alcoolique." "{} a dit : {}".format("Babar", "Tout n'est pas cirrhose dans la vie, comme dit l'alcoolique.") "{} a dit : {}".format(character, message) print("{character2} a dit : {message2}".format(character2=character, message2=message2)) # même chose en utilisant une "fstring" print(f"{character} a dit : {message}") val=4*20 print(f"{val} est plus grand que {4+20}") # 80 est plus grand que 24 # dans une fstring , {} permet d'afficher n'importe quel objet, y compris des résultats de fonctions print(f"PI value is {math.pi}") print(f"PI value is {math.pi:.3f}") # ajout d'un format d'affichage
Méthodes sur les chaînes
-
exemples
"hello world!".split() " hello world! ".strip() "hello world!".capitalize() "hello world!".upper() "HELLO WORLD".lower() ";".join("123","456","789") # 123;456;789 # très utilisée pour concaténer "".join("123","456","789") # 123456789 # trés utilisée pour découper end,separator,start="22:00#17:00".partition("#") # end='22:00' separator='#' start="17:00"
les "range"
- ce sont des progressions arithmétiques d'entiers autogénérée: 3 formats possibles pour les créer
range(stop_value)
range(start_value, stop_value)
range(start_value, stop_value, step_value)
-
à utiliser de préférence dans les boucles for
for i in range(5) print(i) # 0,1,2,3,4 # creation d'une liste à partir d'un range list(range(0,10,2)) # [0,2,4,6,8] s=[0,1,4,6,13] # usage non recommandé (C like) for i in range (len(s)) print(f' index={i} value={s[i]}') # usage recommandé (python like) sans besoin de l'index for v in range (s) print(f' value={v}') # usage recommandé (python like) si besoin de l'index for i,v in enumerate(s) print(f' index={i} value={v}')
Les dictionnaires
- Un dictionnaire est un ensemble non ordonné de valeurs mutables auxquelles vous pouvez accéder grâce d'autres objets (des chaînes de caractère par exemple).
- Un dictionnaire est mutable.
- l'ordre des élements est aléatoire et peut varier d'une exécution à l'autre
- les clés doivent être des types immutables
-
exemple
di = {"un": "one", "deux": "two", "trois": "three"} di = {"quotes": ["Ecoutez-moi, Monsieur Shakespeare, nous avons beau être ou ne pas être, nous sommes !", "On doit pouvoir choisir entre s'écouter parler et se faire entendre."], "li": ["alvin et les Chipmunks", "Babar", "betty boop", "calimero", "casper", "le chat potté", "Kirikou"]} print(di['quotes'])
Méthodes sur les Dictionnaires
di = {"un": "one", "deux": "two", "trois": "three"}
# Connaître le nombre d'éléments
len(di)
# Accéder à un élément
di["un"]
# faire une copie d'un dictionnaire
# note :
# c'est une "shallow copy", cad que si des élements du dictionnaire sont des objets, alors SEULE LEUR REFERENCES SERONT COPIEES
# di_copy=di permet juste d'assigner une nouvelle référence
di_copy=di.copy()
di_copy=dict(di)
# Accéder aux éléments d'une liste qui est elle-même dans un dictionnaire
di["my_list"][0]
# Remplacer (si la clé existe) ou ajouter une valeur (si elle n'existe pas):
di["un"] = "Uno"
# Mettre à jour ou ajouter plusieurs valeurs en même temps
di.update({"li" : ["Alvin", "Père Noël"], "quotes": ["Une citation unique qui sera sauvegardée"]})
# Supprimer une clé et renvoyer sa valeur : même méthode que pour une liste.
di.pop("quotes")
# Supprimer un élément sans renvoyer sa valeur
di.remove("quotes")
# Supprimer un élément sans renvoyer sa valeur
del di["quotes"]
# iteration simple
for key in di:
print(f"{key}=>{di[key]}")
# iteration avec tuple
for key, value in di.items():
print(f"{key}=>{value}")
# iteration sur les valeurs uniquement
for val in di.values():
print (val)
# iteration sur les clés uniquement
for key in di.keys():
print (key)
les ensembles (set)
- Un set est une collection non ordonnée d'éléments uniques et immutables.
- Un set est mutable.
-
exemple
se = {"one", "two", "three"} print(se['quotes'])
Méthodes sur les set
se = {"one", "two", "three"}
# Connaître le nombre d'éléments
len(se)
# faire une copie d'un set
# note :
# c'est une "shallow copy", cad que si des élements du sectionnaire sont des objets, alors SEULE LEUR REFERENCES SERONT COPIEES
# se_copy=se permet juste d'assigner une nouvelle référence
se_copy=se.copy()
se_copy=set(se)
# ajouter un élement
se.add("quatre")
# Mettre à jour ou ajouter plusieurs valeurs en même temps
se.update(["quatre","5","six"])
# Supprimer un élément du set sans renvoyer sa valeur, génère une erreur si l'élément n'existe pas
se.remove("quatre")
# Supprimer un élément du set sans renvoyer sa valeur, ne génère pas erreur si l'élément n'existe pas
se.discard("quatre")
# iteration simple
for val in se:
print(val)
# union de 2 ensembles
se_union=se.union(se2) # identique à se_union=se2.union(se)
# intersection de 2 ensembles
se_intersection=se.intersection(se2)
# difference de 2 ensembles
se_difference=se.difference(se2)
# difference symétrique de 2 ensembles (exclu les éléments identiques)
se_difference=se.symmetric_difference(se2) # identique à se_difference=se2.symmetric_difference(se)
# tester si sous-ensemble
se2.issubset(se)
# tester si super-ensemble
se2.issuperset(se)
# tester si disjoint
se2.isdisjoint(se)
Classes et objets
A savoir
- certaines méthodes spéciales sont entourée de double underscore ''. On les nomme par convention "dunder", par ex: 'name__' se lit 'dunder name'
- tout est objet en python, y compris les fonctions et les modules. On peut donc leur appliquer certaines méthodes "communes" aux objets python.
- chaque objet possède un id unique (ie. une référence vers son emplacement mémoire)
- Python utilise un passage d'argument par référence PAR DÉFAUT
- l'affectation de variables (=) permet d'assigner une référence nommée à un objet
- l'identité de 2 objets se teste avec l'opérateur 'is'
- l'identité de contenus (ie. équivalence) de 2 objets se teste avec l'opérateur '=='
-
exemple
"""Model for aircraft flights.""" class Flights: def __init__(self, number): if not number[:2].isalpha: raise ValueError(f"No Airline code in {number}") if not number[:2].isupper(): raise ValueError(f"Invalid Airline code in {number}. Must be in uppercase") if not (number[2:].isdigit() and int(number[2:]) <= 9999): raise ValueError(f"Invalid route number in {number}. Must be a number from 0000 to 9999") self._number = number def number(self): return self._number def airline(self): return self._number[2:] def code(self): return self._number[:2]
Méthodes (reflexives) sur les objets
- id (unique) d'un objet:
id (objet)
- type d'un objet:
type (objet)
- contenu d'un objet:
dir (objet)
- aide (docstring) d'un objet:
help (objet)
- doc (docstring) sur un objet):
<function>.__doc__
- nom de la fonction (ou de l'objet):
<function>.__name__
Fichiers
- l'encodage des fichiers par défaut dépend de la plateforme. En général, c'est 'utf-8'. Mais pour s'assurer de la compatibilité des fichiers, il est préférable d'indiquer l'encodage explicitement lors de l'ouverture du fichier.
- le caractère de fin "\n" de lignes est universel en python et est converti en fonction de la plateforme.
- les fonctions de lecture (read/readline...) lisent et retournent les caractères de fin de ligne.
- les fonctions d'écriture (write/writeline...) n'ajoutent pas automatiquement les caractères de fin de ligne. Il faut le faire EXPLICITEMENT
-
exemple:
def write_sequence(filename, num): """ Write a sequence to a text file""" f = open(filename, mode='wt', encoding='utf-8') f.writelines(f"{r}\n" for r in islice(sequence(), num + 1)) f.close() def read_series(filename): """ Read a serie of int from a text file""" # method 1 : for loop f = open(filename, mode='rt', encoding='utf-8') series = [] for line in f: a = int(line.strip()) series.append(a) f.close() return series def read_series_v2(filename): """ Read a serie of int from a text file (fast version)""" # method 2 : list comprehension try: f = open(filename, mode='rt', encoding='utf-8') return [int(line.strip()) for line in f] finally: f.close()
blocs "with"
-
les blocs "with" permettent de simplifier la gestion des objets implémentant le protocole "contexte, tel que les fichiers: La fermeture du contexte est automatique
-
le format est :
with EXPR as VAR: BLOCK
-
exemple:
def read_series_v3(filename): """ Read a serie of int from a text file (fast version) using with""" # method 3 : list comprehension and with bloc with open(filename, mode='rt', encoding='utf-8') as f: return [int(line.strip()) for line in f]
Les extensions
packages
- un package désigne:
- soit un dossier contenant un fichier
__init__.py
- soit un package de distribution (release package), éventuellement téléchargeable et installable (via pip par exemple)
- soit un dossier contenant un fichier
- un package/dossier peut être executé via
python -m <dossier_du_package>
(__main__.py
n'est pas nécessaire) - un dossier peut être executé via
python <dossier>
s'il contient un fichier__main__.py
- si LE CONTENU d'un dossier executable est compressé en zip, il peut être executé directement via
python <dossier.zip>
- le module wheel est utilisé pour créer des packages de distribution (ie: compresser et versionner):
- le dossier doit contenir un fichier
setup.py
- se placer dans le dossier du package et executer
python setup.py bdist_wheel
- le dossier doit contenir un fichier
- le module twine sera à uploader des packages vers pypi.org
utilisation de pip
- Il vaut mieux utiliser
python -m pip <commande>
quepip <commande>
car cela permet de rester cohérent entre l'environnement d'exécution python et la liste des packages utilisés/installés. python -m pip install <package>
: installe un packagepip install <package>
: installe un package (version moins sure car 'environnement d'exécution de pip est celui de l'OS, et il peut être différente de celui du python courant)python -m pip install --upgrade <package>
: mettre à jour un packagepython -m pip install --user --upgrade pip
: mettre à jour pip avec la dernière versionpython -m pip freeze
: répertorie les paquets que vous avez installés (mais pas leurs dépendances) dans un format adapté au stockage dans un fichier (souvent appelé fichier requirements.txt ),python -m pip list
: répertorie tous les paquets que vous avez installés (et leurs dépendances) dans un format intelligiblepython -m pip show <package(s)>
: montre des informations utiles sur un ou plusieurs paquets que vous avez installéspython -m pip install <package> ~=2.2
: installe la version la plus élevée disponible au-dessus de 2.2! , mais pas 3.0 ni les versions ultérieurespython -m pip install <package> ~=2.1.0
: installe la version la plus élevée disponible au-dessus de 2.1.0 , mais pas la version 2.2.0 ni les versions ultérieurespython -m pip install <package> >2.5.0
: installe la version la plus élevée disponible au-dessus de 2.5.0python -m pip install "<package> >2.4.0,<2.6.0"
: installe la version la plus élevée disponible supérieure à 2.4.0 , mais inférieure à 2.6.0
Les modules
-
Import avec utilisation préfixe sur les méthodes
import turtle turtle.forward(100)
-
Import sans utilisation de préfixe sur les méthodes. Attention aux méthode ayant le même nom dans des modules différents.
from turtle import * forward(100)
-
exemple
# Utiliser le module random import random print(random.randint(3, 7))
Les librairies
-
installer une librairie
python -m pip install scrapy
-
Une bonne pratique est de réunir toutes les librairies externes dans un fichier "requirements.txt" placé à la racine de votre dossier
Les environnement virtuels
virtualenv/venv : les bases
- installer les outils pour gérer les environnements virtuels:
python -m pip install --user virtualenv
- créer un environnement virtuel dans le dossier projet (par convention on le nomme "env", mais cela pourrait être personnalisé):
python -m venv env
(à préférer pour python 3)python -m virtualenv env
(à préférer pour python 2)
- activer l'environnement virtuel: `./env/bin/activate'
- désactiver l'environnement virtuel: `deactivate'
- le fichier "requirements.txt" à la racine du projet permet de spécifier les paquets à installer pour l'environnement virtuel
- installer tous les paquet du fichier:
python -m pip install -r requirements.txt
- installer tous les paquet du fichier:
- NOTE:
- l'utilisation de virtualfish et/ou de virtualenvwrapper permet de résoudre le problème lorsque les packages globaux sont TOUJOURS inclus dans les environnements virtuels
virtualfish: Commandes basiques
vf new [<options>] <env>
: Create a virtual environmentvf activate <env>
: Activate a virtual environment (Note: Doesn’t use the activatefish script provided by Virtualenv)vf deactivate
: Deactivate the current virtual environmentvf rm <env>
: Delete a virtual environmentvf ls [--details]
: List the available virtual environmentsvf tmp [<options>]
: Create a temporary virtual environment with a randomly generated name that will be removed when it is deactivatedvf upgrade [<options>] [<env(s)>]
: Upgrade virtual environment(s)vf cd
: Change directory to currently-activated virtual environmentvf cdpackages
: Change directory to currently-active virtual environment’s site-packagesvf globalpackages
: Toggle system site packagesvf addpath
: Add a directory to this virtual environment’s syspathvf all <command>
: Run a command in all virtual environments sequentiallyvf connect
: Connect the current working directory with the currently active virtual environment.- This requires the auto-activation plugin to be enabled in order to have any effect besides creating a .venv file in the current directory
virtualenvwrapper: Commandes basiques (ou virtualfish compat_aliases)
mkvirtualenv <env>
: Create a virtual environmentworkon <env>
: Activate a virtual environmentdeactivate
: Deactivate the current virtual environmentrmvirtualenv <env>
: Delete a virtual environmentlsvirtualenv
: List the available virtual environmentsmktmpenv <env>
: Create a temporary virtual environmentcpvirtualenv <env> <targetenv>
: Copy a virtual environmentlssitepackages
: list all of the site packages from within the virtual environmentwipeenv
: Remove all of the third party packages from the current virtual environmentmkproject <myproject>
: create the virtual environment called myproject as well as a project directory