> > > # 기본 예
> > >
> > > Point = namedtuple('Point', ['x', 'y'])
> > > p = Point(11, y=22) # 위치와 키워드 인자로 인스턴스를 만듭니다
> > > p[0] + p[1] # 일반 튜플 (11, 22) 처럼 인덱싱할 수 있습니다
> > > 33
> > > x, y = p # 일반 튜플처럼 언팩합니다
> > > x, y
> > > (11, 22)
> > > p.x + p.y # 필드는 이름으로도 액세스할 수 있습니다
> > > 33
> > > p # name=value 스타일의 가독성 있는 **repr**
> > > Point(x=11, y=22) 

# runtime.py written in PyCharm

from time import time
from math import sqrt

# 일반적인 튜플 사용

pt1 = (1.0, 5.0)
pt2 = (2.5, 1.5)

start1= time()
line_leng1 = sqrt((pt2[0] - pt1[0]) ** 2 + (pt2[1] - pt1[1]) ** 2)
end1 = time()
print('tuple: '.rjust(15), round((end1-start1)\* 10\*\*3, 6))

###################################################################

# 네임드 튜플 사용

from collections import namedtuple

Point = namedtuple('Point', 'x y')
pnt1 = Point(1.0, 5.0)
pnt2 = Point(2.5, 1.5)

start2= time()
line_leng2 = sqrt((pnt2.x - pnt1.x) ** 2 + (pnt2.y - pnt1.y) ** 2)
end2 = time()
print('namedTuple: '.rjust(15), round((end2-start2)\* 10\*\*3, 6))

###################################################################

# 딕셔너리 사용

pdt1 = {'x': 1.0, 'y': 5.0}
pdt2 = {'x': 2.5, 'y': 1.5}

start3= time()
line_leng3 = sqrt((pdt2['x'] - pdt1['x']) ** 2 + (pdt2['y'] - pdt1['y']) ** 2)
end3 = time()
print('dict: '.rjust(15), round((end3-start3)\* 10\*\*3, 6)) 

tuple: 0.068188
namedTuple: 0.010014
dict: 0.004053 

# runtime.py written in PyCharm

from collections import deque

deq = deque(['a', 'b', 'c'])

deq.append('d')
print('append -> d: ', deq)
deq.appendleft('z')
print('append <- z: ', deq)
deq.extend('ef')
print('extend -> ef: ', deq) # list의 extend 결과와 조금 다른 것을 주의!!
deq.extendleft('xy')
print('extend <- xy: ', deq)

deql = deq.copy()

print('deque.pop() ->', end=' ')
while True:
try:
print(deq.pop(), end=' ')
except IndexError:
break

print()
print('deque.popleft() <-', end=' ')
while True:
try:
print(deql.popleft(), end=' ')
except IndexError:
break 

append -> d: deque(['a', 'b', 'c', 'd'])
append <- z: deque(['z', 'a', 'b', 'c', 'd'])
extend -> ef: deque(['z', 'a', 'b', 'c', 'd', 'e', 'f'])
extend <- xy: deque(['y', 'x', 'z', 'a', 'b', 'c', 'd', 'e', 'f'])
deque.pop() -> f e d c b a z x y
deque.popleft() <- y x z a b c d e f 

# runtime.py written in PyCharm

from collections import ChainMap
from time import time

# ChainMap 사용

start = time()
toys = {'Blocks': 30, 'Monopoly': 20}
computers = {'iMac': 1000, 'Chromebook': 800, 'PC': 400}
clothing = {'Jeans': 40, 'T-Shirt': 10}
inventory_chain = ChainMap(toys, computers, clothing)
end = time()
run = end - start

print(round(run \* 10\*\*2, 5))
##########################################################

# dict.update() 사용

start1 = time()
inventory = dict()
inventory.update(toys)
inventory.update(computers)
inventory.update(clothing)
end1 = time()
run1 = end1 - start1

print(round(run1 \* 10\*\*2, 5))
##########################################################

# 내용 확인

print(inventory_chain if inventory_chain == inventory else 'Not same!') 

0.00088
0.00062
ChainMap({'Blocks': 30, 'Monopoly': 20}, {'iMac': 1000, 'Chromebook': 800, 'PC': 400}, {'Jeans': 40, 'T-Shirt': 10}) 

> > > # 목록에 있는 단어의 빈도를 집계
> > >
> > > cnt = Counter()
> > > for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
> > > ... cnt[word] += 1
> > > cnt
> > > Counter({'blue': 3, 'red': 2, 'green': 1})

> > > # 햄릿에서 가장 흔한 단어를 찾음
> > >
> > > import re
> > > words = re.findall(r'\w+', open('hamlet.txt').read().lower())
> > > Counter(words).most_common(10)
> > > [('the', 1143), ('and', 966), ('to', 762), ('of', 669), ('i', 631),
> > > ('you', 554), ('a', 546), ('my', 514), ('hamlet', 471), ('in', 451)] 

> > > d.move_to_end('b')
> > > ''.join(d.keys())
> > > 'acdeb'
> > > d.move_to_end('b', last=False)
> > > ''.join(d.keys())
> > > 'bacde'