Was sind in Python "genannt Tuple"?

Question

Lesen des Änderungen in Python 3.1, Ich habe etwas gefunden ... unerwartet:

Das sys.version_info tuple ist jetzt a genannt Tuple:

Ich habe noch nie zuvor von genannten Tupel gehört, und ich dachte, Elemente könnten entweder durch Zahlen (wie in Tupeln und Listen) oder durch Schlüssel (wie in Dicts) indiziert werden. Ich habe nie erwartet, dass sie in beide Richtungen indiziert werden könnten.

Meine Fragen sind also:

• Wie heißt Tupel?
• Wie benutzt man sie?
• Warum/wann sollte ich genannte Tupel anstelle von normalen Tupeln verwenden?
• Warum/wann sollte ich normale Tupel anstelle von genannten Tupeln verwenden?
• Gibt es irgendeine Art von "genannter Liste" (eine veränderliche Version des genannten Tupels)?

Answer 1

Mit dem Namen Tupel sind leichte Objekttypen im Grunde genommen leicht zu erstellende, leichte Objekttypen. Mit dem Namen Tuple-Instanzen können unter Verwendung einer Objekt-ähnlichen Variablenabendung oder der Standard-Tupel-Syntax referenziert werden. Sie können ähnlich verwendet werden wie struct oder andere gemeinsame Datensatztypen, außer dass sie unveränderlich sind. Sie wurden in Python 2.6 und Python 3.0 hinzugefügt, obwohl es a gibt Rezept für die Implementierung in Python 2.4.

Zum Beispiel ist es üblich, einen Punkt als Tupel darzustellen (x, y). Dies führt zu Code wie folgt:

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)

Mit einem benannten Tupel wird es lesbarer:

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)

Mit dem Namen Tupel sind jedoch immer noch rückwärts kompatibel mit normalen Tupeln, sodass das Folgende immer noch funktioniert:

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

Daher, Sie sollten benannte Tupel anstelle von Tupeln verwenden, wo Sie der Meinung sind, dass Objektnotation Ihren Code pythonischer und einfacher lesbar macht. Ich persönlich habe angefangen, sie zu verwenden, um sehr einfache Werttypen darzustellen, insbesondere wenn ich sie als Parameter an Funktionen übergeben habe. Es macht die Funktionen lesbarer, ohne den Kontext der Tupelpackung zu sehen.

Außerdem, Sie können auch gewöhnlich ersetzen unveränderlich Klassen, die keine Funktionen haben, nur Felder mit ihnen. Sie können sogar Ihre benannten Tupel -Typen als Basisklassen verwenden:

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

Wie bei Tupeln sind Attribute in genannten Tupeln jedoch unveränderlich:

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

Wenn Sie die Werte ändern möchten, benötigen Sie einen anderen Typ. Es gibt ein praktisches Rezept für Veränderliche Datensatztypen Auf diese Weise können Sie neue Werte auf Attribute festlegen.

>>> 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

Mir ist jedoch keine Form der "genannten Liste" bekannt, mit der Sie neue Felder hinzufügen können. Möglicherweise möchten Sie in dieser Situation nur ein Wörterbuch verwenden. Benannte Tupel können in Wörterbücher mithilfe von Wörterbüchern konvertiert werden pt1._asdict() was kehrt zurück {'x': 1.0, 'y': 5.0} und kann mit allen üblichen Wörterbuchfunktionen betrieben werden.

Wie bereits erwähnt, sollten Sie Überprüfen Sie die Dokumentation Weitere Informationen, aus denen diese Beispiele konstruiert wurden.

Answer 2

genannt ist ein Fabrikfunktion für eine Tupelklasse. Mit dieser Klasse können wir auch Tupel erstellen, die auch namentlich abrufbar sind.

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)

Answer 3

Wie heißt Tupel?

Ein namentliches Tupel ist ein Tupel.

Es tut alles, was ein Tupel kann.

Aber es ist mehr als nur ein Tupel.

Es handelt sich um eine bestimmte Unterklasse eines Tupels, das programmgesteuert für Ihre Spezifikation mit benannten Feldern und einer festen Länge erstellt wird.

Dies schafft zum Beispiel eine Unterklasse von Tupel und kann abgesehen von fester Länge (in diesem Fall drei) überall verwendet werden, wo ein Tupel ohne Brechen verwendet wird. Dies ist als Liskov -Substituierbarkeit bekannt:

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

Dies instanziiert es:

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

Wir können es inspizieren und seine Attribute verwenden:

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

Tiefere Erklärung

Um benannte Tupel zu verstehen, müssen Sie zunächst wissen, was ein Tupel ist. Ein Tupel ist im Wesentlichen eine unveränderliche Liste (kann in Speicher nicht in Platzierung geändert werden).

So verwenden Sie ein normales Tupel:

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

Sie können ein Tupel mit iterierbarem Auspacken erweitern:

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

Mit dem Namen Tupel sind Tupel, die es ihren Elementen ermöglichen, mit Namen anstelle von Index zugegriffen zu werden!

Sie machen einen Namen wie diese:

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

Sie können auch eine einzelne Zeichenfolge mit den Namen verwenden, die durch Leerzeichen getrennt sind, eine etwas lesbarere Verwendung der API:

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

Wie benutzt man sie?

Sie können alles tun, was Tupel tun können (siehe oben) sowie Folgendes:

>>> 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')

Ein Kommentator fragte:

Wo definiert man in einem großen Skript oder Programm normalerweise ein benanntes Tupel?

Die Typen, mit denen Sie erstellen namedtuple Im Grunde können Sie Klassen mit einfacher Abkürzung erstellen. Behandle sie wie Klassen. Definieren Sie sie auf der Modulebene, damit Pickle und andere Benutzer sie finden können.

Das funktionierende Beispiel auf globaler Modulebene:

>>> 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')

Und dies zeigt das Versäumnis, die Definition zu suchen:

>>> 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

Warum/wann sollte ich genannte Tupel anstelle von normalen Tupeln verwenden?

Verwenden Sie sie, wenn er Ihren Code verbessert, um die Semantik von Tupelelementen in Ihrem Code zum Ausdruck zu bringen. Sie können sie anstelle eines Objekts verwenden, wenn Sie sonst ein Objekt mit unveränderlichen Datenattributen und ohne Funktionalität verwenden würden. Du kannst auch Unterklasse sie zum Beispiel, um Funktionen hinzuzufügen:

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)

Warum/wann sollte ich normale Tupel anstelle von genannten Tupeln verwenden?

Es wäre wahrscheinlich eine Regression, von benannten Tupeln zu Tupeln zu wechseln. Die Entscheidungsentscheidung im Voraus darum, ob die Kosten aus dem zusätzlichen Code die verbesserte Lesbarkeit wert sind, wenn das Tupel verwendet wird.

Es gibt keinen zusätzlichen Speicher von genannten Tupeln gegenüber Tupeln.

Gibt es irgendeine Art von "genannter Liste" (eine veränderliche Version des genannten Tupels)?

Sie suchen entweder ein geschlitztes Objekt, das alle Funktionen einer statisch großen Liste oder einer unterklassigen Liste implementiert, die wie ein benanntes Tupel funktioniert (und die die Liste irgendwie aus der Änderung der Größe blockiert).

Ein jetzt erweitertes und vielleicht sogar Liskov -Substitutierbares Beispiel des ersten:

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__)

Und nur unterklassen und definieren __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

NamedTuples sind ein großartiges Merkmal, sie sind perfekter Container für Daten. Wenn Sie Daten "speichern" müssen, würden Sie Tupel oder Wörterbücher verwenden, wie:

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

oder:

user = ("John", 20)

Der Wörterbuchansatz ist überwältigend, da das DICT veränderlich und langsamer ist als Tupel. Andererseits sind die Tupel unveränderlich und leicht, aber es fehlt die Lesbarkeit für eine große Anzahl von Einträgen in den Datenfeldern.

NamedTuples sind der perfekte Kompromiss für die beiden Ansätze, die große Lesbarkeit, Leichtgewicht und Unveränderlichkeit haben (außerdem sind sie polymorph!).

Answer 5

Mit dem Namen Tupel ermöglichen die Rückwärtskompatibilität mit Code, der die Version wie diese überprüft

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

Damit zulässt, dass zukünftiger Code mit dieser Syntax expliziter wird

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

Answer 6

genannt

ist eine der einfachsten Möglichkeiten, Ihren Code aufzuräumen und ihn lesbarer zu machen. Es selbst dokumentiert, was im Tupel passiert. NamenstUples-Instanzen sind genauso Speicher effizient wie reguläre Tupel, da sie keine Wörterbücher pro Instanz haben, was sie schneller als Wörterbücher macht.

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"

Ohne jedes Element im Tupel zu benennen, würde es so lesen:

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"

Es ist so viel schwieriger zu verstehen, was im ersten Beispiel vor sich geht. Mit einem Namenstuple hat jedes Feld einen Namen. Und Sie greifen eher mit Namen als in Position oder Index darauf zu. Anstatt von p[1], Wir können es P.Saturation nennen. Es ist einfacher zu verstehen. Und es sieht sauberer aus.

Das Erstellen einer Instanz des benannten Tupels ist einfacher als das Erstellen eines Wörterbuchs.

# 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

Wann könnten Sie namedTuple verwenden

1. Wie gerade gesagt, erleichtert das benannte Tupel das Verständnis von Tupeln erheblich. Wenn Sie also auf die Elemente im Tupel verweisen müssen, ist es einfach sinnvoll, sie als benannte Tupel zu erstellen.
2. NamedTuple ist nicht nur leichter als ein Wörterbuch, sondern hält auch die Reihenfolge im Gegensatz zum Wörterbuch.
3. Wie im obigen Beispiel ist es einfacher, eine Instanz von namedTuple als Wörterbuch zu erstellen. Und das Verweisen auf den Artikel im benannten Tupel sieht sauberer aus als ein Wörterbuch. p.hue stattp['hue'].

Die Syntax

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

• NamedTuple befindet sich in der Sammlungsbibliothek.
• Typename: Dies ist der Name der neuen Tupel -Unterklasse.
• FELD_NAMES: Eine Sequenz von Namen für jedes Feld. Es kann eine Sequenz wie in einer Liste sein ['x', 'y', 'z'] oder Zeichenfolge x y z (ohne Kommas, nur Weiß) oder x, y, z.
• Umbenennung: Wenn umbenannt wird True, ungültige Feldnamen werden automatisch durch Positionsnamen ersetzt. Zum Beispiel, ['abc', 'def', 'ghi','abc'] wird in konvertiert zu ['abc', '_1', 'ghi', '_3'], das Schlüsselwort eliminieren 'def' (Da dies ein reserviertes Wort zum Definieren von Funktionen ist) und der doppelte Feldname 'abc'.
• ausführlich: wenn ausführlich ist True, Die Klassendefinition wird kurz vor dem Bau gedruckt.

Sie können weiterhin über ihre Position auf NamenstUples zugreifen, wenn Sie dies wünschen. p[1] == p.saturation. Es packt immer noch wie ein normales Tupel aus.

Methoden

All die Regelmäßige Tupelmethoden sind unterstützt. Ex: min (), max (), len (), in, nicht in, verkettet (+), index, scheiben usw. und es gibt einige zusätzliche für namentuple. Hinweis: Diese beginnen alle mit einem Unterstrich. _replace, _make, _asdict.

_replaceGibt eine neue Instanz des benannten Tupels zurück, das bestimmte Felder durch neue Werte ersetzt.

Die Syntax

somenamedtuple._replace(kwargs)

Beispiel

>>>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)

Notiz: Die Feldnamen sind nicht in Zitaten; Sie sind hier Schlüsselwörter.Denken Sie daran: Tupel sind unveränderlich - auch wenn sie genannt werden und das haben _replace Methode. Das _replace produziert a new Beispiel; Es ändert das Original nicht oder ersetzt den alten Wert. Sie können das neue Ergebnis natürlich in der Variablen speichern. p = p._replace(hue=169)

_make

Stellt eine neue Instanz aus einer vorhandenen Sequenz oder iterierbar.

Die Syntax

somenamedtuple._make(iterable)

Beispiel

 >>>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

Was ist mit dem letzten passiert? Das Element in der Klammern sollte iterable sein. Eine Liste oder ein Tupel in der Klammern funktioniert also, aber die Abfolge von Werten, ohne als iterable einzuschließen, gibt einen Fehler zurück.

_asdict

Gibt eine neue zurück Geordnet Welche Feldnamen zu ihren entsprechenden Werten bildet.

Die Syntax

somenamedtuple._asdict()

Beispiel

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

Bezug: https://www.reddit.com/r/python/comments/38ee9d/intro_to_namedtuple/

Es gibt auch eine Namensliste, die dem Namen Tuple ähnelt, aber veränderlich isthttps://pypi.python.org/pypi/namedlist

Answer 7

Was ist namedTuple?

Wie der Name schon sagt, ist Namentuple ein Tupel mit Namen. In Standard -Tupel greifen wir mit dem Index auf die Elemente zu, während mit dem Namen mit dem Namen Benutzer den Namen für Elemente definieren kann. Dies ist sehr praktisch, insbesondere die Verarbeitung von CSV -Dateien (Comma Separated Value) und die Arbeit mit komplexem und großem Datensatz, wobei der Code unter Verwendung von Indizes (nicht so pythonisch) chaotisch wird.

Wie benutzt man sie?

>>>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)

Lektüre

>>>#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

Interessantes Szenario in der CSV -Verarbeitung:

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

In Python im Inneren gibt es eine gute Verwendung des Containers, das als Tupel bezeichnet wird. Es kann verwendet werden, um eine Definition der Klasse zu erstellen, und verfügt über alle Funktionen des ursprünglichen Tupels.

Die Verwendung von Named Tuple wird direkt auf die Standardklassenvorlage angewendet, um eine einfache Klasse zu generieren. Diese Methode ermöglicht viel Code, die Lesbarkeit zu verbessern, und es ist auch sehr bequem beim Definieren einer Klasse.

Answer 9

Ein anderer Weg (ein neuer Weg), mit dem Namen Tuple verwendet wird, besteht darin, das NamedTuple vom Tipppaket zu verwenden: Geben Sie Hinweise in namedtuple ein

Verwenden wir das Beispiel der Top -Antwort in diesem Beitrag, um zu sehen, wie man sie benutzt.

(1) Vor der Verwendung des benannten Tupels ist der Code so:

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)

(2) Jetzt verwenden wir das benannte Tupel

from typing import NamedTuple, Number

Erben Sie die benannte Tuple -Klasse und definieren Sie den variablen Namen in der neuen Klasse. Test ist der Name der Klasse.

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

Erstellen Sie Instanzen aus der Klasse und weisen Sie ihnen Werte zu

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

Verwenden Sie die Variablen aus den Berechnung der Instanzen

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

Answer 10

Versuche dies:

collections.namedtuple()

Grundsätzlich, namedtuples sind leicht zu erstellen, leichte Objekttypen. Sie verwandeln Tupel in praktische Behälter für einfache Aufgaben. Mit namedtuples, Sie müssen keine Ganzzahlindizes verwenden, um auf Mitglieder eines Tupels zuzugreifen.

Beispiele:

Code 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

Code 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

Alle anderen haben es bereits beantwortet, aber ich denke, ich habe noch etwas anderes hinzuzufügen.

NamedTuple könnte intuitiv als Verknüpfung angesehen werden, um eine Klasse zu definieren.

Sehen Sie einen umständlichen und konventionellen Weg, um a zu definieren 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'

Wie für 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'