1. Fonction anonyme
Expressions lambda Les expressions de
fonction lambda sont spécialement utilisées pour créer des fonctions simples. C'est une autre façon de créer des fonctions. C'est
une sorte de sucre syntaxique. Elle est généralement utilisée pour compléter des fonctions relativement simples. Les fonctions complexes ont également besoin d'écrire des fonctions régulières.
Les fonctions anonymes sont généralement utilisées comme paramètres et ne sont généralement pas utilisées ailleurs
- Syntaxe lambda parameter list [a, b, c…]: return value
Exemple: (lambda a, b: a + b) (10,20)
Examinons l'exemple de code suivant:
def fn5(a,b):
return a + b
print(fn5(23,56))
Après l'avoir remplacé par une expression lambda, la forme équivalente est la suivante:
fn6 = lambda a,b:a+b
print(fn6(30,20))
Vous pouvez également imprimer et écrire directement ensemble et consulter le code suivant:
print((lambda a,b : a+b)(10,20))
2. filtre filtre
filter (function, itérable)
peut filtrer les éléments éligibles de la séquence et les enregistrer dans une nouvelle séquence
Paramètre 1. Transférer le paramètre de fonction 2. Séquence
à filtrer Valeur de retour Nouvelle séquence après filtrage.
Nous utilisons lambda pour compléter une partie du contenu de la liste de filtres:
l = [1,2,3,4,5,6,7,8,9,10]
r = filter(lambda i : i > 5,l)
print(list(r))
3. carte ()
La fonction map () peut effectuer des opérations spécifiées sur tous les éléments de l'objet itérable, puis l'ajouter à un nouvel objet à renvoyer
l = [1,2,3,4,5,6,7,8,9,10]
r = map(lambda i : i + 1,l)
print(list(r))
4. tri ()
Cette méthode est utilisée pour
trier les éléments de la liste; la méthode sort () compare directement la taille des éléments de la liste par défaut;
une clé de paramètre de mot-clé peut être reçue dans la fonction sort (); la
clé nécessite une fonction comme paramètre;
# sort()方法是直接默认比较列表中元素的大小，是按照字符串进行比较，此时的数据类型要一致；
l = ['bb','aaaa','c','fff','dddddddd']
l.sort()
print(l)
# 我们改为按长度进行比较，在sort()函数中可以接收一个关键字参数 key；key需要一个函数作为参数
l = ['bb','aaaa','c','fff','dddddddd']
l.sort(key= len)
print(l)
Résultat de l'exécution:
['c', 'bb', 'fff', 'aaaa', 'dddddddd']
# 在sort()函数中可以接收一个关键字参数 key；
key需要一个函数作为参数
l = [2,3,'1',3,'5','4']
l.sort(key=int)
print(l)
Résultat de l'exécution: ['1', 2, 3, 3, '4', '5'] Le
code ci-dessus est également une application de fonctions avancées
5. trié ()
La valeur de retour est une nouvelle liste
l = [2,3,'1',3,'5','4']
#返回值 返回一个新的列表
print('排序前:',l)
r = sorted(l,key=int)
print('排序后:',r)
6. Fermeture
Renvoyer une fonction en tant que valeur de retour est également une fonction d'ordre supérieur (fermeture)
Avantages: Grâce à la fermeture, vous pouvez créer des variables auxquelles seule la fonction courante peut accéder (certaines données privées peuvent être cachées dans la fermeture)
###### Conditions pour former la fermeture
1. Imbrication des fonctions
2. Fonction interne Renvoyer comme valeur de retour
3. La fonction interne doit utiliser la variable de la fonction externe
###### Délai d'utilisation de la fermeture
Lorsque certaines de nos données ne veulent pas être consultées et modifiées par d'autres, cela peut garantir la sécurité de nos données
def fn():
a = 10
# 在函数内部在定义一个函数
def inner():
print('我是fn2',a)
# 将内部函数 inner()作为返回值返回
return inner
# r是一个函数，是调用fn()后返回的函数
# 这个函数在fn()内部定义的，并不是全局函数
# 所以这个函数总是能访问到fn()函数内部的变量
r = fn()
r()
Jetons un coup d'œil au code de cas de la fermeture:
# 求多个数的平均值
def make_average():
# 创建一个空的列表
nums = []
# 创建一个函数，用来求平均值
def average(n):
nums.append(n)
# 求平均值
return sum(nums)/len(nums)
return average
avg = make_average()
print(avg(30))
7. Référence au décorateur
Commençons par un morceau de code de cas:
# 打印开始计算 打印计算结束
def add(a,b):
# 求任意两个数的和
# print('计算开始...')
r = a + b
# print('计算结束...')
return r
def mul(a,b):
# 求任意两个数的积
return a * b
r = add(1,2)
print(r)
Grâce aux étapes ci-dessus pour répondre aux besoins actuels, nous avons trouvé les problèmes suivants:
1. S'il y a trop de fonctions à modifier, il sera
difficile de le modifier 2. Ce n'est pas pratique pour une maintenance ultérieure
3. Cela enfreindra un principe d'ouverture et de fermeture (ocp)
Lorsque nous développons, nous avons besoin de pouvoir ouvrir l'extension du programme, mais nous devons fermer la modification du programme.Nous pouvons étendre la
fonction sans modifier la fonction d'origine.
Jetez un œil au saut de code suivant:
def new_add(a,b):
print('函数开始执行......')
r = add(a,b)
print('函数执行结束......')
return r
s= new_add(1,2)
print(s)
A travers l'exemple ci-dessus, si nous voulons étendre la fonction d'origine, nous devons écrire plus de N nouvelles fonctions pour la supporter, ce qui n'est pas assez flexible
8. Utilisation de décorateurs
Nous regardons d'abord un morceau de code:
def start_end(old):
# 用来对其他函数进行扩展 是其他函数可以在执行前打印执行开始，执行后打印执行结束
# 创建一个函数 # *args 接收的是所有的位置参数
# **kwargs 接收所有的关键字参数
def new_function(*args,**kwargs):
print('开始执行.....')
# 调用被扩展的函数
result = old(*args,**kwargs)
print('开始结束.....')
return result
# 返回函数
return new_function
f = start_end(fn)
f2 = start_end(add)
# r = f()
r = f2(123,456)
print(r)
Les fonctions telles que start_end (old) sont appelées décorateurs;
grâce aux décorateurs, les fonctions peuvent être étendues sans modifier les fonctions d'origine. Dans le développement actuel, nous utilisons tous des décorateurs pour étendre les fonctions d'origine Fonction de
8.1 Une autre façon d'écrire des décorateurs
Vous pouvez ajouter le nom de la fonction @ devant la fonction nouvellement définie pour étendre la fonction d'origine
@fn
def fn1()
print('扩展')
fn1()