Python série 4

Table des matières

• Analyse d'algorithme récursif

• Analyse du tri des bulles de risque

• Analyse du décorateur

1 .Récursion

1. La définition de la récursion

La récursivité, également connue sous le nom de récursivité, en mathématiques et en informatique, fait référence à la méthode d'utilisation de la fonction elle-même dans la définition d'une fonction. Le terme récursivité est également utilisé de manière plus longue pour décrire le processus de répétition de choses de manière auto-similaire.

F0 = 0F1 = 1

2. Le principe de récursion

(1) Exemple :

 defth == 5= a1 += defth + 1== recursion(1, 0, 1(ret)

L'image suivante montre le processus d'exécution de la fonction entière. Les rouges représentent l'imbrication couche par couche à l'intérieur, et les vertes représentent la valeur de retour de la fonction renvoyée couche par couche. En fait, la récursivité est ce principe.Après être entré à nouveau dans cette fonction via le flux d'exécution d'une fonction, après avoir renvoyé une valeur via une condition, elle revient couche par couche selon le flux d'exécution à l'instant, et obtient finalement la valeur de retour, mais lors de la récursion Deux points sont à noter :

1. Son état doit être tel que sa récursivité puisse renvoyer une valeur dans une certaine condition, sinon il continuera à récursif jusqu'à épuisement des ressources informatiques (Python a une récursion par défaut Nombre de fois limite)

2. Valeur de retour, la fonction récursive à l'intérieur doit généralement lui donner une certaine valeur de retour, sinon vous n'obtiendrez pas la valeur souhaitée lorsque la dernière récursion sera renvoyée.

2. Tri à bulles

1. Principe du tri à bulles

Le tri à bulles est un algorithme de tri simple. Il parcourt à plusieurs reprises la séquence à trier, comparant deux éléments à la fois et les échangeant s'ils sont dans le mauvais ordre.

冒泡排序算法的运作如下：
　　1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
　　2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
　　3. 针对所有的元素重复以上的步骤，除了最后一个。
　　4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

Le principe de l'échange de données

Utilisez d'abord une variable périphérique pour enregistrer la valeur d'origine, puis échangez des données via une conversion point à adresse. Remarque : lorsque temp pointe vers a, puis a pointe vers b, le point de temp lui-même ne change pas. Comme le montre la figure ci-dessous, a pointe vers b, mais temp pointe toujours vers l'adresse de a, donc c'est toujours le cas. 66

a = 66b = 88temp = a 
a = b 
b = temp

　

Le principe du tri à bulles

2 . Exemple de tri de bulles

 1 # -*- coding:utf-8 -*- 2 # zhou 3 # 2017/6/17 4 list = [0, 88, 99, 33, 22, 11, 1] 5 for j in range(1, len(list)): 6     for i in range(len(list) - j): 7         # 如果第一个数据大, 则交换数据, 否则, 不做改变 8         if list[i] > list[i + 1]: 9             temp = list[i]10             list[i] = list[i + 1]11             list[i + 1] = temp12 print(list)

3. Décorateur

1. Définition du décorateur

Qu'est-ce qu'un décorateur ? En termes simples, il s'agit d'une extension subtile du code sans modifier le code de la fonction source pour améliorer encore ses fonctionnalités. Un décorateur est une fonction, une fonction chargée au-dessus d'autres fonctions,

Comprenons d'abord quelques concepts :

> De ce qui précède, nous pouvons voir que le flux d'exécution de la fonction doit être de haut en bas, c'est-à-dire que le code charge d'abord le premier test1 dans la mémoire, puis alloue une nouvelle mémoire pour stocker le deuxième test1.

Cela devrait être le point du premier test1 changé en 890673481792.

　　<2>. Fonctionner comme variable

def test1():print('日本人.')print(id(test1))def test1():print('中国人.')print(id(test1))
test1()

执行结果：890673481656
890673481792中国人.

　　　　 Il ressort des résultats suivants que le nom de la fonction est en fait une variable qui peut être utilisée pour passer des variables. < 3>. Imbrication de fonctions

Trois fonctions sont définies ici, test1, test2, test3, 3 en a 1 imbriquée et 1 en a 2 imbriquées. Je pense que vous le verrez également à partir de ses résultats. . Sortez le flux d'exécution de la fonction.

　　2. 装饰器原理

　　　　（1）. 装饰器的写法和使用

　　　　　　<1>. 装饰器也是一个函数

　　　　　　<2>. 使用装饰器的格式： 在一个函数前面加上：@装饰器的名字

　　　　（2）. 装饰器的原理

　　　　　　<1>. 把test1函数当做一个变量传入outer中

　　　　　　　　　　func = test1

　　　　　　<2>. 把装饰器嵌套的一个函数inner赋值给test1

　　　　　　　　　　test1 = inner

　　　　　　<3>. 当执行test1函数的时候，就等于执行了inner函数，因此在最后的那个test1()命令其实执行的就是inner，因此先输出（你是哪国人）

　　　　　　<4>. 按照执行流执行到func函数的时候，其实执行的就是原来的test1函数，因此接着输出（我是中国人），并把它的返回值返回给了ret

　　　　　　<5>. 当原来的test1函数执行完了之后，继续执行inner里面的命令，因此输出了（Oh，hh, I love China.）

　　　　（3）. 装饰器的总结

　　　　　　由上面的执行流可以看出来，其实装饰器把之前的函数当做参数传递进去，然后创建了另一个函数用来在原来的函数之前或者之后加上所需要的功能。

(=((

 

　　3. 带参数的装饰器

　　　　为了装饰器的高可用，一般都会采用下面的方式，也就是无论所用的函数是多少个参数，这个装饰器都可以使用

　　　　Python内部会自动的分配他的参数。

# -*- coding:utf-8 -*-# zhou# 2017/6/17def outer(func):def inner(a, *args, **kwargs):print('你是哪国人？')
        ret = func(a, *args, **kwargs)print('Oh, hh, I love China.')return inner

@outerdef test1(a, *args, **kwargs):print('我是中国人.')

test1(1)

　　3.  装饰器的嵌套

　　　<1>. 第一层装饰器的简化（outer装饰器）

　　　　

　　　　

　　　　<2>. 第二层装饰器简化（outer0装饰器）

　　　　

　　　　<3>. 装饰器嵌套攻击额，我们可以发现一层装饰器其实就是把原函数嵌套进另一个函数中间，因此我们只需要一层一层的剥开嵌套就可以了。

# -*- coding:utf-8 -*-# zhou# 2017/6/17def outer0(func):def inner():print('Hello, Kitty.')
        ret = func()print('我是日本人.')return innerdef outer(func):def inner():print('你是哪国人？')
        ret = func()print('你呢？')return inner
@outer0
@outerdef test1():print('我是中国人.')

test1()

结果Hello, Kitty.
你是哪国人？
我是中国人.
你呢？
我是日本人.

 

 

　　

 

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!