AdminSysGNULinux

Outils pour utilisateurs

Outils du site

Piste : • blog
blog

Table des matières

3 billet(s) pour janvier 2026

Notes rsh rcp2026/01/21 18:08Jean-Baptiste
Git - Duplication d'un dépôt2026/01/19 10:22Jean-Baptiste
Exemple simple de conf Nagios2026/01/14 10:07Jean-Baptiste

Python Documentation

Voir :

2025/03/24 15:06
,

Python cours formation

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Voir :

  • PEP 8
  • pep257

Formations :

Apprendre en ligne

Bases :

Avancé :

  • Solutions d'optimisation
  • Interfaçage avec C / C++ Swig
  • Typage statique avec mypy et le module typing
  • Les annotations de types (avec mypy, pypright, pyre ou pytypes)
  • Programmation par contract avec PyContracts

Linter / Formater :

  • Voir :
  • black (The uncompromising code formatter)
  • pydocstyle (checking compliance with Python docstring conventions)
  • autopep8
  • flake8 (enforcing style consistency across Python projects)
  • pylint (linter to detect various errors)
  • isort (simplify import)
  • bandit
  • Autres : tox
  • Jedi for Completions, Definitions, Hover, References, Signature Help, and Symbols
  • Rope for Completions and renaming
  • Pyflakes linter to detect various errors
  • McCabe linter for complexity checking
  • autopep8 for code formatting (preferred over YAPF)
  • pycodestyle
  • prospector
  • pre-commit

Gérer les exceptions et les erreurs :

  • try except finally
  • raise
  • Exception
  • assert
  • traceback
  • pdb

Les Libs:

P.O.O.

  • Attributs et méthodes de classe/instance
  • Les méthodes spéciales (surcharges d'opérateurs, casting, constructeur, destructeur, …)
  • Héritage, surcharge, polymorphisme, la classe object
  • L’héritage simple, l’héritage multiple et le polymorphisme
  • L'héritage multiple et le MRO (Method Resolution Order)
  • Bonnes pratiques de la programmation objet avec Python
  • Les méta-classes et l'héritage multiple

La stdlib - Parcours de quelques modules phares :

Docker / Containers :

Aller plus loin Présentation des objets et fonctions avancés

Les fonctions

def create_hello_world_message(name : str) -> str:
    """
    Creates a personalized greeting message for the given name.
 
    Parameters:
        - name (str) : The name for which the message is created.
 
    Returns:
        - hello_world_message (str) : A personalized greeting message for the given name.
 
    Raises:
        - ValueError : If the given name is empty or None.
    """
 
    if not name:
 
        raise ValueError
 
    hello_world_message = f'Hello World, {name}!'
 
    print(f'name                : { name }')
    print(f'hello_world_message : { hello_world_message }')
 
    return hello_world_message

Import

import os
import sys
sys.path.append(os.path.dirname(os.getcwd()))
 
import plop

Sciences - math

from sympy import symbols, Eq, solve
 
B, G = symbols('B G')
eq1 = Eq(B, 0.3 * B + 5 * G)
eq2 = Eq(100 * B + 200 * G, 1000)
solution = solve(eq1, eq2), (B, G))
solution[B]

Mutable / immutable

Voir aussi : deepcopy 

lst=[1,2,3];
print(list(map(lambda x: [x],lst)));

Autres

import random
random.randint(1,9)
export PYTHONUNBUFFERED=1

Linter

Flake8
ansible-csv-inventory.py:30:80: E501 line too long (82 > 79 characters)

Pour ignorer l'erreur

tox.ini 

[flake8]
extend-ignore = E501

Autres

$ ansible-test sanity --list-tests
action-plugin-docs
ansible-doc
changelog
compile
empty-init
ignores
import
line-endings
no-assert
no-get-exception
no-illegal-filenames
no-smart-quotes
pep8
pslint
pylint
replace-urlopen
runtime-metadata
shebang
shellcheck
symlinks
use-argspec-type-path
use-compat-six
validate-modules
yamllint
2025/03/24 15:06
,

Python - Debug

Voir :

pdb

Voir https://docs.python.org/fr/3/library/pdb.html

Insérer 

import pdb; pdb.set_trace()

Ou lancer le programme en mode debug sans modifier le code 

python2 -m pdb /usr/local/bin/plop.py
Syntax

b pour Breakpoint
Ajout un point d'arrêt ou liste les points d'arrêt

l ou ll
Affiche une portion du code

cl(ear)
Clear breakpoint

p ou pp
Affiche la valeur d'une variable

! statement
Executer du code Python. Dans bien des cas le ! pourra être omis

s(tep)
Exécute la ligne en cours, s'arrête à la première occasion possible (soit dans une fonction qui est appelée, soit sur la ligne suivante de la fonction courante).

n(ext)
La différence entre next et step est que step s'arrête dans une fonction appelée, tandis que next exécute les fonctions appelées à (presque) pleine vitesse

restart
Redémarrer le programe Python débugé.

quit

Exemple
(Pdb) b plop:49
Breakpoint 1 at /usr/local/bin/plop.py:49
(Pdb) r
> /usr/local/bin/plop.py(49)__init__()
-> self.root_wrappers = root_wrappers
(Pdb) p self.svcid
'event-abcd'
(Pdb) self.svcid='event-abcdef'
(Pdb) p self.svcid
'event-abcdef'
(Pdb) r
--Return--
> /usr/local/bin/plop.py(50)__init__()->None
-> self.pwd = pwd.getpwnam(self.svcid)
(Pdb) p self.svcid
'event-abcdef'
(Pdb) r
KeyError: 'getpwnam(): name not found: event-abcdef'
> /usr/local/bin/plop.py(283)fetch_svcids()
-> return [CronTab(site, svcid['nom'], svcid['active'], options, env, root, template_wrapper, root_wrappers) for svcid in svcids]
(Pdb) p [CronTab(site, svcid['nom'], svcid['active'], options, env, root, template_wrapper, root_wrappers) for svcid in svcids]
*** KeyError: KeyError('getpwnam(): name not found: event-abcdef',)
(Pdb) self.svcid='event-abcd'
*** NameError: name 'self' is not defined
(Pdb) b
Num Type         Disp Enb   Where
1   breakpoint   keep yes   at /usr/local/bin/plop.py:49
        breakpoint already hit 1 time
(Pdb) restart
Restarting /usr/local/bin/plop.py with arguments:

> /usr/local/bin/plop.py(6)<module>()
-> """

Ipdb

pip install ipdb
import ipdb; ipdb.set_trace()

trace

python -m trace --trace somefile.py
2025/03/24 15:06

Python - callback2

https://pythonexamples.org/python-callback-function/ 

def callbackFunc(s):
    print('Length of the text file is : ', s)
 
def printFileLength(path, callback):
    f = open(path, "r")
    length = len(f.read())
    f.close()
    callback(length)
 
if __name__ == '__main__':
    printFileLength("sample.txt", callbackFunc)
def callbackFunc1(s):
    print('Callback Function 1: Length of the text file is : ', s)
 
def callbackFunc2(s):
    print('Callback Function 2: Length of the text file is : ', s)
 
def printFileLength(path, callback):
    f = open(path, "r")
    length = len(f.read())
    f.close()
    callback(length)
 
if __name__ == '__main__':
    printFileLength("sample.txt", callbackFunc1)
    printFileLength("sample.txt", callbackFunc2)

https://www.localsolver.com/docs/last/technicalfeatures/callbacks.html 

class CallbackExample:
    def __init__(self):
        self.last_best_value = 0
        self.last_best_running_time = 0
 
    def my_callback(self, ls, cb_type):
        stats = ls.statistics
        obj = ls.model.objectives[0]
        if obj.value > self.last_best_value:
            self.last_best_running_time = stats.running_time
            self.last_best_value = obj.value
        if stats.running_time - self.last_best_running_time > 5:
            print(">>>>>>> No improvement during 5 seconds: resolution is stopped")
            ls.stop()
        else:
            print(">>>>>> Objective %d" % obj.value)
 
ls = localsolver.LocalSolver()
cb = CallbackExample()
ls.add_callback(localsolver.LSCallbackType.TIME_TICKED, cb.my_callback)

https://www.askpython.com/python/built-in-methods/callback-functions-in-python 

def called(n):
    return n[0]*n[1]
 
def caller(func, n):
    return func(n)
 
#tuple
num = (8, 5)
 
ans = caller(called, num)
 
print("Multiplication =", ans)

https://www.delftstack.com/howto/python/python-callback-function/ 

def Func_CallBack(c):
    print("File Length : ", c)
 
 
def File_Len(filepath, callback):
    i = open(filepath, "r")
    file_length = len(i.read())
    i.close()
    callback(file_length)
 
 
if __name__ == "__main__":
    File_Length("randomfile.txt", Func_CallBack)

https://stackoverflow.com/questions/40843039/how-can-i-write-a-simple-callback-function 

def callback(n):
    print("Sum = {}".format(n))
 
def main(a, b, _callback = None):
    print("adding {} + {}".format(a, b))
    if _callback:
        _callback(a+b)
 
main(1, 2, callback)

https://www.ionos.fr/digitalguide/sites-internet/developpement-web/quest-ce-quun-callback/ 

def get_square(val):
    return val ** 2
 
def caller(func, val):
    return func(val)
 
caller(get_square, 5)
2025/03/24 15:06
,

Python - callback

Voir :

Introduction

Exemple d'une fonction sans callback 

#! /usr/bin/env python3
 
from functools import reduce
 
 
def calcfact(i):
    assert i >= 0
    return reduce(lambda a, b: a * b, range(1, i+1) if i > 1 else [1])
 
 
print(calcfact(3))

Exemple de la même fonction avec callback optionnel 

#! /usr/bin/env python3
 
from functools import reduce
 
 
def calcfact_called(i, res):
    print(i, '! = ', res, sep='')
 
 
def calcfact(i, callback=None):
    assert i >= 0
    res = reduce(lambda a, b: a * b, range(1, i+1) if i > 1 else [1])
    if callback is None:
        return res
    else:
        callback(i, res)
 
# Sans Callback
print(calcfact(3))
 
# Avec Callback
calcfact(4, calcfact_called)

Exemple avec async / asyncio / await

#! /usr/bin/env python3
 
import asyncio
 
 
def waitplop_called(i):
    print(i)
 
 
async def waitplop(i, callback=None):
    await asyncio.sleep(i)
    if callback is None:
        return i
    else:
        callback(i)
 
 
async def main():
    async with asyncio.TaskGroup() as tg:
        # Asynchronous with callback
        tg.create_task(waitplop(3, waitplop_called))
        tg.create_task(waitplop(3, waitplop_called))
 
        # Synchronous / sequential without callback
        task1 = await tg.create_task(waitplop(4))
        print(task1)
 
 
asyncio.run(main())
$ time ./plop.py 
3
3
4

real    0m4.120s
user    0m0.095s
sys     0m0.024s
Autre façon de faire un callback avec asyncio

Voir : 

#! /usr/bin/env python3
 
import asyncio
 
 
def waitplop_called(task):
    print(task.result())
 
 
async def waitplop(i):
    await asyncio.sleep(i)
    return i
 
 
async def main():
     task = asyncio.create_task(waitplop(3))
     task.add_done_callback(waitplop_called)
     await asyncio.gather(task)
 
 
asyncio.run(main())

Autres

Voir : 

# Call 'print("Future:", fut)' when "fut" is done.
fut.add_done_callback(
    functools.partial(print, "Future:"))
2025/03/24 15:06
, ,

<< Billets récents | Anciens billets >>

blog.txt · Dernière modification : de 127.0.0.1
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki