Accueil Game Dev Memento Python

05 avril 2019

Memento Python

Tps de lecture estimé:15 minutes 12 secondes

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

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)
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 module twine sera à uploader des packages vers pypi.org

utilisation de pip

Il vaut mieux utiliser python -m pip <commande> que pip <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 package
pip 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 package
python -m pip install --user --upgrade pip: mettre à jour pip avec la dernière version
python -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 intelligible
python -m pip show <package(s)>: montre des informations utiles sur un ou plusieurs paquets que vous avez installés
python -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érieures
python -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érieures
python -m pip install <package> >2.5.0: installe la version la plus élevée disponible au-dessus de 2.5.0
python -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
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 environment
vf activate <env>: Activate a virtual environment (Note: Doesn’t use the activatefish script provided by Virtualenv)
vf deactivate: Deactivate the current virtual environment
vf rm <env>: Delete a virtual environment
vf ls [--details]: List the available virtual environments
vf tmp [<options>]: Create a temporary virtual environment with a randomly generated name that will be removed when it is deactivated
vf upgrade [<options>] [<env(s)>]: Upgrade virtual environment(s)
vf cd: Change directory to currently-activated virtual environment
vf cdpackages: Change directory to currently-active virtual environment’s site-packages
vf globalpackages: Toggle system site packages
vf addpath: Add a directory to this virtual environment’s syspath
vf all <command>: Run a command in all virtual environments sequentially
vf 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 environment
workon <env>: Activate a virtual environment
deactivate: Deactivate the current virtual environment
rmvirtualenv <env>: Delete a virtual environment
lsvirtualenv: List the available virtual environments
mktmpenv <env>: Create a temporary virtual environment
cpvirtualenv <env> <targetenv>: Copy a virtual environment
lssitepackages: list all of the site packages from within the virtual environment
wipeenv: Remove all of the third party packages from the current virtual environment
mkproject <myproject>: create the virtual environment called myproject as well as a project directory

Article suivant Article précédent

Memento Python

Memento Python

Syntaxe de Base

Les variables et les types simples

Les conditions et les boucles

Les méthodes (fonctions)

Les types complexes

tuple

Méthodes sur les tuples

les listes

Méthodes sur les Listes

les chaînes de caractères

Méthodes sur les chaînes

les "range"

Les dictionnaires

Méthodes sur les Dictionnaires

les ensembles (set)

Méthodes sur les set

Classes et objets

A savoir

Méthodes (reflexives) sur les objets

Fichiers

blocs "with"

Les extensions

packages

utilisation de pip

Les modules

Les librairies

Les environnement virtuels

virtualenv/venv : les bases

virtualfish: Commandes basiques

virtualenvwrapper: Commandes basiques (ou virtualfish compat_aliases)

Rechercher un mot

Table des matières

Derniers Articles

Doom Emacs Memento

Memento Unreal Engine 4

Revue de cours UE4

Revue de cours Godot Engine

Revue de livres Godot Engine

Javascript ES6 - progammation fonctionnelle

Syndication

Newsletter