Ausführliche Erklärung der Bedeutung von Rückrufen in Python

Hintergrund der anfänglichen Anforderung für die Rückruffunktion

Das älteste Szenario, das ich mir für die Rückruffunktion vorstellen kann, ist das Systemprogrammierungstreffen verwendet.

Programmierung ist in zwei Kategorien unterteilt:

● Systemprogrammierung

● Anwendungsprogrammierung

(empfohlenes Lernen: Python-Video-Tutorial )

Was ist Systemprogrammierung:

Die sogenannte Systemprogrammierung besteht, vereinfacht gesagt, darin, eine Bibliothek verschiedener Funktionen zu schreiben. Beispielsweise kann Win32 mit den Bibliotheken win32 und gdi32 in Windows die Funktionen der Host-Hardware und der Systemschicht aufrufen und mit gdi32 Grafiken zeichnen. Diese Bibliotheken warten nur darauf, dass diejenigen, die Anwendungen erstellen, sie aufrufen.

Was ist Anwendungsprogrammierung:

Anwendungsprogrammierung ist die Verwendung verschiedener Systemfunktionsbibliotheken und Sprachfunktionsbibliotheken, die zum Schreiben von Programmen mit bestimmten Geschäftsfunktionen geschrieben wurden. Ein Programm ist eine Bewerbung. Beispielsweise kann ein einfaches Crawler-Programm mithilfe der Python-Sprache und der Anforderungsbibliothek erstellt werden, und eine einfache Website kann mithilfe der Java-Sprache und der Java-Servlet-Bibliothek erstellt werden.

Die Beziehung zwischen Systemprogrammierung und Rückrufen

Systemprogrammierer hinterlassen einige Schnittstellen, also APIs, für die Bibliotheken, die sie zur Verwendung durch Anwendungsprogrammierer schreiben. Im Abstraktionsschichtdiagramm befindet sich die Bibliothek also unterhalb der Anwendung. Wenn das Programm ausgeführt wird, ruft die Anwendung unter normalen Umständen häufig vorbereitete Funktionen in der Bibliothek über die API auf. Bei einigen Bibliotheksfunktionen muss die Anwendung jedoch zuerst eine Funktion übergeben, damit sie zum richtigen Zeitpunkt aufgerufen werden kann, um die Zielaufgabe abzuschließen. Die Funktion, die übergeben und später aufgerufen wird, wird als Rückruffunktion bezeichnet.

Wenn Sie beim Lesen des Textes verwirrt sind, schauen Sie sich das Bild an, das ich gezeichnet habe (unten ist Abbildung 1):

Bevor Sie den Rückruf verstehen, verstehen Sie ihn Das ist der erste synchrone Aufruf

Der synchrone Aufruf ist ein blockierender Aufruf. Einfach ausgedrückt, wird er der Reihe nach von oben nach unten ausgeführt. Der Rückruf ist eine asynchrone Aufrufsequenz.

Der spezielle Fall des synchronen Anrufs kann an den alten Leuchtturmturm gedacht werden. Der Beacon-Übertragungsmechanismus der alten Chinesischen Mauer ähnelt synchronen Anrufen. Jetzt gehen wir davon aus, dass jeder Beacon nur den Status benachbarter Beacons sehen kann und der Status jedes Beacons nur hell (zündender Zustand) und dunkel (nicht zündender Zustand) ist. .

Es gibt vier Leuchttürme A, B, C und D. A leuchtet zuerst auf und B sieht, wie das Leuchtfeuer von A aufleuchtet, und es dauert 2 Sekunden, bis es aufleuchtet. Aber die Person, die für das C-Leuchtfeuer verantwortlich war, schlief zu dieser Zeit, aber zu dieser Zeit warteten alle darauf, dass C aufleuchtete. Schließlich schlief C zwei Stunden lang und sah, wie B aufleuchtete, und ging dann, um es anzuzünden. D hat lange Zeit nicht geleuchtet, was zu Problemen mit dem Beacon geführt hat, sodass der gesamte Vorgang darauf wartet, dass D abgeschlossen wird. (Dies führte auch zu einigen Überlegungen. Manchmal kann bei synchronen Aufrufen die Kette leicht verloren gehen. Wenn die Kette im vorherigen Schritt verloren geht, werden die Vorgänge nach dem nächsten Schritt beendet.)

Fallcode synchroner Aufrufe :

print("start.")
print(123)
print(456)
a = 7
if a > 6:
    print(789)
print(91011)
print("end.")

Probleme, die durch Rückrufe gelöst werden müssen

Gemeinsame Systeme werden viele Bibliotheken entwickeln, und es gibt viele Funktionen in den Bibliotheken. Bei einigen Funktionen muss der Aufrufer die aufzurufende Funktion entsprechend seinen eigenen Anforderungen schreiben. Da dies beim Schreiben der Bibliothek nicht vorhersehbar ist und nur vom Aufrufer eingegeben werden kann, ist ein Rückrufmechanismus erforderlich.

Der Rückrufmechanismus ist eine Möglichkeit, den synchronen Aufrufmechanismus zu verbessern. Der asynchrone Aufrufmechanismus wird auch zur Verbesserung des synchronen Aufrufmechanismus verwendet. (Ich werde später einen Artikel schreiben, um dieses wichtigere asynchrone Verfahren vorzustellen)

Beispiele dafür, wie Rückruffunktionen praktische Probleme lösen

Rückrufe lösen die oben genannten Probleme auf folgende Weise.

● Funktionen können in Parameter umgewandelt werden

● Aufruf auf flexible und individuelle Weise

Funktionsvariablenparameter-Fall

def doubel(x):
    return 2*x
def quadruple(x):
    return 4*x
# mind function
def getAddNumber(k, getEventNumber):
    return 1 + getEventNumber(k)
def main():
    k=1
    i=getAddNumber(k,double)
    print(i)
    i=getAddNumber(k,quadruple)
    print(i)
# call main
main()

Ausgabeergebnis:

3
5

Flexible und maßgeschneiderte Möglichkeit zum Anrufen (Hotel weckt Passagiere)

Dieser Fall ist wirklich die Seele des Rückrufs, Sie können nicht wissen, wer die Passagiere ist Checken Sie heute Abend ein. Brauchen Sie morgen einen Weckruf? Welche Art von Weckruf wird benötigt?

def call_you_phone(times):
    """
    叫醒方式： 给你打电话
    :param times: 打几次电话
    :return: None
    """
    print('已经给旅客拨打了电话的次数:', str(times))
def knock_you_door(times):
    """
    叫醒方式： 去敲你房间门
    :param times: 敲几次门
    :return: None
    """
    print('已经给旅客敲门的次数:', str(times))
def no_service(times):
    """
    叫醒方式： 无叫醒服务. （默认旅客是选无叫醒服务）
    :param times: 敲几次门
    :return: None
    """
    print('顾客选择无服务.不要打扰他的好梦。')
def front_desk(times, function_name=no_service()):
    """
    这个相当于酒店的前台，你去酒店之后，你要啥叫醒方式都得在前台说
    这里是实现回调函数的核心，相当于一个中转中心。
    :param times:次数
    :param function_name:回调函数名
    :return:调用的函数结果
    """
    return function_name(times)
if __name__ == '__main__':
    front_desk(100, call_you_phone)  # 意味着给你打100次电话，把你叫醒

Ausgabe:

已经给旅客拨打了电话的次数:100

Praktische Anwendung (der Event-Hook, der mit der Anforderungsbibliothek von Python geliefert wird)

Dieser Fall ist leicht zu lösen. Das Original Das Programm ist Der Synchronisationsmechanismus wird ausgeführt, aber durch Hook-Ereignisse können zuerst einige vorherige Schritte ausgeführt werden. Das Prinzip dieses Hook-Ereignisses ist ein Funktionsrückruf.

import requests
def env_hooks(response, *args, **kwargs):
    print(response.headers['Content-Type'])
def main():
    result = requests.get("https://api.github.com", hooks=dict(response=env_hooks))
    print(result.text)
if __name__ == '__main__':
    main()

Ausgabe:

application/json; charset=utf-8
{"current_user_url":"https://api.github.com/user","current_user_authorizations_html_url":"...省略"}

Dieser Artikel stammt aus der Spalte Python-Tutorial, willkommen zum Lernen!

Das obige ist der detaillierte Inhalt vonAusführliche Erklärung der Bedeutung von Rückrufen in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!