Python 내장함수 및 라이브러리

#for 반복문으로 2차원 리스트 만들기

a = []    # 빈 리스트 생성
for i in range(3):

    line = []              # 안쪽 리스트로 사용할 빈 리스트 생성

    for j in range(2):

        line.append(0)     # 안쪽 리스트에 0 추가

    a.append(line)         # 전체 리스트에 안쪽 리스트를 추가


print(a)
[[0, 0], [0, 0], [0, 0]]


# for문 줄이기
a = [[0 for j in range(2)] for i in range(3)]

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



#리스트 원소 개수만큼 리스트 만들기
a = [3, 1, 4, 3, 5]    # 가로 크기를 저장한 리스트

b = []    # 빈 리스트 생성
for i in a:      # 가로 크기를 저장한 리스트로 반복

    line = []    # 안쪽 리스트로 사용할 빈 리스트 생성

    for j in range(i):    # 리스트 a에 저장된 가로 크기만큼 반복

        line.append(0)

    b.append(line)        # 리스트 b에 안쪽 리스트를 추가

 

print(b)
[[0, 0, 0], [0], [0, 0, 0, 0], [0, 0, 0], [0, 0, 0, 0, 0]]



#리스트 표현식으로 표현해보기
a = [[0] * i for i in [3, 1, 4, 3, 5]]

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

# 중복 키 유지하기

from itertools import chain
from collections import defaultdict

dict1 = {'id': 110809386}

dict2 = {'bookC': ['free'], 'bookD': ["24"], 'bookE': ["5","3","4"]}

dict3 = defaultdict(list)
'''
defaultdict 클래스의 생성자로 기본값을 생성해주는 함수를 넘기면,
모든 키에 대해서 값이 없는 경우 자동으로 
생성자의 인자로 넘어온 함수를 호출하여 그 결과값으로 설정해줍니다.
'''
for k, v in chain(dict1.items(), dict2.items()):

	dict3[k].append(v)

# defaultdict(<class 'list'>, 
# {'id': [110809386], 'bookC': [['free']], 'bookD': [['24']], 'bookE': [['5', '3', '4']]})

for k, v in dict3.items():

	print(k, v)

# 가장 개수가 많은 키 값 찾기
max(dict2, key=lambda key: len(dict2[key]))

dict1["id"] = [str(dict1["id"])]*3

dict1

### lambda
= 함수를 매개변수로 받을때
def func(x):
	return x[1]

func(x) == lambda x: x[1]

https://code.tutsplus.com/ko/tutorials/how-to-merge-two-python-dictionaries--cms-26230

두 파이썬 딕셔너리를 병합하는 법

# 하나의 키값에 여러 value list가 있을때 나누는 법
# 단, 길이가 같은 것만 추출함

[dict(zip(data_dict.keys(), i)) for i in zip(*data_dict.values())]

<예시>
{
  'size': ['s', 'm', 'l'],
  '어깨너비': ['42', '43', '44'],
  '가슴둘레': ['100', '104', '108'],
  '팔둘레': ['36', '37.5', '39'],
  '소매길이': ['58', '59', '60'],
  '총장': ['49.5', '50,5', '51.5']
  }
  
{'size(cm)': 's',
    '총장': '43.5',
    '어깨': '39',
    '가슴': '48',
    '밑단': '47',
    '소매': '58',
    '소매통': '16.5',
    '소매부리': '13.5'},
   {'size(cm)': 'm',
    '총장': '44',
    '어깨': '40',
    '가슴': '50',
    '밑단': '49',
    '소매': '58.5',
    '소매통': '17.5',
    '소매부리': '14.5'}
    
    .
    .
    .

 

Append VS extend

list.append(x)는 리스트 끝에 x 1개를 그대로 넣습니다.

list.extend(iterable)는 리스트 끝에 가장 바깥쪽 iterable의 모든 항목을 넣습니다.

list.append(x)는 리스트 끝에 x 1개를 그대로 넣습니다.

list.extend(iterable)는 리스트 끝에 가장 바깥쪽 iterable의 모든 항목을 넣습니다.

list comprehension

# !!특정한 크기를 가지는 2차원 리스트를 초기화 할때는 리스트 컴프리헨션 사용!!
a = [[0]*m for _ in range(n)]
a[1][1] = 5
print(a)

# 각 행에 두번째 열 값이 다 바뀜
aa = [[0]*m]*n
aa[1][1] = 5
print(aa)

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

itertools

- permutations, combinations(순열, 조합)

- product(permutations와 같이 리스트와 같은 iterable객체에서 r개의 데이터를 뽑아 일렬로 나열

=> 다만 원소를 중복하여 뽑는다.

- combinations_with_replacement는 combinations와 같이 리스트와 같이 iterable 객체에서 r개의 데이터를 뽑아 순서를 고려하지 않고 나열하는 모든 경우(조합)를 계산한다.

=> 다만 원소를 중복해서 뽑는다.

from itertools import permutations, combinations, product, combinations_with_replacement

a = ["A", "B", "C"]
per_res = list(permutations(a, 2))
com_res = list(combinations(a, 2))
com_with_res = list(combinations_with_replacement(a, 2))
pro_res = list(product(a, repeat=2))

print(per_res)
print(pro_res)
print(com_res)
print(com_with_res)


[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
[('A', 'B'), ('A', 'C'), ('B', 'C')]
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]

heapq

- 파이썬에서는 heap 기능을 위해 heapq 라이브러리 제공

- PriorityQueue라이브러리보다 heapq가 더 빠르게 동작함

- 파이썬의 힙은 최소힙(Min Heap)으로 구성되어 있으므로 단순히 원소를 힙에 전부 넣었다가 빼는 것만으로도 시간 복잡도 O(NlogN)에 오름차순 정렬이 완료된다. 보통 최소 힙 자료구조의 최상단 원소는 항상 '가장 작은' 원소이기 때문이다.

- 최대힙을 제공하지 않음 ==> 최대힙을 구현해야 할 때는 원소의 부호를 임시로 변경하는 방식 사용

import heapq

# 최소힙
def heapsort(iterable):
    h = []
    res = []

    # 모든 원소를 차례대로 힙에 삽입
    for v in iterable:
        heapq.heappush(h, v)

    # 힙에 삽입된 모든 원소를 차례대로 꺼내어 담기
    for _ in range(len(h)):
        res.append(heapq.heappop(h))
    
    return res

result = heapsort([1,3,5,7,8,3,2,4,6,8,0])
print(result)

[0, 1, 2, 3, 3, 4, 5, 6, 7, 8, 8]

# 최대힙
def heapsort(iterable):
    h = []
    res = []

    # 모든 원소를 차례대로 힙에 삽입(-부호)
    for v in iterable:
        heapq.heappush(h, -v)

    # 힙에 삽입된 모든 원소를 차례대로 꺼내어 담기(-부호)
    for _ in range(len(h)):
        res.append(-heapq.heappop(h))
    
    return res

result = heapsort([1,3,5,7,8,3,2,4,6,8,0])
print(result)

[8, 8, 7, 6, 5, 4, 3, 3, 2, 1, 0]

bisect

- bisect_left(a, x) : 정렬된 순서를 유지하면서 리스트 a에 데이터 x를 삽입할 가장 왼쪽 인덱스를 찾는 메서드

- bisect_right(a, x) : 정렬된 순서를 유지하도록 리스트 a에 데이터 x를 삽입할 가장 오른쪽 인덱스를 찾는 메서드

# "정렬된 리스트" 였을때!
from bisect import bisect_left, bisect_right

a= [1, 2, 3, 4, 4, 5, 5, 6, 7]
x = 5
left = bisect_left(a, x)
right = bisect_right(a, x)
print(left, right)

5 7(= 인덱스)

def count_by_range(a, left_value, right_value):
    right_index = bisect_right(a, right_value)
    left_index = bisect_left(a, left_value)

    return right_index - left_index

a = [1,2,3,3,3,3,4,4,8,9]

# 값이 4인 데이터 개수
# 값이 [1, 3] 범위에 있는 데이터 개수
print(count_by_range(a, 4, 4))
print(count_by_range(a, 1, 3))

2
6

Collections

- deque, Counter

- deque에서는 리스트 자료형과 다르게 인덱싱, 슬라이싱 등의 기능은 사용할 수 없다.

다만, 연속적으로 나열된 데이터의 시작 부분이나 끝부분에 데이터를 사입하거나 삭제할 때는 매우 효과적으로 사용될 수 있다.

- deque는 스택이나 큐의 기능을 모두 포함 => 스택 or 큐 자료구조의 대용으로 사용될 수 있다.

from collections import deque

data = deque([2,3,4])
data.appendleft(1)
data.append(5)

print(data)
deque([1, 2, 3, 4, 5])

'''
deque를 큐 자료구조로 이용할 때, 
원소를 삽입할 때에는 append()를 사용하고 
원소를 삭제할 때에는 popleft()를 사용하면 된다. 
그러면 먼저 들어온 원소가 항상 먼저 나가게 된다.
'''
print(data.popleft())
1
data.popleft()

# 먼저 들어온 순서대로 출력
print(data)
deque([2, 3, 4, 5])

# 다음 출력을 위해 역순으로 바꾸기
data.reverse()

# 나중에 들어온 원소부터 출력
print(data)
deque([5, 4, 3, 2])

# deque 객체를 리스트 자료형으로 변경하고자 한다면 list(deque)
# => 리스트 자료형 반환
[5, 4, 3, 2]


from collections import Counter

count = Counter([1,1,2,2,3,3,3,4])

print(count)
Counter({3: 3, 1: 2, 2: 2, 4: 1})

round()

Python에서 round() 를 사용하셔서 반올림을 하신다면 위와같이 사사오입 원칙을 따른다는 것을 명심

만약 반올림 대상의 값이 5일 때, 올림이 되는 기능을 원한다면 직접 구현

ex) 2.5 ==> 2(= 3 X)