파이썬 문법 요약
목차
기본 문법
변수 및 자료형: 변수 할당, 숫자형, 문자열, 리스트, 튜플, 딕셔너리, 집합
조건문과 반복문: if문, for문, while문
연산자: 산술 연산자, 비교 연산자, 논리 연산자
자료구조와 함수
리스트(List): 선언, 인덱싱과 슬라이싱, 리스트 관련 함수
문자열(String): 인덱싱과 슬라이싱, 문자열 관련 함수
튜플(Tuple): 선언, 인덱싱과 슬라이싱
딕셔너리(Dictionary): 선언, 추가 및 삭제, 키와 값 접근
집합(Set): 선언, 추가 및 삭제, 집합 연산
함수(Function): 함수 정의, 매개변수와 반환값, 람다 함수
정렬과 탐색
정렬(Sorting): 파이썬 내장 정렬 함수(sorted, sort), 정렬 라이브러리 (heapq, bisect)
이진 탐색(Binary Search): 이진 탐색 구현 방법, bisect 라이브러리
그래프 알고리즘
그래프(Graph): 그래프 구현 방법, 인접 행렬과 인접 리스트
너비 우선 탐색(BFS): 큐(queue)를 활용한 BFS 구현
깊이 우선 탐색(DFS): 재귀 함수를 활용한 DFS 구현
동적 계획법(Dynamic Programming)
다이나믹 프로그래밍: 메모이제이션(Memoization), 탑다운(Top-down)과 바텀업(Bottom-up) 방식
유용한 파이썬 라이브러리
itertools: 순열과 조합을 생성하는 함수 제공
collections: 유용한 자료구조인 deque, Counter 등을 제공
heapq: 힙(Heap) 자료구조와 힙 정렬(Heap Sort)을 제공
bisect: 이진 탐색(Binary Search)을 제공
math: 수학적인 연산을 위한 함수 제공 (팩토리얼, 제곱근, 최대공약수 등)
sys: 입력과 출력에 관련된 기능 제공 (입력 속도를 빠르게 처리할 수 있는 sys.stdin.readline()함수)
본문
기본 문법
변수 및 자료형
변수 및 자료형: 변수 할당, 숫자형, 문자열, 리스트, 튜플, 딕셔너리, 집합
예시:
# 변수 할당
a = 10
b = "hello"
c = [1, 2, 3]
숫자형
a = 10
b = 3.14
c = 2 + 3j
문자열
a = "hello"
b = 'world'
리스트
a = [1, 2, 3, 4, 5]
b = ["apple", "banana", "orange"]
튜플
a = (1, 2, 3)
b = ("apple", "banana", "orange")
딕셔너리
a = {"name": "Alice", "age": 25, "city": "Seoul"}
집합
a = {1, 2, 3}
b = {3, 4, 5}
조건문과 반복문
조건문과 반복문: if문, for문, while문
예시:
# if문
if a > b:
print("a is greater than b")
elif a < b:
print("a is less than b")
else:
print("a is equal to b")
# for문
for i in range(10):
print(i)
for fruit in ["apple", "banana", "orange"]:
print(fruit)
# while문
i = 0
while i < 10:
print(i)
i += 1
연산자
연산자: 산술 연산자, 비교 연산자, 논리 연산자
예시:
# 산술 연산자
a = 10
b = 3
print(a + b) # 13
print(a - b) # 7
print(a * b) # 30
print(a / b) # 3.3333
print(a % b) # 1
print(a ** b) # 1000
# 비교 연산자
a = 10
b = 3
print(a > b) # True
print(a < b) # False
print(a == b) # False
print(a != b) # True
# 논리 연산자
a = True
b = False
print(a and b) # False
print(a or b) # True
print(not a) # False
자료구조와 함수
리스트(List)
리스트(List): 선언, 인덱싱과 슬라이싱, 리스트 관련 함수
예시:
# 리스트 선언
a = [1, 2, 3, 4, 5]
# 리스트 인덱싱과 슬라이싱
print(a[0]) # 1
print(a[-1]) # 5
print(a[1:4]) # [2, 3, 4]
print(a[:3]) # [1, 2, 3]
print(a[2:]) # [3, 4, 5]
# 리스트 관련 함수
a.append(6) # [1, 2, 3, 4, 5, 6]
a.sort() # [1, 2, 3, 4, 5, 6]
a.reverse() # [6, 5, 4, 3, 2, 1]
a.pop() # 1을 제거하고 반환, [6, 5, 4, 3, 2]
문자열(String)
문자열(String): 인덱싱과 슬라이싱, 문자열 관련 함수
예시:
# 문자열 인덱싱과 슬라이싱
s = "hello"
print(s[0]) # 'h'
print(s[-1]) # 'o'
print(s[1:4]) # 'ell'
print(s[:3]) # 'hel'
print(s[2:]) # 'llo'
# 문자열 관련 함수
s = "hello"
print(len(s)) # 5
print(s.upper()) # 'HELLO'
print(s.lower()) # 'hello'
print(s.replace('h', 'j')) # 'jello'
튜플(Tuple)
튜플(Tuple): 선언, 인덱싱과 슬라이싱
예시:
# 튜플 선언
t = (1, 2, 3, 4, 5)
# 튜플 인덱싱과 슬라이싱
print(t[0]) # 1
print(t[-1]) # 5
print(t[1:4]) # (2, 3, 4)
print(t[:3]) # (1, 2, 3)
print(t[2:]) # (3, 4, 5)
딕셔너리(Dictionary)
딕셔너리(Dictionary): 선언, 추가 및 삭제, 키와 값 접근
예시:
# 딕셔너리 선언
d = {"name": "Alice", "age": 25, "city": "Seoul"}
# 추가 및 삭제
d["gender"] = "female"
del d["age"]
# 키와 값 접근
print(d["name"]) # "Alice"
print(d.get("age")) # None (키가 존재하지 않음)
print(d.keys()) # dict_keys(['name', 'city', 'gender'])
print(d.values()) # dict_values(['Alice', 'Seoul', 'female'])
집합(Set)
집합(Set): 선언, 추가 및 삭제, 집합 연산
예시:
# 집합 선언
s = {1, 2, 3}
# 추가 및 삭제
s.add(4)
s.remove(2)
# 집합 연산
s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.union(s2)) # {1, 2, 3, 4, 5}
print(s1.intersection(s2)) # {3}
print(s1.difference(s2)) # {1, 2}
함수(Function)
함수(Function): 함수 정의, 매개변수와 반환값, 람다 함수
예시:
# 함수 정의
def add(a, b):
return a + b
# 매개변수와 반환값
result = add(3, 5)
print(result) # 8
# 람다 함수
square = lambda x: x ** 2
print(square(3)) # 9
정렬과 탐색
정렬(Sorting)
정렬(Sorting): 파이썬 내장 정렬 함수(sorted, sort), 정렬 라이브러리(heapq, bisect)
예시:
# 파이썬 내장 정렬 함수
a = [3, 1, 4, 2, 5]
sorted_a = sorted(a)
print(sorted_a) # [1, 2, 3, 4, 5]
# 리스트 자체를 정렬
a.sort()
print(a) # [1, 2, 3, 4, 5]
# heapq 라이브러리
import heapq
a = [3, 1, 4, 2, 5]
heapq.heapify(a)
print(heapq.heappop(a)) # 1
print(heapq.heappop(a)) # 2
# bisect 라이브러리
import bisect
a = [1, 2, 4, 4, 6]
print(bisect.bisect_left(a, 4)) # 2
print(bisect.bisect_right(a, 4)) # 4
이진 탐색(Binary Search)
이진 탐색(Binary Search): 이진 탐색 구현 방법, bisect 라이브러리
예시:
# 이진 탐색 구현 방법
def binary_search(array, target):
start = 0
end = len(array) - 1
while start <= end:
mid = (start + end) // 2
if array[mid] == target:
return mid
elif array[mid] < target:
start = mid + 1
else:
end = mid - 1
return -1
# bisect 라이브러리
import bisect
a = [1, 2, 4, 4, 6]
print(bisect.bisect_left(a, 4)) # 2
print(bisect.bisect_right(a, 4)) # 4
그래프 알고리즘
그래프(Graph)
그래프(Graph): 그래프 구현 방법, 인접 행렬과 인접 리스트
예시:
# 그래프 구현 방법 - 인접 행렬
graph = [[0] * (n+1) for _ in range(n+1)]
graph[1][2] = 1
graph[2][1] = 1
graph[1][3] = 1
graph[3][1] = 1
graph[2][3] = 1
graph[3][2] = 1
graph[2][4] = 1
graph[4][2] = 1
# ...
# 그래프 출력
for row in graph:
print(row)
# 그래프 구현 방법 - 인접 리스트
graph = [[] for _ in range(n+1)]
graph[1].append(2)
graph[2].append(1)
graph[1].append(3)
graph[3].append(1)
graph[2].append(3)
graph[3].append(2)
graph[2].append(4)
graph[4].append(2)
# ...
# 인접 행렬 예시
# 1 2 3 4
# 1 0 1 0 0
# 2 1 0 1 1
# 3 0 1 0 1
# 4 0 1 1 0
너비 우선 탐색(BFS)
너비 우선 탐색(BFS): 큐(queue)를 활용한 BFS 구현
예시:
from collections import deque
def bfs(graph, start):
visited = [False] * len(graph)
queue = deque([start])
visited[start] = True
while queue:
node = queue.popleft()
print(node, end=' ')
for adjacent_node in graph[node]:
if not visited[adjacent_node]:
queue.append(adjacent_node)
visited[adjacent_node] = True
# 그래프 예시
graph = [
[], # 0번 노드는 사용하지 않음
[2, 3, 4], # 1번 노드와 연결된 노드들
[1, 4], # 2번 노드와 연결된 노드들
[1, 4], # 3번 노드와 연결된 노드들
[1, 2, 3] # 4번 노드와 연결된 노드들
]
bfs(graph, 1) # 1 2 3 4
깊이 우선 탐색(DFS)
깊이 우선 탐색(DFS): 재귀 함수를 활용한 DFS 구현
예시:
def dfs(graph, node, visited):
visited[node] = True
print(node, end=' ')
for adjacent_node in graph[node]:
if not visited[adjacent_node]:
dfs(graph, adjacent_node, visited)
# 그래프 예시
graph = [
[], # 0번 노드는 사용하지 않음
[2, 3, 4], # 1번 노드와 연결된 노드들
[1, 4], # 2번 노드와 연결된 노드들
[1, 4], # 3번 노드와 연결된 노드들
[1, 2, 3] # 4번 노드와 연결된 노
]
visited = [False] * len(graph)
dfs(graph, 1, visited) # 1 2 4 3
최단 경로 알고리즘
최단 경로 알고리즘: 다익스트라 알고리즘, 플로이드-워셜 알고리즘
예시:
import heapq
import sys
def dijkstra(graph, start):
distance = [sys.maxsize] * len(graph)
distance[start] = 0
queue = []
heapq.heappush(queue, (0, start))
while queue:
dist, node = heapq.heappop(queue)
if distance[node] < dist:
continue
for adjacent_node, weight in graph[node]:
cost = dist + weight
if cost < distance[adjacent_node]:
distance[adjacent_node] = cost
heapq.heappush(queue, (cost, adjacent_node))
return distance
# 그래프 예시
graph = [
[], # 0번 노드는 사용하지 않음
[(2, 3), (3, 5), (4, 4)], # 1번 노드와 연결된 노드들과 가중치
[(1, 3), (4, 1)], # 2번 노드와 연결된 노드들과 가중치
[(1, 5), (4, 2)], # 3번 노드와 연결된 노드들과 가중치
[(1, 4), (2, 1), (3, 2)] # 4번 노드와 연결된 노드들과 가중치
]
start_node = 1
distances = dijkstra(graph, start_node)
print(distances) # [inf, 0, 3, 5, 4]
댓글