3,23

Rappelant la section précédente

* args, ** kwargs

* args: * pour les arguments supplémentaires dans une position affectée à l'argument args
** kwargs, ** les arguments de mots-clés supplémentaires dictionnaire assignés à devenir kwargs
Dans les arguments , * une pause

  def index(*args,**kwargs):
      print(x,y)
  
  def wrapper(*args,**kwargs):  # (1,2,34),{'x':1,'y':2}
  	index(*args,**kwargs)  # index(1,2,34,x=1,y=2)
  	
  wrapper(1,2,34,x=1,y=2)

Dans ce format, le format des arguments pour passer l'appel intact wrapper index

Namespace et la portée

L'espace de noms de relation emboîtée fonction définition de la phase, à savoir pour déterminer le moment où la grammaire détectée
objet Fonction
- Il peut fonctionner comme argument à une autre fonction
- Il peut être utilisé comme valeurs de retour de la fonction

définition de la fonction emboîtée

Une fonction dans le paquet de fonction

def outter():
	def inner():
		pass
	return inner  # 不加括号，返回 inner的内存地址

fonction fermeture

Des fonctions intégrées, et cité son nom de fonction extérieure
```
def f1():
	x = 1
	y = 2
	z = 3

f1()
```
f1 espace normal après l'appel est terminé le nettoyage, mais si l'on le nom est une référence aux autres lieux, et que sa référence compte là, son espace de nom ne sera pas récupéré

Paramètre Mode passage

les valeurs des paramètres de forme en fonction de la passe

A titre de masse corporelle de fermeture en fonction de la valeur

def outter(x):
	def wrapper():
		print(x)
	return wrapper  # 处于局部
	
wrapper = outter(1)  # 处于全局

Namespace: espaces de noms différents peuvent utiliser le même nom, de sorte que le local à l'affectation de la fonction globale de la même fonction de nom est possible

cours régulier

décorateur

Qu'est-ce que

Fait référence à un dispositif d'outil, vous pouvez être défini en fonction
Décoratif fait référence à ajouter des fonctionnalités à d'autres outils
décorateur:

La définition d'un outil (classe, fonction, apprendre actuellement la seule fonction), utilisé pour ajouter des fonctionnalités à une autre fonction

Pourquoi utilisez-vous

Dans un véritable environnement de développement pour l'expansion de la fonction d' origine, devrait suivre le principe Ouvert Fermé , le logiciel ne peut pas être facilement modifié pour fonctionner en ligne ou hors

Ouvert Fermé: Voulez-vous ajouter de nouvelles fonctionnalités à une fonction, mais ne veulent pas changer le code source pour cette fonction

Ouvert: ouvert à étendre les fonctionnalités
Fermé: pour modifier le code source est fermé

Ajouter de nouvelles fonctionnalités à la fonction d'origine, il peut impliquer un certain nombre d'endroits, si une erreur, toute erreur de programme, conduit à lancer un corps.

Décoratrice n'est pas modifiée par des objets décoratifs et appelle le code source en vertu du principe, pour ajouter des fonctionnalités à la fonction d'origine

comment

Exemples

def index(x,y):
	print('index %s %s'%(x,y))
	
index(111,222)

Il y a une fonction normale, cette fonction serait maintenant à ajouter une nouvelle fonction, une fonction de statistiques de temps d'exécution

Procédé A: la modification du code source

Avec un module de temps time.timeretourne l'horodatage en cours: De 1970 à l'heure actuelle en secondes
fonctions courir avant time.time, après la fin de la course time.time, la fonction d'heure de fin décroissante du temps de démarrage est une fonction du temps d'exécution
```
import time
def index(x,y):
    start = time.time()
	time.sleep(1)
	print('index %s %s'%(x,y))
    end = time.time()
	print(end - start)

index(111,222)
```
Ne mettre en œuvre la fonction, il n'y a aucun moyen de modifier l'appel de fonction, mais modifier le code source, ne répond pas à l'Open Fermé Principe

Méthode deux: avant et après la déclaration d'appel ont été ajoutés

Avant et après l'appel avec time.time
```
import time
def index(x,y):
	time.sleep(1)
	print('index %s %s'%(x,y))
    
start = time.time()
index(111, 222)
end = time.time()
print(end - start)
```
Lorsqu'un besoin de compter à chaque fois, avant et après les appels d'ajouter ces quelques lignes de code pour obtenir sans modifier le code source, sans changer les appels à sens unique, mais dans de nombreux endroits ont besoin de cette nouvelle fonctionnalité, vous devez répéter pour écrire quelques mots déclaration, le code est redondant, inappropriée

Solution: décorateur

Utilisez des fermetures de fonction pour résoudre le problème de la redondance de code, mais est appelé à devenir enveloppe (), et l'indice est écrit 111222 morts

import time
def index(x,y):
	time.sleep(1)
	print('index %s %s'%(x,y))
	
def wrapper(x,y):
	start = time.time()
    index(111, 222)
    end = time.time()
    print(end - start)
   
wrapper()

Amélioration de 1, ne pas écrire l'emballage mort:
```
	index(x,y)
	...
wrapper(111,222)
```

Amélioré 2, **, vous pouvez passer plusieurs paramètres, paramètres écriture en vie :

def index(x,y,z):
	...
def wrapper(*args,**kwargs):
	...
	index(*args,**kwargs)
	
wrapper(111,222,33,444)

Amélioration de 3: index Préférez seulement une fonction décorative, toutes les fonctions peuvent être wrapper décorés voulait: un besoin de passer dans la fonction enveloppe comme paramètre, mais le paramètre ne peut pas être transmis dans cette fonction: l'utilisation de la fonction de fermeture à la fonction comme argument, la fonction d'écriture en direct
```
def outter(func):  # 把要装饰的函数当作参数传给装饰器的包
	def wrapper(*args,**kwargs):
		func(*args,**kwargs)
	return wrapper

def index(x,y):
	print(x,y)

f = outter(index)  # 实际上是运行了wrapper，wrapper中的func实际上是调用时当作参数传入的函数
f(1,2)
```
Résolu sans modifier le code source, écrivez lettre morte, mais aussi changé les appels à sens unique
Finale: ne change pas les appels à sens unique

Nommé fonction améliorée avec le nom de la fonction d'origine de perpétrer une fraude
```
index = outter(index)
index(1,2)
```

résumé de la méthode

Les éléments décoratifs en fonction de fermeture
Décoré dans le paquet de fonctionner comme un paramètre passé fonctions imbriquées
fonction de fermeture est décoré avec le paquet pour la fonction de l'objet, la fonction d'origine des paramètres reçus
Fonction package retourne fonction de la fonction de celle-ci imbriquée
Rebaptisé, perpétrer une fraude
```
index = outter(index)
index()
```

Pour obtenir l'effet final: les vrais

Cette approche a la fonction retourne d' origine une valeur au moment où le problème: la fonction d' origine a été remplacée par une fonction d'emballage, appelez l'index est en fait wrapper appel, alors que l'emballage ne retourne pas une valeur, il est nécessaire de permettre le retour de la valeur de retour de la fonction emballage d' origine

En fin de compte améliorer

Dans le décorateur, la valeur de retour retournée par la fonction d'origine devrait avoir

def outter(func):  # 把要装饰的函数当作参数传给装饰器的包
	def wrapper(*args,**kwargs):
		func(*args,**kwargs)
        res = func(*args,**kwargs)
        return res  # wrapper函数原函数的运行结果
	return wrapper  # 包函数在偷梁换柱的时候返回内嵌函数的函数体

def index(x,y):
	print(x,y)

index = outter(index)
index(1,2)

Enfin atteint, appelez la même manière, le même code source, la valeur de retour est le même, pour atteindre les vrais

@ Sucre syntactique nom décorateur

Chaque fonction décorative à perpétrer une fraude sur le nom de la fonction d'origine

```
  index = outter(index)
  index(1,2)
```

Il y a des déclarations sur cette syntaxe simple: écrire sur une ligne distincte est directement au- dessus des objets décoratifs @装饰器名字, python vous donner automatiquement perpétrer une fraude

  def timmer():  # 装饰器必须在被装饰函数的上面
  	...
  
  @timmer  # 相当于帮你做了 index = timmer(index)
  def index():
  	...

doit décorateur être placé au - dessus du décorateur , ou pour exécuter @ cette ligne de code, décorateur n'a pas encore été définie, une erreur

Une fonction peut être superposée pluralité de décorateur

ordre de chargement:

@deco1  # deco1.wrapper的内存地址 = deco1(index)
@deco2  # deco2.wrapper的内存地址 = deco2(index)
@deco3  # deco3.wrapper的内存地址 = deco3(index)
def index():
	...

résumé

Le modèle de base

def outter(func):
	def wrapper(*args,**kwargs):
		res = func()
		# 新功能
		...
		return res
	return wrapper

@outter
def index(x,y):
	# 原功能
    ...
    
index(x,y)

Cela devient un modèle, la fonction d'origine écrit index, de nouvelles fonctionnalités emballage écrites, vous obtenez un décorateur sans argument complet

notes d'étude Réseau environnement python épidémie sous 3,23