파이썬 강의 핵심 요약

1~8장 전체 내용을 챕터별로 압축한 참고 자료입니다.

---

1장. 데이터 타입과 변수

Python 실행 방법

모드	특징	용도
CLI (>>>)	즉시 실행, 종료 시 사라짐	빠른 테스트
스크립트 (.py)	파일로 저장, 반복 실행	실제 프로그래밍

주요 데이터 타입

str     "hello"         # 문자열
int     42, -7          # 정수
float   3.14            # 실수
bool    True, False     # 참/거짓
list    [1, 2, 3]       # 리스트
tuple   (1, 2, 3)       # 튜플
dict    {"key": "val"}  # 딕셔너리

동적 타이핑 — Python은 값을 보고 타입을 자동 결정합니다.

A = 42          # int
A = "hello"     # str (재대입 가능)
print(type(A))  # <class 'str'>

내장 함수

input("이름: ")        # 입력 → 항상 str 반환
int(input("나이: "))   # 숫자로 쓰려면 형 변환 필요
print("결과:", x)
type(42)               # <class 'int'>
id(x)                  # 메모리 주소

---

2장. 연산자와 조건문

연산자

# 산술
+  -  *  /      # 사칙 (/ 는 항상 float)
//              # 몫        7 // 2  → 3
%               # 나머지    7 %  2  → 1
**              # 거듭제곱  2 ** 8  → 256

# 비교 (결과는 True/False)
==  !=  >  <  >=  <=

# 논리
and   or   not
1 <= x <= 10    # 연속 비교 가능

# 대입 단축
x += 1    x -= 1    x *= 2    x //= 2    x %= 3

우선순위: () > ** > * / > + - > 비교 > not > and > or

조건문

if 조건:
    ...
elif 조건:
    ...
else:
    ...

# 자주 쓰는 패턴
if x % 2 == 0:       # 짝수 판별
if x % 3 == 0:       # 3의 배수
if a <= x <= b:      # 범위 체크

들여쓰기가 코드 블록을 구분합니다. 들여쓰기가 없으면 에러입니다.

3장. while 반복문

while 조건:
    # 조건이 True인 동안 반복
    카운터 += 1   # 조건이 변해야 무한루프 방지

break / continue

while True:           # 무한 루프
    x = int(input())
    if x == 0:
        break         # 즉시 탈출
    if x < 0:
        continue      # 이번 회 건너뛰기
    print(x)

패턴 모음

# 1~n 합
total = 0
i = 1
while i <= n:
    total += i
    i += 1

# 카운트다운
n = 10
while n >= 0:
    print(n)
    n -= 1

# 피보나치
a, b = 0, 1
while a < 100:
    print(a)
    a, b = b, a + b

---

4장. for 반복문

for 변수 in 시퀀스:
    ...

range()

range(5)          # 0 1 2 3 4
range(1, 6)       # 1 2 3 4 5
range(0, 10, 2)   # 0 2 4 6 8
range(5, 0, -1)   # 5 4 3 2 1

자주 쓰는 패턴

# 리스트 순회
for fruit in ["apple", "banana"]:
    print(fruit)

# 인덱스 + 값
for i, v in enumerate(lst):
    print(i, v)

# 중첩 for (구구단)
for i in range(2, 10):
    for j in range(1, 10):
        print("{}x{}={}".format(i, j, i*j), end="  ")
    print()

# 값 필요 없을 때
for _ in range(3):
    print("반복")

알고리즘 맛보기

방법	설명	예시
탐욕 알고리즘	현재 최선 선택 반복	거스름돈
완전 탐색	모든 경우 시도	두 자리수 탐색

5장. 함수

def 함수명(매개변수):
    # 코드
    return 반환값

함수의 4가지 형태

def hi():                    # 매개변수 X, 반환값 X
    print("안녕")

def hello(name):             # 매개변수 O, 반환값 X
    print("안녕", name)

def get_age():               # 매개변수 X, 반환값 O
    return 18

def add(a, b):               # 매개변수 O, 반환값 O
    return a + b

스코프 (Scope)

x = 10           # 전역 변수

def f():
    x = 20       # 지역 변수 (전역 x와 별개)
    print(x)     # 20

def g():
    global x     # 전역 x를 수정할 때만 필요
    x = 99

f()
print(x)         # 10 (g() 호출 전)

기본값 매개변수 / 여러 값 반환

def power(base, exp=2):       # 기본값
    return base ** exp

def min_max(lst):
    return min(lst), max(lst) # 튜플로 반환

lo, hi = min_max([3,1,4,1,5]) # 언패킹

import

import math                   # math.sqrt(4)
from math import sqrt, pi     # sqrt(4)
import random as r            # r.randint(1, 10)

DRY 원칙

Don't Repeat Yourself — 같은 코드가 반복된다면 함수로 묶으세요.

6장. 클래스

class Monster:
    species = "몬스터"          # 클래스 변수 (공유)

    def __init__(self, name, hp):
        self.name = name        # 인스턴스 변수 (독립)
        self.hp = hp

    def attack(self):
        print(self.name, "공격!")

    def __str__(self):          # print() 시 호출
        return "{}(HP:{})".format(self.name, self.hp)

m = Monster("슬라임", 50)
print(m)            # 슬라임(HP:50)
m.attack()          # 슬라임 공격!

클래스 변수 함정

class Dog:
    tricks = []                  # [주의] 모든 객체가 공유!

class Dog:
    def __init__(self):
        self.tricks = []         # [올바름] 객체마다 독립

상속

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

    def speak(self):
        print("...")

class Dog(Animal):
    def speak(self):             # 오버라이딩
        print(self.name + ": 왈!")

class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)   # 부모 __init__ 호출
        self.color = color

접근 제어

self._value   # 관례적으로 비공개 (외부 사용 자제)
self.__value  # 이름 맹글링 — 외부 직접 접근 차단

6장 (예외/파일). 예외 처리와 파일 처리

예외 처리

try:
    x = int(input())
    result = 10 / x
except ValueError:
    print("숫자를 입력하세요")
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다")
else:
    print("결과:", result)   # 예외 없을 때만 실행
finally:
    print("항상 실행")       # 예외 여부 무관

주요 예외 종류

예외	발생 상황
ValueError	잘못된 값 (int("abc"))
ZeroDivisionError	0으로 나누기
IndexError	범위 밖 인덱스
KeyError	없는 딕셔너리 키
TypeError	타입 불일치 연산
FileNotFoundError	파일 없음

파일 처리

# 쓰기
with open("data.txt", "w", encoding="utf-8") as f:
    f.write("안녕\n")
    f.writelines(["줄1\n", "줄2\n"])

# 읽기
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()          # 전체
    line    = f.readline()      # 한 줄
    lines   = f.readlines()     # 전체 → 리스트

# 추가
with open("data.txt", "a", encoding="utf-8") as f:
    f.write("추가 내용\n")

with 문을 쓰면 자동으로 파일이 닫힙니다. encoding="utf-8"은 한글 파일 처리 시 필수입니다.

7장. 모듈과 패키지

import 방법

import math                    # math.sqrt(4)
from math import sqrt, pi      # sqrt(4)
import numpy as np             # np.array([1,2,3])

자주 쓰는 표준 라이브러리

# math
import math
math.sqrt(16)      # 4.0
math.pi            # 3.14159...
math.floor(3.7)    # 3
math.ceil(3.2)     # 4

# random
import random
random.random()              # 0.0 ~ 1.0 실수
random.randint(1, 10)        # 1~10 정수
random.choice(["a","b","c"]) # 리스트에서 1개
random.shuffle(lst)          # 리스트 섞기 (제자리)

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

# json
import json
json.dumps({"name": "지민"})  # dict → JSON 문자열
json.loads('{"name": "지민"}')# JSON 문자열 → dict

모듈 만들기

# calc.py
def add(a, b): return a + b

if __name__ == "__main__":     # 직접 실행 시에만 동작
    print(add(1, 2))

# main.py
from calc import add
print(add(3, 4))

8장. 리스트·튜플·딕셔너리

리스트 (list)

lst = [1, 2, 3, 4, 5]

# 인덱싱
lst[0]      # 1   (앞에서)
lst[-1]     # 5   (뒤에서)

# 슬라이싱  [시작:끝]  — 끝 미포함
lst[1:4]    # [2, 3, 4]
lst[:3]     # [1, 2, 3]
lst[::2]    # [1, 3, 5]   (2칸씩)
lst[::-1]   # [5, 4, 3, 2, 1]  (역순)

리스트 메서드

lst.append(6)       # 끝에 추가
lst.insert(1, 99)   # 인덱스 1에 삽입
lst.remove(3)       # 값 3 제거 (첫 번째)
lst.pop()           # 마지막 요소 꺼내기
lst.pop(0)          # 인덱스 0 꺼내기
lst.sort()          # 오름차순 정렬
lst.sort(reverse=True)  # 내림차순
lst.reverse()       # 순서 뒤집기
len(lst)            # 길이

튜플 (tuple)

t = (1, 2, 3)
t[0]           # 1   (인덱싱 가능)
# t[0] = 10   # 오류 — TypeError: 변경 불가

# 언패킹
x, y = (3, 7)
a, b = b, a    # 변수 교환

# 함수에서 여러 값 반환
def min_max(lst):
    return min(lst), max(lst)

lo, hi = min_max([3,1,4,1,5])

딕셔너리 (dict)

d = {"name": "지민", "age": 17}

d["name"]              # "지민"
d.get("score")         # None  (키 없어도 오류 없음)
d.get("score", 0)      # 0     (기본값 지정)

d["score"] = 92        # 추가
d["age"] = 18          # 수정
del d["score"]         # 삭제

d.keys()               # dict_keys(['name', 'age'])
d.values()             # dict_values(['지민', 18])
d.items()              # (키, 값) 쌍

for key, val in d.items():
    print(key, ":", val)

"name" in d            # True  (키 검색)

세 자료형 비교

	list	tuple	dict
생성	[1,2]	(1,2)	{"k":"v"}
접근	인덱스	인덱스	키
변경	가능	불가	가능
용도	목록 관리	불변 데이터	이름 있는 데이터

입출력 패턴 모음

# 단일 입력
n = int(input("수: "))

# 공백으로 여러 값
a, b = map(int, input().split())

# 여러 값 → 리스트
nums = list(map(int, input().split()))

# format 출력
print("{}의 점수: {}점".format(name, score))
print("{:.2f}".format(x))  # 소수점 2자리
print(1, 2, 3, sep=", ")   # 구분자 지정
print("A", end="")         # 줄바꿈 없이

---

핵심 원칙 모음

원칙	내용
동적 타이핑	타입 선언 불필요, 값이 타입을 결정
들여쓰기	코드 블록 구분 — 일관성 필수
DRY	반복되는 코드는 함수로 묶기
with 문	파일 처리 시 항상 with 사용
클래스 변수 함정	가변 속성은 __init__에서 self.로
파라미터 바인딩	SQL 값은 ? 플레이스홀더 사용
in 연산자	list/tuple → 값 검색, dict → 키 검색