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/