Documentation

Script python

Exécution
=========
#!/usr/bin/env python
#!/usr/bin/env python3.1

Le fichier a besoin des droits d'exécution (chmod +x fichier.py) pour être lancer sans le nom de l'interpréteur
./fichier.py
/chemin/complet/du/fichier.py

Note windows: si le fichier a l'extension .pyw, alors la fenêtre de console n'affichera pas.

Importation
===========
Importation de fichier (selon sys.path)
> import fichier
/var/lib/python-support/python2.5/fichier.so
ou
/var/lib/python-support/python2.5/fichier/__init__.py
ou
/usr/lib/python2.5/fichier.py
ou
./fichier.py

Importation d'un fichier dans un répertoire
> import repertoire.fichier
/var/lib/python-support/python2.5/repertoire/fichier.py

Importation d'une bibliothèque
> import sys
Il n'y a pas d'aide pour sys.

Importer une classe d'un fichier
> import fichier
> from fichier import ClassName

Importer toutes les fonctions d'un fichier
> from fichier import *

Importer une fonction et la renommer
> from fichier import functionName as aliasName

Note: l'importation de fonction peut se faire à l'intérieur de fonction ou de méthodes de classes 

Commentaires
============
# tout ce qui est à droite du dièse sur cette ligne


Constantes
==========
Le principe n'existe pas (ce sont des variables), mais elles sont nommés en majuscule habituellement.
BLA="string"


Variables
=========
foo=1      # assigner l'entier 1 à la variable qui se nomme foo
bar = "1"  # assigner une chaîne de caractère (string)
foobar           = "1"
x = y = z = 1 # assigner trois variables en même temps l'entier 1
x,y = 1,2     # assigner 1 à x et 2 à y

Nombre:

...,-1,0,1,...

...,-1.1,0.0,1.1,....

1j,1J,complex(0, 1) : nombre imaginaire i
3+1j*3 = 3+3j
(3+1j)*3 = (9+3j)

z=1j
print (z.real) # give 0.0
print (z.imag) # give 1.0

Chaînes:
"chaine"
'chaine'
"chaine \"double-quote\"!"
'chaine \'single-quote\'!'

"multiline\
yes multiline\
sure"

"""
triple double-quote
don't need extra slash
or \n
"""

'''
triple single-quote
don't need extra slash
or \n
'''

raw string [aucune conversion]:
r"bla\n\
test"

Unicode:
'Hello\u0020World !' # \u code hexadécimal à 4 chiffres

Bytes:
 Retournés par string.encode()


Listes:
-------
# Déclaration
a = []
b = [1,2,3,"a","b"]

# Accès
b[1]
[1,[2,3],4][1,0] # donne le premier élément du second élément, 2

# Modification
b[1] = 4
b[0:2] = [1,2]

# Suppression
b[0:2] = []
a[:] = []

Dictionnaire
------------
a = (1,2,3)

Fonctions
=========
Déclaration d'une fonction vide (à redéfinir):
nomFonction = lambda x: x

def nomFonction(*args):
  pass

Affectation d'une fonction lambda:
nomFonction = nomFonction2

Définition:
def nomFonction (param):
    global nomVariableGlobale
    global nomFonctionLambda
    
    # retour non obligatoire
    return 1

# définition de paramètres optionnels (avec valeur par défaut)
def nomFonction (param1, param2='valeur1', param3='valeur3'):
  instructions

# la valeur du paramètre optionnel n'est évalué qu'une seule fois et n'est pas remis à zéro
# une liste ou un objet seront modifiés

# exemple: a sera modifié à chaque appel nomFonction()
def nomFonction(a=[]):
  a.append(1)

# note: une fonction qui ne retourne rien, retourne la valeur None
# note: on peut utilisé les noms des arguments lors de l'appel
#       nomFonction(param3='bla', param1='a')

# *args : tuple des paramètres sans nom
def maFonctionArgs(*args, sep=","): # des paramètres optionels avec nom peuvent être présent après *args
  print(sep.join(args))

# **args : dictionnaire des paramètres avec nom (mais non spécifié)
def maFonction(*bla, **foo):
  for a in bla:
    print(a, end=' ')
  for b in foo: # b est la clé, foo[b] est la valeur
    print(b, end=' ')

# maFonction("9", "8", "7", a="1", b="2", c="3") # affiche 9 8 7 a b c


Conditions
==========
if condition: instruction

if condition:
  instruction1
  instruction2

if condition:
  instruction1
  if condition2:
    instruction2
  if condition3:
    instruction3:
  instruction4

if condition1:
  instruction1
elif condition2:
  instruction2
elif condition3:
  instruction3
else:
  instruction4

Exemples:
if var != None: 
    print 1

if (string.endsWith("bla") or 
    string.endsWith("foo")):
    print 1
elif string.endsWith("test"):
    print 2
else:
    print 3
    
if a > 1 and a < 10:
    print a


Opérateurs
==========
Logique
-------
and   # et logique
or    # ou logique

Mathématique
------------
+     # addition d'entier ou de nombre à virgule
-     # soustraction d'entier ou de nombre à virgule
*     # multiplication d'entier ou de nombre à virgule
/     # division d'entier ou de nombre à virgule (virgule non perdue 1/3 = 0.3333333333333333, 0.3333333333333333*3 = 1.0)
//    # division, garde l'entier seulement (1//3 = 0), il s'agit de la fonction plancher math.floor(1/3)
+     # addition d'entier ou de nombre à virgule
%     # module (reste de la division) 11%3 = 2, car 11 = (3*3) + 2.
<     # plus petit que
>     # plus grand que

Chaîne
------
"a" + "b"   # concaténation de chaîne (donne "ab")
"a" + "b" + "c"   # concaténation de chaîne (donne "abc")
"a" "b"   # concaténation de chaîne (donne "ab")
"a" "b" "c"  # concaténation de chaîne (donne "abc")
"a" * 5     # répétition de chaîne  (donne "aaaaa")
"a" in ("a", "b", "c") # test si "a" est dans la liste (retourne True/False)

"abc"[0]  # donne le premier caractère "a"
"abc"[0:2]  # donne les deux caractères à partir de l'index 0 (a) "ab"
"abc"[:2]   # même chose
"abcd"[2:]   # donne "cd", index 2 (c) et tout ce qui est après.
"abc"[-3]  # donne le troisième caractère en partant de la fin, c (-1), b (-2), a (-3).

List
# Coupure
[1,2,3,4][:1]
[1,2,3,4][1:-1]
[1,2,3,4][1:]

[1,2] + [3,4] # [1,2,3,4] concaténation de liste
a = list[:]   # copie d'une variable nommé "list" dans a

Tests
=====
if False:   #  est faux
if 0:       #  est faux
if "":      #  est faux
if []:      #  est faux
if None:    #  est faux

if True:    #  est vrai
if 1:       #  est vrai
if -1:      #  est vrai
if "0":     #  est vrai
if [0]:     #  est vrai

Boucles
=======
while condition:
  instruction1
  instruction2

while condition:
  pass # retourne à la condition immédiatement (pour recommencer la boucle, instruction1 n'est pas appelé)
  instruction1

for x in list: 
  print(x) # affiche chaque item

for x in range:
  print(x) # affiche chaque élément de l'objet range

for x in string:
  print(x) # affiche chaque caractère

# note: que la liste ne doit pas être changé... utilisé une copie list[:] si le besoin est là


Formatage
=========
"Bla bla bla %s %d %s" % ("allo", 5, "toi")


Exceptions
==========
try:
  bla = "test %s" % None
except TypeError:
  print ("Missing '%s')
  pass

try:
  n
except NameError:
  print ("n is not declared")

try:
  a = { "test1": 1, "test2": 3 };
  b = a["test3"]
except KeyError:
  print ("Bad key when getting b")
except e:
  print ("e is the special exception object")
   
Lever une exception
raise IOError(string message)

Classes
=======
Déclaration d'une classe:

class NomClasse:
    NOMCONSTANTE1=1
    NOMCONSTANTE2=2
    NOMCONSTANTE3="bla"
    
    NOMCONSTANTE4={
        cle="bla",
        cle="bla2"
        }
    # accessible via self.NOMCONSTANTE3[cle]
    
    # constructeur (self = la classe)
    def __init__(self):
        self.bla = 1  # initialisation de la variable interne bla
    
    # constructeur avec 2 arguments
    def __init__(self, arg1, arg2):
        self.bla = arg1

    # test d'égalité ==
    def __cmp__(self, other)
        # return -1 0 or 1  (if other is None, return 1)
        # you can return the cmp(self.arg, other.arg)        

# classe vide sans rien à l'intérieur
class ClasseVide:
  pass


Héritage
========
# Le nom de la classe parente peut contenir des points (dbus.service.Object utilisera $PATH/dbus/service.py: classe Object)
class NomClasse(NomClasseParente): 
    def __init__(self):
        NomClasseParente.__init__(self, ...)    


Externe
=======
Ligne de commande:
 sys.argv (de type list)
 sys.argv[0]  (premier argument après le nom de commande/script, "" si aucun argument)
              (ou -c si -c command est utilisé)
              (ou chemin complet du module si -m module est utilisé)

Variable d'environnement:
 import os
 string = os.environ['NOM_VARIABLE']
 string = os.environ.get('NOM_VARIABLE2')

Entrée/sortie:
  print([string chaine], ...) # affiche une chaîne à la sortie standard avec un changement de ligne
  print("a",1)  # affiche "a 1" (avec des espaces et un changement de ligne)
  print("a",1,2,3) # affiche "a 1 2 3"
  print("a", end=' ') # affiche "a" avec un espace (sans changement de ligne)
  print(list liste) # affiche [element1, element2, element3] de la liste
  string input([string prompt]) # demande une chaîne de caractère sur une ligne (entrée standard). affiche prompt si spécifié


Fichiers:
 # détecter si un chemin complet est un fichier (/etc/passwd)
 os.path.isfile(string filename)

 # ouvrir un fichier
 file = open(string filename)

 # lire un fichier
 string = file.read()

Python:
 Exécuter des commandes
 exec(string commands)

Chaines:
int len(string chaine)  # nombre de caractères

Encodage:
bytes string.encode(string charset)
bytes string.encode('utf-8')
bytes string.encode('iso-8859-1')

Liste:
int len(list liste) # nombre d'éléments d'une liste
list.append(mixed item)   # ajoute un item à la fin d'une liste
list.insert(integer pos, mixed item)   # ajoute un item à la position "pos"
list sorted(list list) # retourne la liste triée

Range:
range range(integer n) # retourne un "range" de 1 à n
range range(integer min, integer max) # retourne un "range" de min à max-1
range range(integer min, integer max, integer step) # retourne un "range" de min à max-1 (avec un bon de -3)
list list(range r)  # convertit un range en liste

Dictionnaire:
dict.keys() # retourne une liste des clés du dictionnaire

Math
====
abs(-1)            # donne 1
abs(complex(3,4))  # donne 5.0 (magnitude, math.sqrt(3^2+4^2))
round(113.111,2)   # donne 113.11
round(-113.111,2)   # donne 113.11