====== Python ======

  * [[python:gunicorn|Gunicorn]]
  * [[:git-python-api|API de GitHub, Gitlab, ...]]
  * [[filesystem|Manipulation du système de fichiers]]
  * [[math-snippets|Snippets de fonctions mathématiques]]
  * [[pymysql|PyMySQL]]
  * [[graphviz|API de GraphViz]]
  * [[python:images|Manipulation d'images]]
  * [[python:modules|Gestion des modules]]
  * [[python:http-request|Requêtes HTTP]]
  * [[python:pickle|Pickle]]
  * [[python:tests|Tests unitaires]]
  * [[python:packaging|Packaging des modules Python]]

  * [[https://python-guide-pt-br.readthedocs.io/fr/latest/#__do_not_save__|Le guide de l’auto-stoppeur pour Python!]]
  * [[https://gist.github.com/sloria/7001839|The Best of the Best Practices (BOBP) Guide for Python]]
  * [[https://www.thecodeship.com/patterns/guide-to-python-function-decorators/|A guide to Python's function decorators]]
  * [[https://www.nicholashairs.com/posts/major-changes-between-python-versions/|Summary of Major Changes Between Python Versions]]

  * [[https://stackoverflow.com/questions/31375656/how-to-draw-the-paths-of-a-networkx-graph-using-different-colours]]


==== Environnements virtuels ====

[[https://docs.python.org/3/tutorial/venv.html|Source]]

=== Créer un environnement ===

<code bash>
python3 -m venv new-env
</code>
''new-env'' est le nom du dossier qui va contenir le nouvel environnement virtuel.


=== Activer l'environnement ===

Dans le dossier de l'environnement:
<code bash>
source bin/activate
</code>




==== Yaml ====

https://pyyaml.org/

=== Installation ===
<code bash>
sudo pip3 install pyyaml
</code>

=== Lecture d'un fichier YAML ===
<code python>
import yaml

config_file = open("file.yaml", 'r')
config = yaml.safe_load(config_file)
</code>
''config'' est alors un dictionnaire contenant toutes les clés du fichier Yaml.

Voir [[https://github.com/yaml/pyyaml/wiki/PyYAML-yaml.load(input)-Deprecation|la note]] sur le dépôt pour les différents //loaders//.


=== Écriture d'un fichier YAML ===

<code python>
import yaml

vars_dict = dict()
# ...

with open('file.yaml'), 'w') as yaml_file:
    yaml.dump(vars_dict, yaml_file, default_flow_style=False)
</code>



==== Arguments du programme ====

<code python>
import sys

if len(sys.argv) < 2:
    sys.exit(1)

action = sys.argv[1]
</code>



==== argparse ====

  * https://docs.python.org/3/library/argparse.html

Permet de gérer facilement les arguments passés à un script, et générer la documentation qui va avec.
<code python>
import argparse

cli_parser = argparse.ArgumentParser()
cli_parser.add_argument("config_file", help="Configuration file in YAML format")
cli_parser.add_argument("nb_cores_per_numa", help="Number of cores per NUMA node", type=int)
args = cli_parser.parse_args()
</code>
''args'' est un objet contenant les paramètres passés en arguments du script (par exemple: ''args.config_file'').

Pour avoir un paramètre optionnel avec une valeur par défaut :
<code python>
cli_parser.add_argument("b", help="Block size", type=int, nargs="?", default=320)
</code>






==== Fonction par défaut ====

<code python>
if __name__ == '__main__':
    # some stuff
</code>





==== Lire un fichier ====

[[https://www.pythonforbeginners.com/files/reading-and-writing-files-in-python|Source]]

<code python>
with open(filename, 'r') as file:
    content = file.read()
    # ou
    lines = file.readlines() # liste où chaque élément est une ligne du fichier
    # ou
    for line in file:
        print(line)
    # ou
    print(file.readline(3)) # lit la 3ème ligne du fichier
</code>

Pour préciser l'encodage du fichier ([[http://sametmax.com/lencoding-en-python-une-bonne-fois-pour-toute/|Source]]):
<code python>
with open(filename, 'rb') as file:
    content = file.read().decode('windows-1252')
</code>


=== CSV ===

[[https://docs.python.org/fr/3/library/csv.html]]

<code python>
import csv
with open('eggs.csv', newline='') as csvfile:
    spamreader = csv.reader(csvfile, delimiter=' ', quotechar='|')
    
    nb_lines = sum(1 for row in spamreader)
    
    for row in spamreader:
        print(', '.join(row))
</code>

Écrire un CSV:
<code python>
import csv

someiterable = [
    ['abc', 20.7, 17.2],
    ['def', 20.6, 17.1]
]

with open('some.csv', 'w', newline='') as f: # possibilité d'utiliser le mode 'a' pour ajouter à la fin d'un fichier existant. Dans tous les cas, le fichier sera créé s'il n'existe pas.
    writer = csv.writer(f)
    writer.writerows(someiterable)
</code>

Il est possible d'écrire sur la sortie standard en utilisant le fichier ''sys.stdout''.


=== Ignorer la première ligne ===

<code python>
reader = csv.reader(file)
next(reader)
</code>


=== Lire l'entrée standard ou un fichier ===

[[https://stackoverflow.com/questions/1450393/how-do-i-read-from-stdin|Source]]

<code python>
import sys


f = open(sys.argv[1]) if len(sys.argv) == 2 else sys.stdin

# ... work with f ...

if len(sys.argv) == 2:
    f.close()
</code>




==== Ecrire sur stderr ====

  * [[https://eli.thegreenplace.net/2015/redirecting-all-kinds-of-stdout-in-python/|Redirecting all kinds of stdout in Python]]

<code python>
import sys

print("Erreur", file=sys.stderr)
</code>



==== Listes ====

=== Retirer un élément ===

Récupère et retire l'élément d'index passé en paramètre:
<code python>
e = liste.pop(0)
</code>

=== Index d'un élément d'une liste ===

[[https://www.programiz.com/python-programming/methods/list/index]]

<code python>
vowels = ['a', 'e', 'i', 'o', 'i', 'u']
index = vowels.index('e')
print('The index of e:', index) # 1
</code>


=== Insérer un élément n'importe où ===

<code python>
l.insert(0, "new") # insert "new" at the beginning of the list
</code>

=== Tri ===

<code python>
sorted_list = sorted(list_to_sort)
sorted_list = sorted(list_to_sort, key=lambda e: e['dict_key'])
list_to_sort.sort()
</code>

Ces fonctions acceptent un paramètre ''reverse=True'' pour trier dans l'ordre décroissant.


=== Map ===

<code python>
list_mapped = map(lambda x: x*2, initial_list)
</code>


=== S'assurer qu'il n'y a pas de doublons ===

[[https://stackoverflow.com/questions/1541797/how-do-i-check-if-there-are-duplicates-in-a-flat-list|Source]]

Si les éléments sont hashables:
<code python>
len(your_list) != len(set(your_list))
</code>
Sinon, une méthode avec une complexité plus importante:
<code python>
any(thelist.count(x) > 1 for x in thelist)
</code>


=== Somme terme à terme de deux listes ===

[[https://stackoverflow.com/questions/18713321/element-wise-addition-of-2-lists|Source]]

<code python>
# Est plus rapide
from operator import add
list(map(add, list1, list2))
</code>
<code python>
[sum(x) for x in zip(list1, list2)]
</code>
Si la vitesse importe vraiment, il est aussi possible de le faire avec Numpy encore plus rapidement.




==== Chaînes de caractères ====


=== Formatage de chaînes de caractères ===

[[https://pyformat.info/]], [[https://fstring.help/cheat/]]

Il faut doubler les accolades pour qu'elles soient ignorées par Python:
<code python>
"\\texttt{{{}}}".format('COPY')  # = "\texttt{COPY}"
</code>




=== Générer une chaîne de caractères aléatoires ===

<code python>
import string
import random

def generate_random_string(size = 40, chars = string.ascii_lowercase + string.digits):
    return ''.join(random.choice(chars) for _ in range(size))
</code>


=== Enlever les espaces de début et fin de chaîne ===

[[https://stackoverflow.com/questions/1185524/how-do-i-trim-whitespace|Source]]

<code python>
s = "  abc "
print(s.strip())
</code>

=== Formater un flottant en texte ===

[[https://stackoverflow.com/questions/6149006/display-a-float-with-two-decimal-places-in-python|Source]]

<code python>
format(2.03, '.5f') # '2.03000'
</code>


=== Trouver une sous-chaîne ===

<code python>
s = "the dude is a cool dude"
s.find('dude') # 4
</code>


=== Tester si une chaîne contient une lettre ===

<code python>
any(c.isalpha() for c in s)
</code>


=== Sur plusieurs lignes ===

[[https://www.techbeamers.com/python-multiline-string/]]

<code python>
# Préserve les retours à la ligne dans la chaîne de caractère:
s = """
multi
ligne
"""

# Pour juste éviter d'avoir un code trop large:
s = ("texte"
     "sur la"
     "même ligne")
</code>


=== Tester si c'est un nombre ===

[[https://stackoverflow.com/questions/1265665/how-can-i-check-if-a-string-represents-an-int-without-using-try-except]]

<code python>
'12'.isdigit()
</code>



=== Trouver le préfixe commun ===

  * [[https://stackoverflow.com/questions/6718196/determine-prefix-from-a-set-of-similar-strings]]
  * https://docs.python.org/3/library/os.path.html#os.path.commonprefix

<code python>
import os

os.path.commonprefix([str1, str2])
</code>


=== Connaître la langue d'un texte ===

  * [[https://stackoverflow.com/questions/39142778/how-to-determine-the-language-of-a-piece-of-text/47106810]]

L'installation de Polyglot est un peu particulière ([[https://stackoverflow.com/questions/64886067/polyglot-importerror-cannot-import-name-locale-from-icu|source]]) :
<code bash>
pip install numpy six icu
pip install pyicu
pip install pycld2
pip install morfessor
</code>
<code python>
from polyglot.text import Text
if Text(txt).language.code not in ["en", "fr"]:
    printf("...")
</code>



==== Temps ====

=== Enlever les secondes d'une date ===

<code python>
dtwithoutseconds = dt.replace(second=0, microsecond=0)
</code>

=== Récupérer le temps actuel ===

<code python>
import datetime

t = datetime.datetime.now() # datetime.datetime(2009, 1, 6, 15, 8, 24, 78915)
t = datetime.datetime.now().time() # datetime.time(15, 8, 24, 78915)
t = datetime.datetime.now().timestamp() # 1575914832.536088
</code>


=== Différence de temps ===

<code python>
t1 = datetime.datetime.now()
t2 = datetime.datetime.now()
delta = t2-t1 # datetime.timedelta(seconds=231, microseconds=573812), peut contenir des jours
(t2-t1).seconds # 231
(t2-t1).total_seconds() # 231.573812, converti tout en secondes
delta.days
</code>


=== Arithmétique sur les temps ===

<code python>
import datetime

some_date -= datetime.timedelta(days=90)
</code>

=== Str vers date ===

<code python>
>>> from datetime import date
>>> date.fromisoformat('2019-12-04')
datetime.date(2019, 12, 4)
</code>
À partir de la version 3.7.

  * [[https://www.journaldev.com/23365/python-string-to-datetime-strptime]]
<code python>
>>> import datetime
>>> d = datetime.datetime.strptime(date_str, '%m-%d-%Y').date()
</code>


=== Date vers Str ===

<code python>
print(date_var.strftime("format"))
</code>

[[https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes|Références des formats possibles]]


=== Mesurer des durées ===

[[https://stackoverflow.com/questions/7370801/how-do-i-measure-elapsed-time-in-python|Source]]

<code python>
from timeit import default_timer as timer

start = timer()
# ...
end = timer()
print(end - start) # Time in seconds, e.g. 5.38091952400282
</code>


==== Regex ====

  * https://regex101.com/


=== Vérifier le respect d'un pattern ===

<code python>
import re

pattern = re.compile("regex\d+")
m = pattern.match("string to test")
if m is not None:
    # "string to test" matches the regex
</code>


=== Capturer des motifs ===

<code python>
p = re.compile(r"^.+\s+(\d{2})/(\d{2})$")
m = p.match("abc 25/11")

if m is not None:
    day = int(m.group(1))
    month = int(m.group(2))
</code>

Trouver toutes les occurrences qui correspondent à un motif ([[https://stackoverflow.com/questions/4697882/how-can-i-find-all-matches-to-a-regular-expression-in-python|source]]) :
<code python>
re.findall( r'all (.*?) are', 'all cats are smarter than dogs, all dogs are dumber than cats')
# Output: ['cats', 'dogs']
</code>


=== Remplacer un motif ===

<code python>
re.sub(r'[\x00-\x08\x0B-\x0C\x0E-\x1F]', '', content)
</code>





==== Flottants ====

=== Tronquer un flottant ===

Utiliser la fonction ''round'':
<code python>
round(1.23456, 3) # 1.235
</code>


=== Tester si une chaîne est un flottant ===

<code python>
s.replace('.','',1).isdigit()
</code>


=== Tester si un flottant est NaN ===

<code python>
import math

math.isnan(f)
</code>


==== Divers ====

=== Condition ternaire ===

<code python>
condition_if_true if condition else condition_if_false
</code>


=== Tester le type d'une variable ===

<code python>
if isinstance(x, dict):
    print("x is dict")
</code>

=== Exécuter une commande système ===

<code python>
import os

code_retour = os.system('ls')
</code>
Attention, chaque commande se place dans le dossier d’exécution du script, il n'y pas de persistance des déplacements dans l'arborescence au sein des différents appels à ''system()''.


Pour capturer ce qui est écrit sur la sortie standard ([[https://stackoverflow.com/a/18739828|source]]):
<code python>
import subprocess

out = subprocess.check_output("ls", text=True)
print(out)

out_with_stderr = subprocess.check_output("ls", text=True, stderr=subprocess.STDOUT)
</code>


=== Quitter le programme avec un code d'erreur spécifique ===
<code python>
import sys

sys.exit(1)
</code>


=== Générer un nombre aléatoire ===

Entre 0 et 1:
<code python>
import random
x = random.random()
</code>

Entre deux entiers:
<code python>
import random
x = random.randint(10, 25) # 10 <= x <= 25
</code>


=== Manipuler l’hexadécimal ===

[[https://stackoverflow.com/questions/209513/convert-hex-string-to-int-in-python|Source]]

Conversion de hexadécimal en décimal:
<code python>
x = int("deadbeef", 16)
y = int("0xdeadbeef", 0)
</code>
''0'' indique à Python de trouver par lui-même la base.

Conversion de décimal en hexadécimal:
<code python>
x = hex(10)
</code>

On peut manipuler l'hexadécimal directement dans la console en préfixant les nombres par ''0x''.


=== Convertir un nombre en binaire ===

<code python>
bin(14) # '0b1110'
</code>


=== Sleep ===

<code python>
import time
time.sleep(5) # secondes
</code>


=== Savoir si la sortie est redirigée ===

[[https://stackoverflow.com/a/1512526|Source]]

On cherche à savoir si ''stdout'' est différent de ''stdin'':
<code python>
import os
redirected_to_file = not (os.fstat(0) == os.fstat(1))
</code>

Une solution plus simple (et semble plus fonctionnelle), mais pas forcément valide avec Windows :
<code python>
import sys

if sys.stdout.isatty():
    print "Not redirected"
else:
    sys.stderr.write("Redirected!\n")
</code>


=== Obtenir le nom des arguments d'une fonction ===

[[https://stackoverflow.com/questions/218616/how-to-get-method-parameter-names|Source]]

<code python>
import inspect

param_names = inspect.getfullargspec(f)[0]
</code>



=== Lire l'entrée standard ===

[[https://stackoverflow.com/questions/1450393/how-do-you-read-from-stdin|Source]]

<code python>
import sys

lines = []
for line in sys.stdin:
    lines.append(line)
</code>

On sort de la boucle lorsque l'entrée standard est fermée.


=== Connaître le nom du script exécuté ===

[[https://stackoverflow.com/questions/4152963/get-name-of-current-script-in-python|Source]]

<code python>
import os
os.path.basename(__file__)
</code>
==== Dictionnaires ====

[[https://realpython.com/iterate-through-dictionary-python/]]

<code python>
a_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}

for key in a_dict:
    print(key, '->', a_dict[key])
    
for key, value in a_dict.items():
    print(key, '->', value)

for value in a_dict.values():
    print(value)
</code>

=== Tri ===

Par valeur:
<code python>
{k: v for k, v in sorted(x.items(), key=lambda item: item[1])}
</code>









==== Parser du XML ====

  * [[https://docs.python.org/3/library/xml.dom.minidom.html]]
  * [[https://www.fil.univ-lille1.fr/~marvie/python/chapitre4.html]]
  * [[https://stackoverflow.com/a/1912516]]

<code python>
doc = minidom.parse("file.xml")
systems = doc.getElementsByTagName("System")
for s in systems:
    n = s.getElementsByTagName("Node")
    name = n[0].getElementsByTagName("NodeDesc")[0].firstChild.data
    uid = n[0].attributes["id"].value
</code>




==== Énumérations ====

[[https://docs.python.org/fr/3/library/enum.html]]

<code python>
from enum import Enum

class Direction(Enum):
    TOP = 0
    BOTTOM = 1
    LEFT = 2
    RIGHT = 3

d = Direction.TOP
</code>

On peut accéder à la valeur de l'élément de l'énumération:
<code python>
Direction.TOP.value # 0
</code>


Pour faciliter la représentation des éléments:
<code python>
class CompMetric(Enum):
    BANDWIDTH = "bandwidth"
    TIME = "time"

    def __repr__(self):
        return self.name
</code>


==== JSON ====

Afficher correctement en objet dans le format JSON:
<code python>
import json
print(json.dumps(data, ensure_ascii=False, indent=4)) # ensure_ascii=False permet d'afficher correctement l'utf-8
</code>


==== Débugguer un segfault ====

  * [[https://stackoverflow.com/questions/16731115/how-to-debug-a-python-segmentation-fault]]
  * https://docs.python.org/3/library/faulthandler.html

<code bash>
export PYTHONFAULTHANDLER=1
</code>