파이썬 문법 정리 - 자료형

1. 자료형

수 자료형

• 기본적인 자료형으로, 정수형과 실수형으로 사용되는데 대부분 정수형으로 출제되며 실수형을 다루는 문제는 출제빈도가 낮다.

• 정수형 (Integer) : 정수를 다루는 자료형. 양의 정수, 음의 정수, 0이 있다.

a = 100 # 양의 정수
print(a)

b = -900 # 음의 정수
print(b)

c = 0 # 0
print(c)

100
-900
0

• 실수형 (real number) : 소수점 아래의 데이터를 포함하는 수 자료형. 파이썬에서는 변수에 소수점을 붙인 수를 대입 시 실수형 변수로 처리.

a = 123.45 # 양의 실수
print(a)

b = -543.21 # 음의 실수
print(b)

c = 3. # 소수부가 0일 때 0 생략하기 (실수형 변수로 처리)
print(c)

d = -.8 # 정수부가 0일 때 0 생략하기 (실수형 변수로 처리)
print(d)

123.45
-543.21
3.0
-0.8

실수형 데이터 표현 방식으로 e 또는 E를 이용하여 지수 표현법을 이용 가능.
ex) 1e8 = 10의 8제곱 (e다음에 오는 수가 10의 지수부)
이를 이용해 큰수를 함축하여 INF(무한)을 표현하기도 한다.

a = 1e8 # 1억의 지수 표현 방식
print(a)

b = 25.39e1
print(b)

c = 2794e-3
print(c)

100000000.0
253.9
2.794

컴퓨터 시스템은 수 데이터를 2진수로 처리하여 부동 소수점 방식을 이용하는데, 이로 인해 실수 정보 표현에 정확도가 한계가 있다. 2진수로 정확히 표현하지 못하는 수에 대해 미세한 오차가 발생하는 경우가 존재하고 이를 인지해둘 필요가 있다.

a = 0.3 + 0.6
print(a)

if a == 0.9:
	print(True)
else:
	print(False)

0.8999999999999999
False

따라서 소수점 값을 비교하는 작업이 필요하다면, 반올림을 이용하여 필요한 결과를 얻을 수 있다. round() 함수를 이용하게 되는데, ()안에 첫 번째 인자는 실수형 데이터, 두 번째 인자는 반올림하고자 하는 위치 -1을 넣으면 된다.

ex) 123.456을 소수점 셋째 자리에서 반올림한다면
round(123.456, 2)이고, 결과는 123.46 이다. (두번째 인자가 없으면 소수점 첫째 자리 반올림)

코딩 테스트 문제에서 실수형 데이터를 비교할 때 보통 소수점 다섯 번째 자리에서 반올림한 결과가 같으면 정답으로 인정하는 식이다.

a = 0.3 + 0.6
print(round(a, 4))

if round(a,4) == 0.9:
	print(True)
else:
	print(False)

0.9
True

• 수 자료형의 연산
  : 프로그래밍에서는 사칙연산(+, -, x, /) 으로 수를 계산한다.
  주의할 부분은 나누기 연산자는 기본적으로 결과를 실수형으로 처리하며,
  나머지와 몫을 구하는 방법은 따로 존재한다.

a = 7
b = 3

print(a/b) # 일반적인 나누기
print(a%b) # 나머지
print(a//b) # 몫

2.333333333333333335
1
2

또한, 거듭제곱 연산자 ** 도 있고 그 외에 다양한 연산자들이 있다.

a = 4
b = 3

print(a ** b)

64

리스트 자료형

• 여러 개의 데이터를 연속적으로 담아 처리하기 위해 사용한다.
• 파이썬의 리스트 자료형은 C나 자바처럼 내부적으로 배열을 채택하고 있다.

• 리스트 만들기
  : 대괄호 [ ] 안에 원소를 넣어 초기화하고, 쉼표로 원소를 구분한다.
  원소에 접근할 때는 인덱 값을 괄호에 넣고, 인덱스 시작은 0 이다.
  
  비어 있는 리스트 선언 : list() 또는 []
  

a = [1, 2, 3, 4, 5, 6]  # 리스트 선언
print(a)

print(a[3]) # 3번 인덱스의 원소에 접근 = 4번째 원소에 접근함.

a = list()  # 비어있는 리스트 선언 시 (1)
print(a)

a = []      # 비어있는 리스트 선언 시 (2)
print(a)

[1, 2, 3, 4, 5, 6]
4
[]
[]

크기가 N인 1차원 리스트를 초기화하는 코딩 테스트 문제에서는 다음과 같이 작성한다.

n = 15
a = [0] * n
print(a)

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

• 리스트의 인덱싱 / 슬라이싱
  : 인덱싱이란, 인덱스값을 입력하여 리스트의 특정 원소에 접근하는 것이다.
  이 인덱스 값은 양의 정수, 음의 정수 모두 사용 가능하며 음의 정수는 거꾸로 탐색한다.
  인덱싱을 활용하여 특정 원소의 값을 바꾸거나 출력할 수 있다.

a = [1, 2, 3, 4, 5, 6, 7, 8]

print(a[2])   # 인덱스 2번 = 앞에서 3번째 원소 출력
print(a[-3])  # 인덱스 -3번 = 뒤에서 3번째 원소 출력

a[4] = 9      # 인덱스 4번 값 변경 = 앞에서 5번째 원소 변경
print(a)

3
6
[1, 2, 3, 4, 9, 6, 7, 8]

다음으로 슬라이싱은 연속적인 위치를 갖는 원소들을 가져올 때 사용한다.
대괄호 내에 콜론 : 을 넣어 시작 인덱스와 끝 인덱스를 설정할 수 있다.

예를 들어 3번째 요소부터 5번째 요소까지라면 a[2 : 5] 이다.
인덱스의 시작이 0이므로 0, 1, 2 로 3번째부터 시작이고, 끝 인덱스는
1을 뺀 값의 인덱스까지 처리되어 5-1 = 4의 인덱스 위치까지 (2, 3, 4) 번 원소들을
슬라이싱 하게 되는 것이다.

a = [1, 2, 3, 4, 5, 6, 7, 8]

print(a[2:5]) # 3번째 요소부터 5번째 요소까지 출력
              # 2번 인덱스부터 5-1=4번 인덱스까지 출력

[3, 4, 5]

• 리스트 컴프리헨션
  : 대괄호 안에 조건문과 반복문을 넣어서 리스트를 초기화하는 방법을 리스트 컴프리헨션이라고 한다. 한 줄의 소스코드로 리스트를 초기화하므로 일반적인 소스코드로 작성하는 것보다 간편하고 간결하다.

array1 = [i for i in range(10) if i % 2 == 1] 
# if문과 for문을 [] 안에 넣어 리스트 컴프리헨션 활용 (0~9까지 수 중 홀수만 포함)

print(array1)

array2 = [i * i for i in range(1,10)]
# for문과 수식을 [] 안에 넣어 리스트 컴프리헨션 활용 (0~9까지 제곱값 포함)

print(array2)

[1, 3, 5, 7, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81]

또한 2차원 리스트 초기화에 효과적으로 사용된다.

n = 3
m = 5

array3 = [[0] * m for _ in range(n)]
# n * m 크기의 2차원 리스트 초기화 (n이 행, m이 열)
# 언더바(_)는 반복을 수행하되 반복을 위한 변수의 값을 무시하고자 할 때 사용
# 단순히 range만큼 반복하는 코드이므로, 변수를 따로 만들지 않고 _를 적는다.

print(array3)

[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]

특정 크기의 2차원 리스트 초기화 시에는 반드시 리스트 컴프리헨션을 이용해야한다.
다음의 결과를 보면 원하지 않은 초기화가 되었음을 확인할 수 있다.

n = 3
m = 5

array = [[0] * m] * n  # 잘못된 초기화 방법
print(array)

array[1][1] = 3
print(array)

[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[0, 3, 0, 0, 0], [0, 3, 0, 0, 0], [0, 3, 0, 0, 0]]

실행결과를 보면 모든 행의 2번째 원소가 같은 값을 가지게 되는데,
이는 내부적으로 3개의 리스트가 동일 객체로 인식되었기 때문이다.
리스트 컴프리헨션으로 작성하면 각각 다른 객체로 초기화되기에 이를 이용하여야한다.

• 리스트 관련 메서드

a = [1, 5, 2]
print("기본 :", a)

a.append(3)   # append() : 리스트에 원소를 하나 삽입할 때 사용
print("원소 삽입 : ", a)

a.sort()   # sort() : 오름차순으로 정렬
print("오름차순 정렬 : ", a)

a.sort(reverse = True)  # 내림차순 정렬 시 sort(reverse = True) 작성
print("내림차순 정렬 : ", a)

a.reverse()   # reverse() : 리스트 순서를 모두 뒤집음
print("순서 뒤집기 : ", a)

a.insert(2,3)   # insert() : 특정 인덱스 위치에 원소 삽입
print("인덱스 2에 3 추가: ", a)

print("값이 3인 데이터 수 : ", a.count(3))
# count() : 리스트에서 특정 값을 가지는 데이터 개수 세기

a.remove(1) # remove() : 특정 값을 갖는 원소 제거 (값을 가진 원소 여러개면 하나만 제거)
print("값이 1인 데이터 삭제 : ", a)

기본 : [1, 5, 2]
원소 삽입 : [1, 5, 2, 3]
오름차순 정렬 : [1, 2, 3, 5]
내림차순 정렬 : [5, 3, 2, 1]
순서 뒤집기 : [1, 2, 3, 5]
인덱스 2에 3 추가: [1, 2, 3, 3, 5]
값이 3인 데이터 수 : 2
값이 1인 데이터 삭제 : [2, 3, 3, 5]

insert() 는 원소의 개수가 N개일 때, 시간 복잡도가 O(N)이다.
원소 삽입 후 원소 위치를 조정해줘야 하기 때문이다.
append() 는 시간 복잡도가 O(1) 이므로 append()를 사용해도 되는 문제에
insert() 를 남발하게 되면 시간 초과가 될 수 있으니 주의.
(remove()도 insert()와 마찬가지로 시간 복잡도가 O(N)이다.)

추가로, 특정 값의 원소를 모두 제거하려면 리스트 컴프리헨션의 if문을 이용하면 된다.

array = [1, 2, 2, 2, 3, 4, 5, 5]
remove_set = [2, 5]    # remove 하고 싶은 값들의 리스트
 
result = [i for i in array if i not in remove_set]
# remove_set에 포함 되지않는 array의 값들만 result에 저장
print(result)

[1, 3, 4]

문자열 자료형

• 문자열 초기화
  : 문자열 변수 초기화시 " 나 ' 를 이용한다. 문자열 안에 " 나 ' 가 있으면 이스케이프 문자인 백슬래시를 사용하여야 문자열 내부에 포함 시킬 수 있다.

data = 'data everywhere'
print(data)

data = "don't you know \"database\"?"
print(data)

data everywhere
don't you know "database"?

• 문자열 연산
  : 파이썬은 문자열 연산도 지원한다. 덧셈을 이용하면 단순히 뒤의 문자열이 더해져서 연결되며, 양의 정수와 문자열을 곱하면 문자열이 그만큼 여러 번 더해지게 된다.

a = "Lovely"
b = "World"

print(a + " " + b)

print(a * 3)

Lovely World
LovelyLovelyLovely

문자열은 내부적으로 리스트와 같이 처리되므로 인덱싱, 슬라이싱이 가능하다.

a = "ABCDEFG"

print(a[2:5])

CDE

튜플 자료형

튜플 자료형은 리스트와 거의 비슷하지만 한 번 선언된 값을 변경할 수 없고, 대괄호 대신 소괄호 () 를 이용한다.

튜플 데이터를 수정하는 코드를 작성해보면 원소의 대입이 불가능하여 선언된 값을 변경할 수 없다는 오류 메시지가 나오게 된다.

a = (1, 2, 3, 4, 5)
print(a)

a[1] = 6

TypeError: 'tuple' object does not support item assignment

따라서 다익스트라 최단 경로 알고리즘과 같은 그래프 알고리즘을 구현할 때는 한 번 들어간 우선순위 큐 값이 바뀌지 않기 때문에 튜플 자료형을 사용하여 작성하게 된다. 튜플이 리스트에 비해 공간 효율적이고 원소의 성질이 서로 다를 때 주로 사용한다. 예를 들어 비용과 노드번호를 튜플로 묶어서 관리한다.

사전 자료형

사전 자료형은 키와 값의 쌍을 데이터로 가지는 자료형이다. 리스트와 튜플은 순차적으로 저장하여 순서가 있지만, 사전 자료형은 키를 통해 값을 찾고 순서가 없다. 내부적으로 해시 테이블을 이용하므로 O(1)의 시간 복잡도를 가진다. 키-값을 쌍으로 가지는 데이터 처리에는 리스트보다 훨씬 빠르게 동작한다.

data = dict()

data['꽃'] = 'flower'
data['괴물'] = 'monster'
data['햄스터'] = 'hamster'

print(data)

if '꽃' in data:  # 특정한 원소가 있는지 검사할 때, 원소 in 사전 이용
    print(" '꽃'을 키로 가지는 데이터 존재함.")

{'꽃': 'flower', '괴물': 'monster', '햄스터': 'hamster'}
'꽃'을 키로 가지는 데이터 존재함.

• 사전 자료형 관련 함수
  키와 값을 따로 뽑아서 활용하는 함수가 있다. keys() 함수는 키 데이터만 뽑아서, values() 함수는 값 데이터만 뽑아서 리스트로 사용한다.

data = dict()

data['꽃'] = 'flower'
data['괴물'] = 'monster'
data['햄스터'] = 'hamster'

key_list = data.keys()     # 키 데이터를 담은 리스트
value_list = data.values() # 값 데이터를 담은 리스트

print(key_list)
print(value_list)

for key in key_list:  # 각 키에 따른 값을 하나씩 출력
  print(data[key])

dict_keys(['꽃', '괴물', '햄스터'])
dict_values(['flower', 'monster', 'hamster'])
flower
monster
hamster

집합 자료형

집합 자료형이란 집합을 처리하기 위해 제공하며 기본적으로 리스트나 문자열을 이용하여 만든다. 중복을 허용하지않으며 순서가 없다는 특징이 있다. 사전 자료형과 다른 점은 키가 존재하지 않고, 값 데이터만을 담는다.
특정한 데이터가 이미 등장한 적이 있는지 여부를 알고 싶을 때 효과적이며, 초기화 시에는 set() 함수를 이용하거나 {} 중괄호를 이용하여 초기화한다.

data = set([1, 1, 2, 2, 3, 4, 4, 4, 5])

print(data)

data = {1, 1, 2, 2, 3, 4, 4, 4, 5}

print(data)

{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}

• 집합 자료형의 연산
  : 합집합, 교집합, 차집합 연산이 있고, 합집합은 | , 교집합은 &, 차집합은 - 로 이용한다.

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

print(a|b)
print(a&b)
print(a-b)

{1, 2, 3, 4, 5, 6, 7, 8, 9}
{5}
{1, 2, 3, 4}

• 집합 자료형 관련 함수
  : add() 함수를 통해 값을 추가하거나, update() 함수를 통해 여러 개의 값을 한꺼번에 추가하고, remove() 함수로 특정 값을 제거한다. (add()와 remove()는 시간 복잡도가 O(1))

data = set([1,2,3,4])
print(data)

data.add(5)
print(data)

data.update([6, 7])
print(data)

data.remove(2)
print(data)

{1, 2, 3, 4}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6, 7}
{1, 3, 4, 5, 6, 7}

참고서적 : 이것이 코딩 테스트다 with 파이썬 / 나동빈