Premier programme

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.

• par exemple :

  x = 0
  for i in range(3):
      x = 2 * x
      x = x + 2
  print(x)
      

  donne 14
• alors que :

  x = 0
  for i in range(3):
      x = 2 * x
  x = x + 2
  print(x)
      

  donne 2 car le x = x + 2 n'est pas dans la boucle !

Commentaires : tout ce qui suit un '#' est assimilé à un commentaire et ignoré.

Pour couper les lignes trop longues :

• soit on la coupe entre une paire de parenthèses :

  if (x == 1 or
      x == 2):
      ...
      

• soit on la coupe explicitement par un backslash (nécessaire si pas de coupure à l'intérieur d'une paire de parenthèses) :

  if x == 1 or \
     x == 2:
     ...
      

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 :
  • rajouter dans le .emacs :

    (defun ipython ()
        (interactive)
        (term "/usr/bin/ipython"))
          

  • puis sous emacs, faire M-x ipython

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)