yoouyeon.dev

2 파이썬 프로그래밍의 기초, 자료형

43분점프 투 파이썬

숫자형

숫자로 이루어진 자료형이다. 정수, 실수, 8진수, 16진수가 모두 숫자형에 들어간다.

정수형

양의 정수, 음의 정수, 0이 정수형이다.

>>> a = 123
>>> a = -178
>>> a = 0

실수형

소수점이 있는 수가 실수형이다.

>>> a = 1.2
>>> a = -3.45

실수는 지수 표현 방식으로도 쓸 수 있다. e(또는 E)는 "× 10의 거듭제곱"이라는 뜻이다. 아주 크거나 아주 작은 수를 0을 길게 늘어놓지 않고 적을 수 있다.

>>> 4.24e10 # 4.24 × 10¹⁰
42400000000.0
>>> 4.24e-10 # 4.24 × 10⁻¹⁰
4.24e-10
>>> 1e3 # 1 × 10³
1000.0

e 뒤의 숫자만큼 소수점을 옮긴다고 보면 된다. 양수면 오른쪽, 음수면 왼쪽으로 옮긴다.

8진수와 16진수

같은 정수를 다른 진법으로 적는 방법이다. 8진수는 0o, 16진수는 0x로 시작한다.

>>> 0o17 # 8진수 17 = 1×8 + 7
15
>>> 0xFF # 16진수 FF = 15×16 + 15
255
>>> type(0o17), type(0xFF)
(<class 'int'>, <class 'int'>)

엄밀히 말하면 8진수와 16진수는 따로 있는 자료형이 아니다. 적는 방법만 다를 뿐 결과는 똑같은 정수(int)다.

자주 쓰지는 않지만 쓰이는 곳이 있다.

파일 권한 (8진수)

리눅스·macOS의 파일 권한은 읽기(4), 쓰기(2), 실행(1)을 더한 숫자 세 자리로 나타낸다. 각 자리가 0~7이라 8진수와 딱 맞는다. 755는 "주인은 읽기·쓰기·실행(7), 나머지는 읽기·실행(5)"이라는 뜻이다.

import os
os.chmod("hello.py", 0o755) # 터미널의 chmod 755 hello.py와 같다

0o를 빼고 755라고 쓰면 10진수 755로 읽혀서 전혀 다른 권한이 된다.

색상 코드 (16진수)

웹에서 쓰는 #FF8800 같은 색상 코드는 빨강·초록·파랑을 두 자리씩 16진수로 적은 것이다. 두 자리 한 쌍이 0~255를 나타낸다.

>>> r, g, b = 0xFF, 0x88, 0x00 # #FF8800
>>> r, g, b
(255, 136, 0)

숫자형 연산자

사칙 연산

+, -, *, /를 쓴다. /는 나누어떨어져도 결과가 항상 실수형이라는 점에 유의한다.

>>> 7 / 2
3.5
>>> 4 / 2
2.0

제곱 **

a ** b는 a의 b제곱이다.

>>> 2 ** 10
1024

나머지 %

나눗셈의 나머지를 반환한다. 나머지 연산 또는 모듈러(modulo) 연산이라고 부른다.

>>> 7 % 3
1

몫 //

나눗셈의 몫만 반환한다. 정수끼리 나누면 정수형이 나온다.

>>> 7 // 2
3

엄밀히 말하면 //는 "몫"이 아니라 "나눈 결과보다 작거나 같은 가장 큰 정수"(내림)를 돌려준다. 그래서 두 가지를 조심해야 한다.

  • 실수가 끼면 결과도 실수형이다. 7.0 // 2는 3.0이다.
  • 음수를 나누면 0 쪽이 아니라 더 작은 쪽으로 내린다. -7 // 2는 -3이 아니라 -4다.
>>> 7.0 // 2
3.0
>>> -7 // 2
-4

복합 연산자

산술 연산과 대입을 합친 연산자다. 변수에 연산한 결과를 그대로 같은 변수에 다시 넣을 때 쓴다. a += 1은 a = a + 1과 같다.

>>> a = 1
>>> a += 1 # a = a + 1
>>> a
2
>>> a *= 3 # a = a * 3
>>> a
6

+=, -=, *=, /=, //=, %=, **=가 있다.

문자열 자료형

문자열 만들기

문자열을 만드는 방법이 4가지나 된다.

"Hello World"
'Hello World'
"""Hello World"""
'''Hello World'''

문자열 안에 따옴표 넣기

문자열 안에 따옴표가 들어가면 문자열을 감싸는 따옴표와 구분해야 한다. 방법은 두 가지다.

  1. 안에 쓴 것과 다른 따옴표로 감싼다. 안에 작은따옴표가 있으면 큰따옴표로 감싸고, 반대도 마찬가지다.
  2. 역슬래시(\)를 붙인다. \ 바로 뒤의 따옴표는 문자열을 감싸는 기호가 아니라 따옴표 문자 그 자체가 된다.
>>> "Python's favorite" # 1. 다른 따옴표로 감싸기
"Python's favorite"
>>> 'Python\'s favorite' # 2. 역슬래시 쓰기
"Python's favorite"
>>> "\"Python is easy\" he says."
'"Python is easy" he says.'

\'처럼 역슬래시로 시작해 특별한 의미를 갖는 문자 조합을 이스케이프 코드라고 한다.

여러 줄 문자열

여러 줄짜리 문자열을 만들려면 문자열 안에 "줄바꿈"이 들어가야 한다. 이때 쓰는 이스케이프 코드가 줄바꿈 문자 \n이다.

>>> multiline = "Life is too short\nYou need python"
>>> print(multiline)
Life is too short
You need python

파이썬은 \n 없이도 여러 줄 문자열을 쓸 수 있게 해 준다. 따옴표 3개(""" 또는 ''')로 감싸면 눈에 보이는 줄바꿈이 그대로 \n으로 저장된다.

>>> multiline = """Life is too short
... You need python"""
>>> multiline
'Life is too short\nYou need python'

자주 쓰는 이스케이프 코드는 요런게 있다.

코드뜻
\n줄바꿈
\t탭
\\역슬래시 문자 자체
\', \"따옴표 문자 자체

따옴표 3개 블록은 주석이 아니다

1장에서 따옴표 3개 블록을 여러 줄 주석으로 쓴다고 정리했는데, 그 정체가 바로 이 여러 줄 문자열이다. 파이썬이 공식으로 인정하는 주석은 #뿐이다.

대화형 인터프리터(>>>)에 넣어 보면 차이가 드러난다. # 주석은 아무 반응이 없지만, 따옴표 3개 블록은 문자열 값으로 처리되어 그대로 출력된다.

>>> # 주석
>>> """
... 주석인 줄 알았는데
... """
'\n주석인 줄 알았는데\n'

파일로 실행할 때는 쓰이지 않는 문자열이라 아무 일도 일어나지 않을 뿐이다. 그래서 주석처럼 보였던 것이다.

문자열 연산

문자열은 더해서 연결할 수 있고, 곱해서 반복할 수 있다.

>>> "Python" + " is fun!"
'Python is fun!'
>>> "python" * 2
'pythonpython'

곱하기는 생각보다 쓸모가 많다. 출력 화면에 구분선을 그릴 때 편하다.

print("=" * 50)
print("My Program")
print("=" * 50)
==================================================
My Program
==================================================

문자열 길이

len 함수로 구한다. 공백 문자도 길이에 포함된다.

>>> len("Life is too short")
17

문자열 인덱싱과 슬라이싱

>>> a = "Life is too short, You need Python"

인덱싱

문자열의 문자 하나하나(공백 포함)에는 순번, 즉 인덱스가 있다. 인덱스는 0부터 시작한다. 0번이 첫 번째 문자다.

[]로 접근한다. a[3]은 a의 3번 인덱스, 그러니까 0, 1, 2, 3을 세어 네 번째 문자다.

>>> a[0]
'L'
>>> a[3]
'e'

음수 인덱스도 있다. -1이 끝에서 첫 번째다.

>>> a[-1]
'n'
>>> a[-2]
'o'

끝에서 첫 번째가 -0이 아니라 -1인 이유는 파이썬에서 -0과 0이 같은 값이기 때문이다. a[-0]은 a[0]과 같아서 첫 문자가 나온다.

슬라이싱

a[시작:끝]으로 범위를 잘라낸다. 시작은 포함하고 끝은 포함하지 않는다.

>>> a[0:4] # 0, 1, 2, 3번
'Life'

시작을 생략하면 처음부터, 끝을 생략하면 마지막까지 자른다. 음수 인덱스도 쓸 수 있다.

>>> a[:17]
'Life is too short'
>>> a[19:]
'You need Python'
>>> a[19:-7]
'You need'

인덱싱과 슬라이싱은 문자열뿐 아니라 리스트, 튜플처럼 순서가 있는 자료형에서 똑같이 쓴다.

문자열은 바꿀 수 없다

파이썬의 문자열은 **변경 불가능(immutable)**한 값이다. 한 글자만 골라 바꿀 수 없다.

>>> a = "Pithon"
>>> a[1] = "y"
TypeError: 'str' object does not support item assignment

수정하려면 새 문자열을 만들어야 한다.

>>> a = a[:1] + "y" + a[2:] # 슬라이싱으로 잘라 붙이기
>>> a
'Python'

문자열 포매팅

문자열 안에 어떤 값을 삽입하는 방법이다.

포맷 코드 (% 방식)

문자열 안에 포맷 코드(%d, %s 등)를 넣고 문자열 뒤에 % 기호와 삽입할 값을 쓰면 그 자리에 값이 쏙 들어간다.

>>> "I eat %d apples." % 3
'I eat 3 apples.'

값을 2개 이상 넣으려면 포맷 코드를 여러 개 넣고 % 뒤에 순서대로 괄호로 묶어 넣는다.

>>> "I ate %d apples. so I was sick for %s days." % (10, "three")
'I ate 10 apples. so I was sick for three days.'
코드뜻
%s문자열 (어떤 값이든 문자열로 바꿔 넣는다)
%c문자 1개
%d정수
%f실수
%o8진수
%x16진수
%%% 문자 자체

포맷 코드가 들어간 문자열에서 % 문자를 그대로 쓰려면 %%로 적어야 한다.

>>> "Error is %d%%." % 98
'Error is 98%.'

정렬과 소수점

포맷 코드 앞에 숫자를 넣으면 그 길이만큼 공간을 마련하고 값을 오른쪽 끝에 넣는다. 음수를 넣으면 왼쪽에 넣는다.

>>> "%10s|" % "hi"
' hi|'
>>> "%-10s|" % "hi"
'hi |'

%f 앞에 0.4처럼 소수점을 붙이면 소수점 아래 그 자릿수까지 표현한다. 앞의 0은 생략해서 %.4f로 써도 된다.

>>> "%0.4f" % 3.42134234
'3.4213'

둘을 합치면 %10.4f가 된다. 점 앞의 숫자는 전체 길이, 점 뒤의 숫자는 소수점 아래 자릿수다.

>>> "%10.4f" % 3.42134234
' 3.4213'

전체 길이 10에는 정수부뿐 아니라 소수점(.)과 소수부까지 모두 들어간다. 3.4213이 6칸이라 앞에 공백 4칸이 붙었다.

format 함수

{} 자리에 format으로 넘긴 값이 들어간다. 인덱스로 넣을 수도 있고,

>>> number = 10
>>> day = "three"
>>> "I ate {0} apples. so I was sick for {1} days.".format(number, day)
'I ate 10 apples. so I was sick for three days.'

이름으로 넣을 수도 있다.

>>> "I ate {number} apples. so I was sick for {day} days.".format(number=10, day=3)
'I ate 10 apples. so I was sick for 3 days.'

둘을 섞어 써도 된다.

>>> "I ate {0} apples. so I was sick for {day} days.".format(10, day=3)
'I ate 10 apples. so I was sick for 3 days.'

정렬은 : 뒤에 화살표 방향으로 쓴다. <는 왼쪽, >는 오른쪽, ^는 가운데다. 정렬 기호 앞에 문자를 하나 두면 공백 대신 그 문자로 채운다.

>>> "{0:<10}".format("hi")
'hi '
>>> "{0:>10}".format("hi")
' hi'
>>> "{0:^10}".format("hi")
' hi '
>>> "{0:=^10}".format("hi")
'====hi===='

% 방식에는 가운데 정렬이 없고, 채우기도 %05d처럼 0으로 채우는 것만 된다.

소수점은 % 방식과 같다. f를 꼭 붙여야 한다.

>>> "{0:0.4f}".format(3.42134234)
'3.4213'
>>> "{0:10.4f}".format(3.42134234)
' 3.4213'

{, } 문자 자체를 쓰려면 {{, }}처럼 겹쳐 쓴다.

>>> "{{ and }}".format()
'{ and }'

f 문자열

format 함수와 비슷하다. 문자열 앞에 f를 붙이고 함수를 호출하는 대신 중괄호 안에 값을 바로 넣는다. 파이썬 3.6부터 쓸 수 있다.

>>> name = "홍길동"
>>> age = 30
>>> f"나의 이름은 {name}입니다. 나이는 {age}입니다."
'나의 이름은 홍길동입니다. 나이는 30입니다.'

중괄호 안에 표현식도 넣을 수 있다.

>>> f"나는 내년이면 {age + 1}살이 된다."
'나는 내년이면 31살이 된다.'

format 함수도 .format(age + 1)처럼 인자 자리에서는 계산할 수 있다. 다만 중괄호 안에 식을 쓰는 건 f 문자열만 된다. "{age + 1}".format(age=30)은 age + 1이라는 이름의 값을 찾다가 KeyError를 낸다.

정렬, 채우기, 소수점은 format 함수와 문법이 같다.

>>> f"{'hi':=^10}"
'====hi===='
>>> f"{3.42134234:0.4f}"
'3.4213'

,를 넣으면 천 단위마다 콤마를 찍어 준다.

>>> f"{1500000:,}"
'1,500,000'
>>> f"{1234567.891:,.2f}"
'1,234,567.89'

: 뒤에 쓰는 이 서식들은 포맷 명세 미니 언어라는 약속된 문법이다. 그래서 f 문자열과 format 함수에서 똑같이 쓸 수 있다("{0:,}".format(1500000)).

문자열 관련 함수

문자열.함수()처럼 값 뒤에 점을 찍어 부르는 함수를 정확히는 메서드라고 한다.

문자열은 바꿀 수 없는 값이라, 이 함수들은 원본을 바꾸지 않고 새 문자열을 돌려준다. 결과를 쓰려면 다시 대입해야 한다.

>>> a = "hi"
>>> a.upper()
'HI'
>>> a
'hi'
>>> a = a.upper()
>>> a
'HI'

count

문자 개수를 센다.

>>> "hobby".count("b")
2

find, index

찾는 문자열이 처음 나온 위치를 돌려준다. 없을 때 find는 -1을 돌려주고, index는 에러를 낸다.

>>> a = "Python is the best choice"
>>> a.find("b")
14
>>> a.find("k")
-1
>>> a.index("k")
ValueError: substring not found

join

문자열 사이사이에 끼워 넣는다. 리스트를 하나의 문자열로 합칠 때 많이 쓴다.

>>> ",".join("abcd")
'a,b,c,d'
>>> ",".join(["a", "b", "c", "d"])
'a,b,c,d'

upper, lower

대문자, 소문자로 바꾼다.

>>> "hi".upper()
'HI'
>>> "HI".lower()
'hi'

lstrip, rstrip, strip

공백을 지운다. lstrip은 왼쪽, rstrip은 오른쪽, strip은 양쪽이다.

>>> a = " hi "
>>> a.lstrip()
'hi '
>>> a.rstrip()
' hi'
>>> a.strip()
'hi'

replace

replace(바뀔 문자열, 바꿀 문자열)로 바꾼다.

>>> "Life is too short".replace("Life", "Your leg")
'Your leg is too short'

split

문자열을 나눠 리스트로 돌려준다. 인자를 비우면 공백(스페이스, 탭, 줄바꿈)을 기준으로 나눈다.

>>> "Life is too short".split()
['Life', 'is', 'too', 'short']
>>> "a:b:c:d".split(":")
['a', 'b', 'c', 'd']

isalpha, isdigit

알파벳으로만, 숫자로만 이루어졌는지 확인한다.

>>> "Python".isalpha()
True
>>> "Python3".isalpha()
False
>>> "123".isdigit()
True

startswith, endswith

특정 문자열로 시작하는지, 끝나는지 확인한다.

>>> "python.py".startswith("python")
True
>>> "python.py".endswith(".py")
True

리스트 자료형

리스트 만들기

리스트는 여러 값을 순서대로 담는 목록이다. 대괄호([])로 감싸고 값은 쉼표로 구분한다.

아무것도 없을 수도 있고, 숫자나 문자열만 들어갈 수도, 둘이 섞일 수도 있다. 리스트 안에 리스트가 들어가는 것까지, 어떤 자료형이든 담을 수 있다.

>>> a = [] # 빈 리스트. list()로도 만든다
>>> b = [1, 2, 3] # 숫자
>>> c = ['Life', 'is', 'too', 'short'] # 문자열
>>> d = [1, 2, 'Life', 'is'] # 섞어서
>>> e = [1, 2, ['Life', 'is']] # 리스트 안에 리스트

리스트 인덱싱과 슬라이싱

문자열과 똑같다.

>>> a = [1, 2, 3, ['a', 'b', 'c']]
>>> a[0]
1
>>> a[-1]
['a', 'b', 'c']
>>> a[0:2]
[1, 2]

리스트 안의 리스트는 []를 이어 붙여 꺼낸다. 2차원 배열과 같다.

>>> a[3][1]
'b'
>>> a[-1][:2]
['a', 'b']

리스트 연산

문자열과 똑같다. +로 더하고, *로 반복하고, len으로 길이를 구한다.

>>> a = [1, 2, 3]
>>> a + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> a * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> len(a)
3

문자열과 리스트는 섞어 연산할 수 없다

비슷해 보여도 다른 자료형이라 서로 더할 수 없다. 리스트 안의 값과 문자열을 더할 때도 마찬가지다.

>>> a + "hi"
TypeError: can only concatenate list (not "str") to list
>>> a[2] + "hi"
TypeError: unsupported operand type(s) for +: 'int' and 'str'

같은 자료형으로 바꿔서 연산해야 한다.

>>> str(a[2]) + "hi" # 정수 → 문자열
'3hi'

문자열과 리스트를 서로 바꾸는 방법은 이렇다.

>>> list("abc") # 문자열 → 리스트 (한 글자씩)
['a', 'b', 'c']
>>> "a b c".split() # 문자열 → 리스트 (기준 문자로 나눠서)
['a', 'b', 'c']
>>> "".join(['a', 'b', 'c']) # 리스트 → 문자열 (이어 붙여서)
'abc'

리스트를 str()에 넣으면 '[1, 2, 3]'처럼 대괄호까지 통째로 문자열이 된다. 요소만 이어 붙이려면 join을 쓴다. join은 문자열 요소만 받으므로 숫자 리스트는 "".join(map(str, a))처럼 각 요소를 문자열로 바꾼 뒤 합친다.

리스트 수정과 삭제

문자열과 달리 리스트는 값을 수정할 수 있다.

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

삭제도 된다. del로 지우면 원본 리스트에서 실제로 사라진다. 슬라이싱을 넣으면 범위째 지운다.

>>> a = [1, 2, 3]
>>> del a[1]
>>> a
[1, 3]
>>> a = [1, 2, 3, 4, 5]
>>> del a[2:]
>>> a
[1, 2]

del은 함수가 아니다. 1장에서 본 def 같은 예약어라서 괄호 없이 del a[1]처럼 쓴다.

리스트 관련 함수

문자열 함수와 달리, 리스트 함수 대부분은 원본 리스트를 직접 바꾸고 아무것도 돌려주지 않는다(None). 그래서 b = a.sort()라고 쓰면 b는 None이 된다. 원본은 그대로 두고 정렬된 새 리스트가 필요하면 sorted(a)를 쓴다.

append

맨 뒤에 요소를 하나 추가한다. 리스트를 넣으면 리스트가 통째로 요소 하나가 된다.

>>> a = [1, 2, 3]
>>> a.append(4)
>>> a
[1, 2, 3, 4]
>>> a.append([5, 6])
>>> a
[1, 2, 3, 4, [5, 6]]

extend

리스트를 풀어서 이어 붙인다. a += [4, 5]와 같다.

>>> a = [1, 2, 3]
>>> a.extend([4, 5])
>>> a
[1, 2, 3, 4, 5]

insert

insert(위치, 값)으로 원하는 위치에 끼워 넣는다.

>>> a = [1, 2, 3]
>>> a.insert(0, 4)
>>> a
[4, 1, 2, 3]

remove, pop

요소를 지운다. remove는 값으로 찾아 처음 나온 하나만 지운다. pop은 위치로 꺼내면서 그 값을 돌려준다. 위치를 비우면 맨 뒤를 꺼낸다.

>>> a = [1, 2, 3, 1, 2, 3]
>>> a.remove(3)
>>> a
[1, 2, 1, 2, 3]
>>> a = [1, 2, 3]
>>> a.pop()
3
>>> a.pop(0)
1
>>> a
[2]

sort, reverse

sort는 정렬하고 reverse는 순서를 뒤집는다. reverse는 정렬 없이 지금 순서 그대로를 거꾸로 할 뿐이다.

>>> a = [1, 4, 3, 2]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.reverse()
>>> a
[4, 3, 2, 1]

index, count

index는 값의 위치를 찾고(없으면 에러), count는 값의 개수를 센다. 문자열의 같은 이름 함수와 같다.

>>> a = [1, 2, 3, 1]
>>> a.index(3)
2
>>> a.count(1)
2

튜플 자료형

튜플은 리스트와 거의 같지만 값을 바꿀 수 없다. 리스트는 [], 튜플은 ()로 감싼다.

튜플 만들기

>>> t1 = ()
>>> t2 = (1,) # 요소가 하나면 쉼표가 꼭 있어야 한다
>>> t3 = (1, 2, 3)
>>> t4 = 1, 2, 3 # 괄호를 생략해도 된다
>>> t5 = ('a', 'b', ('ab', 'cd'))

튜플을 만드는 건 사실 괄호가 아니라 쉼표다. 그래서 (1)은 그냥 괄호로 감싼 숫자 1이고, (1,)이어야 튜플이 된다.

>>> type((1))
<class 'int'>
>>> type((1,))
<class 'tuple'>

튜플은 바꿀 수 없다

요소를 지우거나 바꾸려고 하면 에러가 난다.

>>> t = (1, 2, 'a', 'b')
>>> del t[0]
TypeError: 'tuple' object doesn't support item deletion
>>> t[0] = 'c'
TypeError: 'tuple' object does not support item assignment

그래서 append, sort 같은 함수가 없고, 값을 바꾸지 않는 count와 index만 있다.

단, 튜플 안에 든 리스트는 리스트라서 바꿀 수 있다. 앞의 extend 예제에서 t[0].extend([3])가 됐던 이유다.

튜플 다루기

바꾸는 것만 빼면 리스트와 같다. 인덱싱, 슬라이싱, +, *, len 모두 된다. +와 *는 원래 튜플은 그대로 두고 새 튜플을 만든다.

>>> t = (1, 2, 'a', 'b')
>>> t[0]
1
>>> t[1:]
(2, 'a', 'b')
>>> t + (3, 4)
(1, 2, 'a', 'b', 3, 4)
>>> (3, 4) * 2
(3, 4, 3, 4)
>>> len(t)
4

튜플은 왜 쓸까

공식 FAQ는 리스트와 튜플이 비슷해 보여도 쓰임새가 다르다고 설명한다.

  • 리스트는 다른 언어의 배열에 가깝다. 같은 종류의 값을 개수 제한 없이 담고, 하나씩 처리한다. 예를 들어 폴더 안의 파일 이름 목록은 파일이 늘어도 다루는 방식이 같다.
  • 튜플은 C의 구조체(struct)에 가깝다. 서로 관련된 몇 개의 값을 한 덩어리로 묶는다. 예를 들어 좌표 (x, y)는 항상 두 값이 한 쌍이다.

바꿀 수 없다는 성질 덕분에 되는 일도 있다.

  • 딕셔너리의 키로 쓸 수 있다. 딕셔너리 키는 바뀌지 않는 값이어야 해서, 리스트는 안 되고 튜플은 된다.

    >>> cities = {(37.5, 127.0): "서울"}
    >>> {[37.5, 127.0]: "서울"}
    TypeError: cannot use 'list' as a dict key (unhashable type: 'list')
  • 실수로 바뀔 걱정이 없다. 프로그램 내내 그대로여야 하는 값을 담기 좋다.

튜플이 쓰이고 있었던 곳..!

  • 포매팅의 "%d %s" % (10, "three")에서 값을 묶은 괄호가 튜플이다.
  • 함수가 return 1, 2처럼 값을 여러 개 돌려주면 튜플로 묶여서 나온다. x, y = f()처럼 바로 풀어 받을 수 있다.
  • a, b = b, a로 두 변수를 맞바꾸는 것도 문법상으로는 튜플로 묶었다가 푸는 모양이다.

딕셔너리 자료형

딕셔너리란

Key와 그 Key에 해당하는 Value를 한 쌍으로 묶는 자료형이다. 중괄호로 감싸고 Key: Value를 쉼표로 구분한다.

{Key1: Value1, Key2: Value2, Key3: Value3, ...}
>>> dic = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}

원래는 순서가 보장되지 않았지만, 파이썬 3.7부터 넣은 순서가 유지된다.

리스트처럼 순회할 수 있다. 그냥 순회하면 Key가 하나씩 나온다.

>>> for k in dic:
... print(k)
...
name
phone
birth

쌍 추가, 수정, 삭제

없는 Key에 대입하면 추가되고, 있는 Key에 대입하면 그 Value가 바뀐다. 삭제는 del로 한다.

>>> a = {1: 'a'}
>>> a[2] = 'b' # 없는 Key → 추가
>>> a
{1: 'a', 2: 'b'}
>>> a[1] = 'c' # 있는 Key → 수정
>>> a
{1: 'c', 2: 'b'}
>>> del a[2] # 삭제
>>> a
{1: 'c'}

딕셔너리 사용하기

Key로 Value를 꺼낸다. 모양은 리스트의 인덱싱과 같지만, 딕셔너리 뒤의 [] 안에 들어가는 건 위치가 아니라 Key다.

>>> grade = {'pey': 10, 'julliet': 99}
>>> grade['pey']
10
>>> grade['julliet']
99

주의할 점

Key가 겹치면 하나만 남는다. 뒤에 쓴 값이 앞의 값을 덮어쓴다. Key로 Value를 찾는 구조라 같은 Key가 둘이면 어느 쪽을 줄지 정할 수 없기 때문이다.

>>> {1: 'a', 1: 'b'}
{1: 'b'}

Key에 리스트는 쓸 수 없다. Key는 바뀌지 않는 값이어야 해서 튜플은 되고 리스트는 안 된다. Value에는 아무 값이나 넣을 수 있다.

>>> {(1, 2): 'tuple'}
{(1, 2): 'tuple'}
>>> {[1, 2]: 'list'}
TypeError: cannot use 'list' as a dict key (unhashable type: 'list')

딕셔너리 관련 함수

>>> a = {'name': 'pey', 'phone': '010-9999-1234', 'birth': '1118'}

keys, values, items

keys는 Key만, values는 Value만, items는 (Key, Value) 튜플 쌍을 모아서 돌려준다.

>>> a.keys()
dict_keys(['name', 'phone', 'birth'])
>>> a.values()
dict_values(['pey', '010-9999-1234', '1118'])
>>> a.items()
dict_items([('name', 'pey'), ('phone', '010-9999-1234'), ('birth', '1118')])

반복문에서는 items로 Key와 Value를 한 번에 풀어 받는 경우가 많다.

>>> for k, v in a.items():
... print(k, v)
...
name pey
phone 010-9999-1234
birth 1118

dict_keys는 뷰 객체다

keys가 돌려주는 dict_keys는 리스트가 아니다. 딕셔너리의 Key를 복사한 게 아니라 원래 딕셔너리를 그대로 비춰 보는 뷰(view) 객체다. 그래서 딕셔너리가 바뀌면 뷰도 따라 바뀐다.

>>> d = {'name': 'pey', 'phone': '010'}
>>> k = d.keys()
>>> d['birth'] = '1118'
>>> k # 다시 부르지 않아도 바뀌어 있다
dict_keys(['name', 'phone', 'birth'])

순회, len, in은 되지만 인덱싱은 안 된다. 리스트가 필요하면 list()로 바꾼다. 이때는 그 순간의 복사본이라 더는 따라 바뀌지 않는다.

>>> k[0]
TypeError: 'dict_keys' object is not subscriptable
>>> list(k)
['name', 'phone', 'birth']

복사하지 않으니 딕셔너리가 커도 가볍다. 대부분은 순회만 하면 되므로 이걸로 충분하다. values의 dict_values, items의 dict_items도 원리가 같다.

dict_keys는 집합처럼 교집합(&) 같은 연산도 된다.

>>> k & {'name', 'x'}
{'name'}

get

Key로 Value를 얻는다. a['name']과 같지만, 없는 Key일 때 []는 에러를 내고 get은 None을 돌려준다. 두 번째 인자로 없을 때 쓸 기본값을 줄 수도 있다.

>>> a.get('name')
'pey'
>>> a['nokey']
KeyError: 'nokey'
>>> a.get('nokey')
>>> a.get('nokey', 'foo')
'foo'

a.get('nokey')는 None을 돌려주는데, 대화형 인터프리터는 None을 출력하지 않아서 아무것도 안 보인다.

in

Key가 있는지 확인한다. 함수가 아니라 연산자다. Value는 확인하지 않는다.

>>> 'name' in a
True
>>> 'pey' in a
False

pop

Key로 쌍을 꺼낸다. 딕셔너리에서 지우면서 Value를 돌려준다.

>>> a.pop('name')
'pey'
>>> a
{'phone': '010-9999-1234', 'birth': '1118'}

없는 Key를 꺼내면 에러가 난다. get처럼 두 번째 인자로 기본값을 주면 에러 대신 기본값을 돌려준다.

>>> a.pop('email')
KeyError: 'email'
>>> email = a.pop('email', '정보없음')
>>> email
'정보없음'

clear

모든 쌍을 지운다. 빈 딕셔너리 {}가 된다.

>>> a.clear()
>>> a
{}

집합 자료형

집합(set)은 수학의 집합처럼 값을 모아 두는 자료형이다.

집합 만들기

set() 안에 리스트나 문자열을 넣어 만든다. 중괄호로 바로 만들 수도 있다.

>>> set([1, 2, 3])
{1, 2, 3}
>>> set("Hello")
{'e', 'H', 'l', 'o'} # 순서는 실행할 때마다 다를 수 있다
>>> {1, 2, 3}
{1, 2, 3}

set("Hello")에서 l이 하나뿐인 건 집합이 중복을 허용하지 않기 때문이다. 순서가 뒤섞인 건 집합에 순서가 없기 때문이다. 둘 다 다음 절에서 다룬다.

집합의 특징

  • 중복이 없다. 같은 값은 하나만 남는다.
  • 순서가 없다. 그래서 인덱싱이 안 된다. 값을 꺼내려면 리스트나 튜플로 바꾼다.
>>> s = {1, 2, 3}
>>> s[0]
TypeError: 'set' object is not subscriptable
>>> list(s)[0]
1

중복이 없다는 성질 때문에 리스트의 중복을 없앨 때 많이 쓴다.

>>> a = [1, 2, 2, 3, 3, 3]
>>> list(set(a))
[1, 2, 3]

집합에는 순서가 없으므로, 이렇게 중복을 없애면 원래 리스트의 순서가 유지된다고 장담할 수 없다.

교집합, 합집합, 차집합

>>> s1 = {1, 2, 3, 4, 5, 6}
>>> s2 = {4, 5, 6, 7, 8, 9}

연산자로도 쓰고, 같은 일을 하는 함수도 있다.

연산연산자함수결과
교집합s1 & s2s1.intersection(s2){4, 5, 6}
합집합s1 | s2s1.union(s2){1, 2, 3, 4, 5, 6, 7, 8, 9}
차집합s1 - s2s1.difference(s2){1, 2, 3}

차집합은 순서에 따라 결과가 다르다. s2 - s1은 {7, 8, 9}다.

한쪽에만 있는 값을 모으는 대칭차집합 s1 ^ s2(symmetric_difference)도 있다. 결과는 {1, 2, 3, 7, 8, 9}다.

집합 관련 함수

add, update

add는 값 1개를, update는 여러 개를 추가한다.

>>> s = {1, 2, 3}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.update([5, 6])
>>> s
{1, 2, 3, 4, 5, 6}

add는 받은 값을 통째로 하나 넣고, update는 받은 값을 풀어서 하나씩 넣는다. 리스트의 append와 extend 관계와 같다. 그래서 같은 값을 넣어도 결과가 다르다.

>>> s = {1}
>>> s.add("abc")
>>> s
{1, 'abc'}
>>> s = {1}
>>> s.update("abc") # 문자열을 한 글자씩 풀어서 넣는다
>>> s
{1, 'a', 'b', 'c'} # 순서는 다를 수 있다

add에는 리스트를 넣을 수 없다. 집합의 값도 딕셔너리 Key처럼 바뀌지 않는 값이어야 하기 때문이다. 튜플은 된다.

>>> s.add([2, 3])
TypeError: cannot use 'list' as a set element (unhashable type: 'list')
>>> s.add((2, 3))

remove, discard

값을 지운다. 없는 값을 지우려 하면 remove는 에러를 내고, discard는 조용히 넘어간다.

>>> s = {1, 2, 3}
>>> s.remove(2)
>>> s
{1, 3}
>>> s.remove(99)
KeyError: 99
>>> s.discard(99)

clear

모든 값을 지운다.

>>> s.clear()
>>> s
set()

빈 집합은 {}가 아니라 set()으로 표시된다. {}는 빈 딕셔너리이기 때문이다.

불 자료형

참(True)과 거짓(False)을 나타내는 자료형이다. 첫 글자는 대문자로 쓰고, 따옴표로 감싸지 않는다. "True"는 문자열이다.

>>> a = True
>>> type(a)
<class 'bool'>

비교 연산의 결과가 불 값이다.

>>> 1 == 1
True
>>> 2 < 1
False

자료형의 참과 거짓

모든 자료형에는 참과 거짓이 있다. 비어 있거나 0이면 거짓, 그 외에는 참이다.

값참/거짓
"python", [1, 2, 3], (1, 2, 3), {'a': 1}, {1}, 1참
"", [], (), {}, set(), 0, 0.0, None거짓

그래서 조건문에 값을 바로 넣을 수 있다.

>>> a = [1, 2, 3, 4]
>>> while a: # a가 비어 있지 않은 동안
... a.pop()
...
4
3
2
1

어떤 값이 참인지 거짓인지는 bool 함수로 확인한다.

>>> bool("python")
True
>>> bool("")
False
>>> bool([])
False

논리 연산자

and, or, not을 쓴다.

>>> True and False # 둘 다 참이어야 참
False
>>> True or False # 하나만 참이어도 참
True
>>> not True # 반대로
False

변수

변수 만들기

변수 이름 = 값으로 만든다. Java나 C와 달리 자료형을 따로 선언하지 않는다. 대입한 값을 보고 파이썬이 알아서 판단한다.

>>> a = 1
>>> b = "python"
>>> c = [1, 2, 3]

변수 이름 규칙

반드시 지켜야 하는 규칙이라 어기면 에러가 난다.

  • 문자, 숫자, 밑줄(_)만 쓸 수 있다.
  • 숫자로 시작할 수 없다.
  • 예약어는 쓸 수 없다. 1장에서 본 def = 1이 에러였던 이유다.
  • 대소문자를 구분한다. A와 a는 다른 변수다.
>>> 1abc = 1
SyntaxError: invalid decimal literal

지키지 않아도 에러는 나지 않지만 권장하는 방식도 있다. 파이썬은 변수와 함수 이름을 snake_case로 쓴다. 소문자로 쓰고 단어 사이를 밑줄로 잇는 방식이다.

user_name = "pey" # 파이썬 스타일
userName = "pey" # camelCase. 동작은 하지만 파이썬답지 않다

JavaScript나 Java는 camelCase를 쓰는데 파이썬은 왜 다를까. 문법이 강제하는 게 아니라 파이썬 공식 스타일 가이드인 PEP 8이 그렇게 정했기 때문이다. 표준 라이브러리부터 이 규칙을 따르므로 대부분의 파이썬 코드가 같은 모양이다. 클래스 이름은 PascalCase로 쓴다(class UserName:).

변수는 이름표다

a = [1, 2, 3]은 a라는 상자에 리스트를 넣는 게 아니다. 메모리 어딘가에 [1, 2, 3]이라는 리스트가 만들어지고, a는 그 리스트를 가리키는 이름이 된다.

변수가 가리키는 대상이 무엇인지는 id 함수로 확인할 수 있다. id는 값마다 붙은 고유한 번호를 돌려준다. 보통 쓰는 CPython에서는 이 번호가 그 값의 메모리 주소다.

>>> a = [1, 2, 3]
>>> id(a)
4303029896 # 실행할 때마다 다르다

같은 대상을 가리키면 id가 같다. 생긴 게 같아도 따로 만든 값이면 id가 다르다.

>>> b = a # a가 가리키는 리스트를 b도 가리킨다
>>> c = [1, 2, 3] # 생긴 건 같지만 새로 만든 리스트
>>> id(a) == id(b)
True
>>> id(a) == id(c)
False

id를 직접 비교하는 대신 is 연산자를 쓴다. ==는 값이 같은지, is는 같은 대상인지를 본다.

>>> a is b
True
>>> a == c # 값은 같다
True
>>> a is c # 같은 대상은 아니다
False

리스트 복사

a와 다른 리스트를 만들려면 진짜로 복사해야 한다.

>>> a = [1, 2, 3]
>>> b = a[:] # 1. 슬라이싱으로 전체를 잘라 새 리스트를 만든다
>>> from copy import copy
>>> b = copy(a) # 2. copy 모듈
>>> b = a.copy() # 3. 리스트의 copy 함수
>>> a[1] = 4
>>> b
[1, 2, 3]
>>> a is b
False

리스트의 extend에서 본 "b = a였다면 += 뒤에 b도 바뀐다"도 같은 이유다.

변수를 만드는 여러 가지 방법

여러 변수에 한 번에 값을 넣을 수 있다.

>>> a, b = ('python', 'life')
>>> (a, b) = 'python', 'life'
>>> [a, b] = ['python', 'life']

셋은 모양만 다를 뿐 모두 같다. 오른쪽 값을 하나씩 풀어서 왼쪽 변수에 차례로 넣는다. 이걸 **언패킹(unpacking)**이라고 한다.

  • 오른쪽의 괄호는 생략해도 된다. 튜플은 괄호가 아니라 쉼표로 만들기 때문에 'python', 'life'도 튜플이다.
  • 왼쪽의 (), []도 생략해도 된다. 어떻게 써도 "변수 두 개에 차례로 넣는다"는 뜻이 같다.
  • 오른쪽은 튜플이 아니어도 된다. 리스트, 문자열처럼 순회할 수 있는 값이면 된다. 개수만 맞으면 된다.
>>> a, b = 'hi'
>>> a
'h'
>>> a, b = 1, 2, 3
ValueError: too many values to unpack (expected 2, got 3)

같은 값을 여러 변수에 넣을 수도 있다.

>>> a = b = 'python'

이때 a와 b는 같은 대상을 가리킨다. 문자열은 바꿀 수 없어서 문제가 없지만, a = b = []처럼 리스트를 넣으면 앞의 b = a와 같은 상황이 된다.

두 변수 맞바꾸기

임시 변수 없이 값을 맞바꿀 수 있다.

>>> a = 3
>>> b = 5
>>> a, b = b, a
>>> a
5
>>> b
3

이게 되는 이유는 대입문에서 오른쪽을 먼저 계산하기 때문이다.

  1. 오른쪽 b, a의 값 5와 3을 먼저 다 꺼내 둔다.
  2. 꺼내 둔 값을 왼쪽 a, b에 차례로 넣는다.

넣기 전에 오른쪽 값을 이미 꺼내 두었으니 a가 먼저 바뀌어도 b에 넣을 값은 사라지지 않는다. 문법상으로 오른쪽 b, a는 튜플이지만, 실제로 실행할 때는 튜플을 만들지 않는다(아래 Callout 참고).

end
유연@yoouyeon
frontend developer