Str और repr का उद्देश्य क्या है? [डुप्लिकेट]

Question 1

मुझे वास्तव में समझ में नहीं आ रहा है कि पायथन में कहां __str__और क्या __repr__उपयोग किया जाता है। मेरा मतलब है, मुझे लगता है कि __str__एक वस्तु का स्ट्रिंग प्रतिनिधित्व लौटाता है। लेकिन मुझे इसकी आवश्यकता क्यों होगी? किस परिदृश्य में उपयोग करें? इसके अलावा, मैंने इसके उपयोग के बारे में पढ़ा__repr__

लेकिन जो मुझे समझ नहीं आ रहा है, मैं उनका उपयोग कहां करूंगा?

Question 2

__repr__

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

__str__

str()अंतर्निहित फ़ंक्शन द्वारा और किसी वस्तु के "अनौपचारिक" स्ट्रिंग प्रतिनिधित्व की गणना करने के लिए प्रिंट स्टेटमेंट द्वारा कहा जाता है ।

का प्रयोग करें __str__आप एक वर्ग है, और आप एक जानकारीपूर्ण / अनौपचारिक उत्पादन चाहता हूँ, जब भी आप स्ट्रिंग के भाग के रूप में इस वस्तु का उपयोग करें। उदाहरण के लिए, आप __str__Django मॉडल के लिए तरीकों को परिभाषित कर सकते हैं , जो तब Django प्रशासन इंटरफ़ेस में प्रदान किया जाता है। किसी चीज़ के बदले <Model object>आपको किसी व्यक्ति का पहला और अंतिम नाम, किसी घटना का नाम और तारीख आदि मिलेगा।

__repr__और __str__समान हैं, वास्तव में कभी-कभी बराबर ( मानक पुस्तकालय से BaseSetकक्षा से उदाहरण sets.py):

def __repr__(self):
    """Return string representation of a set.

    This looks like 'Set([<list of elements>])'.
    """
    return self._repr()

# __str__ is the same as __repr__
__str__ = __repr__

Question 3

एक जगह है जहाँ आप उन दोनों का उपयोग करते हैं एक इंटरैक्टिव सत्र में है। यदि आप किसी वस्तु को प्रिंट करते हैं तो उसकी __str__विधि कहलाएगी, जबकि यदि आप किसी वस्तु का उपयोग स्वयं करते हैं तो __repr__यह दिखाया गया है:

>>> from decimal import Decimal
>>> a = Decimal(1.25)
>>> print(a)
1.25                  <---- this is from __str__
>>> a
Decimal('1.25')       <---- this is from __repr__

यह __str__संभव के रूप में मानव-पठनीय होने का इरादा है, जबकि __repr__उद्देश्य कुछ ऐसा होना चाहिए जिसका उपयोग वस्तु को फिर से बनाने के लिए किया जा सके, हालांकि यह अक्सर ऐसा नहीं होगा कि यह कैसे बनाया गया था, जैसा कि इस मामले में है।

यह दोनों के लिए __str__और __repr__समान मूल्य (निश्चित रूप से अंतर्निहित प्रकारों के लिए) वापस करने के लिए भी असामान्य नहीं है ।

Question 4

ग्रासहॉपर, जब संदेह में पहाड़ पर जाते हैं और प्राचीन ग्रंथों को पढ़ते हैं । उनमें आप पाएंगे कि __repr __ () चाहिए:

यदि संभव हो तो, यह एक वैध पायथन अभिव्यक्ति की तरह दिखना चाहिए जिसका उपयोग किसी वस्तु को उसी मान के साथ दोबारा बनाने के लिए किया जा सकता है।

Question 5

पिछले उत्तरों पर निर्माण और कुछ और उदाहरण दिखाते हुए। यदि ठीक से उपयोग किया जाता है, तो बीच का अंतर strऔर reprस्पष्ट है। संक्षेप reprमें, एक स्ट्रिंग को लौटाया जाना चाहिए जिसे ऑब्जेक्ट की सटीक स्थिति को फिर से बनाने के लिए कॉपी-पेस्ट किया जा सकता है, जबकि परिणामों के strलिए loggingऔर observingडीबग करना उपयोगी है । कुछ ज्ञात पुस्तकालयों के लिए अलग-अलग आउटपुट देखने के लिए यहां कुछ उदाहरण दिए गए हैं।

दिनांक और समय

print repr(datetime.now())    #datetime.datetime(2017, 12, 12, 18, 49, 27, 134411)
print str(datetime.now())     #2017-12-12 18:49:27.134452

strजहां के रूप में एक लॉग फ़ाइल, में मुद्रित करने के लिए अच्छा है reprयदि आपने इसे सीधे चलाने के लिए या एक फ़ाइल में आदेशों के रूप में यह डंप करना चाहते सोद्देश्य हो सकता है।

x = datetime.datetime(2017, 12, 12, 18, 49, 27, 134411)

Numpy

print repr(np.array([1,2,3,4,5])) #array([1, 2, 3, 4, 5])
print str(np.array([1,2,3,4,5]))  #[1 2 3 4 5]

Numpy में reprफिर से सीधे उपभोज्य है।

कस्टम वेक्टर 3 उदाहरण

class Vector3(object):
    def __init__(self, args):
        self.x = args[0]
        self.y = args[1]
        self.z = args[2]

    def __str__(self):
        return "x: {0}, y: {1}, z: {2}".format(self.x, self.y, self.z)

    def __repr__(self):
        return "Vector3([{0},{1},{2}])".format(self.x, self.y, self.z)

इस उदाहरण में, reprफिर से एक स्ट्रिंग देता है जिसे सीधे उपभोग / निष्पादित किया जा सकता है, जबकि strडिबग आउटपुट के रूप में अधिक उपयोगी है।

v = Vector3([1,2,3])
print str(v)     #x: 1, y: 2, z: 3
print repr(v)    #Vector3([1,2,3])

एक बात का ध्यान रखें, अगर strपरिभाषित नहीं है repr, लेकिन strस्वचालित रूप से कॉल करेगा repr। इसलिए, कम से कम परिभाषित करना हमेशा अच्छा होता हैrepr

Question 6

__str__समारोह के बिना एक वर्ग है।

class Employee:

    def __init__(self, first, last, pay):
        self.first = first 
        self.last = last
        self.pay = pay

emp1 = Employee('Ivan', 'Smith', 90000)

print(emp1)

जब हम कक्षा के इस उदाहरण को प्रिंट करते हैं, emp1तो हमें यही मिलता है:

<__main__.Employee object at 0x7ff6fc0a0e48>

यह बहुत उपयोगी नहीं है, और निश्चित रूप से यह वह नहीं है जो हम मुद्रित करना चाहते हैं यदि हम इसे प्रदर्शित करने के लिए उपयोग कर रहे हैं (जैसे html)

तो अब, एक ही वर्ग, लेकिन __str__समारोह के साथ :

class Employee:

    def __init__(self, first, last, pay):
        self.first = first 
        self.last = last
        self.pay = pay

    def __str__(self):
        return(f"The employee {self.first} {self.last} earns {self.pay}.")
        # you can edit this and use any attributes of the class

emp2 = Employee('John', 'Williams', 90000)

print(emp2)

अब मुद्रण के बजाय कि कोई वस्तु है, हमें वह मिलता है जो हमने __str__फ़ंक्शन की वापसी के साथ निर्दिष्ट किया था :

The employee John Williams earns 90000

Question 7

strअनौपचारिक और पठनीय प्रारूप reprहोगा, जबकि आधिकारिक वस्तु प्रतिनिधित्व देगा।

class Complex:
    # Constructor
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    # "official" string representation of an object
    def __repr__(self):
        return 'Rational(%s, %s)' % (self.real, self.imag)

    # "informal" string representation of an object (readable)
    def __str__(self):
        return '%s + i%s' % (self.real, self.imag)

    t = Complex(10, 20)

    print (t)     # this is usual way we print the object
    print (str(t))  # this is str representation of object 
    print (repr(t))  # this is repr representation of object   

Answers : 

Rational(10, 20) # usual representation
10 + i20      # str representation
Rational(10, 20)  # repr representation

Question 8

str और repr दोनों प्रतिनिधित्व करने के तरीके हैं। जब आप कक्षा लिख रहे हों तो आप उनका उपयोग कर सकते हैं।

class Fraction:
def __init__(self, n, d):
    self.n = n
    self.d = d
def __repr__(self):
    return "{}/{}".format(self.n, self.d)

उदाहरण के लिए जब मैं इसका एक उदाहरण प्रिंट करता हूं, तो यह चीजों को वापस करता है।

print(Fraction(1, 2))

का परिणाम

1/2

जबकि

class Fraction:
def __init__(self, n, d):
    self.n = n
    self.d = d
def __str__(self):
    return "{}/{}".format(self.n, self.d)
print(Fraction(1, 2))

में भी परिणाम

1/2

लेकिन क्या होगा अगर आप उन दोनों को लिखते हैं, जो एक अजगर का उपयोग करता है?

class Fraction:
def __init__(self, n, d):
    self.n = n
    self.d = d
def __str__(self):
    return "str"
def __repr__(self):
    return "repr"

print(Fraction(None, None))

इसका परिणाम यह होगा

str

तो अजगर वास्तव में str विधि का उपयोग करता है न कि repr पद्धति का जब दोनों लिखे जाते हैं।

Question 9

मान लीजिए कि आपके पास एक वर्ग है और एक उदाहरण का निरीक्षण करना चाहते हैं, तो आप देखते हैं कि प्रिंट बहुत उपयोगी जानकारी नहीं देता है

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age


p1 = Person("John", 36)
print(p1)  # <__main__.Animal object at 0x7f9060250410>

अब एक str के साथ एक क्लास देखें , यह इंस्टेंस जानकारी दिखाता है और repr के साथ आपको प्रिंट की भी आवश्यकता नहीं है। अच्छा लगा ना?

class Animal:
    def __init__(self, color, age, breed):
        self.color = color
        self.age = age
        self.breed = breed

    def __str__(self):
        return f"{self.color} {self.breed} of age {self.age}"

    def __repr__(self):
        return f"repr : {self.color} {self.breed} of age {self.age}"


a1 = Animal("Red", 36, "Dog")
a1  # repr : Red Dog of age 36
print(a1)  # Red Dog of age 36

__Str__ और __repr__ का उद्देश्य क्या है? [डुप्लिकेट]

दिनांक और समय

Numpy

कस्टम वेक्टर 3 उदाहरण

Str और repr का उद्देश्य क्या है? [डुप्लिकेट]