Tuples

 

# Tuples are Immutable
# ====================
# Alright, that's the main difference between a tuple and a list.
# Tuples are immutable.

# Because they don't have the overhead of the methods needed to change them,
# tuples use less memory that lists.
# That's one reason why you might want to use a tuple.

# If your program's dealing with millions of these things, you can save
# memory by using a tuple.

# There are another couple of reasons for preferring a tuple over a list.
# Both reasons are due to tuples being immutable.
# The first reason is to protect the integrity of your data.

# Advantages of Tuples: Number 1
# ==============================
# Using a tuple, for things that should't change,
# can help to prevent bugs in your programs.

# When we tried to alter the tuple a few minutes ago, the program crashed.
# Obviously that's not good, but it's something that we'd spot when testing the code.

# When we used a list, the program didn't crash, and we ended up with incorrect data.
# That could be far worse than the program crashing.

# Advantages of Tuples: Number 2
# ==============================
# The second advantages of tuples, is that you can always unpack them successfully.
# Because a tuple can't be changed, you always know how many items there are to unpack.
# That's why this is described as unpacking a tuple, even though you can unpack any
# sequence type.

 

# 튜플 객체 생성

t = ('white', 'black', 'yellow')print(t)

 

print(type(t))
결과)('white', 'black', 'yellow')

 

<class 'tuple'>
# 요소가 1개라면 소괄호를 사용해도 의미가 없다.t = ('white')print(t)print(type(t))
결과)white

 

<class 'str'>
# 요소가 2개 이상이라면 소괄호가 없어도 기본적으로 튜플이 생성된다.t = 'white', 'black'print(t)

 

print(type(t))
결과)('white', 'black')

 

<class 'tuple'>
# comma 연산자로 생성한다.t = 1, 2, 3, 4

 

print(t)
결과)(1, 2, 3, 4)
# 튜플은 수정이 불가능하다.t = 'first', 'second'

 

t[0] = 'third'
결과)TypeError: 'tuple' object does not support item assignment
# 리스트를 튜플로 변환하기l = ['white', 'black']t = tuple(l)

 

print(t)
결과)('white', 'black')

• 언패킹 (Unpacking)

# 튜플의 요소를 꺼내는 정형화된 방식을 언패킹이라 한다. 리스트에도 사용 가능하나 튜플에서 자주 쓰이며 컨테이너의 크기를 사전에 알고 있어야 한다.

l = ['white', 'black']first, second = lprint(first)

 

print(second)
결과)white

 

black
# 요소 개수가 일치하지 않으면 에러가 발생한다.l = ['white', 'black']first, second, third = lprint(first)print(second)
결과)ValueError: need more than 2 values to unpack

• 튜플의 슬라이싱

# 튜플의 슬라이싱 결과는 튜플이다.t = 'white', 'black'

 

print(t[:])
결과)('white', 'black')
# 슬라이싱에 '[', ']'를 사용한다고 해서 리스트인 것은 아니다.t = 'white', 'black'print(t[0])

 

print(type(t[0]))
결과)white

 

<class 'str'>

• 내장함수 enumerate()를 이용한 리스트 순회

# 인덱스로 리스트를 순회할 때 내장 함수 

enumerate()를 사용할 수 있다. 이 함수는 시퀀스 타입을 하나 받아 두 개의 튜플로 되돌려준다. 각 튜플 요소에는 인덱스와 원래 리스트 요소가 담겨있다. 이 튜플을 for 문의 두 개 변수로 언패킹이 가능하다.

l = ['alpha', 'beta', 'gamma']for i, letter in enumerate(l):

 

print(i, letter)
결과)0 alpha1 beta

 

2 gamma

• 튜플 할당 변수 교환하기

# 리스트에서의 변수 교환x = [1, 2]y = [3, 4]
x, y = y, x
print(x)

 

print(y)
결과)x = [1, 2]y = [3, 4]

# 튜플에서의 변수 교환

a = (1, 2)b = (3, 4)a, b = b, a
print('a:', a)

 

print('b:', b)
결과)a: (3, 4)

 

b: (1, 2)

• 함수에 언팩킹 사용하기

# enumerate() 함수는 인덱스와 요소의 튜플을 리턴한다. 리턴된 튜플이 함수에 적용되면서 개수에 맞게 언팩킹된다.

t = tuple('abcde')
for value in enumerate(t):

 

    print('{}: {}'.format(*value))
결과)0: a1: b2: c3: d

 

4: e

 

# Tuple
# =====
# - It's a sequence of items
# - Individual items can be plucked out by their index position
# - The index() method can be uset to locate the position of an item
# - A tuple doesn't have any of bonus features like a string
# - It's the simplest possible data structure

 

# Tuple as Return Values (Tuple packing)
#
# You can only return one value from a Python function,
# but that value can be a tuple as we've done here.

def circleInfo(r):
    c = 2 * 3.14159 * r
    a = 3.14159 * r * r
    return (c, a)

print(circleInfo(10))

# 결과
(62.8318, 314.159)

 

# Tuple Assignment with unpacking
#
# Unpacking is particularly useful for 
# making iteration code more readable.

def add(n1: int, n2: int) -> int:
    return n1 + n2

print(f"함수에 순서 인자를 넣음: {add(1, 2)}")

ns = (1, 2)
print(f"튜플을 *kwarg로 넣어 unpacking 함: {add(*ns)}")

d ={"1": 1, "2": 2}
for n in d.items():
    print(f"key: {n[0]}, value: {n[1]}")

print("=====")

# You've get one tuple and multiple variable names.
for k, v in d.items():
    print(f"key: {k}, value: {v}")
    

# 결과
함수에 순서 인자를 넣음: 3
튜플을 *kwarg로 넣어 unpacking 함: 3
key: 1, value: 1
key: 2, value: 2
=====
key: 1, value: 1
key: 2, value: 2

 

# 함수에 언패킹 사용하기

work_hours = [('Abby', 100), ('Billy', 200), ('Jerry', 300)]

def employee_check(work_hours):
    current_max = 0
    employee_of_the_month = ''

    for e, h in work_hours:
        if current_max < h:
            current_max = h
            employee_of_the_month = e
        else:
            pass

    return (employee_of_the_month, current_max)

print(employee_check(work_hours))

# 결과
('Jerry', 300)

 

# 명시적 생성자에 의한 튜플 변환
list_in_tuple1 = tuple([1.1, 2.2, 3.3])
list_in_tuple2 = ([1.1, 2.2, 3.3])

print(f'tuple([1.1, 2.2, 3.3]) => {list_in_tuple1}')
print(f'([1.1, 2.2, 3.3]) => {list_in_tuple2}')

# 튜플의 속성 (불변과 메모리 적게 차지)
tuple_1 = (1, 2, 3)
list_1 = [1, 2, 3]

print('elements: 1, 2, 3')
print(f'tuple takes up {tuple_1.__sizeof__()} bytes')
print(f'list takes up {list_1.__sizeof__()} bytes')
print('=' * 50)
print('So if you have a large number of elements,') ;
print('tuples will end up being faster than lists due to ') ;
print('the smaller memory they have compared to a list.')
print('=' * 50)

# 결과
tuple([1.1, 2.2, 3.3]) => (1.1, 2.2, 3.3)
([1.1, 2.2, 3.3]) => [1.1, 2.2, 3.3]
elements: 1, 2, 3
tuple takes up 48 bytes
list takes up 72 bytes
==================================================
So if you have a large number of elements,
tuples will end up being faster than lists due to 
the smaller memory they have compared to a list.
==================================================

 

# 리스트와 동일하지만 튜플을 이용한 슬라이싱
ints_tuples = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

print(f'홀수: {ints_tuples[::2]}') # first부터 2개씩 건너뛰며 선택
print(f'짝수: {ints_tuples[1::2]}') # second부터 2개씩 건너뛰며 선택
print(f'절반 역수: {ints_tuples[4::-1]}') # fifth부터 역으로 하나씩 선택
print(f'역 홀수: {ints_tuples[8::-2]}') # nineth부터 역으로 2개씩 선택

# 결과
홀수: (1, 3, 5, 7, 9)
짝수: (2, 4, 6, 8, 10)
절반 역수: (5, 4, 3, 2, 1)
역 홀수: (9, 7, 5, 3, 1)

 

# 리스트와 동일하지만 튜플을 이용한 슬라이싱 (반복)
num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

print(num_tuple[1::2]) # 짝수

print(num_tuple[0::2]) # 홀수

print(num_tuple[::-2]) # 역 짝수

print(num_tuple[8::-2]) # 역 홀수

print(num_tuple[5::1]) # 6부터 5개

print(num_tuple[0:5:1]) # 1부터 5개

# 결과
(2, 4, 6, 8, 10)
(1, 3, 5, 7, 9)
(10, 8, 6, 4, 2)
(9, 7, 5, 3, 1)
(6, 7, 8, 9, 10)
(1, 2, 3, 4, 5)

 

# 중첩 튜플의 인덱싱
nested_tuple = (1, 2, 3, (4, 5, 6), (7, 8, 9), (10, 11))

print(f'개별 요소 인덱싱: {nested_tuple[0]}')
print(f'중첩 튜플 인덱싱: {nested_tuple[3]}')
print(f'중첩 튜플 내 개별 요소 인덱싱: {nested_tuple[3][1]}')
print(f'중첩 튜플 내 개별 요소 인덱싱: {nested_tuple[5][0]}')

# 결과
개별 요소 인덱싱: 1
중첩 튜플 인덱싱: (4, 5, 6)
중첩 튜플 내 개별 요소 인덱싱: 5
중첩 튜플 내 개별 요소 인덱싱: 10

 

# Tuple Methods
#   - count, index (단, 두 개만 존재)
tn = (1, 2, 3)
print(f"tn contains 2? {tn.count(2)}") # 있으면 1을 반환한다.
print(f"tn contains 99? {tn.count(99)}") # 없으면 0을 반환한다.

ts = ('apple', 'banana', 'cherry')
print(f"ts contains 'apple'? {ts.count('apple')}")
print(f"ts contains 'pears'? {ts.count('pears')}")

print(f"pos of 3 at ts: {tn.index(3)}")
# 주의 index는 요소가 없으면 ValueError가 발생한다.
print(f"pos of 'banana' at ts: {ts.index('banana')}")

# 결과
tn contains 2? 1
tn contains 99? 0
ts contains 'apple'? 1
ts contains 'pears'? 0
pos of 3 at ts: 2
pos of 'banana' at ts: 1