파이썬(python) 튜플(tuple)과 시퀀스(sequense) 정리

튜플은 다양한 데이터 객체들을 담을 수 있다는 점에서 리스트 같이 시퀀스로 분류됩니다. 그러나 리스트와 달리 튜플은 불변(immutable)이기 때문에 용법에서 차이가 있습니다.

튜플(Tuple)

이름	type	예시	가변성	순서유지	중복허용
리스트	list	["사과", 123, 3.14]	가변	O	O
튜플	tuple	("사과", 123, 3.14)	불변	O	O
집합	set	{"사과", 123, 3.14}	가변	X	X
사전	dict	{"원주율":3.14, 123:"일이삼"}	가변	3.6+	키X값O

튜플 만들기

튜플은 괄호와 컴마를 사용합니다. 이때 컴마가 있다면 괄호를 생략할 수도 있습니다.

괄호와 컴마 사용

• t = () 비어있는 튜플
• t = (1, 2, 3)
• t = ("Hello", 3.14, 123) 여러가지 객체들을 담을 수 있어요
• t = ("hello",) 맨 뒤에 컴마가 있으면 아이템이 하나만 있는 튜플을 만들 수 있어요. 컴마가 없으면 그냥 문자열입니다.
• t = "hello", 가독성을 높이기 위해 포매터가 괄호를 넣어줍니다.
• t = 1, 2, 3 튜플을 만들 때 괄호를 생략하는 것을 패킹(packing)이라고 부르기도 합니다.

 

반응형

 

In [1]:

# 리스트를 튜플로 변경할 수 있습니다.
l = [123, 3.14, "Hello"]
t = tuple(l)
t

 

Out[1]:

(123, 3.14, 'Hello')

 

In [2]:

type(t)

 

Out[2]:

tuple

 

In [3]:

# 튜플을 리스트로
m = list(t)
m

 

Out[3]:

[123, 3.14, 'Hello']

 

In [4]:

type(m)

 

Out[4]:

list

 

In [5]:

# 튜플도 안에 튜플을 넣을 수 있습니다.
t = 123, 3.14, "hi!"
u = t, (1, 2, 3)
u

 

Out[5]:

((123, 3.14, 'hi!'), (1, 2, 3))

 

In [6]:

# t의 id와 u안에 들어 있는 t의 id가 동일하다는 것을 확인할 수 있습니다.
id(t) == id(u[0])

 

Out[6]:

True

 

In [7]:

# 튜플 안에 리스트를 넣을 수도 있습니다.
v = ([1, 2], [3.0, 4.9])
for j in v :
    for i in j:
        print(i)

 

 

1
2
3.0
4.9

 

In [8]:

# 리스트 안에 튜플을 넣을 수도 있습니다.
l = [1, 2, 3, (1, 2, 3)]
l

 

Out[8]:

[1, 2, 3, (1, 2, 3)]

 

 

 

[주의] 튜플 안에 가변 객체가 들어 있으면 사전(dict)의 키(key)로 사용될 수 없습니다.

뒤에 dictionary에서 자세히 다루어 보겠습니다.

 

In [9]:

my_dict = {"a":"안녕"}
my_dict["a"]

 

Out[9]:

'안녕'

 

In [10]:

# v는 리스트인데 리스트는 가변객체이므로 키로 사용이 될 수 없습니다.
d = {v: "hello"}
d[v]

 

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [10], in <cell line: 2>()
      1 # v는 리스트인데 리스트는 가변객체이므로 키로 사용이 될 수 없습니다.
----> 2 d = {v: "hello"}
      3 d[v]

TypeError: unhashable type: 'list'

 

 

튜플의 기본적인 사용법

인덱싱과 슬라이싱 방법은 리스트와 동일합니다.

 

In [11]:

t = (1, 2, 3, 5, 6)
# 인덱싱
t[3]

 

Out[11]:

5

 

In [12]:

# 슬라이싱
t[::-1]

 

Out[12]:

(6, 5, 3, 2, 1)

 

 

여러가지 메써드들을 사용할 수 있습니다.

 

In [13]:

# 아이템이 몇 개 들어있는 지를 알려줍니다.
len(t)

 

Out[13]:

5

 

In [14]:

t = ("A", "B", "C", "D", "E")

# "C"가 들어있는 위치 인덱스를 알려줍니다.

t.index("C")

 

Out[14]:

2

 

In [15]:

t = (1, 2, 3, 3, 3, 3, 3, 4, 5)

# 3이 몇 개 들어있는지를 알려줍니다.

t.count(3)

# [참고] 뒤에 배울 set()은 같은 원소를 여러개 포함할 수 없습니다.

 

Out[15]:

5

 

 

패킹(packing)과 언패킹(unpacking)

 

 

튜플을 만들 때 괄호를 생략하는 것을 여러 객체들을 묶어서 포장한다는 의미에서 패킹(packing)이라고 부르기도 합니다.

 

In [16]:

t = 1 ,2, 3, "python"
t

 

Out[16]:

(1, 2, 3, 'python')

 

 

[비교] print(a, "헬로우")와 같이 함수를 호출할 때 괄호 속에 객체들을 나열하는 것과는 다릅니다. 여기에 대해서는 함수에서 다룹니다.

 

In [17]:

t = (123, 456, "hello")

# 튜플 언패킹(unpacking)

a, b, c = t

print(a, b , c)

 

 

123 456 hello

 

In [18]:

# 아이템의 개수가 맞지 않으면 오류가 발생합니다.

x, y = t

print(x, y)

 

 

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Input In [18], in <cell line: 3>()
      1 # 아이템의 개수가 맞지 않으면 오류가 발생합니다.
----> 3 x, y = t
      5 print(x, y)

ValueError: too many values to unpack (expected 2)

 

In [19]:

# 아이템 중 일부를 사용하지 않을 예정이라면 언더스코어로 개수만 맞출 수도 있습니다.
# _는 변수가 아니라 그 자리로 언패킹될 아이템은 안받겠다는 의미입니다.

x, y , _ = t
print(x, y)

 

 

123 456

 

 

문자열이나 리스트 같은 다른 시퀀스에서도 언패킹을 사용할 수 있습니다.

 

In [20]:

# 문자열 언패킹
my_str = "안녕하세요?"
a, b, c, d, e, _ = my_str
print(a, b, c)

 

 

안 녕 하

 

In [21]:

# 리스트 언패킹
l = [1, 2, 3]
a, b, _ = l
a, b

 

Out[21]:

(1, 2)

 

In [22]:

type(a)

 

Out[22]:

int

 

 

튜플의 불변성(Immutability)

튜플은 객체의 내용을 변경할 수 없습니다.

 

In [23]:

t = (123, 456, "hello")
t[0] = 789

 

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Input In [23], in <cell line: 2>()
      1 t = (123, 456, "hello")
----> 2 t[0] = 789

TypeError: 'tuple' object does not support item assignment

 

 

당연히 객체를 변경하는 메써드들도 가지고 있지 않습니다.

 

In [24]:

# 리스트에는 append() 메소드가 있었지만 튜플은 가능할까요?.
t.append("새로 추가가 가능할까요?")

 

 

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Input In [24], in <cell line: 2>()
      1 # 리스트에는 append() 메소드가 있었지만 튜플은 가능할까요?.
----> 2 t.append("새로 추가가 가능할까요?")

AttributeError: 'tuple' object has no attribute 'append'

 

In [25]:

# 리스트에는 reverse() 메소드가 있었지만 튜플은 가능할까요?
t.reverse()

 

 

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Input In [25], in <cell line: 2>()
      1 # 리스트에는 reverse() 메소드가 있었지만 튜플은 가능할까요?
----> 2 t.reverse()

AttributeError: 'tuple' object has no attribute 'reverse'

 

 

튜플은 리스트보다 메모리를 적게 사용합니다.

 

In [26]:

l = ["사과", "바나나", "오렌지", 3.14]
t = tuple(l)

import sys
print("리스트 객체의 크기", sys.getsizeof(l))
print("튜플 객체의 크기", sys.getsizeof(t))

 

 

리스트 객체의 크기 120
튜플 객체의 크기 72

 

 

일반적으로 리스트는 아이템을 추가하거나 삭제할 일이 많을 때 편리합니다. 예를 들어서 맛집의 대기 손님의 목록(리스트)을 생각해보면 새로운 손님을 추가할 수도 있고 입장한 손님을 삭제할 수도 있어야 합니다.

반면에 튜플은 리스트보다 메모리를 적게 차지하고 처리 속도가 빠릅니다. 아이템 추가/삭제가 불가능하다는 점에서 사용이 불편해 보일 수도 있지만 리스트의 가변성이 예기치 못한 실수나 문맥 오류로 이어질 수도 있기 때문에 튜플이 오히려 더 중요하게 사용되는 경우도 많습니다.

 

 

[시퀀스] (Sequence) : 수학에서는 수의 나열, 수열이라고도 합니다.

문자열(str), 리스트(list), 튜플(tuple), 범위(range) 등이 시퀀스 자료형으로 분류됩니다. 아래 연산들은 모든 시퀀스 객체에서 사용할 수 있습니다. 시퀀스가 아이템들이 나열된 구조라는 것과 연관 지으면 직관적으로 이해할 수 있습니다.

 

In [27]:

t = (1, 2, 3, 4, 5)

# 1이 t에 포함되어 있는지를 True/False로 알려줍니다.
1 in t

 

Out[27]:

True

 

In [28]:

t = (1, 2, 3, 4, 5)

# 1이 t에 포함되어 있지 '않은지'를 True/False로 알려줍니다.
1 not in t

 

Out[28]:

False

 

In [29]:

t = (1, 2, 3, 4, 5)
s = (6, 7, 8, 9, 10)

# +로 합칠 수 있습니다.
t + s

 

Out[29]:

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

 

In [30]:

t = (1, 2, 3, 4, 5)

# 가장 큰 아이템을 찾아줍니다. 
max(t)

 

Out[30]:

5

 

In [31]:

t = (1, 2, 3, 4, 5, 8, 10)

# 가장 작은 아이템을 찾아줍니다. 
min(t)

 

Out[31]:

1

 

In [32]:

# numpy를 호출하여 중앙값을 구할수도 있습니다. numpy는 추후에 다루도록 하겠습니다. 
import numpy as np
np.median(t)

 

Out[32]:

4.0

 

In [33]:

# 평균도 계산할 수 있습니다.
np.mean(t)

 

Out[33]:

4.714285714285714

 

In [34]:

t = ("A", "B", "C", "D", "E", "a", "b", "c", "d", "e")
max(t)

 

Out[34]:

'e'

 

In [35]:

min(t)

 

Out[35]:

'A'

 

In [36]:

t = ("A", "B", "C", "D", "E")

# "D"가 들어있는 위치 인덱스를 알려줍니다.
t.index("D")

 

Out[36]:

3

 

In [37]:

t = (1, 2, 3, 3, 3, 3, 3, 4, 5)

# 3이 몇 개 들어있는지를 알려줍니다.
t.count(3)

# [참고] set()은 같은 원소를 여러개 포함할 수 없습니다.

 

Out[37]:

5

 

 

range()는 for문과 함께 사용되는 경우가 많습니다.

 

In [38]:

l = []
for i in range(0, 11, 2):  # (start, stop, step)은 슬라이싱과 동일
    l.append(i)
l

 

Out[38]:

[0, 2, 4, 6, 8, 10]

 

 

이 포스팅은 쿠팡파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받을 수 있습니다.