[코테] 자주 쓰이는 라이브러리 정리

itertools : 조합, 중복조합, 순열, 중복순열 구하기

1. combinations(조합)

iterable 객체와 조합을 만들 갯수를 던져주면, 객체 안의 원소로 만들 수 있는 모든 순열 반환

from itertools import combinations
def combi(n):
    for i in combinations(n, 2): # n의 원소 중 2개로 만들 수 있는 조합
        print(i)

if __name__ == '__main__':
    n = [1, 2, 3, 4]
    combi(n)
출력:
(1, 2)
(1, 3)
(1, 4)
(2, 3)
(2, 4)
(3, 4)

2. permutations(순열)

iterable 객체와 순열을 만들 갯수를 던져주면, 객체 안의 원소로 만들 수 있는 모둔 순열 반환

from itertools import permutations
def permu(n):
    for i in permutations(n, 2): # n의 원소 중 2개로 만들 수 있는 순열
        print(i)

if __name__ == '__main__':
    n = [1, 2, 3, 4]
    permu(n)
출력:
(1, 2)
(1, 3)
(1, 4)
(2, 1)
(2, 3)
(2, 4)
(3, 1)
(3, 2)
(3, 4)
(4, 1)
(4, 2)
(4, 3)

3. product(중복순열)

iterable 객체와 순열을 만들 갯수를 던져주면, 객체 안의 원소로 만들 수 있는 모둔 중복 순열 반환

from itertools import product
def prod(n):
    for i in product(n, repeat=2): # 반복은 'repeat'로 주어야 한다.
        print(i)

if __name__ == '__main__':
    n = [1, 2, 3, 4]
    prod(n)
출력:
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 1)
(3, 2)
(3, 3)
(3, 4)
(4, 1)
(4, 2)
(4, 3)
(4, 4)

product에 iterator 객체를 넣으면 넣은 객체 수 만큼 중복 반복문이 실행된다.

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

# 1
for i, j, k in product(a, b, c):
	print(i, j, k)
# 2
for i in a:
	for j in b:
    	for k in c:
        	print(i, j, k)
 #1과 #2는 같은 값을 반환한다. 
 
 그래서 처음 예시의 for i product(n, repeat=2) 것은 
 for i, j in product(n, n)과 같고
 for i in n:
 	for j in n:
    	print(i, j)
와 같다.
zip 함수와 다르게 작동하면서 차이점을 알아두면 사용하기 편하다.

4. combinations_with_replacement(중복조합)

iterable 객체와 순열을 만들 갯수를 던져주면, 객체 안의 원소로 만들 수 있는 모둔 중복 조합 반환

from itertools import combinations, permutations, product, combinations_with_replacement
def combi(n):
    for i in combinations_with_replacement(n, 2):
        print(i)

if __name__ == '__main__':
    n = [1, 2, 3, 4]
    combi(n)
출력:
(1, 1)
(1, 2)
(1, 3)
(1, 4)
(2, 2)
(2, 3)
(2, 4)
(3, 3)
(3, 4)
(4, 4)

heapq

우선순위 큐

collections

1. deque

큐 자료구조

2. defaultdict

defaultdict(인자)는 인자로 주어진 function을 딕셔너리의 초기값으로 설정한다.
int, list. set 이 자주 쓰인다.

2.1 int

defaultdict(int)
딕셔너리의 key값을 넣으면, value가 '0'으로 자동으로 초기화가 된 딕셔너리가 생성.
같은 key 값이 몇 번 입력되는지 확인할 때 자주 쓰이는다.

from collections import defaultdict
def defaultd(n):
    dH = defaultdict(int)
    for i in n:
        dH[i] += 1 # key가 i인 값에 1을 더한다
    print(dH)

if __name__ == '__main__':
    n = ['a', 'b', 'c', 'd', 'a', 'a', 'b']
    defaultd(n)
출력:
defaultdict(<class 'int'>, {'a': 3, 'b': 2, 'c': 1, 'd': 1})

2.2 list

딕셔너리의 key값을 넣으면, value가 [ ](빈 리스트)로 초기화가 된 딕셔너리가 생성
같은 key값에 원소값 하나하나를 확인해야 할 때 자주 쓰인다.

from collections import defaultdict
def defaultd(n):
    dH = defaultdict(list)
    for i in n:
        dH[i].append(i)
    print(dH)

if __name__ == '__main__':
    n = ['a', 'b', 'c', 'd', 'a', 'a', 'b']
    defaultd(n)
출력:
defaultdict(<class 'list'>, {'a': ['a', 'a', 'a'], 'b': ['b', 'b'], 'c': ['c'], 'd': ['d']})

2.3 set

딕셔너리의 key값을 넣으면, value가 set()로 초기화가 된 딕셔너리가 생성
같은 key값에 들어오는 원소의 중복을 없앨 때 자주 사용된다.

from collections import defaultdict
def defaultd(n):
    dH = defaultdict(set)
    for i in n:
        dH[i].add(i)
    print(dH)

if __name__ == '__main__':
    n = ['a', 'b', 'c', 'd', 'a', 'a', 'b']
    defaultd(n)
출력:
defaultdict(<class 'set'>, {'a': {'a'}, 'b': {'b'}, 'c': {'c'}, 'd': {'d'}})

2.4 초기값 바꾸기

value값에 직접 입력을 해주면 초기 설정값은 입력값으로 바뀐다.

from collections import defaultdict
def defaultd(n):
    dH = defaultdict(list)
    for i in n:
        if i == 'a' or i == 'b':
            dH[i] = 'value'
        else:
            dH[i].append(i)
    print(dH)

if __name__ == '__main__':
    n = ['a', 'b', 'c', 'd', 'a', 'a', 'b']
    defaultd(n)
출력:
defaultdict(<class 'list'>, {'a': 'value', 'b': 'value', 'c': ['c'], 'd': ['d']})

3. Counter

변수 안의 원소의 수를 세어서 원소는 key로 수는 value로 즉, dict형으로 반환해준다.
반환할 때의 순서는 value의 값을 기준으로 내림차순으로 정렬하여 반환한다.

from collections import Counter

# 1. 문자열
strH = ['this', 'is', 'python', 'python', 'is', 'good', 'python', 'is', 'python', 'good']
print(Counter(strH))
출력:
Counter({'python': 4, 'is': 3, 'good': 2, 'this': 1})

# 2. set
sH = {1, 2, 3, 4, 1, 2, 3, 4, 'a', 'b', 'c', 'c', 'c'}
print(Counter(sH))
출력:
Counter({'b': 1, 1: 1, 2: 1, 3: 1, 4: 1, 'c': 1, 'a': 1})

# 3. dict
dH = {'a':2, 'b':1, 'c':5, 'd':3}
print(Counter(dH))
출력:
Counter({'c': 5, 'd': 3, 'a': 2, 'b': 1})

math(수학)

올림

import math
print((math.ceil(4.1))) # 출력: 5

내림

import math
print((math.floor(4.9))) # 출력: 4

반올림(주의)

문제는 '0.5'가 올림해서 짝수이면 올림하고 홀수이면 내림을 한다.
0.5보다 조금이라도 높거나 낮다면 정상적으로 반올림한다.

print((round(4.5))) # 출력: 4
print((round(3.5))) # 출력: 4
print((round(4.50001))) # 출력: 5, '0.5'보다 높다면 정상대로 반올림