Explication détaillée de la signification des rappels en Python

Contexte de l'exigence initiale de la fonction de rappel

Le scénario le plus ancien auquel je puisse penser pour la fonction de rappel est le réunion de programmation système utilisée.

La programmation est divisée en deux catégories :

● programmation système

● programmation d'applications

(apprentissage recommandé: Tutoriel vidéo Python )

Qu'est-ce que la programmation système :

La soi-disant programmation système, en termes simples, consiste à écrire diverses bibliothèques de fonctions. Par exemple, les bibliothèques win32 et gdi32 sous Windows, win32 peuvent appeler les fonctions du matériel hôte et de la couche système, et gdi32 peut être utilisé pour dessiner des graphiques. Ces bibliothèques n'attendent que que ceux qui en font la demande les appellent.

Qu'est-ce que la programmation d'application :

La programmation d'application consiste à utiliser diverses bibliothèques de fonctions système et bibliothèques de fonctions de langage qui ont été écrites pour écrire des programmes avec certaines fonctions métier. Un programme est une candidature. Par exemple, un programme d'exploration de base peut être réalisé à l'aide du langage Python et de la bibliothèque de requêtes, et un site Web de base peut être réalisé à l'aide du langage Java et de la bibliothèque Java Servlet.

La relation entre la programmation système et les rappels

Les programmeurs système laisseront certaines interfaces, c'est-à-dire les API, aux bibliothèques qu'ils écrivent pour être utilisées par les programmeurs d'applications. Ainsi, dans le diagramme de la couche d'abstraction, la bibliothèque se trouve sous l'application. Lorsque le programme est en cours d'exécution, dans des circonstances normales, l'application appelle souvent des fonctions pré-préparées dans la bibliothèque via l'API. Cependant, certaines fonctions de la bibliothèque nécessitent que l'application lui transmette d'abord une fonction, afin qu'elle puisse être appelée au moment approprié pour terminer la tâche cible. La fonction qui est transmise et appelée ultérieurement est appelée fonction de rappel .

Si vous êtes confus en lisant le texte, vous pouvez regarder l'image que j'ai dessinée (ci-dessous la figure 1) :

Avant de comprendre le rappel , comprenez-le d'abord Appel synchrone

L'appel synchrone est un appel bloquant En termes simples, il est exécuté de haut en bas dans l'ordre. Le rappel est une séquence d'appel asynchrone.

Le cas spécifique de l'appel synchrone peut être pensé à l'ancienne tour-phare. Le mécanisme de transmission des balises de l'ancienne Grande Muraille est similaire à l'appel synchrone. Nous supposons maintenant que chaque balise ne peut voir que l'état des balises adjacentes, et que l'état de chaque balise est uniquement brillant (état d'allumage) et sombre (état non d'allumage). .

Il y a quatre tours de balise A, B, C et D. A s'allume en premier. B voit la balise de A s'allumer et va immédiatement l'allumer. Cela prend 2 secondes pour s'allumer. Mais le responsable de la balise C dormait à ce moment-là, mais à ce moment-là tout le monde attendait que C s'allume. Finalement, C a dormi 2 heures et a vu B s'allumer, puis est allé l'allumer. D n'a pas été allumé pendant longtemps, ce qui a causé des problèmes avec la balise, donc tout le processus attendait que D soit terminé. (Cela a également conduit à réfléchir. Les appels synchrones sont parfois faciles à perdre la chaîne. Si la chaîne est perdue à l'étape précédente, les opérations après l'étape suivante seront terminées.)

Code de cas des appels synchrones :

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

Problèmes qui doivent être résolus avec des rappels

Les systèmes courants développeront de nombreuses bibliothèques, et il existe de nombreuses fonctions dans les bibliothèques. Certaines fonctions nécessitent que l'appelant écrive la fonction à appeler en fonction de ses propres besoins. Étant donné que cela ne peut pas être prédit lors de l'écriture de la bibliothèque et ne peut être saisi que par l'appelant, un mécanisme de rappel est nécessaire.

Le mécanisme de rappel est un moyen d'améliorer le mécanisme d'appel synchrone. Le mécanisme d'appel asynchrone est également utilisé pour améliorer le mécanisme d'appel synchrone. (J'écrirai un article plus tard pour présenter cet asynchrone plus important)

Exemples de la façon dont les fonctions de rappel résolvent des problèmes pratiques

Les rappels résolvent les problèmes ci-dessus des manières suivantes.

● Les fonctions peuvent être transformées en paramètres

● Appel de manière flexible et personnalisée

Cas de paramètre variable de fonction

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()

Résultat de sortie :

3
5

Cas d'appel flexible et personnalisé (l'hôtel réveille les passagers)

Cette affaire est vraiment l'âme du rappel Supposons que vous soyez la réceptionniste de l'hôtel, vous ne pouvez pas connaître les passagers qui le feront. enregistrez-vous ce soir Avez-vous besoin d'un réveil demain ? Quel type de réveil est nécessaire ?

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次电话，把你叫醒

Sortie :

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

Application pratique (le hook d'événement fourni avec la bibliothèque de requêtes de Python)

Ce cas est facile à résoudre L'original. Le programme est Le mécanisme de synchronisation est exécuté, mais grâce aux événements de hook, certaines étapes précédentes peuvent être exécutées en premier. Le principe de cet événement hook est le rappel de fonction.

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()

Sortie :

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

Cet article provient de la colonne tutoriel python, bienvenue pour apprendre !

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!