python函数修饰符

❶ python 中 @ 是什么意思

修饰符，比如说

class A:

@staticmethod

def m(self):

pass

就相当于

class A:

def m(self):

pass

m = staticmethod(m)

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

(1)python函数修饰符扩展阅读：

函数修饰符

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

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

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

❷ 这些python操作符都是什么意思或作用

其实，你就是对于基础知识，不了解而已。
相关的一些基础知识，也许对你有用：
【整理】Python语言简介
【教程】如何下载最新版的，各种版本的，包括Python 2.x和Python 3.x的Python
【教程】如何在Windows系统中安装Python
【整理】【多图详解】如何在Windows下开发Python：在cmd下运行Python脚本+如何使用Python Shell（command line模式和GUI模式）+如何使用Python IDE
等等等。。。

比如你要的模块方面的：

【教程】Python中的内置的模块 和第三方的模块
【待完善】【总结】Python安装第三方的库、package的方法
【已解决】Python中导入子文件夹中的模块

其他的不多说了，都整理到这里了，需要的话，自己去看吧：
【教程】Python开发入门详解

而另外，中级的，开发过程中有关的，都在这里：
【整理】Python开发过程中相关方面的知识

都看完，基本上就算懂了不少了。
剩下的，主要还是要靠你自己多练习。

（此处不给贴地址，请自己用google搜帖子标题，即可找到帖子地址）

❸ Python 有哪些优雅的代码实现让自己的代码更pythonic

写程序其实就跟写作文、遣词造句一样，会用成语会让你的文章显得老练，但是滥用成语就让人受不了了。程序也一样，重要的是要理解什么样的逻辑应当用什么样的语法来表达。其中关键的是让读代码的人是否容易理解，而不是执行起来是否正确。

以下是一些个人的见解。总的来说原则是：在代码中提供恰到好处的信息量，既不缺少，也不冗余

列表推导与循环
什么时候列表推导作为代码来说比较清晰？当读者能够清晰理解你这条语句是要生成一个列表，除此以外什么都没有做的时候。
比较：

new_list = [v[1] for v in old_list if v[2]]

和

new_list = []for v in old_list:
if v[2]:
new_list.append(v[1])

前者（对于熟练的程序员来说）明显更容易理解你的意图，即便不能一眼看清楚你所有的条件，他也能明白：这句语句只是将列表进行了一个格式的调整。
再比较

result = [v for v in iter(self.read_socket, '') if not v.startswith('+')]

和

result = []while True:
v = self.read_socket()
if v == '':
break
if not v.startswith('+'):
result.append(v)

前者明显就很糟糕，read_socket可能是个非常复杂、有明显副作用的过程，读代码的人不会期待你在这么短的语句当中完成个非常重要的逻辑。read_socket可能在里面抛出异常，你将没有机会给它加上try...except来进行处理，你也不会喜欢抛出的异常的堆栈信息里面有一堆<lambda> <genexpr>这样的意义不明的东西，而不是一个明确的行号。而且，很明显这是这段代码最重要的逻辑，这意味着这个逻辑以后可能会变更、会重构，你不会想要把一个列表推导变更得越来越复杂直到被迫推倒重来。
另外，用到map和filter的都要尽量重写成列表推导。

lambda表达式与具名函数
Python是支持函数嵌套定义的，在已有的函数中可以嵌套定义新的函数：

def my_func():
def subfunc():
...
subfunc()
...

嵌套的具名函数可以完全替代lambda表达式，而且有许多优点：

• 一个函数名可以迅速告诉读代码的人这个函数在做什么
  

• 抛出异常的时候，有函数名称明显要比显示为<lambda>强

• 可以添加比较复杂的逻辑

• 可以使用decorator

• 具名函数可以用yield（也就是说可以定义嵌套的具名的generator，但不能定义lambda的generator）
  

• 需要作为返回值的一部分的时候，在repr表达式当中能显示函数名，方便调试

一般来说lambda表达式的使用一定要严格限定为（与关系）：

• 非常简单的逻辑，尤其最好不要在lambda当中再嵌套列表推演或者生成器表达式或者其他lambda表达式，非常不清晰

• 没有副作用，或者只包装一个有副作用的表达式

• 一次性使用（绝对不要用f = lambda x: ...这样的语句，虽然只有一行，但读代码的时候会很难找到f的定义）

• 单返回值——使用tuple或者list的多返回值会让括号嵌套变得复杂难读懂。
  

例如：

• return lambda x: lambda y: x + y



和

• def add_closure(x):


• def add_func(y):


• return x + y


• return add_funcreturn add_closure



同样是嵌套的闭包，明显后一种写法要清晰得多，以后调试起来也要容易。

可以在列表推导当中嵌套lambda，但最好不要在lambda当中嵌套列表推导。在列表推导中使用lambda的时候，首先确定这个逻辑是必要的；其次，给这个列表起一个非常明确的变量名，说明这个列表中的函数起什么作用；第三，给lambda表达式加上括号，让人能比较清楚地看到lambda表达式的开始和结束；最后，一定要警惕闭包封闭循环变量的方式，非常容易出意料之外的bug。

• multipliers = [(lambda x, i = i: x * i) for i in range(0, 20)]



修饰符/注解（decorator）

修饰符是让代码变得优雅易读的非常重要的工具，正确运用能有非常多的好处。但也一定要注意：


1. decorator中只做定义和初始化的工作，不要用decorator来执行某个操作。或者说，decorator不要有除了定义以外的副作用

例如，严格杜绝下面的用法：

• def execute_once(f):


• f('test')



• @execute_once


• def my_func(param):


• ...



没有人会从代码中判断这个函数会在import的时候自动执行。而且，没有人会懂为什么my_func的值是None。

❹ Python 中 @ 符号在方法前定义是什么意思

这个是decorator，可以用来修改后面的那个函数的行为。具体做了什么不见得能从输入看出来啊，需要看源码。
光看名字猜测是把后面这个getmodel方法静态化了，也就是说这个方法变成类方法了，每个对象引用的都将是这个方法。

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

装饰函数，或者装饰语句

❻ Python 中的 classmethod 和 staticmethod 有什么具体用途

classmethod：类方法
staticmethod：静态方法

在python中，静态方法和类方法都是可以通过类对象和类对象实例访问。但是区别是：

@classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。

普通对象方法至少需要一个self参数，代表类对象实例

类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量cls是子类，而非父类。对于类方法，可以通过类来调用，就像C.f()，有点类似C＋＋中的静态方法, 也可以通过类的一个实例来调用，就像C().f()，这里C()，写成这样之后它就是类的一个实例了。

静态方法则没有，它基本上跟一个全局函数相同，一般来说用的很少

Example 1:

>>>classa():
@staticmethod
defstaticm():
print'static'
defnormalm(self):
print'nomarl',self
@classmethod
defclassm(cls):
print'class',cls


>>>a1=a()
>>>a1.normalm()
nomarl<__main__.ainstanceat0x84dddec>
>>>a1.staticm()
static
>>>a1.classm()
class__main__.a
>>>type(a)
<type'classobj'>
>>>type(a1)
<type'instance'>

Example 2:

classA(object):
@classmethod
defcm(cls):
print'类方法cm(cls)调用者：',cls.__name__
@staticmethod
defsm():
print'静态方法sm()被调用'
classB(A):
pass
A.cm()
B.cm()
A.sm()
B.sm()
输出：
类方法cm(cls)调用者：A
类方法cm(cls)调用者：B
静态方法sm()被调用
静态方法sm()被调用

@classmethod与@staticmethod的应用实例

#!/usr/bin/envpython
#-*-coding:utf-8-*-
classTClassStatic(object):
obj_num=0
def__init__(self,data):
self.data=data
TClassStatic.obj_num+=1
defprintself(self):
print("self.data:",self.data)
@staticmethod
defsmethod():
print("thenumberofobjis:",TClassStatic.obj_num)
@classmethod
defcmethod(cls):
print("cmethod:",cls.obj_num)
cls.smethod()
defmain():
objA=TClassStatic(10)
objB=TClassStatic(12)
objB.printself()
objA.smethod()
objB.cmethod()
print("------------------------------")
TClassStatic.smethod()
TClassStatic.cmethod()
if__name__=="__main__":
main()

输出结果如下：

('self.data:',12)
('thenumberofobjis:',2)
('cmethod:',2)
('thenumberofobjis:',2)
------------------------------
('thenumberofobjis:',2)
('cmethod:',2)
('thenumberofobjis:',2)

❼ python 如何用修饰符打造一个单例

defsingleton(cls):
instance=cls()
instance.__call__=lambda:instance
returninstance

@singleton
classHighlander:
x=100

if__name__=='__main__':

h=Highlander()

printtype(h)
printtype(Highlander)

❽ python 中的 类方法 @ classmathod 怎么用 请举一个最简单的例子

classmethod修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class A(object):

bar = 1

def func1(self):

print ('foo')

@classmethod

def func2(cls):

print ('func2')

print (cls.bar)

cls().func1() # 调用 foo 方法

A.func2() # 不需要实例化

输出为：

❾ Python中@是什么意思

修饰器，decorator，参见PEP 318: http://www.python.org/dev/peps/pep-0318/