자료형

연산

a = 7
b = 3

# 나누기
print(a / b) # 2.33333335

# 나머지
print(a % b) # 1

# 몫
print(a // b) # 2

리스트

list comprehension

# 0 ~ 19 의 수 중 홀수만 포함하는 리스트
array = [i for i in range(20) if i % 2 == 1]

print(array) # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

list method

이미지 출처 : https://product.kyobobook.co.kr/detail/S000001810273

sorted

특정 키에 따라 정렬할 수 있다.

result = sorted([('홍길동', 35), ('이순신', 75), ('아무개', 50)], key = lambda x: x[1], reverse= True)
print(result) # [('이순신', 75), ('홍길동', 35), ('아무개', 50)]

tip

• insert, remove 의 경우 O(N) 이 소요되니 제거할 때 set, list comprehension 을 이용하면 성능을 더 높일 수 있다.

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

# remove_set 에 포함되지 않은 값만을 저장
result = [i for i in a if i not in remove_set]
print(result) # [1, 2, 4]

버블 정렬 시간복잡도 - O(N^2) 비효율적이다.

선택 정렬 시간복잡도 - O(N^2), 버블정렬보다는 조금 더 빠르다

삽입 정렬 시간복잡도 - O(N) / 최악의 경우 O(N^2)

• 데이터의 상태, 크기에 따라 성능의 편차가 굉장히 심한 정렬법이다.

퀵 정렬 시간복잡도 - O(NlogN) / 최악의 경우 O(N^2)

• 분할할때 logN, 전체적으로 NlogN
• pivot 에 따라 시간복잡도가 크게 달라진다.

병합 정렬 시간복잡도 - O(NlogN)

• 항상 O(NlogN) 이다.
• 추가적인 메모리가 필요하다.

힙 정렬 시간복잡도 - O(NlogN) 효율적이다.

• 이상적인 경우 퀵 정렬보다 느리다.
• 데이터의 상태에 따라 다른 정렬보다 조금 느린 편이다.

기수 정렬 (radix sort) 시간복잡도 - O(N)

• 굉장히 빠르다.
• 버킷이라는 추가적인 메모리가 할당되어야 한다.
• 데이터 타입이 일정해야 한다.

시간복잡도 비교

이미지 출처 : https://joshuajangblog.wordpress.com/2016/09/21/time_complexity_big_o_in_easy_explanation/

사전

data = dict()
data['사과'] = 'Apple'
data['바나나'] = 'Banana'
data['코코넛'] = 'Coconut'

# 키 데이터만 담은 리스트
key_list = data.keys()
# 값 데이터만 담은 리스트
value_list = data.values()
# 각 키에 따른 값을 하나씩 출력
for key in key_list:
	print(data[key])
    
# 키가 존재하는지
if '사과' in data:
	# ...

집합

• 중복을 허용하지 않는다.
• 순서가 없다.

# 집합 자료형 초기화
data = set([1, 1, 2, 3, 4, 4, 5])
print(data) # {1, 2, 3, 4, 5}

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

집합 연산

a = set([1, 2, 3, 4, 5])
b = set([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}

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

# 새 원소 추가
data.add(4)

# 새 원소 여러 개 추가
data.update([5, 6])

# 특정한 값을 갖는 원소 삭제
data.remove(3)

집합 관련 참고 레퍼런스 - 모두의 케빈

조건문

in, not in

x in list:
	# ...
    
x not in list:
	# ...
    
a = [1, 2, 3, 4, 5, 5, 5]
remove_set = {3, 5}
result = [i for i in a if i not in remove_set]

print(result) # [1, 2, 4]

조건부 표현식

score = 85
result = 'Success' if score >= 80 else 'Fail'

함수

람다 표현식

특정한 기능을 수행하는 함수를 한 줄에 표현 가능하다.

# 일반적인 함수
def add(a, b):
	print('함수의 결과 : ', a + b)
    
add(b = 3, a = 7) # 매개변수의 순서가 달라도 상관 없다.

# 람다 표현식으로 구성한 add() 메서드
print((lambda a, b: a+ b)(3, 7)) # 10

입출력

# input
4
1 42 12 55

# output
12 42 1 55

# 주로 사용하는 기법
list(map(int, input().split()))

# 실제로 기본적으로 입력을 위한 코드

# 데이터의 개수 입력
N = int(input())
# 각 데이터를 공백으로 구분하여 입력
data = list(map(int, input().split()))

data.sort(reverse = True)

먼저 input() 으로 입력받은 문자열을 split() 을 통해 공백으로 나눈 리스트로 바꾼 뒤 map 을 이용하여 해당 리스트의 모든 원소에 int() 함수를 적용한다. 최종적으로 list() 를 다시 바꿔 입력받은 문자열을 띄어쓰기로 구분하여 각각 숫자 자료형으로 저장하는 코드이다.

공백을 기준으로 적은 수의 데이터 입력의 경우

# input
# 3 5 7

# n, m, k 를 공백으로 구분하여 입력
n, m, k = map(int, input().split())

더 나은 성능을 위해 sys 라이브러리 사용

파이썬의 input() 함수는 동작 속도가 느려서 sys 라이브러리의 sys.stdin.readline() 함수를 이용하고 마짐가에 rstip() 함수를 호출하여 공백 문자를 제거한다.

이 함수는 한줄한줄 입력받을 때 사용한다.

import sys

# 문자열 입력받기
data = sys.stdin.readline().rstrip()

추가로 정리한 알고리즘

2차원 리스트(행렬)를 90도 회전

def rotate_a_matrix_by_90_degree(a):
	row_length = len(a)
    column_length = len(a[0])
    
    res = [[0] * row_length for _ in range(column_length)]
    for r in range(row_length):
    	for c in range(column_length):
        	res[c][row_length - 1 - r] = a[r][c]
            
     return res
     
a = [
	[1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]

print(rotate_a_matrix_by_90_degree(a))

레퍼런스

blog
얍문's coding world - sort
book
이것이 취업을 위한 코딩 테스트다 with 파이썬