주요 활용 분야

• 웹 크롤링
• 백엔드 개발
• 데이터 분석
• 로봇 제어
• 대규모 AI 모델 구동

기본 개념

파이썬은 귀도 반 로섬(Guido van Rossum)이 개발한 인터프리터 언어이며, 영국 코미디 그룹 몬티 파이튼(Monty Python)에서 이름을 따왔다. 소스 코드는 암호화할 수 없지만 exe 실행 파일로 변환하여 배포 가능하다.

환경 설정

# 버전 확인
python --version

# 설치 위치 조회
where python

# macOS에서 python 명령어 간소화
echo 'alias python="python3"' >> ~/.zshrc

# 파이썬 인터프리터 실행
python

# 종료
exit()

# 스크립트 실행
python script.py

기초 문법

자료형

• 정수형: 메모리 한도 내에서 무제한 표현 가능
• 실수형: 과학적 표기법 지원 (예: 3.4e2)
• 문자열: 4가지 정의 방식 제공 ('', "", '''''', """""")
• 불리언: True/False 값으로 조건 판단

형변환

str_value = str(123)
int_value = int("456")
float_value = float("78.9")

연산자

• 산술 연산자 (+, -, *, /, //, %, **)
• 비교 연산자 (>, <, == 등)
• 논리 연산자 (and, or, not)
• 진법 변환 (bin(), oct(), hex())

입출력 처리

name = input("이름 입력: ")
age = int(input("나이 입력: "))
print(f"안녕하세요 {name}님, 내년 나이는 {age + 1}세 입니다.")

제어 흐름

조건문

ADULT_AGE = 18
age = int(input("나이를 입력하세요: "))

if age < ADULT_AGE:
    print("미성년자 출입 금지")
elif age < 30:
    print("청년입니다!")
elif age < 50:
    print("가정을 꾸릴 시기입니다.")
else:
    print("은퇴 준비를 시작하세요.")

반복문

# while 루프
count = 1
while count <= 3:
    print(f"{count}번째 반복")
    count += 1

# for 루프
for i in range(1, 10):
    for j in range(1, i+1):
        print(f"{j}×{i}={i*j}", end="\t")
    print()

제어 키워드

target_num = 20
while True:
    guess = int(input("숫자를 맞춰보세요: "))
    if guess == target_num:
        print("정답입니다!")
        break
    elif guess == 0:
        print("게임 종료")
        break
    else:
        print("틀렸습니다. 다시 시도하세요.")

함수

기본 사용법

def greet(name, greeting="안녕"):
    """인사말 생성 함수"""
    return f"{name}님, {greeting}!"

def order_food(count, *items, **details):
    print(f"{count}개 주문: {list(items)}")
    print(f"추가 요청: {details}")

# 호출 예시
print(greet("김철수"))
order_food(2, "김밥", "라면", spicy=True, seat="창가")

고급 기능

• 여러 값 반환 튜플로 가능
• 가변 인자 (*args, **kwargs)
• 기본값 매개변수 지원
• 전역/지역 변수 스코프 구분

자료구조

리스트

# 기본 조작
data = [1, 2, 3]
data.append(4)
data.insert(0, 0)
data.extend([5, 6])

# 검색과 삭제
index = data.index(3)
data.remove(2)
popped = data.pop()

# 순회 방법
for item in data:
    print(item)

for i, val in enumerate(data):
    print(f"{i}: {val}")

튜플

• 불변 객체로서 데이터 보호
• 함수에서 여러 값 반환 시 유용
• 딕셔너리 키로 사용 가능

집합

set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

union = set_a | set_b      # 합집합
intersect = set_a & set_b  # 교집합
diff = set_a - set_b       # 차집합

딕셔너리

student = {
    "name": "홍길동",
    "age": 20,
    "grades": {"math": 90, "eng": 85}
}

# 요소 접근
print(student["name"])
print(student.get("email", "없음"))

# 반복 처리
for key, value in student.items():
    print(f"{key}: {value}")

슬라이싱

text = "Hello World"
print(text[0:5])     # Hello
print(text[::-1])    # dlroW olleH
print(text[::2])     # HloWrd

객체지향 프로그래밍

클래스 정의

class Person:
    max_age = 100  # 클래스 속성
    
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
    
    def introduce(self):
        return f"저는 {self.name}입니다."
    
    @classmethod
    def create_from_birthyear(cls, name, birth_year, gender):
        current_year = 2024
        age = current_year - birth_year
        return cls(name, age, gender)
    
    @staticmethod
    def is_adult(age):
        return age >= 18

상속과 다형성

class Student(Person):
    def __init__(self, name, age, gender, major):
        super().__init__(name, age, gender)
        self.major = major
    
    def study(self):
        return f"{self.major} 전공을 공부합니다."

# 다형성 예시
people = [Person("일반인"), Student("학생", "컴공")]
for person in people:
    print(person.introduce())

접근 제어

• public: 일반 속성
• protected: _로 시작 (_protected)
• private: __로 시작 (__private)

고급 기능

예외 처리

def divide_numbers():
    try:
        a = int(input("첫 번째 숫자: "))
        b = int(input("두 번째 숫자: "))
        result = a / b
    except ValueError:
        print("유효하지 않은 입력입니다.")
    except ZeroDivisionError:
        print("0으로 나눌 수 없습니다.")
    except Exception as e:
        print(f"알 수 없는 오류: {e}")
    else:
        print(f"결과: {result}")
    finally:
        print("계산 완료")

데코레이터

def timing_decorator(func):
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 실행 시간: {end-start:.2f}초")
        return result
    return wrapper

@timing_decorator
def slow_function():
    import time
    time.sleep(1)

타입 어노테이션

from typing import List, Dict, Optional

def process_data(items: List[int], config: Dict[str, str]) -> Optional[float]:
    if not items:
        return None
    return sum(items) / len(items)

파일 처리

# 읽기
with open('data.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    for line in f:
        print(line.strip())

# 쓰기
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write("안녕하세요\n")
    f.writelines(["첫 줄\n", "두 번째 줄\n"])

# 이진 파일 복사
with open('source.jpg', 'rb') as src, open('copy.jpg', 'wb') as dst:
    dst.write(src.read())

병렬 처리

멀티프로세싱

from multiprocessing import Process, Queue
import os

def worker(task_queue):
    while not task_queue.empty():
        task = task_queue.get()
        print(f"프로세스 {os.getpid()}: {task}")

if __name__ == '__main__':
    tasks = Queue()
    for i in range(5):
        tasks.put(f"작업{i}")
    
    processes = []
    for _ in range(2):
        p = Process(target=worker, args=(tasks,))
        p.start()
        processes.append(p)
    
    for p in processes:
        p.join()

멀티쓰레딩

from threading import Thread, Lock
import time

counter_lock = Lock()
shared_counter = 0

def increment():
    global shared_counter
    for _ in range(100000):
        with counter_lock:
            shared_counter += 1

threads = []
for i in range(4):
    t = Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"최종 카운터 값: {shared_counter}")

비동기 프로그래밍

import asyncio
import aiohttp

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        'https://httpbin.org/get',
        'https://httpbin.org/user-agent'
    ]
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        
        for i, result in enumerate(results):
            print(f"응답 {i+1}: {len(result)} 바이트")

# 실행
asyncio.run(main())

유용한 도구

내장 함수

• map(): 시퀀스에 함수 적용
• filter(): 조건에 맞는 요소 필터링
• sorted(): 정렬 (key 파라미터 지원)
• zip(): 여러 시퀀스 결합

표현식

# 리스트 컴프리헨션
squares = [x**2 for x in range(10)]

# 조건부 리스트 컴프리헨션
evens = [x for x in range(20) if x % 2 == 0]

# 사전 컴프리헨션
word_lengths = {word: len(word) for word in ['apple', 'banana']}

# 집합 컴프리헨션
unique_squares = {x**2 for x in [1, 2, 2, 3]}

가상 환경

# 가상 환경 생성
python -m venv myenv

# 활성화 (Windows)
myenv\Scripts\activate

# 활성화 (macOS/Linux)
source myenv/bin/activate

# 패키지 설치
pip install requests pandas numpy

패키지 관리

# 미러 사이트 사용
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple package_name

# 자주 사용하는 패키지
pip install requests          # HTTP 요청
pip install beautifulsoup4    # HTML 파싱
pip install pandas            # 데이터 분석
pip install matplotlib        # 그래프 작성
pip install pillow            # 이미지 처리

개발 팁

• PEP 8 스타일 가이드 준수
• 문서화를 위한 docstring 작성
• 단위 테스트 작성 (unittest, pytest)
• 코드 포맷팅 도구 사용 (black, autopep8)
• 정적 분석 수행 (pylint, flake8)