Python에서 "named tuples"는 무엇입니까?
- 튜플이라고 하는 것은 무엇이며 어떻게 사용하는가?
- 일반 튜플 대신 명명된 튜플을 사용해야 하는 경우 또는 그 반대로 사용해야 하는 경우.
- "이름 있는 목록"도 있습니까? (예: 가변 이름 있는 튜플)
명명된 튜플은 기본적으로 작성하기 쉽고 가벼운 객체 유형입니다.이름 있는 태플인스턴스는 오브젝트와 같은 변수 참조 또는 표준 태플 구문을 사용하여 참조할 수 있습니다.''와 할 수 있습니다.struct또는 기타 일반적인 레코드 유형(단, 불변).Python 2.6과 Python 3.0에 추가되었지만 Python 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
따라서 오브젝트 표기가 코드를 보다 쉽게 읽을 수 있도록 하는 것으로 생각되는 장소에 tuples 대신 명명된 tuples를 사용해야 합니다.개인적으로 매우 단순한 값 유형을 나타내기 위해, 특히 함수에 매개 변수로 전달할 때 사용하기 시작했습니다.태플 패킹의 컨텍스트를 보지 않고 기능을 보다 쉽게 읽을 수 있습니다.
또한 함수는 없고 필드만 있는 일반 불변의 클래스를 대체할 수도 있습니다.이름 있는 태플 유형을 기본 클래스로 사용할 수도 있습니다.
class Point(namedtuple('Point', 'x y')):
[...]
단, tuples와 마찬가지로 이름 있는 tuples의 속성은 변경할 수 없습니다.
>>> 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에서는 클래스 정의를 사용하여 명명된 튜플을 만들 수 있습니다.
from typing import NamedTuple
class ANamedTuple(NamedTuple):
"""a docstring"""
foo: int
bar: str
baz: list
위에는 타입 주석과 docstring이 추가되어 있다는 점을 제외하고 위는 와 동일합니다.다음은 Python 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'
명명된 튜플은 인덱스가 아닌 이름으로 요소에 액세스할 수 있는 튜플입니다.
이렇게 명명된 튜플을 만듭니다.
>>> 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기본적으로 쉽게 만들 수 있는 클래스입니다.츠미야모듈 수준에서 정의하여 피클 및 다른 사용자가 찾을 수 있도록 합니다.
글로벌 모듈레벨에서의 동작 예를 다음에 나타냅니다.
>>> 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)
명명된 튜플 대신 일반 튜플을 사용해야 하는 이유/시기
명명된 튜플을 사용하는 것에서 튜플로 전환하는 것은 회귀 분석일 수 있습니다.선행 설계 결정은 태플을 사용할 때 추가 코드에 따른 비용이 가독성을 개선할 가치가 있는지 여부에 중점을 두고 있습니다.
명명된 튜플 대 튜플에 사용되는 추가 메모리는 없습니다.
"named list"(네임드 태플의 가변 버전)가 있습니까?
정적 크기 목록의 모든 기능을 구현하는 슬롯 개체 또는 명명된 튜플처럼 작동하는 하위 클래스 목록 중 하나를 찾고 있습니다(이 때문에 목록의 크기가 변경되지 않습니다).
첫 번째 예로는 확장되었으며 아마도 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
named tuple은 태플 클래스를 만들기 위한 공장 함수입니다.이 클래스에서는 이름으로 호출할 수 있는 튜플을 만들 수 있습니다.
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는 가독성, 경량성 및 불변성(및 다형성!)의 두 가지 접근법에 대한 완벽한 타협입니다.
명명된 튜플은 다음과 같은 버전을 확인하는 코드와의 하위 호환성을 허용합니다.
>>> sys.version_info[0:2]
(3, 1)
이 구문을 사용하여 미래의 코드를 보다 명확하게 할 수 있습니다.
>>> sys.version_info.major
3
>>> sys.version_info.minor
1
명명된 태플
코드를 삭제하고 읽기 쉽게 만드는 가장 쉬운 방법 중 하나입니다.태플에서 무슨 일이 일어나고 있는지 스스로 기록한다.명명된 튜플 인스턴스는 인스턴스별 사전이 없는 만큼 일반 튜플과 마찬가지로 메모리 효율이 뛰어나 사전보다 빠릅니다.
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"
첫 번째 예에서 무슨 일이 일어나고 있는지 이해하는 것은 훨씬 더 어렵다. tuple을각name.named tuple이 .위치나 인덱스가 아닌 이름으로 액세스합니다.p[1]., p.saturation., 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
named tuple은 언제 사용할 수 있습니까?
- 앞서 말한 바와 같이 명명된 튜플을 사용하면 이해가 훨씬 쉬워집니다.따라서 튜플의 항목을 참조해야 하는 경우 명명된 튜플로 작성하는 것이 좋습니다.
- namedtuple은 사전보다 더 가벼울 뿐만 아니라 사전과 달리 순서를 지킨다.
- 위의 예시와 같이 namedtuple 인스턴스를 작성하는 것이 사전보다 간단합니다.그리고 명명된 튜플에 있는 항목을 참조하는 것은 사전보다 깨끗해 보입니다.
p.huep['hue'].
구문
collections.namedtuple(typename, field_names[, verbose=False][, rename=False])
- namedtuple은 컬렉션 라이브러리에 있습니다.
- 타이프네임:이것은 새로운 태플 서브클래스의 이름입니다.
- field_names:아!일 수 .
['x', 'y', 'z']문자열 " " " " "x y z('공백')x, y, z. - 이 rename인 : " 변경"
True유효하지 않은 필드명은 자동으로 위치명으로 대체됩니다.를 들어, 「」라고 하는 것은,['abc', 'def', 'ghi','abc']is is is is is로 됩니다.['abc', '_1', 'ghi', '_3']" " " 를 삭제합니다'def'에) 및된 필드명(「」를 참조해 주세요.'abc'. - 가 '상세정보'
True이치노
원하는 경우 위치에 따라 명명된 튜플에 액세스할 수 있습니다. p[1] == p.saturation 일반. 그것은 여전히 일반 태플처럼 풀린다.
방법들
모든 일반 태플 방식이 지원됩니다.예: min(), max(), len(), in, not in, 연결(+), 인덱스, 슬라이스 등그리고 named tuple에는 몇 가지 추가 항목이 있습니다.주의: 모두 밑줄로 시작합니다. _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)
주의: 필드 이름은 따옴표로 묶지 않고 키워드입니다.주의:Tuple은 불변합니다.Tuple이라는 이름이 붙여지고 Tuple이_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
필드 이름을 대응하는 값에 매핑하는 새로운 OrderDict를 반환합니다.
구문
somenamedtuple._asdict()
예
>>>p._asdict()
OrderedDict([('hue', 169), ('saturation', 0.1), ('luminosity', 0.6)])
참고 자료: https://www.reddit.com/r/Python/comments/38ee9d/intro_to_namedtuple/
이름 있는 tuple과 비슷하지만 https://pypi.python.org/pypi/namedlist에서 변경할 수 있는 이름 있는 목록도 있습니다.
튜플이란 이름은 무엇입니까?
이름에서 알 수 있듯이 named tuple은 이름이 붙은 태플이다.표준 태플에서는 인덱스를 사용하여 요소에 액세스하지만 named 태플에서는 사용자가 요소의 이름을 정의할 수 있습니다.이 기능은 특히 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)
튜플을 하위 클래스로 분류하고 도면층을 추가하여 위치 요소에 특성 이름을 할당합니다.
컬렉션 표준 라이브러리 모듈에 있습니다.
from collections import namedtuple
'named tuple'은 'tuple'에서 상속되는 새로운 클래스를 생성하는 함수이지만, 'named properties'를 제공하여 태플의 요소에 액세스합니다.
이름 있는 태플 클래스 생성
"named tuple"은 클래스 공장입니다.클래스를 생성하려면 몇 가지 사항이 필요합니다.
사용하고 싶은 클래스명
할당하는 필드명의 순서(태플의 요소순서).필드 이름은 "밑줄"로 시작할 수 없는 경우를 제외하고 유효한 변수 이름입니다.
"namedtuple"에 대한 콜의 반환값은 클래스가 됩니다.이 클래스를 코드의 변수 이름에 할당해야 인스턴스를 구성할 수 있습니다.일반적으로 생성된 클래스의 이름과 동일한 이름을 사용합니다.
좌표 = 명명된 튜플('Cords', ['x', 'y')
이제 좌표 인스턴스를 만들 수 있습니다.
pt=Coords(10,20)명명된 튜플 함수에 필드 이름 목록을 제공할 수 있는 방법은 여러 가지가 있습니다.
현악기 목록
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 --> 20namedtuple은 생성된 클래스가 태플에서 상속되므로 다음과 같이 쓸 수 있습니다.
class Coord(tuple): ...."tuple"은 태플이므로 불변의
named tuple 키워드 arg
필드 이름은 밑줄로 시작할 수 없습니다.
Coords = namedtuple('Coords', ['x', '_y']) # does not work
에는 키워드 인수 namedtuple이 .rename(기본값은 False) 비활성 필드 이름을 자동으로 변경합니다.
Coords = namedtuple('Coords', ['x', '_y'], rename=True)
되지 않지만 는 "x"로 됩니다._1입니다. 1의
자기성찰
명명된 태플 생성 클래스의 필드 이름이 있는지 쉽게 알 수 있습니다.
Coords = namedtuple('Coords', ['x', '_y'])
Coords._fields -> ("x","_1") # returns tuple
하면 실제로 그의 코드가 알 수 ._source.7.3-3.. 때의 에 대한 수 있기 .7 되었습니다.
명명된 튜플 값을 사전에 추출하는 중
Coords = namedtuple('Coords', ['x', 'y'])
coord=Coords(10,20)
coord._asdict()
{'x': 10, 'y': 20}
named tuple을 사용하는 이유는 무엇입니까?
이 클래스가 있는 경우:
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 컬렉션의 함수를 사용하면 각 필드 또는 속성에 이름이 첨부된 튜플을 만들 수 있습니다.이것은 위치에만 의존하는 것이 아니라 "이름"으로 태플 구조의 데이터를 참조하는 데 편리합니다.하지만 명심해, 튜플은 불변의 존재니까, 만약 당신이 불변성을 원한다면, 클래스를 고수해.
- namedtuple은 반복할 수 있으므로 반복할 수 있는 방법을 사용할 수 있습니다.예를 들어 클래스 인스턴스로 "좌표"가 있는 경우 최대 좌표를 찾을 수 없습니다.하지만 이름 있는 태플이 있으면 할 수 있어요.
Python 내부에는 named tuple이라는 이름의 컨테이너가 있어 클래스 정의를 작성할 수 있으며 오리지널 tuple의 모든 기능을 갖추고 있습니다.
이름 있는 태플을 사용하면 기본 클래스 템플릿에 직접 적용되어 단순한 클래스를 생성할 수 있습니다.이 메서드는 많은 코드를 사용하여 가독성을 향상시킬 수 있으며 클래스를 정의할 때도 매우 편리합니다.
Named에 대한 정보를 추가할 가치가 있다고 생각합니다.유형 힌트를 사용한 튜플:
# 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
명명된 튜플을 사용하는 다른 방법(새로운 방법)은 명명된 튜플을 사용하는 것입니다.타이핑 패키지의 태플:명명된 튜플에 힌트 입력
이 투고에 있는 상위 답변의 예를 사용하여 사용 방법을 알아보겠습니다.
(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
명명된 것을 상속하다클래스를 튜플하고 새 클래스에서 변수 이름을 정의합니다.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)
이것을 시험해 보세요.
collections.namedtuple()
으로는 ★★★★★★★★★★★★★★★★★」namedtuples이치그들은 간단한 작업을 위한 편리한 컨테이너로 tuples를 변환합니다.★★★★★★★★★★★★★★★★ 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
'programing' 카테고리의 다른 글
| Java의 UUID.randomUUID는 어느 정도 우수합니까? (0) | 2022.09.04 |
|---|---|
| Spring Boot 2.5.0은 plain.jar 파일을 생성합니다.제거할 수 있나요? (0) | 2022.09.04 |
| $(표준)jQuery를 사용하지 않는 ready 등가물 (0) | 2022.09.04 |
| 스프링 부트 내장 HornetQ 클러스터가 메시지를 전달하지 않음 (0) | 2022.09.04 |
| SHOW PROCESS LIST에서 전체 쿼리를 표시하는 방법 (0) | 2022.09.04 |