파이썬에서 "명명 된 튜플"이란 무엇입니까?
Python 3.1 의 변경 사항을 읽으면서 예기치 않은 것을 발견했습니다.
sys.version_info 튜플은 이제 명명 된 튜플입니다 .
명명 된 튜플에 대해 들어 본 적이 없었고 요소가 숫자 (튜플 및 목록과 같은) 또는 키 (사전과 같은)로 인덱싱 될 수 있다고 생각했습니다. 나는 그들이 두 가지 방법으로 색인화 될 수 있다고 결코 예상하지 못했습니다.
따라서 내 질문은 다음과 같습니다.
- 명명 된 튜플이란 무엇입니까?
- 어떻게 사용하나요?
- 왜 / 언제 일반 튜플 대신 명명 된 튜플을 사용해야합니까?
- 왜 / 언제 명명 된 튜플 대신 일반 튜플을 사용해야합니까?
- "명명 된 목록"(명명 된 튜플의 변경 가능한 버전)이 있습니까?
명명 된 튜플은 기본적으로 생성하기 쉽고 가벼운 개체 유형입니다. 명명 된 튜플 인스턴스는 객체와 유사한 변수 역 참조 또는 표준 튜플 구문을 사용하여 참조 할 수 있습니다. struct변경 불가능하다는 점을 제외하고는 다른 일반 레코드 유형 과 유사하게 사용할 수 있습니다 . Python 2.4에서 구현 하는 방법 이 있지만 Python 2.6 및 Python 3.0에 추가되었습니다 .
예를 들어, 점을 튜플로 나타내는 것이 일반적 (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}수 있으며 모든 일반적인 사전 함수와 함께 작동 할 수 있습니다.
이미 언급했듯이 이러한 예제가 생성 된 자세한 내용 은 설명서 를 확인 해야합니다 .
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)
명명 된 튜플이란 무엇입니까?
명명 된 튜플은 튜플입니다.
튜플이 할 수있는 모든 것을합니다.
그러나 그것은 단순한 튜플 이상입니다.
이름이 지정된 필드와 고정 길이를 사용하여 사양에 맞게 프로그래밍 방식으로 생성되는 튜플의 특정 하위 클래스입니다.
예를 들어, 이것은 튜플의 서브 클래스를 생성하고 고정 길이 (이 경우 3 개)를 제외하고는 튜플이 끊어지지 않고 사용되는 모든 곳에서 사용할 수 있습니다. 이것은 Liskov 대체 가능성으로 알려져 있습니다.
>>> 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'
명명 된 튜플은 인덱스 대신 이름으로 요소에 액세스 할 수있는 튜플입니다!
다음과 같이 namedtuple을 만듭니다.
>>> 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)
왜 / 언제 명명 된 튜플 대신 일반 튜플을 사용해야합니까?
명명 된 튜플 사용에서 튜플으로 전환하는 것은 아마도 회귀 일 것입니다. 추가 코드로 인한 비용이 튜플을 사용할 때 가독성을 향상시킬 가치가 있는지 여부를 결정하는 초기 디자인 결정은 중심이됩니다.
명명 된 튜플과 튜플이 사용하는 추가 메모리가 없습니다.
"명명 된 목록"(명명 된 튜플의 변경 가능한 버전)이 있습니까?
정적으로 크기가 지정된 목록의 모든 기능을 구현하는 슬롯 형 개체 또는 명명 된 튜플처럼 작동하는 하위 클래스 목록 (어떻게 든 목록의 크기 변경을 차단 함)을 찾고 있습니다.
이제 확장되고 아마도 Liskov 대체 가능, 첫 번째 예 :
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은 훌륭한 기능이며 데이터를위한 완벽한 컨테이너입니다. 데이터를 "저장"해야 할 때 다음과 같은 튜플 또는 사전을 사용합니다.
user = dict(name="John", age=20)
또는:
user = ("John", 20)
dict는 변경 가능하고 튜플보다 느리기 때문에 사전 접근 방식은 압도적입니다. 반면에 튜플은 변경 불가능하고 가볍지 만 데이터 필드의 많은 항목에 대한 가독성이 부족합니다.
명명 된 튜플은 가독성, 경량 성 및 불변성 (또한 다형성입니다!)이라는 두 가지 접근 방식에 대한 완벽한 절충안입니다.
명명 된 튜플은 이와 같은 버전을 확인하는 코드와의 역 호환성을 허용합니다.
>>> sys.version_info[0:2]
(3, 1)
이 구문을 사용하여 향후 코드를보다 명확하게
>>> sys.version_info.major
3
>>> sys.version_info.minor
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이라고 부를 수 있습니다. 이해하기 더 쉽습니다. 그리고 깨끗해 보입니다.
namedtuple의 인스턴스를 만드는 것이 사전을 만드는 것보다 쉽습니다.
# 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
언제 namedtuple을 사용할 수 있습니까?
- 방금 언급했듯이 namedtuple을 사용하면 튜플을 훨씬 쉽게 이해할 수 있습니다. 따라서 튜플의 항목을 참조해야하는 경우 해당 항목을 namedtuple로 만드는 것이 합리적입니다.
- 사전보다 가벼운 것 외에도 namedtuple은 사전과 달리 순서를 유지합니다.
- 위의 예에서와 같이 사전보다 namedtuple의 인스턴스를 만드는 것이 더 간단합니다. 그리고 명명 된 튜플의 항목을 참조하는 것은 사전보다 깔끔해 보입니다.
p.hue대신p['hue'].
구문
collections.namedtuple(typename, field_names[, verbose=False][, rename=False])
- namedtuple은 컬렉션 라이브러리에 있습니다.
- typename : 이것은 새로운 튜플 서브 클래스의 이름입니다.
- field_names : 각 필드의 이름 시퀀스입니다. 목록
['x', 'y', 'z']이나 문자열x y z(쉼표없이 공백 만 있음) 또는x, y, z. - rename : rename이
True이면 잘못된 필드 이름이 자동으로 위치 이름으로 바뀝니다. 예를 들어['abc', 'def', 'ghi','abc']는로 변환되어['abc', '_1', 'ghi', '_3']키워드'def'(함수 정의를위한 예약어이므로)와 중복 fieldname을 제거'abc'합니다. - verbose : verbose가
True이면 클래스 정의가 빌드 직전에 인쇄됩니다.
원하는 경우 위치별로 namedtuple에 액세스 할 수 있습니다. 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 인 명명 된 목록도 있습니다.
Nametuple이란 무엇입니까?
이름에서 알 수 있듯이 namedtuple은 이름이있는 튜플입니다. 표준 튜플에서는 인덱스를 사용하여 요소에 액세스하는 반면 namedtuple에서는 사용자가 요소의 이름을 정의 할 수 있습니다. 이것은 특히 csv (쉼표로 구분 된 값) 파일을 처리하고 복잡하고 큰 데이터 세트로 작업하는 데 매우 편리합니다. 여기서 코드는 인덱스 사용으로 인해 복잡해집니다 (그렇게 파이썬 적이 지 않음).
그들을 사용하는 방법?
>>>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)
파이썬 내부에는 명명 된 튜플이라는 컨테이너가 잘 사용되고 있으며, 클래스 정의를 생성하는 데 사용할 수 있으며 원래 튜플의 모든 기능을 가지고 있습니다.
명명 된 튜플을 사용하면 기본 클래스 템플릿에 직접 적용되어 간단한 클래스를 생성 할 수 있습니다.이 메서드는 많은 코드를 사용하여 가독성을 높이고 클래스를 정의 할 때 매우 편리합니다.
명명 된 튜플을 사용하는 또 다른 방법 (새로운 방법)은 package 입력에서 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, Number
NamedTuple 클래스를 상속하고 새 클래스에서 변수 이름을 정의합니다. test는 클래스의 이름입니다.
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)
이 시도:
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'
참고 URL : https://stackoverflow.com/questions/2970608/what-are-named-tuples-in-python
'Development Tip' 카테고리의 다른 글
| 32 비트 정수에서 설정 비트 수를 계산하는 방법은 무엇입니까? (0) | 2020.09.28 |
|---|---|
| ASP.NET 웹 사이트 또는 ASP.NET 웹 응용 프로그램? (0) | 2020.09.28 |
| sudo를 사용하여 쓰기 권한이없는 위치로 출력을 리디렉션하려면 어떻게해야합니까? (0) | 2020.09.28 |
| Java에서 2 * (i * i)가 2 * i * i보다 빠른 이유는 무엇입니까? (0) | 2020.09.28 |
| 이벤트 버블 링 및 캡처 란 무엇입니까? (0) | 2020.09.27 |