Dans l'apprentissage automatique, nous avons souvent besoin d'utiliser des classes et des fonctions pour définir diverses parties du modèle, comme définir des fonctions de lecture données, fonctions de prétraitement des données, fonctions d'architecture de modèle et de processus de formation, etc. Alors, quel genre de fonction est belle et agréable à l’œil ? Ce didacticiel expliquera comment développer de merveilleuses fonctions sous six aspects, notamment la dénomination et la taille du code. Il y a un tutoriel vidéo enregistré pour tout le monde à la fin de l'article. Vous pouvez apprendre selon vos besoins, et vous pouvez laisser un message si vous n'êtes pas clair !
Comme dans la plupart des langages de programmation modernes, en Python, les fonctions sont l'une des méthodes de base d'abstraction et d'encapsulation. Vous avez peut-être écrit des centaines de fonctions au cours de la phase de développement, mais toutes les fonctions ne sont pas égales. L'écriture de "mauvaises" fonctions affectera directement la lisibilité et la maintenabilité du code. Alors, quel type de fonction est une « mauvaise » fonction ? Plus important encore, comment écrire une « bonne » fonction ?
Un aperçu rapide
Les mathématiques regorgent de fonctions, même si nous ne nous en souvenons peut-être pas. Tout d’abord, rappelons le sujet préféré de tous : le calcul. Vous vous souvenez peut-être de cette équation : f(x) = 2x + 3. Il s'agit d'une fonction appelée "f" qui prend un nombre inconnu x et "renvoie" 2*x+3. Cette fonction ne ressemble peut-être pas à ce que nous voyons en Python, mais l’idée de base est la même que celle des fonctions dans les langages informatiques.
Les fonctions ont une longue histoire en mathématiques, mais elles sont encore plus puissantes en informatique. La fonction présente néanmoins quelques défauts. Nous discuterons ensuite de ce qu’est une « bonne » fonction et des signes dont nous avons besoin pour la refactoriser.
La clé pour déterminer si une fonction est bonne ou mauvaise
Quelle est la différence entre une bonne fonction Python et une fonction Python merdique ? Il est surprenant de constater le nombre de définitions des « bonnes » fonctions. Pour nos besoins, je définirais une bonne fonction Python comme une fonction conforme à la plupart des règles de la liste suivante (certaines sont plus difficiles à mettre en œuvre) :
Pour beaucoup de personnes, cette liste est peut-être un peu trop restrictive. Mais je vous garantis que si vos fonctions suivent ces règles, votre code sera magnifique. Ci-dessous, j'expliquerai chaque règle étape par étape, puis je résumerai comment ces règles constituent une « bonne » fonction.
Nommer
Concernant cette question, ma phrase préférée (de Phil Karlton, toujours confondue avec Donald Knuth) est :
Il y a seulement deux problèmes difficiles en informatique : l'invalidation du cache et le problème de dénomination.
Cela semble un peu bizarre, mais toute cette histoire de dénomination est vraiment difficile. Voici un exemple de mauvaise dénomination de fonction :
def get_knn(from_df):复制代码
J'ai vu de mauvaises dénominations pratiquement partout, mais cet exemple vient de la science des données (ou de l'apprentissage automatique), où les praticiens utilisent toujours des notebooks Jupyter. Écrivez le code ci-dessus, puis essayez transformer ces unités disparates en un programme compréhensible.
Le premier problème lié à la dénomination de cette fonction est l'utilisation d'acronymes/abréviations. Les mots anglais complets valent mieux que les abréviations et les acronymes impopularisés. La seule raison d'utiliser des abréviations est de gagner du temps de saisie, mais les éditeurs modernes disposent d'une saisie semi-automatique, vous n'avez donc qu'à saisir le nom complet une seule fois. La raison pour laquelle les abréviations posent problème est qu’elles ne sont généralement utilisées que dans des domaines spécifiques. Dans le code ci-dessus, knn fait référence à « K-Nearest Neighbours » et df fait référence à « DataFrame » – la structure de données Pandas omniprésente. Si un autre programmeur qui n'est pas familier avec ces abréviations lit le code, cette personne sera confuse.
Deux autres problèmes mineurs avec ce nom de fonction : le mot "get" n'a pas d'importance. Avec la plupart des fonctions bien nommées, il est évident que la fonction renvoie quelque chose, et son nom le reflétera. from_df est également inutile. Si le nom du paramètre n'est pas assez clair, le commentaire de la documentation de la fonction ou l'annotation de type décrira le type du paramètre.
Alors comment renommer cette fonction ? Par exemple :
def k_nearest_neighbors(dataframe):复制代码
Désormais, même un profane sait ce que cette fonction calcule, et le nom du paramètre (dataframe) nous indique clairement quel type de paramètre doit être transmis.
Principe à fonction unique
「单一功能原则」来自 Bob Martin「大叔」的一本书，不仅适用于类和模块，也同样适用于函数（Martin 最初的目标）。该原则强调，函数应该具有「单一功能」。也就是说，一个函数应该只做一件事。这么做的一大原因是：如果每个函数只做一件事，那么只有在函数做那件事的方式必须改变时，该函数才需要改变。当一个函数可以被删除时，事情就好办了：如果其他地方发生改动，不再需要该函数的单一功能，那么只需将其删除。
举个例子来解释一下。以下是一个不止做一件「事」的函数：
def calculate_and print_stats(list_of_numbers):
sum = sum(list_of_numbers)
mean = statistics.mean(list_of_numbers)
median = statistics.median(list_of_numbers)
mode = statistics.mode(list_of_numbers)
print('-----------------Stats-----------------')
print('SUM: {}'.format(sum) print('MEAN: {}'.format(mean)
print('MEDIAN: {}'.format(median)
print('MODE: {}'.format(mode)复制代码这一函数做两件事：计算一组关于数字列表的统计数据，并将它们打印到 STDOUT。该函数违反了只有一个原因能让函数改变的原则。显然有两个原因可以让该函数做出改变：新的或不同的数据需要计算或输出的格式需要改变。最好将该函数写成两个独立的函数：一个用来执行并返回计算结果；另一个用来接收结果并将其打印出来。函数有多重功能的一个致命漏洞是函数名称中含有单词「and」
这种分离还可以简化针对函数行为的测试，而且它们不仅被分离成一个模块中的两个函数，还可能在适当情况下存在于不同的模块中。这使得测试更加清洁、维护更加简单。
只做两件事的函数其实非常罕见。更常见的情况是一个函数负责许多许多任务。再次强调一下，为可读性、可测试性起见，我们应该将这些「多面手」函数分成一个一个的小函数，每个小函数只负责一项任务。
文档注释
很多 Python 开发者都知道 PEP-8，它定义了 Python 编程的风格指南，但很少有人了解定义了文档注释风格的 PEP-257。在这里并不会详细介绍 PEP-257，读者可详细阅读该指南所约定的文档注释风格。
首先文档注释是在定义模块、函数、类或方法的第一段字符串声明，这一段字符串应该需要描述清楚函数的作用、输入参数和返回参数等。PEP-257 的主要信息如下：
在编写函数时，遵循这些规则很容易。我们只需要养成编写文档注释的习惯，并在实际写函数主体之前完成它们。如果你不能清晰地描述这个函数的作用是什么，那么你需要更多地考虑为什么要写这个函数。
返回值
函数可以且应该被视为一个独立的小程序。它们以参数的形式获取一些输入，并返回一些输出值。当然，参数是可选的，但是从 Python 内部机制来看，返回值是不可选的。即使你尝试创建一个不会返回值的函数，我们也不能选择不在内部采用返回值，因为 Python 的解释器会强制返回一个 None。不相信的读者可以用以下代码测试：
❯ python3 Python 3.7.0 (default, Jul 23 2018, 20:22:55) [Clang 9.1.0 (clang-902.0.39.2)] on darwin Type "help", "copyright", "credits" or "license" *for *more information. >>> def add(a, b): ... print(a + b) ... >>> b = add(1, 2) 3 >>> b >>> b is None True复制代码
运行上面的代码，你会看到 b 的值确实是 None。所以即使我们编写一个不包含 return 语句的函数，它仍然会返回某些东西。不过函数也应该要返回一些东西，因为它也是一个小程序。没有输出的程序又会有多少用，我们又如何测试它呢？
我甚至希望发表以下声明：每一个函数都应该返回一个有用的值，即使这个值仅可用来测试。我们写的代码应该需要得到测试，而不带返回值的函数很难测试它的正确性，上面的函数可能需要重定向 I/O 才能得到测试。此外，返回值能改变方法的调用，如下代码展示了这种概念：
with open('foo.txt', 'r') as input_file:
for line in input_file:
if line.strip().lower().endswith('cat'):
# ... do something useful with these lines复制代码代码行 if line.strip().lower().endswith('cat') 能够正常运行，因为字符串方法 (strip(), lower(), endswith()) 会返回一个字符串以作为调用函数的结果。
以下是人们在被问及为什么他们写的函数没有返回值时给出的一些常见原因：
「函数所做的就是类似 I/O 的操作，例如将一个值保存到数据库中，这种函数不能返回有用的输出。」
我并不同意这种观点，因为在操作成功完成时，函数可以返回 True。
「我需要返回多个值，因为只返回一个值并不能代表什么。」
当然也可以返回包含多个值的一个元组。简而言之，即使在现有的代码库中，从函数返回一个值肯定是一个好主意，并且不太可能破坏任何东西。
函数长度
函数的长度直接影响了可读性，因而会影响可维护性。因此要保证你的函数长度足够短。50 行的函数对我而言是个合理的长度。
如果函数遵循单一功能原则，一般而言其长度会非常短。如果函数是纯函数或幂等函数（下面会讨论），它的长度也会较短。这些想法对于构造简洁的代码很有帮助。
那么如果一个函数太长该怎么办？代码重构（refactor）！代码重构很可能是你写代码时一直在做的事情，即使你对这个术语并不熟悉。它的含义是：在不改变程序行为的前提下改变程序的结构。因此从一个长函数提取几行代码并转换为属于该函数的函数也是一种代码重构。这也是将长函数缩短最快和最常用的方法。只要适当给这些新函数命名，代码的阅读将变得更加容易。
幂等性和函数纯度
幂等函数（idempotent function）在给定相同变量参数集时会返回相同的值，无论它被调用多少次。函数的结果不依赖于非局部变量、参数的易变性或来自任何 I/O 流的数据。以下的 add_three(number) 函数是幂等的：
def add_three(number): """Return *number* + 3.""" return number + 3复制代码
无论何时调用 add_three(7)，其返回值都是 10。以下展示了非幂等的函数示例：
def add_three():
"""Return 3 + the number entered by the user."""
number = int(input('Enter a number: '))
return number + 3复制代码这函数不是幂等的，因为函数的返回值依赖于 I/O，即用户输入的数字。每次调用这个函数时，它都可能返回不同的值。如果它被调用两次，则用户可以第一次输入 3，第二次输入 7，使得对 add_three() 的调用分别返回 6 和 10。
为什么幂等很重要？
可测试性和可维护性。幂等函数易于测试，因为它们在使用相同参数的情况下会返回同样的结果。测试就是检查对函数的不同调用所返回的值是否符合预期。此外，对幂等函数的测试很快，这在单元测试（Unit Testing）中非常重要，但经常被忽视。重构幂等函数也很简单。不管你如何改变函数以外的代码，使用同样的参数调用函数所返回的值都是一样的。
什么是「纯」函数？
在函数编程中，如果函数是幂等函数且没有明显的副作用（side effect），则它就是纯函数。记住，幂等函数表示在给定参数集的情况下该函数总是返回相同的结果，不能使用任何外部因素来计算结果。但是，这并不意味着幂等函数无法影响非局部变量（non-local variable）或 I/O stream 等。例如，如果上文中 add_three(number) 的幂等版本在返回结果之前先输出了结果，它仍然是幂等的，因为它访问了 I/O stream，这不会影响函数的返回值。调用 print() 是副作用：除返回值以外，与程序或系统中其余部分的交互。
我们来扩展一下 add_three(number) 这个例子。我们可以用以下代码片段来查看 add_three(number) 函数被调用的次数：
add_three_calls = 0
def add_three(number):
"""Return *number* + 3."""
global add_three_calls
print(f'Returning {number + 3}')
add_three_calls += 1
return number + 3
def num_calls():
"""Return the number of times *add_three* was called."""
return add_three_calls复制代码现在我们向控制台输出结果（一项副作用），并修改了非局部变量（又一项副作用），但是由于这些副作用不影响函数的返回值，因此该函数仍然是幂等的。
纯函数没有副作用。它不仅不使用任何「外来数据」来计算值，也不与系统／程序的其它部分进行交互，除了计算和返回值。因此，尽管我们新定义的 add_three(number) 仍是幂等函数，但它不再是纯函数。
纯函数不记录语句或 print() 调用，不使用数据库或互联网连接，不访问或修改非局部变量。它们不调用任何其它的非纯函数。
总之，纯函数无法（在计算机科学背景中）做到爱因斯坦所说的「幽灵般的远距效应」（spooky action at a distance）。它们不以任何形式修改程序或系统的其余部分。在命令式编程中（写 Python 代码就是命令式编程），它们是最安全的函数。它们非常好测试和维护，甚至在这方面优于纯粹的幂等函数。测试纯函数的速度与执行速度几乎一样快。而且测试很简单：没有数据库连接或其它外部资源，不要求设置代码，测试结束后也不需要清理什么。
显然，幂等和纯函数是锦上添花，但并非必需。即，由于上述优点，我们喜欢写纯函数或幂等函数，但并不是所有时候都可以写出它们。关键在于，我们本能地在开始部署代码的时候就想着剔除副作用和外部依赖。这使得我们所写的每一行代码都更容易测试，即使并没有写纯函数或幂等函数。
总结
写出好的函数的奥秘不再是秘密。只需按照一些完备的最佳实践和经验法则。希望本期教程能够帮助到大家。
Recommandations d'apprentissage gratuites associées : Tutoriel vidéo 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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
