Programmation Python : directives de base sur les valeurs de retour des fonctions et les meilleures pratiques

Cet article, comme le dernier article sur le thème des fonctions, présente les valeurs de retour des fonctions et quelques directives de base sur les meilleures pratiques pour l'écriture de fonctions.

Sortie de fonction : valeur de retour

La valeur de retour d'une fonction est l'une des choses qui placent Python devant ses concurrents. Dans la plupart des autres langages, les fonctions ne sont généralement autorisées qu'à renvoyer un objet, mais en Python, vous pouvez renvoyer un tuple, ce qui signifie que tout ce que vous voulez peut être renvoyé. Cette fonctionnalité permet aux programmeurs d'écrire des logiciels beaucoup plus difficiles, voire certainement plus fastidieux, à écrire dans d'autres langages. Nous avons déjà dit que pour renvoyer quelque chose d'une fonction, nous devons utiliser l'instruction return suivie de l'élément que nous voulons renvoyer. Il peut y avoir plusieurs instructions return dans le corps de la fonction selon les besoins.

D'un autre côté, si dans le corps de la fonction nous ne renvoyons rien, ou si nous appelons une instruction return "nue", la fonction renverra None. Ce comportement est inoffensif lorsqu'il n'est pas nécessaire, mais il permet également d'élaborer des modèles intéressants, confirmant que Python est un langage très cohérent.

Nous disons que c'est inoffensif car vous n'êtes jamais obligé de récupérer le résultat d'un appel de fonction. Ce qui suit vous montrera ce qui est dit à travers un exemple :

# 返回none值
def func():
pass

func() # 这个调用是没有接收的，将丢失
a = func() # 这个调用被a接收
print(a) # prints: None

Notez que l'ensemble du corps de la fonction n'est constitué que d'instructions pass. Comme nous le dit la documentation officielle, pass n'est pas une opération car lorsqu'il est exécuté, rien ne se passe. Il est utile comme espace réservé lorsqu'une instruction est syntaxiquement requise mais ne nécessite pas l'exécution du code. Dans d'autres langages, nous pourrions simplement exprimer cela avec une paire d'accolades ({}), qui définissent une portée vide ; mais en Python, les portées sont définies par du code indenté, donc des instructions comme pass sont nécessaires.

Notez également que le premier appel à func() renvoie une valeur qui n'a pas été reçue (Aucune). Comme nous l'avons mentionné précédemment, il n'est pas nécessaire de recevoir la valeur de retour d'un appel de fonction.

C'est sympa mais pas très intéressant, que diriez-vous d'écrire une fonction amusante N'oubliez pas que nous avons discuté de la fonction factorielle ? Écrivons ici notre propre implémentation (pour plus de simplicité, nous supposons que la fonction est toujours appelée correctement avec les valeurs appropriées, nous n'avons donc pas besoin de vérifier les paramètres d'entrée) :

# 阶乘函数，返回单个值
def factorial(n):
if n in (0, 1):
return 1
result = n
for k in range(2, n):
result *= k
return result

f5 = factorial(5) # f5 = 120

Notez que nous avons deux points de retour. Si n vaut 0 ou 1, alors 1 est renvoyé. Sinon, nous effectuons les calculs requis et renvoyons le résultat.

Astuce : En Python, il est courant d'utiliser l'opérateur in pour la vérification des membres, comme nous l'avons fait dans l'exemple précédent, plutôt que la vérification plus détaillée :

if n == 0 ou n == 1 :

…

Essayez maintenant d'écrire cette fonction de manière plus concise :

# 返回单个值示例.2
from functools import reduce
from operator import mul

def factorial2(n):
return reduce(mul, range(1, n + 1), 1)

f5 = factorial(5) # f5 = 120

Cet exemple simple montre comment Python peut être à la fois élégant et concis. Cette implémentation est lisible même si nous n'avons jamais vu réduire() ou mul(). Si vous ne parvenez pas à le lire ou à le comprendre, prenez quelques minutes pour effectuer des recherches dans la documentation Python jusqu'à ce que vous compreniez son comportement. Être capable de trouver des fonctions dans la documentation et de comprendre le code écrit par d'autres sont des tâches que chaque développeur doit être capable d'effectuer, alors faites-en un défi.

Astuce : Apprenez à afficher l'aide fournie avec Python. Assurez-vous de rechercher la fonction help(), qui est très utile lors de l'exploration à l'aide de la console.

Renvoi de plusieurs valeurs

Comme nous l'avons mentionné précédemment, contrairement à la plupart des autres langages, Python permet de renvoyer très facilement plusieurs objets à partir d'une fonction. Cette fonctionnalité ouvre des possibilités infinies et vous permet de coder dans un style difficile à reproduire dans d'autres langages. Notre réflexion est limitée par les outils que nous utilisons. Ainsi, lorsque Python vous offre plus de liberté que d’autres langages, cela améliore vos capacités créatives.

Renvoyer plusieurs valeurs est très simple : utilisez simplement des tuples (explicites ou implicites). Regardons un exemple simple qui imite la fonction intégrée divmod() :

# 返回多个值
def moddiv(a, b):
return a // b, a % b

print(moddiv(20, 7)) # prints (2, 6)

Nous pourrions mettre la partie en gras du code précédent entre parenthèses pour en faire un tuple explicite, mais ce n'est pas nécessaire. La fonction ci-dessus renvoie à la fois le résultat de la division et le reste.

Conseils utiles sur les fonctions

Lors de l'écriture de fonctions, il est très utile de suivre quelques directives de bonnes pratiques afin de pouvoir bien les écrire. Jetons un coup d'œil à ces directives pour vous aider à mieux comprendre et appliquer les fonctions.

1) Une fonction ne doit faire qu'une seule chose

Une fonction qui fait une chose est facile à décrire en une phrase. Les fonctions qui exécutent plusieurs tâches peuvent être refactorisées en fonctions plus petites qui exécutent une seule tâche. Ces fonctions plus petites sont généralement plus faciles à lire et à comprendre.

2) Les fonctions doivent être petites

Plus elles sont petites, plus il est facile de les tester et de les écrire, elles sont donc davantage concentrées sur une seule chose.

3) Moins il y a de paramètres d'entrée, mieux c'est

Les fonctions qui acceptent un grand nombre de paramètres deviennent vite ingérables (entre autres problèmes). Lorsque davantage de paramètres d'entrée sont requis, considérez-les comme appropriés, comme la refactorisation en objets de classe ou en d'autres données composites.

4) La valeur de retour d'une fonction doit être cohérente

Retourner False et renvoyer None ne sont pas la même chose, même dans un contexte booléen, leurs valeurs sont toutes deux fausses. False signifie que nous avons des informations (c'est-à-dire False), tandis qu'Aucun signifie qu'il n'y a aucune information. Dans la mesure du possible, écrivez des fonctions qui reviennent de manière cohérente, quel que soit ce qui se passe dans leur logique.

5）函数不应该有副作用

换句话说，函数不应该影响调用它们的值。这可能是目前最难理解的一条实践性原则，所以这里给出一个使用列表的示例。在下面的代码中，注意如何不使用sorted()函数对numbers进行排序，该函数实际上返回的是已排序的数字副本。相反，list.sort()方法作用于numbers对象本身，这很好，因为它是一个方法(属于对象的函数，因此有权修改它):

>>> numbers = [4, 1, 7, 5]
>>> sorted(numbers) # 不会排序原始的'numbers' 数字列表
[1, 4, 5, 7]
>>> numbers # 验证一下
[4, 1, 7, 5] # 很好，没有改变原始数据对象
>>> numbers.sort() # 这将实质性影响原始列表
>>> numbers
[1, 4, 5, 7]

所以，遵循以上这些常规的基本指导原则，将有益于你写出更好的函数，为你实现更好的服务。

本文小结

到此关于Python函数的主体性知识就介绍完了——函数定义语法、输入参数定义以及相关规则、返回值实现和多返回值等，并简单总结了基于最佳实践的一些有益基本指导原则。请多加练习和体会，以便更好的理解和掌握作为Python的核心特性之一的函数。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!