점프 투 파이썬 2장 - 자료형

1장은 기본적인 설치와 에디터 등의 내용이기 때문에 2장부터 내용 정리를 한다.

 

2-1 숫자형

<정수형>

정수를 뜻하는 자료형

a = 10

<실수형>

소수점이 포함된 숫자

a = 0.2
a = 1.2E10
a = 1.2e-10

지수 표현을 할 때 e와 E를 모두 사용할 수 있다.

 

<8진수와 16진수>

8진수는 0o, 0O로 시작

16진수는 0x로 시작

a = 0o77
print(a)  //63

b = 0xABC
print(b)  //2748

 

<연산자>

1. 사칙연산

+, -, *, /

2. x의 y제곱

x**y로 쓴다.

a = 3
b = 4
print(a**b) //81

3. %, //

%는 나눈 나머지, //는 나눈 몫을 반환한다.

 

2-2 문자열 자료형

<문자열을 만드는 방법>

1. 큰따옴표로 둘러싸기 & 큰따옴표 3개로 둘러싸기

"Hard Study"
"""Hard Study"""

2. 작은 따옴표로 둘러싸기 & 작은 따옴표 3개로 둘러싸기

'Hard Study'
'''Hard Study'''

<문자열 안에 큰따옴표, 작은 따옴표 포함>

"Ha'rd' Study"
'Ha"rd" Study'

큰 따옴표로 감싸면 작은 따옴표는 문자열로 인식된다.

반대로 작은 따옴표로 감싸면 큰따옴표는 문자열로 인식된다.

"Ha\'rd\' St\"ud\"y"

 

역슬래시를 '와 " 앞에 붙여서 문자열로 인식시키는 방법도 있다.

 

<여러줄 문자열을 변수에 담는 방법>

1. \n 삽입

"Hard\nStudy"

2. 연속된 작은 따옴표, 큰따옴표 3개 사용

'''Hard
... study'''

"""Hard
... study"""

 

<문자열 연산>

1. 문자열 더하기

a = "Hard"
b = "Study"
print(a+b) // "HardStudy"

2. 문자열 곱하기

a = "Hard"
print(a*2) //"HardHard"

*로 곱한 횟수만큼 문자열이 반복돼서 나온다.

 

<문자열 인덱싱, 슬라이싱>

*문자열 길이 구하기

a = "Hard"
print(len(a)) //4

문자열 인덱싱

a = "Hard"
a[0]: "H", a[1]: "a", a[2]: "r", a[3]: "d"
a[-1]: "d"

문자열의 첫 글자는 0번째부터 시작한다.

-1번째는 뒤에서부터 첫번째 문자를 가리킨다.

 

문자열 슬라이싱

a = "Hard"
a[0:3]= "Har"
a[0:4]= "Hard"
a[1:2]= "a"
a[:2]= "Ha"
a[2:]= "rd"

x:y로 슬라이싱을 하면 x<= <y 번째에 있는 문자를 가져온다.

즉, y번째는 포함하지 않는다.

0:3으로 슬라이싱을 하면 a[0], a[1], a[2]를 가져온다.

[:2]는 처음부터 2번째까지 슬라이싱한 것을 뜻하고

[2:]는 2번째부터 끝까지 슬라이싱한 것을 뜻한다.

 

<문자열 포매팅>

문자열 안의 특정한 값을 바꿔야 하는 경우에 사용한다.

1. 숫자 대입

print("Hard Study %d days." % 3)
// Hard Study 3 days.

숫자가 들어가야 할 자리에 %d를 쓰고 문자열 뒤에 % 숫자를 쓰면 된다.

 

2. 문자열 대입

print("Hard Study %s days." % "three")
// Hard Study three days.

숫자 대입과 거의 같은데 %d 대신에 %s를 사용한다.

 

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

num = 3
print("Hard Study %d days." % num)
// Hard Study 3 days.

숫자 대입과 방식은 같다.

 

4. 2개 이상의 값 넣기

print("Hard Study %d days and %d weeks." %(7, 1))
// Hard Study 7 days and 1 weeks.

괄호 안의 쉼표로 값을 구분하여 각각 넣어주면 된다.

%s 문자열
%c 문자 1개
%d 정수
%f 부동소수
%o 8진수
%x 16진수
%% 문자 % 자체

다양한 자료형의 문자열 포맷 코드 종류이다.

 

<유용한 포맷 코드>

1. 정렬과 공백

print("%10s" % "Hard")
//"      Hard"

%10s는 전체 길이가 10인 문자열 공간에서 오른쪽으로 문자열을 정렬하고

그 앞은 공백으로 채우라는 의미이다.

즉, 6칸의 공백과 Hard 4글자가 출력된다.

왼쪽 정렬은 %-10s 로 사용할 수 있다.

 

2. 소수점 표현

print("%0.4f" % 3.141592)
// 3.1415

%0.4f는 소수점 4번째 자리까지만 나타내는 것을 의미한다.

%0.4f 대신에 %.4f로 사용하기도 한다.

 

<format 함수>

1. 숫자 대입

print("Hard Study {0} days.".foramt(3))
// "Hard Study 3 days."

{0}부분을 .format함수를 이용하면 숫자로 바꿀 수 있다.

 

2. 문자열 대입

print("Hard Study {0} days.".foramt("three"))
// "Hard Study three days."

숫자와 같은 방식으로 대입할 수 있다.

 

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

num = 3
print("Hard Study {0} days.".foramt(num))
// "Hard Study 3 days."

4. 2개 이상의 값 넣기

num = 3
week = "one"
print("Hard Study {0} days and {1} week.".foramt(num, week))
// "Hard Study 3 days and one week."

{0}, {1}로 format함수안의 인자의 인덱스를 {}안에 넣어주면

해당 인덱스의 입력값이 순서에 맞게 들어간다.

print("Hard Study {num} days and {week} week.".foramt(num=3, week="one"))
// "Hard Study 3 days and one week."

인덱스로 하지 않고 변수 이름으로 할 수도 있다.

 

<f문자열 포매팅>

파이썬 3.6버전부터 지원되는 기능이다.

num = 3
print(f'Hard Study {num} days.')
// 'Hard Study 3 days.'

변숫값을 생성한뒤, 뒤에 format함수를 붙이는 대신에 앞에 f를 붙이면 

값을 알아서 참조한다.

 

<문자열 관련 함수들>

1. count

a = "Haaard"
print(a.count('a'))
// 3

문자열 안의 특정 문자가 몇개 들어가 있는지 개수를 세어준다.

 

2. find

a = "Hard"
print(a.find('r'))
// 2

문자열 안에서 특정 문자의 위치를 검색해서 처음 나오는 인덱스를 반환한다.

존재하지 않는 경우에는 -1을 반환한다.

 

3. join

print(",".join("Hard"))
// "H,a,r,d"

문자 사이에 ,를 삽입한다.

 

4. upper, lower

a = 'hard'
b = 'HARD'
print(a.upper()) // 'HARD'
print(a.lower()) // 'hard'

upper는 문자를 대문자로, lower는 소문자로 바꿔준다.

 

5. lstrip, rstrip, strip

a = "   Hard   "
print(a.lstrip()) // "Hard   "
print(a.rstrip()) // "   Hard"
print(a.strip()) // "Hard"

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

strip은 양쪽 공백을 지운다.

 

6. replace

a = "Hard Study"
print(a.replace("Study", "Hack"))
// 'Hard Hack'

replace는 (바뀔 문자열, 바꿀 문자열) 이렇게 입력값을 받고

문자열 안의 특정 값을 다른 값으로 바꿔준다.

 

7. split

a = "Hard Study"
print(a.split())
// ['Hard', 'Study']
b = "a:b:c:d"
print(b.split(':'))
// ['a', 'b', 'c', 'd']

split 함수 안에 아무것도 넣지 않으면, 공백(space, tab, enter)를 기준으로 문자열을 나눈다.

split함수의 입력값으로 특정 문자를 주면, 해당 문자를 구분자로 문자열을 나눠준다.

나눈 값을 리스트에 넣어서 반환한다.

 

 

2-3 리스트 자료형

<리스트의 생성>

a = [1,2,3,4]

대괄호로 감싸고 각 요소를 쉼표로 구분해서 생성하면 된다.

 

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

a = [1,2,[3,4]]
a[0] // 1
a[2][1] // 4

인덱싱은 문자열과 거의 같다. 

0번째부터 시작하고, 리스트 안에 리스트가 있는 경우에는 []를 2개 써서 원하는 위치를 가져올 수 있다.

a = [1,2,3,4]
a[0:2] // [1,2]

슬라이싱도 문자열과 같은 원리이다.

 

<리스트 값 수정 및 삭제>

a = [1,2,3]
a[0] = 4
a // [4,2,3]

del a[1:]
a // [4]

수정은 그냥 원하는 인덱스를 정의하면 되고

삭제는 del함수를 이용해서 할 수 있다.

 

<리스트 관련 함수>

1. append

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

append(x)는 리스트의 마지막에 x 값을 추가해준다.

 

2. sort

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

sort함수는 리스트를 정렬해준다.

문자열도 알파벳 순으로 정렬해준다.

 

3. reverse

a = [1,2,3]
a.reverse()
a // [3,2,1]

reverse함수는 리스트를 거꾸로 뒤집는다.

 

4. index

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

index(x)는 리스트 안에서 x가 몇번째에 있는지 찾아준다.

 

5. insert

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

insert(x, y)는 x번째에 y값을 삽입한다.

 

6. remove

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

remove(x)는 리스트 안에서 x를 제거한다.

 

7. pop

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

pop(x)는 리스트에서 x번째 값을 제거한다. 

그냥 pop()으로 쓰면 마지막 원소를 제거한다.

 

8. count

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

count(x)는 리스트 안에 x가 몇개 있는지 세어주는 함수이다.

 

9. extend

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

extend는 리스트를 더하는 함수이다.

a.extend(x)는 a+=x와 동일한 의미이다.

 

2-4 튜플 자료형

<튜플 생성>

t1 = ()
t2 = (1,)
t3 = (1,2,3)
t4 = 1,2,3

튜플은 리스트와 거의 같지만 []대신 ()를 사용하고,

소괄호를 생략해서 쓸수도 있다. 

그리고 요소가 1개만 있을 때는 , 를 붙여야 한다.

튜플과 리스트의 차이는 요소값의 변경 가능성이다.

리스트는 안에 있는 값을 마음대로 바꿀수 있지만 튜플은 바꿀 수 없다.

튜플의 인덱싱, 슬라이싱이나 연산 등은 리스트와 모두 동일하기 때문에 넘어가겠다.

 

2-5 딕셔너리 자료형

<딕셔너리>

딕셔너리는 key와 value가 쌍으로 이루어진 데이터의 집합이다.

dic = {'key1': 'value1', 'key2': 'value2'}

딕셔너리의 기본적인 형태는 key:value가 쉼표로 구분되어 나열되어 있는 형태이다.

 

<딕셔너리 쌍 추가>

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

쌍 추가는 리스트와 비슷한데, 인덱스를 넣는 것이 아니라 키를 넣어주면 된다.

 

<딕셔너리 요소 삭제>

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

요소 삭제는 del함수를 이용해 할 수 있다.

 

**딕셔너리에는 key가 중복으로 들어갈 수 없다.

그리고 key로 리스트는 쓸 수 없지만 튜플은 쓸 수 없다. key가 변하면 안된다는 특성 때문이다.

 

<딕셔너리 관련 함수>

a = {'key': 'value', 'aaa': 'bbb'}
a.keys()
dict_keys(['key', 'aaa'])

a.keys()는 딕셔너리 a의 key들을 모아 객체를 리턴한다.

리스트 형태로 리턴받고 싶으면 list(a.keys())로 쓰면 된다.

a.values()
dict_values(['value', 'bbb'])

a.values는 딕셔너리 a의 value값들을 모아 객체를 리턴한다.

a.items()
dict_items([('key', 'value'), ('aaa', 'bbb')])

items 함수는 key, value쌍을 튜플로 만든 값을 객체로 리턴한다.

a.clear()
{}

clear 함수는 딕셔너리의 모든 요소를 삭제한다.

a.get('key')
value

get 함수는 key에 대응되는 value값을 반환한다. 

a['key']와 동일한 결과이지만, 딕셔너리에 존재하지 않는 키를 입력했을 때

a['key']는 에러가 나지만 get 함수는 None을 리턴한다는 차이점이 있다.

'key' in a
True
'key1' in a
False

in 함수는 딕셔너리 안에 해당 key가 있는지 조사하고 True, False로 리턴한다.

 

2-6 집합 자료형

<집합 자료형 생성>

s = set([1,2,3])
s2 = set("Hello")
s2 //{'e', 'H', 'l', 'o'}

집합 자료형은 set으로 생성한다. 

문자열을 입력해서 만들 수도 있다.

집합 자료형은 순서가 없고, 중복을 허용하지 않기 때문에 Hello로 만든 set이 저런 결과를 낸다.

 

<교집합 구하기>

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

s1 & s2
{4,5,6}
s1.intersection(s2)
{4,5,6}

&연산자를 이용하거나 intersection 함수를 사용하면 된다.

 

<합집합 구하기>

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

| 연산자를 이용하거나 union 함수를 사용하면 된다.

 

<차집합 구하기>

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

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

add함수를 이용해 set에 1개의 값을 추가할 수 있다.

 

2. update

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

update 함수를 이용하면 한번에 여러 개의 값을 추가할 수 있다.

 

3. remove

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

remove 함수를 이용해 특정 값을 제거할 수 있다.

 

2-7 불 자료형

bool 자료형은 참(True), 거짓(False)를 나타내는 자료형이다.

문자열, 리스트, 튜플, 딕셔너리 등의 자료형에서 값이 비어있으면 거짓이 되고,

비어있지 않으면 참이 된다.

 

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

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

파이썬은 변수에 저장된 값을 알아서 판단하고 자료형의 타입을 지정해주기 때문에 편리하다.

 

<리스트 복사>

a = [1,2,3]
b = a
id(a) == id(b)
True

b = a를 통해 변수를 대입해 같은 리스트를 만들 수 있다.

이렇게 하면 변수의 주소인 id도 같게 된다.

a[0] = 4
b[0] //4

하지만 이렇게 하면, a의 값을 바꿔도 b의 값이 같이 바뀌어 버린다는 문제점이 생긴다.

이 문제점을 해결할 수 있는 2가지 방법이 있다.

1. [:] 이용

b = a[:]

이렇게 하면 a[:]는 변수 a 그 자체가 아니라 리스트의 값 전체를 가리키기 때문에 값만 복사할 수 있다.

 

2. copy 이용

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

copy 모듈을 불러와서 copy함수를 사용하면 리스트 값을 복사할 수 있다.