Fonctions et paramètres

Valeur par défaut des paramètres

On les déclare ainsi:

		def f(p1, p2=10):
			pass

		# p2 vaut 15
		f(5, 15)

		# p2 n'est pas spécifié, alors il vaut 10, sa valeur par défaut
		f(5)
	

Quand un paramètre a une valeur par défaut, il devient facultatif de le préciser lors d'un appel de la fonction, et lorsqu'on les précise leur ordre est sans importance. Les paramètres sans valeur par défaut restent obligatoires lors de l'appel.

Les paramètres qui ont une valeur par défaut doivent être placés APRES ceux qui n'ont pas de valeur par défaut, aussi bien lors de la déclaration de la fonction, que lors de l'appel de la fonction.

Passage de paramètres par leur nom

Au moment de l’appel d’une fonction, on peut donner la valeur d’un paramètre en spécifiant son nom également, au lieu de uniquement sa valeur, on les appelle alors des paramètres nommés, named parameters ou keyword arguments en anglais. On appelle paramètres positionnels ou positional arguments les paramètres passés de façon classique.

		def f(p1, p2, p3):
			pass

		# ↓ L'ordre des paramètres nommés n'est pas important
		f(p2=50, p3=8, p1=2)

		# ↓ ERREUR: il est interdit de spécifier plusieurs fois le même paramètre
		# Ici p1 est donné 2 fois
		f(p2=50, p3=8, p1=2, p1=10)
	

On peut donner à la fois des paramètres positionnels et des paramètres nommés. Dans ce cas, les paramètres positionnels doivent être listés en premier, et les paramètres nommés ensuite. L'ordre des paramètres positionnels reste important:

		def f(p1, p2, p3, p4):
			pass

		# ↓ OK
		# p1 vaut 50, p2 vaut 8
		f(50, 8, p4=2, p3=10)

		# ↓ ERREUR: les paramètres nommés doivent être passés APRES les non nommés.
		# Ici p4=2 est avant 8, ça devrait être l'inverse.
		f(50, p4=2, 8, p3=10)

		# ↓ ERREUR: p1 est donné deux fois!
		# p1 vaut 50, puis on dit aussi qu'il vaut 10...
		f(50, 8, p4=2, p3=10, p1=10)
	

Nombre variable de paramètres positionnés

Cette option est rarement utilisée. On peut spécifier dans la définition d’une fonction un paramètre spécial précédé de *, comme ceci:

		def f(arg1, arg2=8, *args):
			print('arg1=', arg1)
			print('arg2=', arg2)
			for p in args:
				print('args', p)

		f(10, 12, 20, 40)
	

Affichage:

		arg1= 10
		arg2= 12
		args 20
		args 40
	

Ce paramètre spécial, nommé paramètre variadique, qui référencera une liste au moment de l'exécution de la fonction, est placé en dernier dans la liste des paramètres, dans la définition de la fonction, ou juste avant le paramètre ** quand il est présent. Il va englober lors de l’appel tous les paramètres positionnels, à partir de sa position dans la définition de la fonction. Tous les paramètres suivants lors de l’appel ne peuvent être que des paramètres nommés.

On le nomme par défaut args, pour arguments, mais il peut avoir n'importe quel nom, c'est la présence de l'étoile qui compte.

Nombre variable de paramètres nommés

Cette option est également rarement utilisée. On peut spécifier dans la définition d’une fonction un paramètre spécial précédé de **, comme ceci:

		def f(arg1, arg2=8, **kwargs):
			print('arg1=', arg1)
			print('arg2=', arg2)
			for clé, valeur in kwargs.items():
				print('kwargs', clé, valeur)

		f(10, arg2=20, truc='bidule', a='b')
	

Affichage:

		arg1= 10
		arg2= 20
		kwargs truc bidule
		kwargs a b
	

Ce paramètre référencera un dictionnaire au moment de l'appel, qui contiendra pour clés tous les paramètres nommés avec leur valeur associée, autres que ceux déclarés formellement dans la définition de la fonction. Il doit forcément être le dernier paramètre d’une fonction, quand il est présent.

Le nom kwargs est souvent employé, car il signifie en anglais “keyword arguments”, ce qui signifie arguments (ou paramètre, c’est pareil) par mot-clé, ou argument nommé. Mais il peut être nommé comme on veut, c'est la présence de la double étoile qui compte.

La portée des variables

Variables globales

Les variables globales sont accessibles en lecture dans les fonctions, mais pas en écriture:

		var_globale = 10

		def une_fonction():
			# Lit var_globale
			print(var_globale) # Affiche 10
	

		var_globale = 10

		def une_fonction():
			var_globale = 8
			# Ne modifie pas var_globale
			# mais créé une nouvelle variable LOCALE qui s'appelle aussi var_globale

	

Pour modifier une variable globale depuis une fonction, il faut utiliser le mot-clé global comme ceci:

		var_globale = 10

		def une_fonction():
			global var_globale
			var_globale = 8
			# La variable globale est bien modifiée
	

La fonction built-in globals(), peu importe où elle est appelée, retourne toujours un dictionnaire qui contient tous les identifiants du contexte global du module dans lequel elle est appelée et leurs objets associés.

Dans les fonctions: les variables locales

Les variables déclarées / créées dans les fonctions sont appelées variables locales. Les paramètres des fonctions sont aussi des variables locales, créées automatiquement et initialisées avec les valeurs effectives lors de l'appel de la fonction. Les variables locales n'existent que pendant l'execution de la fonction dans laquelle elles sont déclarées.

Ici on parle bien des indetifiants, et pas des objets qu'elles référencent, qu'il ne faut pas confondre. Par exemple si vous créez une liste dans une fonction, la stockez dans une variable locale L, puis retournez L, la variable L n'existe plus lorsque la fonction a fini son execution, mais la liste si, et peut être utilisée ensuite en dehors de la fonction au travers d'autres variables.

La fonction locals() retourne la liste de toutes les variables locales et leur valeur associée, dans le contexte dans lequel locals() est appelée, dans une fonction, ou en dehors. Si appelée en dehors d'une fonction, elle se comporte comme globals().