7. Python 자료형 정리 : List, Tuple, Dictionary, Set, Sequence, Range

 

Python 자료형 정리 : List, Tuple, Dictionary, Set, Sequence, Range

목차

1. 리스트(List) : 순서 있는 변경 가능한 컬렉션

2. 튜플(Tuple) : 불변의 순서 있는 컬렉션

3. 딕셔너리(Dictionary) : 키-값 쌍의 저장소

4. 집합(Set) : 중복 없는 데이터 모음

5. List vs Tuple vs Set vs Dictionary 비교

6. 시퀀스(Sequence) : 순서가 있는 자료형의 공통 기반

7. range 객체로 숫자 시퀀스 만들기

8. del 키워드로 항목 제거하기

관련 글 링크

 

 

1. 리스트(List) : 순서 있는 변경 가능한 컬렉션

리스트는 여러 개의 값을 순서대로 저장할 수 있는 가변(mutable) 시퀀스 자료형입니다.
파이썬에서 가장 많이 쓰이는 기본 자료구조 중 하나로, 각 항목은 인덱스(index) 를 통해 접근하거나 수정할 수 있습니다.

fruits = ['apple', 'banana', 'cherry']
print(fruits[0])  # 출력: 'apple'

 

Python에서 인덱스는 0부터 시작하며, 음수 인덱스를 사용하면 뒤에서부터 접근할 수 있습니다.

print(fruits[-1])  # 출력: 'cherry'

 

▶ 리스트 생성 방법

# 기본 생성
a = [1, 2, 3]

# 문자열 리스트
names = ['Alice', 'Bob', 'Charlie']

# 혼합 자료형 리스트
mixed = [42, 'Python', True, 3.14]

# 빈 리스트
empty = []

# list() 함수를 이용한 변환
text = "hello"
char_list = list(text)
print(char_list)  # ['h', 'e', 'l', 'l', 'o']

 

▶ 리스트 항목 추가/삭제

numbers = [1, 2, 3]

numbers.append(4)         # 맨 끝에 추가
numbers.insert(1, 1.5)    # 인덱스 1에 삽입
numbers.extend([5, 6])    # 여러 개 항목 추가

print(numbers)  # [1, 1.5, 2, 3, 4, 5, 6]

items = ['a', 'b', 'c', 'd']

items.remove('b')   # 값으로 삭제
items.pop()         # 마지막 요소 제거
del items[0]        # 인덱스로 삭제

print(items)  # ['c']

• pop(index)로 특정 위치 항목 제거도 가능
• 존재하지 않는 항목을 remove() 하면 오류 발생

▶ 리스트 슬라이싱(부분 선택)

data = ['a', 'b', 'c', 'd', 'e']

print(data[1:4])   # ['b', 'c', 'd']
print(data[:3])    # ['a', 'b', 'c']
print(data[::2])   # ['a', 'c', 'e'] (간격 2)
print(data[::-1])  # ['e', 'd', 'c', 'b', 'a'] (역순)

 

▶ 리스트 정렬

nums = [3, 1, 4, 2]

nums.sort()  # 리스트 자체를 정렬 (in-place)
print(nums)  # [1, 2, 3, 4]

# 정렬된 새로운 리스트 반환
sorted_nums = sorted([5, 3, 1])
print(sorted_nums)  # [1, 3, 5]

• sort(reverse=True)로 내림차순 정렬 가능

▶ 리스트 유용한 메서드

colors = ['red', 'blue', 'green', 'blue']

print(colors.index('blue'))     # 1 (첫 번째 위치)
print(colors.count('blue'))     # 2 (등장 횟수)
colors.reverse()                # 리스트 뒤집기
colors.clear()                  # 모든 항목 제거

 

▶ 리스트 컴프리헨션(List Comprehension)

리스트 컴프리헨션은 기존 리스트나 반복 가능한(iterable) 객체를 기반으로 새로운 리스트를 한 줄로 생성하는 Python의 축약 문법입니다.
가독성이 뛰어나고, 반복문과 조건문을 간단하게 표현할 수 있어 매우 자주 사용됩니다.

# 일반적인 방식
squares = []
for i in range(5):
    squares.append(i * i)

# 리스트 컴프리헨션으로 간결하게
squares = [i * i for i in range(5)]

[표현식 for 항목 in 반복가능객체]

[표현식 for 항목 in 반복가능객체 if 조건식]

# 숫자 제곱 리스트 만들기
squares = [x**2 for x in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# 짝수만 필터링
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # [0, 2, 4, 6, 8]

# 문자열 리스트에서 소문자만 추출
words = ['Apple', 'banana', 'Cherry']
lowercase = [w for w in words if w.islower()]
print(lowercase)  # ['banana']

# 리스트 요소 변환 (문자열 길이 구하기)
names = ['Tom', 'Alice', 'Bob']
lengths = [len(name) for name in names]
print(lengths)  # [3, 5, 3]

# 중첩 for문 (2단 구구단)
gugu = [f"2 x {i} = {2*i}" for i in range(1, 10)]
print(gugu)

# 2차원 리스트 만들기
matrix = [[i * j for j in range(1, 4)] for i in range(1, 4)]
print(matrix)  # [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

# map을 이용한 방법
squares = list(map(lambda x: x**2, range(5)))

# filter를 이용한 방법
evens = list(filter(lambda x: x % 2 == 0, range(10)))

 

 

2. 튜플(Tuple) : 불변의 순서 있는 컬렉션

튜플은 불변(immutable) 시퀀스 자료형으로, 한 번 생성되면 내용을 변경할 수 없습니다.
속도가 빠르고 메모리 효율이 좋아 읽기 전용 데이터를 다룰 때 주로 사용되며, 리스트보다 안전한 자료 저장 방식으로 평가받습니다.

point = (3, 4)
print(point[1])  # 출력: 4

 

▶ 튜플 생성

# 일반 튜플
colors = ('red', 'green', 'blue')

# 혼합형 튜플
info = ('Alice', 30, True)

# 중첩 튜플
coords = ((1, 2), (3, 4))

# 빈 튜플
empty = ()

# 단일 요소 튜플 ← 꼭 쉼표 필요!
single = (42,)

# 괄호 없이도 가능
a = 1, 2, 3  # 자동으로 튜플로 인식됨
print(type(a))  # <class 'tuple'>

 

▶ 튜플의 불변성

튜플은 내용을 변경할 수 없습니다. 아래 코드는 오류를 발생시킵니다.

t = (1, 2, 3)
t[0] = 100  # TypeError: 'tuple' object does not support item assignment

# 단, 튜플 내부에 가변 객체가 있다면 그 객체 자체는 변경 가능
nested = (1, [2, 3])
nested[1][0] = 99
print(nested)  # (1, [99, 3])

 

▶ 튜플 접근 및 반복, 슬라이싱

튜플도 리스트처럼 인덱스를 사용해 접근 가능하며, 반복문도 사용할 수 있습니다.

t = ('a', 'b', 'c')

print(t[0])     # 'a'
print(t[-1])    # 'c'

for item in t:
    print(item)

# 슬라이싱도 리스트처럼 사용 가능
data = (10, 20, 30, 40, 50)

print(data[1:4])   # (20, 30, 40)
print(data[::-1])  # (50, 40, 30, 20, 10)

 

▶ 튜플과 함수

튜플은 여러 값을 한 번에 반환할 때 유용합니다.

def get_name_and_age():
    return 'Alice', 30

name, age = get_name_and_age()
print(name, age)  # Alice 30

함수의 다중 반환 → 내부적으로는 튜플로 처리됩니다.

 

▶ 활용예시

# 사전의 키로 사용 (리스트는 불가)
my_dict = {('x', 'y'): 100}
print(my_dict[('x', 'y')])  # 100

# for문에서 enumerate로 인덱스와 값 튜플 받기
fruits = ['apple', 'banana', 'cherry']
for i, fruit in enumerate(fruits):
    print(i, fruit)

 

 

3. 딕셔너리(Dictionary) : 키-값 쌍의 저장소

딕셔너리(dictionary)는 Python에서 데이터를 키(key)-값(value) 쌍으로 저장하는 비순차적 자료형입니다.
빠른 검색이 가능하며, 실세계의 매핑 구조(예: 이름 → 전화번호)를 표현할 때 매우 유용합니다.

person = {
    'name': 'Alice',
    'age': 30,
    'city': 'Seoul'
}
print(person['name'])  # Alice

 

▶ 딕셔너리 생성 방법

# 기본 생성
user = {'id': 'kim', 'level': 3}

# dict() 함수 사용
user2 = dict(id='lee', level=2)

# 키-값 리스트로부터 생성
pairs = [('a', 1), ('b', 2)]
d = dict(pairs)

# 빈 딕셔너리
empty = {}

• 키는 문자열, 숫자, 튜플(불변형) 가능 → 리스트는 ❌

▶ 딕셔너리 접근 및 추가/수정/삭제

person = {'name': 'Tom'}
person['age'] = 28  # 새 항목 추가
person['name'] = 'Jerry'  # 기존 항목 수정
# 존재하지 않는 키 접근 시 KeyError 발생

# 안전하게 접근: get()
print(person.get('job'))       # None
print(person.get('job', 'N/A'))  # N/A

# 삭제
# popitem()은 임의 또는 마지막 항목을 삭제하고 반환 (버전별 차이 있음)
del person['age']        # 특정 키 삭제
person.pop('name')       # 삭제하면서 반환
person.clear()           # 모든 항목 삭제

 

▶ 키/값/쌍 조회

data = {'x': 10, 'y': 20}

print(data.keys())      # dict_keys(['x', 'y'])
print(data.values())    # dict_values([10, 20])
print(data.items())     # dict_items([('x', 10), ('y', 20)])

# 반복문에서 자주 사용:
for key, value in data.items():
    print(f"{key}: {value}")

# 키 존재 여부 확인
if 'x' in data:
    print("x exists")

 

▶ 딕셔너리 컴프리헨션 (Dict Comprehension)

# 기본 구조
{key_expr: value_expr for item in iterable}

# 조건부 딕셔너리 컴프리헨션도 가능:
{key: value for item in iterable if 조건식}

# 숫자 → 제곱값 딕셔너리 만들기
squares = {x: x**2 for x in range(5)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 문자열 리스트 → 길이 딕셔너리
words = ['apple', 'banana', 'cherry']
lengths = {word: len(word) for word in words}
print(lengths)  # {'apple': 5, 'banana': 6, 'cherry': 6}

# 짝수만 포함하는 딕셔너리
evens = {x: x**2 for x in range(10) if x % 2 == 0}
print(evens)  # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

# 리스트에 인덱스 붙이기
names = ['Tom', 'Jerry', 'Spike']
indexed = {i: name for i, name in enumerate(names)}
print(indexed)  # {0: 'Tom', 1: 'Jerry', 2: 'Spike'}

#  zip()으로 두 리스트 병합
keys = ['id', 'name', 'age']
values = [101, 'Alice', 25]

user = {k: v for k, v in zip(keys, values)}
print(user)  # {'id': 101, 'name': 'Alice', 'age': 25}

 

 

4. 집합(Set) : 중복 없는 데이터 모음

집합(set)은 Python의 중복 없는 요소들의 모음을 표현하는 자료형입니다.
수학의 집합처럼 합집합, 교집합, 차집합 등의 연산을 지원하며, 중복 제거, 빠른 포함 검사 등에 자주 사용됩니다.

• 중복 자동 제거: 동일한 값은 한 번만 저장됩니다.
• 순서 없음: 요소의 저장 순서가 유지되지 않으며, 인덱스로 접근할 수 없습니다.
• 가변형(mutable): 생성 후에도 요소를 추가하거나 삭제할 수 있습니다.
• 다양한 자료형 변환 가능: 리스트, 튜플, 문자열 등 반복 가능한 객체를 set()으로 쉽게 변환할 수 있습니다.

unique_nums = {1, 2, 3, 2, 1}
print(unique_nums)  # {1, 2, 3}

 

▶ 집합(Set) 생성 방법

# 중괄호를 사용한 생성
fruits = {'apple', 'banana', 'cherry'}

# set() 함수로 생성 (특히 빈 집합은 반드시 이렇게!)
nums = set([1, 2, 3, 3])
chars = set('hello')  # {'h', 'e', 'l', 'o'}

# 빈 집합
empty = set()

• {}는 빈 딕셔너리입니다. → 빈 집합은 set()으로 만들어야 합니다.

▶ 요소 추가 및 삭제

• set 내부 요소는 직접 수정할 수 없습니다.
• set은 순서가 없기 때문에 인덱스로 접근하여 바꾸는 작업도 불가능합니다.

s = {1, 2, 3}

s.add(4)        # 하나 추가
s.update([5, 6])  # 여러 개 추가

s.remove(2)     # 요소 삭제 (존재하지 않으면 오류)
s.discard(10)   # 안전하게 삭제 (없어도 무시)
s.pop()         # 임의의 요소 제거

 

▶ 집합 연산 및 관계

종류	연산자	예제	결과
합집합	`	`	`A
교집합	&	A & B	A와 B에 모두 있는 값
차집합	-	A - B	A에만 있고 B엔 없는 값
대칭 차집합	^	A ^ B	A 또는 B만의 고유 값

A = {1, 2, 3}
B = {3, 4, 5}

print(A | B)  # {1, 2, 3, 4, 5}
print(A & B)  # {3}
print(A - B)  # {1, 2}
print(A ^ B)  # {1, 2, 4, 5}

A = {1, 2}
B = {1, 2, 3}

print(A.issubset(B))   # True (A ⊆ B)
print(B.issuperset(A)) # True (B ⊇ A)
print(A.isdisjoint({4, 5}))  # True (교집합 없음)

 

▶ 집합 활용 예제

# 리스트 중복 제거
data = [1, 2, 2, 3, 1]
unique = list(set(data))
print(unique)  # [1, 2, 3]

# 두 문자열의 공통 문자 구하기
a = set("apple")
b = set("grape")

print(a & b)  # {'p', 'e', 'a'}

# 유효하지 않은 단어 제거
stopwords = {'the', 'a', 'an'}
sentence = "this is a test".split()
filtered = [word for word in sentence if word not in stopwords]
print(filtered)  # ['this', 'is', 'test']

 

 

5. List vs Tuple vs Set vs Dictionary 비교

항목	List	Tuple	Set	Dictionary
기호	[]	()	{} 또는 set()	{key: value}
순서 유지	✅ 있음	✅ 있음	❌ 없음	✅ 있음 (3.7+부터)
중복 허용	✅ 허용	✅ 허용	❌ 중복 제거	✅ (키는 중복 불가, 값은 가능)
인덱싱/슬라이싱	✅ 가능	✅ 가능	❌ 불가능	❌ 키로 접근
가변성(Mutable)	✅ 가변형	❌ 불변형	✅ 가변형	✅ 가변형
요소 접근 방식	인덱스	인덱스	값 자체로 검색	키로 검색
사용 목적 예시	순차 데이터	고정된 데이터 묶음	중복 제거, 집합 연산	키-값 매핑 데이터 저장
메모리 사용량	중간	가장 적음	작음	중간 ~ 많음
반복 가능 여부	✅ 가능	✅ 가능	✅ 가능	✅ 가능 (items(), keys() 등)
변환 함수 예시	list(iterable)	tuple(iterable)	set(iterable)	dict(zip(keys, values))

 

 

6. 시퀀스(Sequence) : 순서가 있는 자료형의 공통 기반

시퀀스(Sequence)는 Python에서 순서가 있는 자료형의 공통 기반 개념입니다.
리스트(List), 튜플(Tuple), 문자열(String), range, 바이트(Byte) 등은 모두 시퀀스이며, 다음과 같은 공통 연산을 지원합니다.

 

▶ 시퀀스의 종류

자료형	예시
리스트	[10, 20, 30]
튜플	(1, 2, 3)
문자열	"hello"
range 객체	range(5)
바이트	b'ABC'

 

▶ 시퀀스 연산 정리

종류	예시	설명
인덱싱	s[0]	0번 요소 조회
슬라이싱	s[1:3]	1~2번 요소 추출
길이 확인	len(s)	요소 개수 반환
포함 여부	'a' in s	특정 값 포함 여부 확인
반복	for x in s	요소 순회
정렬	sorted(s)	새로운 정렬 리스트 반환
결합	s1 + s2	두 시퀀스 연결
반복 생성	s * n	시퀀스를 n번 반복
최소/최대값	min(s), max(s)	가장 작은/큰 값 반환

 

▶  반복 생성, 결합 연산 예시

연산자	자료형	기능	예시
+	리스트	두 리스트 연결	[1, 2] + [3] → [1, 2, 3]
+	문자열	문자열 이어붙이기	"A" + "B" → "AB"
*	튜플/리스트	시퀀스를 반복	('a',) * 3 → ('a', 'a', 'a')
*	문자열	문자열 반복	"ha" * 2 → "haha"

 

 

7. range 객체로 숫자 시퀀스 만들기

range는 Python에서 숫자의 연속된 시퀀스를 생성하는 내장 함수입니다.
보통 for 반복문과 함께 사용되며, 리스트보다 메모리를 적게 사용하는 지연 평가(lazy evaluation) 객체입니다.

range(stop)
range(start, stop)
range(start, stop, step)

# start	시작 숫자 (기본값: 0)
# stop	종료 숫자 (미포함)
# step	간격 (기본값: 1, 음수 가능)

1. 기본 사용법
for i in range(5):
    print(i, end=' ')
# 출력: 0 1 2 3 4

2. 간격 (step) 지정
for i in range(1, 10, 2):
    print(i, end=' ')
# 출력: 1 3 5 7 9

3. 역방향 반복 (step 음수)
for i in range(5, 0, -1):
    print(i, end=' ')
# 출력: 5 4 3 2 1

4. range를 리스트로 변환
numbers = list(range(5))
print(numbers)  # [0, 1, 2, 3, 4]

 

 

8. del 키워드로 항목 제거하기

del은 Python의 삭제 연산자(delete operator)입니다.
객체 자체나 리스트의 요소, 딕셔너리의 키, 변수 전체 등을 메모리에서 제거할 때 사용됩니다.

대상	예시	설명
변수	del x	변수 x 자체를 메모리에서 삭제합니다. 이후 x를 참조하면 NameError 발생
리스트 요소	del list[1]	리스트에서 인덱스 1에 해당하는 요소를 제거합니다.
슬라이스	del list[1:3]	리스트의 인덱스 1부터 2까지(3 미만) 구간의 요소들을 한꺼번에 삭제합니다.
딕셔너리 키	del dict['key']	지정한 키와 그에 해당하는 값을 딕셔너리에서 제거합니다.
전체 객체	del 객체명	변수 또는 데이터 객체 전체를 삭제합니다. 이후 참조하면 오류 발생

 

▶ del 객체 사용시 주의사항

• del은 단순히 참조를 끊는 것이며, 메모리 해제는 GC가 판단하여 실행합니다.
• 다중 참조된 객체는 모두 삭제되기 전까지 메모리에 남아 있습니다.

a = [1, 2, 3]
b = a  # b도 같은 리스트를 참조

del a  # a는 제거되지만...
print(b)  # 여전히 접근 가능 → [1, 2, 3]

• a와 b는 동일한 객체(리스트)를 참조하고 있음
• del a를 실행해도 b가 여전히 참조하고 있기 때문에, 객체는 메모리에 남아 있음

▶ del이 유리한 경우 (예외적 활용)

del은 일반적인 상황에서는 굳이 사용할 필요가 없으며,
특정 목적(메모리 최적화, 보안, 디버깅)이 있을 때만 신중하게 사용하는 것이 좋습니다.

상황	이유
대용량 데이터 즉시 해제	메모리 부담을 줄이기 위해 일부 데이터를 명시적으로 제거
민감 정보 제거	인증 토큰, 비밀번호 등을 의도적으로 메모리에서 제거
Jupyter/IPython에서 네임스페이스 정리	코드 재실행 시 변수 충돌 방지, 메모리 절약
동일 변수명 재사용	예전 값을 명확히 제거하고 새 용도로 사용하고 싶을 때
GC 튜닝이 필요한 경우	순환 참조가 있는 상황에서 gc.collect()와 함께 사용

 

 

---

 

 

관련 글 링크