पायथन में "टुपल्स" नाम क्या हैं?

Question

पायथन 3.1 में बदलावों को पढ़ते हुए , मुझे कुछ मिला ... अप्रत्याशित:

Sys.version_info टुपल अब एक नामित टपल है :

मैंने पहले कभी टुपल्स के नाम के बारे में नहीं सुना था, और मुझे लगा कि तत्वों को या तो संख्याओं (जैसे टुपल्स और सूचियों) में या कुंजी द्वारा अनुक्रमित किया जा सकता है (जैसे डाइट में)। मुझे उम्मीद नहीं थी कि उन्हें दोनों तरीकों से अनुक्रमित किया जा सकता है।

इस प्रकार, मेरे प्रश्न हैं:

• टुपल्स नाम क्या हैं?
• उनका उपयोग कैसे करें?
• मुझे सामान्य ट्यूपल्स के बजाय टुपल्स का उपयोग क्यों / कब करना चाहिए?
• नामित ट्यूपल्स के बजाय मुझे सामान्य ट्यूपल्स का उपयोग क्यों / कब करना चाहिए?
• क्या किसी प्रकार की "नामित सूची" (नामित टपल का एक परिवर्तनशील संस्करण) है?

Answer 1

नामांकित tuples मूल रूप से आसानी से निर्मित, हल्के वस्तु प्रकार के होते हैं। नामित टुपल इंस्टेंसेस को ऑब्जेक्ट-जैसे वैरिएबल डेरेफेरिंग या मानक टुपल सिंटैक्स का उपयोग करके संदर्भित किया जा सकता है। उन्हें समान structया अन्य सामान्य रिकॉर्ड प्रकारों के लिए उपयोग किया जा सकता है , सिवाय इसके कि वे अपरिवर्तनीय हैं। उन्हें पायथन 2.6 और पायथन 3.0 में जोड़ा गया था, हालांकि पायथन 2.4 में कार्यान्वयन के लिए एक नुस्खा है ।

उदाहरण के लिए, एक टुपल के रूप में एक बिंदु का प्रतिनिधित्व करना आम है (x, y)। यह निम्नलिखित की तरह कोड की ओर जाता है:

pt1 = (1.0, 5.0)
pt2 = (2.5, 1.5)

from math import sqrt
line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2)

नामित टपल के उपयोग से यह अधिक पठनीय हो जाता है:

from collections import namedtuple
Point = namedtuple('Point', 'x y')
pt1 = Point(1.0, 5.0)
pt2 = Point(2.5, 1.5)

from math import sqrt
line_length = sqrt((pt1.x-pt2.x)**2 + (pt1.y-pt2.y)**2)

हालांकि, नामित टुपल्स अभी भी सामान्य ट्यूपल्स के साथ संगत हैं, इसलिए निम्नलिखित अभी भी काम करेंगे:

Point = namedtuple('Point', 'x y')
pt1 = Point(1.0, 5.0)
pt2 = Point(2.5, 1.5)

from math import sqrt
# use index referencing
line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2)
 # use tuple unpacking
x1, y1 = pt1

इस प्रकार, आपको ट्यूपल्स के बजाय नामित ट्यूपल्स का उपयोग करना चाहिए कहीं भी आपको लगता है कि ऑब्जेक्ट नोटेशन आपके कोड को अधिक पायथोनिक और अधिक आसानी से पठनीय बना देगा । मैंने व्यक्तिगत रूप से उन्हें बहुत सरल मूल्य प्रकारों का प्रतिनिधित्व करने के लिए उपयोग करना शुरू कर दिया है, खासकर जब उन्हें कार्यों के मापदंडों के रूप में पारित किया जाता है। यह कार्य को अधिक पठनीय बनाता है, बिना टुपल पैकिंग के संदर्भ को देखे।

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

class Point(namedtuple('Point', 'x y')):
    [...]

हालांकि, टुपल्स की तरह, नामित टुपल्स में विशेषताएँ अपरिवर्तनीय हैं:

>>> Point = namedtuple('Point', 'x y')
>>> pt1 = Point(1.0, 5.0)
>>> pt1.x = 2.0
AttributeError: can't set attribute

यदि आप मूल्यों को बदलने में सक्षम होना चाहते हैं, तो आपको दूसरे प्रकार की आवश्यकता है। परस्पर रिकॉर्ड करने के लिए एक आसान नुस्खा है जो आपको विशेषताओं के लिए नए मान सेट करने की अनुमति देता है।

>>> from rcdtype import *
>>> Point = recordtype('Point', 'x y')
>>> pt1 = Point(1.0, 5.0)
>>> pt1 = Point(1.0, 5.0)
>>> pt1.x = 2.0
>>> print(pt1[0])
    2.0

मुझे "नामित सूची" के किसी भी रूप के बारे में पता नहीं है जो आपको नए क्षेत्रों को जोड़ने की अनुमति देता है। आप इस स्थिति में केवल एक शब्दकोश का उपयोग करना चाह सकते हैं। नामित ट्यूपल्स को उन शब्दकोशों में परिवर्तित किया जा सकता है, pt1._asdict()जिनका उपयोग करके रिटर्न {'x': 1.0, 'y': 5.0}और सभी सामान्य शब्दकोश कार्यों के साथ संचालित किया जा सकता है।

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

Comments

पायथॉन 3.7 से, डेटासलैस को भी एक विकल्प के रूप में मानते हैं (बैकपोर्ट 3.6 के लिए उपलब्ध है, लेकिन पहले के संस्करण नहीं)

— Innov8

मामले में आपको __slots__

— परस्पर

क्या rcdtype नहीं dataclasses का उपयोग करने का मुख्य कारण है

— मल्लाह

Dict के लिए वैकल्पिक विशेषता शब्दकोश है stackoverflow.com/questions/4984647/...

— mrgloom

जैसा कि यह उत्तर आपको हमेशा मिलता है, यह ध्यान देने योग्य हो सकता है कि अब ऐसा भी है typing.NamedTupleजो टाइप संकेत के लिए अनुमति देता है और विशेष रूप से उपवर्ग के लिए सुविधाजनक है।

— DerWeh

Answer 2

namedtuple एक है कारखाने समारोह एक टपल वर्ग बनाने के लिए। उस वर्ग के साथ हम ट्यूपल बना सकते हैं जो नाम से भी कॉल करने योग्य हैं।

import collections

#Create a namedtuple class with names "a" "b" "c"
Row = collections.namedtuple("Row", ["a", "b", "c"], verbose=False, rename=False)   

row = Row(a=1,b=2,c=3) #Make a namedtuple from the Row class we created

print row    #Prints: Row(a=1, b=2, c=3)
print row.a  #Prints: 1
print row[0] #Prints: 1

row = Row._make([2, 3, 4]) #Make a namedtuple from a list of values

print row   #Prints: Row(a=2, b=3, c=4)

Comments

क्रिया और नाम का पैरामीटर डिफ़ॉल्ट रूप से गलत तरीके से तय किया जाता है, ताकि उन्हें इस मूल्य पर स्पष्ट रूप से सेट करने की आवश्यकता न हो।

— Trismegistos

namedtuple is a factory function for making a tuple class.यहाँ शायद यही एकमात्र सही उत्तर है: P

— Mr_and_Mrs_D

Answer 3

टुपल्स नाम क्या हैं?

टपल नाम का एक टपल है।

यह सब कुछ एक गुदगुदी कर सकता है।

लेकिन यह सिर्फ एक तुक से अधिक है।

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

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

पायथन 3.6 में नया , हमtyping.NamedTupleएक नामांकित बनाने केलिए एक वर्ग परिभाषा का उपयोग कर सकते हैं:

from typing import NamedTuple

class ANamedTuple(NamedTuple):
    """a docstring"""
    foo: int
    bar: str
    baz: list

ऊपर वाला नीचे के समान है, सिवाय इसके कि ऊपर अतिरिक्त रूप से एनोटेशन और एक डॉकस्ट्रिंग है। नीचे पायथन 2+ में उपलब्ध है:

>>> from collections import namedtuple
>>> class_name = 'ANamedTuple'
>>> fields = 'foo bar baz'
>>> ANamedTuple = namedtuple(class_name, fields)

यह इसे तुरंत करता है:

>>> ant = ANamedTuple(1, 'bar', [])

हम इसका निरीक्षण कर सकते हैं और इसकी विशेषताओं का उपयोग कर सकते हैं:

>>> ant
ANamedTuple(foo=1, bar='bar', baz=[])
>>> ant.foo
1
>>> ant.bar
'bar'
>>> ant.baz.append('anything')
>>> ant.baz
['anything']

गहरा विवेचन

टुपल्स को समझने के लिए, आपको सबसे पहले यह जानना होगा कि टुपल क्या है। एक ट्यूपल अनिवार्य रूप से एक अपरिवर्तनीय है (मेमोरी में इन-प्लेस नहीं बदला जा सकता है)।

यहां बताया गया है कि आप नियमित रूप से कैसे काम कर सकते हैं:

>>> student_tuple = 'Lisa', 'Simpson', 'A'
>>> student_tuple
('Lisa', 'Simpson', 'A')
>>> student_tuple[0]
'Lisa'
>>> student_tuple[1]
'Simpson'
>>> student_tuple[2]
'A'

आप चलने योग्य अनपैकिंग के साथ टपल का विस्तार कर सकते हैं:

>>> first, last, grade = student_tuple
>>> first
'Lisa'
>>> last
'Simpson'
>>> grade
'A'

नामांकित tuples tuples हैं जो अपने तत्वों को सिर्फ इंडेक्स के बजाय नाम से एक्सेस करने की अनुमति देते हैं!

आप इस तरह एक नामांकित बनाते हैं:

>>> from collections import namedtuple
>>> Student = namedtuple('Student', ['first', 'last', 'grade'])

आप रिक्त स्थान द्वारा अलग किए गए नामों के साथ एक भी स्ट्रिंग का उपयोग कर सकते हैं, एपीआई का थोड़ा अधिक पठनीय उपयोग:

>>> Student = namedtuple('Student', 'first last grade')

उनका उपयोग कैसे करें?

आप कर सकते हैं सब कुछ कर सकते हैं tuples कर सकते हैं (ऊपर देखें) और साथ ही साथ निम्न कार्य करें:

>>> named_student_tuple = Student('Lisa', 'Simpson', 'A')
>>> named_student_tuple.first
'Lisa'
>>> named_student_tuple.last
'Simpson'
>>> named_student_tuple.grade
'A'
>>> named_student_tuple._asdict()
OrderedDict([('first', 'Lisa'), ('last', 'Simpson'), ('grade', 'A')])
>>> vars(named_student_tuple)
OrderedDict([('first', 'Lisa'), ('last', 'Simpson'), ('grade', 'A')])
>>> new_named_student_tuple = named_student_tuple._replace(first='Bart', grade='C')
>>> new_named_student_tuple
Student(first='Bart', last='Simpson', grade='C')

एक टिप्पणीकार ने पूछा:

एक बड़ी स्क्रिप्ट या कार्यक्रम में, आमतौर पर एक नामित टपल को कहां परिभाषित किया जाता है?

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

वैश्विक मॉड्यूल स्तर पर काम करने का उदाहरण:

>>> from collections import namedtuple
>>> NT = namedtuple('NT', 'foo bar')
>>> nt = NT('foo', 'bar')
>>> import pickle
>>> pickle.loads(pickle.dumps(nt))
NT(foo='foo', bar='bar')

और यह परिभाषा को देखने में विफलता को दर्शाता है:

>>> def foo():
...     LocalNT = namedtuple('LocalNT', 'foo bar')
...     return LocalNT('foo', 'bar')
... 
>>> pickle.loads(pickle.dumps(foo()))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
_pickle.PicklingError: Can't pickle <class '__main__.LocalNT'>: attribute lookup LocalNT on __main__ failed

मुझे सामान्य ट्यूपल्स के बजाय टुपल्स का उपयोग क्यों / कब करना चाहिए?

जब यह आपके कोड में सुधार करता है, तो आपके कोड में व्यक्त किए गए टपल तत्वों के शब्दार्थ को सुधारता है।

यदि आप अन्यथा अपरिवर्तित डेटा विशेषताओं और किसी कार्यक्षमता के साथ किसी ऑब्जेक्ट का उपयोग करेंगे, तो आप ऑब्जेक्ट के बजाय उनका उपयोग कर सकते हैं।

उदाहरण के लिए, कार्यक्षमता जोड़ने के लिए आप उन्हें भी उपवर्गित कर सकते हैं :

class Point(namedtuple('Point', 'x y')):
    """adding functionality to a named tuple"""
        __slots__ = ()
        @property
        def hypot(self):
            return (self.x ** 2 + self.y ** 2) ** 0.5
        def __str__(self):
            return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)

नामित ट्यूपल्स के बजाय मुझे सामान्य ट्यूपल्स का उपयोग क्यों / कब करना चाहिए?

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

ट्यूपल्स बनाम ट्यूपल्स नाम से उपयोग की जाने वाली कोई अतिरिक्त मेमोरी नहीं है।

क्या किसी प्रकार की "नामित सूची" (नामित टपल का एक परिवर्तनशील संस्करण) है?

आप या तो एक स्लेटेड ऑब्जेक्ट की तलाश कर रहे हैं, जो एक स्टेटिकली साइज़ लिस्ट या सबक्लासिड लिस्ट की कार्यक्षमता को लागू करता है, जो नामांकित टपल की तरह काम करता है (और यह किसी भी तरह लिस्ट को आकार में बदलने से रोकता है।)

अब विस्तार किया गया है, और शायद लिस्कोव को भी प्रतिस्थापित किया जा सकता है, पहला उदाहरण:

from collections import Sequence

class MutableTuple(Sequence): 
    """Abstract Base Class for objects that work like mutable
    namedtuples. Subclass and define your named fields with 
    __slots__ and away you go.
    """
    __slots__ = ()
    def __init__(self, *args):
        for slot, arg in zip(self.__slots__, args):
            setattr(self, slot, arg)
    def __repr__(self):
        return type(self).__name__ + repr(tuple(self))
    # more direct __iter__ than Sequence's
    def __iter__(self): 
        for name in self.__slots__:
            yield getattr(self, name)
    # Sequence requires __getitem__ & __len__:
    def __getitem__(self, index):
        return getattr(self, self.__slots__[index])
    def __len__(self):
        return len(self.__slots__)

और उपयोग करने के लिए, बस उपवर्ग और परिभाषित करें __slots__:

class Student(MutableTuple):
    __slots__ = 'first', 'last', 'grade' # customize 


>>> student = Student('Lisa', 'Simpson', 'A')
>>> student
Student('Lisa', 'Simpson', 'A')
>>> first, last, grade = student
>>> first
'Lisa'
>>> last
'Simpson'
>>> grade
'A'
>>> student[0]
'Lisa'
>>> student[2]
'A'
>>> len(student)
3
>>> 'Lisa' in student
True
>>> 'Bart' in student
False
>>> student.first = 'Bart'
>>> for i in student: print(i)
... 
Bart
Simpson
A

Answer 4

nametuples एक महान विशेषता है, वे डेटा के लिए एकदम सही कंटेनर हैं। जब आपको डेटा "स्टोर" करना होगा तो आप टुपल्स या शब्दकोशों का उपयोग करेंगे, जैसे:

user = dict(name="John", age=20)

या:

user = ("John", 20)

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

nametuples दो दृष्टिकोणों के लिए एकदम सही समझौता है, बड़ी पठनीयता, हल्कापन और अपरिवर्तनीयता है (साथ ही वे बहुरूपिक हैं!)।

Comments

ध्यान रखें कि नेकटअप की तुलना में यदि आप उनके गुणों को एक्सेस करते हैं, तो डिट्ट की तुलना में नेमप्लस का रास्ता धीमा है: ntuple.fooबनाम ntuple[1]बाद वाला ज्यादा तेज है। इस पर अधिक: stackoverflow.com/questions/2646157/…

— रोटारती

Answer 5

tuples नाम इस तरह के संस्करण के लिए जाँच करता है कि कोड के साथ पिछड़े संगतता की अनुमति देते हैं

>>> sys.version_info[0:2]
(3, 1)

इस सिंटैक्स का उपयोग करके भविष्य के कोड को और अधिक स्पष्ट करने की अनुमति देता है

>>> sys.version_info.major
3
>>> sys.version_info.minor
1

Answer 6

namedtuple

अपने कोड को साफ करने और इसे अधिक पठनीय बनाने के सबसे आसान तरीकों में से एक है। यह स्व-दस्तावेजों को बताता है कि ट्यूपल में क्या हो रहा है। Namedtuples उदाहरण नियमित रूप से tuples के रूप में स्मृति के रूप में कुशल हैं क्योंकि वे प्रति उदाहरण शब्दकोशों नहीं है, उन्हें शब्दकोशों की तुलना में तेजी से बना रहे हैं।

from collections import namedtuple

Color = namedtuple('Color', ['hue', 'saturation', 'luminosity'])

 p = Color(170, 0.1, 0.6)
 if p.saturation >= 0.5:
     print "Whew, that is bright!"
 if p.luminosity >= 0.5:
     print "Wow, that is light"

टपल में प्रत्येक तत्व का नाम लिए बिना, यह इस तरह से पढ़ेगा:

p = (170, 0.1, 0.6)
if p[1] >= 0.5:
    print "Whew, that is bright!"
if p[2]>= 0.5:
   print "Wow, that is light"

यह समझना बहुत कठिन है कि पहले उदाहरण में क्या चल रहा है। एक नामांकित के साथ, प्रत्येक क्षेत्र का एक नाम है। और आप इसे स्थिति या सूचकांक के बजाय नाम से एक्सेस करते हैं। इसके बजाय p[1], हम इसे p.saturation कह सकते हैं। इसे समझना आसान है। और यह साफ दिखता है।

शब्दकोश बनाने की तुलना में नेमटुपल का एक उदाहरण बनाना आसान है।

# dictionary
>>>p = dict(hue = 170, saturation = 0.1, luminosity = 0.6)
>>>p['hue']
170

#nametuple
>>>from collections import namedtuple
>>>Color = namedtuple('Color', ['hue', 'saturation', 'luminosity'])
>>>p = Color(170, 0.1, 0.6)
>>>p.hue
170

आप नेमप्ले का उपयोग कब कर सकते हैं

1. जैसा कि अभी कहा गया है, नेमटुपल टुपल्स को समझने में बहुत आसान बनाता है। तो अगर आपको टुपल में आइटम को संदर्भित करने की आवश्यकता है, तो उन्हें नामांकित के रूप में बनाने से बस समझ में आता है।
2. शब्दकोश की तुलना में अधिक हल्का होने के अलावा, नामपट्ट भी शब्दकोश के विपरीत क्रम रखता है।
3. जैसा कि ऊपर दिए गए उदाहरण में, शब्दकोश की तुलना में नेमटुपल का उदाहरण बनाना सरल है। और नामित टपल में आइटम का संदर्भ एक शब्दकोष से साफ दिखता है। p.hueके बजाय p['hue']।

वाक्य रचना

collections.namedtuple(typename, field_names[, verbose=False][, rename=False])

• नामपट्ट संग्रह पुस्तकालय में है।
• typename: यह नए टपल उपवर्ग का नाम है।
• field_names: प्रत्येक क्षेत्र के लिए नामों का एक क्रम। यह एक सूची ['x', 'y', 'z']या स्ट्रिंग x y z(अल्पविराम के बिना, बस व्हाट्सएप) या के रूप में एक अनुक्रम हो सकता है x, y, z।
• नाम बदलें: यदि नाम बदला गया है True, तो अमान्य फ़ील्डनाम स्वचालित रूप से स्थितीय नामों से बदल दिए जाते हैं। उदाहरण के लिए, ['abc', 'def', 'ghi','abc']में बदल जाती है ['abc', '_1', 'ghi', '_3'], कीवर्ड को नष्ट करने 'def'(के बाद से है कि कार्यों को परिभाषित करने के लिए एक आरक्षित शब्द है) और डुप्लिकेट FIELDNAME 'abc'।
• वर्बोज़: यदि वर्बोज़ है True, तो कक्षा की परिभाषा का निर्माण होने से ठीक पहले मुद्रित किया जाता है।

यदि आप ऐसा चुनते हैं, तो आप अभी भी उनकी स्थिति के अनुसार नाममात्र का उपयोग कर सकते हैं। p[1] == p.saturation। यह अभी भी नियमित टपल की तरह अनपैक करता है।

तरीके

सभी नियमित टपल तरीकों का समर्थन किया जाता है। Ex: min (), max (), len (), in, not in, concatenation (+), इंडेक्स, स्लाइस इत्यादि। और कुछ अतिरिक्त नामांक के लिए हैं। नोट: ये सभी एक अंडरस्कोर के साथ शुरू होते हैं। _replace, _make, _asdict।

_replace नए क्षेत्रों के साथ निर्दिष्ट फ़ील्ड्स की जगह नामित टपल का एक नया उदाहरण देता है।

वाक्य रचना

somenamedtuple._replace(kwargs)

उदाहरण

>>>from collections import namedtuple

>>>Color = namedtuple('Color', ['hue', 'saturation', 'luminosity'])
>>>p = Color(170, 0.1, 0.6)

>>>p._replace(hue=87)
Color(87, 0.1, 0.6)

>>>p._replace(hue=87, saturation=0.2)
Color(87, 0.2, 0.6)

सूचना : क्षेत्र के नाम उद्धरण में नहीं हैं; वे यहाँ खोजशब्द हैं। याद रखें : ट्यूपल्स अपरिवर्तनीय हैं - भले ही वे नामांकित हैं और _replaceविधि है। _replaceएक का उत्पादन newउदाहरण; यह मूल को संशोधित नहीं करता है या पुराने मूल्य को प्रतिस्थापित नहीं करता है। आप निश्चित रूप से नए परिणाम को चर में सहेज सकते हैं।p = p._replace(hue=169)

_make

एक मौजूदा अनुक्रम या चलने योग्य से एक नया उदाहरण बनाता है।

वाक्य रचना

somenamedtuple._make(iterable)

उदाहरण

 >>>data = (170, 0.1, 0.6)
 >>>Color._make(data)
Color(hue=170, saturation=0.1, luminosity=0.6)

>>>Color._make([170, 0.1, 0.6])  #the list is an iterable
Color(hue=170, saturation=0.1, luminosity=0.6)

>>>Color._make((170, 0.1, 0.6))  #the tuple is an iterable
Color(hue=170, saturation=0.1, luminosity=0.6)

>>>Color._make(170, 0.1, 0.6) 
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "<string>", line 15, in _make
TypeError: 'float' object is not callable

पिछले एक के साथ क्या हुआ था? कोष्ठक के अंदर की वस्तु पुनरावृत्त होनी चाहिए। तो कोष्ठक के अंदर एक सूची या तुच्छ काम करता है, लेकिन एक पुनरावृत्ति के रूप में संलग्न किए बिना मूल्यों का अनुक्रम एक त्रुटि देता है।

_asdict

एक नया ऑर्डरडिटक लौटाता है जो फ़ील्ड नामों को उनके संबंधित मानों में मैप करता है।

वाक्य रचना

somenamedtuple._asdict()

उदाहरण

 >>>p._asdict()
OrderedDict([('hue', 169), ('saturation', 0.1), ('luminosity', 0.6)])

संदर्भ : https://www.reddit.com/r/Python/comments/38ee9d/intro_to_amehupup/

वहाँ भी नाम सूची है जो नाम के समान है, लेकिन परस्पर https://pypi.python.org/pypi/maillist

Comments

हालाँकि, नोट करें कि PEP8 के अनुसार एक एकल अंडरस्कोर को अपने व्यवहार के साथ "कमजोर" आंतरिक उपयोग "संकेतक" माना जाता है । शुरू होने वाले कार्यों का उपयोग करते समय सावधान _!

— जेन्स

Answer 7

नामांकित क्या है?

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

उनका उपयोग कैसे करें?

>>>from collections import namedtuple
>>>saleRecord = namedtuple('saleRecord','shopId saleDate salesAmout totalCustomers')
>>>
>>>
>>>#Assign values to a named tuple 
>>>shop11=saleRecord(11,'2015-01-01',2300,150) 
>>>shop12=saleRecord(shopId=22,saleDate="2015-01-01",saleAmout=1512,totalCustomers=125)

पढ़ना

>>>#Reading as a namedtuple
>>>print("Shop Id =",shop12.shopId)
12
>>>print("Sale Date=",shop12.saleDate)
2015-01-01
>>>print("Sales Amount =",shop12.salesAmount)
1512
>>>print("Total Customers =",shop12.totalCustomers)
125

सीएसवी प्रसंस्करण में दिलचस्प परिदृश्य:

from csv import reader
from collections import namedtuple

saleRecord = namedtuple('saleRecord','shopId saleDate totalSales totalCustomers')
fileHandle = open("salesRecord.csv","r")
csvFieldsList=csv.reader(fileHandle)
for fieldsList in csvFieldsList:
    shopRec = saleRecord._make(fieldsList)
    overAllSales += shopRec.totalSales;

print("Total Sales of The Retail Chain =",overAllSales)

Answer 8

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

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

Answer 9

ट्यूपल नाम का उपयोग करने का दूसरा तरीका (नया तरीका) टाइपिंग पैकेज से NamedTuple का उपयोग कर रहा है: नामांकित में टाइप संकेत

आइए इस पोस्ट में शीर्ष उत्तर के उदाहरण का उपयोग करके देखें कि इसका उपयोग कैसे किया जाता है।

(1) नामित टपल का उपयोग करने से पहले, कोड इस प्रकार है:

pt1 = (1.0, 5.0)
pt2 = (2.5, 1.5)

from math import sqrt
line_length = sqrt((pt1[0]-pt2[0])**2 + (pt1[1]-pt2[1])**2)
print(line_length)

(२) अब हम नामित टपल का उपयोग करते हैं

from typing import NamedTuple, Number

NamedTuple वर्ग वारिस करें और नई कक्षा में चर नाम परिभाषित करें। परीक्षा कक्षा का नाम है।

class test(NamedTuple):
x: Number
y: Number

कक्षा से उदाहरण बनाएं और उन्हें मान प्रदान करें

pt1 = test(1.0, 5.0)   # x is 1.0, and y is 5.0. The order matters
pt2 = test(2.5, 1.5)

गणना करने के लिए उदाहरणों से चर का उपयोग करें

line_length = sqrt((pt1.x-pt2.x)**2 + (pt1.y-pt2.y)**2)
print(line_length)

Answer 10

इसे इस्तेमाल करे:

collections.namedtuple()

मूल रूप namedtuplesसे, हल्के ऑब्जेक्ट प्रकार बनाने में आसान हैं। वे सरल कार्यों के लिए टुपल्स को सुविधाजनक कंटेनरों में बदलते हैं। साथ namedtuples, आप एक टपल के सदस्यों तक पहुँचने के लिए सूचकांक पूर्णांक उपयोग करने के लिए नहीं है।

उदाहरण:

कोड 1:

>>> from collections import namedtuple

>>> Point = namedtuple('Point','x,y')

>>> pt1 = Point(1,2)

>>> pt2 = Point(3,4)

>>> dot_product = ( pt1.x * pt2.x ) +( pt1.y * pt2.y )

>>> print dot_product
11

कोड 2:

>>> from collections import namedtuple

>>> Car = namedtuple('Car','Price Mileage Colour Class')

>>> xyz = Car(Price = 100000, Mileage = 30, Colour = 'Cyan', Class = 'Y')

>>> print xyz

Car(Price=100000, Mileage=30, Colour='Cyan', Class='Y')
>>> print xyz.Class
Y

Answer 11

बाकी सभी ने पहले ही इसका जवाब दे दिया है, लेकिन मुझे लगता है कि मुझे अभी भी कुछ और जोड़ना है।

Namedtuple को एक वर्ग को परिभाषित करने के लिए शॉर्टकट के रूप में सहज रूप से समझा जा सकता है।

एक परिभाषित करने के लिए बोझिल और पारंपरिक तरीका देखें class।

class Duck:
    def __init__(self, color, weight):
        self.color = color
        self.weight = weight
red_duck = Duck('red', '10')

    In [50]: red_duck
    Out[50]: <__main__.Duck at 0x1068e4e10>
    In [51]: red_duck.color
    Out[51]: 'red'

से संबंधित namedtuple

from collections import namedtuple
Duck = namedtuple('Duck', ['color', 'weight'])
red_duck = Duck('red', '10')

In [54]: red_duck
Out[54]: Duck(color='red', weight='10')
In [55]: red_duck.color
Out[55]: 'red'

Comments

क्षमा करें, लेकिन यह गलत है। नामित टपल भी इनका समर्थन करता है: red_duck[0]या len(red_duck)या for x in red_duck: print(x)। इसके अलावा, नामित ट्यूपल्स अपरिवर्तनीय हैं, इसलिए ये ऑपरेशन विफल हो जाएंगे: red_duck[0] = 2, red_duck.foo = 'bar'। चूँकि वे अपरिवर्तनीय हैं, इसलिए टुपल्स का उपयोग dictकुंजी के रूप में किया जा सकता है ।

— डेनिलसन सा

हाँ, यह मूल बातें है।

— कैलकुलस

@ जवासा नहीं, यह "मूल बातें" नहीं है। नामित ट्यूपल्स नियमित कक्षाओं की तुलना में पूरी तरह से अलग कार्यक्षमता का समर्थन करते हैं। जबकि सार में ट्यूपल नाम एक वर्ग है, इसका मतलब यह नहीं है कि कक्षाओं को ट्यूपल्स नाम दिया गया है।

— संयोजकचर