Python

• Gunicorn
• API de GitHub, Gitlab, ...
• Manipulation du système de fichiers
• Snippets de fonctions mathématiques
• PyMySQL
• API de GraphViz
• Manipulation d'images
• Gestion des modules
• Requêtes HTTP
• Pickle
• Tests unitaires
• Packaging des modules Python

• Le guide de l’auto-stoppeur pour Python!
• The Best of the Best Practices (BOBP) Guide for Python
• A guide to Python's function decorators
• Summary of Major Changes Between Python Versions

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

Source

python3 -m venv new-env

new-env est le nom du dossier qui va contenir le nouvel environnement virtuel.

Dans le dossier de l'environnement:

source bin/activate

https://pyyaml.org/

sudo pip3 install pyyaml

import yaml
 
config_file = open("file.yaml", 'r')
config = yaml.safe_load(config_file)

config est alors un dictionnaire contenant toutes les clés du fichier Yaml.

Voir la note sur le dépôt pour les différents loaders.

import yaml
 
vars_dict = dict()
# ...
 
with open('file.yaml'), 'w') as yaml_file:
    yaml.dump(vars_dict, yaml_file, default_flow_style=False)

import sys
 
if len(sys.argv) < 2:
    sys.exit(1)
 
action = sys.argv[1]

• 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.

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()

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 :

cli_parser.add_argument("b", help="Block size", type=int, nargs="?", default=320)

if __name__ == '__main__':
    # some stuff

Source

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

Pour préciser l'encodage du fichier (Source):

with open(filename, 'rb') as file:
    content = file.read().decode('windows-1252')

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

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))

Écrire un CSV:

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)

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

reader = csv.reader(file)
next(reader)

• Redirecting all kinds of stdout in Python

import sys
 
print("Erreur", file=sys.stderr)

Récupère et retire l'élément d'index passé en paramètre:

e = liste.pop(0)

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

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

l.insert(0, "new") # insert "new" at the beginning of the list

sorted_list = sorted(list_to_sort)
sorted_list = sorted(list_to_sort, key=lambda e: e['dict_key'])
list_to_sort.sort()

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

list_mapped = map(lambda x: x*2, initial_list)

Source

Si les éléments sont hashables:

len(your_list) != len(set(your_list))

Sinon, une méthode avec une complexité plus importante:

any(thelist.count(x) > 1 for x in thelist)

Source

# Est plus rapide
from operator import add
list(map(add, list1, list2))

[sum(x) for x in zip(list1, list2)]

Si la vitesse importe vraiment, il est aussi possible de le faire avec Numpy encore plus rapidement.

https://pyformat.info/

Il faut doubler les accolades pour qu'elles soient ignorées par Python:

"\\texttt{{{}}}".format('COPY')  # = "\texttt{COPY}"

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))

Source

s = "  abc "
print(s.strip())

Source

format(2.03, '.5f') # '2.03000'

s = "the dude is a cool dude"
s.find('dude') # 4

any(c.isalpha() for c in s)

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

# 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")

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

'12'.isdigit()

• 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

import os
 
os.path.commonprefix([str1, str2])

• 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 (source) :

pip install numpy six icu
pip install pyicu
pip install pycld2
pip install morfessor

from polyglot.text import Text
if Text(txt).language.code not in ["en", "fr"]:
    printf("...")

dtwithoutseconds = dt.replace(second=0, microsecond=0)

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

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

import datetime
 
some_date -= datetime.timedelta(days=90)

>>> from datetime import date
>>> date.fromisoformat('2019-12-04')
datetime.date(2019, 12, 4)

À partir de la version 3.7.

• https://www.journaldev.com/23365/python-string-to-datetime-strptime

>>> import datetime
>>> d = datetime.datetime.strptime(date_str, '%m-%d-%Y').date()

print(date_var.strftime("format"))

Références des formats possibles

Source

from timeit import default_timer as timer
 
start = timer()
# ...
end = timer()
print(end - start) # Time in seconds, e.g. 5.38091952400282

• https://regex101.com/

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

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))

re.sub(r'[\x00-\x08\x0B-\x0C\x0E-\x1F]', '', content)

Utiliser la fonction round:

round(1.23456, 3) # 1.235

s.replace('.','',1).isdigit()

import math
 
math.isnan(f)

condition_if_true if condition else condition_if_false

if isinstance(x, dict):
    print("x is dict")

import os
 
code_retour = os.system('ls')

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 (source):

import subprocess
 
out = subprocess.check_output("ls", text=True)
print(out)
 
out_with_stderr = subprocess.check_output("ls", text=True, stderr=subprocess.STDOUT)

import sys
 
sys.exit(1)

Entre 0 et 1:

import random
x = random.random()

Entre deux entiers:

import random
x = random.randint(10, 25) # 10 <= x <= 25

Source

Conversion de hexadécimal en décimal:

x = int("deadbeef", 16)
y = int("0xdeadbeef", 0)

0 indique à Python de trouver par lui-même la base.

Conversion de décimal en hexadécimal:

x = hex(10)

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

bin(14) # '0b1110'

import time
time.sleep(5) # secondes

Source

On cherche à savoir si stdout est différent de stdin:

import os
redirected_to_file = not (os.fstat(0) == os.fstat(1))

Une solution plus simple (et semble plus fonctionnelle), mais pas forcément valide avec Windows :

import sys
 
if sys.stdout.isatty():
    print "Not redirected"
else:
    sys.stderr.write("Redirected!\n")

Source

import inspect
 
param_names = inspect.getfullargspec(f)[0]

Source

import sys
 
lines = []
for line in sys.stdin:
    lines.append(line)

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

Source

import os
os.path.basename(__file__)

https://realpython.com/iterate-through-dictionary-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)

Par valeur:

{k: v for k, v in sorted(x.items(), key=lambda item: item[1])}

• 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

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

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

from enum import Enum
 
class Direction(Enum):
    TOP = 0
    BOTTOM = 1
    LEFT = 2
    RIGHT = 3
 
d = Direction.TOP

On peut accéder à la valeur de l'élément de l'énumération:

Direction.TOP.value # 0

Pour faciliter la représentation des éléments:

class CompMetric(Enum):
    BANDWIDTH = "bandwidth"
    TIME = "time"
 
    def __repr__(self):
        return self.name

Afficher correctement en objet dans le format JSON:

import json
print(json.dumps(data, ensure_ascii=False, indent=4)) # ensure_ascii=False permet d'afficher correctement l'utf-8