[Python] 파이썬 문법 정리[4탄] (코딩 테스트 대비)

 

For문 역순으로 사용

numbers = [1, 2, 3, 4, 5]
for i in reversed(numbers):
	print(i)
    
"""
5
4
3
2
1
"""

text = "hello"
for char in reversed(text):
	print(char)
    
"""
o
l
l
e
h
"""

 

내림차순 정렬

#sorted()함수의 기본 문법
sorted(iterable, key=None, reverse=True)

#iterable: 정렬 대상
#key: 정렬 기준을 정의하는 함수
#reverse: 정렬 순서

numbers = [3, 1, 5, 7, 4]
sorted_numbers = sorted(numbers, reverse=True) #[7, 5, 4, 3, 1]

 

Lambda 사용 정렬

1. 숫자 리스트를 절댓값 기준으로 정렬

numbers = [5, -2, 9, 1, -5, 6]

sorted_numbers = sorted(numbers, key=lambda x: abs(x))
#[1, -2, 5, -5 6, 9]

 

2. 문자열 리스트를 길이 기준으로 정렬

words = ["apple", "banana", "cherry", "date"]

sorted_words = sorted(words, key=lambda x: len(x))
#['date', 'apple', 'banana', 'cherry']

 

3. 복잡한 객체 리스트를 특정 속성 기준으로 정렬

students = [
    {"name": "John", "age": 25},
    {"name": "Jane", "age": 22},
    {"name": "Dave", "age": 28}
]

sorted_students = sorted(students, key=lambda x: x["age"])

#[{'name': 'Jane', 'age': 22}, {'name': 'John', 'age': 25}, {'name': 'Dave', 'age': 28}]

 

4. 내림차순 정렬과 함께 사용

numbers = [5, -2, 9, 1, -5, 6]

sorted_numbers = sorted(numbers, key=lambda x: abs(x), reverse=True)
#[9, -5, 5, 6, -2, 1]

 

Math 모듈

import math

"""
제곱(pow)
math.pow(x,y)는 x의 y제곱을 반환
"""
result = math.pow(2, 3) #8.0

"""
제곱근(sqrt)
math.sqrt(x)는 x의 제곱근을 반환
"""
result = math.sqrt(16) #4.0

"""
절댓값(fabs)
math.fabs(x)는 x의 절댓값을 반환
"""
result = math.fabs(-5.5) #5.5

"""
소수점 이하 올림 (ceil)과 내림 (floor)
math.ceil(x)는 x보다 크거나 같은 가장 작은 정수를 반환
math.floor(x)는 x보다 작거나 같은 가장 큰 정수를 반환
"""
result_ceil = math.ceil(4.2) #5
result_floor = math.floor(4.8) #4

"""
로그(자연로그)(log)
math.log(x)는 x의 자연로그(밑이 e)를 반환
math.log(x, base)는 x의 지정된 밑(base) 로그를 반환
"""
result = math.log(10) #2.302585092994046
result_base10 = math.log(100, 10) #2.0

"""
로그(밑이 10)
math.log10(x)는 x의 밑이 10인 로그를 반환
"""
result = math.log10(1000) #3.0

"""
지수 함수(exp)
math.exp(x)는 e의 x제곱을 반환
"""
result = math.exp(2) #.3890560989306495

"""
삼각 함수 (sin, cos, tan)
math.sin(x)는 x(라디안 단위)의 사인 값을 반환
math.cos(x)는 x(라디안 단위)의 코사인 값을 반환
math.tan(x)는 x(라디안 단위)의 탄젠트 값을 반환
"""
result_sin = math.sin(math.pi / 2) #1.0
result_cos = math.cos(math.pi) #-1.0
result_tan = math.tan(math.pi / 4) #1.0

"""
라디안 변환 (radians), 도 변환 (degrees)
math.radians(x)는 x(도 단위)를 라디안으로 변환
math.degrees(x)는 x(라디안 단위)를 도로 변환
"""
result_radians = math.radians(180) #3.141592653589793
result_degrees = math.degrees(math.pi) #180.0

 

최대공약수, 최소공배수, 소인수분해

import math

"""
최대공약수(gcd)
math.gcd(a, b)는 a와 b의 최대공약수를 반환
"""
result = math.gcd(48, 64) #16

#배열에 있는 모든 숫자의 최대 공약수
from functools import reduce
array = [48, 64, 16]
gcdA = reduce(math.gcd, array) # 16

"""
최소공배수(lcm)
두 수의 곱을 그들의 최대공약수로 나누어서 구할 수 있음
"""
def lcm(a, b):
	return abs(a*b) // math.gcd(a, b)
result = lcm(12, 15) #60

"""
소인수분해
외부 라이브러리 사용
"""
from sympy import factorint
result = factorint(56) #{2: 3, 7: 1}

 

조합 생성(Combinations)

from itertools import combinations

data = ['A', 'B', 'C', 'D']
r = 2

comb = combinations(data, r)
"""
('A', 'B')
('A', 'C')
('A', 'D')
('B', 'C')
('B', 'D')
('C', 'D')
"""

#숫자 리스트 조합
numbers = [1, 2, 3, 4]
r = 3

comb = combinations(numbers, r)
"""
(1, 2, 3)
(1, 2, 4)
(1, 3, 4)
(2, 3, 4)
"""

#문자열 조합
string = "ABCDE"
r = 2

comb = combinations(string, r)
"""
AB
AC
AD
AE
BC
BD
BE
CD
CE
DE
"""

#리스트로 변환
data = [1, 2, 3, 4]
r = 2

comb = combinations(data, r)
comb_list = list(comb) #[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

 

순열 생성(Permutations)

from itertools import permutations

#기본 사용
data = ['A', 'B', 'C']
r = 2

perm = permutations(data, r)
"""
('A', 'B')
('A', 'C')
('B', 'A')
('B', 'C')
('C', 'A')
('C', 'B')
"""

#숫자 리스트의 순열
numbers = [1, 2, 3]
r = 3

perm = permutations(numbers, r)
"""
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
"""

#문자열의 순열
string = "ABC"
r = 2

perm = permutations(string, r)
"""
AB
AC
BA
BC
CA
CB
"""

#리스트로 변환
data = [1, 2, 3]
r = 2

perm = permutations(data, r)

perm_list = list(perm) #[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

• combinations: 순서를 고려하지 않고 r개의 요소를 선택
• permutations: 순서를 고려하여 r개의 요소를 선택

요소의 빈도수 계산

from collections import Counter

# 리스트를 사용한 예시
data = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
counter = Counter(data)
#Counter({'apple': 3, 'banana': 2, 'orange': 1})

# 문자열을 사용한 예시
text = "hello world"
counter = Counter(text)
#Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

#Counter 객체 초기화
counter = Counter(a=3, b=2, c=1)
#Counter({'a': 3, 'b': 2, 'c': 1})

counter = Counter({'a': 3, 'b': 2, 'c': 1})
#Counter({'a': 3, 'b': 2, 'c': 1})

#요소의 개수 업데이트
counter = Counter({'a': 3, 'b': 2})
counter.update({'a': 1, 'b': 2, 'c': 1})
#Counter({'a': 4, 'b': 4, 'c': 1})

#요소의 개수 감소
counter = Counter({'a': 3, 'b': 2})
counter.subtract({'a': 1, 'b': 2, 'c': 1})
#Counter({'a': 2, 'b': 0, 'c': -1})

#가장 빈도가 높은 요소
data = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
Counter(data).most_common() #[('apple', 3)]
Counter(data).most_common(2) #[('apple', 3), ('banana', 2)]

#요소의 개수 합
counter = Counter({'a': 3, 'b': 2, 'c': 1})
list(counter.elements()) #['a', 'a', 'a', 'b', 'b', 'c']

#Counter 객체 간의 연산
counter1 = Counter({'a': 3, 'b': 2})
counter2 = Counter({'a': 1, 'b': 2, 'c': 1})

# 덧셈
print(counter1 + counter2) #Counter({'a': 4, 'b': 4, 'c': 1})

# 뺄셈
print(counter1 - counter2) #Counter({'a': 2})

# 교집합
print(counter1 & counter2) #Counter({'a': 1, 'b': 2})

# 합집합
print(counter1 | counter2) #Counter({'a': 3, 'b': 2, 'c': 1})

 

 

2자리 수 포맷팅

• answer = f"{str: .2f}"

 

우선순위 큐

import heapq

#힙 생성 및 초기화
data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
heapq.heapify(data)

#힙에 요소 추가
heap = []
heapq.heappush(heap, 3)
heapq.heappush(heap, 1)
heapq.heappush(heap, 4)
heapq.heappush(heap, 1)
heapq.heappush(heap, 5)
#[1, 1, 4, 3, 5]

#힙에서 요소 제거
heapq.heappop(heap) # 1
print(heap) #[1, 3, 4, 5]

#우선순위 낮은 값 삭제
max_idx = list.index(max(list))
list.pop(max_idx)
heapq.heapify(list)

#힙에서 최소값 확인
print(heap[0]) # 1

#최대 힙 구현
max_heap = []
heapq.heappush(max_heap, -3)
heapq.heappush(max_heap, -1)
heapq.heappush(max_heap, -4)
heapq.heappush(max_heap, -1)
heapq.heappush(max_heap, -5)
print([-x for x in max_heap])
# [5, 1, 4, 1, 3]

# 최대값 제거
print(-heapq.heappop(max_heap))
# 5

#n개의 최소값/최대값 찾기
data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(heapq.nsmallest(3, data))
# [1, 1, 2]

print(heapq.nlargest(3, data))
# [9, 6, 5]

 

2024.05.08 - [IT] - [Python] 파이썬 문법 정리[1탄](변수, 리스트, for, while, if-elif-else)

[Python] 파이썬 문법 정리[1탄](변수, 리스트, for, while, if-elif-else)

2024.05.08 - [IT] - [Python] 파이썬 문법 정리[2탄] (함수, 반환문, 지역변수, 전역변수, 람다)

[Python] 파이썬 문법 정리[2탄] (함수, 반환문, 지역변수, 전역변수, 람다)

2024.05.22 - [IT] - [Python] 파이썬 문법 정리[3탄] (자료형, 문자열과 리스트, Tuple, Dictionary, Set)

[Python] 파이썬 문법 정리[3탄] (자료형, 문자열과 리스트, Tuple, Dictionary, Set)