Analyse des fonctions d'ordre supérieur et des décorateurs de fonctions en Python

L'éditeur suivant vous apportera une discussion détaillée des fonctions d'ordre supérieur et des décorateurs de fonctions de Python (recommandé). L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Suivons l'éditeur et jetons un coup d'oeil ensemble

1 Revue de la section précédente

Problèmes d'encodage de caractères Python2 et Python3, que vous soyez. je suis débutant ou je connais déjà bien les projets Python, et je ferai quelques erreurs de codage. Je vais résumer brièvement les différences entre Python3 et Python2 ici.

Tout d'abord, Python3-->les fichiers de code sont tous interprétés en utf-8. Lorsque le code et les fichiers sont lus dans la mémoire, ils deviennent Unicode. C'est pourquoi Python code uniquement mais ne décode pas, car le codage des caractères dans la mémoire est modifié en Unicode, et Unicode est un code universel qui peut être « traduit » ainsi. l'encodage du format est format. En Python3, str et bytes sont deux formats et les bytes peuvent être utilisés comme représentation binaire.

Python2 utilise le codage de caractères par défaut du système pour interpréter le code, donc si vous souhaitez utiliser utf-8 pour interpréter le code, vous devez le déclarer dans l'en-tête et il y a le décodage et le codage dans Python2, mais l'action de décodage est nécessaire et l'action d'encodage peut être ignorée, car le code Python chargé dans la mémoire est Unicode, ce qui est le même que python3 ; une autre chose à noter dans Python2 est que str et bytes ont la même signification. La str dans Python2 est le format d'octets dans Python3, et la str dans Python3 est en fait Unicode.

Bases des fonctions (ici j'utilise la recherche binaire dans la fonction récursive)

Pourquoi utiliser les fonctions : Le programme sera conçu comme un module

Il existe trois formes de fonctions définies :

- fonction sans paramètre

- Fonction avec paramètres

- Fonction vide

PS : Si la fonction a plusieurs valeurs de retour, alors le retour format de données Est un tuple

- Comment limiter le format des données des paramètres lorsque la fonction passe des paramètres.

def leon(x:int,y:int)->int:

pass

où x et y sont spécifiés ici et doivent être de type int" -> ; " signifie que la valeur de retour de la fonction doit également être de type int

print(yan.__annotations__) : affiche le format de données limité des paramètres formels et le format de la valeur de retour

a = [1,2,3,4,5,7,9,10,11,12,14,15,16,17,19,21] #形参中的num
def calc(num,find_num):
 print(num)
 mid = int(len(num) / 2)   #中间数的下标
 if mid == 0: #递归函数非常重要的判断条件
 if num[mid] == find_num:
  print("find it %s"%find_num)
 else:
  print("cannt find num")
 if num[mid] == find_num: #直接找到不用递归，结束函数
 print("find_num %s"%find_num)
 elif num[mid] > find_num: #find_num应该在左边，向下递归
 calc(num[0:mid],find_num)

 elif num[mid] < find_num: #find_num应该在右边，向下递归
 calc(num[mid+1:],find_num)
calc(a,12)

Fonction anonyme

c = lambda x:x+1 #x就是形参，c就是这个匿名函数的对象

print(c(22))

Fonctions d'ordre supérieur

1. une fonction à une autre fonction, en tant que paramètre

2. Une fonction renvoie une autre fonction en tant que valeur de retour

def calc(a,b,c):
print(c(a) + c(b))

calc(-5,10,abs) #引用上一节的实例，将-5和10绝对值相加

2. Fonctions d'ordre supérieur (supplémentaires)

La fonction est un objet de première classe

La fonction peut se voir attribuer une valeur

peut être utilisé comme paramètre

peut être utilisé comme valeur de retour

peut être utilisé comme élément de type conteneur

#函数可以被赋值
def leon():
 print("in the leon")

l = leon
l()

#函数可以被当做参数
def yan(x): #这里x形参，其实就是我们调用实参的函数名
 x() #运行函数

y = yan(leon)


#函数当做返回值
def jian(x): 和上面一样这这也必须传入一个函数
 return x
j = jian(leon) #这里需要注意一点就是这里的意思是运行jian这个函数而这个函数返回的是x 也就是leon这个函数的内存地址，也就是说这时候leon这个函数并没有被执行
j() #运行 leon函数

#可以做为容器类型的元素
leon_dict = {"leon":leon}

leon_dict["leon"]() #这样也可以运行leon这个函数

3. Fonction de fermeture

1. Laissez-moi jeter un œil et comparer le concept sur le site officiel (ce n'est pas ce que j'ai trouvé sur le site officiel, mais ce n'est pas grave, vous ne pouvez pas le comprendre de toute façon) :

La fermeture est lexicale Fermeture L'abréviation de est une fonction qui fait référence à des variables libres. La variable libre référencée restera avec la fonction même après avoir quitté l'environnement dans lequel elle a été créée. Une fermeture est donc une entité composée d’une fonction et de son environnement de référence associé.

Vous êtes confus ? N'existe pas. J'en parlerai brièvement ci-dessous, mais une chose est très importante. La fermeture est le point clé chez les décorateurs. Si vous ne comprenez pas vraiment les fermetures, vous les oublierez rapidement après avoir appris les décorateurs. Illustrons-le à travers un exemple

import requests #首先导入一个模块，这个可以不用记

def get(url): #定义一个get函数里面需要传一个url的位置参数
 def wapper(): #在定义一个wapper函数
 res = requests.get(url) #这一步就是打开一个网页
 return res.text #将网页以文字的形式返回
 return wapper #返回最里层的wapper函数

g = get("http://www.baidu.com") #调用：首先因为作用域的原因，我们无法访问到里层的wapper函数，所以我们直接调用get函数这里返回了一个wapper函数
print(g()) # 然后我在调用g（get函数）的对象，这样是不是就访问到里层的wapper函数呢

PS : Ici, nous pouvons traiter la fonction comme une variable spéciale au démarrage du code. from Lors de l'exécution de haut en bas, si la fonction n'est pas appelée, le code de la fonction ne sera pas exécuté. Prenons l'exemple ci-dessus. Lorsque nous exécutons la fonction get, l'adresse mémoire d'une fonction wapper sera renvoyée. Cependant, la fonction wapper n'a pas été exécutée pour le moment. est en fait le wapper, cela signifie que nous devons uniquement exécuter g, ce qui équivaut à exécuter le code dans le wapper.

4. Appel imbriqué de fonctions

L'appel imbriqué est en fait facile à comprendre, c'est le résultat de l'appel d'une autre fonction au sein d'une fonction, qui est la chose de retour. De même, jetons un coup d'œil à un code très simple.

#嵌套调用，在一个函数中调用另一个函数的功能
#calc这个函数就是在对比两个数字的大小
def calc2(x,y):
 if x >y :
 return x
 else:
 return y

#我靠老板非常变态，然你直接计算四个数字的大小，擦。
def calc4(a,b,c,d):
 res1 = calc2(a,b) #res1的值，这里不就是calc2这个函数比较时最大的哪一个吗。
 res2 = calc2(res1,c)
 res3 = calc2(res2,d)
 return res3

Nous créons un souvenir grâce au code ci-dessus. Quand les appels imbriqués sont-ils utilisés ? Évidemment, notre fonction (calc4) a besoin du résultat d'exécution d'une autre fonction (retour y ou x).

5. Décorateur (fonction de fermeture avancée)

Prenons le code suivant comme exemple. Comment calculer le temps d'exécution du code sans changer le code source

def geturl(url):
 response = requests.get(url)
 print(response.status_code)

geturl(http://www.baidu.com)

def timer(func):
 def wapper(url):
 start_time = time.time()
 func(url)
 stop_time = time.time()
 so_time_is = stop_time - start_time
 print("运行时间%s"%so_time_is)
 return wapper


@timer
def geturl(url):
 response = requests.get(url)
 print(response.status_code)

python = geturl(http://www.baidu.com)

Code illustré

装饰器必备：

@timer就是装饰器，意思是装饰它下面的函数，而装饰器和被装饰的都是一个函数。

timer（装饰器函数），首先它会有一个位置参数（func）名字随意，但是必须并且只能是一个位置参数

func参数就是被装饰的geturl这个函数

为什么func是geturl这个函数呢-->上面写了一个装饰器功能：geturl=timer(geturl)，我们看到这里的timer中传入的其实就是func函数所以func = geturl（被装饰的函数）

分析geturl=timer(geturl)，首先我们可以得知timer这是一个闭包函数，当我们执行这个闭包函数，会把里层的函数（wapper）返回，也就是说timer(geturl)其实就是返回的wapper，所以就可以这样理解了geturl==wapper，所以当我们运行geturl的时候就相当于在执行wapper()这样的一个操作；如果这里实在记不住，就这样。咱上面不是有一个闭包函数吗？你就把geturl=timer(geturl)中的geturl(执行函数的返回结果)当做上面g（函数调用的返回结果），然后在分别再执行了下"g"或者"geturl”这个对象。

如果被装饰者有位置参数的话，我们需要在wapper函数中加上对应的位置参数用来接收，如果长度是不固定的话还可以用*args和**kwargs

六、有参装饰器

听着名字顾名思义，就是在装饰器中还有位置参数。

#一个low得不能再low得验证脚本，如果是显示环境中所有数据必须是由数据库或者一个静态文件提供，并且登录成功时，需要保存用户的一个状态

def auth(auth_type): #有参装饰器名称
 def auth_deco(func): #定义第二层函数名称
 def wrapper(*args,**kwargs): #最里层函数，主要实现认证功能
  if auth_type == "file":
  username = input("username>>:").strip()
  password = input("username>>").strip()
  if username == "leon" and password == "loveleon":
   res = func(*args,**kwargs)
   return res
  elif auth_type == "mysql_auth":
  print("mysql_auth...")
  return func(*args,**kwargs)
 return wrapper #第二层返回的是wrapper函数，其实就是home
 return auth_deco #第一层返回的结果等于第二层函数的名称

@auth('file')
def home():
 print("welcome")

home() #执行home-->wrapper

有参函数必备知识：

套路，通过上面无参装饰器，我们得出了geturl=timer(geturl)这个等式。回到有参装饰器，我们又会有什么样子的等式呢？首先@auth("file")是一个装饰器也就是一个函数，所以我们定义了一个auth(auth_type)这个函数，而这个函数返回的是什么呢？没有错就是第二层函数；到了这里我们就会发现@auth("file")其实就是@auth_deco，现在我们知道了现在装饰器其实就是auth_deco，那剩下的还不知道怎么写吗？

整理公式，auth('file')-----------(return)> auth_deco----->@auth_deco ->home=auth_deco(home)

如果记不住？如果实在是记不住，其实就可以这样理解，有参装饰器无非就是在无参装饰器上面加了一层(三层)，然后在第一层返回了第二层的函数，而到了第二层就和我们普通用的装饰器是一毛一样了

七、模块导入

import ，创建一个leonyan.py的模块文件，等待被导入

a = 10
b = 20
c = 30

def read1():
 print("in the read1")

def read2():
 print("in the read2")

导入leonyan.py文件（调用模块文件和模块文件在同一目录下）

import leonyan #Python IDE这行会爆红，但是不用管

leonyan.read1() #执行leonyan这个包中的read1函数

leonyan.read2() #执行leonyan这个包中read2函数

print(leonyan.a + leonyan.b + leonyan.c ) #输出60

总结：在Python中包的导入（import ***）会干三个事情：1：创建新的作用域；2：执行该作用域的顶级代码，比如你导入的那个包中有print执行后就会直接在屏幕中输出print的内容；3：得到一个模块名，绑定到该模块内的代码

在模块导入的时候给模块起别名

import leonyan as ly
import pandas as pd #这是一个第三方模块，以后的博客中会写到，这是一个用于做统计的

 

给模块起别名还是挺多的，在有些模块的官方文档中，还是比较推荐这种方法的，比如pandas的官方文档中就是起了一个pd别名，总之as就是一个模块起别名

from *** import ***

from leonyan import read1 #引入直接调用
read1()

 

如果在调用模块的函数作用域中有相同的同名的，会将调用过来的覆盖。

在form ** import ** 中控制需要引用的变量（函数其实在未被执行的时候也是一个存放在内存中的变量）

from leonyan import read1,read2 在同一行中可以引用多个，只需要用逗号隔开就行了

print(read1)
print(read2)
#这里打印的就是read1和read2的内存地址

#需求我现在只需要导入read2

这时候我们就可以在leonyan这个函数中加上这么一行：

__all__ = ["read2"] #这里的意思就是别的文件调用为的时候用from ** import ** 只能拿到read2 这个函数的内存地址，也就是只有read2可以被调用

把模块当做一个脚本执行

我们可以通过模块的全局变量__name__来查看模块名：

当做脚本运行：

__name__ 等于'__main__'

作用：用来控制.py文件在不同的应用场景下执行不同的逻辑

if __name__ == '__main__':

#fib.py

def fib(n): # write Fibonacci series up to n
 a, b = 0, 1
 while b < n:
 print(b, end=&#39; &#39;)
 a, b = b, a+b
 print()

def fib2(n): # return Fibonacci series up to n
 result = []
 a, b = 0, 1
 while b < n:
 result.append(b)
 a, b = b, a+b
 return result

if __name__ == "__main__":
 import sys
 fib(int(sys.argv[1]))

代码执行 Python flb.py 100

只需要简单了解的Python模块导入搜索路径

内建(build-in)  --> sys.path（sys.path是一个列表，而且第一个位置就是当前文件夹）

模块导入的重点-->包的导入

Dans un environnement de développement réel, vous ne pouvez pas écrire le code d'un fichier jusqu'au bout. Bien sûr, vous pouvez également référencer d'autres modules dans le même dossier, mais avez-vous déjà pensé que ce projet ne pouvait pas être écrit par vous seul ? , sont développés en collaboration par de nombreuses personnes. Cela crée un problème : il est impossible pour différentes personnes d'utiliser le même ordinateur et il est impossible d'écrire des fonctions dans le même dossier. Ils ont également leurs propres dossiers de code, puis chacun appelle les fonctions via des interfaces. A l’heure actuelle, nous sommes confrontés au problème de l’appel de ces différents dossiers. Ce type de problème doit également être appelé depuis ** import **.

Dans l'image ci-dessus, j'exécute le dossier "module import.py". Tout d'abord, j'importe la configuration depuis Pythonscript.leonyan.command, car nous devons exécuter le script. et les éléments qui doivent être importés. Les packages sont tous dans le répertoire Pythonscript, je les ai donc importés directement via le chemin absolu, puis je suis descendu couche par couche avec "." faire attention à une chose : lorsque le script est exécuté dans la couche la plus externe, sys. Le premier paramètre dans la liste des chemins est le répertoire dans lequel le script est exécuté. Qu'est-ce que cela signifie que vous avez appelé d'autres choses dans d'autres. Par exemple, mon config.py appelle le fichier bing.py. Vous devez écrire le chemin absolu car il ne peut plus être trouvé dans le dossier sys.path, ce qui signifie qu'il ne peut pas être importé.

Résumé : L'importation de packages est en fait très simple. Vous devez vous rappeler une chose : lorsque vous importez le Python intégré ou le module tiers téléchargé. , utilisez-le directement import import, si vous l'écrivez vous-même, utilisez simplement from ** import ** et utilisez le répertoire absolu pour importer, c'est-à-dire importez depuis le répertoire de niveau supérieur du script appelant. Cela garantit que les erreurs d’importation de module ne seront pas signalées.

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!