Apa yang disebut "tupel" dengan Python?

Membaca perubahan dalam Python 3.1 , saya menemukan sesuatu ... tak terduga:

Tuple sys.version_info sekarang menjadi tuple bernama :

Saya tidak pernah mendengar tentang nama tupel sebelumnya, dan saya pikir elemen dapat diindeks dengan angka (seperti dalam tupel dan daftar) atau dengan kunci (seperti dalam dikts). Saya tidak pernah berharap mereka bisa diindeks dua arah.

Jadi, pertanyaan saya adalah:

• Apa yang disebut tuple?
• Bagaimana cara menggunakannya?
• Mengapa / kapan saya harus menggunakan nama tuple alih-alih tuple normal?
• Mengapa / kapan saya harus menggunakan tuple biasa dan bukan tuple bernama?
• Apakah ada jenis "daftar nama" (versi yang dapat diubah dari tuple bernama)?

Tupel bernama pada dasarnya mudah dibuat, jenis objek yang ringan. Contoh tuple yang dinamai dapat dirujuk menggunakan dereferencing variabel seperti objek atau sintaks tuple standar. Mereka dapat digunakan serupa dengan structatau jenis rekaman umum lainnya, kecuali bahwa mereka tidak berubah. Mereka ditambahkan dalam Python 2.6 dan Python 3.0, meskipun ada resep untuk implementasi di Python 2.4 .

Sebagai contoh, itu umum untuk mewakili titik sebagai tupel (x, y). Ini mengarah ke kode seperti berikut:

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)

Menggunakan tuple bernama itu menjadi lebih mudah dibaca:

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)

Namun, tupel bernama masih kompatibel dengan tupel normal, sehingga yang berikut masih berfungsi:

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

Dengan demikian, Anda harus menggunakan nama tuple daripada tuple di mana saja Anda pikir notasi objek akan membuat kode Anda lebih pythonic dan lebih mudah dibaca . Saya pribadi sudah mulai menggunakannya untuk mewakili tipe nilai yang sangat sederhana, terutama ketika meneruskannya sebagai parameter untuk fungsi. Itu membuat fungsi lebih mudah dibaca, tanpa melihat konteks pengemasan tuple.

Selain itu, Anda juga dapat mengganti kelas abadi biasa yang tidak memiliki fungsi , hanya bidang dengan mereka. Anda bahkan dapat menggunakan tipe tuple bernama Anda sebagai kelas dasar:

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

Namun, seperti halnya tupel, atribut dalam tupel bernama tidak dapat diubah:

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

Jika Anda ingin dapat mengubah nilai, Anda perlu tipe lain. Ada resep praktis untuk recordtypable yang bisa diubah yang memungkinkan Anda untuk menetapkan nilai baru ke atribut.

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

Namun, saya tidak mengetahui adanya "daftar nama" yang memungkinkan Anda menambahkan bidang baru. Anda mungkin hanya ingin menggunakan kamus dalam situasi ini. Tupel yang diberi nama dapat dikonversi ke kamus menggunakan pt1._asdict()yang mengembalikan {'x': 1.0, 'y': 5.0}dan dapat dioperasikan dengan semua fungsi kamus yang biasa.

Seperti yang sudah disebutkan, Anda harus memeriksa dokumentasi untuk informasi lebih lanjut dari mana contoh-contoh ini dibangun.

namedtuple adalah fungsi pabrik untuk membuat kelas tuple. Dengan kelas itu kita bisa membuat tupel yang bisa dipanggil dengan nama juga.

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)

Apa yang disebut tuple?

Sebuah tuple bernama adalah tuple.

Itu melakukan semua yang bisa dilakukan oleh tuple.

Tapi itu lebih dari sekadar tuple.

Ini adalah subkelas spesifik dari tupel yang secara pemrograman dibuat sesuai spesifikasi Anda, dengan bidang bernama dan panjang tetap.

Ini, misalnya, membuat subkelas tupel, dan selain memiliki panjang tetap (dalam hal ini, tiga), ia dapat digunakan di mana pun tupel digunakan tanpa putus. Ini dikenal sebagai substitusi Liskov.

Baru di Python 3.6 , kita bisa menggunakan definisi kelas dengantyping.NamedTupleuntuk membuat nameserupup:

from typing import NamedTuple

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

Di atas sama dengan yang di bawah, kecuali yang di atas juga memiliki jenis anotasi dan dokumentasi. Di bawah ini tersedia dalam Python 2+:

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

Ini instantiate itu:

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

Kami dapat memeriksanya dan menggunakan atributnya:

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

Penjelasan lebih dalam

Untuk memahami tupel bernama, Anda harus terlebih dahulu tahu apa tupel itu. Sebuah tuple pada dasarnya adalah daftar yang tidak dapat diubah (tidak dapat diubah di tempat dalam memori).

Inilah cara Anda menggunakan tuple biasa:

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

Anda dapat memperluas tuple dengan membongkar iterable:

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

Named tuple adalah tuple yang memungkinkan elemen-elemennya diakses dengan nama alih-alih hanya indeks!

Anda membuat nama bernama seperti ini:

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

Anda juga dapat menggunakan string tunggal dengan nama yang dipisahkan oleh spasi, penggunaan API yang sedikit lebih mudah dibaca:

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

Bagaimana cara menggunakannya?

Anda dapat melakukan semua hal yang dapat dilakukan oleh tuple (lihat di atas) dan juga melakukan hal berikut:

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

Seorang komentator bertanya:

Dalam skrip atau program besar, di mana biasanya orang mendefinisikan tuple bernama?

Jenis yang Anda buat namedtuplepada dasarnya adalah kelas yang dapat Anda buat dengan singkatan yang mudah. Perlakukan mereka seperti kelas. Tentukan mereka di tingkat modul, sehingga acar dan pengguna lain dapat menemukannya.

Contoh kerja, pada tingkat modul global:

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

Dan ini menunjukkan kegagalan untuk mencari definisi:

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

Mengapa / kapan saya harus menggunakan nama tuple alih-alih tuple normal?

Gunakan mereka ketika meningkatkan kode Anda untuk memiliki semantik elemen tuple yang dinyatakan dalam kode Anda.

Anda dapat menggunakannya sebagai ganti objek jika Anda akan menggunakan objek dengan atribut data yang tidak berubah dan tidak ada fungsi.

Anda juga dapat mensubklasifikasikan mereka untuk menambahkan fungsionalitas, misalnya :

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)

Mengapa / kapan saya harus menggunakan tuple biasa dan bukan tuple bernama?

Mungkin akan menjadi regresi untuk beralih dari menggunakan nama tupel ke tupel. Keputusan desain dimuka berpusat di sekitar apakah biaya dari kode tambahan yang terlibat layak dibaca lebih baik ketika tuple digunakan.

Tidak ada memori tambahan yang digunakan oleh nama tuple versus tuple.

Apakah ada jenis "daftar nama" (versi yang dapat diubah dari tuple bernama)?

Anda sedang mencari objek yang ditempatkan yang mengimplementasikan semua fungsi dari daftar berukuran statis atau daftar subkelas yang bekerja seperti tuple bernama (dan yang entah bagaimana memblokir daftar dari perubahan ukuran.)

A sekarang diperluas, dan mungkin bahkan Liskov yang dapat diganti, contoh yang pertama:

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

Dan untuk digunakan, cukup subkelas dan tentukan __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

namedtuples adalah fitur yang hebat, mereka wadah yang sempurna untuk data. Saat Anda harus "menyimpan" data, Anda akan menggunakan tuple atau kamus, seperti:

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

atau:

user = ("John", 20)

Pendekatan kamus luar biasa, karena dikt dapat berubah dan lebih lambat dari tupel. Di sisi lain, tupel tidak berubah dan ringan tetapi kurang mudah dibaca untuk sejumlah besar entri di bidang data.

Bernamaup adalah kompromi yang sempurna untuk dua pendekatan, memiliki keterbacaan yang hebat, ringan dan kekekalan (ditambah mereka polimorfik!).

beri nama tuple memungkinkan kompatibilitas dengan kode yang memeriksa versi seperti ini

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

sementara memungkinkan kode masa depan menjadi lebih eksplisit dengan menggunakan sintaks ini

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

namedtuple

adalah salah satu cara termudah untuk membersihkan kode Anda dan membuatnya lebih mudah dibaca. Ini mendokumentasikan apa yang terjadi di tuple. Contoh Namedtuples sama efisiennya dengan memori dengan tupel biasa karena mereka tidak memiliki kamus per-instance, menjadikannya lebih cepat daripada kamus.

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"

Tanpa menyebutkan setiap elemen dalam tuple, akan berbunyi seperti ini:

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"

Jauh lebih sulit untuk memahami apa yang terjadi dalam contoh pertama. Dengan nama yang dinamai, setiap bidang memiliki nama. Dan Anda mengaksesnya dengan nama daripada posisi atau indeks. Alih-alih p[1], kita bisa menyebutnya p.saturation. Lebih mudah dimengerti. Dan itu terlihat lebih bersih.

Membuat instance dari namesuple lebih mudah daripada membuat kamus.

# 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

Kapan mungkin Anda menggunakan namesuple

1. Seperti yang baru saja dinyatakan, namesuple membuat pemahaman tuple menjadi lebih mudah. Jadi jika Anda perlu mereferensikan item dalam tuple, maka membuat item tersebut sebagai namesuple masuk akal.
2. Selain lebih ringan dari kamus, namedtuple juga menjaga urutan tidak seperti kamus.
3. Seperti pada contoh di atas, lebih mudah untuk membuat instance dari namestuple daripada kamus. Dan referensi item dalam tuple bernama terlihat lebih bersih daripada kamus. p.huebukannya p['hue'].

Sintaksnya

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

• namedtuple ada di perpustakaan koleksi.
• ketikkan nama: Ini adalah nama subclass tuple baru.
• field_names: Urutan nama untuk setiap bidang. Itu bisa berupa urutan seperti dalam daftar ['x', 'y', 'z']atau string x y z(tanpa koma, hanya spasi putih) atau x, y, z.
• rename: Jika rename adalah True, nama field yang tidak valid secara otomatis diganti dengan nama posisional. Misalnya, ['abc', 'def', 'ghi','abc']dikonversi menjadi ['abc', '_1', 'ghi', '_3'], menghilangkan kata kunci 'def'(karena itu adalah kata yang disediakan untuk mendefinisikan fungsi) dan fieldname duplikat 'abc'.
• verbose: Jika verbose adalah True, definisi kelas dicetak sesaat sebelum dibangun.

Anda masih dapat mengakses namesuple dengan posisi mereka, jika Anda mau. p[1] == p.saturation. Itu masih membongkar seperti tuple biasa.

Metode

Semua metode tuple reguler didukung. Mis: min (), maks (), len (), dalam, bukan dalam, gabungan (+), indeks, slice, dll. Dan ada beberapa yang tambahan untuk namedtuple. Catatan: ini semua dimulai dengan garis bawah. _replace, _make, _asdict.

_replace Mengembalikan instance baru dari tuple bernama menggantikan bidang yang ditentukan dengan nilai-nilai baru.

Sintaksnya

somenamedtuple._replace(kwargs)

Contoh

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

Perhatikan : Nama bidang tidak ada dalam tanda kutip; mereka adalah kata kunci di sini. Ingat : Tuple tidak dapat diubah - bahkan jika mereka diberi nama Tupel dan memiliki _replacemetode. The _replacemenghasilkan newcontoh; itu tidak mengubah yang asli atau mengganti nilai yang lama. Anda tentu saja dapat menyimpan hasil baru ke variabel.p = p._replace(hue=169)

_make

Membuat instance baru dari urutan yang ada atau iterable.

Sintaksnya

somenamedtuple._make(iterable)

Contoh

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

Apa yang terjadi dengan yang terakhir? Item di dalam kurung harus iterable. Jadi daftar atau tuple di dalam tanda kurung bekerja, tetapi urutan nilai tanpa melampirkan sebagai iterable mengembalikan kesalahan.

_asdict

Mengembalikan OrderedDict baru yang memetakan nama bidang ke nilai yang sesuai.

Sintaksnya

somenamedtuple._asdict()

Contoh

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

Referensi : https://www.reddit.com/r/Python/comments/38ee9d/intro_to_namedtuple/

Ada juga daftar bernama yang mirip dengan nama tuple tetapi dapat diubah https://pypi.python.org/pypi/namedlist

Apa yang disebuttuple?

Seperti namanya, namesuple adalah tuple dengan nama. Dalam tuple standar, kami mengakses elemen menggunakan indeks, sedangkan namupuple memungkinkan pengguna untuk menentukan nama untuk elemen. Ini sangat berguna terutama memproses file csv (comma separated value) dan bekerja dengan dataset yang kompleks dan besar, di mana kode menjadi berantakan dengan penggunaan indeks (tidak terlalu pythonic).

Bagaimana cara menggunakannya?

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

Bacaan

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

Skenario Menarik dalam Pemrosesan 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)

Dalam Python di dalamnya ada penggunaan wadah yang baik bernama tuple bernama, itu dapat digunakan untuk membuat definisi kelas dan memiliki semua fitur tuple asli.

Menggunakan tuple bernama akan langsung diterapkan ke templat kelas default untuk menghasilkan kelas sederhana, metode ini memungkinkan banyak kode untuk meningkatkan keterbacaan dan juga sangat nyaman saat mendefinisikan kelas.

Cara lain (cara baru) untuk menggunakan nama tuple adalah dengan menggunakan NamedTuple dari mengetik paket: Ketik petunjuk dalam namedtuple

Mari kita gunakan contoh jawaban teratas di posting ini untuk melihat bagaimana menggunakannya.

(1) Sebelum menggunakan tuple bernama, kodenya seperti ini:

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) Sekarang kita menggunakan tuple bernama

from typing import NamedTuple, Number

mewarisi kelas NamedTuple dan mendefinisikan nama variabel di kelas baru. test adalah nama kelas.

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

buat instance dari kelas dan berikan nilai kepada mereka

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

gunakan variabel dari instance untuk menghitung

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

Coba ini:

collections.namedtuple()

Pada dasarnya, namedtuplesmudah dibuat, jenis objek yang ringan. Mereka mengubah tuple menjadi wadah yang nyaman untuk tugas-tugas sederhana. Dengan namedtuples, Anda tidak harus menggunakan indeks integer untuk mengakses anggota tuple.

Contoh:

Kode 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

Kode 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

Semua orang sudah menjawabnya, tapi saya pikir saya masih punya sesuatu untuk ditambahkan.

Namedtuple dapat secara intuitif dianggap sebagai jalan pintas untuk mendefinisikan kelas.

Lihat cara rumit dan konvensional untuk mendefinisikan a 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'

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