[TIL] 파이썬 프로그래밍의 기초, 자료형

2-1. 숫자형

숫자형이란?

• 숫자형(Number)이란 숫자 형태로 이루어진 자료형
  • 정수, 실수, 8진수, 16진수

항목	사용 예
정수	123, -345, 0
실수	123.45, -1234.5, 3.4e10
8진수	0o34, 0o25
16진수	0x2A, 0xFF

숫자형은 어떻게 만들고 사용할까?

정수형(Integer)

• 정수를 뜻하는 자료형
  • 양의 정수, 음의 정수, 0

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

실수형(Floating-point)

• 소수점이 포함된 숫자를 뜻하는 자료형

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

• 위 방식은 일반적인 소수점 표현 방식

>>> a = 4.24E10
>>> a = 4.24e-10

• 위 방식은 컴퓨터식 지수 표현 방식
• 파이썬에서는 4.24e10 or 4.24E10처럼 표현
  • e와 E 둘 중 어느 것을 사용해도 무방
  • 4.24E10은 4.24∗10^10, 4.24e-10은 4.24∗10^−10을 의미

8진수(Octal)와 16진수(Hexadecimal)

• 8진수를 만들기 위해 0o or 0O(숫자 0 + 알파벳 o or O)로 시작

>>> a = 0o177

• 16진수를 만들기 위해 0x로 시작

>>> a = 0x8ff
>>> b = 0xABC

숫자형을 활용하기 위한 연산자

사칙연산

• 사칙연산(+, -, *, /)

>>> a = 3
>>> b = 4
>>> a + b
7
>>> a * b
12
>>> a / b
0.75

x의 y제곱을 나타내는 **연산자

• x ** y처럼 사용했을 때 x의 y제곱(x^y) 값을 돌려줌

>>> a = 3
>>> b = 4
>>> a ** b
81

나눗셈 후 나머지를 반환하는 %연산자

• %는 나눗셈의 나머지 값을 돌려주는 연산자

>>> 7 % 3
1
>>> 3 % 7
3

나눗셈 후 몫을 반환하는 //연산자

• /연산자를 사용하면 실수를 반환

>>> 7 / 41.75

• //연산자를 사용하면 정수를 반환

>>> 7 // 41

2-2. 문자열 자료형

문자열이란?

• 문자열(String) : 문자, 단어 등으로 구성된 문자들의 집합을 의미

"Life is too short, You need Python"
"a"
"123"

• 문자열 예문을 보면 모두 큰따옴표(" ")로 둘러싸여 있음
  • 따옴표로 둘러싸여 있으면 모두 문자열

문자열은 어떻게 만들고 사용할까?

• 큰따옴표(" ") 이 외에도 문자열을 만드는 방법은 3가지가 더 있음
  • 파이썬에서 문자열을 만드는 방법은 총 4가지

1. 큰따옴표(")로 양쪽 둘러싸기

"Hello World"

2. 작은따옴표(')로 양쪽 둘러싸기

'Python is fun'

3. 큰따옴표 3개를 연속(""")으로 써서 양쪽 둘러싸기

"""Life is too short, You need python"""

4. 작은따옴표 3개를 연속(''')으로 써서 양쪽 둘러싸기

'''Life is too short, You need python'''

• 파이썬이 문자열을 만드는 방법은 왜 4가지나 가지게 되었을까?

문자열 안에 작은따옴표나 큰따옴표를 포함시키고 싶을 때

• 문자열을 만들어 주는 주인공은 작은따옴표(')와 큰따옴표(")

1. 문자열에 작은따옴표 (') 포함시키기

Python's favorite food is perl

• 위 문자열을 food 변수에 저장하려고 할 때, 문자열 중 Python’s에 작은따옴표(‘)가 포함되어 있음
  • 이럴 때는 문자열을 큰따옴표(")로 둘러싸야 함

>>> food = "Python's favorite food is perl"

• 프롬프트에 food를 입력해서 결과를 확인
  • 변수에 저장된 문자열이 그대로 출력됨

>>> food
"Python's favorite food is perl"

• 다음과 같이 큰따옴표(")가 아닌 작은따옴표(')로 문자열을 둘러싼 후 다시 실행해보면 ‘Python’이 문자열로 인식되어 구문 오류(SyntaxError)가 발생함

>>> food = 'Python's favorite food is perl'  
  File "<stdin>", line 1    
    food = 'Python's favorite food is perl'                   
                  ^
SyntaxError: invalid syntax

2. 문자열에 큰따옴표 (") 포함시키기

"Python is very easy." he says.

• 위와 같이 큰따옴표(")가 포함된 문자열이라면 어떻게 해야 큰따옴표가 제대로 표현될까?
  • 문자열을 작은따옴표(')로 둘러싸면 됨

>>> say = '"Python is very easy." he says.'

• 작은따옴표(') 안에 사용된 큰따옴표(")는 문자열을 만드는 기호로 인식안됨

3. 백슬래시(\)를 사용해서 작은따옴표(')와 큰따옴표(")를 문자열에 포함시키기

>>> food = 'Python\'s favorite food is perl'
>>> say = "\"Python is very easy.\" he says."

• 작은따옴표(')나 큰따옴표(")를 문자열에 포함시키는 또 다른 방법은 백슬래시(\)를 사용하는 것
• 백슬래시(\)를 작은따옴표(')나 큰따옴표(") 앞에 삽입하면 백슬래시(\) 뒤의 작은따옴표(')나 큰따옴표(")는 문자열을 둘러싸는 기호의 의미가 아닌 문자 (‘), (“) 그 자체를 뜻함

여러 줄인 문자열을 변수에 대입하고 싶을 때

• 여러 줄의 문자열을 변수에 대입하려면 어떻게 처리해야 할까?

Life is too short
You need python

1. 줄을 바꾸기 위한 이스케이프 코드 \n 삽입하기

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

• 줄바꿈 문자 \n을 삽입하는 방법이 있지만 읽기에 불편하고 줄이 길어지는 단점이 있음

2. 연속된 작은따옴표 3개(''') 또는 큰따옴표 3개(""") 사용하기

• 위 1번의 단점을 극복하기 위해 파이썬에서는 다음과 같이 작은따옴표 3개(''') 또는 큰따옴표 3개(""")를 사용

작은따옴표 3개를 사용한 경우

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

큰따옴표 3개를 사용한 경우

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

• print(multiline)을 입력해서 어떻게 출력되는지 확인

>>> print(multiline)
Life is too short
You need python

• 문자열이 여러 줄인 경우 이스케이프 코드를 쓰는 것보다 따옴표를 연속해서 쓰는 것이 훨씬 깔끔함

이스케이프 코드란?

• 프로그래밍할 때 사용할 수 있도록 미리 정의해 둔 “문자 조합”
• 주로 출력물을 보기 좋게 정렬하는 용도로 사용

코드	설명
\n	문자열 안에서 줄을 바꿀 때 사용
\t	문자열 사이에 탭 간격을 줄 때 사용
\\	문자 \를 그대로 표현할 때 사용
\'	작은따옴표(')를 그대로 표현할 때 사용
\"	큰따옴표(")를 그대로 표현할 때 사용
\r	캐리지 리턴(줄 바꿈 문자, 현재 커서를 가장 앞으로 이동)
\f	폼 피드(줄 바꿈 문자, 현재 커서를 다음 줄로 이동)
\a	벨 소리(출력할 때 PC 스피커에서 ‘삑’ 소리가 난다)
\b	백 스페이스
\000	널 문자

• 이중에서 활용빈도가 높은 것은 \n, \t, \\, \', \"
  • 나머지는 프로그램에서 잘 사용하지 않음

문자열 연산하기

• 파이썬에서는 문자열을 더하거나 곱할 수 있음

문자열 더해서 연결하기(Concatenation)

>>> head = "Python"
>>> tail = " is fun!"
>>> head + tail
'Python is fun!'

• “Python”이라는 head 변수와 “ is fun!”이라는 tail 변수를 더한 결과는 ‘Python is fun!’
  • 즉 head와 tail 변수가 +에 의해 합쳐진 것

문자열 곱하기

>>> a = "python"
>>> a * 2
'pythonpython'

• 위 소스 코드에서 a * 2 문장은 a를 두 번 반복하라는 뜻
  • 즉 *는 문자열의 반복을 뜻하는 의미로 사용함

문자열 곱하기 응용

# multistring.py

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

• 입력한 소스는 C:\doit 디렉터리에 파일 이름 multistring.py로 저장

명령 프롬프트로 프로그램을 실행시킨 결과

C:\Users>cd C:\doit
C:\doit>python multistring.py
==================================================
My Program
==================================================

• 이런 식의 표현은 앞으로 자주 사용하게됨
  • 프로그램을 만들어 실행시켰을 때 출력되는 화면 제일 위쪽에 프로그램 제목을 이와 같이 표시하면 보기 좋음

문자열 길이 구하기

• 문자열의 길이는 len() 함수를 사용하면 구할 수 있음
• len() 함수는 print 함수처럼 파이썬의 기본 내장 함수로 별다른 설정 없이 바로 사용할 수 있음

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

문자열 인덱싱과 슬라이싱

• 인덱싱(Indexing) : “가리킨다”를 의미함
• 슬라이싱(Slicing) : “잘라낸다”를 의미함

문자열 인덱싱이란?

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

• 변수 a에 저장한 문자열의 각 문자마다 번호를 매겨 보면 다음과 같음

Life is too short, You need Python
0         1         2         3 
0123456789012345678901234567890123

• “Life is too short, You need Python” 문자열에서 L은 첫 번째 자리를 뜻하는 숫자 0, 바로 다음인 i는 1 이런 식으로 계속 번호를 붙인 것
  • 중간에 있는 short의 s는 12

>>> a = "Life is too short, You need Python"
>>> a[3]
'e'

• a[3]이 뜻하는 것은 a라는 문자열의 네 번째 문자 e를 말함

“파이썬은 0부터 숫자를 센다”

a[0]:'L', a[1]:'i', a[2]:'f', a[3]:'e', a[4]:' ', ...

• a[번호]는 문자열 안의 특정한 값을 뽑아내는 역할
  • 이러한 작업을 인덱싱이라고 함

문자열인덱싱 활용하기

>>> a = "Life is too short, You need Python"
>>> a[0]
'L'
>>> a[12]
's'
>>> a[-1]
'n'

• a[-1]은 문자열을 뒤에서부터 읽기 위해 마이너스(-) 기호를 붙이는 것
  • 즉 a[-1]은 뒤에서부터 세어 첫 번째가 되는 문자를 말함
• a의 값은 “Life is too short, You need Python” 문자열이므로 뒤에서부터 첫 번째 문자는 가장 마지막 문자 ‘n’
• 0과 -0은 똑같은 것이기 때문에 a[-0]은 a[0]과 똑같은 값

>>> a[-0]
'L'
>>> a[-2]
'o'
>>> a[-5]
'y'

문자열 슬라이싱이란?

• “Life is too short, You need Python” 문자열에서 단순히 한 문자만을 뽑아내는 것이 아니라 ‘Life’ 또는 ‘You’ 같은 단어를 뽑아내는 방법은 없을까?

>>> a = "Life is too short, You need Python"
>>> b = a[0] + a[1] + a[2] + a[3]
>>> b
'Life'

• 위 방법처럼 단순하게 접근할 수도 있지만 파이썬에서는 더 좋은 방법인 슬라이싱(Slicing) 기법이 있음

>>> a = "Life is too short, You need Python"
>>> a[0:4]
'Life'

• a[0:4]가 뜻하는 것은 a 문자열, 즉 “Life is too short, You need Python” 문장에서 자리 번호 0부터 4까지의 문자를 뽑아낸다는 뜻
• 슬라이싱 기법으로 a[시작 번호:끝 번호]를 지정할 때 끝 번호에 해당하는 것은 포함하지 않음

시작 번호 <= a < 끝 번호

문자열을 슬라이싱하는 방법

>>> a[0:5]
'Life '

• 위 예는 a[0] + a[1] + a[2] + a[3] + a[4]와 동일

• a[4]는 공백 문자이기 때문에 ‘Life’가 아닌 ‘Life ‘가 출력됨

  • 공백 문자 역시 L, i, f, e 같은 문자와 동일하게 취급함

  • ‘Life’와 ‘Life ‘는 완전히 다른 문자열

• 슬라이싱할 때 항상 시작 번호가 0일 필요는 없음

>>> a[0:2]
'Li'
>>> a[5:7]
'is'
>>> a[12:17]
'short'

• a[시작 번호:끝 번호]에서 끝 번호 부분을 생략하면 시작 번호부터 그 문자열의 끝까지 뽑아냄

>>> a[19:]
'You need Python'

• a[시작 번호:끝 번호]에서 시작 번호를 생략하면 문자열의 처음부터 끝 번호까지 뽑아냄

>>> a[:17]
'Life is too short'

a[시작 번호:끝 번호]에서 시작 번호와 끝 번호를 생략하면 문자열의 처음부터 끝까지를 뽑아냄

>>> a[:]
'Life is too short, You need Python'

• 슬라이싱에서도 인덱싱과 마찬가지로 마이너스(-) 기호를 사용할 수 있음

>>> a[19:-7]
'You need'

• 위 코드에서 a[19:-7]이 뜻하는 것은 a[19]에서부터 a[-8]까지를 말함
  • a[-7]은 포함하지 않음

슬라이싱으로 문자열 나누기

• 자주 사용하게 되는 슬라이싱 기법 중 하나

>>> a = "20010331Rainy"
>>> date = a[:8]
>>> weather = a[8:]
>>> date
'20010331'
>>> weather
'Rainy'

• 위 문자열 “20010331Rainy”를 연도 2001, 월과 일을 나타내는 0331, 날씨를 나타내는 Rainy의 세 부분으로 나눈 코드

>>> a = "20010331Rainy"
>>> year = a[:4]
>>> day = a[4:8]
>>> weather = a[8:]
>>> year
'2001'
>>> day
'0331'
>>> weather
'Rainy'

• 인덱싱과 슬라이싱은 프로그래밍을 할때 매우 자주 사용하는 기법이니 꼭 반복해서 연습!!

“Pithon”이라는 문자열을 “Python”으로 바꾸려면?

>>> a = "Pithon"
>>> a[1]
'i'
>>> a[1] = 'y'

• a 변수에 “Pithon” 문자열을 대입하고 a[1]의 값이 i니까 a[1]을 y로 바꾸어 준다 -> 오류 발생
  • 문자열의 요솟값은 바꿀 수 있는 값이 아니기 때문
  • 문자열 자료형은 그 요솟값을 변경할 수 없음, immutable한 자료형
• 슬라이싱 기법을 사용하면 Pithon 문자열을 사용해 Python 문자열을 만들 수 있음

>>> a = "Pithon"
>>> a[:1]
'P'
>>> a[2:]
'thon'
>>> a[:1] + 'y' + a[2:]
'Python'

문자열 포매팅

"현재 온도는 18도입니다""현재 온도는 20도입니다"

• 문자열 안의 특정한 값을 바꿔야 할 경우가 있을 때 이것을 가능하게 해주는 것이 바로 문자열 포매팅 기법

문자열 포매팅 따라 하기

1. 숫자 바로 대입

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

• 문자열 안에서 숫자를 넣고 싶은 자리에 %d 문자를 넣어 주고, 삽입할 숫자 3은 가장 뒤에 있는 % 문자 다음에 써 넣었음
  • %d는 문자열 포맷 코드라고 부름

2. 문자열 바로 대입

>>> "I eat %s apples." % "five"
'I eat five apples.'

• 숫자를 넣기 위해서는 %d를 써야 하고, 문자열을 넣기 위해서는 %s를 써야 함

문자열을 대입할 때는 앞에서 배운 것처럼 큰따옴표나 작은따옴표를 반드시 써주어야 함

3. 숫자 값을 나타내는 변수로 대입

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

• 1번처럼 숫자를 바로 대입하나 숫자 값을 나타내는 변수를 대입하나 결과는 같음

4. 2개 이상의 값 넣기

>>> number = 10
>>> day = "three"
>>> "I ate %d apples. so I was sick for %s days." % (number, day)
'I ate 10 apples. so I was sick for three days.'

• 2개 이상의 값을 넣으려면 마지막 % 다음 괄호 안에 콤마(,)로 구분하여 각각의 값을 넣어 주면 됨

문자열 포맷 코드

코드	설명
%s	문자열(String)
%c	문자 1개(character)
%d	정수(Integer)
%f	부동소수(floating-point)
%o	8진수
%x	16진수
%%	Literal % (문자 % 자체)

• %s 포맷 코드는 어떤 형태의 값이든 변환해 넣을 수 있음

>>> "I have %s apples" % 3
'I have 3 apples'
>>> "rate is %s" % 3.234
'rate is 3.234'

• 3을 문자열 안에 삽입하려면 %d를 사용하고, 3.234를 삽입하려면 %f를 사용해야 함 하지만 %s를 사용하면 이런 것을 생각하지 않아도 됨
  • 왜냐하면 %s는 자동으로 % 뒤에 있는 값을 문자열로 바꿈

포매팅 연산자 %d와 %를 같이 쓸 때는 %%를 쓴다

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

• 위 예문의 결괏값으로 “Error is 98%.”가 출력될 것이라고 예상하겠지만 파이썬은 값이 올바르지 않다는 값 오류(Value Error) 메시지를 보여 줌

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: incomplete format

• 이유는 문자열 포맷 코드인 %d와 %가 같은 문자열 안에 존재하는 경우, %를 나타내려면 반드시 %%로 써야 함

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

포맷 코드와 숫자 함께 사용하기

1. 정렬과 공백

>>> "%10s" % "hi"
'        hi'

• %10s는 전체 길이가 10개인 문자열 공간에서 대입되는 값을 오른쪽으로 정렬하고 그 앞의 나머지는 공백으로 남겨 두라는 의미
• 반대쪽인 왼쪽 정렬은 %-10s

>>> "%-10sjane." % 'hi'
'hi        jane.'

2. 소수점 표현하기

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

• ’.’의 의미는 소수점 포인트를 말하고 그 뒤의 숫자 4는 소수점 뒤에 나올 숫자의 개수를 말함

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

• 숫자 3.42134234를 소수점 네 번째 자리까지만 표시하고 전체 길이가 10개인 문자열 공간에서 오른쪽으로 정렬하는 예

format 함수를 사용한 포매팅

숫자 바로 대입하기

>>> "I eat {0} apples".format(3)
'I eat 3 apples'

• “I eat {0} apples” 문자열 중 {0} 부분이 숫자 3으로 바뀜

문자열 바로 대입하기

>>> "I eat {0} apples".format("five")
'I eat five apples'

• 문자열의 {0} 항목이 five라는 문자열로 바뀜

숫자 값을 가진 변수로 대입하기

>>> number = 3
>>> "I eat {0} apples".format(number)
'I eat 3 apples'

• 문자열의 {0} 항목이 number 변수 값인 3으로 바뀜

2개 이상의 값 넣기

>>> 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.'

• 2개 이상의 값을 넣을 경우 문자열의 {0}, {1}과 같은 인덱스 항목이 format 함수의 입력값으로 순서에 맞게 바뀜
  • {0}은 format 함수의 첫 번째 입력값인 number로 바뀌고 {1}은 format 함수의 두 번째 입력값인 day로 바뀜

이름으로 넣기

>>> "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.'

• {0}, {1}과 같은 인덱스 항목 대신 더 편리한 {name} 형태를 사용하는 방법도 있음 {name} 형태를 사용할 경우 format 함수에는 반드시 name=value 와 같은 형태의 입력값이 있어야만 함
• 문자열의 {number}, {day}가 format 함수의 입력값인 number=10, day=3 값으로 각각 바뀜

인덱스와 이름을 혼용해서 넣기

>>> "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.'

• 인덱스 항목과 name=value 형태를 혼용하는 것도 가능

왼쪽 정렬

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

• :<10 표현식을 사용하면 치환되는 문자열을 왼쪽으로 정렬하고 문자열의 총 자릿수를 10

오른쪽 정렬

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

• 오른쪽 정렬은 :< 대신 :>을 사용
  • 화살표 방향을 생각하면 어느 쪽으로 정렬되는지 바로 알 수 있음

가운데 정렬

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

• :^ 기호를 사용하면 가운데 정렬도 가능

공백 채우기

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

• 정렬할 때 공백 문자 대신에 지정한 문자 값으로 채워 넣는 것도 가능
• 채워 넣을 문자 값은 정렬 문자 <, >, ^ 바로 앞에 넣어야 함
• 첫 번째 예제는 가운데(^)로 정렬하고 빈 공간을 = 문자로 채웠고, 두 번째 예제는 왼쪽(<)으로 정렬하고 빈 공간을 ! 문자로 채움

소수점 표현하기

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

• format 함수를 사용해 소수점을 4자리까지만 표현하는 방법
• 앞에서 살펴보았던 표현식 0.4f를 그대로 사용

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

• 자릿수를 10으로 맞출 수도 있음
• 앞에서 살펴본 10.4f의 표현식을 그대로 사용

{ 또는 } 문자 표현하기

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

• format 함수를 사용해 문자열 포매팅을 할 경우 { }와 같은 중괄호(brace) 문자를 포매팅 문자가 아닌 문자 그대로 사용하고 싶은 경우에는 위 예의 {{ }}처럼 2개를 연속해서 사용

f 문자열 포매팅

• 파이썬 3.6 버전부터는 f 문자열 포매팅 기능을 사용할 수 있음
  • 파이썬 3.6 미만 버전에서는 사용할 수 없는 기능
• 문자열 앞에 f 접두사를 붙이면 f 문자열 포매팅 기능을 사용할 수 있음

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

• f 문자열 포매팅은 위와 같이 name, age와 같은 변수 값을 생성한 후에 그 값을 참조할 수 있음
• f 문자열 포매팅은 표현식을 지원하기 때문에 다음과 같은 것도 가능

표현식 : 문자열 안에서 변수와 +, -와 같은 수식을 함께 사용하는 것

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

• 딕셔너리는 f 문자열 포매팅에서 다음과 같이 사용할 수 있음

딕셔너리 : Key와 Value라는 것을 한 쌍으로 갖는 자료형

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

• 정렬은 다음과 같이 할 수 있음

>>> f'{"hi":<10}'  # 왼쪽 정렬
'hi        '
>>> f'{"hi":>10}'  # 오른쪽 정렬
'        hi'
>>> f'{"hi":^10}'  # 가운데 정렬
'    hi    '

• 공백 채우기는 다음과 같이 할 수 있음

>>> f'{"hi":=^10}'  # 가운데 정렬하고 '=' 문자로 공백 채우기
'====hi===='
>>> f'{"hi":!<10}'  # 왼쪽 정렬하고 '!' 문자로 공백 채우기
'hi!!!!!!!!'

• 소수점은 다음과 같이 표현할 수 있음

>>> y = 3.42134234
>>> f'{y:0.4f}'  # 소수점 4자리까지만 표현
'3.4213'
>>> f'{y:10.4f}'  # 소수점 4자리까지 표현하고 총 자리수를 10으로 맞춤
'    3.4213'

• f 문자열에서 { } 문자를 표시하려면 다음과 같이 두 개를 동시에 사용해야 함

>>> f''
'{ and }'

문자열 관련 함수들

• 문자열 자료형은 자체적으로 함수를 가지고 있음 이들 함수를 다른 말로 문자열 내장 함수라 함
• 이 내장 함수를 사용하려면 문자열 변수 이름 뒤에 (.)를 붙인 다음에 함수 이름을 써주면 됨

문자 개수 세기(count)

>>> a = "hobby"
>>> a.count('b')
2

• 문자열 중 문자 b의 개수를 돌려줌

위치 알려주기1(find)

>>> a = "Python is the best choice"
>>> a.find('b')
14	# 파이썬은 숫자를 0부터 세기 때문에 b의 위치는 15가 아닌 14가 됨
>>> a.find('k')
-1

• 문자열 중 문자 b가 처음으로 나온 위치를 반환
  • 만약 찾는 문자나 문자열이 존재하지 않는다면 -1을 반환

위치 알려주기2(index)

>>> a = "Life is too short"
>>> a.index('t')
8
>>> a.index('k')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

• 문자열 중 문자 t가 맨 처음으로 나온 위치를 반환
  • 만약 찾는 문자나 문자열이 존재하지 않는다면 오류를 발생
• 앞의 find 함수와 다른 점은 문자열 안에 존재하지 않는 문자를 찾으면 오류가 발생한다는 점

문자열 삽입(join)

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

• abcd 문자열의 각각의 문자 사이에 ‘,’를 삽입
• join() 함수는 문자열뿐만 아니라 리스트나 튜플도 입력으로 사용할 수 있음
• join() 함수의 입력으로 리스트를 사용하는 예

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

소문자를 대문자로 바꾸기(upper)

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

• upper() 함수는 소문자를 대문자로 바꿔 줌

대문자를 소문자로 바꾸기(lower)

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

• lower() 함수는 대문자를 소문자로 바꿔 줌

왼쪽 공백 지우기(lstrip)

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

• 문자열 중 가장 왼쪽에 있는 한 칸 이상의 연속된 공백들을 모두 지움
• lstrip에서 l은 left를 의미

오른쪽 공백 지우기(rstrip)

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

• 문자열 중 가장 오른쪽에 있는 한 칸 이상의 연속된 공백을 모두 지움
• rstrip에서 r는 right를 의미

양쪽 공백 지우기(strip)

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

• 문자열 양쪽에 있는 한 칸 이상의 연속된 공백을 모두 지움

문자열 바꾸기(replace)

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

• replace(바뀌게 될 문자열, 바꿀 문자열)처럼 사용해서 문자열 안의 특정한 값을 다른 값으로 치환

문자열 나누기(split)

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

• split() 함수는 a.split()처럼 괄호 안에 아무 값도 넣어 주지 않으면 공백(스페이스, 탭, 엔터 등)을 기준으로 문자열을 나눔
• b.split(':')처럼 괄호 안에 특정 값이 있을 경우에는 괄호 안의 값을 구분자로 해서 문자열을 나눔
• 이렇게 나눈 값은 리스트에 하나씩 들어가게 됨
  • ['Life', 'is', 'too', 'short']나 ['a', 'b', 'c', 'd']
• 위에서 소개한 문자열 관련 함수는 문자열 처리에서 사용 빈도가 매우 높고 유용함

2-3. 리스트 자료형

리스트는 어떻게 만들고 사용할까?

• 리스트를 사용하면 1, 3, 5, 7, 9 숫자 모음을 다음과 같이 간단하게 표현할 수 있음

>>> odd = [1, 3, 5, 7, 9]

• 리스트를 만들 때는 대괄호([ ])로 감싸 주고 각 요솟값은 쉼표(,)로 구분

리스트명 = [요소1, 요소2, 요소3, ...]

여러 가지 리스트의 생김새

>>> a = []
>>> b = [1, 2, 3]
>>> c = ['Life', 'is', 'too', 'short']
>>> d = [1, 2, 'Life', 'is']
>>> e = [1, 2, ['Life', 'is']]

• 리스트 안에는 어떠한 자료형도 포함시킬 수 있음

비어 있는 리스트는 a = list()로 생성할 수도 있음

리스트의 인덱싱과 슬라이싱

• 리스트도 문자열처럼 인덱싱과 슬라이싱이 가능

리스트의 인덱싱

• 리스트 역시 문자열처럼 인덱싱을 적용할 수 있음
• a 변수에 [1, 2, 3] 값을 설정

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

• a[0]은 리스트 a의 첫 번째 요솟값을 말함

>>> a[0]
1

• 다음 예는 리스트의 첫 번째 요소인 a[0]과 세 번째 요소인 a[2]의 값을 더한 것

>>> a[0] + a[2]
4

• 1 + 3으로 해석되어 값 4를 출력함

• 파이썬은 숫자를 0부터 세기 때문에 a[1]이 리스트 a의 첫 번째 요소가 아니라 a[0]이 리스트 a의 첫 번째 요소임
• a[-1]은 문자열에서와 마찬가지로 리스트 a의 마지막 요솟값을 말함

>>> a[-1]
3

• 리스트 a는 숫자 1, 2, 3과 또 다른 리스트인 [‘a’, ‘b’, ‘c’]를 포함함

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

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

• a[-1]은 마지막 요솟값 [‘a’, ‘b’, ‘c’]를 나타냄

• a[3]은 리스트 a의 네 번째 요소를 나타내기 때문에 마지막 요소를 나타내는 a[-1]과 동일한 결괏값을 보여줌

• 리스트 a에 포함된 [‘a’, ‘b’, ‘c’] 리스트에서 ‘a’ 값을 인덱싱을 사용해 뽑아내는 법

>>> a[-1][0]
'a'

• a[-1]이 [‘a’, ‘b’, ‘c’] 리스트에서 첫 번째 요소를 불러오기 위해 [0]을 붙여 준 것

>>> a[-1][1]
'b'
>>> a[-1][2]
'c'

삼중 리스트에서 인덱싱하기

>>> a = [1, 2, ['a', 'b', ['Life', 'is']]]

• 리스트 a 안에 [‘a’, ‘b’, [‘Life’, ‘is’]] 리스트가 포함되어 있고, 그 리스트 안에 다시 [‘Life’, ‘is’] 리스트가 포함되어 있는 삼중 구조의 리스트

• ‘Life’ 문자열만 끄집어내려면

>>> a[2][2][0]
'Life'

• 리스트 a의 세 번째 요소인 리스트 [‘a’, ‘b’, [‘Life’, ‘is’]]에서 세 번째 요소인 리스트 [‘Life’, ‘is’]의 첫 번째 요소를 나타냄
• 리스트를 삼중으로 중첩해서 쓰면 혼란스럽기 때문에 자주 사용하지는 않지만 알아두는 것이 좋음

리스트의 슬라이싱

• 문자열과 마찬가지로 리스트에서도 슬라이싱 기법을 적용할 수 있음
  • 슬라이싱은 ‘나눈다’는 뜻

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

• 앞의 예를 문자열에서 슬라이싱한 경우

>>> a = "12345"
>>> a[0:2]
'12'

• 2가지가 완전히 동일하게 사용되었음
  • 문자열에서 했던 것과 사용법이 완전히 동일

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

• b 변수는 리스트 a의 첫 번째 요소부터 두 번째 요소인 a[1]까지 나타내는 리스트
  • a[2] 값인 3은 포함되지 않음
• c라는 변수는 리스트 a의 세 번째 요소부터 끝까지 나타내는 리스트

중첩된 리스트에서 슬라이싱하기

• 리스트가 포함된 중첩 리스트 역시 슬라이싱 방법은 똑같이 적용됨

>>> a = [1, 2, 3, ['a', 'b', 'c'], 4, 5]
>>> a[2:5]
[3, ['a', 'b', 'c'], 4]
>>> a[3][:2]
['a', 'b']

• a[3]은 [‘a’, ‘b’, ‘c’]를 나타냄
• 따라서 a[3][:2]는 [‘a’, ‘b’, ‘c’]의 첫 번째 요소부터 세 번째 요소 직전까지의 값, 즉 [‘a’, ‘b’]를 나타내는 리스트

리스트 연산하기

리스트 역시 + 기호를 사용해서 더할 수 있고 * 기호를 사용해서 반복할 수 있음

리스트 더하기(+)

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]

• 리스트 사이에서 + 기호는 2개의 리스트를 합치는 기능
• 문자열에서 "abc" + "def" = "abcdef"가 되는 것과 같은 이치

리스트 반복하기(*)

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

• [1, 2, 3] 리스트가 세 번 반복되어 새로운 리스트를 만들어냄
• 문자열에서 "abc" * 3 = "abcabcabc" 가 되는 것과 같은 이치

리스트 길이 구하기

• 리스트 길이를 구하기 위해서는len함수를 사용해야함

>>> a = [1, 2, 3]
>>> len(a)
3

• len 함수는 문자열, 리스트 외에 앞으로 배울 튜플과 딕셔너리에도 사용할 수 있는 함수

초보자가 범하기 쉬운 리스트 연산 오류

>>> a = [1, 2, 3]
>>> a[2] + "hi"

• a[2]의 값인 3과 문자열 hi가 더해져서 3hi가 출력될 것이라고 생각
  • 형 오류(TypeError)가 발생

Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

• a[2]에 저장된 값은 3이라는 정수인데 “hi”는 문자열

• 정수와 문자열은 당연히 서로 더할 수 없기 때문에 형 오류가 발생한 것

• 만약 숫자와 문자열을 더해서 ‘3hi’처럼 만들고 싶다면 숫자 3을 문자 ‘3’으로 바꿔야함

>>>str(a[2]) + "hi"

• str 함수는 정수나 실수를 문자열의 형태로 바꾸어 주는 파이썬의 내장 함수

리스트 수정과 삭제

• 리스트는 값을 수정하거나 삭제할 수 있음

리스트에서 값 수정하기

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

• a[2]의 요솟값 3이 4로 바뀜

del 함수 사용해 리스트 요소 삭제하기

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

• del a[x]는 x번째 요솟값을 삭제함

• a 리스트에서 a[1]을 삭제하는 방법

• del 함수는 파이썬이 자체적으로 가지고 있는 삭제 함수

del 객체

객체 : 파이썬에서 사용되는 모든 자료형

• 슬라이싱 기법을 사용하여 리스트의 요소 여러 개를 한꺼번에 삭제할 수 있음

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

• a[2:]에 해당하는 리스트의 요소들이 삭제됨

• 리스트의 요소를 삭제하는 방법에는 2가지가 더 있음

  • 리스트의 remove와 pop 함수를 사용하는 방법

리스트 관련 함수들

• 문자열과 마찬가지로 리스트 변수 이름 뒤에 ‘.’를 붙여서 여러 가지 리스트 관련 함수를 사용할 수 있음

리스트에 요소 추가(append)

• append를 사전에서 검색해 보면 “덧붙이다, 첨부하다”라는 뜻
• append(x)는 리스트의 맨 마지막에 x를 추가하는 함수

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

• 리스트 안에는 어떤 자료형도 추가할 수 있음

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

리스트 정렬(sort)

• sort() 함수는 리스트의 요소를 순서대로 정렬해줌

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

• 문자 역시 알파벳 순서로 정렬할 수 있음

>>> a = ['a', 'c', 'b']
>>> a.sort()
>>> a
['a', 'b', 'c']

리스트 뒤집기(reverse)

• reverse() 함수는 리스트를 역순으로 뒤집어줌
• 이때 리스트 요소들을 순서대로 정렬한 다음 다시 역순으로 정렬하는 것이 아니라 그저 현재의 리스트를 그대로 거꾸로 뒤집음

>>> a = ['a', 'c', 'b']
>>> a.reverse()
>>> a
['b', 'c', 'a']

위치 반환(index)

• index(x) 함수는 리스트에 x 값이 있으면 x의 위치 값을 돌려줌

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

• 리스트 a에 있는 숫자 3의 위치는 a[2]이므로 2를 돌려주고, 숫자 1의 위치는 a[0]이므로 0을 돌려줌

• 값 0은 a 리스트에 존재하지 않기 때문에 값 오류(ValueError)가 발생

>>> a.index(0)

Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>
ValueError: 0 is not in list

리스트에 요소 삽입(insert)

• insert(a, b)는 리스트의 a번째 위치에 b를 삽입하는 함수
• 파이썬에서는 숫자를 0부터 센다는 것을 반드시 기억!!

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

• 0번째 자리, 즉 첫 번째 요소(a[0]) 위치에 값 4를 삽입하라는 뜻

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

• 위 예는 리스트 a의 a[3], 즉 네 번째 요소 위치에 값 5를 삽입하라는 뜻

리스트 요소 제거(remove)

• remove(x)는 리스트에서 첫 번째로 나오는 x를 삭제하는 함수

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

• a가 3이라는 값을 2개 가지고 있을 경우 첫 번째 3만 제거됨

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

• remove(3)을 한 번 더 실행하면 다시 3이 삭제

리스트 요소 끄집어내기(pop)

• pop()은 리스트의 맨 마지막 요소를 돌려주고 그 요소는 삭제함

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

리스트에 포함된 요소 x의 개수 세기(count)

• count(x)는 리스트 안에 x가 몇 개 있는지 조사하여 그 개수를 돌려주는 함수

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

• 1이라는 값이 리스트 a에 2개 들어 있으므로 2를 돌려줌

리스트 확장(extend)

• extend(x)에서 x에는 리스트만 올 수 있으며 원래의 a 리스트에 x 리스트를 더함

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

• a.extend([4, 5])는 a += [4, 5]와 동일함

2-4. 튜플 자료형

튜플은 어떻게 만들까?

• 튜플(tuple)은 몇 가지 점을 제외하곤 리스트와 거의 비슷함

리스트와 다른 점

• 리스트는 [ ]으로 둘러싸지만 튜플은 ( )으로 둘러쌈
• 리스트는 그 값의 생성, 삭제, 수정이 가능하지만 튜플은 그 값을 바꿀 수 없음

>>> t1 = ()
>>> t2 = (1,)
>>> t3 = (1, 2, 3)
>>> t4 = 1, 2, 3
>>> t5 = ('a', 'b', ('ab', 'cd'))

• 리스트와 모습은 거의 비슷하지만 튜플에서는 리스트와 다른 2가지 차이점있음
  • t2 = (1,)처럼 단지 1개의 요소만을 가질 때는 요소 뒤에 콤마(,)를 반드시 붙여야함
  • t4 = 1, 2, 3처럼 괄호( )를 생략해도 무방하다는 점
• 튜플과 리스트의 가장 큰 차이는 값을 변화시킬 수 있는가 여부
  • 리스트의 항목 값은 변화가 가능하고 튜플의 항목 값은 변화가 불가능
    • 프로그램 실행되는 동안 그 값이 변하기 않기 바란다면 튜플을 사용
    • 반대로 수시로 그 값을 벼놔시켜야 할 경우 리스트를 사용
• 실제 프로그램에서는 값이 변경되는 형태의 변수가 훨씬 많기 때문에 평균적으로 튜플보다는 리스트를 더 많이 사용함

튜플의 요소값을 지우거나 변경하려고 하면 어떻게 될까?

• 튜플의 요솟값은 한 번 정하면 지우거나 변경할 수 없음

1. 튜플 요솟값을 삭제하려 할 때

>>> t1 = (1, 2, 'a', 'b')
>>> del t1[0]

Traceback (most recent call last): 
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

• 튜플의 요소를 리스트처럼 del 함수로 지우려고 한 예
• 튜플은 요소를 지우는 행위가 지원되지 않는다는 메시지가 나옴

2. 튜플 요솟값을 변경하려 할 때

>>> t1 = (1, 2, 'a', 'b')
>>> t1[0] = 'c'

Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

• 튜플의 요솟값을 변경하려고 해도 마찬가지로 오류가 발생함

튜플 다루기

• 튜플은 값을 변화시킬 수 없다는 점만 제외하면 리스트와 완전히 동일

인덱싱하기

>>> t1 = (1, 2, 'a', 'b')
>>> t1[0]
1
>>> t1[3]
'b'

• 문자열, 리스트와 마찬가지로 t1[0], t1[3]처럼 인덱싱이 가능

슬라이싱하기

>>> t1 = (1, 2, 'a', 'b')
>>> t1[1:]
(2, 'a', 'b')

• t1[1]부터 튜플의 마지막 요소까지 슬라이싱하는 예

튜플 더하기

>>> t1 = (1, 2, 'a', 'b')
>>> t2 = (3, 4)
>>> t1 + t2
(1, 2, 'a', 'b', 3, 4)

튜플 곱하기

>>> t2 = (3, 4)
>>> t2 * 3
(3, 4, 3, 4, 3, 4)

튜플 길이 구하기

>>> t1 = (1, 2, 'a', 'b')
>>> len(t1)
4

2-5. 딕셔너리 자료형

딕셔너리란?

• 요즘 사용하는 대부분의 언어는 대응 관계를 나타내는 자료형을 갖고 있는데, 이를 연관 배열(Associative array) or 해시(Hash)라고 함
• 파이썬에서는 이러한 자료형을 딕셔너리(Dictionary)라고 함
  • 단어 그대로 해석하면 사전이라는 뜻
  • 딕셔너리는 Key와 Value를 한 쌍으로 갖는 자료형
• 딕셔너리는 리스트나 튜플처럼 순차적으로(sequential) 해당 요솟값을 구하지 않고 Key를 통해 Value를 얻음
  • 이것이 바로 딕셔너리의 가장 큰 특징
  • ex) baseball이라는 단어의 뜻을 찾기 위해 사전의 내용을 순차적으로 모두 검색하는 것이 아니라 baseball이라는 단어가 있는 곳만 펼쳐 보는 것

딕셔너리는 어떻게 만들까?

• 기본 딕셔너리 모습

{Key1:Value1, Key2:Value2, Key3:Value3, ...}

• Key와 Value의 쌍 여러 개가 { }로 둘러싸여 있음
• 각각의 요소는 Key : Value 형태로 이루어져 있고 쉼표(,)로 구분되어 있음

Key에는 변하지 않는 값을 사용하고, Value에는 변하는 값과 변하지 않는 값 모두 사용할 수 있음

>>> dic = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}

• 위에서 Key는 각각 ‘name’, ‘phone’, ‘birth’이고, 각각의 Key에 해당하는 Value는 ‘pey’, ‘0119993323’, ‘1118’

딕셔너리 dic의 정보

key	value
name	pey
phone	01199993323
birth	1118

• Key로 정수 값 1, Value로 문자열 ‘hi’를 사용한 예

>>> a = {1: 'hi'}

• 다음 예처럼 Value에 리스트도 넣을 수 있음

>>> a = { 'a': [1,2,3]}

딕셔너리 쌍 추가, 삭제하기

딕셔너리 쌍 추가하기

>>> a = {1: 'a'}
>>> a[2] = 'b'
>>> a
{1: 'a', 2: 'b'}

• {1: ‘a’} 딕셔너리에 a[2] = ‘b’와 같이 입력하면 딕셔너리 a에 Key와 Value가 각각 2와 ‘b’인 2 : ‘b’라는 딕셔너리 쌍이 추가됨

>>> a['name'] = 'pey'
>>> a
{1: 'a', 2: 'b', 'name': 'pey'}

• 딕셔너리 a에 ‘name’: ‘pey’라는 쌍이 추가됨

>>> a[3] = [1,2,3]
>>> a
{1: 'a', 2: 'b', 'name': 'pey', 3: [1, 2, 3]}

• Key는 3, Value는 [1, 2, 3]을 가지는 한 쌍이 또 추가됨

딕셔너리 요소 삭제하기

>>> del a[1]
>>> a
{2: 'b', 'name': 'pey', 3: [1, 2, 3]}

• 위 예제는 딕셔너리 요소를 지우는 방법
• del 함수를 사용해서 del a[key]처럼 입력하면 지정한 Key에 해당하는 {key : value} 쌍이 삭제됨

딕셔너리를 사용하는 방법

• 4명의 사람이 있다고 가정하고, 각자의 특기를 표현할 수 있는 좋은 방법
  • 리스트나 문자열로는 표현하기 까다로움

{"김연아":"피겨스케이팅", "류현진":"야구", "박지성":"축구", "귀도":"파이썬"}

• 사람 이름과 특기를 한 쌍으로 하는 딕셔너리

딕셔너리에서 Key 사용해 Value 얻기

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

• 리스트나 튜플, 문자열은 요솟값을 얻고자 할 때 인덱싱이나 슬라이싱 기법 중 하나를 사용했음
• 하지만 딕셔너리는 단 한 가지 방법, Key를 사용해서 Value를 구하는 방법임
• 위 예에서 ‘pey’라는 Key의 Value를 얻기 위해 grade[‘pey’]를 사용한 것처럼 어떤 Key의 Value를 얻기 위해서는 딕셔너리변수이름[Key]를 사용

>>> a = {1:'a', 2:'b'
}>>> a[1]
'a'
>>> a[2]
'b'

• a 변수에 {1:’a’, 2:’b’} 딕셔너리를 대입
• a[1]이 의미하는 것은 리스트나 튜플의 a[1]과는 전혀 다름
  • 딕셔너리 변수에서 [ ] 안의 숫자 1은 두 번째 요소를 뜻하는 것이 아니라 Key에 해당하는 1을 나타냄
• 딕셔너리는 리스트나 튜플에 있는 인덱싱 방법을 적용할 수 없음
  • 따라서 a[1]은 딕셔너리 {1:’a’, 2:’b’}에서 Key가 1인 것의 Value인 ‘a’를 돌려주게됨, a[2] 역시 마찬가지
• a라는 변수에 앞의 예에서 사용한 딕셔너리의 Key와 Value를 뒤집어 놓은 딕셔너리를 대입

>>> a = {'a':1, 'b':2}
>>> a['a']
1
>>> a['b']
2

• a[‘a’], a[‘b’]처럼 Key를 사용해서 Value를 얻을 수 있음
• 딕셔너리 a는 a[Key]로 입력해서 Key에 해당하는 Value를 얻음

>>> dic = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
>>> dic['name']
'pey'
>>> dic['phone']
'0119993323'
>>> dic['birth']
'1118'

딕셔너리 만들 때 주의 사항

• 딕셔너리에서 Key는 고유한 값이므로 중복되는 Key 값을 설정해 놓으면 하나를 제외한 나머지 것들이 모두 무시됨
• 다음 예에서 볼 수 있듯이 동일한 Key가 2개 존재할 경우 1:’a’ 쌍이 무시됨

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

• Key가 중복되었을 때 1개를 제외한 나머지 Key:Value 값이 모두 무시되는 이유
  • 동일한 Key가 존재하면 어떤 Key에 해당하는 Value를 불러야 할지 알 수 없기 때문
• Key에 리스트는 쓸 수 없음
  • 하지만 튜플은 Key로 쓸 수 있음
• 딕셔너리의 Key로 쓸 수 있느냐 없느냐는 Key가 변하는 값인지 변하지 않는 값인지에 달려 있음
  • 리스트는 그 값이 변할 수 있기 때문에 Key로 쓸 수 없음
  • 튜플은 그 값이 변할 수 없기 때문에 Key로 쓸 수 이씀
• 리스트를 Key로 설정하면 리스트를 키 값으로 사용할 수 없다는 오류가 발생

>>> a = {[1,2] : 'hi'}
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

• 딕셔너리의 Key 값으로 딕셔너리를 사용할 수 없음은 당연
• Value에는 변하는 값이든 변하지 않는 값이든 상관없이 아무 값이나 넣을 수 있음

딕셔너리 관련 함수들

Key 리스트 만들기 (keys)

>>> a = {'name': 'pey', 'phone': '0119993323', 'birth': '1118'}
>>> a.keys()
dict_keys(['name', 'phone', 'birth'])

• a.keys()는 딕셔너리 a의 Key만을 모아서 dict_keys 객체를 돌려줌

파이썬 3.0 이후 버전의 keys 함수, 어떻게 달라졌나?

• 파이썬 2.7 버전까지는 a.keys() 함수를 호출할 때 반환 값으로 dict_keys가 아닌 리스트를 돌려줌
  • 리스트로 돌려주면 메모리 낭비가 발생함
• 파이썬 3.0 이후 버전에서는 이러한 메모리 낭비를 줄이기 위해 dict_keys 객체를 돌려줌
• 3.0 이후 버전에서 반환 값으로 리스트가 필요한 경우에는 list(a.keys())를 사용하면 됨
• dict_keys, dict_values, dict_items 등은 리스트로 변환하지 않더라도 기본적인 반복(iterate) 구문(예: for문)을 실행할 수 있음

dict_keys 객체

• 리스트를 사용하는 것과 차이가 없지만, 리스트 고유의 append, insert, pop, remove, sort 함수는 수행할 수 없음

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

• dict_keys 객체를 리스트로 변환한다면

>>> list(a.keys())
['name', 'phone', 'birth']

Value 리스트 만들기(values)

>>> a.values()
dict_values(['pey', '0119993323', '1118'])

• Key를 얻는 것과 마찬가지 방법으로 Value만 얻고 싶다면 values() 함수를 사용
  • values() 함수를 호출하면 dict_values 객체를 돌려줌

Key, Value 쌍 얻기(items)

>>> a.items()
dict_items([('name', 'pey'), ('phone', '0119993323'), ('birth', '1118')])

• items() 함수는 Key와 Value의 쌍을 튜플로 묶은 값을 dict_items 객체로 돌려줌
• dict_values 객체와 dict_items 객체 역시 dict_keys 객체와 마찬가지로 리스트를 사용하는 것과 동일하게 사용할 수 있음

Key: Value 쌍 모두 지우기(clear)

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

• clear() 함수는 딕셔너리 안의 모든 요소를 삭제함
• 빈 리스트를 [ ], 빈 튜플을 ( )로 표현하는 것과 마찬가지로 빈 딕셔너리도 { }로 표현함

Key로 Value얻기(get)

>>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
>>> a.get('name')
'pey'
>>> a.get('phone')
'0119993323'

• get(x) 함수는 x라는 Key에 대응되는 Value를 돌려줌

• a.get(‘name’)은 a[‘name’]을 사용했을 때와 동일한 결괏값을 돌려받음

• 다음 예제에서 볼 수 있듯이 a[‘nokey’]처럼 존재하지 않는 키(nokey)로 값을 가져오려고 할 경우 a[‘nokey’]는 Key 오류를 발생시키고 a.get(‘nokey’)는 None을 돌려준다는 차이있음

>>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
>>> print(a.get('nokey'))
None
>>> print(a['nokey'])
Traceback (most recent call last):  
  File "<stdin>", line 1, in 
<module>KeyError: 'nokey'

• 딕셔너리 안에 찾으려는 Key 값이 없을 경우 미리 정해 둔 디폴트 값을 대신 가져오게 하고 싶을 때에는 get(x, ‘디폴트 값’)을 사용하면 편리함

>>> a.get('foo', 'bar')
'bar'

• a 딕셔너리에는 ‘foo’에 해당하는 값이 없음 따라서 디폴트 값인 ‘bar’를 돌려줌

해당 Key가 딕셔너리 안에 있는지 조사하기(in)

>>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
>>> 'name' in a
True
>>> 'email' in a
False

• ‘name’ 문자열은 a 딕셔너리의 Key 중 하나이므로 ‘name’ in a를 호출하면 참(True)을 돌려줌
• 반대로 ‘email’은 a 딕셔너리 안에 존재하지 않는 Key이므로 거짓(False)을 돌려줌

2-6. 집합 자료형

집합 자료형은 어떻게 만들까?

• 집합(set)은 파이썬 2.3부터 지원하기 시작한 자료형
  • 집합에 관련된 것을 쉽게 처리하기 위해 만든 자료형
• 집합 자료형은 다음과 같이 set 키워드를 사용해 만들 수 있음

>>> s1 = set([1,2,3])
>>> s1
{1, 2, 3}

• set()의 괄호 안에 리스트를 입력하여 만들거나 다음과 같이 문자열을 입력하여 만들 수도 있음

>>> s2 = set("Hello")
>>> s2
{'e', 'H', 'l', 'o'}

비어 있는 집합 자료형은 s = set()로 만들수 있음

집합 자료형의 특징

• 위에서 본 set("Hello")의 결과가 좀 이상함 분명 “Hello” 문자열로 set 자료형을 만들었는데 생성된 자료형에는 l 문자가 하나 빠져 있고 순서도 뒤죽박죽임

set의 2가지 특징

• 중복을 허용하지 않음

• 순서가 없음(Unordered)

• 리스트나 튜플은 순서가 있기(ordered) 때문에 인덱싱을 통해 자료형의 값을 얻을 수 있지만 set 자료형은 순서가 없기(unordered) 때문에 인덱싱으로 값을 얻을 수 없음
  • 딕셔너리와 비슷, 딕셔너리 역시 순서가 없는 자료형이라 인덱싱을 지원하지 않음
• 만약 set 자료형에 저장된 값을 인덱싱으로 접근하려면 다음과 같이 리스트나 튜플로 변환한후 해야함

>>> s1 = set([1,2,3])
>>> l1 = list(s1)
>>> l1
[1, 2, 3]
>>> l1[0]
1
>>> t1 = tuple(s1)
>>> t1
(1, 2, 3)
>>> t1[0]
1

중복을 허용하지 않는 set의 특징은 자료형의 중복을 제거하기 위한 필터 역할로 종종 사용

교집합, 합집합, 차집합 구하기

• s1은 1부터 6까지의 값을 가지게 되었고, s2는 4부터 9까지의 값을 가지게 됨

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

1. 교집합

>>> s1 & s2
{4, 5, 6}

• “&” 기호를 이용하면 교집합을 간단히 구할 수 있음
• 또는 다음과 같이 intersection() 함수를 사용해도 동일한 결과를 돌려줌

>>> s1.intersection(s2)
{4, 5, 6}
>>> s2.intersection(s1)	# s2.intersection(s1)을 사용해도 결과는 같음
{4, 5, 6}

2. 합집합

• 4, 5, 6처럼 중복해서 포함된 값은 한 개씩만 표현됨

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

• ”	” 기호를 사용한 방법

>>> s1.union(s2)
{1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> s2.union(s1)
{1, 2, 3, 4, 5, 6, 7, 8, 9}

• 또는 union() 함수를 사용하면 됨
• 교집합에서 사용한 intersection() 함수와 마찬가지로 s2.union(s1)을 사용해도 동일한 결과를 돌려줌

3. 차집합

>>> s1 - s2
{1, 2, 3}
>>> s2 - s1
{8, 9, 7}

• 빼기(-) 기호를 사용한 방법

>>> s1.difference(s2)
{1, 2, 3}
>>> s2.difference(s1)
{8, 9, 7}

• difference() 함수를 사용해도 차집합을 구할 수 있음

집합 자료형 관련 함수들

값 1개 추가하기(add)

• 이미 만들어진 set 자료형에 값을 추가할 수 있음
• 1개의 값만 추가(add)할 경우

>>> s1 = set([1, 2, 3])
>>> s1.add(4)
>>> s1
{1, 2, 3, 4}

값 여러 개 추가하기(update)

• 여러 개의 값을 한꺼번에 추가(update)할 경우

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

특정 값 제거하기(remove)

• 특정 값을 제거하고 싶은 경우

>>> s1 = set([1, 2, 3])
>>> s1.remove(2)
>>> s1
{1, 3}

2-7. 불 자료형

불 자료형이란?

• 불(bool) 자료형이란 참(True)과 거짓(False)을 나타내는 자료형

불 자료형 2가지 값

• True - 참
• False - 거짓

True나 False는 파이썬의 예약어로 true, false와 같이 사용하지 말고 첫 문자를 항상 대문자로 사용해야함

• a에는 True를, 변수 b에는 False를 지정

>>> a = True
>>> b = False

• 따옴표로 감싸지 않은 문자열을 변수에 지정해서 오류가 발생할 것 같지만 잘 실행됨
• type() 함수를 변수 a와 b에 사용하면 두 변수의 자료형이 bool로 지정된 것을 확인할 수 있음

>>> type(a)
<class 'bool'>
>>> type(b)
<class 'bool'>

type(x)는 x의 자료형을 확인하는 파이썬의 내장 함수

• 불 자료형은 조건문의 반환 값으로도 사용됨

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

자료형의 참과 거짓

• 자료형의 참과 거짓을 구분하는 기준

값	참 or 거짓
“python”	참
””	거짓
[1, 2, 3]	참
[]	거짓
()	거짓
{}	거짓
1	참
0	거짓
None	거짓

• 문자열, 리스트, 튜플, 딕셔너리 등의 값이 비어 있으면(“ “, [ ], ( ), { }) 거짓이 됨
  • 비어있지 않으면 참이됨
• 숫자에서는 그 값이 0일 때 거짓

>>> a = [1, 2, 3, 4]
>>> while a:
...     print(a.pop())
...
4
3
2
1

• while문은 조건문이 참인 동안 조건문 안에 있는 문장을 반복해서 수행함

while 조건문:    
  수행할 문장

• 위 예를 보면 a가 참인 경우에 a.pop( )을 계속 실행하라는 의미
• a.pop( ) 함수는 리스트 a의 마지막 요소를 끄집어내는 함수이므로 리스트 안에 요소가 존재하는 한(a가 참인 동안) 마지막 요소를 계속해서 끄집어냄
• 결국 더 이상 끄집어낼 것이 없으면 a가 빈 리스트([ ])가 되어 거짓이 됨, 따라서 while문에서 조건이 거짓이 되므로 중지됨
• 위에서 본 예는 파이썬 프로그래밍에서 매우 자주 사용하는 기법 중 하나

>>> if []:
...     print("참")
... else:
...     print("거짓")
...
거짓

• [ ]는 앞의 표에서 볼 수 있듯이 비어 있는 리스트이므로 거짓임, 따라서 “거짓”이란 문자열이 출력됨

>>> if [1, 2, 3]:
...     print("참")
... else:
...     print("거짓")
... 
참

• [1, 2, 3]은 요솟값이 있는 리스트이기 때문에 참임, 따라서 “참”을 출력

불 연산

• bool() 내장 함수를 사용하면 자료형의 참과 거짓을 식별할 수 있음

>>> bool('python')
True

• ‘python’ 문자열은 빈 문자열이 아니므로 bool 연산의 결과로 불 자료형인 True를 돌려줌

>>> bool('')
False

• ’’ 문자열은 빈 문자열이므로 bool 연산의 결과로 불 자료형인 False를 돌려줌

>>> bool([1,2,3])
True
>>> bool([])
False
>>> bool(0)
False
>>> bool(3)
True

2-8. 자료형의 값을 저장하는 공간, 변수

변수는 어떻게 만들까?

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

• 변수를 만들 때는 위 예처럼 =(assignment) 기호를 사용함
• 다른 프로그래밍 언어인 C나 JAVA에서는 변수를 만들 때 자료형을 직접 지정해야 함
  • 하지만 파이썬은 변수에 저장된 값을 스스로 판단하여 자료형을 지정하기 때문에 더 편리함

변수 이름 = 변수에 저장할 값

변수란?

• 파이썬에서 사용하는 변수는 객체를 가리키는 것

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

• a = [1, 2, 3]이라고 하면 [1, 2, 3] 값을 가지는 리스트 자료형(객체)이 자동으로 메모리에 생성되고 변수 a는 [1, 2, 3] 리스트가 저장된 메모리의 주소를 가리키게됨

메모리 : 컴퓨터가 프로그램에서 사용하는 데이터를 기억하는 공간

>>> a = [1, 2, 3]
>>> id(a)
4303029896

• id() 함수는 변수가 가리키고 있는 객체의 주소 값을 돌려주는 파이썬 내장 함수
• 여기에서 변수 a가 가리키는 [1, 2, 3] 리스트의 주소 값은 4303029896 임

리스트를 복사하고자 할 때

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

• b 변수에 a 변수를 대입하면 b는 a와 완전히 동일함

• [1, 2, 3] 리스트를 참조하는 변수가 a 변수 1개에서 b 변수가 추가되어 2개로 늘어났다는 차이만 있을 뿐

• id() 함수를 사용하여 확인할 수 있음

>>> id(a)
4303029896
>>> id(b)
4303029896

• id(a)의 값이 id(b)의 값과 동일함
  • 즉 a가 가리키는 대상과 b가 가리키는 대상이 동일하다는 것을 알 수 있음
• 동일한 객체를 가리키고 있는지에 대해서 판단하는 파이썬 명령어 is를 다음과 같이 실행해도 역시 참(True)을 돌려줌

>>> a is b  # a와 b가 가리키는 객체는 동일한가?True

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

• a 리스트의 두 번째 요소를 값 4로 바꾸었더니 a만 바뀌는 것이 아니라 b도 똑같이 바뀌었음
  • 그 이유는 앞에서 살펴본 것처럼 a, b 모두 동일한 리스트를 가리키고 있기 때문

b 변수를 생성할 때 a 변수의 값을 가져오면서 a와는 다른 주소를 가리키도록 만드는 2가지 방법

1. [:] 이용

• 리스트 전체를 가리키는 [:]을 사용해서 복사하는 것

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

• a 리스트 값을 바꾸더라도 b 리스트에는 영향을 끼치지 않음

2. copy 모듈 이용

>>> from copy import copy
>>> a = [1, 2, 3]
>>> b = copy(a)

• b = copy(a)는 b = a[:]과 동일

• 두 변수가 같은 값을 가지면서 다른 객체를 제대로 생성했는지 확인

>>> b is a
False

• b is a가 False를 돌려주므로 b와 a가 가리키는 객체는 서로 다르다는 것을 알 수 있음

• 리스트 자료형의 자체 함수인 copy() 함수를 사용해도 copy 모듈을 사용하는 것과 동일함

>>> a = [1, 2, 3]
>>> b = a.copy()

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

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

• 튜플로 a, b에 값을 대입할 수 있음

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

• 튜플은 괄호를 생략해도 됨

• 리스트로 변수를 만들 수도 있음

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

• 여러 개의 변수에 같은 값을 대입할 수도 있음

>>> a = b = 'python'

느낀점

• 파이썬의 각 자료형들에 대해 알 수 있었다. 특히 헷갈리기 쉬운 리스트, 튜플에 대해서 차이점을 명확히 한번더 상기 시킬 수 있었다. 그리고 각 자료형에 대한 다양한 내장함수를 알아 볼 수 있었고 앞으로 코테하는데 많이 사용될거 같애서 따로 사용되는 경우를 보면서 정리해야겠다.

reference

점프 투 파이썬