[Python] 인프런 - 프로그래밍 시작하기 - 파이썬 입문 - Se04. 파이썬 자료형

목록

1. 개요
2. 본론
     2-1. 숫자형 (int, float)
     2-2. 문자형 (str)
     2-3. 리스트 (list)
     2-4. 튜플 (tuple)
     2-5. 딕셔너리 (dict)
     2-6. 집합 (set)
3. 요약

1. 개요

해당 포스팅은 인프런의 프로그래밍 시작하기 : 파이썬 입문 (Inflearn Original) 강의를 학습하고 정리한 포스팅이다.

이번 챕터에서는 파이썬이 지원하는 주요 자료형인 숫자형, 문자형, 리스트, 튜플, 딕셔너리, 집합에 대해 정리한다.

파이썬이 지원하는 자료형은 다음과 같다.

자료형	설명
int	정수
float	실수
complex	복소수
bool	불린
str	문자열 (시퀀스)
list	리스트 (시퀀스)
tuple	튜플 (시퀀스)
set	집합
dict	사전

2. 본론

2-1. 숫자형 (int, float)

정수(int) & 실수(float)

파이썬의 정수형은 크기 제한이 없다.

i = 77
i2 = -14
big_int = 777777777777777777999999999999999    # 큰 수도 그대로 지원

f = 0.9999
f2 = 3.141592
f4 = 3 / 9    # 0.3333...

숫자형 연산자

연산자	설명	예시
+	덧셈	3 + 4
-	뺄셈	10 - 3
*	곱셈	2 * 5
/	나눗셈	7 / 2 → 3.5
//	몫	7 // 2 → 3
%	나머지	7 % 2 → 1
**	거듭제곱	2 ** 3 → 8

형 변환

print(float(6))       # 6.0
print(int(3.9))       # 3 (소수점 버림)
print(int(True))      # 1
print(float(False))   # 0.0
print(complex(3))     # (3+0j)

수치 연산 함수

print(abs(-7))              # 7 (절대값)
x, y = divmod(100, 8)
print(x, y)                 # 12 4 (몫, 나머지)
print(pow(5, 3), 5 ** 3)    # 125 125

import math
print(math.ceil(5.1))       # 6 (올림)
print(math.pi)              # 3.141592653589793

2-2. 문자형 (str)

문자열 생성

str1 = "I am Python"
str2 = 'Python'
str3 = """How are you?"""    # 멀티라인 가능
str4 = '''Thank you!'''

print(len(str1))    # 11

이스케이프 문자

이스케이프	설명
\n	개행
\t	탭
\\	역슬래시 문자
\'	작은따옴표 문자
\"	큰따옴표 문자

print("I'm Boy")
print('I\'m Boy')
raw_s1 = r'D:\Python\test'    # Raw String: 이스케이프 무시
print(raw_s1)                  # D:\Python\test

문자열 연산

str_o1 = "Python"
str_o2 = "Apple!"

print(str_o1 * 3)           # PythonPythonPython
print(str_o1 + str_o2)      # PythonApple!
print('y' in str_o1)        # True
print('p' not in str_o2)    # True

문자열 함수

str_o1 = "Python"
str_o4 = "Seoul Daejeon Busan Jinju"

print(str_o1.capitalize())         # Python
print(str_o2.endswith("!"))        # True
print(str_o1.replace("thon", " Good"))  # Py Good
print(sorted(str_o1))              # ['P', 'h', 'n', 'o', 't', 'y']
print(str_o4.split(' '))           # ['Seoul', 'Daejeon', 'Busan', 'Jinju']

슬라이싱 (Slicing)

파이썬의 시퀀스 자료형은 슬라이싱을 지원한다. [시작:끝:스텝] 형태로 사용한다.

str_s1 = "Nice Python"

print(str_s1[0:3])      # Nic
print(str_s1[5:])       # Python
print(str_s1[::2])      # Nc yhn
print(str_s1[::-1])     # nohtyP eciN (역순)
print(str_s1[-5:])      # ython

아스키 코드

print(ord('z'))     # 122
print(chr(122))     # z

2-3. 리스트 (list)

리스트는 순서O, 중복O, 수정O, 삭제O 인 자료형이다.

선언

a = []
b = list()
c = [70, 75, 80, 85]
d = [1000, 10000, 'Ace', 'Base', 'Captine']
e = [1000, 10000, ['Ace', 'Base', 'Captine']]   # 중첩 리스트

인덱싱 & 슬라이싱

print(d[1])         # 10000
print(d[-1])        # Captine
print(e[-1][1])     # Base

print(d[0:3])       # [1000, 10000, 'Ace']

리스트 연산

c = [70, 75, 80, 85]
d = [1000, 10000, 'Ace']

print(c + d)        # 리스트 합치기
print(c * 3)        # 리스트 반복

수정 & 삭제

c = [70, 75, 80, 85]
c[0] = 4            # 수정
print(c)            # [4, 75, 80, 85]

c[1:2] = ['a', 'b', 'c']   # 슬라이스 범위 교체
del c[2]            # 인덱스로 삭제

리스트 함수

a = [5, 2, 3, 1, 4]

a.append(10)        # 끝에 추가
a.sort()            # 오름차순 정렬
a.reverse()         # 역순
a.insert(2, 7)      # 인덱스 2 위치에 7 삽입
a.remove(10)        # 값으로 삭제 (처음 발견된 것)
a.pop()             # 마지막 요소 꺼내기
a.extend([8, 9])    # 다른 리스트 합치기

print(a.index(3))   # 값의 인덱스 반환

삭제 방법 비교:

• remove(값) : 값으로 삭제
• pop() : 마지막 요소 삭제 후 반환
• del list[인덱스] : 인덱스로 삭제

2-4. 튜플 (tuple)

튜플은 순서O, 중복O, 수정X, 삭제X 인 자료형으로, 리스트와 달리 불변(immutable) 이다.

선언

a = ()
b = (1,)                                # 원소가 1개일 때 반드시 콤마 필요
c = (11, 12, 13, 14)
d = (100, 1000, 'Ace', 'Base', 'Captine')
e = (100, 1000, ('Ace', 'Base', 'Captine'))  # 중첩 튜플

인덱싱 & 슬라이싱

리스트와 동일하게 사용 가능하다.

print(d[1])         # 1000
print(d[-1])        # Captine
print(d[0:3])       # (100, 1000, 'Ace')

수정 불가

# d[0] = 1500    # TypeError 발생

팩킹 & 언팩킹 (Packing & Unpacking)

튜플의 가장 중요한 특징 중 하나다.

# 팩킹 : 여러 값을 하나의 튜플로
t = ('foo', 'bar', 'baz', 'qux')

# 언팩킹 : 튜플의 값을 각 변수에 분배
(x1, x2, x3, x4) = t
print(x1, x2, x3, x4)    # foo bar baz qux

# 괄호 없이도 동작
t2 = 1, 2, 3              # 팩킹
x1, x2, x3 = t2          # 언팩킹
x4, x5, x6 = 4, 5, 6

2-5. 딕셔너리 (dict)

딕셔너리는 순서X, 키 중복X, 수정O, 삭제O 인 자료형이다. JSON과 유사한 키-값 구조다.

선언

a = {'name': 'Kim', 'phone': '01033337777', 'birth': '870514'}

# dict() 함수로 선언
e = dict([('Name', 'Niceman'), ('City', 'Seoul'), ('Age', 33)])

f = dict(Name='Niceman', City='Seoul', Age=33)

값 접근

print(a['name'])         # Kim (키 없으면 KeyError 발생)
print(a.get('name1'))    # None (키 없으면 None 반환)

추가 & 수정 & 삭제

a['address'] = 'seoul'      # 추가
a['address'] = 'dj'         # 수정
a.update(birth='910904')    # update로 수정
a.update({'address': 'Busan'})

print(a.pop('name'))        # 키로 삭제 후 값 반환
print(f.popitem())          # 마지막 항목 삭제 후 반환

키, 값, 항목 조회

print(a.keys())             # dict_keys([...])
print(a.values())           # dict_values([...])
print(a.items())            # dict_items([...])

# 리스트로 변환 후 사용
print(list(a.keys()))
print(list(a.values()))

포함 여부 확인

print('birth' in a)             # True (키 기준)
print('Seoul' in d.values())    # True (값 기준)

2-6. 집합 (set)

집합은 순서X, 중복X 인 자료형이다.

선언

a = set()
b = set([1, 2, 3, 4])
c = {1, 4, 5, 6}
d = {42, 'foo', (1, 2, 3), 3.14159}    # 다양한 타입 혼용 가능

# 중복 자동 제거
e = {'foo', 'bar', 'baz', 'foo', 'qux'}    # 'foo' 중복 제거됨

집합 자료형 활용 (집합 연산)

s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6, 7, 8, 9])

# 교집합
print(s1 & s2)                  # {4, 5, 6}
print(s1.intersection(s2))      # {4, 5, 6}

# 합집합
print(s1 | s2)                  # {1, 2, 3, 4, 5, 6, 7, 8, 9}
print(s1.union(s2))

# 차집합
print(s1 - s2)                  # {1, 2, 3}
print(s1.difference(s2))

# 교집합 여부 확인 (중복 없으면 True)
print(s1.isdisjoint(s2))        # False (교집합 있음)

# 부분집합 여부
print(s1.issubset(s2))          # s1이 s2의 부분집합인가
print(s1.issuperset(s2))        # s1이 s2를 포함하는가

추가 & 제거

s1 = {1, 2, 3, 4}

s1.add(5)           # 원소 추가
print(s1)           # {1, 2, 3, 4, 5}

s1.remove(2)        # 삭제 (없으면 KeyError)
s1.discard(3)       # 삭제 (없어도 에러 없음)
s1.clear()          # 전체 삭제

타입 변환

b = set([1, 2, 3, 4])

t = tuple(b)    # set → tuple
l = list(b)     # set → list

3. 요약

자료형	순서	중복	수정	삭제	특징
list	O	O	O	O	범용 순서 있는 컬렉션
tuple	O	O	X	X	불변, 팩킹/언팩킹 지원
dict	X	키 중복X	O	O	키-값 쌍, JSON 유사
set	X	X	-	O	집합 연산 지원

• 리스트는 가장 범용적인 자료형으로, 수정/삭제가 자유롭다.
• 튜플은 불변이므로 데이터 보호가 필요할 때 사용하며, 언팩킹이 유용하다.
• 딕셔너리는 키-값 구조로, 키를 통한 빠른 접근이 가능하다. get()은 키가 없을 때 None을 반환해 안전하다.
• 집합은 중복 제거와 집합 연산(교집합, 합집합, 차집합)이 필요할 때 사용한다.