[Python] 코딩테스트에 필요한 문법 정리

문자열/컬렉션

문자열/배열 (튜플도 문법 거의 똑같음)

✅ 배열 슬라이싱

https://dojang.io/mod/page/view.php?id=2208 

 

- list[시작인덱스:끝인덱스:증가폭]

시작인덱스, 증가 폭 생략 시 디폴트는 0

끝 인덱스 -> 끝인덱스 -1

 

- 시작 인덱스와 끝 인덱스가 같으면 빈 리스트를 반환함

>>> a = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
>>> a[4:7]     # 인덱스 4부터 6까지 요소 3개를 가져옴
[40, 50, 60]
>>> a[1:1]    # 인덱스 1부터 0까지 잘라서 새 리스트를 만듦
[]
>>> a[1:2]    # 인덱스 1부터 1까지 잘라서 새 리스트를 만듦
[10]
>>> a[4:-1]    # 인덱스 4부터 -2까지 요소 5개를 가져옴
[40, 50, 60, 70, 80]
>>> a[5:1:-1]
[50, 40, 30, 20]
>>> del a[2:5]    # 인덱스 2부터 4까지 요소를 삭제
>>> a
[0, 10, 50, 60, 70, 80, 90]

 

*배열 역순: list[::-1]

 

✅ 문자열/배열 인덱스 함수 정리

 

list.index(element): element가 포함된 첫번째 인덱스 반환, 없으면 -1 반환

 

✅ 문자열에서 또 하나의 부분 문자열 만들기

string = "aabbaccc"
print(string[:3])  // aab -> 끝 인덱스는 포함 X
print(string[3:])   // baccc

 

✅ 배열 마지막 원소 접근

list[-1] (마지막에서 두번째는 -2, 세번째는 -3 ....)

 

✅ 반복된 원소로 이루어진 배열/문자열 초기화

print("3" * 6) // 333333
print([3] * 4) // [3, 3, 3, 3]

 

✅ N개의 빈 리스트로 이루어진 빈 2차원 배열 초기화

# N*M 크기의 2차원 배열
n = 5
m = 2
arr = [[0]*m for _ in range(n)]

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

 

✅ 배열/문자열 추가 / 제거 / 교체 / 특정 원소 세기

 

[추가]

append(element) : 배열 끝에 인자 element를 추가하는 메소드

extend(array): 배열 끝에 array의 element들을 추가하는 메소드

array += array2 : 배열 끝에 배열 원소 추가해서 합침 (시간복잡도 O(N))

insert(index, element) : 배열의 index 자리에 인자의 element를 추가하는 메소드

 

[제거]

remove(특정 값) : 특정한 값을 가지는 원소를 제거하되, 여러개면 맨 처음 등장하는 하나만 제거 (문자열은 str.replce('제거할 문자열', '') 혹은 리스트 컴프리헨션을 통해 부분만 가져와 문자열을 잘라서 가지고 오는 것처럼 할 수 있음)

del a[index]: 인덱스 위치의 원소 제거 (여러개 제거 --> del a[index:index+2] --> index부터 index+2까지의 원소 제거)

a.pop() : 마지막 요소를 리턴하고 원래 리스트에서 해당 요소 삭제  (문자열: str[:-1])

a.pop(n): n번째 인덱스의 요소를 리턴하고 원래 리스트에서 해당 요소 삭제 (첫번째를 삭제하고 싶으면 a.pop(0))

 

[교체]

list[index1], list[index2] = list[index2], list[index1]

 

[특정 원소 세기]

list.count(특정 값)

 

✅ 오름차순/내림차순 정렬

 

list.sort() : 정렬 / sorted(list, string): 반환값이 있는 정렬

내림차순 정렬 : sort(reverse=True), sorted(list, reverse=True)

-> 문자열의 경우 알파벳 사전순 기준으로 정렬한다.

 

🔥 특정 조건에 의한 정렬

1) key=lambda

data = ["2", "2, 1", "2, 1, 3", "2, 1, 3, 4"]
data = sorted(data, key=lambda x:len) ["2", "2, 1", "2, 1, 3", "2, 1, 3, 4"]

sample = [[0, 4], [0, 2], [1, 3], [2, 1]]
print(sorted(sample, key=lambda x:x[1])) #[[2, 1], [0, 2], [1, 3], [0, 4]]

sample1 = {1: 4, 2:1, 3: 2}
print(sorted(sample1, key=lambda x:sample1[x], reverse=True)) #[1, 3, 2]
// 딕셔너리 자체를 sorted에 넣으면 key를 기준으로 정렬 및 key값 만을 return함

# 기준 여러개 -> 소괄호로 묶기
arr = [but, i, wont, hesitate]
arr.sort(key=lambda x:(len, x))

 

*딕셔너리 정렬 레퍼런스 링크: https://blockdmask.tistory.com/566

 

2) from functools import cmp_to_key (시간복잡도가 늘어날 가능성이 있으므로 가급적 지양)

def compare(x, y):    # 음수이면 y가 앞으로, 양수이면 x가 앞으로 오도록 정렬하는 방법
    if x+y > y+x:
    	return -1
    elif x+y == y+x:
    	return 0
    else:
    	return 1
        
from functools import cmp_to_key

l = ['34', '37', '9', '31', '3']
return sorted(l, key=cmp_to_key(compare))

#['9', '37', '34', '3', '31']

 

✅ 배열/문자열 뒤집기

return 값 O : list[::-1]

return 값 X : list.reverse()

 

✅ 문자열 쪼개기

split('구분자')

구분자가 없으면 디폴트로 공백, \n, \t을 기준으로 split을 진행한다.

 

* 구분자 여러개

-> 여기선 스킬이 필요함. 구분자 여러개를 먼저 1개로 통일 후 작업

data_val = "100-200*300-500+20"

# 구분자 통일
data_val = data_val.replace('*', '-').replace('+', '-')

# 문자열 분할
list_val = data_val.split('-')

print(data_val)
print(list_val)

 

✅ 배열 <-> 문자열 변환,  배열 <-> 정수 변환

 배열 -> 문자열 : ' '.join(문자로 구성된 리스트)

- 리스트가 문자로 구성되어있지 않으면 오류가 난다. 

* 주의할점: ' '.join의 실체는 '구분자'.join 이고, ' ' 에 문자열을 이어 붙이는 형태가 아니다. 따라서 여러 개의 문자열을 한꺼번에 이어붙이고 싶다면 리스트에 차례대로 이어붙일 문자열 리스트를 나열해두고, ' ' .join(리스트) 형태로 호출해야한다.

my_string	index_list	result
"cvsgiorszzzmrpaqpe"	[16, 6, 5, 3, 12, 14, 11, 11, 17, 12, 7]	"programmers"

return ''.join([my_string[idx] for idx in index_list])

개행문자 넣고 싶으면?:  '\n'.join(리스트)

 

문자열 -> 배열:

(공백 포함) list(str)

(공백 제거) str.split()

 

정수 -> 배열

n = 12345
n_list = list(map(int, str(n)))
// [1, 2, 3, 4, 5]

 

배열 -> 정수

int(''.join(map(str, list(str(age)))))

 

✅ string 일부 문자 치환

String.replace('old Value', 'new Value') -> 문자열에서 모든 oldValue 값을 newValue로 치환한 문자열을 반환한다.

str = "programmers"

str.replace('m', 'rn') //prograrnrners

 

✅ 정수, 문자 판별 / 대문자, 소문자 관련 메소드

isdigit() : 해당 character가 정수인지에 대한 bool 값

isalpha() : 해당 character가 문자인지에 대한 bool 값 (공백이 섞여있으면 false값 리턴)

isupper() : 해당 character가 대문자인지에 대한 bool 값

islower() : 해당 character가 소문자인지에 대한 bool 값

 

문자열 전체 소문자 -> 대문자 : upper()

문자열 전체 대문자 -> 소문자 : lower()

문자열 전체 대문자로 시작하도록 변환 : capitalize()

 

✅ f-string

- f "{ i: 포맷 }" -> i 변수를 포맷을 입혀서 출력해줌

- f "안녕하세요 저는 {name}이에요" -> name 변수를 포함해서 출력

float = [0.5555, 0.6666, 0.7777]
for x in float: 
    print(f'두째자리까지 표현 {x:.2f}')
# 두째자리까지 표현 0.56
# 두째자리까지 표현 0.67
# 두째자리까지 표현 0.78

intlist = [12, 13, 15]
for i in intlist:
	print(f"{i:03d}")

 

✅ 문자열끼리 비교 연산자를 통해 비교가 가능하다. (Ascii code로 비교 -> 참고 링크)

print("Yuri" > "yuri") // false
print("yuri" == "yuri") // true
print("05:00" < "06:00") // true

 

✅ 배열 인덱스, 요소 한꺼번에 접근

enumerate(리스트) : 인덱스, 인덱스에 맞는 요소 한꺼번에 접근하는방법

str = "ABCDE"
for i, e in enumerate(str) {
    print(f"{i} - {e}")
}

// 0 - A
// 1 - B
// 2 - C
// 3 - D
// 4 - E

 

✅ 2차원 배열 -> 1차원 배열 변환

import itertools

my_list = [[1, 2], [3, 4], [5, 6]]

# 1. 리스트 컴프리헨션
to_1nd_array = [y for x in my_list for y in x]

#2. itertools 활용
to_1nd_array = list(itertools.chain(*my_list))

print(to_1nd_array)

itertools.chain의 인자는 반드시 * 을 붙여야 함을 주의

 

✅ 알파벳(String형) -> 정수 변환 (순서)

알파벳은 총 26개이다.

ord('문자')

 

✅ 정수 -> 알파벳 변환 (순서)

chr(정수)

 

✅ String.startswith(str) : 문자열이 특정 부분으로 시작하는지 판단하는 함수

endswith(str): 특정 부분으로 끝나는지 판단하는 함수

my_string	is_prefix
"banana"	"ban"

return 1 if my_string.startswith(is_prefix) else 0
# my_string이 접두사가 is_prefix가 맞으면 1, 아니면 0 리턴

return 1 if my_string.endswith(is_prefix) else 0

 

✅ 특정 문자 제거

strip('제거할 문자: 생략 가능 (디폴트 공백)') : 양 끝에 특정 문자열 제거

lstrip(): 왼쪽

rstrip(): 오른쪽

str = "     strawberry     "
result = str.strip()			# 'strawberry'
result = str.lstrip()			# 'strawberry     '
result = str.rstrip()			# '     strawberry'

 

✅ 리스트 할당 / 복사

https://velog.io/@kkamyang/Python-%EC%96%95%EC%9D%80-%EB%B3%B5%EC%82%AC-%EA%B9%8A%EC%9D%80-%EB%B3%B5%EC%82%AC-shallow-copy-deep-copy

[Python] 할당과 복사 / 얕은 복사, 깊은 복사 (shallow copy, deep copy)

할당

1) 리스트 a = b  --> a와 b는 둘다 같은 리스트를 가리킴. 한 쪽이 변경되면 다른 한 쪽도 변경됨 (call by reference)

 

복사 (call by value)

[얕은 복사 --> 값이 같은 서로 다른 리스트를 가리킴, 가장 바깥에 있는 껍질만 복사 --> 1차원 배열에 사용]

2) b = a.copy()

3) import copy / copy.copy(a)

4) b = a[:]

 

[깊은 복사 --> 값이 같은 서로 다른 리스트를 가리키며, 안쪽 요소까지 모두 복사해줌 --> 2차원 배열 이상에 사용]

4) import copy / copy.deepcopy(a)

 

✅ 리스트 슬라이싱 시 유의할 점 - 리스트 슬라이스는 인덱스가 잘못되어도 오류가 나지 않음

https://blex.me/@mildsalmon/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EB%AC%B8%EC%9E%90%EC%97%B4%EA%B3%BC-%EB%A6%AC%EC%8A%A4%ED%8A%B8%EC%9D%98-%EC%8A%AC%EB%9D%BC%EC%9D%B4%EC%8A%A4

파이썬 문자열과 리스트의 슬라이스 — mildsalmon

길이가 4인 문자열이나 리스트에 5번째 원소(오프셋)를 선택하면 에러가 발생한다.
하지만, 슬라이싱을 시도하면 문자열이나 리스트의 범위를 초과하더라도 빈값이 return되고 에러는 나지 않는다.
리스트 슬라이스는 문자열의 슬라이스와 같이 잘못된 인덱스를 지정할 수 있지만 예외는 발생하지 않는다. 유효 범위의 인덱스를 반환하거나 아무것도 반환하지 않는다.

 

✅ any, all

any(iterable): iterable의 요소가 단 하나라도 True이면 True 반환 (여기서 설명하는 true는 문자열이나 배열이 비어있지 않음도 포함)

all(iterable): iterable의 요소가 모두 True여야 True 반환

>>> any([False, False, False])
False
>>> any([False, True, False])
True
>>> all([False, True, False])
False
>>> all([True, True, True])
True
>>> all([1, 2, 3])
True

>>> all([1, 2, 3, 0])
False

>>> all([])
True

cur = 3
temp = [1,3,6,2]
if any(cur<num for num in temp):
	print("There exist number that is larger than 3")

 

* 특정 원소가 2차원 배열에 있는지 확인하는 방법

#lock에 0이 존재하지 않는지?
if all(0 not in l for l in lock):
        return True

#lock에 0이 하나라도 존재하는지?
if any(0 in l for l in lock):
        return True

 

✅ 배열의 특정 인덱스 원소만 모아서 리스트 만들기

arr = [e[0] for e in sorted(dic[genre], key=lambda x:(-x[1], x[0]))]
answer += arr[:min(len(arr),2)] # arr의 길이가 2보다 크거나 같다면 2까지, 작다면 arr의 길이만큼 가져옴

 

딕셔너리

✅ 딕셔너리 기본값 활용하여 딕셔너리 편리하게 초기화하기

- from collections import defaultdict

https://dogsavestheworld.tistory.com/entry/python-%EB%94%95%EC%85%94%EB%84%88%EB%A6%AC-defaultdict-%EC%82%AC%EC%9A%A9-%EB%B0%A9%EB%B2%95

 

✅ 딕셔너리 업데이트 / 제거

words = {}

words["B"] = "Banana"  # 동일한 키가 없으면 ===> 추가하기

words["B"] = "Blue"    # 동일한 키가 있으면 ===> 기존 밸류 덮어쓰기

del words["B"] # B에 해당하는 value 값 제거

words.clear() # 모든 키-값 쌍 삭제

 

✅ 딕셔너리 - keys(), values(), items(), list(dic)

리스트로 사용할 필요가 있을 시, 변환 필요

myDict = {1: "One", 2: "Two", 3: "Three"}

for (key, value) in myDict.items():
    print(key, value)


for key in myDict.keys():
    print(key)


for value in myDict.values():
    print(value)
    
list(myDict) = [1, 2, 3]
# 키값만 뽑아서 리스트 만들어줌

 

✅ len(딕셔너리)

--> 딕셔너리에 포함된 총 key, value 쌍의 개수를 반환함

--> value가 0이어도 개수를 세주므로, 만약 value가 0일 때 개수에 포함시키지 않고 싶다면 사전에 해당 key-value 쌍을 지워줘야한다. (del dic[key])

myDict = {1: "One", 2: "Two", 3: "Three"}

len(myDict) # 3 출력

 

✅ 딕셔너리 정렬

d = {"dream": 0, "car": 99, "blockdmask": 1, "error": 30, "app": 20}

# lambda x : x[1]
d2 = sorted(d.items(), key=lambda x: x[1])
print(d2)

#[('dream': 0), ('blockmask', 1), ('app', 20), ('error', 30), ('ear', 99)]

 

✅ 딕셔너리 키/값 최대/최소값

max/min(myDict.keys()))
max/min(myDict.values())

 

✅ 딕셔너리 컴프리헨션 --> 한꺼번에 간편하게 초기화하는 방법

results = {n: n ** 2 for n in range(10)}

 

세트

https://wikidocs.net/1015

02-6 집합 자료형

집합 만들기: set([1, 2, 3, 4, 5]) --> 시간복잡도 O(n)

합집합: set1 | set2

교집합: set1 & set2

차집합: set1 - set2

 

자료구조

힙

https://littlefoxdiary.tistory.com/3

[Python] 힙 자료구조 / 힙큐(heapq) / 파이썬에서 heapq 모듈 사용하기

import heapq

- 파이썬은 최소힙만 지원함 (최대힙으로 사용하고 싶다면 음수로 바꾼 후 넣은다음, 꺼낼 때 다시 부호를 반대로 돌리는 테크닉 필요)

 

큐, 덱(deque)

https://wikidocs.net/104977

008 앞뒤에서 자료를 넣고 빼려면? ― collections.deque

 

기타

✅from collections import Counter : 리스트 각 요소를 key, 갯수를 value로 가지는 Dictionary 형태의 Counter 자료형 return

--> 주로 요소의 개수를 셀 필요가 있고, 해당 갯수를 활용해야할 때 많이 사용함

 

elements(): value값 들을 풀어서 리스트로 반환

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> sorted(c.elements())
['a', 'a', 'a', 'a', 'b', 'b']

 

items(): (key, value) 튜플 리스트 반환

most_common(n): 갯수가 많은 순서대로 정렬된 (key, value) 튜플 리스트 반환

-> n을 지정하면 가장 개수가 많은 n개의 리스트 반환

 

-> 셋다 배열처럼 사용하려면 list()로 감싸줘야하고, 딕셔너리처럼 사용하려면 dict(Counter) 이런식으로 감싸줘야함

>>> Counter('abracadabra').most_common(3)  
[('a', 5), ('r', 2), ('b', 2)]

 

⭐️ Counter 클래스 간의 합집합 (|), 교집합(&)

합집합: Counter 간의 key, value를 합쳐서 반환하는데 겹치는 key가 있다면 두 value 중 더 큰 value를 가지게됨

교집합: Counter 간의 key, value의 교집합을 반환하게 되는데, 겹치는 key가 있다면 두 value 중 더 작은 value를 가지게됨

 

✅ 연산 함수 모음

sum(iterable (리스트, 튜플..., start = 0) : start는 합 시작 값

sum(iterable, start = []): 빈 배열에 iterable을 더한 리스트 반환

최대값 : max(a, b) -> a, b중 큰 값 반환

최소값 : min(a,b) -> a, b중 작은 값 반환

 

✅ print문 활용

https://sylagape1231.tistory.com/42

print(_, sep=" ", end="\n)

 

sep: 출력할 때 어떤 구분자를 넣어서 출력할 것인지? (기본값 빈문자열),

end: 출력할 때 어떤 형식으로 마칠것인지? (기본값 개행문자)

 

✅ 람다 표현식 + map/filter/reduce

속도가 느려서 많이 쓰는게 좋지는 않다. (쓰는것과 안쓰는것이 차이가 많이남)

for 문이나 리스트 슬라이싱을 활용할 수 있다면 최대한 활용하는 것이 좋으며 특히 반복문 안에서 사용하는 것은 지양

 

https://dojang.io/mod/page/view.php?id=2360

 

1) map

주어진 클로저를 시퀀스 요소에 매핑한 결과를 포함하는 배열을 반환

ex)

cast = ["Vivien", "Marlon", "Kim", "Karl"]
lowercaseNames = list(map(lambda x: x.lower(), cast)))
// 'lowercaseNames' == ["vivien", "marlon", "kim", "karl"]
letterCounts = list(map(lambda x:len(x), cast)))
// 'letterCounts' == [6, 6, 3, 4]

 

2) filter

주어진 조건자를 만족하는 시퀀스의 요소를 순서대로 포함하는 배열을 반환

ex)

cast = ["Vivien", "Marlon", "Kim", "Karl"]
shortNames = len(list(filter(lambda v: len(x) < 5, cast)))
print(shortNames)
// "["Kim", "Karl"]"

 

3) reduce

주어진 클로저를 사용하여 시퀀스의 요소를 결합한 결과를 반환합니다.

lst = [1, 2, 3, 4, 5]
print(reduce(lambda x, y:x+y, [1, 2, 3, 4, 5]) # 1+2+3+4+5 = 15

 

✅ for문 역순

for i in range(n,0,-1):
    print(i)

for i in reversed(range(n)):

 

✅ 소수점, 절댓값 관련 함수

https://jsikim1.tistory.com/223

Python 반올림(round), 올림(ceil), 내림(floor), 소수점 버림(trunc) 하는 방법

 

round(i, n) : i의 반올림 값 (n은 생략 가능, 반올림하고자 하는 위치-1)

abs(i) : i의 절댓값

 

아래는 import math 필요

ceil(i) : i의 올림한 값

floor(i) : i의 내림한 값

trunc(i) : i의 소수점 부분을 버림한 값

 

✅ 제곱근, 제곱

import math

제곱 : math.pow(x, y) / x ** y

제곱근 : math.sqrt(x)

 

✅ n진수 변환

10진수 -> 2/8/16진수 : bin(), oct(), hex()

 

라이브러리 사용 안하고 변환하기

def radixChange(num, radix):
    if num == 0: return '0'
    nums = []
    while num:
    	num, remain = divmod(num, radix)
        nums.append(str(remain))  # 나머지 값을 계속 추가하고
    return ''.join(reversed(nums))  # 뒤집음

 

2/8/16 진수 -> 10진수: int(문자열, n)

 

✅ 프로그램 중도에 종료

프로그램 실행 도중, 중단시키고싶을 때 exit() 을 쓴다.

 

✅ zip

iterable 객체 인자 2개를 받아 튜플 형태로 같이 순회할 수 있도록 묶어주는 함수

>>> numbers = [1, 2, 3]
>>> letters = ["A", "B", "C"]
>>> for pair in zip(numbers, letters):
...     print(pair)
...
(1, 'A')
(2, 'B')
(3, 'C')

 

✅ for-else문

- for문을 모두 실행하고 난 뒤에 else문 실행 (break문을 만나면 else문도 실행 안함)

>>> for x in [1, 2, 3, 4]:
...     print(x)
... else:
...     print("리스트의 원소를 모두 출력했어요")
... 
1
2
3
4
리스트의 원소를 모두 출력했어요

 

코테에서 자주 쓰이는 라이브러리 모음

1) import sys

- 입력을 빠르게 받도록 도와주는 sys.stdin.readline()

- sys.setrecursionlimit(10**6): 재귀의 깊이를 늘려주는 함수

 

2) from itertools

- import cominations(list, n): 조합

- import permutations(list, n): 순열

 

3) from functools import cmp_to_key

- 특정 기준으로 정렬하고 싶을 때 lambda의 key로 비교하는 함수 사용

- 함수의 return 값이 양수이면 a가 앞으로 오고 음수이면 b가 앞으로옴

예제: https://school.programmers.co.kr/learn/courses/30/lessons/42746

 

4) import heapq

- 우선순위 큐, 힙 정렬시 사용

 

5) from collections

- import defaultdict: 기본값이 있는 딕셔너리

- import Counter: 리스트 각 요소, 갯수를 각각 key, value 쌍으로 가지고 있는 딕셔너리와 유사한 자료형 (사용하고자 한다면 list 혹은 dictionary로 변환 필요) 

- import deque: 큐 구현

 

6) import math

- gcd / lcm : 최대공약수/최소공배수

- sqrt(x) : 제곱근

- pow(x, y) : x의 y제곱

- factorial(x): x의 팩토리얼

 

7) from bisect

- import bisect(사용할 배열, 찾을 값) --> 오른쪽 방향을 우선적으로 탐색하여 이진탐색을 통해 원하는 값의 인덱스를 찾아줌

- import bisect_left(사용할 배열, 찾을 값) --> 왼쪽 방향을 우선적으로 탐색하여 이진탐색을 통해 원하는 값의 상한선 인덱스를 찾아줌