🐍 Python 기초 완전 정복 A-Z

설치부터 변수·조건문·반복문·함수·클래스·파일·예외처리까지
비전공자도 현업에서 바로 쓰는 Python 완전 마스터

🗺️ AI Dev Guide 시리즈 전체 흐름

📋 전체 학습 목차

🐍 Chapter 01. Python이란? 왜 AI 개발자에게 필수인가?

설치부터 Google Colab 환경 세팅까지 — 첫 번째 파이썬 코드 실행!

💡 Python이란?

Python은 1991년 네덜란드 개발자 귀도 반 로섬(Guido van Rossum)이 만든 프로그래밍 언어입니다. 읽기 쉽고 배우기 쉬운 문법으로 전 세계에서 가장 인기 있는 언어가 되었으며, 특히 AI·데이터 과학 분야의 표준 언어로 자리잡았습니다.

영어와 비슷한 문법 덕분에 코드를 읽으면 대충 무슨 내용인지 이해할 수 있고, 수많은 AI 라이브러리(NumPy, Pandas, TensorFlow, PyTorch)가 Python으로 만들어져 있습니다.

🛠️ 개발 환경 세팅 — 2가지 방법

📌 첫 번째 Python 코드 실행해보기!

# Hello, AI World! — 나의 첫 파이썬 코드
print("Hello, AI World!")

# 계산도 됩니다
print(2024 + 1)  # 2025 출력

# 변수 사용
name = "김AI"
print(f"안녕하세요, {name}님! Python AI 개발 시작합니다!")

# 실행 결과:
# Hello, AI World!
# 2025
# 안녕하세요, 김AI님! Python AI 개발 시작합니다!

📦 Chapter 02. 변수와 자료형 완전 정복

int, float, str, bool, None — Python의 모든 데이터 타입 마스터

💡 변수란? 데이터를 담는 상자!

변수는 데이터를 저장하는 이름표입니다. 마치 우편함에 이름을 붙이듯, 데이터에 이름을 붙여 나중에 불러쓸 수 있게 합니다. Python은 타입을 자동으로 감지하기 때문에 타입을 직접 선언할 필요가 없습니다.

# ===== 변수 선언과 자료형 =====
age = 25               # int (정수)
height = 175.5          # float (소수점)
name = "김파이썬"       # str (문자열)
is_developer = True    # bool (참/거짓)
nothing = None          # None (값 없음)

# 자료형 확인
print(type(age))         # <class "int">
print(type(name))        # <class "str">

# 타입 변환 (형변환)
age_str = str(age)      # 25 → "25" (정수→문자열)
score = int("98")       # "98" → 98 (문자열→정수)
ratio = float("3.14")  # "3.14" → 3.14 (문자열→소수)

📊 Python 자료형 완전 비교

✍️ 문자열(str) 완전 정복

# ===== 문자열 조작 (AI 개발 핵심!) =====
text = "Python으로 AI 개발하기"

# 기본 연산
print(len(text))          # 길이: 16
print(text.upper())      # 대문자 변환
print(text.lower())      # 소문자 변환
print(text.replace("Python", "파이썬"))  # 치환
print(text.split(" "))   # 공백 기준 분리 → 리스트 반환
print(text[0:6])         # 슬라이싱: "Python"

# f-string (현업 필수!)
model = "GPT-4"
accuracy = 95.7
print(f"모델: {model}, 정확도: {accuracy:.1f}%")  # 모델: GPT-4, 정확도: 95.7%

# 멀티라인 문자열 (LLM 프롬프트 작성 시 자주 사용)
prompt = """
당신은 친절한 AI 어시스턴트입니다.
사용자의 질문에 한국어로 답변해주세요.
"""
print(prompt.strip())   # 앞뒤 공백 제거

🔀 Chapter 03. 조건문과 반복문 완전 정복

if/elif/else, for, while — 프로그램의 흐름을 제어하는 핵심!

🚦 조건문 (if / elif / else)

조건문은 "만약 ~이면 ~하고, 아니면 ~해라"를 코드로 표현합니다. Python은 들여쓰기(indent, 스페이스 4칸)로 코드 블록을 구분합니다. 이것이 Python의 가장 큰 특징입니다!

# ===== 기본 조건문 =====
score = 85

if score >= 90:
    print("A등급 - 우수!")
elif score >= 80:
    print("B등급 - 양호!")  # 이게 실행됨
elif score >= 70:
    print("C등급 - 보통")
else:
    print("D등급 - 재시험")

# ===== AI 예시: 모델 정확도 평가 =====
model_accuracy = 0.943

if model_accuracy >= 0.95:
    print("✅ 프로덕션 배포 가능!")
elif model_accuracy >= 0.90:
    print("⚠️ 추가 튜닝 필요")  # 이게 실행됨
else:
    print("❌ 모델 재학습 필요")

# ===== 비교 연산자 정리 =====
# ==  같다         !=  다르다
# >   크다         <   작다
# >=  크거나 같다  <=  작거나 같다
# and 둘 다 참     or  하나라도 참    not 반대

🔄 반복문 — for문과 while문

# ===== for문 기본 =====
fruits = ["사과", "바나나", "딸기"]

for fruit in fruits:
    print(f"과일: {fruit}")

# ===== range() 사용 — AI 에폭 학습 시뮬레이션 =====
total_epochs = 5

for epoch in range(1, total_epochs + 1):
    loss = 1.0 / epoch  # 에폭이 늘수록 손실 감소 (간단 시뮬레이션)
    print(f"Epoch {epoch}/{total_epochs} - Loss: {loss:.4f}")

# 출력:
# Epoch 1/5 - Loss: 1.0000
# Epoch 2/5 - Loss: 0.5000
# Epoch 3/5 - Loss: 0.3333
# Epoch 4/5 - Loss: 0.2500
# Epoch 5/5 - Loss: 0.2000

# ===== enumerate() — 인덱스와 값 동시에 =====
labels = ["고양이", "개", "새"]

for idx, label in enumerate(labels):
    print(f"클래스 {idx}: {label}")

# ===== while문 — 조건 만족 시까지 반복 =====
loss = 1.0
threshold = 0.1
step = 0

while loss > threshold:
    loss *= 0.7   # 학습마다 30% 감소
    step += 1
    print(f"Step {step}: loss = {loss:.4f}")

# break / continue
for i in range(10):
    if i == 3: continue  # 3은 건너뛰기
    if i == 7: break     # 7에서 완전 중단
    print(i)               # 0,1,2,4,5,6 출력

📚 Chapter 04. 자료구조 4종 완전 정복

list, tuple, dict, set — AI 데이터 처리의 핵심 도구

📊 4가지 자료구조 한눈에 비교

# ===== 1. LIST — AI 데이터셋 저장 =====
training_data = [0.1, 0.5, 0.8, 0.3, 0.9]
labels = [0, 1, 1, 0, 1]  # 0=부정, 1=긍정

training_data.append(0.7)    # 추가
training_data.remove(0.1)    # 삭제
print(training_data[0])       # 첫 번째 요소
print(training_data[-1])      # 마지막 요소
print(training_data[1:3])    # 슬라이싱 [0.5, 0.8]
print(len(training_data))     # 길이
print(sorted(training_data))  # 정렬

# ===== 2. DICT — 하이퍼파라미터 설정 =====
hyperparams = {
    "learning_rate": 0.001,
    "batch_size": 32,
    "epochs": 100,
    "optimizer": "adam",
    "dropout": 0.3
}

print(hyperparams["learning_rate"])   # 0.001
hyperparams["epochs"] = 200          # 수정
hyperparams["model"] = "ResNet50"    # 추가

for key, value in hyperparams.items():
    print(f"{key}: {value}")

# ===== 3. TUPLE — 이미지 크기, 색상 =====
image_size = (256, 256, 3)  # 가로, 세로, 채널 (변경 불가)
rgb_color = (255, 128, 0)    # 오렌지 색상
width, height, channels = image_size  # 언패킹

# ===== 4. SET — 고유 클래스 추출 =====
all_labels = ["cat", "dog", "cat", "bird", "dog"]
unique_classes = set(all_labels)
print(unique_classes)  # {"cat", "dog", "bird"} — 중복 제거!
print(len(unique_classes))  # 3 (클래스 수)

⚡ Chapter 05. 함수와 람다 완전 정복

def, return, *args, **kwargs, lambda — 재사용 가능한 코드 설계

🔧 함수(Function)란?

함수는 특정 작업을 수행하는 코드 묶음입니다. 한 번 만들고 여러 번 재사용할 수 있어 코드를 훨씬 효율적으로 작성할 수 있습니다. AI 개발에서 데이터 전처리, 모델 학습, 평가 등 모든 것이 함수로 구성됩니다.

# ===== 함수 기본 구조 =====
def greet(name):
    """환영 메시지를 출력하는 함수 (docstring)"""
    message = f"안녕하세요, {name}님! AI 개발 화이팅!"
    return message

result = greet("김개발")
print(result)  # 안녕하세요, 김개발님! AI 개발 화이팅!

# ===== 기본값 매개변수 =====
def train_model(epochs=10, lr=0.001, batch_size=32):
    print(f"학습 시작: epochs={epochs}, lr={lr}, batch={batch_size}")

train_model()                              # 기본값 사용
train_model(epochs=50)                    # epochs만 변경
train_model(epochs=100, lr=0.0001)       # 두 개 변경

# ===== *args — 가변 인수 =====
def calculate_average(*scores):
    """임의 개수의 점수를 받아 평균 반환"""
    return sum(scores) / len(scores)

print(calculate_average(80, 90, 85))          # 85.0
print(calculate_average(95, 88, 92, 100))     # 93.75

# ===== **kwargs — 키워드 가변 인수 =====
def build_model_config(**kwargs):
    """모델 설정을 딕셔너리로 구성"""
    config = {}
    for key, value in kwargs.items():
        config[key] = value
    return config

cfg = build_model_config(model="ResNet50", pretrained=True, num_classes=10)
print(cfg)  # {"model": "ResNet50", "pretrained": True, "num_classes": 10}

# ===== lambda — 한 줄 함수 (데이터 처리에 자주 사용) =====
square = lambda x: x ** 2
normalize = lambda x, max_val: x / max_val

print(square(5))           # 25
print(normalize(128, 255)) # 0.502 (픽셀 정규화)

# 람다 + sorted() — 모델 성능 순위 정렬
models = [
    {"name": "모델A", "accuracy": 0.92},
    {"name": "모델B", "accuracy": 0.95},
    {"name": "모델C", "accuracy": 0.88},
]
ranked = sorted(models, key=lambda m: m["accuracy"], reverse=True)
for i, m in enumerate(ranked, 1):
    print(f"{i}위: {m['name']} - {m['accuracy']*100:.1f}%")

🏗️ Chapter 06. 클래스와 객체지향 프로그래밍 완전 정복

class, __init__, 상속, 캡슐화, 다형성 — 현업 Python의 핵심!

💡 클래스란? — 설계도와 실체의 관계

클래스는 객체를 만들기 위한 설계도(Blueprint)입니다. 예를 들어, "AI 모델"이라는 설계도(클래스)를 만들면, 그 설계도를 토대로 실제 모델(객체)을 여러 개 찍어낼 수 있습니다. PyTorch나 TensorFlow의 모든 모델이 클래스로 구현되어 있습니다.

# ===== 클래스 기본 구조 =====
class AIModel:
    """AI 모델 기본 클래스"""

    # 클래스 변수 (모든 인스턴스가 공유)
    framework = "PyTorch"
    model_count = 0

    def __init__(self, name, input_size, output_size):
        # 인스턴스 변수 (각 객체마다 고유)
        self.name = name
        self.input_size = input_size
        self.output_size = output_size
        self.is_trained = False
        self.accuracy = None
        AIModel.model_count += 1

    def train(self, epochs=10):
        """모델 학습"""
        print(f"[{self.name}] {epochs} 에폭 학습 시작...")
        self.is_trained = True
        self.accuracy = 0.93  # 시뮬레이션
        print(f"[{self.name}] 학습 완료! 정확도: {self.accuracy:.1%}")

    def predict(self, data):
        """예측 수행"""
        if not self.is_trained:
            print("⚠️ 먼저 학습이 필요합니다!")
            return None
        return f"{data} 분류 결과: 양성"

    def __repr__(self):
        return f"AIModel(name={self.name}, trained={self.is_trained})"

# 객체 생성 및 사용
model1 = AIModel("ImageClassifier", input_size=784, output_size=10)
model2 = AIModel("SentimentAnalyzer", input_size=512, output_size=2)

model1.train(epochs=20)
print(model1.predict("테스트 이미지"))
print(f"총 모델 수: {AIModel.model_count}")  # 2

🧬 상속 — 클래스 확장

# ===== 상속 — 부모 클래스를 물려받아 확장 =====
class CNNModel(AIModel):  # AIModel을 상속
    """CNN (합성곱 신경망) 모델 — 이미지 특화"""

    def __init__(self, name, input_size, output_size, num_layers):
        super().__init__(name, input_size, output_size)  # 부모 초기화
        self.num_layers = num_layers  # CNN만의 추가 속성

    def extract_features(self, image):
        """이미지에서 특징 추출 (CNN 고유 기능)"""
        return f"{self.num_layers}층 CNN으로 특징 추출 완료"

    def train(self, epochs=10):  # 메서드 오버라이딩
        print(f"CNN 전처리 (이미지 증강) 적용 중...")
        super().train(epochs)  # 부모 train() 호출

class LLMModel(AIModel):  # 또 다른 상속
    """LLM (대형 언어 모델) — 텍스트 특화"""

    def __init__(self, name, input_size, output_size, context_length):
        super().__init__(name, input_size, output_size)
        self.context_length = context_length

    def generate(self, prompt, max_tokens=100):
        """텍스트 생성 (LLM 고유 기능)"""
        return f"프롬프트: {prompt[:20]}... → {max_tokens}토큰 생성"

# 다형성 — 같은 메서드 이름, 다른 동작
cnn = CNNModel("VGG16", 224*224, 1000, num_layers=16)
llm = LLMModel("GPT-mini", 4096, 50000, context_length=2048)

for model in [cnn, llm]:
    model.train(epochs=5)  # 각 클래스에 맞는 train() 호출

📁 Chapter 07. 파일 입출력과 모듈 완전 정복

open(), json, csv, import, pip — 데이터 저장과 외부 라이브러리 활용

📂 파일 입출력 — AI 데이터 저장/불러오기

# ===== 텍스트 파일 쓰기/읽기 =====
# with 문: 파일을 자동으로 닫아줌 (권장!)

# 쓰기 (w)
with open("training_log.txt", "w", encoding="utf-8") as f:
    f.write("Epoch 1: loss=1.2345, acc=0.65\n")
    f.write("Epoch 2: loss=0.8901, acc=0.78\n")

# 읽기 (r)
with open("training_log.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# ===== JSON — 설정값, API 응답 저장 =====
import json

hyperparams = {
    "model": "ResNet50",
    "lr": 0.001,
    "epochs": 100,
    "layers": [64, 128, 256]
}

# JSON 저장
with open("config.json", "w") as f:
    json.dump(hyperparams, f, indent=4)

# JSON 불러오기
with open("config.json", "r") as f:
    loaded_config = json.load(f)
print(loaded_config["model"])  # ResNet50

# ===== CSV — 데이터셋 저장/불러오기 =====
import csv

# CSV 쓰기
dataset = [
    ["feature1", "feature2", "label"],
    [0.5, 1.2, 1],
    [0.3, 0.8, 0]
]

with open("data.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerows(dataset)

# ===== 모듈 임포트 (AI 라이브러리) =====
import os
import math
import random
from datetime import datetime

print(os.getcwd())          # 현재 디렉토리
print(math.sqrt(144))       # 12.0
print(random.random())     # 0.0 ~ 1.0 랜덤
print(datetime.now())      # 현재 날짜/시간

🛡️ Chapter 08. 예외 처리 완전 정복

try/except/finally, raise — 오류를 우아하게 처리하는 법

🚨 예외(Exception)란?

프로그램 실행 중 발생하는 오류를 예외(Exception)라고 합니다. AI 개발에서 API 호출 실패, 잘못된 데이터 형식, 파일 없음 등 다양한 오류가 발생할 수 있습니다. 예외 처리를 잘 해두면 오류가 나도 프로그램이 멈추지 않고 계속 실행됩니다.

# ===== 기본 try/except =====
try:
    result = 10 / 0  # ZeroDivisionError 발생!
except ZeroDivisionError:
    print("❌ 0으로 나눌 수 없습니다!")

# ===== 다중 예외 처리 =====
try:
    number = int("abc")  # ValueError 발생
except ValueError as e:
    print(f"값 오류: {e}")
except TypeError as e:
    print(f"타입 오류: {e}")
except Exception as e:
    print(f"알 수 없는 오류: {e}")
else:
    print("✅ 정상 실행!")  # 예외 없을 때
finally:
    print("항상 실행됩니다")  # 예외 여부 상관없이 항상

# ===== AI API 호출 예외 처리 (현업 패턴) =====
import time

def call_ai_api(prompt, max_retries=3):
    """AI API 호출 — 재시도 로직 포함"""
    for attempt in range(max_retries):
        try:
            # from openai import OpenAI
            # response = client.chat.completions.create(...)
            print(f"시도 {attempt+1}: API 호출 중...")
            return "API 응답 성공"
        except ConnectionError:
            print(f"연결 오류 — {2**attempt}초 후 재시도")
            time.sleep(2 ** attempt)  # 지수 백오프
        except Exception as e:
            print(f"예외 발생: {e}")
            break
    return None

# ===== 사용자 정의 예외 =====
class ModelNotTrainedError(Exception):
    """학습되지 않은 모델 사용 시 발생하는 커스텀 예외"""
    pass

def predict(model, data):
    if not model.is_trained:
        raise ModelNotTrainedError("먼저 model.train()을 실행하세요!")
    return "예측 결과"

⚡ Chapter 09. 고급 Python 문법 완전 정복

comprehension, decorator, generator, 비동기 — 현업 Python 개발자처럼 코딩하기

🚀 List Comprehension — 한 줄로 리스트 만들기

# ===== List Comprehension =====
# 일반 방식
squares = []
for x in range(10):
    squares.append(x ** 2)

# comprehension 방식 (훨씬 간결!)
squares = [x ** 2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 조건부 comprehension (AI 데이터 필터링)
all_scores = [0.55, 0.92, 0.38, 0.88, 0.71, 0.95]
high_scores = [s for s in all_scores if s >= 0.8]
print(high_scores)  # [0.92, 0.88, 0.95]

# Dict Comprehension
classes = ["cat", "dog", "bird"]
class_to_id = {cls: idx for idx, cls in enumerate(classes)}
print(class_to_id)  # {"cat": 0, "dog": 1, "bird": 2}

# ===== Decorator — 함수 기능 확장 =====
import time

def timer(func):
    """함수 실행 시간 측정 데코레이터"""
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 실행 시간: {end-start:.4f}초")
        return result
    return wrapper

@timer  # 데코레이터 적용
def train_epoch(data_size):
    """모델 1 에폭 학습"""
    time.sleep(0.1)  # 학습 시뮬레이션
    return 0.95

acc = train_epoch(10000)  # train_epoch 실행 시간: 0.1003초

# ===== Generator — 메모리 효율적인 대용량 데이터 처리 =====
def data_batch_generator(dataset, batch_size):
    """대용량 데이터셋을 배치로 나눠서 반환"""
    for i in range(0, len(dataset), batch_size):
        yield dataset[i:i + batch_size]  # yield = 메모리 효율적 반환

dataset = list(range(100))

for batch in data_batch_generator(dataset, batch_size=10):
    print(f"배치 처리: {batch}")

# ===== 비동기 프로그래밍 (async/await) =====
import asyncio

async def call_api(model_name):
    """비동기 API 호출 (I/O 대기 중 다른 작업 수행)"""
    print(f"{model_name} API 호출 중...")
    await asyncio.sleep(1)  # API 응답 대기 시뮬레이션
    return f"{model_name}: 응답 완료"

async def main():
    # 여러 API를 동시에 호출 (병렬 처리)
    results = await asyncio.gather(
        call_api("GPT-4"),
        call_api("Claude"),
        call_api("Gemini")
    )
    for r in results:
        print(r)

# asyncio.run(main())  # Colab에서는 await main()

🎯 Chapter 10. 현업 면접 질문과 답변 TOP 10

AI 개발자 취업 면접에서 Python 관련 가장 자주 나오는 질문과 모범 답변

✅ AiDevGuide0002 완료 체크리스트

이 모든 항목을 완료하면 다음 단계(데이터 분석)로 진행할 준비가 된 것입니다!

AiDevGuide0002 완료!

Python 기초를 완전히 정복했습니다!
이제 AI 개발의 언어를 자유롭게 구사할 수 있습니다 💪