[Python] 기본 문법 - 자료형

'이것이 취업을 위한 코딩 테스트다 with 파이썬 - 부록A' 와 '점프 투 파이썬' 을 참고하여 정리한 내용입니다.

1. 자료형

👉 수(Number) 자료형

정수형

• 양의 정수, 음의 정수, 0 이 있다.
• 정수형으로 변환할려면 int()를 이용한다.
• 불변 객체 (immutable object) 

 

실수형

• 아래와 같이 소수점을 이용하여 표현
• 소수부가 0 이거나 정수부가 0인 경우 생략할 수 있다.
• 실수형으로 변환할려면 float()를 이용한다.
• 불변 객체 (immutable object) 

a = 52.6
b = 7. # 7.0
c = .7 # 0.7
d = -.25 # -0.25

 

• e 는 10의 지수부를 의미하고, 실수형으로 표현된다.

a = 1e3 # 1000.0
b = 5e1 # 50.0
c = 73.456e2 # 7345.6
d = 1e-3 # 0.001

 

• 컴퓨터 시스템은 2진수를 이용하기 때문에 실수 정보를 표현하는데 한계가 있다. 
• 실수 값을 비교할 때 round 함수를 이용한다.

a = 0.3 + 0.6 # 0.8999999999999999
b = round(a, 4) # 소수점 다섯째 자리에서 반올림 한다. b=0.9

 

수 연산

• 사칙연산 ( +, -, *, / )
• 나눗셈 연산자 '/' 는 소수점 형태의 결과값을 얻기 위해서는 한 개의 값이상이 실수여야 한다.
• a ** b ( a의 b승 )
• % : 나머지,  // : 몫
• += 가능

 

---

 

👉 리스트(List) 자료형

리스트 선언

a = [1,2,3,4]
b = list() # 빈 리스트 선언

 

인덱싱과 슬라이싱

• 인덱싱: 인덱스 값을 입력하여 리스트의 특정한 원소에 접근하는 것. 인덱스 값은 0부터 시작한다.

   a[0] : 첫번째 원소,  a[3] : 네번째 원소, a[-1] : 뒤에서 첫번째 원소, a[-2] : 뒤에서 두번째 원소

• 슬라이싱: 리스트에서 연속적인 위치를 갖는 원소들을 가져오는 것. a[c:d] 라면 c부터 d-1까지의 원소를 가지는 리스트를 반환한다.
• 순서가 있기 때문에 인덱싱과 슬라이싱으로 값을 얻을 수 있다.

a = [1,2,3,4,5,6]
print(a[:3]) # [1,2,3]
print(a[2:5]) # [3,4,5]
print(a[2:]) # [3,4,5,6]

a = [1,2,3,['long','short','thin']]
print(a[3]) # ['long','short','thin']
print(a[-1][2]) # thin

a = [1,2,[2,4,['a','b']]]
print(a[2]) # [2,4,['a','b']]
print(a[-1]) # [2,4,['a','b']]
print(a[-1][2]) # ['a','b']
print(a[2][2][0]) # a

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

 

• 리스트는 가변 객체 (mutable object) 이므로 인덱싱이나 슬라이싱으로 원소 값을 변경할 수 있다.

# 리스트 원소 변경
a = [1,2,3,4]
a[2] = 5 
print(a) # [1,2,5,4]
a[1:4] = [6,7,8] 
print(a) # [1,6,7,8]
a[1:2] = ['a','b','c']
print(a) # [1,'a','b','c',7,8]
b = [1,6,7,8]
b[1] = ['a','b','c']
print(b) # [1,['a','b','c'],7,8]

# 리스트 원소 삭제
a[1:3] = []
print(a) # [1,'c',7,8]
del a[1] 
print(a) # [1,7,8]
del a[1:3]
print(a) # [1]

 

리스트 더하고 반복하기

a = [1,2,3]
b = [4,5,6]
c = a+b # [1,2,3,4,5,6]
d = a*2 # [1,2,3,1,2,3]

 

리스트 컴프리헨션

• [] 안에 조건문과 반복문을 넣는 방식으로 리스트 초기화

arr = [i for i in range(5)] # [0,1,2,3,4]
arr2 = [i*i for i in range(5)] # [0,1,4,9,16]
arr3 = [i for i in range(10) if i % 2 == 1] # [1,3,5,7,9]

 

• 2차원 리스트 초기화

# row * col (3행 4열 리스트)
row,col = 3,4
d = [[0]*col for _ in range(row)]
print(d) # [[0,0,0,0],[0,0,0,0],[0,0,0,0]]
d[0][2] = 1
print(d) # [[0,0,1,0],[0,0,0,0],[0,0,0,0]]

 

• 2차원 리스트 초기화 잘못된 방법

# 리스트 초기화의 잘못된 방법
arr = [[0]*col]*row
arr[1][1] = 5
print(arr) # [[0,5,0,0], [0,5,0,0], [0,5,0,0]]

3개의 리스트가 모두 동일한 객체에 대한 레퍼런스로 인식되어 arr은 3개의 모든 리스트의 두번째 원소가 바뀐다.

 

리스트 관련 함수

함수	설명	시간복잡도 (N: 리스트 원소 수)
len(a)	리스트 a의 길이를 반환	O(1)
a.append(x)	리스트 a의 마지막에 x 추가	O(1)
a.pop()	리스트 a의 마지막 원소를 삭제	O(1)
a.pop(0)	리스트 a의 첫번째 원소를 삭제	O(N)
a.sort()	리스트 a를 오름차순 정렬	O(NlogN)
a.sort(reverse=True)	리스트 a를 내림차순 정렬	O(NlogN)
a.reverse()	리스트 a의 순서를 뒤집는다	O(N)
a.index(x)	리스트 a에서 x가 처음 나오는 위치 인덱스 값 반환	O(N)
a.insert(i, x)	리스트 a에서 i 위치에 x 삽입	O(N)
a.remove(x)	리스트 a에서 처음 나오는 x 삭제 (하나만 삭제)	O(N)
a.count(x)	리스트 a에서 x의 개수를 반환	O(N)
a.extend(x)	리스트 a 끝에 리스트 x를 더함	O(len(x))

a = [1,1,3,4]
print(len(a)) # 4

a.append(7)
print(a) # [1,1,3,4,7]

a.pop()
print(a) # [1,1,3,4]

a.pop(0)
print(a) # [1,3,4]

b = [5,2,1,4]
b.sort() 
print(b) # [1,2,4,5]
b.sort(reverse=True) 
print(b) # [5,4,2,1]

b.reverse()
print(b) # [1,2,4,5]

c = [3,2,2,4]
print(c.index(2)) # 1
print(c.index(4)) # 3

c.insert(1,7) 
print(c) # [3,7,2,2,4]

d = [1,3,2,3]
d.remove(3) 
print(d) # [1,2,3]

print(c.count(2)) # 2

d.extend([4,5])
print(d) # [1,2,3,4,5]

시간복잡도가 O(N)인 함수를 남발하면 코딩테스트에서 시간초과될 수 있음
리스트에서 특정한 값의 원소를 모두 제거하려면 아래와 같은 방법을 이용하는 것이 좋음

a = [1,2,3,4,5,5,6,6]
remove_set = {2,5,6}

r = [i for i in a if i not in remove_set]
print(r) # [1,3,4]

 

---

 

👉 문자열(String) 자료형

문자열 초기화

• 큰따옴표(")나 작은따옴표(')를 이용
• 문자열 안에 큰따옴표가 포함 되어야 하는 경우 : 외부는 작은따옴표, 내부는 큰따옴표 사용
• 문자열 안에 작은따옴표가 포함 되어야 하는 경우 : 외부는 큰따옴표, 내부는 작은따옴표 사용
• '\' (역슬래시) 로 큰따옴표와 작은따옴표를 문자열에 포함시킬 수 있다.
• 줄바꿈 기호 : '\n'
• str() 함수를 이용하여 문자열로 바꿀 수 있다.

a = 'Hello World'
print(a) # Hello World
b = 'Hello "World"'
print(b) # Hello "World"
c = "Hello 'World'"
print(c) # Hello 'World'
d = 'Hello \'World\''
print(d) # Hello 'World'
e = 'Hello \nWorld'
print(e)
# Hello
# World

 

문자열 더하기 반복하기

a = "I'm"
b = "a student"
print(a+" "+b) # I'm a student

c = 'hungry'
print(c*3) # hungryhungryhungry

 

인덱싱과 슬라이싱

• 문자열은 여러개의 문자가 합쳐진 리스트라 볼 수 있다. (리스트처럼 인덱싱과 슬라이싱이 가능)
• 단, 문자열은 불변 객체 (immutable object)이므로 인덱싱이나 슬라이싱으로 원소 값을 변경할 수 없다.

a = 'Hello World'
print(a[0]) # H
print(a[-1]) # d
print(a[0:4]) # Hell
print(a[6:]) # World

a[3] = 'r' # 오류발생 (TypeError: 'str' object does not support item assignment)

 

문자열 포맷팅

• 문자열 포맷 코드

코드	설명
%s	문자열 (String)
%c	문자 한개 (Character)
%d	정수 (Integer)
%f	부동소수 (Floating-point), %.3f (소수점  셋째자리까지 표현, 넷째자리에서 반올림)
%o	8진수
%x	16진수

a = 3
print('I have %d apples'%(a)) # I have 3 apples
print('I have %2d apples'%(a)) # I have  3 apples

f = 2.567
print('Rate is %f'%(f)) # Rate is 2.567000
print('Rate is %.2f'%(f)) # Rate is 2.57

string = 'Number is %d and Rate is %.3f'%(a,f)
print(string) # Number is 3 and Rate is 2.567

 

f-string

• Python 3.6 이상의 버전부터 f-string 문법을 사용할 수 있다.

a = 3
f = 2.567
s1 = f"Number is {a} and Rate is {f}"
print(s1) # Number is 3 and Rate is 2.567

 

문자열 관련 함수

함수	설명
a.upper()	문자열 a를 모두 대문자로 바꾼 문자열을 반환.
a.count(x)	문자열 a중 x와 일치하는 것의 개수를 반환
a.find(x)	문자열 a중 문자 x가 처음으로 나온 위치를 반환. 없으면 -1 반환
a.index(x)	문자열 a중 문자 x가 처음으로 나온 위치를 반환. 없으면 에러 발생
a.join(s)	s라는 문자열의 각각의 원소 문자 사이에 문자열 a를 삽입한 결과를 반환
a.lower()	문자열 a를 모두 소문자로 바꾼 문자열을 반환
a.lstrip()	문자열 a의 왼쪽 공백을 모두 지운 문자열을 반환
a.rstrip()	문자열 a의 오른쪽 공백을 모두 지운 문자열을 반환
a.strip()	문자열 a의 양쪽 공백을 모두 지운 문자열을 반환
a.replace(s, r)	문자열 a의 s라는 문자열을 r이라는 문자열로 치환된 결과를 반환
a.split()	문자열 a를 공백으로 나눈 문자열들이 리스트의 원소가 되어 리스트를 반환
a.split('c')	문자열 a를 c문자로 나눈 문자열들이 리스트의 원소가 되어 리스트를 반환
a.swapscase()	문자열 a의 대문자는 소문자로, 소문자는 대문자로 각각 바꾸어 준 결과를 반환

a = 'hi'
print(a.upper()) # HI

a = 'append'
print(a.count('p')) # 2

a = 'Better than yesterday'
print(a.find('t')) # 2

a = 'Challenge whatever you want'
print(a.index('w')) # 10

a = ':'
print(a.join('abcd')) # a:b:c:d

a = 'HI'
print(a.lower()) # hi

a = ' hi'
print(a.lstrip()) # hi

a = 'hi '
print(a.rstrip()) # hi

a = ' hi '
print(a.strip()) # hi

a = 'Jane loves you'
print(a.replace('Jane','Joe')) # Joe loves you

a = 'Spring Summer Fall Winter'
print(a.split()) # ['Spring','Summer','Fall','Winter']

a = 'a:b:c:d'
print(a.split(':')) # ['a','b','c','d']

a = 'call ME'
print(a.swapcase()) # CALL me

 

---

 

👉 튜플(Tuple) 자료형

• () 를 이용하여 초기화 한다.
• 인덱싱, 슬라이싱, 더하기, 곱하기 등 리스트와 비슷하다.
• 단, 불변 객체 (immutable object)이므로 인덱싱이나 슬라이싱으로 원소 값을 변경할 수 없다.
• 값이 절대 변하면 안되거나 변하지 않고자 할 때 튜플을 사용하는 것이 좋다.

리스트에 비해 상대적으로 공간 효율적이고, 일반적으로 각 원소의 성질이 다를 때 주로 사용한다. 예를들어 다익스트라 최단 경로 알고리즘에서 서로 다른 성질을 가지는 '비용', '노드 번호' 라는 데이터를 (비용, 노드번호) 형태로 관리하는 경우가 많다.

# 튜플 초기화
t1 = ()
t2 = (1,2,3)
t3 = ('a','b',('c','d'))

# 인덱싱, 슬라이싱
t = (1,2,3,4)
print(t[0]) # 1
print(t[-1]) # 4
print(t[1:3]) # (2,3)

# 더하기, 반복하기
t2 = (5,6)
print(t+t2) # (1,2,3,4,5,6)
print(t2*2) # (5,6,5,6)

t[2] = 5 # TypeError: 'tuple' object does not support item assignment
del t[0] # TypeError: 'tuple' object doesn't support item deletion

 

---

 

👉 사전(Dictionary) 자료형

사전 자료형 이란?

• 키(Key)와 값(Value)의 쌍을 데이터로 가지는 자료형
• 순서가 없기 때문에 인덱싱으로 값을 얻을 수 없다. key를 통해서만 value를 얻는다. 
• key 값으로는 변경 불가능한 값만 사용할 수 있다. ( bool, int, float, string, tuple )

데이터 검색 및 수정에 있어서 시간복잡도가 O(1) 이다. 따라서 key-value 쌍으로 구성된 데이터를 처리하는데 리스트보다 훨씬 빠르게 동작한다.

data = dict() # 빈 딕셔너리 선언
print(data) # {}

dic = {'name':'dongsu','age':17,'height':177}
print(dic['age']) # 17

if 'age' in dic:
  print(True) # True

 

쌍 추가, 삭제

• 가변 객체(mutable object)로 값을 변경할 수 있다.
• key를 통해서만 쌍을 추가하고 삭제할 수 있다.

data = dict()
data['name'] = 'Dongsu'
print(data) # {'name':'Dongsu'}
data['age'] = 17 
print(data) # {'name':'Dongsu','age':17}
data['height'] = 177
print(data) # {'name':'Dongsu','age':17, 'height':177}
data['age'] = 27
print(data) # {'name':'Dongsu','age':27, 'height':177}

del data['age'] 
print(data) # {'name':'Dongsu', 'height':177}

 

딕셔너리 관련 함수

함수	설명
a.keys()	딕셔너리 a의 key들을 모아놓은 리스트를 반환
a.values()	딕셔너리 a의 value들을 모아놓은 리스트를 반환
a.items()	딕셔너리 a의 (key,value)쌍의 튜플을 모아놓은 리스트를 반환
a.clear()	딕셔너리 a의 모든 key:value 쌍들을 삭제
a.get(x)	딕셔너리 a의 key가 x인 것의 value를 반환

dic = {'name':'dongsu','age':17,'height':177}

print(dic.keys()) # dict_keys(['name', 'age', 'height'])

print(dic.values()) # dict_values(['dongsu', 17, 177])

print(dic.items()) # dict_items([('name', 'dongsu'), ('age', 17), ('height', 177)])

print(dic.get('age')) # 17

dic.clear()
print(dic) # {}

 

---

 

👉 집합(Set) 자료형

집합 자료형 이란?

• 집합(set)을 처리하기 위한 자료형
• 중복을 허용하지 않으며, 순서가 없다. 
• 리스트나 튜플은 순서가 있기 때문에 인덱싱으로 자료형의 값을 얻을 수 있는 반면, 사전 자료형과 집합 자료형은 순서가 없기 때문에 인덱싱으로 값을 얻을 수 없다.
• 사전 자료형과 달리 값 데이터만 담는다.
• 가변 객체 (mutable object) 이고, 아래 언급되는 집합 자료형 함수들을 이용하여 원소 값을 수정할 수 있다.

특정 원소가 존재하는지 검사하는 연산의 시간 복잡도가 O(1)이다. 따라서 집합 자료형은 특정한 데이터가 존재하는지 검사할 때에 매우 효과적이다.

data = set([1,1,2,3,3,4,5])
print(data) # {1,2,3,4,5} # 중복을 허용하지 않음

data = {1,1,2,3,3,4,5}
print(data) # {1,2,3,4,5}

data = {3,2,1,5,4}
print(data) # {1,2,3,4,5} # 순서가 없다

data = {'age','age','b','c'} 
print(data) # {'age', 'b', 'c'}

data = {'age','b','c','age'} 
print(data) # {'age', 'b', 'c'}

if 'b' in data:
  print(True) # True 출력
else:
  print(False)

if 'd' in data:
  print(True)
else:
  print(False) # False 출력

 

집합 자료형 연산

• 합집합: | , 교집합: & , 차집합: -

a = {1,2,3,4,5}
b = {3,4,5,6,7}

print(a | b) # {1,2,3,4,5,6,7}
print(a & b) # {3,4,5}
print(a - b) # {1,2}

 

집합자료형 관련 함수

함수	설명
a.add(x)	집합 a에 x를 추가
a.update(x)	집합 a에 x원소들을 추가
a.remove(x)	집합 a에서 x를 삭제

a = {1,3,6,7}
a.add(2)
print(a) # {1,2,3,6,7}

a.update([4,8])
print(a) # {1,2,3,4,6,7,8}

a.remove(6)
print(a) # {1,2,3,4,7,8}

 

---

 

👉 불(Bool) 자료형

불 자료형 이란?

• 참(True)와 거짓(False)를 나타내는 자료형
• True, False (파이썬에서는 true, false와 같이 사용하면 안된다. 항상 첫문자를 대문자로 사용)
• 조건문의 반환 값

 

자료형의 참과 거짓

• 자료형에는 참과 거짓이 있다.
• bool(자료형)을 이용하여 자료형의 참과 거짓을 식별할 수 있다.

자료형	True or False
""가 아닌 문자열	True
""	False
[]가 아닌 리스트, ()가 아닌 튜플, {}가 아닌 딕셔너리	True
[], (), {}	False
0이 아닌 숫자	True
0	False
None	False

a = [1,2,3,4]
print(bool(a)) # True
while a:
    a.pop()
    
print(a) # []
print(bool(a)) # False

 

---

 

👉 변수

변수란?

• 파이썬에서 변수는 객체(자료형)를 가리키는 것

a = [1, 2, 3] 에서 [1, 2, 3] 값을 가지는 리스트 객체가 자동으로 메모리에 생성된다. 변수 a는 [1, 2, 3] 리스트가 저장된 메모리 주소를 가리킨다.

• id(변수)를 통해 메모리의 주소를 확인할 수 있다.

 

리스트 복사

a = [1,2,3]
b = a
print(id(a)) # 140179082816960
print(id(b)) # 140179082816960

print(a is b) # True (a와 b가 가리키는 객체가 동일하다)

a[1] = 4

print(a) # [1,4,3]
print(b) # [1,4,3]

is는 동일한 객체를 가리키고 있는지에 대해서 판단하는 파이썬 명령어이다. 위 코드에서 a와 b는 동일한 객체를 가리킨다.  따라서 a의 요소를 바꾸면 b의 요소가 똑같이 바뀐다. 

• 리스트 객체에 대해서 변수의 값을 가져오면서 다른 주소를 가리키도록 하기 위해서 [:] 와 copy 모듈을 이용한다.

a = [1,2,3]
b = a[:]
a[1] = 4
print(a) # [1,4,3]
print(b) # [1,2,3]

from copy import copy

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

a[1] = 4
print(a) # [1,4,3]
print(b) # [1,2,3]
print(b is a) # False

 

스와프 (Swap)

• 파이썬에서는 C언어와 달리 별도의 변수 없이 두 변수 값을 교체 할 수 있다.

a = 1
b = 2
print(a, b) # 1 2
a, b = b, a
print(a,b) # 2 1

array = [3,5]
array[0],array[1] = array[1],array[0] # 0 인덱스와 1 인덱스의 원소 교체
print(array) # [5, 3]