기본적으로 쉽게 알 수 있는 기본 연산자라던가, 다른 언어와 크게 다르지 않은 부분들은 모두 제외하고,
실제로 코드를 짧게 줄이거나, 더 편하게 문제를 풀 수 있는 스킬들만 모았습니다.
1. 기본 입출력
1-1. input()
input() 은 입력받는 한 줄을 모두 문자열(str)로 취급하여 입력받음.
그래서 입력받은 후 캐스팅을 통해 원하는 타입으로 바꿀 필요가 있음.
a = input() # 3 입력
b = int(input()) # 3 입력
a => (str) 3
b => (int) 3
1-2. 여러 개 나누어 입력받기
1 2 3
a, b, c = map(int, input().split())
이러면 a=1, b=2, c=3 으로 잘 담긴다.
map(function, iterable) 에서 fuction 부분에 캐스팅을 위해 int(), iterable 부분은 input().split() 으로 문자열을 입력받아 공백 기준으로 split하여 문자열 리스트가 나옴. 이는 iterable 함.
map 함수에 대한 것은 아래에서.
1-3. 입출력 속도 개선
import sys
input = sys.stdin.readline
print = sys.stdout.write
또는
from sys import stdin, stdout
input = stdin.readline
print = stdout.write
와 같이 input() 과 print() 를 변경.
변경 이후 input() 은 개행문자 \n 까지 받아오기에 처리해 주어야 하고,
from sys import stdin, stdout
read = sys.stdin.readline
a = read().strip("\n")
print() 는 str 타입만 매개변수로 넣을 수 있거나,
print("%d" % 1) # 1
print("%s" % "Hello") # Hello
print("Hello") # Hello
와 같이 c언어의 printf() 느낌으로 사용해 줘야 할 것은 유의.
보통 코테에서 이러한 것 때문에 시간초과가 되거나 하지는 않으나,
백준 등에서 문제를 풀 때 가끔 사용해야 할 일이 있기도 하다.
2. 배열(List) 입력
2-1. 첫 줄에 배열 개수, 둘째 줄부터 배열
3
1 2 3
4 5 6
7 8 9
와 같이 첫 번째 줄에는 배열의 개수, 둘째 줄부터는 배열이 나올 때,
MAP = [list(map(int, input().split())) for _ in range(int(input()))]
와 같이 입력받을 수 있다.
** 파이썬의 리스트 안에서는 if 문이나 for 문을 사용할 수 있음.
aList = [1, 2, 3]
bList = [num*3 for num in aList]
print(bList)
# [3, 6, 9]
** for _ in range() 와 같이 값이 필요 없는 경우에는 underscore(_) 로 넘길 수 있음.
2-1-1. 한 줄에 서로 다른 자료형이 들어오는 경우
백준 5635번과 같이 이런 자료형을 입력받을 때는, str형은 int로 캐스팅할 수 없으므로
5
Mickey 1 10 1991
Alice 30 12 1990
Tom 15 8 1993
Jerry 18 9 1990
Garfield 20 9 1990
n = int(input())
MAP = [list(input().split()) for _ in range(n)]
for i in range(n):
map(int, [MAP[i][1], MAP[i][2], MAP[i][3]])
과 같이 입력받은 후 숫자를 모두 int형으로 캐스팅하거나,
입력받을 때 미리 캐스팅한 다음 빈 리스트에 하나씩 append 하는 방법도 존재한다.
2-2. 정수와 배열이 같은 줄에 들어오는 경우
한 줄마다, 맨 앞에는 수의 개수 n, 그 다음부터 n개의 수가 주어지는 경우
4 1 2 3 4
3 3 6 9
3 5 10 15
n, *arr = map(int, input().split())
변수 앞에 *를 붙이면 List로 저장이 된다.
2-3. 문자열을 잘라서 배열에 저장
3
AAAA
ABCA
AAAA
arr = [['A', 'A', 'A', 'A']
['A', 'B', 'C', 'A']
['A', 'A', 'A', 'A']]
위의 입력값을 두번째와 같이 한 글자씩 잘라 배열에 넣고 싶을 때
arr = [list(input()) for _ in range(int(input()))]
3. 배열(List) 출력
3-1. 배열 요소를 붙여 출력
arr = [1, 2, 3, 4]
이 배열을
1234
와 같이 출력하고 싶을 때
print("".join(map(str, arr)))
map 을 이용해 배열의 요소를 string으로 캐스팅하고, "".join() 을 이용해 공백 없이 값을 출력.
*또는, print() 함수의 sep= 파라미터를 이용하는 방법도 존재함. 3-2 참조.
print(*arr, sep="")
*** "(구분자)".join 함수로 iterable한 자료의 데이터를 합칠 수 있음.
"_".join(["HI", "Hello"])
# >> HI_Hello
3-2. 배열 요소를 한 칸씩 띄워 출력
arr = [1, 2, 3, 4]
이 배열을
1 2 3 4
와 같이 출력하고 싶을 때.
3-1을 이용해 " ".join 으로 공백을 넣어 합쳐도 되지만,
print(*arr)
만으로 출력이 가능함.
4. 문자열
4-1. 문자열 관련 내장 메소드
count()
문자열에서 특정 문자의 개수를 반환.
Astring = "Hello, World!"
a = Astring.count("l")
print(a) # 3
find()
해당 문자가 처음으로 등장하는 index를 반환.
없다면 -1 반환.
Astring = "Hello, World!"
a = Astring.find("l")
b = Astring.find("A")
print(a, b) # 2, -1
index()
find() 와 동일하나, 없을 때 -1 반환이 아닌 error 발생.
strip(), rstrip(), lstrip()
strip()은 양쪽 끝, rstrip은 우측 끝, lstrip은 좌측 끝의 공백을 제거.
a = " asdf "
a.lstrip() # " asdf"
a.rstrip() # "asdf "
a.strip() # "asdf"
replace()
문자열.replace([str1], [str2])
한 문자를 다른 문자로 변경.
a = "abcd"
a.replace("a", "AAA")
a => "AAAbcd"
split(), join()
split()은 [1-1. input()] 부터,
join()은 [3-1. 배열 요소를 붙여 출력] 에서 이미 다룸.
split([sep], [maxsplit = ])
와 같이 사용, sep에는 나눌 기준, maxsplit은 앞에서부터 나눌 횟수.
maxsplit을 비우면 모두 나눔.
a = "abcdefg"
c, d = a.split("d")
c => "abc"
d => "efg"
str = "a b c d e f g"
print(str.split(sep="e"))
print(str.split(sep=" ", maxsplit=3))
# output
# ['a b c d ', ' f g']
# ['a', 'b', 'c', 'd e f g']
4-2. 문자열 슬라이싱(slicing)
문자열[ (start) : (end) : (step) ]
처럼 사용 가능.
end-1번째 index까지 자른다.
물론, 음수 인덱싱도 가능하다.
a = "123456789"
a[1:3] => "23"
a[-5:8] => "5678"
a[-1:2] => ""
a[0:5:2] => "135"
a[3:7:-1] => ""
a[7:3:-1] => "8765"
4-2-1. 문자열 뒤집기
문자열 slicing을 응용해, 문자열을 뒤집을 수 있다.
a = "123456789"
a[::-1] => "987654321"
문자열을 리스트로 변환해 reverse() 를 쓰는 방법도 있긴 함.
5. 배열(List)
5-1. 배열 관련 내장 메소드
기본적인 원소 추가, 제거(append, insert, remove) 와 같은 것들은 다루지 않고,
밑의 링크로 대체. (Python 공식 문서)
https://docs.python.org/3/library/stdtypes.html?highlight=list%20sort#common-sequence-operations
https://docs.python.org/3/library/stdtypes.html?highlight=list%20sort#mutable-sequence-types
reverse()
배열 뒤집기. 반환값 없이 직접 배열에 작용함.
a = [1, 2, 3, 4, 5]
a.reverse()
print(a) # [5, 4, 3, 2, 1]
count()
문자열과 마찬가지로 몇 개 있는지 반환.
a = [1, 1, 1, 4, 5]
print(a.count(1)) # 3
sort()
5-5. 배열 정렬(sort())로.
5-3. 배열 초기화
배열의 가로, 세로 크기가 정해졌을 때, 그 크기의 배열을 0으로 초기화하며 생성.
row = 3, column = 5
arr = [[0] * column for _ in range(row)]
# [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
5-4. 중복되는 원소 제거
a = [1, 1, 1, 2, 2, 3, 3, 4, 5, 5]
b = list(set(a))
print(b) # [1, 2, 3, 4, 5]
조합(set)은 중복되는 원소 없이 유일하기 때문에, set으로 변환 후 다시 list로 변환.
이차원 배열일 경우에는,
a = [[1, 2], [1, 2], [2, 3], [3, 5]]
b = list(set(map(tuple, a)))
print(b) # [(2, 3), (1, 2), (3, 5)]
5-5. 배열 정렬(sort())
arr.sort([key=None], [reverse=False])
a = [1, 5, 4, 2, 3]
와 같은 리스트를 오름차순 정렬 하려면 그대로 사용.
a.sort()
print(a) # [1, 2, 3, 4, 5]
내림차순으로 정렬하려면
a.sort(reverse = True) # [5, 4, 3, 2, 1]
a.sort(key = lambda x:-x) # [5, 4, 3, 2, 1] 음수 인덱싱 이용도 가능
또한, 이중 리스트 등에서 특정 key값을 통해 그 key값을 기준으로 정렬할 수 있다.
a = [[1, 2], [1, 4], [2, 3], [3, 5]]
a.sort(key=lambda x: (x[0], x[1]))
print(a) # [[1, 2], [1, 4], [2, 3], [3, 5]]
lambda x:(x[0], x[1]) => 0번 index를 기준으로 정렬 후, 0번 index가 동일하면 1번 index를 기준으로 정렬.
a = [[1, 2], [1, 4], [2, 3], [3, 5]]
a.sort(key=lambda x: (x[0], -x[1]))
print(a) # [[1, 4], [1, 2], [2, 3], [3, 5]]
이렇게 음수 인덱싱을 이용해 0번 index는 오름차순, 1번 index는 내림차순으로 정렬도 가능하다.
5-6. 리스트 슬라이싱(slicing)
4-2. 문자열 슬라이싱(slicing)과 동일.
5-6-1. 리스트 슬라이싱(List slicing)을 이용한 복사 (deep copy)
python에서는 기본적으로 shallow copy가 이용되어, 리스트 등의 객체를 복사하더라도 동일한 객체임.
이를 list slicing을 이용해 deep copy가 가능.
단, 2차원 이상의 list에서는 1차 list 내부의 객체들은 여전히 shallow copy.
이를 해결하려면 여러 방법이 있는데, 필자는 copy.deepcopy() 를 이용하곤 함.
단, copy.deepcopy() 는 copy 모듈을 import해야 사용 가능.
list slicing을 이용한 deep copy.
arr1 = [1, 2, 3, 4, 5]
arr2 = arr1
arr3 = arr1[:]
arr3.append(6)
print(arr1) # [1, 2, 3, 4, 5]
arr2.append(6)
print(arr1) # [1, 2, 3, 4, 5, 6]
copy.deepcopy() 를 이용한 deep copy
import copy
arr1 = [[1, 2], [3, 4]]
arr2 = arr1[:]
arr3 = copy.deepcopy(arr1)
arr3[0][0] = 7
print(arr1) # [[1, 2], [3, 4]]
arr2[0][0] = 7
print(arr1) # [[7, 2], [3, 4]]
5-7. 리스트 안에 들어있는 지 확인 (in, not in)
in, not in 으로 List 안에 어떤 값이 들어있는 지 확인.
List 뿐 아니라, string, tuple, dictionary.. 등 iterable한 객체에 모두 사용 가능.
a = [1, 2, 3, 4, 5]
if 1 in a:
print("1 is in a")
if 6 not in a:
print("6 is not in a")
>> 1 is in a
>> 6 is not in a
5-8. 리스트 컴프리헨션 (List comprehension)
Python에서 List와 같은 객체들을 짧고 간결하게 초기화할 수 있는 방법!
위의 2-1, 2-3 에서 다루었던 것.
[ (변수 활용식) for (변수명) in (iterable 객체)] 와 같은 문법으로 사용.
예시로 간략하게 설명하겠음.
Ex-1. [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ....] 과 같은 배열 초기화.
N = 12
arr = [0] * N
print(arr)
# output : [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Ex-2. [2, 4, 6, 8, 10, 12]
arr = [i*2 for i in range(1, 7)]
print(arr)
# output : [2, 4, 6, 8, 10, 12]
Ex-3. N줄의 입력에 대한 2차원 배열 초기화
는 2-1, 2-3 으로.
* 참고로, 코테에서 자주 쓰일 일은 없으나, 조건문을 이용하여 filtering하는 등의 과정을 포함시킬 수 있다.
** 또한, dictionary와 같은 자료형도 comprehension을 이용해 초기화할 수 있다. Union-Find 등을 구현할 때에 유용하게 쓰인다.
dic = {i: i for i in range(10)}
print(dic)
# output : {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
6. tuple
list, dictionary 등과 다르게, 한 번 생성하면 요소를 변경할 수 없는, immutable한 객체.
immutable하다는 것만 제외하면, list와 거의 동일하므로, 생략.
list에서 가능한, 인덱싱, 슬라이싱, +연산, *연산... 등등 대부분 가능.
7. 딕셔너리(Dictionary)
해시를 이용할 때 or 딕셔너리형 자료형이 필요할 때 이용.
기본적으로 BFS 등에서 visited list를 관리할 때,
각 key에 대한 삽입, 삭제, 요소가 있는 지 확인하는 과정의 time complexity가 O(1)이기 때문에 유용하게 사용할 수 있음.
7-1. 딕셔너리 기본 조작, 기본 내장 메소드들
초기화(clear())
d = {1: 'a'}
d.clear()
>> {}
추가 / 수정
a = {1: 'a'}
a[2] = b
>> {1: 'a', 2: 'b'}
삭제 (del, pop(), popitem())
a = {1: 'a', 2: 'b', 3: 'c'}
del a[1] # {2: 'b', 3: 'c'}
a.pop(2) # {3: 'c'}
a.pop(0) # keyError: 0
딕셔너리.pop(키값[, defaultValue]) 처럼 사용하면 없는 key값일 때 defaultValue 반환
a = {1: 'a', 2: 'b', 3: 'c'}
print(a.pop(0, -1))
>> -1
popitem() 은 맨 마지막 key-value 쌍 삭제하며 반환.
d = {1: 'a', 2: 'b', 3: 'c'}
d.popitem() # {1: 'a', 2: 'b'}
딕셔너리 합치기(update())
a = {1: 'a', 2: 'b', 3: 'c'}
b = {3: 'd', 4: 'e'}
a.update(b)
>> a : {1: 'a', 2: 'b', 3: 'd', 4: 'e'}
update()를 이용하면, 값이 덮어씌워짐.
key로 value 접근 ([], get())
물론 기본적인 경우는 [] 로 접근하면 됨.
d = {1: 'a', 2: 'b', 3: 'c'}
print(d[1])
print(d[0])
>> a
>> KeyError: 0
그러나 이 경우, 없는 key값으로 접근하면 에러가 남. 따라서 get()을 이용하면
딕셔너리.get(키값[, defaultValue])
d = {1: 'a', 2: 'b', 3: 'c'}
print(d.get(0, -1))
>> -1
없는 key로 접근했을 때 두 번째 인자로 넣어준 기본값이 반환된다.
7-2. 리스트로 딕셔너리 생성하기
list1 = ["a", "b", "c"]
list2 = [1, 2, 3]
dic = dict(zip(list1, list2))
>> {'a': 1, 'b': 2, 'c': 3}
물론, 리스트 말고 다른 iterable 객체로도 가능.
tuple1 = ("a", "b", "c")
dic = dict(zip(tuple1, range(3)))
>> {'a': 0, 'b': 1, 'c': 2}
7-3. value로 key 찾기
두 가지 방법이 있는데,
더 시간적 효율이 좋은 것은 key와 value값을 서로 바꿔 key값으로 다시 찾는 것.
그러나 이 방법은 value값에 중복이 있으면 key-value 쌍을 뒤집는 과정에서 자료가 손실되므로 유의.
(고유한 key값은 중복될 수 없음.)
- key - value 쌍 뒤집기
a = {'a': 1, 'b': 2, 'c': 3}
reverse = dict(map(reversed,pratice_dict.items()))
>>> {1: 'a', 2: 'b', 3: 'c'}
- for문 이용
a = {'a': 1, 'b': 2, 'c': 3}
for key in a.keys():
if a[key] == 2:
print(key)
>>> b
7-4. 전체 key 리스트, value 리스트, key-value쌍 리스트 가져오기
차례대로 key(), value(), items() 내장 함수가 있다.
d = {1: 'a', 2: 'b', 3: 'c'}
print(d.keys()) # dict_keys([1, 2, 3])
print(d.values()) # dict_values(['a', 'b', 'c'])
print(d.items()) # dict_items([(1, 'a'), (2, 'b'), (3, 'c')])
python3 인가..? 부터는 List가 아니라 저렇게 자체적인 객체로 반환하기 때문에,
리스트로 사용하고 싶다면 list()를 이용해 이렇게 사용하자.
d = {1: 'a', 2: 'b', 3: 'c'}
print(list(d.keys())) # [1, 2, 3]
근데 물론 저 dict_keys 같은 놈들도 iterable해서, for문 같은 곳에 그대로 써도 됨.
7-5. 딕셔너리 안에 key값이 있는지 확인(in, not in)
5-7. 리스트 안에 들어있는 지 확인 (in, not in) 과 동일.
다만, key값만 검사함.
7-6. value가 최대 / 최소인 key 찾기
max(dict, key = dict.get)
7-7. comprehension을 이용한 dictionary 초기화
는 5-8 로.
8. 힙(Heap - heapq), 우선순위 큐(Priority Queue)
파이썬에서, Priority Queue를 이용해 문제를 풀어야 할 때 사용.
heapq 모듈을 import하여 사용할 수 있다.
기본적으로, list 객체를 이용하여 heap을 표현하고,
min Heap(최소 힙)만 제공하며, max Heap(최대 힙)은 요소를 음수로 표현하여 처리해야 한다.
8-1. 기본 조작
삽입
heapq.heappush(heap, item)
Time Complexity(시간 복잡도) 는 O(logN).
import heapq
arr = []
heapq.heappush(arr, 2)
heapq.heappush(arr, 4)
heapq.heappush(arr, 1)
heapq.heappush(arr, 3)
print(arr)
# output : [1, 3, 2, 4]
삭제
heapq.heappop(heap)
Time Complexity(시간 복잡도) 는 O(logN).
import heapq
arr = [5, 1, 2, 4, 3]
heapq.heapify(arr)
print(arr) # [1, 3, 2, 4, 5]
print(heapq.heappop(arr)) # 1
print(arr) # [2, 3, 5, 4]
Heapify
heapq.heapify(list)
Time Complexity(시간 복잡도) 는 O(N).
예시는 삭제에서.
8-2. max Heap(최대 힙) 구현
기본적으로 최소 힙만을 제공하기 때문에, 요소에 -를 붙여 최대 힙을 구현함.
import heapq
arr = [5, 1, 2, 4, 3]
arr1 = list(map(lambda x: -x, arr))
arr2 = arr
heapq.heapify(arr1)
heapq.heapify(arr2)
for _ in range(5):
print(-heapq.heappop(arr1), heapq.heappop(arr2))
# output :
# 5 1
# 4 2
# 3 3
# 2 4
# 1 5
8-3. 리스트(List)와 튜플(Tuple) 등의 힙(heapq) 이용
리스트 또는 튜플도 heap의 원소로 들어갈 수 있다.
다만, 정렬은 객체의 첫 번째 원소 기준.
import heapq
arr = [[5, 1], [3, 2], [4, 2], [1, 4], [2, 7]]
arr2 = [(5, 1), (3, 2), (4, 2), (1, 4), (2, 7)]
heapq.heapify(arr)
heapq.heapify(arr2)
for _ in range(5):
print(heapq.heappop(arr), heapq.heappop(arr2))
# output :
# [1, 4] (1, 4)
# [2, 7] (2, 7)
# [3, 2] (3, 2)
# [4, 2] (4, 2)
# [5, 1] (5, 1)
9. 큐, 스택 - 데크(Deque)
from collections import deque
로 import 하여 사용.
9-1. 기본 조작
생성
deque(iterable 객체)
a = deque([1,2,3,4]) # deque([1, 2, 3, 4])
b = deque("String") # deque(['S', 't', 'r', 'i', 'n', 'g'])
c = deque({1:'a', 2:'b'}) # deque([1, 2])
삽입
deque.append(value)
deque.appendleft(value)
a = deque([2, 3, 4])
a.append(5)
a.appendleft(1)
# deque([1, 2, 3, 4, 5])
삭제
deque.pop()
deque.popleft()
a = deque([1, 2, 3, 4, 5])
a.pop() # return 5
a.popleft() # return 1
# deque([2, 3, 4])
deque.remove(value)
a = deque([1, 2, 3, 4, 5])
a.remove(3)
# deque([1, 2, 4, 5])
초기화
deque.clear()
9-2. 회전, 뒤집기
deque.rotate(value)
양수면 오른쪽, 음수면 왼쪽으로 value만큼 회전함.
a = deque([1, 2, 3, 4, 5])
a.rotate(3) # deque([3, 4, 5, 1, 2])
a.rotate(-1) # deque([4, 5, 1, 2, 3])
deque.reverse()
9-3. 확장
deque.extend(iterable)
deque.extendleft(iterable)
a = deque([3])
a.extend([4, 5]) # deque([3, 4, 5])
a.extendleft([1, 2]) # deque([1, 2, 3, 4, 5])
10. 여러 유용한, 자주 쓰이는 함수들
10-1. range()
for _ in _ 문에서 굉장히 자주 쓰이는 range.
range([start], end, [step]) 과 같이 사용할 수 있음.
arr1, arr2, arr3, arr4 = [], [], [], []
for i in range(5):
arr1.append(i)
for i in range(2, 4):
arr2.append(i)
for i in range(0, 9, 2):
arr3.append(i)
for i in range(9, 3, -1):
arr4.append(i)
print(arr1) # [0, 1, 2, 3, 4]
print(arr2) # [2, 3]
print(arr3) # [0, 2, 4, 6, 8]
print(arr4) # [9, 8, 7, 6, 5, 4]
10-2. len()
리스트, 튜플, 딕셔너리, 문자열... 등의 원소 개수(길이)를 return하는 함수.
arr = [1, 2, 3, 4]
dic = {"c": 1, "a": 2, "b": 5}
tup = (1, 4)
str1 = "abdfdsf"
print(len(arr), len(dic), len(tup), len(str1))
# output : 4 3 2 7
10-3. sorted()
sorted( [iterable한 data], [key(Option)], [reverse(Option)] )
이터러블한 데이터(리스트, 튜플, 딕셔너리 등)를 정렬할 수 있는 함수.
key 옵션으로 무엇을 기준으로 정렬할 지 지정.(주로 lambda 함수 이용)
reverse = True 를 넣어주면 내림차순으로 정렬할 수 있음. (기본 오름차순)
arr = [[5, 10], [2, 5], [4, 7], [3, 9]]
와 같은 리스트를 각 내부 리스트의 두 번째 원소(10, 5, 7, 9)를 기준으로 내림차순 정렬.
newArr = sorted(arr, key=lambda x: x[1], reverse=True)
print(newArr) # [[5, 10], [3, 9], [4, 7], [2, 5]]
주의할 점은 새로운 iterable 객체에 결과값을 담아줘야 한다는 것.
파라미터로 넣은 이터러블 객체 자체는 그대로 유지된다.
newArr = sorted(arr, key=lambda x: -x[1]) # [[5, 10], [3, 9], [4, 7], [2, 5]]
와 같이 람다함수의 return값에 -를 붙여도 내림차순으로 정렬되어, 간단하게 reverse=True 의 효과를 낼 수 있다.
sorted(arr, key=lambda x: (-x[1], x[0]))
lambda 함수의 return값을 tuple로 주면, 첫 번째 값이 동일할 때, 다음 값을 기준으로 정렬.
10-4. map()
사용법은, map(function, iterable) .
첫 번째 파라미터로는 함수(lambda함수도 무관), 두 번째 파라미터로는 iterable한 객체를 넣어 주면 된다.
각종 사용법은 위에서 많이 예시를 보여주었으므로 생략.
위에 나오지 않은 예시들만 아래 몇 가지 첨부.
Ex-1. map - 2차원 리스트의 최댓값 구하기
max(map(max, List))
10-5. sum(), max(), min()
따로 설명할 게 없음.. 패스.
arr = [1, 2, 3]
print(sum(arr), max(arr), min(arr))
# output : 6 3 1
10-6. enumerate()
for _ in _ 문법으로 리스트, 딕셔너리, 튜플 등의 원소를 돌려 사용할 때,
원소의 값 뿐만 아니라 index(반복 횟수) 또한 필요할 때 사용.
물론 그냥 for i in range(): 해갖고 arr[i] 로 쓰면 되겠지만,, 가독성을 위해 종종 씁니다.
arr = ["a", "b", "c", "d", "e"]
for i, v in enumerate(arr):
print(i, v)
# output :
# 0 a
# 1 b
# 2 c
# 3 d
# 4 e
10-7. zip()
길이가 같은 iterable 객체 여러 개를 묶을 수 있음.
dictionary를 초기화할 때, 아니면 또 다른 때에 쓸 일이 있을..지도. 알아두면 뭐.. 나쁠건없는듯
arr = [1, 2, 3]
arr2 = ("a", "b", "c")
print(list(zip(arr, arr2)))
print(dict(zip(arr, arr2)))
# output :
# [(1, 'a'), (2, 'b'), (3, 'c')]
# {1: 'a', 2: 'b', 3: 'c'}
10-8. 아스키코드 - ord(), chr()
문자를 숫자로, 숫자를 문자로 변환할 일이 생각보다 있음.
C++에서는 char형을 int형에 할당하면 묵시적 형변환으로 숫자로 바뀌었지만(반대도 마찬가지),
파이썬에서는 함수를 이용해야 합니당.
chr(65) # 'A'
ord("Z") # 90
10-9. Counter()
collections 모듈의 Counter 클래스를 import하여 사용 가능.
리스트, 문자열 등의 원소의 빈도수를 쉽게 알 수 있음.
most_common() 을 이용해, 빈도수를 기준으로 내림차순 정렬도 가능.
사실 이건 저도 딱 한 번 써봤어요.
from collections import Counter
arr = ["a", "a", "b", "b", "b", "c"]
c = Counter(arr)
print(c) # Counter({'b': 3, 'a': 2, 'c': 1})
print(c["a"]) # 2
print(c.most_common()) # [('b', 3), ('a', 2), ('c', 1)]