숫자형
숫자로 이루어진 자료형이다. 정수, 실수, 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 + 715>>> 0xFF # 16진수 FF = 15×16 + 15255>>> type(0o17), type(0xFF)(<class 'int'>, <class 'int'>)
엄밀히 말하면 8진수와 16진수는 따로 있는 자료형이 아니다. 적는 방법만 다를 뿐 결과는 똑같은 정수(int)다.
자주 쓰지는 않지만 쓰이는 곳이 있다.
파일 권한 (8진수)
리눅스·macOS의 파일 권한은 읽기(4), 쓰기(2), 실행(1)을 더한 숫자 세 자리로 나타낸다. 각 자리가 0~7이라 8진수와 딱 맞는다. 755는 "주인은 읽기·쓰기·실행(7), 나머지는 읽기·실행(5)"이라는 뜻이다.
import osos.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 / 23.5>>> 4 / 22.0
제곱 **
a ** b는 a의 b제곱이다.
>>> 2 ** 101024
나머지 %
나눗셈의 나머지를 반환한다. 나머지 연산 또는 모듈러(modulo) 연산이라고 부른다.
>>> 7 % 31
몫 //
나눗셈의 몫만 반환한다. 정수끼리 나누면 정수형이 나온다.
>>> 7 // 23
엄밀히 말하면 //는 "몫"이 아니라 "나눈 결과보다 작거나 같은 가장 큰 정수"(내림)를 돌려준다. 그래서 두 가지를 조심해야 한다.
- 실수가 끼면 결과도 실수형이다.
7.0 // 2는3.0이다. - 음수를 나누면 0 쪽이 아니라 더 작은 쪽으로 내린다.
-7 // 2는-3이 아니라-4다.
>>> 7.0 // 23.0>>> -7 // 2-4
복합 연산자
산술 연산과 대입을 합친 연산자다. 변수에 연산한 결과를 그대로 같은 변수에 다시 넣을 때 쓴다. a += 1은 a = a + 1과 같다.
>>> a = 1>>> a += 1 # a = a + 1>>> a2>>> a *= 3 # a = a * 3>>> a6
+=, -=, *=, /=, //=, %=, **=가 있다.
문자열 자료형
문자열 만들기
문자열을 만드는 방법이 4가지나 된다.
"Hello World"'Hello World'"""Hello World"""'''Hello World'''
문자열 안에 따옴표 넣기
문자열 안에 따옴표가 들어가면 문자열을 감싸는 따옴표와 구분해야 한다. 방법은 두 가지다.
- 안에 쓴 것과 다른 따옴표로 감싼다. 안에 작은따옴표가 있으면 큰따옴표로 감싸고, 반대도 마찬가지다.
- 역슬래시(
\)를 붙인다.\바로 뒤의 따옴표는 문자열을 감싸는 기호가 아니라 따옴표 문자 그 자체가 된다.
>>> "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 shortYou 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 | 실수 |
%o | 8진수 |
%x | 16진수 |
%% | % 문자 자체 |
포맷 코드가 들어간 문자열에서 % 문자를 그대로 쓰려면 %%로 적어야 한다.
>>> "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)...namephonebirth
쌍 추가, 수정, 삭제
없는 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 peyphone 010-9999-1234birth 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 aTrue>>> 'pey' in aFalse
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', '정보없음')'정보없음'
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 & s2 | s1.intersection(s2) | {4, 5, 6} |
| 합집합 | s1 | s2 | s1.union(s2) | {1, 2, 3, 4, 5, 6, 7, 8, 9} |
| 차집합 | s1 - s2 | s1.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()>>> sset()
빈 집합은 {}가 아니라 set()으로 표시된다. {}는 빈 딕셔너리이기 때문이다.
불 자료형
참(True)과 거짓(False)을 나타내는 자료형이다. 첫 글자는 대문자로 쓰고, 따옴표로 감싸지 않는다. "True"는 문자열이다.
>>> a = True>>> type(a)<class 'bool'>
비교 연산의 결과가 불 값이다.
>>> 1 == 1True>>> 2 < 1False
자료형의 참과 거짓
모든 자료형에는 참과 거짓이 있다. 비어 있거나 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()...4321
어떤 값이 참인지 거짓인지는 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 = 1SyntaxError: 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 bTrue>>> 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 bFalse
리스트의 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, 3ValueError: 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>>> a5>>> b3
이게 되는 이유는 대입문에서 오른쪽을 먼저 계산하기 때문이다.
- 오른쪽
b, a의 값5와3을 먼저 다 꺼내 둔다. - 꺼내 둔 값을 왼쪽
a,b에 차례로 넣는다.
넣기 전에 오른쪽 값을 이미 꺼내 두었으니 a가 먼저 바뀌어도 b에 넣을 값은 사라지지 않는다. 문법상으로 오른쪽 b, a는 튜플이지만, 실제로 실행할 때는 튜플을 만들지 않는다(아래 Callout 참고).