पाठ्यक्रम 246 में से पाठ 19 · Module 1: इस कोर्स के लिए Python
Module 1: इस कोर्स के लिए Python

Objects जो याद रखते हैं (classes और closures)

यह क्यों मायने रखता है Module 4 में आप एक autograd engine बनाएँगे। यह एक class है जिसके objects साधारण + और @ से जोड़ते और गुणा करते हैं, और हर नतीजा एक छोटा function रखता है जो याद रखता है कि वह कैसे बना। यह पाठ उसके पीछे का Python है।

एक class objects का एक नुस्खा है

class Box:
    def __init__(self, value):      # runs when you write Box(3)
        self.value = value          # self is the object being made

    def doubled(self):              # a method: a function that belongs to the object
        return Box(self.value * 2)


b = Box(3)
b.value          # 3
b.doubled().value   # 6

+ और @ को काम करवाना

जब Python आपके objects पर a + b देखता है, वह a.__add__(b) बुलाता है। a @ b के लिए वह a.__matmul__(b) बुलाता है। वे methods लिखें और आपके objects सामान्य चिह्नों के साथ काम करते हैं। हर ओर दो underscores वाले नाम dunder methods कहलाते हैं।

    def __add__(self, other):
        return Box(self.value + other.value)

एक मान जो पूछने पर निकाला जाता है (@property)

एक method के ऊपर @property रखें और आप उसे एक रखे मान की तरह पढ़ते हैं, बिना कोष्ठकों के: b.size() के बजाय b.size। यह हर बार नया निकाला जाता है।

छोटे functions: lambda

square = lambda x: x * x एक-line का function है जिसका अपना कोई नाम नहीं। यह def square(x): return x * x जैसा ही है।

Functions जो याद रखते हैं (closures)

def make_scaler(k):
    def scale(x):
        return k * x       # k comes from the call to make_scaler
    return scale


triple = make_scaler(3)
triple(5)        # 15: scale still remembers k = 3

एक याद रखा variable पढ़ना बस काम करता है। एक बदलने में सावधानी चाहिए: अंदरूनी function में count += 1 Python से count को एक बिल्कुल नया local variable मनवाता है, और आपको UnboundLocalError मिलता है। दो इलाज: अंदरूनी function की पहली line के रूप में nonlocal count लिखें, जो कहता है "बाहर वाला count", या संख्या को एक list के अंदर रखें, count = [0], और count[0] बदलें, जो नाम फिर बाँधने के बजाय list बदलता है।

def make_total():
    total = 0
    def add(x):
        nonlocal total     # without this line: UnboundLocalError
        total += x
        return total
    return add

अंदरूनी function उन variables को रखता है जो उसने उसे बनाने वाले function से इस्तेमाल किए, उस function के ख़त्म होने के बाद भी। Autograd ठीक यही इस्तेमाल करता है: + या * का हर नतीजा एक नन्हा closure रखता है जो उसके inputs याद रखता है, बाद में उन्हें gradients वापस भेजने को तैयार।

Class: objects का एक नुस्खा। Method: एक function जो एक object का है और उसे self के रूप में पाता है। Closure: एक अंदरूनी function जो वहाँ के variables याद रखता है जहाँ वह बना।

सार __init__ एक object तैयार करता है, __add__ और __matmul__ उसे + और @ देते हैं, @property एक मान की तरह पढ़ा जाता है, और एक closure अपनी याद साथ ले जाता है।

इस पाठ के शब्द और चिह्न
a @ b
matrix गुणा (संख्याओं की दो lists के लिए dot product भी)
आपकी बारी

class Vec पूरी करें, संख्याओं की एक list जो गणित करती है। Vec([1, 2]) + Vec([3, 4]) को [4, 6] रखने वाला एक नया Vec देना होगा (item दर item जोड़ें); Vec([1, 2]) @ Vec([3, 4]) को संख्या 11 देनी होगी (item दर item गुणा करें और जोड़ें); Vec([3, 4]).size को 5.0 होना होगा (लंबाई, वर्गों के जोड़ का square root), एक property के रूप में पढ़ा। कोई input नहीं बदलना चाहिए। फिर make_counter() लिखें: यह एक function लौटाता है जो, हर बार बुलाए जाने पर, 1, फिर 2, फिर 3 वग़ैरह लौटाता है, हर counter अपने आप गिनते हुए।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।