{{tag>Brouillon Python}}

= Python cours formation

<code ->
>>> 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!
</code>

Voir :
* PEP 8
* pep257

Formations : 
* https://github.com/la415/epub-python
* https://www.orsys.fr/formation-python-programmation-objet.html
* https://www.humancoders.com/formations/python
* https://www.humancoders.com/formations/python-avance
* https://makina-corpus.com/formations/formation-python-initiation
* https://www.nouvelleviepro.fr/formation/fiche/formation-python-paris/3085
* https://www.apollo-formation.com/informatique/langages-de-developpement/python/python.html

Apprendre en ligne
* http://www.jaicompris.com/python.php (les bases)
* https://www.lemondeinformatique.fr/actualites/lire-2-mooc-axes-python-ia-et-datavisualisation-81195.html
* https://www.welcometothejungle.com/fr/articles/meilleures-formations-pour-apprendre-a-coder

Bases :
  * https://scouv.lisn.upsaclay.fr/python-memento/index.fr.html
  * [[http://www.xavierdupre.fr/app/teachpyx/helpsphinx/c_lang/types.html|Types et variables du langage python]]
  * Listes / tuples : https://www.askpython.com/python/list/python-list-of-tuples https://www.tutorialspoint.com/convert-a-list-into-a-tuple-in-python http://olivierschmitt.fr/python-les-listes-et-tuples/
  * Itérateurs
  * Générateurs
  * Décorateurs
  * Web framework : Django, Flask, Pyramid, connexion, hug
  * Parsing : ElementTree (XML), Yaml, Json
  * Science : [[https://numpy.org/|Numpy]], Scipy, Pandas, matplotlib
  * Introspection : (dir, help) module inspect ''from inspect import getsource''
  * Boucle : émuler un switch_case, compression liste
  * Mots clefs et fonctions utiles : with, any, all...
  * Programmation fonctionnelle : lambda, map, filter, reduce, itertools.filterfalse
  * Fonction Lambda https://www.codeflow.site/fr/article/python-lambda
  * Script système : sys os platform syslog
  * Fonction : Arguments par défaut, ''*args'' et ''**kwargs''
  * émuler un switch_case
  * Complexité et preuves algorithmiques
  * Base de données ORM
  * Design Patterns [[https://www.toptal.com/python/python-design-patterns]] https://karczmarczuk.users.greyc.fr/TEACH/PyObj/Design.html

Avancé :
  * Solutions d'optimisation
  * Interfaçage avec C / C++ [[https://www.swig.org/tutorial.html|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 :
  * https://linuxfr.org/news/python-partie-9-formateur-de-code-analyse-statique
* 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:
* [[https://github.com/trananhkma/fucking-awesome-python|Awesome-python]]


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 :
* gestion de fichiers
* argparse
* logging (Gestion des logs avec Python) https://code.tutsplus.com/fr/tutorials/error-handling-logging-in-python--cms-27932
* configparser
* os
* sys
* sh
* subprocess (shell, bash, commands) voir https://www.redhat.com/sysadmin/python-subprocess-module ou ''ptyprocess''
* re (expressions rationnelles)

Docker / Containers :
* [[https://developers.redhat.com/articles/2023/09/05/beginners-guide-python-containers|A beginner's guide to Python containers]]

Aller plus loin
Présentation des objets et fonctions avancés
* context managers (with) https://www.geeksforgeeks.org/context-manager-in-python/ https://stackabuse.com/python-context-managers/ 
* documenter avec sphinx
* Packager une application en Python
* Créer des tests unitaires dans son application : pytest, Testinfra, hypothesis, unittest, docstests


== Les fonctions

<code python>
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
</code>


== Import 

<code python>
import os
import sys
sys.path.append(os.path.dirname(os.getcwd()))

import plop
</code>

== Sciences - math

<code python>
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]
</code>



== Mutable / immutable

Voir aussi : deepcopy

<code python>
lst=[1,2,3];
print(list(map(lambda x: [x],lst)));
</code>


== Autres

<code python>
import random
random.randint(1,9)
</code>

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

== Linter

=== Flake8

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

Pour ignorer l'erreur

''tox.ini''
<code ini>
[flake8]
extend-ignore = E501
</code>



== Autres

<code bash>
$ 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
</code>