python中修饰器是什么？

就是一个callable object。 它使python编程更加容易。

创新互联长期为上千客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为北辰企业提供专业的网站建设、成都网站设计，北辰网站改版等技术服务。拥有十多年丰富建站经验和众多成功案例,为您定制开发。

例如：

@dec

def A(args):

pass

它就等价于dec(A). 当然还有带参数的decorator。我就不举例了。

python文档里有这样一句话。

A function definition may be wrapped by one or more decorator expressions. Decorator expressions are evaluated when the function is defined, in the scope that contains the function definition. The result must be a callable, which is invoked with the function object as the only argument. The returned value is bound to the function name instead of the function object. Multiple decorators are applied in nested fashion.

大概就是说函数的定义可以用多个decorator。decorator就在函数定义时用函数作为参数调用，然后返回一个可调用对象。 所以写decorator的时候一定要返回一个可调用对象。

不知道你明白没。

Python中的“ @”（@）符号有什么作用？

【@】符号在python中是装饰器的意思。

装饰器对一个可调用对象（函数、方法、类等等）进行装饰，它返回的也是一个可调用对象。

一般情况下，装饰器是对被装饰对象的修饰与增强。用现实事物类比的话，可以类比为中间商：中间商不生产产品，它将工厂生产的产品进行包装、运输后再销售给顾客。装饰器不实现核心功能，它提供对目标函数调用的封装与强。

它装饰的方法返回值是一个对象（BillList、Bill、List[BillDetail]等），而装饰器【enabled_cache】的作用如它的名称一样：使用缓存。可以看到，这个装饰器函数中定义了一个函数【wrapper】然后将这个wrapper作为返回值。这样，原本调用ProductionBos.bill_with_last_week的代码就不需要做任何改变就能享受到ProductionBos.bill_with_last_week原有的功能（得到一个BillList对象）和enabled_cache提供的附加功能（如果该对象有缓存，就不再从数据库查询）。

如何理解 Python

先来看一个简单例子：

def foo():

print('i am foo')

现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：

def foo():

print('i am foo')

logging.info("foo is running")

bar()、bar2()也有类似的需求，怎么做？再写一个logging在bar函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门处理日志 ，日志处理完之后再执行真正的业务代码

def use_logging(func):

logging.warn("%s is running" % func.__name__)

func()

def bar():

print('i am bar')

use_logging(bar)

逻辑上不难理解， 但是这样的话，我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢？当然有，答案就是装饰器。

简单装饰器

def use_logging(func):

def wrapper(*args, **kwargs):

logging.warn("%s is running" % func.__name__)

return func(*args, **kwargs)

return wrapper

def bar():

print('i am bar')

bar = use_logging(bar)

bar()

函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。

@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作

def use_logging(func):

def wrapper(*args, **kwargs):

logging.warn("%s is running" % func.__name__)

return func(*args)

return wrapper

@use_logging

def foo():

print("i am foo")

@use_logging

def bar():

print("i am bar")

bar()

如上所示，这样我们就可以省去bar = use_logging(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。

装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。

带参数的装饰器

装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@use_logging，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。

def use_logging(level):

def decorator(func):

def wrapper(*args, **kwargs):

if level == "warn":

logging.warn("%s is running" % func.__name__)

return func(*args)

return wrapper

return decorator

@use_logging(level="warn")

def foo(name='foo'):

print("i am %s" % name)

foo()

上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。

类装饰器

再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

class Foo(object):

def __init__(self, func):

self._func = func

def __call__(self):

print ('class decorator runing')

self._func()

print ('class decorator ending')

@Foo

def bar():

print ('bar')

bar()

functools.wraps

使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：

装饰器

def logged(func):

def with_logging(*args, **kwargs):

print func.__name__ + " was called"

return func(*args, **kwargs)

return with_logging

函数

@logged

def f(x):

"""does some math"""

return x + x * x

该函数完成等价于：

def f(x):

"""does some math"""

return x + x * x

f = logged(f)

不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。

print f.__name__ # prints 'with_logging'

print f.__doc__ # prints None

这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。

from functools import wraps

def logged(func):

@wraps(func)

def with_logging(*args, **kwargs):

print func.__name__ + " was called"

return func(*args, **kwargs)

return with_logging

@logged

def f(x):

"""does some math"""

return x + x * x

print f.__name__ # prints 'f'

print f.__doc__ # prints 'does some math'

内置装饰器

@staticmathod、@classmethod、@property

装饰器的顺序

@a

@b

@c

def f ():

等效于

f = a(b(c(f)))

python让一个循环不影响其他代码

循环是一种常用的程序控制结构。我们常说，机器相比人类的最大优点之一，就是机器可以不眠不休的重复做某件事情，但人却不行。而“循环”，则是实现让机器不断重复工作的关键概念。

在循环语法方面，Python 表现的即传统又不传统。它虽然抛弃了常见的 for(init;condition;incrment) 三段式结构，但还是选择了 for 和 while 这两个经典的关键字来表达循环。绝大多数情况下，我们的循环需求都可以用 forin来满足， while相比之下用的则更少些。

虽然循环的语法很简单，但是要写好它确并不容易。在这篇文章里，我们将探讨什么是“地道”的循环代码，以及如何编写它们。

什么是“地道”的循环？

“地道”这个词，通常被用来形容某人做某件事情时，非常符合当地传统，做的非常好。打个比方，你去参加一个朋友聚会，同桌的有一位广东人，对方一开口，句句都是标准京腔、完美儿化音。那你可以对她说：“您的北京话说的真地道”。

既然“地道”这个词形容的经常是口音、做菜的口味这类实实在在的东西，那“地道”的循环代码又是什么意思呢？让我拿一个经典的例子来解释一下。

如果你去问一位刚学习 Python 一个月的人：“如何在遍历一个列表的同时获取当前下标？”。他可能会交出这样的代码：



上面的循环虽然没错，但它确一点都不“地道”。一个拥有三年 Python 开发经验的人会说，代码应该这么写：

enumerate() 是 Python 的一个内置函数，它接收一个“可迭代”对象作为参数，然后返回一个不断生成 (当前下标,当前元素) 的新可迭代对象。这个场景使用它最适合不过。

所以，在上面的例子里，我们会认为第二段循环代码比第一段更“地道”。因为它用更直观的代码，更聪明的完成了工作。

enumerate() 所代表的编程思路

不过，判断某段循环代码是否地道，并不仅仅是以知道或不知道某个内置方法作为标准。我们可以从上面的例子挖掘出更深层的东西。

如你所见，Python 的 for 循环只有 forin这一种结构，而结构里的前半部分 - 赋值给 item- 没有太多花样可玩。所以后半部分的 可迭代对象 是我们唯一能够大做文章的东西。而以 enumerate() 函数为代表的“修饰函数”，刚好提供了一种思路：通过修饰可迭代对象来优化循环本身。

这就引出了我的第一个建议。

建议1：使用函数修饰被迭代对象来优化循环

使用修饰函数处理可迭代对象，可以在各种方面影响循环代码。而要找到合适的例子来演示这个方法，并不用去太远，内置模块 itertools 就是一个绝佳的例子。

简单来说，itertools 是一个包含很多面向可迭代对象的工具函数集。我在之前的系列文章《容器的门道》里提到过它。

如果要学习 itertools，那么 Python 官方文档 是你的首选，里面有非常详细的模块相关资料。但在这篇文章里，侧重点将和官方文档稍有不同。我会通过一些常见的代码场景，来详细解释它是如何改善循环代码的。

1. 使用 product 扁平化多层嵌套循环

虽然我们都知道“扁平的代码比嵌套的好”。但有时针对某类需求，似乎一定得写多层嵌套循环才行。比如下面这段：



对于这种需要嵌套遍历多个对象的多层循环代码，我们可以使用 product() 函数来优化它。product() 可以接收多个可迭代对象，然后根据它们的笛卡尔积不断生成结果。



相比之前的代码，使用 product() 的函数只用了一层 for 循环就完成了任务，代码变得更精炼了。

2. 使用 islice 实现循环内隔行处理

有一份包含 Reddit 帖子标题的外部数据文件，里面的内容格式是这样的：



可能是为了美观，在这份文件里的每两个标题之间，都有一个 "---" 分隔符。现在，我们需要获取文件里所有的标题列表，所以在遍历文件内容的过程中，必须跳过这些无意义的分隔符。

参考之前对 enumerate() 函数的了解，我们可以通过在循环内加一段基于当前循环序号的 if 判断来做到这一点：



但对于这类在循环内进行隔行处理的需求来说，如果使用 itertools 里的 islice() 函数修饰被循环对象，可以让循环体代码变得更简单直接。

islice(seq,start,end,step) 函数和数组切片操作（ list[start:stop:step] ）有着几乎一模一样的参数。如果需要在循环内部进行隔行处理的话，只要设置第三个递进步长参数 step 值为 2 即可（默认为 1）。



3. 使用 takewhile 替代 break 语句

有时，我们需要在每次循环开始时，判断循环是否需要提前结束。比如下面这样：



对于这类需要提前中断的循环，我们可以使用 takewhile() 函数来简化它。takewhile(predicate,iterable)会在迭代 iterable 的过程中不断使用当前对象作为参数调用 predicate 函数并测试返回结果，如果函数返回值为真，则生成当前对象，循环继续。否则立即中断当前循环。

使用 takewhile 的代码样例：



itertools 里面还有一些其他有意思的工具函数，他们都可以用来和循环搭配使用，比如使用 chain 函数扁平化双层嵌套循环、使用 zip_longest 函数一次同时循环多个对象等等。

篇幅有限，我在这里不再一一介绍。如果有兴趣，可以自行去官方文档详细了解。

4. 使用生成器编写自己的修饰函数

除了 itertools 提供的那些函数外，我们还可以非常方便的使用生成器来定义自己的循环修饰函数。

让我们拿一个简单的函数举例：



在上面的函数里，循环体内为了过滤掉所有奇数，引入了一条额外的 if 判断语句。如果要简化循环体内容，我们可以定义一个生成器函数来专门进行偶数过滤：



将 numbers 变量使用 even_only 函数装饰后， sum_even_only_v2 函数内部便不用继续关注“偶数过滤”逻辑了，只需要简单完成求和即可。

Hint：当然，上面的这个函数其实并不实用。在现实世界里，这种简单需求最适合直接用生成器/列表表达式搞定：sum(numfornuminnumbersifnum%2==0)

建议2：按职责拆解循环体内复杂代码块

我一直觉得循环是一个比较神奇的东西，每当你写下一个新的循环代码块，就好像开辟了一片黑魔法阵，阵内的所有内容都会开始无休止的重复执行。

但我同时发现，这片黑魔法阵除了能带来好处，它还会引诱你不断往阵内塞入越来越多的代码，包括过滤掉无效元素、预处理数据、打印日志等等。甚至一些原本不属于同一抽象的内容，也会被塞入到同一片黑魔法阵内。

python 中 @ 是什么意思

修饰符，比如说

class A:

@staticmethod

def m(self):

pass

就相当于

class A:

def m(self):

pass

m = staticmethod(m)

其实就是一调用一个函数参数为下行的变量，并且替换它

扩展资料：

函数修饰符

@用做函数的修饰符，可以在模块或者类的定义层内对函数进行修饰，出现在函数定义的前一行，不允许和函数定义在同一行。

一个修饰符就是一个函数，它将被修饰的函数作为参数，并返回修饰后的同名函数或其他可调用的东西。

在Python的函数中偶尔会看到函数定义的上一行有@functionName的修饰，当解释器读到@这样的修饰符的时候会优先解除@后的内容，直接就把@的下一行的函数或者类作为@后边函数的参数，然后将返回值赋给下一个修饰的函数对象。

参考资料来源：百度百科-Python （计算机程序设计语言）

本文名称：包含python修饰函数吗的词条
文章源于：http://abwzjs.com/article/dochooe.html