Python 3.1での変更を読んで、私は何かを見つけました...予期しない：
sys.version_infoタプルは名前付きタプルになりました：
名前付きタプルについてはこれまで聞いたことがなく、要素は数値（タプルやリストなど）またはキー（dictなど）のいずれかでインデックス付けできると思いました。両方の方法でインデックスを作成できるとは思っていませんでした。
したがって、私の質問は次のとおりです。
名前付きタプルは、基本的に作成が簡単で軽量のオブジェクトタイプです。名前付きタプルインスタンスは、オブジェクトのような変数の逆参照または標準のタプル構文を使用して参照できます。structそれらは不変であることを除いて、または他の一般的なレコードタイプと同様に使用できます。これらはPython2.6とPython3.0で追加されましたが、Python2.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
したがって、オブジェクト表記によってコードがよりPython的で読みやすくなると思われる場所では、タプルの代わりに名前付きタプルを使用する必要があります。私は個人的に、特に関数にパラメーターとして渡すときに、非常に単純な値型を表すためにそれらを使用し始めました。タプルパッキングのコンテキストを見なくても、関数が読みやすくなります。
さらに、関数を持たず、フィールドのみを持つ通常の不変クラスを置き換えることもできます。名前付きタプルタイプを基本クラスとして使用することもできます。
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}
すでに述べたように、これらの例が作成された詳細については、ドキュメントを確認する必要があります。
タプルとは何ですか？
名前付きタプルはタプルです。
タプルが実行できるすべてのことを実行します。
しかし、それは単なるタプルではありません。
これは、指定されたフィールドと固定長を使用して、仕様に合わせてプログラムで作成されたタプルの特定のサブクラスです。
これは、たとえば、タプルのサブクラスを作成し、固定長（この場合は3つ）である以外に、タプルが壊れることなく使用されるすべての場所で使用できます。これは、リスコフの置換可能性として知られています。
Python 3.6の新機能として、クラス定義を使用しtyping.NamedTupleて名前付きタプルを作成できます。
from typing import NamedTuple
class ANamedTuple(NamedTuple):
"""a docstring"""
foo: int
bar: str
baz: list
上記は以下と同じですが、上記に型注釈とdocstringが追加されている点が異なります。以下はPython2+で利用できます。
>>> 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'
名前付きタプルは、インデックスだけでなく名前で要素にアクセスできるようにするタプルです。
次のような名前付きタプルを作成します。
>>> from collections import namedtuple
>>> Student = namedtuple('Student', ['first', 'last', 'grade'])
名前をスペースで区切った単一の文字列を使用することもできます。これは、APIのもう少し読みやすい使用法です。
>>> Student = namedtuple('Student', 'first last grade')
それらの使い方は？
タプルが実行できるすべてのこと（上記を参照）を実行できるだけでなく、次のことも実行できます。
>>> 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は、基本的に簡単な省略形で作成できるクラスです。それらをクラスのように扱います。それらをモジュールレベルで定義して、pickleや他のユーザーがそれらを見つけられるようにします。
グローバルモジュールレベルでの実際の例：
>>> 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
namedtupleは、タプルクラスを作成するためのファクトリ関数です。そのクラスを使用して、名前でも呼び出すことができるタプルを作成できます。
import collections
#Create a namedtuple class with names "a" "b" "c"
Row = collections.namedtuple("Row", ["a", "b", "c"])
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)
namedtuplesは優れた機能であり、データの完全なコンテナーです。データを「保存」する必要がある場合は、次のようなタプルまたは辞書を使用します。
user = dict(name="John", age=20)
また：
user = ("John", 20)
dictは可変であり、タプルよりも遅いため、辞書のアプローチは圧倒的です。一方、タプルは不変で軽量ですが、データフィールドの多数のエントリの可読性に欠けています。
namedtuplesは、2つのアプローチの完璧な妥協点であり、優れた可読性、軽量性、および不変性を備えています（さらに、それらは多形性です！）。
名前付きタプルは、このようなバージョンをチェックするコードとの下位互換性を可能にします
>>> sys.version_info[0:2]
(3, 1)
この構文を使用することで、将来のコードをより明確にすることができます
>>> sys.version_info.major
3
>>> sys.version_info.minor
1
コードをクリーンアップして読みやすくする最も簡単な方法の1つです。タプルで何が起こっているかを自己文書化します。Namedtuplesインスタンスは、インスタンスごとのディクショナリがないため、通常のタプルと同じようにメモリ効率が高く、ディクショナリよりも高速です。
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
p.hueではなく
p['hue']。構文
collections.namedtuple(typename, field_names[, verbose=False][, rename=False])
['x', 'y', 'z']または文字列x y z（コンマなし、空白のみ）または。のようなシーケンスにすることができますx, y, z。True、無効なフィールド名は自動的に位置名に置き換えられます。たとえば、['abc', 'def', 'ghi','abc']はに変換され['abc', '_1', 'ghi', '_3']、キーワード'def'（関数を定義するための予約語であるため）と重複するフィールド名を削除し'abc'ます。True、クラス定義はビルドの直前に出力されます。必要に応じて、位置によって名前付きタプルにアクセスできます。p[1] == p.saturation。それでも通常のタプルのように解凍されます。
すべての通常のタプルメソッドがサポートされています。例：min（）、max（）、len（）、in、not in、連結（+）、インデックス、スライスなど。また、namedtupleにはいくつかの追加のものがあります。注：これらはすべてアンダースコアで始まります。_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
フィールド名を対応する値にマップする新しいOrderedDictを返します。
構文
somenamedtuple._asdict()
例
>>>p._asdict()
OrderedDict([('hue', 169), ('saturation', 0.1), ('luminosity', 0.6)])
参照：https ：//www.reddit.com/r/Python/comments/38ee9d/intro_to_namedtuple/
名前付きタプルに似ていますが、変更可能な名前付きリストもあり ますhttps://pypi.python.org/pypi/namedlist
名前付きタプルとは何ですか？
名前が示すように、namedtupleは名前の付いたタプルです。標準のタプルでは、インデックスを使用して要素にアクセスしますが、namedtupleを使用すると、ユーザーは要素の名前を定義できます。これは、特にcsv（コンマ区切り値）ファイルを処理し、複雑で大きなデータセットを操作する場合に非常に便利です。この場合、インデックスを使用するとコードが乱雑になります（それほどpythonicではありません）。
それらの使い方は？
>>>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
CSV処理の興味深いシナリオ：
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)
タプルをサブクラス化し、位置要素にプロパティ名を割り当てるためのレイヤーを追加します
コレクションの標準ライブラリモジュールにあります
from collections import namedtuple
「namedtuple」は、「タプル」から継承する新しいクラスを生成する関数ですが、タプルの要素にアクセスするための「名前付きプロパティ」も提供します。
「namedtuple」はクラスファクトリです。クラスを生成するにはいくつかのことが必要です
使用したいクラス名
タプル内の要素の順序で、割り当てるフィールド名のシーケンス。フィールド名は、「アンダースコア」で始めることができないことを除いて、任意の有効な変数名にすることができます。
「namedtuple」の呼び出しの戻り値はクラスになります。そのクラスをコード内の変数名に割り当てて、インスタンスを構築するために使用できるようにする必要があります。通常、生成されたクラスの名前と同じ名前を使用します。
Coords = namedtuple（'Coords'、['x'、'y']）
これで、Coordsのインスタンスを作成できます。
pt=Coords(10,20)
名前付きtuple関数にフィールド名のリストを提供する方法はたくさんあります。
文字列のリスト
namedtuple('Coords',['x','y'])
文字列のタプル
namedtuple('Coords',('x','y'))
フィールド名が空白またはコンマで区切られた単一の文字列
namedtuple('Coords','x, y'])
名前付きタプルクラスを作成した後、通常のクラスと同じようにそれらをインスタンス化できます。実際、__new__生成されたクラスのメソッドは、パラメーター名として指定したフィールド名を使用します。
Coords = namedtuple('Coords', ['x', 'y'])
coord=Coords(10,20)
名前付きタプルは単なるタプルであるため、他のタプルと同じように処理できます。インデックス、スライス、反復によって
Coords = namedtuple('Coords', ['x', 'y'])
coord=Coords(10,20) isinstance(coord,tuple) --> True # namedtuple is subclass of tuple
x,y=coord # Unpacking
x=coord[0] # by index
for e in coord:
print(e)
これで、クラスで行ったのと同じように、フィールド名を使用してデータにアクセスすることもできます。
coord.x --> 10
coord.y --> 20
名前付きタプルはタプルから継承する生成されたクラスであるため、次のように記述できます。
class Coord(tuple):
....
「coord」はタプルであるため、不変です
フィールド名をアンダースコアで始めることはできません
Coords = namedtuple('Coords', ['x', '_y']) # does not work
namedtupleには、rename無効なフィールド名の名前を自動的に変更するキーワードのみの引数（デフォルトはFalse）があります。
Coords = namedtuple('Coords', ['x', '_y'], rename=True)
フィールド名「x」は変更されませんが、「_y」はに変更され_1ます。1はフィールド名のインデックスです。
名前付きタプルで生成されたクラスのフィールド名を簡単に見つけることができます。
Coords = namedtuple('Coords', ['x', '_y'])
Coords._fields -> ("x","_1") # returns tuple
_source3-3.7未満のPythonを使用している場合は、classプロパティを使用して、そのクラスのコードを実際に確認できます。そのプロパティを実装する際のメモリ使用量について懸念があった可能性があるため、v3.7以降削除されました
Coords = namedtuple('Coords', ['x', 'y'])
coord=Coords(10,20)
coord._asdict()
{'x': 10, 'y': 20}
このクラスがある場合：
class Stock:
def __init__(self, symbol, year, month, day, open, high, low, close):
self.symbol = symbol
self.year = year
self.month = month
self.day = day
self.open = open
self.high = high
self.low = low
self.close = close
クラスアプローチ-vs-タプルアプローチ
djia.symbol djia[0]
djia.open djia[4]
djia.close djia[7]
djia.high – djia.low djia[5] – djia[6]
ご覧のとおり、タプルアプローチは読み取り可能ではありません。コレクション内のnamedtuple 関数を使用すると、各フィールドまたはプロパティに名前が付けられたタプルを作成できます。これは、位置だけに依存するのではなく、「名前」でタプル構造内のデータを参照するのに便利です。ただし、タプルは不変であることに注意してください。可変性が必要な場合は、クラスに固執してください。
内部のPythonには、名前付きタプルと呼ばれるコンテナーがうまく使用されています。これを使用してクラスの定義を作成でき、元のタプルのすべての機能を備えています。
名前付きタプルを使用すると、デフォルトのクラステンプレートに直接適用されて単純なクラスが生成されます。このメソッドを使用すると、多くのコードで読みやすさが向上し、クラスを定義するときにも非常に便利です。
名前付きタプルを使用する別の方法（新しい方法）は、パッケージの入力からNamedTupleを使用することです。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)
（2）名前付きタプルを使用します
from typing import NamedTuple
NamedTupleクラスを継承し、新しいクラスで変数名を定義します。testはクラスの名前です。
class test(NamedTuple):
x: float
y: float
クラスからインスタンスを作成し、それらに値を割り当てます
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)
タイプヒントを使用してNamedTuplesに関する情報を追加する価値があると思います。
# dependencies
from typing import NamedTuple, Optional
# definition
class MyNamedTuple(NamedTuple):
an_attribute: str
my_attribute: Optional[str] = None
next_attribute: int = 1
# instantiation
my_named_tuple = MyNamedTuple("abc", "def")
# or more explicitly:
other_tuple = MyNamedTuple(an_attribute="abc", my_attribute="def")
# access
assert "abc" == my_named_tuple.an_attribute
assert 1 == other_tuple.next_attribute
これを試して：
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
他の誰もがすでにそれに答えていますが、私はまだ何か他に追加する必要があると思います。
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'