Memento Python

Tps de lecture estimé:10 minutes 56 secondes
programmation développement python

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:

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 '=='

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__

Les extensions

utilisation de pip

  • 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 ),
  • pip list: répertorie tous les paquets que vous avez installés (et leurs dépendances) dans un format intelligible
  • pip show <package(s)>: montre des informations utiles sur un ou plusieurs paquets que vous avez installés
  • 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érieures
  • 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érieures
  • pip install <package> >2.5.0: installe la version la plus élevée disponible au-dessus de 2.5.0
  • 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

  • créer un environnement virtuel dans le dossier projet (par convention on le nomme "env", mais cela pourrait être personnalisé):`python -m venv env"
  • 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: pip install -r requirements.txt

Article suivant Article précédent