파이썬 예시 코드 200선

print("안녕하세요, 파이썬!")

안녕하세요, 파이썬!

name = "인수샘"
age = 30
print(name, age)

인수샘 30

score = 95
print(score)

95

height = 1.72
weight = 68.5
bmi = weight / (height ** 2)
print(round(bmi, 2))

23.15

name = input("이름: ")
print("반갑습니다,", name)

입력값에 따라 달라짐

a = int(input("첫 번째 수: "))
b = int(input("두 번째 수: "))
print("합:", a + b)

입력값에 따라 달라짐

a = 10
b = 3
print(a + b)
print(a - b)
print(a * b)
print(a / b)

13
7
30
3.3333333333333335

n = 17
print("몫:", n // 5)
print("나머지:", n % 5)

몫: 3
나머지: 2

first = "Data"
second = "Science"
print(first + " " + second)

Data Science

word = "파이썬 "
print(word * 3)

파이썬 파이썬 파이썬 

text = "인공지능"
print(len(text))

4

text = "Python"
print(text[0])
print(text[-1])

P
n

text = "Information"
print(text[0:4])
print(text[4:])

Info
rmation

text = "Python Data"
print(text.upper())
print(text.lower())

PYTHON DATA
python data

text = "   데이터 분석   "
print(text.strip())

데이터 분석

text = "나는 자바를 배운다."
print(text.replace("자바", "파이썬"))

나는 파이썬을 배운다.

data = "서울,부산,광주"
cities = data.split(",")
print(cities)

['서울', '부산', '광주']

name = "민수"
score = 88
print(f"{name}의 점수는 {score}점입니다.")

민수의 점수는 88점입니다.

n = 7
if n > 0:
    print("양수")

양수

n = 12
if n % 2 == 0:
    print("짝수")
else:
    print("홀수")

짝수

score = 87
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"
print(grade)

B

age = 17
if 14 <= age <= 19:
    print("청소년")

청소년

temperature = 25
rain = False
if temperature >= 20 and not rain:
    print("야외 활동 가능")

야외 활동 가능

for i in range(1, 6):
    print(i)

1
2
3
4
5

total = 0
for i in range(10):
    total += i
print(total)

45

for i in range(1, 10):
    print(f"2 × {i} = {2*i}")

2 × 1 = 2 ... 2 × 9 = 18

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

5
4
3
2
1

count = 1
while count <= 5:
    print(count)
    count += 1

1
2
3
4
5

for i in range(1, 11):
    if i == 6:
        break
    print(i)

1
2
3
4
5

for i in range(1, 6):
    if i == 3:
        continue
    print(i)

1
2
4
5

fruits = ["사과", "배", "포도"]
print(fruits)

['사과', '배', '포도']

numbers = [10, 20, 30, 40]
print(numbers[1])
print(numbers[-1])

20
40

colors = ["빨강", "파랑", "초록"]
colors[1] = "노랑"
print(colors)

['빨강', '노랑', '초록']

scores = [80, 90]
scores.append(100)
print(scores)

[80, 90, 100]

animals = ["고양이", "개", "토끼"]
animals.remove("개")
print(animals)

['고양이', '토끼']

numbers = [5, 2, 8, 1]
numbers.sort()
print(numbers)

[1, 2, 5, 8]

numbers = [12, 7, 25, 3]
print(max(numbers))
print(min(numbers))

25
3

scores = [80, 90, 70, 100]
average = sum(scores) / len(scores)
print(average)

85.0

point = (3, 5)
print(point[0], point[1])

3 5

numbers = [1, 2, 2, 3, 3, 3]
unique = set(numbers)
print(unique)

{1, 2, 3}

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a & b)

{3, 4}

student = {"이름": "지훈", "점수": 92}
print(student["이름"])

지훈

student = {"이름": "지훈", "점수": 92}
student["점수"] = 95
print(student)

{'이름': '지훈', '점수': 95}

scores = {"민수": 90, "영희": 85}
for name, score in scores.items():
    print(name, score)

민수 90
영희 85

text = "123"
number = int(text)
print(number + 10)

133

age = 18
message = "나이: " + str(age)
print(message)

나이: 18

value = 3.141592
print(round(value, 3))

3.142

print(abs(-15))
print(abs(3.5))

15
3.5

x = 10
y = "10"
print(type(x))
print(type(y))

<class 'int'>
<class 'str'>

# 원의 넓이를 계산한다.
radius = 5
area = 3.14 * radius ** 2
print(area)

78.5

def greet(name):
    return f"{name}님, 반갑습니다."

print(greet("서연"))

서연님, 반갑습니다.

def larger(a, b):
    if a > b:
        return a
    return b

print(larger(10, 7))

10

def power(base, exponent=2):
    return base ** exponent

print(power(5))
print(power(2, 3))

25
8

def profile(name, age, city):
    print(name, age, city)

profile(city="전주", name="민수", age=17)

민수 17 전주

def total(*numbers):
    return sum(numbers)

print(total(1, 2, 3, 4))

10

message = "전역"

def show():
    message = "지역"
    print(message)

show()
print(message)

지역
전역

def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))

120

square = lambda x: x ** 2
print(square(6))

36

squares = [x ** 2 for x in range(1, 6)]
print(squares)

[1, 4, 9, 16, 25]

evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)

[2, 4, 6, 8, 10]

matrix = [[1, 2], [3, 4], [5, 6]]
print(matrix[1][0])

3

fruits = ["사과", "배", "포도"]
for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)

1 사과
2 배
3 포도

names = ["민수", "영희", "철수"]
scores = [90, 85, 88]
for name, score in zip(names, scores):
    print(name, score)

민수 90
영희 85
철수 88

words = ["python", "ai", "data"]
print(sorted(words, key=len))

['ai', 'data', 'python']

students = [
    {"name": "민수", "score": 88},
    {"name": "영희", "score": 95}
]
result = sorted(students, key=lambda x: x["score"], reverse=True)
print(result)

[{'name': '영희', 'score': 95}, {'name': '민수', 'score': 88}]

words = ["파이썬", "데이터", "인공지능"]
print(" · ".join(words))

파이썬 · 데이터 · 인공지능

text = "파이썬 데이터 분석"
print("데이터" in text)
print("자바" in text)

True
False

text = "banana"
counts = {}
for ch in text:
    counts[ch] = counts.get(ch, 0) + 1
print(counts)

{'b': 1, 'a': 3, 'n': 2}

squares = {x: x ** 2 for x in range(1, 6)}
print(squares)

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

a = {"국어": 90, "영어": 85}
b = {"수학": 95}
merged = a | b
print(merged)

{'국어': 90, '영어': 85, '수학': 95}

a = {1, 2, 3}
b = {3, 4, 5}
print(a ^ b)

{1, 2, 4, 5}

try:
    print(10 / 0)
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")

0으로 나눌 수 없습니다.

try:
    age = int(input("나이: "))
    print(age)
except ValueError:
    print("정수를 입력하세요.")

입력값에 따라 달라짐

try:
    value = int("100")
    print(value)
finally:
    print("작업 종료")

100
작업 종료

with open("memo.txt", "w", encoding="utf-8") as file:
    file.write("파이썬 파일 저장")
print("저장 완료")

저장 완료

with open("memo.txt", "r", encoding="utf-8") as file:
    content = file.read()
print(content)

파이썬 파일 저장

with open("memo.txt", "a", encoding="utf-8") as file:
    file.write("\n새로운 줄")

파일 내용에 새로운 줄 추가

with open("memo.txt", "r", encoding="utf-8") as file:
    for line in file:
        print(line.strip())

파일 내용에 따라 달라짐

import math
print(math.sqrt(81))
print(round(math.pi, 4))

9.0
3.1416

import random
number = random.randint(1, 6)
print(number)

실행할 때마다 달라짐

import random
menu = ["김밥", "라면", "비빔밥"]
print(random.choice(menu))

실행할 때마다 달라짐

from datetime import datetime
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M"))

실행 시각에 따라 달라짐

from datetime import date
start = date(2026, 3, 1)
end = date(2026, 3, 15)
print((end - start).days)

14

class Student:
    def __init__(self, name):
        self.name = name

student = Student("민수")
print(student.name)

민수

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

r = Rectangle(4, 5)
print(r.area())

20

class Book:
    def __init__(self, title):
        self.title = title

    def __str__(self):
        return f"책: {self.title}"

print(Book("데미안"))

책: 데미안

class Animal:
    def sound(self):
        return "소리"

class Dog(Animal):
    def sound(self):
        return "멍멍"

print(Dog().sound())

멍멍

class Counter:
    count = 0

    def __init__(self):
        Counter.count += 1

Counter()
Counter()
print(Counter.count)

2

numbers = [4, 7, 2, 9, 5]
target = 9
position = -1
for i, value in enumerate(numbers):
    if value == target:
        position = i
        break
print(position)

3

numbers = [5, 3, 8, 1]
for end in range(len(numbers)-1, 0, -1):
    for i in range(end):
        if numbers[i] > numbers[i+1]:
            numbers[i], numbers[i+1] = numbers[i+1], numbers[i]
print(numbers)

[1, 3, 5, 8]

n = 29
is_prime = n >= 2
for i in range(2, int(n ** 0.5) + 1):
    if n % i == 0:
        is_prime = False
        break
print(is_prime)

True

a, b = 48, 18
while b:
    a, b = b, a % b
print(a)

6

a, b = 0, 1
for _ in range(10):
    print(a, end=" ")
    a, b = b, a + b

0 1 1 2 3 5 8 13 21 34

stack = []
stack.append("A")
stack.append("B")
print(stack.pop())
print(stack)

B
['A']

from collections import deque
queue = deque(["A", "B"])
queue.append("C")
print(queue.popleft())
print(queue)

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

from collections import Counter
words = ["사과", "배", "사과", "포도", "사과"]
print(Counter(words))

Counter({'사과': 3, '배': 1, '포도': 1})

from collections import defaultdict
groups = defaultdict(list)
for name, class_no in [("민수", 1), ("영희", 2), ("철수", 1)]:
    groups[class_no].append(name)
print(dict(groups))

{1: ['민수', '철수'], 2: ['영희']}

from itertools import product
for item in product(["A", "B"], [1, 2]):
    print(item)

('A', 1)
('A', 2)
('B', 1)
('B', 2)

from itertools import combinations
students = ["민수", "영희", "철수"]
print(list(combinations(students, 2)))

[('민수', '영희'), ('민수', '철수'), ('영희', '철수')]

import csv
rows = [["이름", "점수"], ["민수", 90], ["영희", 95]]
with open("scores.csv", "w", newline="", encoding="utf-8-sig") as file:
    writer = csv.writer(file)
    writer.writerows(rows)
print("CSV 저장 완료")

CSV 저장 완료

import csv
with open("scores.csv", "r", encoding="utf-8-sig") as file:
    reader = csv.DictReader(file)
    for row in reader:
        print(row["이름"], row["점수"])

민수 90
영희 95

import json
data = {"name": "민수", "scores": [90, 88, 95]}
with open("student.json", "w", encoding="utf-8") as file:
    json.dump(data, file, ensure_ascii=False, indent=2)

student.json 생성

import json
with open("student.json", "r", encoding="utf-8") as file:
    data = json.load(file)
print(data["scores"])

[90, 88, 95]

from pathlib import Path
folder = Path("results")
folder.mkdir(exist_ok=True)
print(folder.exists())

True

from pathlib import Path
for path in Path(".").glob("*.py"):
    print(path.name)

현재 폴더의 .py 파일 목록

from pathlib import Path
path = Path("memo.txt")
if path.exists():
    print(path.stat().st_size)

파일에 따라 달라짐

import re
text = "온도는 23도, 습도는 58퍼센트입니다."
numbers = re.findall(r"\d+", text)
print(numbers)

['23', '58']

import re
email = "student@example.com"
pattern = r"^[\w.-]+@[\w.-]+\.[A-Za-z]{2,}$"
print(bool(re.match(pattern, email)))

True

import hashlib
text = "mypassword"
digest = hashlib.sha256(text.encode("utf-8")).hexdigest()
print(digest)

64자리 16진수 문자열

import secrets
token = secrets.token_urlsafe(16)
print(token)

실행할 때마다 달라짐

import html
text = "<script>alert('XSS')</script>"
print(html.escape(text))

<script>alert('XSS')</script>

import statistics
data = [10, 20, 20, 30, 100]
print(statistics.mean(data))
print(statistics.median(data))
print(statistics.mode(data))

36
20
20

import statistics
data = [70, 75, 80, 85, 90]
print(round(statistics.pstdev(data), 2))

7.07

import statistics
x = [1, 2, 3, 4, 5]
y = [2, 4, 5, 4, 5]
mx, my = statistics.mean(x), statistics.mean(y)
num = sum((a-mx)*(b-my) for a, b in zip(x, y))
den = (sum((a-mx)**2 for a in x) * sum((b-my)**2 for b in y)) ** 0.5
print(round(num / den, 3))

0.775

import random
counts = {i: 0 for i in range(1, 7)}
for _ in range(1000):
    counts[random.randint(1, 6)] += 1
print(counts)

각 값이 약 167회 전후

import random
inside = 0
trials = 100000
for _ in range(trials):
    x, y = random.random(), random.random()
    if x*x + y*y <= 1:
        inside += 1
print(4 * inside / trials)

약 3.14

import random
answer = random.randint(1, 20)
while True:
    guess = int(input("1~20: "))
    if guess == answer:
        print("정답")
        break
    print("더 큼" if guess < answer else "더 작음")

입력에 따라 달라짐

import random
choices = ["가위", "바위", "보"]
computer = random.choice(choices)
user = "가위"
if user == computer:
    result = "무승부"
elif (user, computer) in [("가위","보"),("바위","가위"),("보","바위")]:
    result = "승리"
else:
    result = "패배"
print(computer, result)

실행할 때마다 달라짐

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            return True
        return False

account = BankAccount("민수", 10000)
account.deposit(5000)
account.withdraw(3000)
print(account.balance)

12000

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("절대영도보다 낮을 수 없습니다.")
        self._celsius = value

print(Temperature(25).celsius)

25

class Circle:
    def area(self):
        return 3.14 * 2 ** 2

class Square:
    def area(self):
        return 4 ** 2

shapes = [Circle(), Square()]
print([shape.area() for shape in shapes])

[12.56, 16]

from dataclasses import dataclass

@dataclass
class Student:
    name: str
    score: int

student = Student("민수", 95)
print(student)

Student(name='민수', score=95)

class Person:
    count = 0

    def __init__(self, name):
        self.name = name
        Person.count += 1

    @classmethod
    def total(cls):
        return cls.count

Person("민수")
Person("영희")
print(Person.total())

2

class Calculator:
    @staticmethod
    def add(a, b):
        return a + b

print(Calculator.add(3, 4))

7

def announce(func):
    def wrapper():
        print("시작")
        func()
        print("끝")
    return wrapper

@announce
def study():
    print("파이썬 공부")

study()

시작
파이썬 공부
끝

def make_multiplier(n):
    def multiply(x):
        return x * n
    return multiply

double = make_multiplier(2)
print(double(7))

14

def countdown(n):
    while n > 0:
        yield n
        n -= 1

for value in countdown(5):
    print(value)

5
4
3
2
1

squares = (x ** 2 for x in range(1000000))
print(next(squares))
print(next(squares))

0
1

numbers = [1, 2, 3, 4]
result = list(map(lambda x: x * 10, numbers))
print(result)

[10, 20, 30, 40]

numbers = [1, 2, 3, 4, 5, 6]
result = list(filter(lambda x: x % 2 == 0, numbers))
print(result)

[2, 4, 6]

from functools import reduce
numbers = [1, 2, 3, 4]
product = reduce(lambda a, b: a * b, numbers)
print(product)

24

def binary_search(data, target):
    left, right = 0, len(data) - 1
    while left <= right:
        mid = (left + right) // 2
        if data[mid] == target:
            return mid
        if data[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

print(binary_search([1,3,5,7,9], 7))

3

data = [64, 25, 12, 22, 11]
for i in range(len(data)-1):
    min_index = i
    for j in range(i+1, len(data)):
        if data[j] < data[min_index]:
            min_index = j
    data[i], data[min_index] = data[min_index], data[i]
print(data)

[11, 12, 22, 25, 64]

data = [5, 2, 4, 6, 1, 3]
for i in range(1, len(data)):
    key = data[i]
    j = i - 1
    while j >= 0 and data[j] > key:
        data[j+1] = data[j]
        j -= 1
    data[j+1] = key
print(data)

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

def merge_sort(data):
    if len(data) <= 1:
        return data
    mid = len(data) // 2
    left = merge_sort(data[:mid])
    right = merge_sort(data[mid:])
    result = []
    while left and right:
        result.append(left.pop(0) if left[0] < right[0] else right.pop(0))
    return result + left + right

print(merge_sort([5, 1, 4, 2, 8]))

[1, 2, 4, 5, 8]

def quick_sort(data):
    if len(data) <= 1:
        return data
    pivot = data[0]
    left = [x for x in data[1:] if x <= pivot]
    right = [x for x in data[1:] if x > pivot]
    return quick_sort(left) + [pivot] + quick_sort(right)

print(quick_sort([5, 3, 8, 1, 2]))

[1, 2, 3, 5, 8]

graph = {
    "A": ["B", "C"],
    "B": ["A", "D"],
    "C": ["A"],
    "D": ["B"]
}
print(graph["A"])

['B', 'C']

from collections import deque

graph = {"A":["B","C"], "B":["D"], "C":["E"], "D":[], "E":[]}
queue = deque(["A"])
visited = {"A"}
while queue:
    node = queue.popleft()
    print(node, end=" ")
    for nxt in graph[node]:
        if nxt not in visited:
            visited.add(nxt)
            queue.append(nxt)

A B C D E

graph = {"A":["B","C"], "B":["D"], "C":["E"], "D":[], "E":[]}
visited = set()

def dfs(node):
    visited.add(node)
    print(node, end=" ")
    for nxt in graph[node]:
        if nxt not in visited:
            dfs(nxt)

dfs("A")

A B D C E

def divide(a, b):
    assert b != 0, "b는 0이 아니어야 합니다."
    return a / b

print(divide(10, 2))

5.0

import unittest

def add(a, b):
    return a + b

class TestAdd(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)

if __name__ == "__main__":
    unittest.main()

테스트 통과 메시지

import logging
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
logging.info("프로그램 시작")
logging.warning("주의가 필요합니다.")

INFO와 WARNING 메시지

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--name", default="사용자")
args = parser.parse_args()
print(f"안녕하세요, {args.name}")

실행 인자에 따라 달라짐

import os
value = os.getenv("APP_MODE", "development")
print(value)

설정에 따라 달라짐

from time import perf_counter
start = perf_counter()
total = sum(range(1_000_000))
elapsed = perf_counter() - start
print(total)
print(round(elapsed, 6))

합계와 실행 시간

import heapq
heap = []
for value in [5, 1, 3]:
    heapq.heappush(heap, value)
while heap:
    print(heapq.heappop(heap), end=" ")

1 3 5

import bisect
data = [1, 3, 5, 7]
bisect.insort(data, 4)
print(data)

[1, 3, 4, 5, 7]

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(35))

9227465

import pickle
data = {"name": "민수", "score": 95}
with open("data.pkl", "wb") as file:
    pickle.dump(data, file)
with open("data.pkl", "rb") as file:
    loaded = pickle.load(file)
print(loaded)

{'name': '민수', 'score': 95}

def average(values: list[float]) -> float:
    if not values:
        raise ValueError("빈 리스트입니다.")
    return sum(values) / len(values)

print(average([80.0, 90.0, 100.0]))

90.0

from typing import TypeVar

T = TypeVar("T")

def first(items: list[T]) -> T:
    return items[0]

print(first([10, 20, 30]))

10

from typing import Protocol

class HasArea(Protocol):
    def area(self) -> float: ...

def print_area(shape: HasArea) -> None:
    print(shape.area())

class Square:
    def area(self) -> float:
        return 16.0

print_area(Square())

16.0

command = ("move", 10, 20)
match command:
    case ("move", x, y):
        print(f"{x}, {y}로 이동")
    case ("stop",):
        print("정지")
    case _:
        print("알 수 없음")

10, 20로 이동

numbers = [1, 2, 3, 4, 5]
if (count := len(numbers)) > 3:
    print(f"항목 수: {count}")

항목 수: 5

class Timer:
    def __enter__(self):
        from time import perf_counter
        self.start = perf_counter()
        return self

    def __exit__(self, exc_type, exc, tb):
        from time import perf_counter
        print(round(perf_counter() - self.start, 6))

with Timer():
    sum(range(100000))

실행 시간 출력

from contextlib import contextmanager

@contextmanager
def managed_resource():
    print("자원 열기")
    try:
        yield "데이터"
    finally:
        print("자원 닫기")

with managed_resource() as value:
    print(value)

자원 열기
데이터
자원 닫기

class InvalidScoreError(Exception):
    pass

def validate_score(score):
    if not 0 <= score <= 100:
        raise InvalidScoreError("점수 범위 오류")
    return score

print(validate_score(95))

95

try:
    int("abc")
except ValueError as error:
    raise RuntimeError("데이터 변환 실패") from error

예외 추적 정보 출력

from functools import partial

def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
print(square(7))

49

from functools import singledispatch

@singledispatch
def describe(value):
    return "기타"

@describe.register
def _(value: int):
    return "정수"

@describe.register
def _(value: str):
    return "문자열"

print(describe(10), describe("a"))

정수 문자열

class CountDown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        value = self.current
        self.current -= 1
        return value

print(list(CountDown(5)))

[5, 4, 3, 2, 1]

class Config:
    debug = True
    port = 8000

config = Config()
for name in ["debug", "port"]:
    print(name, getattr(config, name))

debug True
port 8000

class Settings:
    pass

settings = Settings()
setattr(settings, "theme", "dark")
print(settings.theme)

dark

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def hello():
    print("안녕")

hello()

안녕
안녕
안녕

import timeit
list_time = timeit.timeit("[x*x for x in range(1000)]", number=1000)
loop_time = timeit.timeit("result=[]\nfor x in range(1000): result.append(x*x)", number=1000)
print(round(list_time, 4), round(loop_time, 4))

환경에 따라 달라짐

class Point:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(3, 4)
print(p.x, p.y)

3 4

data = bytearray(b"abcdef")
view = memoryview(data)
view[0] = ord("A")
print(data)

bytearray(b'Abcdef')

from concurrent.futures import ThreadPoolExecutor

def square(x):
    return x * x

with ThreadPoolExecutor(max_workers=3) as executor:
    print(list(executor.map(square, [1, 2, 3, 4])))

[1, 4, 9, 16]

from concurrent.futures import ProcessPoolExecutor

def square(x):
    return x * x

if __name__ == "__main__":
    with ProcessPoolExecutor() as executor:
        print(list(executor.map(square, [1, 2, 3, 4])))

[1, 4, 9, 16]

import asyncio

async def greet():
    await asyncio.sleep(1)
    print("비동기 작업 완료")

asyncio.run(greet())

1초 후 비동기 작업 완료

import asyncio

async def task(name, delay):
    await asyncio.sleep(delay)
    return name

async def main():
    result = await asyncio.gather(task("A", 1), task("B", 0.5))
    print(result)

asyncio.run(main())

['A', 'B']

import asyncio

async def slow():
    await asyncio.sleep(2)

async def main():
    try:
        await asyncio.wait_for(slow(), timeout=1)
    except asyncio.TimeoutError:
        print("시간 초과")

asyncio.run(main())

시간 초과

import sqlite3

with sqlite3.connect("school.db") as conn:
    conn.execute("CREATE TABLE IF NOT EXISTS students (name TEXT, score INTEGER)")
print("테이블 준비 완료")

테이블 준비 완료

import sqlite3

with sqlite3.connect("school.db") as conn:
    conn.execute("INSERT INTO students VALUES (?, ?)", ("민수", 95))
print("삽입 완료")

삽입 완료

import sqlite3

with sqlite3.connect("school.db") as conn:
    rows = conn.execute("SELECT name, score FROM students WHERE score >= ?", (90,))
    for row in rows:
        print(row)

저장 데이터에 따라 달라짐

from urllib.request import urlopen

with urlopen("https://example.com", timeout=5) as response:
    print(response.status)
    print(response.read(60).decode("utf-8", errors="ignore"))

상태 코드 200과 일부 HTML

from urllib.parse import urlencode
params = {"q": "파이썬 데이터", "page": 1}
print(urlencode(params))

q=%ED%8C%8C...&page=1

class Trie:
    def __init__(self):
        self.root = {}

    def insert(self, word):
        node = self.root
        for ch in word:
            node = node.setdefault(ch, {})
        node["$"] = True

    def contains(self, word):
        node = self.root
        for ch in word:
            if ch not in node:
                return False
            node = node[ch]
        return "$" in node

trie = Trie()
trie.insert("python")
print(trie.contains("python"))

True

weights = [2, 3, 4]
values = [3, 4, 5]
capacity = 5
dp = [0] * (capacity + 1)
for w, v in zip(weights, values):
    for c in range(capacity, w - 1, -1):
        dp[c] = max(dp[c], dp[c-w] + v)
print(dp[capacity])

7

data = [10, 20, 10, 30, 20, 50]
dp = [1] * len(data)
for i in range(len(data)):
    for j in range(i):
        if data[j] < data[i]:
            dp[i] = max(dp[i], dp[j] + 1)
print(max(dp))

4

import heapq

graph = {
    "A": [("B", 2), ("C", 5)],
    "B": [("C", 1)],
    "C": []
}
dist = {node: float("inf") for node in graph}
dist["A"] = 0
heap = [(0, "A")]
while heap:
    cost, node = heapq.heappop(heap)
    if cost > dist[node]:
        continue
    for nxt, weight in graph[node]:
        new_cost = cost + weight
        if new_cost < dist[nxt]:
            dist[nxt] = new_cost
            heapq.heappush(heap, (new_cost, nxt))
print(dist)

{'A': 0, 'B': 2, 'C': 3}

from collections import deque

graph = {"A":["C"], "B":["C"], "C":["D"], "D":[]}
indegree = {node: 0 for node in graph}
for node in graph:
    for nxt in graph[node]:
        indegree[nxt] += 1
queue = deque([n for n in graph if indegree[n] == 0])
order = []
while queue:
    node = queue.popleft()
    order.append(node)
    for nxt in graph[node]:
        indegree[nxt] -= 1
        if indegree[nxt] == 0:
            queue.append(nxt)
print(order)

['A', 'B', 'C', 'D'] 또는 A/B 순서 교환

parent = list(range(5))

def find(x):
    if parent[x] != x:
        parent[x] = find(parent[x])
    return parent[x]

def union(a, b):
    ra, rb = find(a), find(b)
    if ra != rb:
        parent[rb] = ra

union(0, 1)
union(1, 2)
print(find(0) == find(2))

True

n = 50
is_prime = [True] * (n + 1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(n ** 0.5) + 1):
    if is_prime[i]:
        for multiple in range(i*i, n+1, i):
            is_prime[multiple] = False
print([i for i, value in enumerate(is_prime) if value])

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

def sqrt_newton(value, tolerance=1e-10):
    guess = value / 2
    while abs(guess * guess - value) > tolerance:
        guess = (guess + value / guess) / 2
    return guess

print(sqrt_newton(2))

약 1.41421356237

def integrate(f, a, b, n=1000):
    h = (b - a) / n
    total = (f(a) + f(b)) / 2
    for i in range(1, n):
        total += f(a + i * h)
    return total * h

print(integrate(lambda x: x**2, 0, 1))

약 0.3333335

def euler(f, x0, y0, h, steps):
    x, y = x0, y0
    for _ in range(steps):
        y += h * f(x, y)
        x += h
    return x, y

x, y = euler(lambda x, y: y, 0, 1, 0.1, 10)
print(x, y)

약 1.0 2.5937

A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]
result = [[sum(A[i][k] * B[k][j] for k in range(2)) for j in range(2)] for i in range(2)]
print(result)

[[19, 22], [43, 50]]

class Discount:
    def apply(self, price):
        return price

class StudentDiscount:
    def apply(self, price):
        return price * 0.8

class Order:
    def __init__(self, strategy):
        self.strategy = strategy

    def total(self, price):
        return self.strategy.apply(price)

print(Order(StudentDiscount()).total(10000))

8000.0

class Subject:
    def __init__(self):
        self.observers = []

    def subscribe(self, observer):
        self.observers.append(observer)

    def notify(self, message):
        for observer in self.observers:
            observer(message)

subject = Subject()
subject.subscribe(lambda m: print("알림:", m))
subject.notify("새 데이터")

알림: 새 데이터

class Dog:
    def speak(self): return "멍멍"

class Cat:
    def speak(self): return "야옹"

def create_animal(kind):
    classes = {"dog": Dog, "cat": Cat}
    return classes[kind]()

print(create_animal("cat").speak())

야옹

from unittest.mock import Mock

service = Mock()
service.get_score.return_value = 95
print(service.get_score("민수"))
service.get_score.assert_called_once_with("민수")

95

from tempfile import NamedTemporaryFile

with NamedTemporaryFile(mode="w+", encoding="utf-8", delete=True) as file:
    file.write("테스트 데이터")
    file.seek(0)
    print(file.read())

테스트 데이터

import cProfile

def work():
    return sum(i*i for i in range(100000))

cProfile.run("work()")

프로파일링 표 출력

import logging
logging.basicConfig(
    filename="app.log",
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(message)s",
    encoding="utf-8"
)
logging.info("프로그램 시작")

app.log 생성

import configparser

config = configparser.ConfigParser()
config["APP"] = {"theme": "dark", "font_size": "14"}
with open("settings.ini", "w", encoding="utf-8") as file:
    config.write(file)
print("설정 저장")

설정 저장

from zipfile import ZipFile

with ZipFile("backup.zip", "w") as zip_file:
    zip_file.write("memo.txt")
print("압축 완료")

backup.zip 생성

import hmac
import hashlib

key = b"secret-key"
message = b"important data"
signature = hmac.new(key, message, hashlib.sha256).hexdigest()
print(signature)

64자리 서명

from html.parser import HTMLParser

class TitleParser(HTMLParser):
    def handle_starttag(self, tag, attrs):
        if tag == "h1":
            print("제목 태그 발견")

parser = TitleParser()
parser.feed("<h1>파이썬</h1>")

제목 태그 발견

def area(width: float, height: float) -> float:
    """직사각형의 넓이를 반환한다.

    Args:
        width: 가로 길이
        height: 세로 길이
    """
    return width * height

print(area.__doc__)

함수 설명 출력