Explication détaillée des fonctions en Python

Les fonctions en Python, qu'elles soient nommées ou anonymes, sont des collections d'instructions et d'expressions. En Python, les fonctions sont les objets de première classe, ce qui signifie qu'il n'y a aucune restriction sur la façon dont elles peuvent être utilisées. Les fonctions Python sont utilisées comme les autres valeurs en Python, telles que les chaînes et les nombres. Les fonctions Python ont certains attributs, qui peuvent être visualisés à l'aide du répertoire de fonctions intégré Python, comme indiqué dans le code suivant :

Python

1 2 3 4 5 6 7 8

déf carré (x):  retour x**2 >> > carré <fonction carré à 0x031AA230> >>> dir(carré) ['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', ' __init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__' , '__subclasshook__', 'func_closure' , 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name'] >>> ;

Parmi eux, certains attributs de fonction importants sont les suivants :

1 __doc__ renvoie la chaîne de documentation de la fonction spécifiée.

Python

1

1 2 3 4 5 6

def square(x):     """return square of given number"""     return x**2   >>> square.__doc__ 'return square of given number'

2

3

4

5

6

def carré(x):

 """carré de retour du nombre donné"""

 retour x**2

>>> carré.__doc__

'carré de retour d'un nombre donné'

2. __name__返回函数名字。

Python

def carré(x) :

    """carré de retour du nombre donné"""

    retour x**2

 

>>> carré.func_nom

'carré'

1

1 2 3 4 5 6

def square(x):     """return square of given number"""     return x**2   >>> square.func_name 'square'

2

3

4

5

6

3. __module__返回函数定义所在模块的名字。

Python

1

1 2 3 4 5 6

def square(x):     """return square of given number"""     return x**2   >>> square.__module__ '__main__'

2

3

4

5

6

def carré(x) :

    """carré de retour du nombre donné"""

    retour x**2

 

>>> carré.__module__

'__main__'

4. func_defaults renvoie un tuple contenant les valeurs de paramètres par défaut. Les paramètres par défaut seront discutés plus tard.

5. func_globals renvoie une référence de dictionnaire contenant des variables globales de fonction.

Python

1

1 2 3 4 5 6

def square(x):     """return square of given number"""     return x**2   >>> square.func_globals {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', 'square': <function square at 0x10f099c08>, '__doc__': None, '__package__': None}

2

3

4

5

6

def carré(x):

 """carré de retour du nombre donné"""

 retour x**2

>>> carré.func_globaux

{' __builtins__' : <<🎜>module<🎜> <🎜>'__builtin__'<🎜> <🎜>(<🎜>construit<🎜>-<🎜>in<🎜>)<🎜>>, '__name__': '__main__', 'carré' : <<🎜>fonction <🎜>carré <🎜>à<🎜 > <🎜>0x10f099c08<🎜>>, '__doc__': Aucun, '__package__' : Aucun}

6. func_dict返回支持任意函数属性的命名空间。

Python

1

1 2 3 4 5 6

def square(x):     """return square of given number"""     return x**2   >>> square.func_dict {}

2

3

4

5

6

def carré(x) :

    """carré de retour du nombre donné"""

    retour x**2

 

>>> carré.func_dict

{}

7. func_closure renvoie un tuple de corps de cellule, où le corps de cellule contient la liaison des variables libres de fonction. La fermeture sera discutée plus tard.

Les fonctions peuvent être transmises comme arguments à d'autres fonctions. Ces fonctions qui prennent d’autres fonctions comme arguments sont souvent appelées fonctions d’ordre supérieur et constituent une partie très importante de la programmation fonctionnelle. Un bon exemple de fonction d'ordre supérieur est la fonction map, qui prend une fonction et un itérateur comme arguments, applique la fonction à chaque élément de l'itérateur et renvoie une nouvelle liste. Nous allons le démontrer dans l'exemple suivant, où la fonction carrée définie précédemment et un itérateur numérique sont transmis à la fonction map.

Python

1

1 2	>>> map(square, range(10)) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

2

>>> carte(carré, plage(10 ))

[0, 1, 4, 9 , 16, 25, 36, 49, 64, 81]

De plus, les fonctions peuvent également être définies dans d'autres blocs de code de fonction et peuvent également être renvoyées à partir d'autres appels de fonction.

Python

1

1 2 3 4 5

def outer():     outer_var = "outer variable"     def inner():         return outer_var     return inner

2

3

4

5

def extérieur() :

 outer_var = "variable externe"

 def intérieur() :

 retour outer_var

 retour intérieur

Dans l'exemple ci-dessus, nous définissons une autre fonction interne à l'intérieur de la fonction externe, et lorsque la fonction externe est exécutée, la fonction interne sera renvoyée. De plus, comme tout autre objet Python, les fonctions peuvent également être affectées à des variables, comme ceci :

Python

1

1 2 3 4 5 6 7 8 9 10

def outer():     outer_var = "outer variable"     def inner():         return outer_var     return inner   >>> func = outer() >>> func <function inner at 0x031AA270> >>>

2

3

4

5

6

7

8

9

10

def extérieur () : outer_var = "variable externe" def intérieur():

 retour var_outer

retour intérieur

>>> func = extérieur( )

>>> func

<<🎜>fonction <🎜>intérieur <🎜>à<🎜> <🎜 > 0x031AA270<🎜>>

>>>

Dans l'exemple ci-dessus, lorsque la fonction externe est appelée, elle renverra une fonction et affectera la fonction renvoyée à la variable func. Enfin, la variable peut être appelée tout comme la fonction renvoyée :

Python

tbody>

1

1 2	>>> func() 'outer variable'

2

>>>

func

(

)

'variable externe'

Définition de fonction

Le mot-clé def est utilisé pour créer des fonctions définies par l'utilisateur. Les définitions de fonctions sont des instructions exécutables.

1 2	def square(x):     return x**2

Python

1 2	def carré(x) :  retour x**2

Dans la fonction carrée ci-dessus, lorsque le module contenant la fonction est chargé dans l'interpréteur Python, ou si la fonction est définie dans le REPL Python, l'instruction de définition de fonction sera exécutée def carré(x). Cependant, cela a certaines implications pour les paramètres par défaut avec des structures de données mutables comme valeurs, que nous aborderons plus tard. L'exécution de la définition de fonction liera le nom de la fonction dans l'espace de noms local actuel (l'espace de noms peut être considéré comme un mappage du nom à la valeur, et ce mappage peut également être imbriqué. Les espaces de noms et les portées seront détaillés dans un autre didacticiel) Introduit) à un objet fonction, qui est un wrapper autour du code exécutable dans une fonction. Cet objet fonction contient une référence à l'espace de noms global actuel, qui fait référence à l'espace de noms global utilisé lors de l'appel de la fonction. De plus, la définition de fonction n'exécute pas le corps de la fonction, qui ne s'exécute que lorsque la fonction est appelée.

Paramètres d'appel de fonction

En plus des paramètres normaux, les fonctions Python prennent également en charge un nombre variable de paramètres. Ces paramètres se répartissent principalement en trois catégories décrites ci-dessous :

1. Valeurs des paramètres par défaut : Cela permet à l'utilisateur de définir certaines valeurs par défaut pour les paramètres de la fonction. Dans ce cas, la fonction peut être appelée avec moins d'arguments. Pour les arguments non fournis lors de l'appel de la fonction, Python utilisera les valeurs fournies par défaut comme valeurs d'argument. L'exemple suivant illustre cette utilisation :

Python

1

1 2	def show_args(arg, def_arg=1, def_arg2=2):       return "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg, def_arg2)

2

def show_args(arg, def_arg=1, def_arg2=2) :

 retour "arg={}, def_arg={}, def_arg2={}". format(arg, def_arg, def_arg2)

La définition de l'exemple de fonction ci-dessus contient un paramètre de position normale arg et deux paramètres par défaut def_arg et def_arg2. Cette fonction peut être appelée de l'une des manières suivantes :

(1) Seules les valeurs de paramètres de position autres que celles par défaut sont fournies. Dans cet exemple, les paramètres par défaut prennent les valeurs par défaut :

Python

1

1 2 3 4 5

def show_args(arg, def_arg=1, def_arg2=2):       return "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg, def_arg2)     >>> show_args("tranquility")   'arg=tranquility, def_arg=1, def_arg2=2'

2

3

4

5

def show_args(arg, def_arg=1, def_arg2=2) :

 retour "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg, def_arg2)

>> ;> show_args("tranquillité")

'arg=tranquilité, def_arg=1, def_arg2=2'

(2) Remplacez certaines valeurs de paramètres par défaut par les valeurs fournies, y compris les paramètres de position non par défaut :

Python

1

1 2 3 4 5

def show_args(arg, def_arg=1, def_arg2=2):       return "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg, def_arg2)     >>> show_args("tranquility", "to Houston")   'arg=tranquility, def_arg=to Houston, def_arg2=2'

2

3

4

5

def show_args(arg, def_arg =1, def_arg2=2):

 retour "arg={}, def_arg ={}, def_arg2={}".format (arg, def_arg, def_arg2 )

>>> show_args("tranquillité", "vers Houston")

'arg=tranquilité, def_arg=à Houston, def_arg2=2'

(3) Fournissez des valeurs pour tous les paramètres, qui peuvent être utilisées pour remplacer les valeurs des paramètres par défaut :

Python

1

1 2 3 4 5

def show_args(arg, def_arg=1, def_arg2=2):       return "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg, def_arg2)      >>> show_args("tranquility", "to Houston", "the eagle has landed") 'arg=tranquility, def_arg=to Houston, def_arg2=the eagle has landed'

2

3

4

5

def show_args(arg, def_arg=1, def_arg2=2) :

retour "arg={}, def_arg={} , def_arg2={}".format(arg, def_arg, def_arg2)

>>> show_args("tranquillité", "à Houston", "l'aigle a atterri")

'arg=tranquillité, def_arg=à Houston, def_arg2=l'aigle a atterri'

Des précautions particulières doivent être prises lors de l'utilisation de structures de données par défaut mutables comme paramètres par défaut. Étant donné que la définition de la fonction n'est exécutée qu'une seule fois, ces structures de données mutables (valeurs de référence) ne sont créées qu'une seule fois lorsque la fonction est définie. Cela signifie que la même structure de données mutable sera utilisée pour tous les appels de fonction, comme indiqué dans l'exemple suivant :

Python

def show_args_using_mutable_defaults(arg, def_arg=[]) :

-v">def_arg.append( "Bonjour tout le monde")

 retour "arg={}, def_arg={}".format( arg, def_arg)

>>> show_args_using_mutable_defaults("test")

"arg=test, def_arg =['Hello World']"

>>> show_args_using_mutable_defaults( "test 2")

"arg=test 2, def_arg=['Hello World', 'Hello World' ]"

1

1 2 3 4 5 6 7 8

def show_args_using_mutable_defaults(arg, def_arg=[]):       def_arg.append("Hello World")       return "arg={}, def_arg={}".format(arg, def_arg)     >>> show_args_using_mutable_defaults("test")   "arg=test, def_arg=['Hello World']"   >>> show_args_using_mutable_defaults("test 2")   "arg=test 2, def_arg=['Hello World', 'Hello World']"

2

3

4

5

6

7

8

Dans chaque appel de fonction, "Hello World" est ajouté à la liste def_arg Après avoir appelé la fonction deux fois, il y aura deux caractères "Hello World" dans l'argument par défaut. Ceci est important à noter lors de l’utilisation de paramètres par défaut variadiques comme valeurs par défaut. Les raisons de cela deviendront claires lorsque nous discuterons du modèle de données Python.

2. Paramètres de mots-clés : Vous pouvez également appeler des fonctions en utilisant des paramètres de mots-clés sous la forme "kwarg=value". Parmi eux, kwarg fait référence au nom du paramètre utilisé dans la définition de la fonction. Prenons comme exemple la fonction définie ci-dessous avec des paramètres par défaut et autres que ceux par défaut :

Python

1

1 2	def show_args(arg, def_arg=1):        return "arg={}, def_arg={}".format(arg, def_arg)

2

def show_args(arg, def_arg= 1) :

 retour "arg={}, def_arg={}".format(arg, def_arg)

Pour démontrer l'appel d'une fonction à l'aide d'arguments de mots-clés, la fonction suivante peut être appelée de l'une des manières suivantes :

Python

tableau>

1

1	show_args(arg="test", def_arg=3)

show_args

( arg=

"test"

, def_arg

=

3

)

1	show_args(test)

Python

1	show_args(test)

Python

1

1	show_args(arg="test")

show_args

(arg=

"test"

)

1	show_args("test", 3)

Python

1	show_args("test", 3 )

Dans un appel de fonction, les arguments de mot-clé ne doivent pas précéder les arguments non-mot-clé, donc l'appel suivant échouera :

Python

1

1	show_args(def_arg=4)

show_args

( def_arg

=

4)

La fonction ne peut pas fournir de doublons pour un argument valeur, donc la méthode d'appel suivante est illégale :

1	show_args("test", arg="testing")

Python

Dans l'exemple ci-dessus, le paramètre arg est un paramètre positionnel, donc la valeur "test" lui sera attribuée. Et essayer de l'attribuer à nouveau au mot-clé arg signifie essayer une affectation multiple, ce qui est illégal.

Tous les paramètres de mots-clés transmis doivent correspondre aux paramètres acceptés par une fonction, et l'ordre des mots-clés contenant des paramètres non facultatifs n'est pas important, donc l'écriture suivante avec l'ordre des paramètres inversé est légale :

Python

1	show_args("test", arg= "tests")

1

1	show_args(def_arg="testing", arg="test")

show_args (def_arg="tests", arg ="test")

3. Liste de paramètres arbitraires : Python prend également en charge la définition d'une telle fonction, qui peut accepter n'importe quel nombre de paramètres passés sous forme de tuples, tutoriel Python Un exemple. de ceci ressemble à ceci :

Python

1

1 2	def write_multiple_items(file, separator, *args):     file.write(separator.join(args))

2

def write_multiple_items(fichier, séparateur, *args) :

fichier.écrire(séparateur.rejoindre (args))

N'importe quel nombre d'arguments doit suivre les arguments normaux. Dans cet exemple, un nombre illimité de paramètres existent après le fichier de paramètres et le séparateur. Voici un exemple d'appel de la fonction définie ci-dessus :

Python

1

1 2	f = open("test.txt", "wb") write_multiple_items(f, " ", "one", "two", "three", "four", "five")

2

f = ouvrir( "test.txt", "wb")

write_multiple_items(f, " ", "un", "deux", "trois", "quatre", "cinq")

Les paramètres ci-dessus un, deux, trois, quatre et cinq sont regroupés pour former un tuple, accessible via le paramètre args.

Décompresser les paramètres de fonction

Parfois, les paramètres d'un appel de fonction peuvent exister sous la forme de tuples, de listes ou de dictionnaires. Ces paramètres peuvent être décompressés dans la fonction pour être invoqués à l'aide des opérateurs "*" ou "**". Prenons l'exemple de la fonction suivante. Cette fonction accepte deux paramètres de position et imprime les valeurs des deux paramètres.

Python

1

1 2 3

def print_args(a, b):     print a     print b

2

3

def print_args(a, b) :

 imprimer a

 imprimer b

Si les valeurs des paramètres fournies à la fonction sont sous forme de liste, alors nous pouvons décompresser ces valeurs directement dans la fonction, comme suit :

Python

corps >

1

1 2 3 4

>>> args = [1, 2] >>> print_args(*args) 1 2

2

3

4

>> > ; args = [1 , 2 ]

>>> print_args(*args)

1

2

De même, lorsque nous avons des mots-clés, nous pouvons utiliser un dictionnaire pour stocker la relation de mappage de kwarg à valeur, et utiliser l'opérateur "**" pour décompresser les paramètres du mot-clé dans la fonction. , comme suit :

Python

1 2 3 4 5 6 7 8

>>> def perroquet (tension, état='a raide', action='voom'):    imprimer "-- Ce perroquet ne le ferait pas" , action,  imprimer "si tu mets", tension, "volts à travers.",                                        🎜>, état, "!" >>> d = {"tension": "quatre millions", "état" : "sanglanté", "action " : "VOOM"} >>> perroquet(**d) >>> Ce perroquet ne't VOOM si vous mettez quatre millions volts à travers il. E's saignement' décédé

利用“*”和“**”定义函数

有时候，当定义一个函数时，我们之前可能不知道参数的数量。这就导致了下面签名的函数定义：

Python

1

1	show_args(arg, *args, **kwargs)

show_args(arg, *args, **kwargs)

Le paramètre "*args" représente la longueur de séquence de paramètres de position inconnue, tandis que "**kwargs" représente un dictionnaire contenant des relations de mappage de mots-clés et de valeurs, qui peuvent contenir n'importe quel nombre de mots-clés et mappage de valeurs et "*args" doit précéder "**kwargs" dans la définition de la fonction. Le code suivant illustre cette situation :

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

déf show_args(arg, *args , **kwargs):  imprimer arg  pour article dans args :            >imprimer arguments   pour clé , valeur en kwargs :   imprimer clé, valeur >>> arguments = [1, 2, 3, 4] >>> kwargs = dict(nom='test', âge=24, année=2014) > ;>> show_args("hé", *arguments, **kwargs) hé 1 2 3 4 âge 24 nom test année 2014

Les paramètres normaux doivent être fournis à la fonction, mais "*args" et "**kwargs" sont facultatifs, comme indiqué ci-dessous :

Python

1

1 2	>>> show_args("hey", *args, **kwargs) hey

2

>>> show_args("hé", *args, **kwargs)

hé

Dans les appels de fonction, les paramètres ordinaires sont fournis de la manière normale, tandis que les paramètres facultatifs peuvent être atteints dans l'appel de fonction sous forme décompressée.

Fonctions anonymes

Python prend également en charge les fonctions anonymes, qui sont créées à l'aide du mot-clé lambda. La forme d'une expression Lambda en Python est la suivante :

Python

corps >

1

1	lambda_expr ::=  "lambda" [parameter_list]: expression

lambda_expr ::= "lambda" [parameter_list] : expression

Une expression Lambda renvoie un objet fonction évalué et possède les mêmes propriétés que la fonction nommée. En Python, les expressions Lambda ne sont généralement utilisées que pour des fonctions très simples, comme ceci :

Python

1

1 2 3 4 5 6 7 8 9 10 11 12 13 14

>>> square = lambda x: x**2 >>> for i in range(10):     square(i) 0 1 4 9 16 25 36 49 64 81 >>>

2

3

4

5

6

7

8

9

10

11

12

13

14

>>> carré = lambda x : x**2

>>> pour i dans plage(10) :

 carré( je)

0

1

4

9

16

25

36

49

64

81

>>>

L'expression lambda ci-dessus fait la même chose que la fonction nommée ci-dessous :

Python

1

1 2	def square(x):     return x**2

2

def carré(x):

 retour x**2

Fonctions et fermetures imbriquées

Définir une fonction à l'intérieur d'une fonction crée une fonction imbriquée, comme indiqué ci-dessous :

Python

1

1 2 3 4 5 6 7

```python    def outer():        outer_var = "outer variable"        def inner():            return outer_var         return inner ```

2

3

4

5

6

7

```python

def extérieur() :

 outer_var = "variable externe" def intérieur() :

    retour outer_var

 retour intérieur

```

Dans ce type de définition de fonction, la fonction interne n'est valide qu'à l'intérieur de la fonction externe, donc lorsque la fonction interne doit être renvoyée (déplacée vers la portée externe) ou passée à une autre Lorsque vous travaillez avec des fonctions, il est souvent pratique d'utiliser des fonctions imbriquées. Dans la fonction imbriquée ci-dessus, une nouvelle instance de fonction imbriquée est créée à chaque fois que la fonction externe est appelée, car la définition de la fonction interne est exécutée à chaque fois que la fonction externe est exécutée et son corps de fonction ne sera pas exécuté.

Une fonction imbriquée a accès à l'environnement dans lequel elle a été créée, ce qui est le résultat direct de la sémantique de définition de fonction de Python. Une conséquence est que les variables définies dans la fonction externe peuvent être référencées dans la fonction interne, même après que la fonction externe a terminé son exécution.

Python

1 2 3 4 5 6 7 8 9 10 11

def extérieur():  var_extérieur = "variable externe"  def intérieur(): retour outer_var  retour intérieur > ;>> x = extérieur () >>> x <fonction intérieure à 0x0273BCF0> >>> x() 'variable externe'

Lorsque la fonction imbriquée interne fait référence à la variable dans l'extérieur function Quand , on dit que la fonction imbriquée est fermée par rapport à la variable de référence. Nous pouvons accéder à cette variable incluse en utilisant un attribut spécial "__closure__" de l'objet fonction, comme suit :

Python

1

1 2 3 4 5 6

>>> cl = x.__closure__ >>> cl (<cell at 0x029E4470: str object at 0x02A0FD90>,)   >>> cl[0].cell_contents 'outer variable'

2

3

4

5

6

>>> cl = x.__closure__>>> cl(<<🎜><🎜>cellule <🎜>à<🎜> <🎜 > <🎜>0x029E4470<🎜><🎜>:<🎜><🎜> <🎜>str<🎜><🎜> <🎜 >objet<🎜><🎜> <🎜>à<🎜><🎜> <🎜>0x02A0FD90<🎜><🎜>>,) >>> > cl[0].cellule_contenu'variable externe'

Les fermetures en Python ont un comportement étrange. Dans Python 2.x et versions antérieures, les variables pointant vers des types immuables (tels que des chaînes et des nombres) ne peuvent pas être renvoyées dans les fermetures. L'exemple suivant illustre cela :

Python

1 2 3 4 5 6 7 8 9 10 11 12 13

def compteur(): compte = 0  def c():             > compte += 1           retour compte  retour c >>> c = compteur()>>> c ()Traceback ( les plus récents appeler le dernier) :   Fichier "", ligne 1, dans <module>   Fichier "" , ligne 4, in c UnboundLocalError: local variable 'count' référencée avant affectation

Une solution plutôt peu fiable consiste à utiliser un type mutable pour capturer la fermeture, comme ceci :

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14

def compteur():  compte = [0]  déf c():   compte[0] += 1  retour compte[0 ]  retour c > ;>> c = compteur () >>> c () 1 >>> c() 2 >>> c() Python 3 introduit des mots clés « non locaux » qui sont utilisés pour résoudre le problème de portée de fermeture illustré ci-dessous. Dans la section Espaces de noms de ce didacticiel, nous décrivons ces utilisations originales plus en détail.

Python

1

2

3

4

5

6

7

def

compteur

1 2 3 4 5 6 7

def counter():        count = 0        def c():            nonlocal count            count += 1            return count         return c

() : compte = 0 def c():                                                                                 += 1    retour compte    retour c

Les fermetures peuvent être utilisées pour maintenir l'état (différentes des classes). Dans certains cas simples, elles peuvent également fournir une solution plus concise et lisible que les classes, nous utilisons un schéma. exemple de journal dans tech_pro pour illustrer ce point. Supposons une API de journalisation très simple qui utilise des idées orientées objet basées sur des classes et peut imprimer des journaux à différents niveaux :

Python

1 2 3 4 5 6 7 8 9 10

cours Journal :  def __init__ (soi, niveau) :  soi._level = niveau def __call__(moi, message):  imprimer("{} : {}".format(soi._level, message )) log_info = Journal("infos") log_warning = Journal("avertissement") log_error = Journal("erreur")

相同的功能也可以使用闭包来实现，如下所示：

Python

table>可以看出，即使两个版本都实现了相同的功能，但基于闭包的版本更简洁、可读性更好。闭包在一个主要的Python dit « »讲解。

1

1 2 3 4 5 6 7 8

def make_log(level):     def _(message):         print("{}: {}".format(level, message))     return _   log_info = make_log("info") log_warning = make_log("warning") log_error = make_log("error")

2

3

4

5

6

7

8

def

make_log

(niveau) :

    def _(message) :

        imprimer("{} : {}".format(niveau, message))

    retour _

 

log_info = make_log("info")

log_warning = make_log("avertissement")

log_error = make_log( "erreur")