Python — 학습 허브

01

변수 타입

변수 타입 (Variable Types)

변수는 데이터를 담아두는 이름표 붙은 상자입니다. 숫자·글자·참거짓처럼 데이터 종류마다 어울리는 상자 모양이 달라서, Python에는 9가지 기본 타입의 상자가 준비되어 있습니다.

9가지 기본 타입

• int — 정수 (예: 10) 나이, 개수
• float — 실수 (예: 3.14) 온도, 비율
• str — 문자열 (예: "Python") 큰따옴표/작은따옴표 모두 가능
• bool — 논리값 True / False
• list — 순서 있음, 수정 가능: ["red", "green"]
• tuple — 순서 있음, 수정 불가: (10, 20)
• dict — 키-값 쌍: {"name": "Tom"}
• set — 중복 불가, 순서 없음: {1, 2, 3}
• NoneType — 값 없음: None

변수 선언 예제

x = 10             # int
y = 3.14           # float
name = "Python"    # str
is_fun = True      # bool
colors = ["red", "green", "blue"]    # list
coords = (10, 20)                    # tuple
person = {"name": "Tom", "age": 30}  # dict
nums = {1, 2, 3}   # set
nothing = None     # NoneType

타입 확인

print(type(x))             # <class 'int'>
print(isinstance(x, int))  # True

변수 이름 짓기 규칙

• 영문자·숫자·_(밑줄)만 사용 가능 — 한글·공백·특수기호 ❌
• 숫자로 시작 불가 — 2name ❌ → name2 ✅
• 대·소문자 구분 — Age와 age는 다른 변수
• 예약어 사용 불가 — 아래 목록 참고

Python 예약어 (사용 금지 단어)

Python이 특별한 기능으로 미리 점유한 단어들. 변수 이름으로 쓰면 오류 발생.
• 조건·반복: if elif else for while break continue pass
• 함수·클래스: def return class lambda yield
• 논리·값: True False None and or not in is
• 모듈·예외: import from as try except finally raise with

네이밍 스타일 비교

• snake_case — 단어를 _로 연결. Python 변수·함수에서 공식 권장 (PEP 8)
• PascalCase — 단어마다 첫 글자를 대문자. Python 클래스 이름에 사용
• camelCase — 두 번째 단어부터 첫 글자를 대문자. JavaScript 스타일, Python에서는 비권장

# snake_case — 변수·함수 (Python 권장)
user_name = "Alice"
total_score = 100

# PascalCase — 클래스 이름
class UserProfile:
    pass

# camelCase — Python에서는 비권장 (JS 스타일)
userName = "Alice"   # ⚠️ Python 비권장 (PEP 8 위반, 동작은 됨)

# ❌ 잘못된 이름
2score = 95          # 숫자로 시작
user name = "AI"     # 공백 포함
if = 10              # 예약어 사용

02

기초 연산

기초 연산 (Operations)

숫자 계산에 쓰는 산술 연산자와 코드를 줄여주는 복합 대입 연산자 학습

산술 연산자

a = 5
b = 2

print(a + b)   # 7    덧셈
print(a - b)   # 3    뺄셈
print(a * b)   # 10   곱셈
print(a / b)   # 2.5  나눗셈
print(a // b)  # 2    몫
print(a % b)   # 1    나머지
print(a ** b)  # 25   거듭제곱

문자열 연산

a = "hello"
b = "world"
print(a + b)   # helloworld  (이어붙이기)
print(a * 2)   # hellohello  (반복)

복합 대입 연산자

score += 10 은 score = score + 10 의 짧은 표현 — 반복문에서 자주 등장

score = 0

score += 10    # 10  ( score = score + 10 )
score -= 3     # 7   ( score = score - 3  )
score *= 2     # 14  ( score = score * 2  )
score /= 2     # 7.0 ( score = score / 2  )

03

리스트

리스트 (List)

리스트는 순서가 있고 수정 가능하며 중복을 허용하는 자료형입니다.

인덱싱 & 슬라이싱

colors = ["red", "green", "blue"]

print(colors[0])    # red    (첫 번째)
print(colors[-1])   # blue   (마지막)
print(colors[0:2])  # ['red', 'green']  (슬라이싱)

값 변경 & 주요 메서드

colors[-1] = "black"         # 값 변경
colors.append("pink")        # 끝에 추가
colors.insert(0, "white")    # 특정 위치에 삽입
colors.remove("white")       # 값으로 제거

numbers = [8, 5, 3, 2, 7]
numbers.sort()               # 오름차순 정렬
numbers.sort(reverse=True)   # 내림차순 정렬
numbers.reverse()            # 순서 뒤집기
print(2 in numbers)          # True (포함 여부)

04

f-string

Python 3.6+에서 사용 가능한 문자열 포맷 방식입니다. 문자열 앞에 f를 붙이고 { } 중괄호 안에 변수를 넣습니다.

기존 방식 vs f-string

name = "King"
age = 99

# 기존 방식 (불편함)
print("저는", name, "입니다. 나이는", age, "살입니다.")

# f-string 방식 (권장)
print(f"저는 {name}입니다. 나이는 {age}살입니다.")

표현식 삽입 & 포맷 지정

a = 5
b = 3
print(f"{a} + {b} = {a + b}")       # 5 + 3 = 8
print(f"소수점 2자리: {3.14159:.2f}") # 3.14

.format() 방식

name = "King"
age = 99

# { } 자리에 순서대로 채움
print("저는 {}입니다. 나이는 {}살입니다.".format(name, age))

05

조건문 if

조건문 (if / elif / else)

"만약 ~라면" 상황별 판단을 코드로 표현하는 구조. 위에서부터 조건을 차례로 확인하고, 처음으로 맞는 조건의 코드만 실행

기본 구조 — 비가 오면 우산 챙기기

is_raining = True  # 비가 오는가?

if is_raining:
    print("우산을 챙겨요!")  # True이므로 이 줄 실행
else:
    print("우산 없어도 돼요")

elif 활용 — 오늘 기온에 따른 옷차림

temperature = 28  # 오늘 기온 (°C)

if temperature >= 30:
    print("덥다! 반팔 입기")
elif temperature >= 20:
    print("딱 좋아! 가볍게 입기")  # 이 줄 출력 (28 >= 20)
elif temperature >= 10:
    print("쌀쌀해, 겉옷 챙기기")
else:
    print("추워! 두꺼운 코트 입기")

06

반복문 for

리스트, 문자열, range 등에서 요소를 하나씩 꺼내며 반복 작업을 수행합니다.

기본 for 반복

mixed = [1, "hello", 3.14, True]

for item in mixed:
    print(item)
# 1
# hello
# 3.14
# True

enumerate — 인덱스 + 값 동시 출력

for index, item in enumerate(mixed):
    print(f"index: {index}, item: {item}")
# index: 0, item: 1
# index: 1, item: hello
# index: 2, item: 3.14
# index: 3, item: True

07

zip()

zip() — 두 리스트 짝지어 묶기

이름과 점수가 따로 떨어진 두 리스트를, 지퍼처럼 한 칸씩 같은 자리끼리 맞물려 한 쌍으로 묶어주는 함수
STEP 06 for문과 짝꿍 — 한 번에 두 리스트를 같이 돌고 싶을 때 사용

기본 — 두 리스트 같이 돌리기

이름과 점수를 같은 자리끼리 짝지어 한 쌍씩 출력 — for문이 한 번 돌 때마다 (name, score) 한 쌍을 받음

names = ["뽀삐", "초코", "쿠키"]
scores = [95, 88, 72]

for name, score in zip(names, scores):
    print(f"{name}: {score}점")
# 출력:
# 뽀삐: 95점
# 초코: 88점
# 쿠키: 72점

for문 없이 ① — list(zip(...)) 결과 한 번에 받기

list()로 감싸면 짝지은 결과가 한꺼번에 (이름, 점수) 튜플 리스트로 출력 — 짝꿍이 어떻게 매칭됐는지 한눈에 확인 가능

names = ["뽀삐", "초코", "쿠키"]
scores = [95, 88, 72]

pairs = list(zip(names, scores))
print(pairs)
# [('뽀삐', 95), ('초코', 88), ('쿠키', 72)]

for문 없이 ② — dict(zip(...)) 한 줄에 딕셔너리 만들기

이름표 붙은 사물함 비유 — zip()이 이름표(키)와 안에 들어갈 내용(값)을 같은 자리끼리 짝지어 주고, dict()가 "이름표만 부르면 안의 내용이 튀어나오는 사물함"으로 묶어줌
아래 예제는 한 사람의 프로필 카드 — 항목 이름표("이름"·"나이"·"직업")와 그 답("홍길동"·30·"개발자")을 한 줄에 짝지어 즉석 사전 완성

keys = ["이름", "나이", "직업"]
values = ["홍길동", 30, "개발자"]

person = dict(zip(keys, values))
print(person)
# {'이름': '홍길동', '나이': 30, '직업': '개발자'}

list vs dict — 어떤 그릇에 담을까?

zip()은 짝짓기만 한 번, 결과를 담는 그릇만 다름
· list(zip(...)) — 줄 세우기, 번호로 꺼냄: pairs[0]
· dict(zip(...)) — 이름표 붙이기, 이름표로 꺼냄: person["이름"]

정리 — 여러 리스트를 같은 자리끼리 묶고 싶을 땐 항상 zip(), 길이가 다르면 짧은 쪽 기준으로 끝남

08

pyfiglet

pyfiglet — 아스키 아트

텍스트를 아스키 아트로 변환해주는 외부 라이브러리. figlet_format 함수에 문자열을 넘기면 큼지막한 아스키 아트로 출력

설치

pip install pyfiglet

사용 예제

import pyfiglet

sentence = pyfiglet.figlet_format("Hello")
print(sentence)

09

termcolor

termcolor — 컬러 출력

글자색·배경색·스타일을 적용해 터미널 출력을 컬러풀하게 꾸며주는 외부 라이브러리. colored(문자열, 글자색, 배경색, [스타일]) 형태로 사용

설치

pip install termcolor

사용 예제

from termcolor import colored

# colored(문자열, 글자색, 배경색, attrs=[스타일])
result = colored("Hello", "red", "on_green", ["bold"])
print(result)

10

pyfiglet + termcolor

두 라이브러리를 함께 활용해 아스키 아트 텍스트에 색상까지 입히기. pyfiglet.figlet_format으로 만든 텍스트를 colored에 넘기면 컬러풀한 아스키 아트 완성

조합 예제

import pyfiglet
from termcolor import colored

py_text = pyfiglet.figlet_format("Hello")
color_text = colored(py_text, "red")
print(color_text)

🔒

라이브러리를 불러오는 방법은?

배경색 + 스타일까지

import pyfiglet
from termcolor import colored

py_text = pyfiglet.figlet_format("Python")
color_text = colored(py_text, "yellow", "on_blue", ["bold"])
print(color_text)

🔒

위 정답 입력 시 함께 해제

11

함수 def

함수 (def)

함수는 자주 쓰는 코드를 이름표를 붙여 묶어 둔 재사용 상자입니다. 한 번 정의해 두면 어디서든 같은 이름으로 불러 동일한 작업을 반복할 수 있습니다.

· 독스트링("""...""") — 함수 첫 줄에 적는 설명서, 역할·매개변수·반환값을 기록
· 매개변수 타입 힌트(: str) — 받을 값의 자료형 표시, 잘못된 타입 사용을 미리 알려 주는 안내판
· 반환 타입 힌트(-> int) — 함수가 돌려줄 값의 자료형 표시, def 줄 끝에 화살표(->)로 적음

기본 함수 정의 — 독스트링 & 매개변수 타입 & 반환 타입

import pyfiglet

def good_sentence(sentence: str) -> None:
    """
    입력된 문자열을 pyfiglet 형식으로 출력합니다.
    매개변수: sentence (str)
    반환: None — 출력만 수행
    """
    py_sentence = pyfiglet.figlet_format(sentence)
    print(py_sentence)

good_sentence("GOOD")

12

return

반환 (return)

계산기에 숫자를 누르면 답이 화면에 나타나듯, return은 함수가 만든 결과를 바깥으로 건네주는 명령어.
print처럼 그냥 보여주는 것이 아니라, 결과를 변수에 담아 다른 곳에서도 쓸 수 있게 해줌

return 예제

from termcolor import colored

def highlight(text):
    return colored(text, "yellow", "on_red", ["bold"])  # 꾸민 텍스트를 돌려줌

msg = highlight("중요 공지!")
print(msg)

13

예외 처리

예외 처리 (try / except)

오류가 날 수 있는 코드는 try 블록에, 오류가 났을 때 할 일은 except 블록에 작성.
try에서 오류가 발생하면 즉시 except로 이동하고, 오류가 없으면 except는 건너뜀

기본 구조 — ValueError

ValueError — 값의 형식이 잘못됐을 때 발생하는 오류. 예: 문자 "안녕"을 float()로 숫자로 바꾸려 하면 Python이 던짐

user_input = input("미터 값을 입력해주세요: ")

try:
    meters = float(user_input)   # 숫자 변환 시도
    feet = meters * 3.28084
    print(f"{meters}m는 {feet:.2f}ft입니다.")
except ValueError:
    print("숫자를 입력해주세요.")  # 변환 실패 시 실행

ZeroDivisionError

0으로 나누면 수학에서도 답이 없듯, Python도 오류를 던짐

try:
    result = 10 / 0
except ZeroDivisionError:
    print("0으로 나눌 수 없어요!")

TypeError

서로 다른 타입끼리 연산하면 발생. 예: 문자열에 숫자를 바로 이어 붙이기

try:
    result = "나이: " + 20
except TypeError:
    print("문자열과 숫자는 바로 합칠 수 없어요! str(20) 으로 변환 필요")

14

반복문 while

반복문 (while)

회전목마가 돌고 있는 동안 제자리에서 도는 것처럼, while은 조건이 True인 동안 코드를 계속 반복.
break는 멈춤 버튼 — while 안에서 만나면 반복을 즉시 멈추고 빠져나옴

while + 숫자 조건 — 카운트다운

숫자가 0보다 클 때만 계속 반복, 0이 되면 자연스럽게 종료 — break 없이도 멈출 수 있음

number = 5
while number > 0:
    print(number)
    number -= 1
print("발사!")
# 5
# 4
# 3
# 2
# 1
# 발사!

while — 회전목마 N바퀴

lap이 3 이하인 동안 회전, 3바퀴 채우면 자동 종료 — 카드 상단 비유 그대로

lap = 1
while lap <= 3:
    print(f"회전목마 {lap}바퀴!")
    lap += 1
print("끝!")
# 회전목마 1바퀴!
# 회전목마 2바퀴!
# 회전목마 3바퀴!
# 끝!

while True + break — 입력 반복

위 예제처럼 횟수가 정해진 게 아니라, 올바른 입력을 받을 때까지 몇 번이든 다시 시도 → break로 탈출

def meters_to_feet(meters):
    return meters * 3.28084

while True:
    user_input = input("미터 값을 입력해주세요: ")
    try:
        meters = float(user_input)
        feet = meters_to_feet(meters)
        print(f"{meters}m는 {feet:.2f}ft입니다.")
        break          # 성공하면 루프 종료
    except ValueError:
        print("숫자를 입력해주세요. 다시 시도하세요.")

15

파일 입출력 (with)

수도꼭지를 사용한 뒤 자동으로 잠가주는 센서 수전처럼, with는 파일을 다 쓰면 자동으로 닫아주는 안전장치
들여쓴 블록이 끝나면 깜빡 잊어도 알아서 닫혀, 데이터 손실이나 자원 낭비를 막아줌

파일 쓰기 — with open(...) "w" 모드

메모장에 한 줄을 새로 쓰는 동작 — 한글이 깨지지 않도록 encoding="utf-8" 명시 권장
같은 파일이 이미 있으면 덮어쓰기, 없으면 새로 만들기

with open("memo.txt", "w", encoding="utf-8") as f:
    f.write("안녕, 파이썬!\n")
    f.write("with문이 자동으로 닫아줌\n")
# 블록을 빠져나오면 파일은 알아서 닫힘

파일 읽기 — with open(...) "r" 모드

방금 쓴 memo.txt를 통째로 읽어 화면에 출력 — read()는 전체 한 번에, readlines()는 줄 단위 리스트로 받기

with open("memo.txt", "r", encoding="utf-8") as f:
    text = f.read()
print(text)
# 출력:
# 안녕, 파이썬!
# with문이 자동으로 닫아줌

이어 쓰기 — with open(...) "a" 모드

"a"는 append(이어 붙이기) — 기존 내용은 그대로 두고 맨 끝에 새 줄만 덧붙이기
일기처럼 매일 한 줄씩 추가할 때 적합

with open("memo.txt", "a", encoding="utf-8") as f:
    f.write("새로운 한 줄 추가\n")
# 기존 내용은 그대로, 끝에만 한 줄이 더 붙음

정리 — 세 가지 모드만 기억
· "w" 새로 쓰기 — 기존 내용 덮어쓰기
· "r" 읽기 — 파일 내용 읽어오기
· "a" 이어 쓰기 — 기존 내용 뒤에 덧붙이기

16

클래스

클래스 (class)

붕어빵 틀로 같은 모양 붕어빵을 여러 개 찍어내듯, class는 비슷한 정보(이름·나이·색깔)를 가진 여러 개를 같은 틀로 찍어내는 설계도
정보(이름·나이)와 그 정보로 할 수 있는 일(짖기·걷기)을 한 통에 함께 묶어 두는 것이 핵심

함수 vs 클래스 — 왜 클래스를 쓸까?

강아지 한 마리만 다룰 땐 함수로도 충분. 하지만 강아지 100마리의 이름·나이·색깔을 따로따로 변수로 만들기 시작하면 금방 헝클어짐
클래스는 한 마리에 대한 정보 + 행동을 한 묶음으로 만들어, 100마리든 1000마리든 깔끔하게 관리할 수 있게 해주는 도구

• 함수 — 한 가지 동작을 하는 도구 (인사하기, 더하기 같은 일회성 작업)
• 클래스 — 정보 + 동작을 함께 담은 상자 (이름·나이를 가진 강아지가 짖고 걷기)

핵심 단어 — 붕어빵 비유 (설명 색상 = 코드 색상)

• 클래스 — 붕어빵 틀 (설계도) → 코드의 class Dog
• 객체 — 틀로 찍어낸 진짜 붕어빵 (실제로 만들어진 것) → 코드의 dog1, dog2
• 속성 — 붕어빵의 맛·크기 (정보를 담는 변수) → 코드의 self.name, self.age
• 메서드 — 붕어빵이 할 수 있는 일 (먹기·데우기 — 클래스 안의 함수) → 코드의 bark()
• __init__ — 붕어빵을 처음 만들 때 자동 실행되는 준비 단계 (재료 넣기) → 코드의 __init__
• self — 지금 이 붕어빵 (자기 자신) → 코드의 self

예제 — Dog 클래스 (강아지 만들기)

class Dog:                          # 강아지 설계도(틀)
    def __init__(self, name, age):  # 생성자 — 강아지 만들 때 이름·나이 넣기
        self.name = name            # 자기 이름 저장
        self.age = age              # 자기 나이 저장

    def bark(self):                 # 강아지가 할 수 있는 일: 짖기
        print(f"{self.name}: 멍멍!")

# 같은 틀로 강아지 두 마리 만들기
dog1 = Dog("뽀삐", 3)
dog2 = Dog("초코", 5)

dog1.bark()       # 뽀삐: 멍멍!
dog2.bark()       # 초코: 멍멍!
print(dog2.age)   # 5

함수만으로 만들면? — 어떻게 되고 뭐가 불편할까

위 Dog 클래스를 함수와 변수만으로 똑같이 만들어 보면 아래와 같음
강아지 1~2마리는 그럭저럭이지만 100마리가 되면 손대기 어려워짐

# 강아지 1
dog1_name = "뽀삐"      # 객체 1의 정보가
dog1_age = 3            # 따로따로 변수로 흩어짐

# 강아지 2
dog2_name = "초코"
dog2_age = 5

def bark(name):         # 짖기는 외부 함수 (매번 이름을 받아야 함)
    print(f"{name}: 멍멍!")

bark(dog1_name)         # 뽀삐: 멍멍!
bark(dog2_name)         # 초코: 멍멍!
print(dog2_age)         # 5

불편한 점

• 변수가 강아지마다 따로 만들어짐 — 100마리면 변수 200개, 1000마리면 2000개로 폭발
• dog1의 name·age가 한 통에 묶여 있다는 표시가 코드에 없음 — 같은 강아지 것인지 변수 이름의 접두어로만 짐작
• 짖기를 시킬 때마다 이름을 외부에서 인자로 넘겨줘야 함 — bark(dog1_name)은 dog1.bark()처럼 "자기 정보로 자기 행동"이 되지 않음
• 새 속성(예: 색깔) 추가 시 모든 강아지 변수에 일일이 만들어야 함
• 함수(bark)와 데이터(dog1_name)가 분리되어 있어, 코드가 길어지면 어떤 함수가 어떤 강아지에 쓰이는지 추적이 어려움

클래스는 이 모든 불편을 한 번에 해결 — 정보(속성)와 행동(메서드)을 한 통(설계도)에 묶어 두니, 1마리든 1000마리든 같은 틀로 깔끔하게 관리

17

람다 함수

람다 함수 (lambda)

긴 편지 대신 짧은 쪽지에 휘갈겨 쓰듯, lambda는 함수를 한 줄로 짧게 줄여 쓰는 방법
이름표(함수 이름)를 안 붙이고 바로 쓸 수도 있고, 짧으니까 한 번 쓰고 버리는 일회용 함수에 잘 어울림

양식 — 빈칸 채우기 모양

아래 양식의 빈칸 세 곳만 채우면 람다 한 줄이 완성
· 함수명 — 함수에 붙일 이름표
· 매개변수 — 함수에 넣어줄 재료
· 반환값 — 재료로 만들어 돌려줄 결과

# 람다 양식
함수명 = lambda 매개변수 : 반환값

여러 줄 레시피 — 정성스럽게 적은 함수

요리 레시피처럼 def로 시작해서 단계를 한 줄씩 차근차근 적는 보통 함수
두 숫자를 더해서 결과를 돌려주는 더하기 함수 예시

# 일반 함수 — 여러 줄 레시피
def add(a, b):
    return a + b

print(add(7, 3))  # 10

한 줄 포스트잇 — 똑같은 일을 한 줄로

위 더하기 함수와 결과는 똑같지만, 포스트잇 한 장에 휘갈겨 쓴 메모처럼 한 줄로 끝냄
lambda 뒤에 재료(a, b) → 콜론(:) → 결과(a + b) 순으로 적기

# 람다 함수 — 한 줄 포스트잇
add = lambda a, b: a + b

print(add(7, 3))  # 10

꾸미기 함수 — 글자를 큰 그림으로

글자를 큼지막한 아스키 아트로 바꿔주는 pyfiglet을 람다로 한 줄에 묶어 보기
"Lambda"라는 글자를 넣으면 큰 그림 글씨로 출력

import pyfiglet

# 일반 함수로 만들면 (참고)
# def decorate_text(text):
#     return pyfiglet.figlet_format(text)

# 람다로 한 줄 줄임
decorate_text = lambda text: pyfiglet.figlet_format(text)
py_text = decorate_text("Lambda")
print(py_text)

정리하면, 일반 함수는 긴 편지, 람다는 짧은 쪽지
한두 줄로 끝나는 간단한 일은 람다, 단계가 많은 일은 일반 함수가 어울림