Python-Serie 4

Inhaltsverzeichnis

• Rekursive Algorithmusanalyse

• Risk Bubble Sort Parsing

• Decorator Parsing

1 . Rekursion

1. Die Definition der Rekursion

Rekursion, in der Mathematik und Informatik auch Rekursion genannt, bezieht sich auf die Methode, die Funktion selbst bei der Definition einer Funktion zu verwenden. Der Begriff Rekursion wird auch länger verwendet, um den Vorgang der selbstähnlichen Wiederholung von Dingen zu beschreiben.

F0 = 0F1 = 1

2. Das Prinzip der Rekursion

(1) Beispiel:

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

Das folgende Bild zeigt den Ausführungsprozess der gesamten Funktion. Die roten stellen die Verschachtelung Schicht für Schicht dar, und die grünen stellen den Rückgabewert der Funktion dar, die Schicht für Schicht zurückgegeben wird. Tatsächlich ist Rekursion dieses Prinzip, nachdem diese Funktion durch den Ausführungsfluss einer Funktion erneut eingegeben wurde, nachdem sie einen Wert durch eine Bedingung zurückgegeben hat, wird sie Schicht für Schicht entsprechend dem Ausführungsfluss zurückgegeben und erhält schließlich den Rückgabewert. aber bei der Rekursion sollten zwei Punkte beachtet werden:

1. Seine Bedingung muss so sein, dass seine Rekursion einen Wert innerhalb einer bestimmten Bedingung zurückgeben kann, andernfalls wird die Rekursion fortgesetzt, bis die Computerressourcen erschöpft sind (Python verfügt über Rekursion). standardmäßig Anzahl der Male begrenzt)

2. Rückgabewert, die darin enthaltene rekursive Funktion muss ihr im Allgemeinen einen bestimmten Rückgabewert geben, sonst erhalten Sie nicht den gewünschten Wert, wenn die letzte Rekursion zurückgegeben wird.

2. Blasensortierung

1. Blasensortierungsprinzip

Blasensortierung ist ein einfacher Sortieralgorithmus. Er durchläuft wiederholt die zu sortierende Sequenz, vergleicht jeweils zwei Elemente und vertauscht sie, wenn sie in der falschen Reihenfolge sind.

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

Das Prinzip des Datenaustauschs

Verwenden Sie zunächst eine periphere Variable, um den ursprünglichen Wert zu speichern, und tauschen Sie dann Daten durch Punkt-zu-Adressen-Konvertierung aus. Hinweis: Wenn temp auf a und dann a auf b zeigt, ändert sich der Punkt von temp selbst nicht. Wie in der Abbildung unten gezeigt, zeigt a auf b, temp zeigt jedoch immer noch auf die Adresse von a, also ist es still 66

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

　

Das Prinzip der Blasensortierung

2. Beispiel für die Blasensortierung

 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. Decorator

1. Decorator-Definition

Was ist ein Decorator? Einfach ausgedrückt handelt es sich um eine subtile Erweiterung des Codes, ohne den Quellfunktionscode zu ändern, um seine Funktionalität weiter zu verbessern. Ein Dekorator ist eine Funktion, eine Funktion, die über anderen Funktionen geladen wird.

Lassen Sie uns zunächst einige Konzepte verstehen:

> Aus dem Obigen können wir ersehen, dass der Ausführungsfluss der Funktion so sein sollte Das heißt, der Code lädt zuerst den ersten Test1 in den Speicher und weist dann einen neuen Speicher zum Speichern des zweiten Tests1 zu.

Dies sollte der Punkt sein, an dem der erste test1 in 890673481792 geändert wurde.

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

执行结果：890673481656
890673481792中国人.

　　<2>. Funktion als Variable

　　　　 Aus den folgenden Ergebnissen ist ersichtlich, dass der Funktionsname tatsächlich eine Variable ist, die verwendet werden kann Variablen übergeben. <3>. Funktionsverschachtelung

Hier sind drei Funktionen definiert: test1, test2, test3, 3 enthält 1 und 1 enthält 2 verschachtelte Funktionen . Aus dem Ausführungsablauf der Funktion.

　　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.
你是哪国人？
我是中国人.
你呢？
我是日本人.

 

 

　　

 

Das obige ist der detaillierte Inhalt vonPython-Serie 4. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!