578

मैं कुछ पायथन कोड देख रहा हूं जिसमें @प्रतीक का उपयोग किया गया था , लेकिन मुझे नहीं पता कि यह क्या करता है। मुझे यह भी नहीं पता है कि पायथन डॉक्स की खोज के लिए क्या खोज करना है या @प्रतीक शामिल होने पर Google प्रासंगिक परिणाम वापस नहीं करता है।

python syntax python-decorators

— AJ00200
स्रोत

303

एक @पंक्ति की शुरुआत में एक प्रतीक का उपयोग वर्ग, फ़ंक्शन और विधि सज्जाकारों के लिए किया जाता है ।

यहाँ और पढ़ें:

पीईपी 318: सज्जाकार

पायथन डेकोरेटर्स

सबसे आम पायथन सज्जाकार आप में भाग लेंगे:

@संपत्ति

@classmethod

@staticmethod

यदि आप @एक पंक्ति के मध्य में देखते हैं , तो यह एक अलग बात है, मैट्रिक्स गुणन। अन्य उत्तरों को देखने के लिए नीचे स्क्रॉल करें जो उस पते का उपयोग करते हैं @।

— FogleBird
स्रोत

31

ऐसा लगता है कि यह एक मैट्रिक्स गुणन ऑपरेटर भी हो सकता है: stackoverflow.com/a/21563036/5049813

— Pro Q

@decorators भी जोड़ा जा सकता है

— विजय पांचाल

346

उदाहरण

class Pizza(object):
    def __init__(self):
        self.toppings = []

    def __call__(self, topping):
        # When using '@instance_of_pizza' before a function definition
        # the function gets passed onto 'topping'.
        self.toppings.append(topping())

    def __repr__(self):
        return str(self.toppings)

pizza = Pizza()

@pizza
def cheese():
    return 'cheese'
@pizza
def sauce():
    return 'sauce'

print pizza
# ['cheese', 'sauce']

यह दिखाता है कि function/ method/ classआप के बाद एक तय कर रहे हैं डेकोरेटर सिर्फ मूल रूप से एक के रूप में पारित हो जाता है argumentकरने के लिए function/ methodके तुरंत बाद @हस्ताक्षर।

प्रथम दर्शन

माइक्रोफ़्रामवर्क फ्लास्क निम्नलिखित प्रारूप में शुरू से ही सज्जाकारों का परिचय देता है :

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

यह बदले में इसका अनुवाद करता है:

rule      = "/"
view_func = hello
# They go as arguments here in 'flask/app.py'
def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
    pass

इसे साकार करते हुए आखिरकार मैंने फ्लास्क के साथ शांति का अनुभव किया।

— मॉर्गन वाइल्ड
स्रोत

7

मामले में फ्लास्क app.route("/"): यह फ़ंक्शन एक फ़ंक्शन देता है, जिसे आप hello()एक तर्क के रूप में अपने साथ आमंत्रित करते हैं

— shaqed

3

डेकोरेटर होने के यहाँ क्या वाक्यात्मक या व्यावहारिक लाभ है, इसके बजाय (उदाहरण के लिए) सिर्फ app.route("/", hello)परिभाषित करने के तुरंत बाद कुछ कॉल करना hello, या यहाँ तक helloकि तर्क में लंबोदर के रूप में परिभाषित करना app.route? (उत्तरार्द्ध उदाहरण Node.js http.Serverऔर एक्सप्रेस मार्गों के साथ आम है ।)

— आयनो

185

यह कोड स्निपेट:

def decorator(func):
   return func

@decorator
def some_func():
    pass

इस कोड के बराबर है:

def decorator(func):
    return func

def some_func():
    pass

some_func = decorator(some_func)

डेकोरेटर की परिभाषा में आप कुछ संशोधित चीजें जोड़ सकते हैं जो सामान्य रूप से एक फ़ंक्शन द्वारा वापस नहीं किया जाएगा।

— माथियस अरुजो
स्रोत

1

इस पंक्ति में "ome_func = डेकोरेटर (some_func)", पहले some_func एक वेरिएबल = function some_func, सही है?

— विराग जू 19 ’

147

पायथन 3.5 में आप @ऑपरेटर के रूप में ओवरलोड कर सकते हैं । इसे नाम दिया गया है __matmul__, क्योंकि यह मैट्रिक्स गुणा करने के लिए डिज़ाइन किया गया है, लेकिन यह कुछ भी हो सकता है जिसे आप चाहते हैं। देखें PEP465 जानकारी के लिए।

यह मैट्रिक्स गुणा का एक सरल कार्यान्वयन है।

class Mat(list):
    def __matmul__(self, B):
        A = self
        return Mat([[sum(A[i][k]*B[k][j] for k in range(len(B)))
                    for j in range(len(B[0])) ] for i in range(len(A))])

A = Mat([[1,3],[7,5]])
B = Mat([[6,8],[4,2]])

print(A @ B)

यह कोड पैदावार:

[[18, 14], [62, 66]]

— jinhwanlazy
स्रोत

14

आपके पास @=(इन-प्लेस) ऑपरेटर भी है, जो है __imatmul__।

— पाएल जीडी

क्या इस तरह के कोई अन्य अतिदेय ऑपरेटर हैं? मुझे पता है __add__और __sub__क्रमशः + और - से जुड़े हुए हैं, लेकिन पहले कभी भी @संकेत के बारे में नहीं सुना था । क्या कोई अन्य वहाँ दुबका हुआ है?

— थॉमस किम्बर

103

पायथन में "एट" (@) प्रतीक क्या करता है?

संक्षेप में, इसका उपयोग डेकोरेटर सिंटैक्स और मैट्रिक्स गुणा के लिए किया जाता है।

सज्जाकारों के संदर्भ में, यह वाक्य रचना:

@decorator
def decorated_function():
    """this function is decorated"""

इसके बराबर है:

def decorated_function():
    """this function is decorated"""

decorated_function = decorator(decorated_function)

आव्यूह गुणन के संदर्भ में, a @ bका आह्वान a.__matmul__(b)- इस वाक्य बनाने:

a @ b

के बराबर

dot(a, b)

तथा

a @= b

के बराबर

a = dot(a, b)

जहां dotहै, उदाहरण के लिए, numpy आव्यूह गुणन समारोह और aऔरb मैट्रिक्स कर रहे हैं।

आप इसे अपने दम पर कैसे खोज सकते हैं?

मुझे यह भी नहीं पता है कि पायथन डॉक्स या Google को खोजने के लिए क्या खोजना है जब @ प्रतीक शामिल होने पर प्रासंगिक परिणाम वापस नहीं आते हैं।

यदि आप एक विशेष रूप से अजगर सिंटैक्स का एक विशेष टुकड़ा क्या है के बारे में पूरी तरह से देखना चाहते हैं, तो सीधे व्याकरण फ़ाइल को देखें। अजगर 3 शाखा के लिए:

~$ grep -C 1 "@" cpython/Grammar/Grammar 

decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
decorators: decorator+
--
testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [',']
augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' |
            '<<=' | '>>=' | '**=' | '//=')
--
arith_expr: term (('+'|'-') term)*
term: factor (('*'|'@'|'/'|'%'|'//') factor)*
factor: ('+'|'-'|'~') factor | power

हम यहां देख सकते हैं कि @तीन संदर्भों में इसका उपयोग किया जाता है:

सज्जाकार
कारकों के बीच एक ऑपरेटर
एक संवर्धित असाइनमेंट ऑपरेटर

डेकोरेटर सिंटेक्स:

"डेकोरेटर पायथन डॉक्स" के लिए एक Google खोज शीर्ष परिणामों में से एक के रूप में देता है, "पायथन लैंग्वेज रेफरेंस" का "कंपाउंड स्टेटमेंट्स" खंड। फ़ंक्शन परिभाषाओं पर अनुभाग तक स्क्रॉल करना , जिसे हम शब्द "डेकोरेटर" के लिए खोज कर पा सकते हैं, हम देखते हैं कि ... पढ़ने के लिए बहुत कुछ है। लेकिन शब्द, "डेकोरेटर" शब्दकोष का एक लिंक है , जो हमें बताता है:

डेकोरेटर

एक फ़ंक्शन दूसरे फ़ंक्शन को लौटाता है, आमतौर पर @wrapperसिंटैक्स का उपयोग करके फ़ंक्शन परिवर्तन के रूप में लागू किया जाता है । सज्जाकारों के लिए सामान्य उदाहरण हैं classmethod()और staticmethod()।

डेकोरेटर सिंटैक्स केवल वाक्यगत चीनी है, निम्नलिखित दो फ़ंक्शन परिभाषाएं शब्दार्थ के बराबर हैं:
def f(...):
    ...
f = staticmethod(f)

@staticmethod
def f(...):
    ...
कक्षाओं के लिए एक ही अवधारणा मौजूद है, लेकिन वहां कम सामान्यतः उपयोग किया जाता है। डेकोरेटर के बारे में अधिक के लिए फ़ंक्शन परिभाषा और वर्ग परिभाषा के लिए प्रलेखन देखें।

तो, हम देखते हैं कि

@foo
def bar():
    pass

शब्दार्थ समान है:

def bar():
    pass

bar = foo(bar)

वे बिल्कुल समान नहीं हैं क्योंकि पायथन डेकोरेटर ( @) सिंटैक्स के साथ बार से पहले फू एक्सप्रेशन (जो एक बिंदीदार लुकअप और एक फंक्शन कॉल हो सकता है ) का मूल्यांकन करता है, लेकिन दूसरे मामले में बार के बाद फू एक्सप्रेशन का मूल्यांकन करता है।

_{(यदि यह अंतर आपके कोड के अर्थ में अंतर करता है, तो आपको इस बात पर पुनर्विचार करना चाहिए कि आप अपने जीवन के साथ क्या कर रहे हैं, क्योंकि यह रोगविज्ञान होगा।)}

स्टैक्ड डेकोरेटर्स

अगर हम फ़ंक्शन डेफिनिशन सिंटैक्स डॉक्यूमेंट में वापस जाते हैं, तो हम देखते हैं:

@f1(arg)
@f2
def func(): pass

के बराबर है

def func(): pass
func = f1(arg)(f2(func))

यह एक प्रदर्शन है जिसे हम एक फ़ंक्शन कह सकते हैं जो पहले एक डेकोरेटर है, साथ ही स्टैक डेकोरेटर भी। कार्य, पायथन में, प्रथम श्रेणी की वस्तुएं हैं - जिसका अर्थ है कि आप एक फ़ंक्शन को किसी अन्य फ़ंक्शन के तर्क के रूप में पास कर सकते हैं, और फ़ंक्शन वापस कर सकते हैं। सज्जाकार इन दोनों चीजों को करते हैं।

यदि हम डेकोरेटर्स को स्टैक करते हैं, तो फंक्शन, जैसा कि परिभाषित किया गया है, डेकोरेटर को तुरंत उसके ऊपर से पास किया जाता है, फिर अगला, और इसी तरह।

कि @सज्जाकारों के संदर्भ में उपयोग के बारे में है।

परिचालक, `@`

भाषा संदर्भ के लेक्सिकल विश्लेषण अनुभाग में, हमारे पास ऑपरेटरों पर एक अनुभाग है , जिसमें शामिल है @, जो इसे एक ऑपरेटर भी बनाता है:

निम्नलिखित टोकन ऑपरेटर हैं:

+       -       *       **      /       //      %      @
<<      >>      &       |       ^       ~
<       >       <=      >=      ==      !=

और अगले पृष्ठ में, डेटा मॉडल, हमारे पास न्यूमेरिक प्रकार का अनुकरण करने वाला अनुभाग है ,

object.__add__(self, other)
object.__sub__(self, other) 
object.__mul__(self, other) 
object.__matmul__(self, other) 
object.__truediv__(self, other) 
object.__floordiv__(self, other)
[...] इन विधियों द्विआधारी अंकगणितीय आपरेशनों (लागू करने के लिए कहा जाता है +, -, *, @, /, //, [...]

और हम देखते हैं कि इससे __matmul__मेल खाता है @। यदि हम "मैटमुल" के लिए दस्तावेज खोजते हैं, तो हमें "PEP 465 - मैट्रिक्स गुणा के लिए एक समर्पित इन्फिक्स ऑपरेटर" शीर्षक के तहत "मेटमुल" के साथ नया क्या है ।

इसे परिभाषित करके __matmul__(), __rmatmul__()और __imatmul__()नियमित रूप से, प्रतिबिंबित और इन-प्लेस मैट्रिक्स गुणन के लिए लागू किया जा सकता है।

(इसलिए अब हम सीखते हैं कि @=इन-प्लेस संस्करण है)। यह आगे बताता है:

गणित, विज्ञान, इंजीनियरिंग के कई क्षेत्रों में मैट्रिक्स गुणा एक विशेष रूप से सामान्य ऑपरेशन है, और @ के अलावा क्लीनर कोड लिखने की अनुमति देता है:
S = (H @ beta - r).T @ inv(H @ V @ H.T) @ (H @ beta - r)
के बजाय:
S = dot((dot(H, beta) - r).T,
        dot(inv(dot(dot(H, V), H.T)), dot(H, beta) - r))

हालांकि इस ऑपरेटर को लगभग कुछ भी करने के लिए अधिभारित किया जा सकता है numpy, उदाहरण के लिए, हम इस सिंटैक्स का उपयोग सरणियों और मैट्रिस के आंतरिक और बाहरी उत्पाद की गणना करने के लिए करेंगे:

>>> from numpy import array, matrix
>>> array([[1,2,3]]).T @ array([[1,2,3]])
array([[1, 2, 3],
       [2, 4, 6],
       [3, 6, 9]])
>>> array([[1,2,3]]) @ array([[1,2,3]]).T
array([[14]])
>>> matrix([1,2,3]).T @ matrix([1,2,3])
matrix([[1, 2, 3],
        [2, 4, 6],
        [3, 6, 9]])
>>> matrix([1,2,3]) @ matrix([1,2,3]).T
matrix([[14]])

Inplace मैट्रिक्स गुणन: `@=`

पूर्व के उपयोग पर शोध करते समय, हम सीखते हैं कि इनप्ले मैट्रिक्स गुणन भी है। यदि हम इसका उपयोग करने का प्रयास करते हैं, तो हम पा सकते हैं कि यह अभी तक लागू नहीं हुआ है:

>>> m = matrix([1,2,3])
>>> m @= m.T
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: In-place matrix multiplication is not (yet) supported. Use 'a = a @ b' instead of 'a @= b'.

जब इसे लागू किया जाता है, तो मैं उम्मीद करूंगा कि परिणाम इस तरह दिखाई देगा:

>>> m = matrix([1,2,3])
>>> m @= m.T
>>> m
matrix([[14]])

— हारून हॉल
स्रोत

36

पायथन में "एट" (@) प्रतीक क्या करता है?

@ प्रतीक एक वाक्य रचना चीनी अजगर का उपयोग करने के लिए प्रदान करता है decorator,
प्रश्न को स्पष्ट करने के लिए , यह वास्तव में पायथन में डेकोरेटर क्या करता है?

इसे सरल रखें decoratorआप किसी दिए गए फ़ंक्शन की परिभाषा को उसके अंतर को छूने के बिना संशोधित कर सकते हैं (यह बंद है)।
यह सबसे ज्यादा मामला है जब आप थर्ड पार्टी से अद्भुत पैकेज आयात करते हैं। आप इसकी कल्पना कर सकते हैं, आप इसका उपयोग कर सकते हैं, लेकिन आप इसके अंतरतम और इसके दिल को नहीं छू सकते।

यहां एक त्वरित उदाहरण है,
मान लीजिए कि मैं read_a_bookइफ्थॉन पर एक फ़ंक्शन को परिभाषित करता हूं

In [9]: def read_a_book():
   ...:     return "I am reading the book: "
   ...: 
In [10]: read_a_book()
Out[10]: 'I am reading the book: '

आप देखिए, मैं इसमें नाम जोड़ना भूल गया।
ऐसी समस्या को कैसे हल करें? बेशक, मैं समारोह को फिर से परिभाषित कर सकता हूं:

def read_a_book():
    return "I am reading the book: 'Python Cookbook'"

फिर भी, क्या होगा अगर मुझे मूल फ़ंक्शन में हेरफेर करने की अनुमति नहीं है, या यदि ऐसे हजारों फ़ंक्शन को संभाला जाए।

अलग-अलग सोचकर समस्या का समाधान करें और new_function को परिभाषित करें

def add_a_book(func):
    def wrapper():
        return func() + "Python Cookbook"
    return wrapper

फिर इसे नियोजित करें।

In [14]: read_a_book = add_a_book(read_a_book)
In [15]: read_a_book()
Out[15]: 'I am reading the book: Python Cookbook'

टाडा, तुम देखो, मैं read_a_bookइसे बंद करने के भीतर को छूने के बिना संशोधन किया । मेरे साथ सुसज्जित कुछ भी नहीं रोकता है decorator।

इसके बारे में क्या @

@add_a_book
def read_a_book():
    return "I am reading the book: "
In [17]: read_a_book()
Out[17]: 'I am reading the book: Python Cookbook'

@add_a_bookएक फैंसी और आसान तरीका है read_a_book = add_a_book(read_a_book), यह एक वाक्यात्मक चीनी है, इसके बारे में अधिक कट्टरपंथी कुछ भी नहीं है।

— गणना
स्रोत

16

यदि आप एक पायथन नोटबुक में कुछ कोड का उल्लेख कर रहे हैं जो Numpy लाइब्रेरी का उपयोग कर रहा है, तो @ operatorइसका मतलब है मैट्रिक्स गुणन । उदाहरण के लिए:

import numpy as np
def forward(xi, W1, b1, W2, b2):
    z1 = W1 @ xi + b1
    a1 = sigma(z1)
    z2 = W2 @ a1 + b2
    return z2, a1

— f__society
स्रोत

8

पायथन 3.5 के साथ शुरू, '@' का उपयोग MATRIX MULTIPLICATION (PEP 0465 - https://www.python.org/dev/peps/pep-0465/ ) के लिए एक समर्पित इनफ़िक्स प्रतीक के रूप में किया जाता है

— dpodbori
स्रोत

6

पायथन में फंक्शन और मेथड रैपिंग करने के लिए डेकोरेटर्स को जोड़ा गया (एक फंक्शन जो एक फंक्शन प्राप्त करता है और एक बढ़ाया हुआ रिटर्न देता है) पढ़ने और समझने में आसान होता है। मूल उपयोग का मामला उनकी परिभाषा के सिर पर वर्ग विधियों या स्थिर तरीकों के रूप में विधियों को परिभाषित करने में सक्षम होना था। डेकोरेटर सिंटैक्स के बिना, इसे एक विरल और दोहराव की आवश्यकता होगी:

class WithoutDecorators:
def some_static_method():
    print("this is static method")
some_static_method = staticmethod(some_static_method)

def some_class_method(cls):
    print("this is class method")
some_class_method = classmethod(some_class_method)

यदि डेकोरेटर सिंटैक्स का उपयोग उसी उद्देश्य के लिए किया जाता है, तो कोड छोटा और समझने में आसान होता है:

class WithDecorators:
    @staticmethod
    def some_static_method():
        print("this is static method")

    @classmethod
    def some_class_method(cls):
        print("this is class method")

सामान्य वाक्यविन्यास और संभावित कार्यान्वयन

डेकोरेटर आम तौर पर एक नामित वस्तु है ( लैम्ब्डा एक्सप्रेशन की अनुमति नहीं है ) जो किसी एकल तर्क को स्वीकार करता है जब उसे बुलाया जाता है (यह सजाया गया फ़ंक्शन होगा) और एक और कॉल करने योग्य ऑब्जेक्ट देता है। "कॉल करने योग्य" का उपयोग यहां "फ़ंक्शन" के बजाय पूर्वस्क्रिप्शन के साथ किया जाता है। जबकि सज्जाकार अक्सर तरीकों और कार्यों के दायरे में चर्चा करते हैं, वे उनके लिए सीमित नहीं हैं। वास्तव में, जो कुछ भी कॉल करने योग्य है (कोई भी वस्तु जो _call__ विधि को कॉल करने योग्य माना जाता है), एक डेकोरेटर के रूप में उपयोग की जा सकती है और अक्सर उनके द्वारा लौटाए गए ऑब्जेक्ट सरल कार्य नहीं होते हैं, लेकिन अधिक जटिल वर्गों के अधिक उदाहरण अपने स्वयं के___all_ पद्धति को लागू करते हैं।

डेकोरेटर सिंटैक्स केवल एक सिंटैक्टिक चीनी है । निम्नलिखित डेकोरेटर उपयोग पर विचार करें:

@some_decorator
def decorated_function():
    pass

इसे हमेशा एक स्पष्ट डेकोरेटर कॉल और फ़ंक्शन रीसाइनमेंट द्वारा बदला जा सकता है:

def decorated_function():
    pass
decorated_function = some_decorator(decorated_function)

हालांकि, बाद वाला कम पठनीय होता है और यह समझने में भी बहुत मुश्किल होता है कि एक ही फ़ंक्शन पर कई डेकोरेटर का उपयोग किया जाता है या नहीं। डेकोरेटर का उपयोग कई अलग-अलग तरीकों से किया जा सकता है जैसा कि नीचे दिखाया गया है:

एक समारोह के रूप में

कस्टम डेकोरेटर लिखने के कई तरीके हैं, लेकिन सबसे सरल तरीका एक फ़ंक्शन लिखना है जो एक सबफ़ंक्शन देता है जो मूल फ़ंक्शन कॉल को लपेटता है।

जेनेरिक पैटर्न इस प्रकार है:

def mydecorator(function):
    def wrapped(*args, **kwargs):
        # do some stuff before the original
        # function gets called
        result = function(*args, **kwargs)
        # do some stuff after function call and
        # return the result
        return result
    # return wrapper as a decorated function
    return wrapped

एक वर्ग के रूप में

जबकि सज्जाकार लगभग हमेशा कार्यों का उपयोग करके लागू किया जा सकता है, उपयोगकर्ता-परिभाषित कक्षाओं का उपयोग करते समय कुछ स्थितियां बेहतर विकल्प होती हैं। यह अक्सर सच होता है जब डेकोरेटर को जटिल पैरामीरिजेशन की आवश्यकता होती है या यह एक विशिष्ट स्थिति पर निर्भर करता है।

एक वर्ग के रूप में एक गैर-स्वरूपित डेकोरेटर के लिए सामान्य पैटर्न निम्नानुसार है:

class DecoratorAsClass:
    def __init__(self, function):
        self.function = function

    def __call__(self, *args, **kwargs):
        # do some stuff before the original
        # function gets called
        result = self.function(*args, **kwargs)
        # do some stuff after function call and
        # return the result
        return result

पैरामीटर सजाने वाले

वास्तविक कोड में, अक्सर डेकोरेटर्स का उपयोग करने की आवश्यकता होती है जो पैरामीट्रिज्ड हो सकते हैं। जब फ़ंक्शन को डेकोरेटर के रूप में उपयोग किया जाता है, तो समाधान सरल होता है - रैपिंग के दूसरे स्तर का उपयोग करना पड़ता है। यहाँ डेकोरेटर का एक सरल उदाहरण है जो एक सजाए गए फ़ंक्शन के निष्पादन को निर्दिष्ट करता है जिसे हर बार निर्दिष्ट संख्या कहा जाता है:

def repeat(number=3):
"""Cause decorated function to be repeated a number of times.

Last value of original function call is returned as a result
:param number: number of repetitions, 3 if not specified
"""
def actual_decorator(function):
    def wrapper(*args, **kwargs):
        result = None
        for _ in range(number):
            result = function(*args, **kwargs)
        return result
    return wrapper
return actual_decorator

डेकोरेटर इस तरह से परिभाषित कर सकते हैं पैरामीटर स्वीकार कर सकते हैं:

>>> @repeat(2)
... def foo():
...     print("foo")
...
>>> foo()
foo
foo

ध्यान दें कि भले ही पैरामीरिजेड डेकोरेटर के पास अपने तर्कों के लिए डिफ़ॉल्ट मान हों, लेकिन इसके नाम के बाद कोष्ठक आवश्यक हैं। डिफ़ॉल्ट तर्कों के साथ पूर्ववर्ती डेकोरेटर का उपयोग करने का सही तरीका इस प्रकार है:

>>> @repeat()
... def bar():
...     print("bar")
...
>>> bar()
bar
bar
bar

अंत में डेकोरेटर्स को प्रॉपर्टीज के साथ देखने दें।

गुण

गुण एक अंतर्निहित डिस्क्रिप्टर प्रकार प्रदान करते हैं जो किसी विशेषता को विधियों के सेट से जोड़ना जानता है। एक प्रॉपर्टी में चार वैकल्पिक तर्क होते हैं: fget, fset, fdel, और doc। अंतिम को एक डॉकस्ट्रिंग को परिभाषित करने के लिए प्रदान किया जा सकता है जो विशेषता से जुड़ा हुआ है जैसे कि यह एक विधि थी। यहाँ एक आयत वर्ग का एक उदाहरण है जिसे दो कोने बिंदुओं की दुकान या चौड़ाई, और ऊँचाई के गुणों का उपयोग करके सीधे पहुँच द्वारा नियंत्रित किया जा सकता है:

class Rectangle:
    def __init__(self, x1, y1, x2, y2):
        self.x1, self.y1 = x1, y1
        self.x2, self.y2 = x2, y2

    def _width_get(self):
        return self.x2 - self.x1

    def _width_set(self, value):
        self.x2 = self.x1 + value

    def _height_get(self):
        return self.y2 - self.y1

    def _height_set(self, value):
        self.y2 = self.y1 + value

    width = property(
        _width_get, _width_set,
        doc="rectangle width measured from left"
    )
    height = property(
        _height_get, _height_set,
        doc="rectangle height measured from top"
    )

    def __repr__(self):
        return "{}({}, {}, {}, {})".format(
            self.__class__.__name__,
            self.x1, self.y1, self.x2, self.y2
    )

संपत्ति बनाने के लिए सबसे अच्छा वाक्यविन्यास एक डेकोरेटर के रूप में संपत्ति का उपयोग कर रहा है। यह कक्षा के अंदर विधि हस्ताक्षरों की संख्या को कम कर देगा और कोड को अधिक पठनीय और बनाए रखने योग्य बना देगा । डेकोरेटर्स के साथ उपरोक्त वर्ग बनता है:

class Rectangle:
    def __init__(self, x1, y1, x2, y2):
        self.x1, self.y1 = x1, y1
        self.x2, self.y2 = x2, y2

    @property
    def width(self):
        """rectangle height measured from top"""
        return self.x2 - self.x1

    @width.setter
    def width(self, value):
        self.x2 = self.x1 + value

    @property
    def height(self):
        """rectangle height measured from top"""
        return self.y2 - self.y1

    @height.setter
    def height(self, value):
        self.y2 = self.y1 + value

— iun1x
स्रोत

2

यह कहने के लिए कि दूसरों के पास एक अलग तरीके से क्या है: हाँ, यह एक डेकोरेटर है।

पायथन में, यह इस तरह है:

एक फ़ंक्शन बनाना (@ कॉल के अंतर्गत)
आपके बनाए फ़ंक्शन पर काम करने के लिए दूसरे फ़ंक्शन को कॉल करना। यह एक नया फ़ंक्शन देता है। फ़ंक्शन जिसे आप कॉल करते हैं वह @ का तर्क है।
नए फ़ंक्शन के साथ परिभाषित फ़ंक्शन को प्रतिस्थापित करना वापस लौटा।

इसका उपयोग सभी प्रकार की उपयोगी चीजों के लिए किया जा सकता है, संभव बनाया गया क्योंकि फ़ंक्शन ऑब्जेक्ट हैं और बस आवश्यक निर्देश हैं।

— मयूर पटेल
स्रोत

2

@ प्रतीक का उपयोग प्लाईडेटा / पांडा डेटाफ्रेम क्वेरी के अंदर चर तक पहुंचने के लिए भी किया जाता है pandas.DataFrame.query। उदाहरण:

df = pandas.DataFrame({'foo': [1,2,15,17]})
y = 10
df >> query('foo > @y') # plydata
df.query('foo > @y') # pandas

— Aswin
स्रोत

1

यह इंगित करता है कि आप एक डेकोरेटर का उपयोग कर रहे हैं। यहां 2008 से ब्रूस एकेल का उदाहरण है।

— पीटर रोवेल
स्रोत

पायथन में "एट" (@) प्रतीक क्या करता है?

उदाहरण

प्रथम दर्शन

पायथन में "एट" (@) प्रतीक क्या करता है?

आप इसे अपने दम पर कैसे खोज सकते हैं?

डेकोरेटर सिंटेक्स:

डेकोरेटर

स्टैक्ड डेकोरेटर्स

परिचालक, @

Inplace मैट्रिक्स गुणन: @=

परिचालक, `@`

Inplace मैट्रिक्स गुणन: `@=`