Python est un langage interprété :
- pas d'étape réelle de compilation.
- cependant, quand on utilise des modules, l'interpréteur python génère à partir des fichiers sources .py des fichiers de byte-code .pyc prêts à être exécutés.
- python n'est pas très rapide (car interprété), mais il y a des librairies C disponibles comme numpy qui permettent de faire des programmes en langage python qui sont très rapides et efficaces en terme de mémoire.
Sous linux, faire commencer le programme par :
- #!/usr/bin/python si python est installé à cet endroit (en principe). C'est le "shebang".
- on peut aussi utiliser #!/usr/bin/env python : python est alors cherché automatiquement dans la variable , et ça rend le script indépendant de l'endroit où se trouve réellement python.
Attention : sous python, les espaces en début de ligne sont significatifs (en général par groupes de 4) !!! Ils servent à déterminer les blocs d'instructions.
Commentaires : tout ce qui suit un '#' est assimilé à un commentaire et ignoré.
Pour couper les lignes trop longues :
Pour faire ses premiers essais en python, il est pratique d'utiliser l'interpréteur en interactif pour voir immédiatement le résultat de ce que l'on tape :
- taper simplement python sous le shell.
- on peut alors rentrer directement des commandes et fonctions.
- pour sortir de l'interpréteur, faire quit() ou exit() ou Ctrl-D
ipython, alternative a python interactif :
- il y a la complétion sous ipython.
- sous ipython, pour avoir la liste des variables définies : who.
- whos : donne la liste des variables avec leur type.
Récupération des arguments de la ligne de commande :
- ils sont présents dans la liste sys.argv, avec sys.argv[0] qui est le nom du programme, et donc le premier argument est dans sys.argv[1].
- il faut faire un import sys pour pouvoir l'utiliser.
- en fait pour avoir une gestion évoluée des arguments de la ligne de commande, utiliser le module argparse (chercher argparse sur ce site).
python en ligne de commande :
- python -c 'print(1); print(2);'
- python -c 'import sys; print(sys.argv[1]);' toto (argv[0] est le nom du programme).
- cependant, on est vite limité par l'absence de possiblités d'indentations ...
stdout, stdin, stderr :
- sys.stdout.write() : pour écrire sur stdout (sortie standard).
- print('valeur =', 3) : imprime aussi sur stdout, en convertissant automatiquement ses arguments en chaîne de caractère et en ajoutant un retour à la ligne à la fin.
- sys.stderr.write() : pour écrire sur stderr (sortie d'erreur).
- sys.stdin.readline() : pour lire sur stdin (entrée standard).
- char = sys.stdin.read(1) : pour lire un caractère sur stdin, mais il faut taper return après ce caractère !
Pour inactiver temporairement stderr :
stderrCopy = sys.stderr
sys.stderr = open(os.devnull, 'w')
...
sys.stderr.close()
sys.stderr = stderrCopy
Fonction print :
- print('a', 'b', 3) : par défaut, utilise la sortie standard stdout, le caractère de fin \n et un espace comme séparateur.
- on peut modifier ces défauts : print('a', 'b', 3, sep=',', end='', file = sys.stderr).
Pour éviter le buffering de stdout :
- par défaut, le stdout est bufferisé (c'est à dire que tant qu'on n'a pas imprimé une certaine quantité de caractères, rien ne s'affiche car ils restent dans une mémoire tampon).
- on peut mettre python -u dans le shebang (#!...) (mais ne marche pas avec /usr/bin/env !)
- sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
- ou mettre la variable d'environnement PYTHONUNBUFFERED à une valeur non vide, par exemple 1 : export PYTHONUNBUFFERED=1
- ou alors à chaque impression, faire sys.stdout.flush() pour vider le tampon.
Impression formattée :
- print('%s = %3d' % ('carre', x*x))
- s = 'hello : %.1f world' % (123.456) : "impression" dans une chaîne de caractère (s se voit attribuer la valeur).
Pour sortir d'un programme avec un statut d'erreur 0 (pour indiquer que tout s'est bien passé) : sys.exit(0).
Indention ou désindentation d'un bloc de code avec l'éditeur emacs, pour éviter de le faire ligne par ligne :
- sélectionner le bloc (en allant au début du bloc, mettre la marque avec Ctrl-espace, puis aller à la fin du bloc).
- Ctrl-C > : pour le déplacer tout le bloc vers la droite.
- Ctrl-C < : pour le déplacer tout le bloc vers la gauche.
python et emacs :
- pour démarrer python depuis emacs : M-x python-shell
- pour démarrer ipython depuis emacs :
On peut avoir un fichier de commandes exécutées à chaque invocation interactive de python si l'adresse de ce fichier est contenue dans la variable d'environnement PYTHONSTARTUP
Conventions générales de codage en python :
- utiliser 4 espaces pour les indentations (pas de tabulation).
- ne pas faire des lignes de plus de 79 caractères (mais c'est juste une convention, pas obligatoire).
- utiliser les lignes vides pour séparer les fonctions et les classes.
- mettre les commentaires sur leur propre ligne.
- utiliser des docstrings pour les fonctions.
- utiliser des espaces autour des opérateurs et après les virgules.
- utiliser la convention de majuscules "MyClass" (majuscule au début) pour les classes, my_function pour les fonctions et les méthodes (bien que cela ne soit pas toujours observé ...)
- toujours utiliser le nom de variable self pour le premier argument des méthodes (ça, c'est biens suivi).
Pour avoir dans un programme la version de python utilisée :
- sys.executable : le path du python utilisé.
- sys.version : la version utilisée.
- sys.version_info : donne un tuple comme sys.version_info(major=3, minor=10, micro=10, releaselevel='final', serial=0)
