PYTHON

Liens_Web:

Ensemble de commande utiles

Liens_Web:

Obtenir de l’aide sur une class ou une méthode (python)

Dans la console Python, saisir :

help("nom_de_la_class")

Lignes de code à insérer au debut de chaque script sous Linux

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

N.B : copier ces lignes entièrement sans oublier le « # » devant.

os library

Liens Web:

OS_lib: Traitement des répertoires

  1. Connaître le répertoire de travail

    import os
    # on commence par importer la bibliothèque 'os'
os.getcwd()

  2. Redéfinir le répertoire courant

    import os
os.chdir("mon_rep/de/travail")
    # meme sous Windows, il faut remplacer les "\" dans le chemin de
    destination par des "/"

    ex : os.chdir("C:/mntJeanCloud/Perso/LAB/Pierre/python/projet/appliActivity")

  3. Savoir si un chemin représente un répertoire ?

    os.path.isdir(path)
    # renvoi True si path désigne un répertoire existant

  4. Créer un répertoire

    os.mkdir(path, mode=0777)
    # créé un répertoire le plus à droite dans path

os.makedirs(path, mode=0777)
    # crée tous les répertoires de path n'existant pas

  5. Supprimer un répertoire

    os.rmdir(path)
    # supprime le répertoire path si celui-ci est vide

  6. Supprimer un fichiers

    os.remove([nom_du_fichier])

  7. Renommer/déplacer un répertoire

    os.rename(src, dst)
    # permet de renommer le répertoire src en le répertoire dst,
    # tous les répertoire parent de dst doivent cependant déjà exister,
    # une erreur étant sinon retournée.

os.renames(src, dst)
    # permet de renommer le répertoire src en dst tout en créant si
    # nécessaire les répertoires parent du répertoire de destination.

    N.B : Si le répertoire de destination se trouve sur le même système de fichiers, vous pouvez utiliser aussi bien les fonctions os.rename, os.renames que shutil.move sinon préférez shutil.move, les 2 autres fonctions pouvant échouer à leur tâche.

  8. Connaître la taille d’un répertoire

Pour connaître la taille d’un répertoire, il suffit de le parcourir son arborescence en ajoutant la taille de chaque fichier rencontré.

import os.path

def sizedirectory(path):
    size = 0
    for root, dirs, files in os.walk(path):
        for fic in files:
            size += os.path.getsize(os.path.join(root, fic))
    return size

print( sizedirectory([path_=_mon_chemin_de_dossier]))

shutil library

Liens_Web:

shutil: Traitement des répertoires

  1. Supprimer un répertoire non vide

    shutil.rmtree(path)

  2. Renommer/déplacer un répertoire

    shutil.move(src, dst)
    # renomme exactement comme os.renames le répertoire src en dst si
    # le répertoire de destination est sur le même système de fichiers.
    # Autrement elle copie simplement src sur dst puis efface src.

psutil (process and system utilities)

Pour surveiller différent process machine ( CPU, RAM, Network, etc)

Liens_Web:

pip (Python installing packages)

Liens web:

Installation de PIP sous linux

Liens_Web:

  1. Récupération et installation du paquet

    wget https://bootstrap.pypa.io/get-pip.py
    # recuperation du script d'installation

python get-pip.py
    # se placer dans le répertoire d'installation et lancer le script
    # une élévation est peut être nécessaire

/!\: si aucun alias sur python n'a été créé, il faut lancer python avec son numéros de
     version.

     ex:
     python3.6 get-pip.py

  2. Installation depuis apt-get

    sudo apt-get install python3-pip
    # pip sera installer dans le répertoire suivant :
    # /usr/bin/pip3

Utilisation de PIP

La commande pip s’exécute directement dans le shell

  1. Exécuter pip pour python3 dans un environnement Linux

    pip-3.2 [une_commande]
        ou
pip3 [une commande]

  2. obtenir la liste des options

    pip help
    # fonctionne aussi avec pip tout seul

  3. chercher un paquet

    pip search [nom_du_paquet_rechercher]
    # on peut rechercher plusieurs termes en les séparent par des espaces
    # ex : pip search py3 numpy
    # attention, la recherche est également faite sur
    # les définissions des paquets

  4. installer un paquet

    pip install [nom_du_paquet_a_installer]

Les environnements virtuels Python : virtualenv et virtualenvwrapper (version Linux)

Liens Web:

installation des environnements virtuels

  1. Installation de virtualenv et virtualenvwrapper

N.B : il est préférable de les installer en sudo et non en root (su)

sudo pip install virtualenv
sudo pip install virtualenvwrapper

configuration des environnements virtuels

  1. Créer un dossier pour les environnements virtuels

    • Se placer dans le répertoire de l’utilisateur (/home/pi)

    • Créer un dossier pour les environnements virtuels

mkdir virtualenv

  1. Editer le fichier .bashrc

    sudo nano .bashrc

  2. renseigner le fichier .bashrc

  • Se placer à la fin du fichier et saisir :

    # virtualenvwrapper

export WORKON_HOME=~/virtualenv
    # si le dossier n'a pas été créer au même endroit ou avec le même
    # nom, modifier la ligne précédente en conséquence

mkdir -p $WORKON_HOME
source  /usr/local/bin/virtualenvwrapper.sh
    # si virtualenvwrapper.sh n'est pas installer au même endroit,
    # adapter le chemin d'accès au fichier

Utilisation environnements virtuels

  1. Création d’un nouvel environnements virtuel

    mkvirtualenv [nom_de_l_environnement] -p /usr/bin/python3.2
    # ex : mkvirtualenv env1 -P /usr/bin/python3.2

    # un dossier du nom de votre environnement virtuel est alors créer
    # dans le dossier virtualenv créer en section 2.1

    # l'option "-p usr/bin/python3.2" permet de configurer environnements
    # virtuel pour python3. par défaut sur Rpi, c'est python2 qui est
    # utilisé
  2. Activation / désactivation de l’environnent

    Pour être utilisé, un environnement doit être activé :

    workon [nom_de_l_environnement]
        # ex : workon env1

    A la fin de son utilisation, ou pour passer sur un autre environnement, il faut le désactiver :

    deactivate
    # c'est tout !
    # Attention, ce n'est pas deSactivate,
    # mais bien deactivate sans "S"

  3. supprimer un environnement

    rmvirtualenv [nom_de_l_environnement]
    # ex : rmvirtualenv env1
    # le dossier de l’environnement sera également supprimer

Un shell Python qui fait de l’auto complétion

  • ipython

  • ipython3 (pour python3)

convertir un string en bytes

b = bytes(mystring, 'utf-8')

Connaître l’adresse mémoire d’un objet

a = 'a'
id(a)
    # on récupère l'adresse au format décimal
>>> 45748752

hex( id(a) )
    # récupère l'adresse et on la convertit directement au format hexadécimal

>>> '0x2ba1210'

Affectation, copy et deepcopy

  1. Affectation :

    L’affectation ne créer pas un nouvel objet. Elle se contente de pointer sur la même adresse en mémoire

    a = 1
b = a

a = b = 1
# a et b ont la même adresse
>>> hex( id(a) )
'0x5ec5e370'
>>> hex( id(b) )
'0x5ec5e370'
  2. copy

    La commande « copy » permet de créer un nouvel objet qui pointe sur l’adresse du premier objet tant que la valeur du second n’a pas été modifier

    >>> import copy
>>> a = 1
>>> b = copy.copy( a )
>>> hex( id(a) )
'0x5ec5e370'
>>> hex( id(b) )
'0x5ec5e370'
>>> a
1
>>> b
1
>>> b = 2
>>> a
1
>>> b
2
>>> hex( id(a) )
'0x5ec5e370'
>>> hex( id(b) )
'0x5ec5e380'

    Attention la copy d’une liste crée un nouvel objet mais les adresse des données pointée par la liste reste les mêmes, donc la modification d’une valeur dans la liste B modifiera aussi la valeur de la liste A

    >>> a = [1, 2, 3]
>>> b = copy.copy(a)
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> hex( id(a) )
'0x593d78'
>>> hex( id(b) )
'0x2f81300'
>>> hex( id(a[0]))
'0x5ec5e370'
>>> hex( id(b[0]))
'0x5ec5e370'

    On parle de shallow copy

  3. deepcopy

    Le deepcopy permet de faire une copie « en profondeur », c’est à dire une copie complète y compris le contenu des données itérables

    >>> a
[1, 2, 3]
>>> b = copy.deepcopy(a)
>>> b
[1, 2, 3]
>>> hex( id(a) )
'0x593d78'
>>> hex( id(b) )
'0x593800'

faire un exécutable à partir d’un script

les softs:

  • py2exe

  • cx_Freeze

La procédure d’utilisation :

Liens WEB:

web framework

Bottle

Liens Web:

Bottle is a fast, simple and lightweight WSGI micro web-framework for Python.

Flask

Liens Web:

Flask is a micro webdevelopment framework for Python.

Les décorateurs

Liens Web:

exemple d’utilisation :

>>> def decorateur(fonct) :
...     """ fonction décorateur permettant de donnée le temps d’exécution d'une fonction """
...     @functools.wraps( fonct )
...     def appelFonc( *args, **kwargs ) :
...             t = time.time()
...             tache = fonct( *args, **kwargs )
...             print(f"temps d’exécution : {time.time()-t}")
...             return tache
...     return appelFonc
...
>>>
>>> @decorateur
... def f(a, b, c) :
...     """ affiche le contenue et le type des variables passées en argument """
...     print( f"{a} - {type(a)}")
...     print( f"{b} - {type(b)}")
...     print( f"{c} - {type(c)}")
...
>>> f('a', 1, c=f)
a - <class 'str'>
1 - <class 'int'>
<function f at 0x000001F6E7792268> - <class 'function'>
temps d'execution : 0.00653386116027832

Les fonction lambda

Les fonctions lambda sont des fonctions sur une seule ligne (une seule expression serait plus juste). Elle sont associé à une variable. Elle peuvent recevoir 0, 1 ou plusieurs argument. Y compris des arguments ayant une valeur par défaut.

La syntaxe est la suivante :

[varriable_d'affectation] = lambda [0, 1 ou n arguments] : [expression]

ex:
# fonction classique:
def f(var1, var2):
    return var1 + var2

>>>f(1, 2)
3

# fonction lambda:
f = lambda var1, var2 : var1 + var2

>>>f(1, 2)
3

# lambda sans argument:
f = lambda : print("Je suis une lambda sans agurment")

>>>f()
Je suis une lambda sans argument

# lambda avec 1 argument
>>> f = lambda var1 : print(f"voici l'argument 'var1' : {var1}")
>>> f("arg1")
voici l'argument 'var1' : arg1

# lambda avec un argument par défaut:
>>> f = lambda var1="valeur par défaut" : print(f"voici l'argument 'var1' : {var1}")
>>> f()
voici l'argument 'var1' : valeur par défaut
>>> f("arg personalisé")
voici l'argument 'var1' : arg personalisé

Tester un type attendu

  1. Pour Test si une variable ou une instance et bien du type attendu :

    isinstance( [variable_a_traiter], [type_attendu] )

ex :

>>> a = [1, 2, 3]
>>> isinstance( a, list )
True

Packing et UnPacking (utilisation de : “*args” et “**kwargs”)

Liens Web:

N.B : on parle de l’opérateur “splat” lorsque l’on parle de l’astérisque “*”

  1. “*args”

    “*args” permet de passer, à une fonctions, des arguments en nombres et de types inconnue puis converti l’ensemble en tuple. Dans le prototype d’une fonction, cet argument est utilisé comme « positional argument ». ex :

    >>> def f(*args) :
...     print( args )
...     for i in range( len(args) ) :
...             print( "{} - {}".format(args[i], type(args[i])))
...
>>> f(1, 'a', True)
(1, 'a', True)
1 - <class 'int'>
a - <class 'str'>
True - <class 'bool'>

  2. « **kwargs »

    “**kwargs” permet de passer, à une fonctions, des arguments en nombres et de types inconnue puis converti l’ensemble en dictionnaire. Dans le prototype d’une fonction, cet argument est utilisé pour les argument par défaut. ex :

    >>> def fd(**kwargs) :
...     print( kwargs )
...
>>> fd(a=1, b=2, c=3)
{'c': 3, 'a': 1, 'b': 2}

N.B : Les termes « args » et « kwargs » sont des conventions et peuvent être remplacés par un nom plus parlant mais se n’est pas conseillé.

Passer des paramètres à un programme avec argparse

Liens Web:
https://openclassrooms.com/courses/apprenez-a-programmer-en-python/un-peu-de-programmation-systeme
# une bonne introductions sur la gestion des flux entrant et sortant ainsi que

sur argparse

https://docs.python.org/3.4/library/argparse.html

# La doc officielle

https://docs.python.org/3.4/howto/argparse.html

# Un tuto tire de la doc officielle

http://www.developpez.net/forums/d1477855/autres-langages/python-zope/general-python/marche-argparse/

# Voir le post de “tyrtamos” du 27/10/2014 à 16h40

  1. Obtenir de l’aide sur les options de notre code

    Même si on ne met pas l’option “-h” ou « - -help », cette options est implémentée par défaut dès lors que l’on crée un parser avec argparse. Cette options vas lister et détailler nos propre options :

    python code.py --help
usage: code.py [-h]

optional arguments:
  -h, --help  show this help message and exit

  2. Éléments de bases

    import argparse

parser = argparse.ArgumentParser()
    # Création de l'instance

args = parser.parse_args()
    # Récupérer les arguments

  3. ajouter des arguments a parser

    parser.add_argument([listes_des_options_separees_par_des_virgules])

  4. positional arguments

    Les “positional arguments” sont des arguments obligatoires lors de l’appel du script. ils sont déclaré entre guillemets (ou simples cotes) et sans tiret. Ils n’ont pas non plus un appel long et un appel court.

    ex :

    parser.add_argument("x", type=int, help="le nombre à mettre au carré")

  5. optional arguments

    Les “optional arguments” sont des argument facultatifs. Ils sont déclare entre guillemets (ou simples cotes) avec tiret. Les appels court sont composes d’un tiret et d’une lettre. Les appels long sont composes d’un double tiret et d’un nom significatif. Les 2 appels peuvent être soit déclare ensemble ou déclarer seuls (l’un ou l’autre)

    N.B : même si il n’y a pas de d’argument optionnel de déclaré, il y en a

    toujours au moins un puisque le help (-h ou –help) est ajouter automatiquement.

    ex :

    parser.add_argument("-v", "--verbose", action="store_true", help="augmente la verbosité")

  6. l’exemple tire du help( « argparse » )

    The following is a simple usage example that sums integers from the
command-line and writes the result to a file::

    parser = argparse.ArgumentParser(
        description='sum the integers at the command line')
    parser.add_argument(
        'integers', metavar='int', nargs='+', type=int,
        help='an integer to be summed')
    parser.add_argument(
        '--log', default=sys.stdout, type=argparse.FileType('w'),
        help='the file where the sum should be written')
    args = parser.parse_args()
    args.log.write('%s' % sum(args.integers))
    args.log.close()

Connaître le nombre de CPU d’un système

os.cpu_count()

logging Library

Liens Web:
Description:

Cette Lib permet de faire du log sur des éléments.

Cette Lib doit être intégrée dans le code (pas de décorateur et pas de « débraillasse »). Les niveaux d’alertes son à définir soit même. Ils correspondent à un entier allant de 10 à 50 par palier de 10.

Définition_des_niveaux_d’alerte:

Level

Numeric Value

Function

Used to

Critical

50

logging.critical()

Show a serious error, the program may be unable to continue running

Error

40

logging.error()

Show a more serious problem

Warning

30

logging.warning()

Indicate something unexpected happened, or could happen

Info

20

logging.info()

Confirm that things are working as expected

Debug

10

logging.debug()

Diagnose problems, show detailed information
Snipet:

Ce Snipet vient de Sam&Max

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import logging

from logging.handlers import RotatingFileHandler

logger = logging.getLogger()
    # création de l'objet logger qui va nous servir à écrire dans les logs

logger.setLevel(logging.DEBUG)
    # on met le niveau du logger à DEBUG, comme ça il écrit tout

formatter = logging.Formatter('%(asctime)s :: %(levelname)s :: %(funcName)s :: %(lineno)d :: %(message)s')
    # création d'un formateur qui va ajouter le temps, le niveau
    # de chaque message quand on écrira un message dans le log
    #
    # Les diférents attribue utilisablent avec le formateur :
    # https://docs.python.org/3.6/library/logging.html#logrecord-attributes

file_handler = RotatingFileHandler('activity.log', 'a', 1000000, 1)
    # création d'un handler qui va rediriger une écriture du log vers
    # un fichier en mode 'append', avec 1 backup et une taille max de 1Mo

file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
    # on lui met le niveau sur DEBUG, on lui dit qu'il doit utiliser le formateur
    # créé précédement et on ajoute ce handler au logger

stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.DEBUG)
logger.addHandler(stream_handler)
    # création d'un second handler qui va rediriger chaque écriture de log
    # sur la console

logger.info('Hello')
logger.warning('Testing %s', 'foo')
    # Après 3 heures, on peut enfin logguer
    # Il est temps de spammer votre code avec des logs partout

Utilisation de l’underscore (_)

Liens Web:

Publique, Protégé et Privé

Bien qu’il n’y ai pas de notion « protégé » ou « privé » en python il y a des conventions qui permettent d’introduire ces notions dans les interpréteurs

  1. Publique

    C’est l’affectation classique. Cette affectation sera visible dans l’API (dir() help())

    maVariablePublique = 1

  2. Protégé

    On préfixe notre objet (attribut ou méthode) avec un simple underscore (_). L’objet n’apparaîtra pas dans l’API mais sera utilisable de l’extérieur si on l’appel spécifiquement

    _maVaribleProtegee = 2

  3. Privé

    On préfix notre objet avec un double underscore (__). Il n’apparaîtra pas dans l’API et renverra un « AttributError » si on l’appel spécifiquement

    __maVariablePrivee = 3

Exemple d’utilisation :

>>> class C(object) :
...     pub     = 1
...     _prot   = 2
...     __priv  = 3
...     def getProt(self) :
...             return self._prot
...     def getPriv(self) :
...             return self.__priv
...
>>> test = C()
>>> help(test)
Help on C in module __main__ object:

class C(builtins.object)
 |  Methods defined here:
 |
 |  getPriv(self)
 |
 |  getProt(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  pub = 1

>>> test._prot
2
>>> test.__priv
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'C' object has no attribute '__priv'
>>> test.getPriv()
3

Connaître l’os de travail

ex Win :
>>> import os
>>> os.name
'nt'

ex Mac / Linux :
>>> import os
>>> os.name
'posix'

UUID

Liens_Web:

URLtheque

Ici se trouvent un ensemble de liens intéressant dont le sujet ne nécessitent pas d’explications supplémentaires.

Les context managers et le mot clé “with” en Python:
matplotlib:
hashlib Library:
créer un setup.py (installable avec pip) et mettre sa bibliothèque en ligne sur pypi:
Fichiers de configuration (.ini):