B1 · 第19集 · 4:41
手算Python函数执行
本集讲解如何手动模拟Python函数的执行过程，包括参数传递、变量变化和返回值。
来源：jmbarbier / peertube.solidev.net · 许可：CC BY-SA 4.0
字幕
Alors sur cette partie, on va revenir un petit peu sur les fonctions.
那么，这一部分我们将稍微回顾一下函数。
Je vous ai dit que c'était un des points les plus importants et peut- être les plus
我之前告诉过大家，这是课程中最重要的知识点之一，
compliqués aussi du programme.
可能也是最难的部分之一。
Donc on va prendre le temps pour être sûr que tout le monde sait lire,
因此，我们会花些时间，确保每个人都会阅读，
exécuter des fonctions.
并执行函数。
Et entre autres, pour pouvoir écrire une fonction,
此外，要能自己编写一个函数，
il faut comprendre vraiment comment ça fonctionne.
就必须真正理解它的运行原理。
Et pour ça, il faut être capable de
为此，你得能够，
savoir ce que fait une fonction, prévoir ce que va faire une fonction.
清楚一个函数的作用，并能预判它将执行什么操作。
En prenant le temps qu'il faut pour écrire les différentes opérations,
通过仔细写出每一步运算，
qui est appelé avec quelle variable.
包括它用的是哪个变量。
Un peu comme qu'on avait fait en assembleur,
这有点像我们之前学汇编语言时的做法，
vous allez retrouver un petit peu des notations et des
你们会再次见到一些汇编语言中的符号和方法，
manières de faire de l'assembleur.
只是形式略有不同。
On va prendre en fait quelques fonctions et on va les faire à la main,
实际上，我们将选取几个函数，手动逐步分析，
on va les exécuter sur le papier et puis ensuite après on prendra le Python et puis
也就是在纸上执行它们；之后再用 Python 和相关工具，
des outils pour pouvoir aller vérifier que ce qu'on a fait est correct.
来验证我们的分析是否正确。
Donc voilà un premier exercice où on a une fonction et on va voir comment un petit
下面是一个入门练习：给出一个函数，
peu dérouler les différentes opérations pour ça.
我们将一起逐步展开它的各项操作。
Donc quand Python va lire le programme,
当 Python 读取程序时，
il va partir du début du programme ici et il va arriver à une définition de
它从程序开头开始执行，到达此处的函数定义，
fonction. Quand il arrive à une définition de fonction, il continue,
一旦遇到函数定义，它不会立即执行，而是继续往下读，
il va jusqu'à la fin, d'accord?
一直读到程序末尾，明白了吗？
Il lit, il apprend simplement la définition de la fonction.
它只是读取并记住这个函数的定义。
Puis je vais arriver ici, à cet endroit- là.
接着，程序会运行到这里。
Là, la première partie qui va être exécutée.
这里，将首先执行的第一部分。
Il va voir le plus intérieur.
它会先查看最内层的内容。
Quand on a des parenthèses comme ça, le Python va commencer par exécuter,
当出现这样的括号时，Python 会先执行其中的内容，
par faire ce qu'il y a à l'intérieur.
也就是括号内部的代码。
Donc là, en l'occurrence, l'intérieur, c'est cette fonction,
因此，本例中，‘内部’指的就是这个函数——
fonction 2 3 1, cet appel de fonction.
即函数 231 的这次调用。
Donc là, le Python va aller sauter
于是，Python 将跳转到
à l'intérieur de la fonction.
该函数的内部去执行。
Donc là, on va sauter pour aller dans la fonction.
也就是说，我们马上要跳进去执行这个函数了。
Et on peut le noter.
这一点我们可以标记出来。
Alors, quand on le note comme ça, c'est un peu comme quand on est en Python,
这样标记，有点像在 Python 中调试时那样，
ça permet de suivre où
它能帮我们跟踪当前执行到了哪里，
est- ce qu'on en était.
也就是程序运行到了哪一步。
Mais on va détailler ça, en fait, avec ce qu'on appelle la pile d'appel.
不过，我们接下来会借助‘调用栈’来详细说明这一点。
Donc on part. de notre programme principal,
我们从主程序开始，
et à chaque fois qu'on va appeler une fonction,
每次调用一个函数时，
on va noter un petit peu plus d'informations sur
都会记录下更多相关信息：
avec quoi est- ce qu'elle a été appelée, qu'est- ce qu'elle fait,
比如它是用什么参数被调用的、正在做什么操作，
et qu'est- ce qu'elle renvoie.
以及它将返回什么结果。
Donc là, quand je suis passé de
所以，当我从这里
fonction 2 3 1.
跳转到函数 231 时，
là ici qui est l'appel de la fonction,
也就是这个函数调用的位置，
que j'ai sauté maintenant dans l'exécution de la fonction qui est là,
而我现在已跳入其执行过程，
je vais le noter en utilisant une petite flèche comme ça qui dit ok j'étais dans le
我会用这样一个小箭头来标记：
programme principal et j'appelle la fonction qui s'appelle fonction.
主程序中，现在调用了名为‘函数’的这个函数。
2. Et juste à côté ou juste en dessous,
2. 就在旁边，或正下方，
je vais noter les variables qui sont dans cette fonction.
我将写下该函数中用到的变量。
Donc là en l'occurrence, on a.
这里具体来说，我们有：
Un paramètre qui est le paramètre a en première position,
第一个参数是 a，
un paramètre qui est le paramètre b en deuxième position,
第二个参数是 b，
et quand je vais le fournir, j'ai ici un appel de fonction où les paramètres sont
当我调用这个函数时，参数是按位置传入的：
donnés par position.
即按顺序提供。
Le 3 qui est là va correspondre au a, le 1 qui est là va correspondre au b.
这里的 3 对应参数 a，这里的 1 对应参数 b。
Donc mon appel de fonction se fait ici avec la variable paramètre a,
因此，这次函数调用中，参数 a 的值是：
donc qui fait une variable a
一个值为 3 的变量 a，
qui vaut 3. Et le b qui vaut 1.
而 b 的值是 1。
D'accord, donc la variable a contient 3, la variable b contient 3,
好的，所以变量 a 存储的是 3，变量 b 存储的是 1，
puisqu'on a passé le paramètre première position a, deuxième position b.
因为我们按顺序传入了第一个参数 a、第二个参数 b。
Ensuite, je vais faire l'étape d'après: b est égal à a moins b.
接下来，执行下一步：b 等于 a 减去 b。
Donc b est égal à moins b, ça me fait b est égal à a moins b.
即 b 等于 a 减 b，得到 b 等于 a 减 b。
C'est égal à 3 moins 1,
等于 3 减 1，
c'est égal à 2.
结果是 2。
Donc b contient 2 maintenant et a n'a pas changé.
因此，b 现在存的是 2，而 a 的值没有改变。
Et enfin, je vais renvoyer b.
最后，我返回 b 的值。
Donc je renvoie la valeur 2.
也就是返回数值 2。
Donc là ici, je fais une flèche qui revient vers le programme principal avec la
于是，我画一条箭头，从这里回到主程序，
valeur de retour que je vais noter dessus.
并在箭头上标出返回值。
Il renvoie la valeur 2.
它返回的是数值 2。
Et donc mon return B fait que je reviens
因此，return b 这条语句让我返回到
à la position.
原来调用的位置。
De j'étais parti.
我之前已经离开了。
Maintenant, mon fonction qui est là,
现在，我原本调用的那个函数，
je suis revenu de l'appel de la fonction,
我已经从它的调用中返回了；
c'est comme si le fonction n'existait plus et qu'on avait remplacé ça par la valeur
这就像是那个函数已不复存在，
qui arrivait de là.
而它被自己返回的值替换了。
ici, la valeur qui correspond ici maintenant c'est 2.
这里此刻对应的值是2。
Donc ce que je vais avoir comme affichage, c'est print 2.
因此，最终输出的结果就是：print 2。
Donc si je dessine comme on le faisait un écran quelque part,
如果像之前那样，在某个地方画一个屏幕，
voilà mon écran.
这就是我的屏幕。
J'ai ici un affichage qui fera 2 à cet endroit.
屏幕上这个位置会显示数字2。