Fonctions

Définition d'une fonction :

def myFunc(n):
	print(n)
	return 1
  

Documentation d'une fonction : mettre la chaîne de documentation en première ligne du corps :

• def myFunc(n):
  	"""Chaine de documentation."""
  	print(n)
      

• La première ligne doit commencer par une majuscule et terminer par un point, et être la description générale de la fonction.
• on peut ensuite ajouter des détails e n sautant une ligne, et alors les triples quotes sont vraiment indispensables !

  def myFunc(n):
  	"""Chaine de documentation.
  
  	   et des précisions sur la documentation,
  	   avec encore une troisième ligne"""
  
  	print(n)
      

Les paramètres sont passés par valeur (mais c'est la référence qui est passée par valeur quand c'est une variable de type liste ou dictionnaire ou tuple).

Par défaut, les variables d'une fonction sont locales :

• on ne peut pas accéder à la valeur d'une variable locale avant de l'avoir initialisée (n'est pas initialisée à None par défaut !).
• on ne peut pas modifier une variable globale, mais on peut par contre la lire (dans une fonction, la variable est cherchée successivement dans la table des symboles locale, puis globale, puis built-in)

Valeur de retour d'une fonction :

• une fonction peut renvoyer un argument avec return.
• une fonction qui n'a pas de return ou un return sans valeur renvoie None.
• une fonction peut renvoyer un tuple qui est récupéré dans plusieurs variables à condition que le nombre de variables matche le nombre de valeurs du tuple :

  def myFunc():
      return (1, 'a')
  
  (x, y) = myFunc() # valide
  (x, y, z) = myFunc() # invalide
      

• convention lorsqu'on veut récupérer seulement certains arguments de retour d'une fonction qui renvoie une liste ou un tuple : on utilise '_' pour ceux qu'on ne veut pas récupérer (mais c'est seulement une convention). Par exemple : x, _, y, _ = myFunction()

On peut definir une fonction avec des valeurs par défaut :

• def myFunc(a, b = 4):
• on peut alors appeler myFunc(0, 1) ou myFunc(0)

Attention aux valeurs par défaut mutables !

• la valeur par défaut n'est évaluée qu'une seule fois !

• def f(x, y = []):
      y.append('a')
      print(y)
  f(1); f(2); f(3)
      

  imprime

  ['a']
  ['a', 'a']
  ['a', 'a', 'a']
      

• si on ne veut pas ce comportement, mettre une valeur par défaut à None, et fixer la valeur dans la fonction si la valeur vaut None.
• en bref, éviter les objets mutables comme valeurs par défaut dans la définition d'une fonction !

On peut appeler une fonction avec des arguments précisés par nom :

def myFunc(a, b = 4):
...
myFunc(a = 1, b = 5)
myFunc(a = 2)
  

Les arguments par défaut sont évalués dans le scope de la définition :

a = 3
def myFunc(x = a):
    print(x)
a = 4
myFunc()
  

va imprimer 3 et non 4 !

Avec la formulation **, l'argument recoit le dictionnaire de tous les arguments précisés par nom :

def myFunc(**args):
	for kw in args.keys():
		print(kw, ':', args[kw])
  

Avec la formulation *, l'argument reçoit le tuple de tous les arguments :

def myFunc(*args):
	for kw in args:
		print(kw)
  

On peut mélanger tout cela :

def myFunc(a, *b, **c):
    print(a)
    print(b)
    print(c)

myFunc(4, 5, 7, x = 4, y = 8)
  

imprime :

4
(5, 7)
{'titi': 8, 'toto': 4}
  

Unpacking :

• si fonction définie par :

  def myFunc(**args):
  	for kw in args.keys():
  		print(kw, ':', args[kw])
      

  on peut l'appeler avec myFunc(**{'a' = 3, 'b' = 4}).
• si fonction définie par :

  def myFunc(a, b):
  	return a + b
      

  on peut aussi l'appeler avec myFunc(**{'a' = 3, 'b' = 4}) ou également myFunc(*[3, 4]) ou même myFunc(*(3, 4)).

lambda function (fonction anonyme) : lambda x, y: x * y

Variable statique dans une fonction, qui garde la mémoire entre 2 appels :

• on peut définir une variable statique dans une fonction, par exemple :

  def myFunc(a):
      if getattr(myFunc, 'myVar', None) is None:
          # initialisation au premier appel
          myFunc.myVar = 0
      myFunc.myVar += a
      print(myFunc.myVar)
  
  myFunc(1) # affiche 1
  myFunc(2) # affiche 3
      

Une fonction peut être stockée dans une variable avant d'être utilisée :

def myFunc(x):
    return x + 1

f = myFunc
print(f(3)) # donne 4
  

Si myFunc est une fonction définie :

• myFunc.__name__ renvoie son nom : myFunc
• si on met cette fonction dans une autre variable : myFunc2 = myFunc, myFunc2.__name__ renvoie myFunc

On peut définir une fonction à l'intérieur d'une fonction, pour que la fonction englobante retourne une fonction :

def buildMyFunc(a):
    def myFunc(x):
        return a * x
    return myFunc

f = buildMyFunc(2)
f(3) # renvoie 6
  

Test si un attribut est une fonction (ou méthode) : callable(myMeth) : renvoie True si myMeth est une fonction ou méthode, False sinon.

Appel des attributs par nom :

• hasattr(myObj, myField) renvoie True si l'objet a le champ défini, False sinon.
• callable(myMeth) : renvoie True si myMeth est une fonction ou méthode.
• appel d'une méthode par son nom sur un objet : l = [6, 3, 5, 1, 9]; getattr(l, 'sort')() : tri la liste en appliquant la méthode sort.
• pour fixer la valeur d'un champ : setattr(myObj, 'myField', 35)

abs(-2) : valeur absolue du nombre.

Il n'y a pas de fonction standard sign en python pour avoir le signe d'un nombre !

• on peut cependant en créer une facilement : sign = lambda x: (x > 0) - (x < 0). Alors :
  • sign(2) : donne 1.
  • sign(-2) : donne -1.
  • sign(0) : donne 0.
• ou alors, on peut utiliser numpy.sign(2), une fonction du package numpy (qui renvoie un int64 ou float64).