나혼자 코딩

Python 클래스와 객체 이해하기: OOP의 기초부터 실무 활용까지

python2ai — Thu, 8 May 2025 16:13:32 +0900

Python은 객체 지향 프로그래밍(Object-Oriented Programming, OOP)을 지원하는 언어로, 클래스(class)와 객체(object)의 개념을 바탕으로 코드를 보다 효율적이고 재사용 가능하게 작성할 수 있습니다. 본 글에서는 객체 지향 프로그래밍의 핵심 개념을 Python 문법을 중심으로 정리하고, 실무에서 클래스를 어떻게 활용할 수 있는지까지 함께 살펴보겠습니다.

클래스와 객체 예시

1. 클래스와 객체란?

클래스(Class)는 데이터(속성)와 기능(메서드)을 하나로 묶는 사용자 정의 자료형의 설계도입니다.
객체(Object)는 클래스의 인스턴스로, 클래스를 기반으로 생성된 실체입니다.

예를 들어, "자동차"라는 클래스를 만든다면, 실제로 존재하는 "내 차, 친구 차"는 각각 하나의 객체입니다. 클래스는 공통된 구조를 정의하고, 객체는 그 구조를 바탕으로 동작하는 개별 실체입니다.

class Car:
    def __init__(self, brand):
        self.brand = brand

my_car = Car("Hyundai")
print(my_car.brand)  # 출력: Hyundai

이처럼 클래스를 정의한 후 Car()를 통해 인스턴스를 생성하면, 그 인스턴스는 해당 클래스의 모든 속성과 메서드를 사용할 수 있습니다.

2. 생성자 `init()`

클래스 인스턴스를 만들 때 자동으로 호출되는 특수 메서드가 __init__()입니다. 이를 통해 객체의 초기 상태를 설정할 수 있습니다.

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

user1 = User("Alice", 30)
print(user1.name, user1.age)

self.name, self.age는 인스턴스 변수이며, 객체마다 고유한 값을 가집니다.
생성자는 초기화 로직을 담기에 적절하며, 실무에서 객체 생성과 동시에 필수 데이터를 주입할 때 사용됩니다.

3. 인스턴스 변수와 메서드

인스턴스 변수는 객체마다 별도로 존재하는 속성입니다.
인스턴스 메서드는 클래스 내부에 정의된 함수로, 객체의 상태를 조회하거나 변경하는 데 사용됩니다.

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def discount(self, rate):
        return self.price * (1 - rate)

item = Product("Laptop", 1000)
print(item.discount(0.1))  # 출력: 900.0

메서드는 항상 self를 첫 번째 인자로 받으며, 이를 통해 인스턴스 변수에 접근하거나 수정할 수 있습니다. 이는 메서드가 특정 객체에 소속되어 있다는 것을 의미합니다.

4. self의 의미

self는 인스턴스 메서드 내에서 현재 객체 자신을 참조하는 예약어입니다.
모든 인스턴스 메서드는 self를 통해 객체 내부 상태에 접근합니다.

class Demo:
    def show(self):
        print("Hello from", self)

obj = Demo()
obj.show()  # self는 obj를 참조

실무에서 self는 객체 간 데이터 공유, 내부 속성 조작, 메서드 간 호출 등에서 필수적인 역할을 합니다.

Tip: 클래스 밖에서 함수처럼 정의한 메서드에서 self를 빼먹는 실수를 종종 하게 되는데, 이는 TypeError를 발생시킵니다.

5. 클래스 변수 vs 인스턴스 변수

Python 클래스에서는 클래스 단위로 공유되는 변수와 인스턴스 단위로 독립적인 변수를 구분할 수 있습니다.

구분	정의 위치	접근 방식	공유 여부
클래스 변수	클래스 내부, 메서드 외부	클래스명 또는 인스턴스명	모든 인스턴스가 공유
인스턴스 변수	생성자(__init__) 또는 메서드 내	self.변수명	각 인스턴스마다 개별 존재

class Counter:
    count = 0  # 클래스 변수

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

print(Counter.count)  # 출력: 0
c1 = Counter()
c2 = Counter()
print(Counter.count)  # 출력: 2

클래스 변수는 인스턴스 생성 횟수 카운팅, 공통 설정값 저장 등에 유용합니다.
반면, 인스턴스 변수는 각 객체의 고유한 속성을 저장할 때 사용합니다.

6. 상속과 오버라이딩

상속(Inheritance)은 기존 클래스의 기능을 물려받아 새로운 클래스를 정의하는 기법입니다. 이를 통해 코드의 중복을 줄이고 구조화된 설계를 가능하게 합니다.

부모 클래스: 공통 기능을 정의
자식 클래스: 부모 기능을 물려받고 필요에 따라 오버라이딩(재정의)

class Animal:
    def speak(self):
        print("소리를 냅니다.")

class Dog(Animal):
    def speak(self):  # 오버라이딩
        print("멍멍!")

d = Dog()
d.speak()  # 출력: 멍멍!

오버라이딩은 같은 이름의 메서드를 자식 클래스에서 새롭게 구현하여, 동일한 인터페이스로 다른 동작을 수행할 수 있도록 해줍니다. 이를 통해 다형성을 구현할 수 있습니다.

마무리

이번 글에서는 Python의 객체 지향 프로그래밍(OOP)의 기초를 다뤘습니다.

클래스는 데이터와 기능을 하나로 묶는 구조이며,
객체는 그 구조를 실체화한 개별 인스턴스입니다.
__init__() 생성자를 통해 객체 초기화를 수행하고,
self를 통해 객체 내부의 속성과 동작을 연결할 수 있습니다.
클래스 변수와 인스턴스 변수의 차이를 이해하면 설계 유연성이 향상됩니다.
상속과 오버라이딩은 OOP의 핵심 원칙인 재사용성과 확장성을 실현하는 도구입니다.

이제 클래스와 객체의 기본 개념을 이해하셨다면, 다음 단계로는 추상 클래스, 다형성, 캡슐화, Mixin 패턴 등 고급 OOP 설계 패턴을 살펴보는 것이 좋습니다. 실무에 바로 적용 가능한 객체 지향 설계 감각을 키워봅시다!

Python 파일 입출력 완전 정복: open(), read(), write()

python2ai — Sat, 12 Apr 2025 18:47:28 +0900

Python을 활용한 데이터 처리에서 빠질 수 없는 기술이 바로 파일 입출력(I/O) 입니다. 실무에서는 로그 저장, 설정 파일 읽기, 데이터 분석을 위한 CSV/텍스트 처리 등 다양한 상황에서 파일을 다루게 됩니다. 이 글에서는 open() 함수부터 파일을 읽고 쓰는 주요 메서드들까지, Python 파일 입출력의 핵심을 실무 중심으로 정리해보겠습니다.

1. 파일 열기: `open()` 함수

Python에서 파일 작업은 항상 open() 함수로 시작합니다. 이 함수는 지정한 파일을 열어 읽기, 쓰기, 추가 등 다양한 작업을 할 수 있는 파일 객체를 반환합니다.

f = open('example.txt', 'r')  # 읽기 모드로 파일 열기

주요 인자:

첫 번째 인자: 파일 경로 또는 이름 (상대경로나 절대경로 모두 사용 가능)
두 번째 인자: 모드 (읽기/쓰기/추가/이진 등)

모드	의미
'r'	읽기 (기본값, 파일이 없으면 에러 발생)
'w'	쓰기 (파일이 있으면 덮어쓰고, 없으면 새로 생성)
'a'	추가 (파일이 없으면 생성하고, 있으면 끝에 이어쓰기)
'rb', 'wb'	바이너리 모드 (텍스트가 아닌 파일 처리용)

주의: 'w' 모드는 기존 파일 내용을 완전히 지우므로 주의해서 사용해야 합니다.

2. 파일 읽기: `read()`, `readline()`, `readlines()`

파일을 읽을 때는 목적에 따라 적절한 메서드를 선택하는 것이 중요합니다.

(1) 전체 읽기: `read()`

파일의 모든 내용을 한 번에 문자열로 읽습니다.

with open('example.txt', 'r') as f:
    content = f.read()
    print(content)

장점: 전체 내용을 문자열로 간단히 읽을 수 있음
단점: 파일 크기가 큰 경우 메모리 사용량이 증가할 수 있음

(2) 한 줄씩 읽기: `readline()`

한 번에 한 줄씩 읽는 메서드로, 반복문과 함께 사용됩니다.

with open('example.txt', 'r') as f:
    line = f.readline()
    while line:
        print(line.strip())
        line = f.readline()

줄 단위로 처리할 때 적합
.strip()은 줄 끝의 개행 문자(\n) 제거용

(3) 모든 줄 리스트로 읽기: `readlines()`

파일의 모든 줄을 리스트 형태로 한 번에 읽습니다.

with open('example.txt', 'r') as f:
    lines = f.readlines()
    for line in lines:
        print(line.strip())

간단한 텍스트 분석이나 정렬 등에서 유용함

3. 파일 쓰기: `write()`, `writelines()`

(1) 문자열 쓰기: `write()`

문자열 하나하나를 직접 파일에 기록합니다.

with open('output.txt', 'w') as f:
    f.write("Hello, World!\n")
    f.write("두 번째 줄입니다.\n")

줄바꿈이 필요할 경우 반드시 \n 추가
기존 파일이 있다면 덮어씀

(2) 리스트 쓰기: `writelines()`

여러 줄을 한꺼번에 파일에 쓰고 싶을 때 사용합니다.

lines = ["첫째 줄\n", "둘째 줄\n", "셋째 줄\n"]
with open('output.txt', 'w') as f:
    f.writelines(lines)

리스트 내 각 문자열 끝에 \n이 포함되어 있어야 줄바꿈 처리됨
루프 없이 한 번에 여러 줄 쓰기 용도로 좋음

Tip: 파일 쓰기 시 encoding='utf-8'을 명시하면 한글 처리 오류를 방지할 수 있습니다.

4. 파일 열기 모드 정리

작업 목적에 따라 파일을 여는 모드를 다르게 설정해야 합니다.

모드	설명
'r'	읽기 전용 (파일이 존재하지 않으면 에러 발생)
'w'	쓰기 전용 (기존 내용 덮어씀, 없으면 새로 생성)
'a'	추가 전용 (기존 내용 보존, 뒤에 덧붙임)
'r+'	읽기 + 쓰기 (읽고 수정 가능, 파일 없으면 에러)
'rb', 'wb'	이진 파일 처리 (이미지, PDF 등)

r+b, a+b 등 복합 모드도 존재하며, 바이너리 파일 수정 시 사용됩니다.

5. `with` 문과 파일 자동 닫기

파일을 다 사용한 뒤 close()를 호출하지 않으면, 리소스 누수나 파일 잠금 문제가 발생할 수 있습니다.

with 문을 사용하면 파일을 열고 블록이 끝나는 시점에 자동으로 파일을 닫아줍니다.

with open('example.txt', 'r') as f:
    data = f.read()

with 문은 예외가 발생해도 파일을 안전하게 닫아주는 안정성 높은 구조입니다.
실무에서는 반드시 with 문으로 파일을 다루는 습관을 들이는 것이 좋습니다.

6. CSV 파일 간단히 다루기

Python에는 표 형태의 데이터를 다루기 위한 csv 모듈이 내장되어 있습니다. 특히 데이터 분석, 로깅, 시스템 구성 파일 처리에서 유용하게 활용됩니다.

CSV 읽기

import csv

with open('data.csv', 'r', newline='') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

newline=''을 넣는 이유는 플랫폼에 따라 줄바꿈이 중복되는 것을 방지하기 위함입니다.

CSV 쓰기

with open('data.csv', 'w', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['이름', '나이'])
    writer.writerow(['홍길동', 30])

writerow()는 한 줄씩, writerows()는 여러 줄을 리스트로 입력 가능

실제 프로젝트에서는 pandas.read_csv() 또는 to_csv()를 사용하는 경우가 더 많지만, 내장 csv 모듈로도 충분히 다양한 작업이 가능합니다.

마무리

이번 글에서는 Python의 파일 입출력 기능을 실무 중심으로 정리해보았습니다.

open() 함수로 파일을 연다
read(), write() 등의 메서드로 다양한 방식으로 데이터를 다룬다
with 문을 통해 리소스를 안정적으로 관리한다
CSV 파일도 다룰 수 있다

파일 입출력은 단순한 입문 기술처럼 보이지만, 실무에서는 데이터 파이프라인, 자동 보고서 생성, 시스템 로그 분석, 구성 파일 관리 등에서 필수적인 기능입니다.

Python 모듈과 패키지 이해하기: import, from, as의 활용법

python2ai — Mon, 24 Mar 2025 10:34:58 +0900

Python 프로젝트를 규모 있게 운영하거나 협업을 고려할 때, 모듈과 패키지의 개념은 필수적으로 이해해야 할 부분입니다. 이 글에서는 import, from, as 구문을 중심으로 모듈과 패키지의 기본 개념부터 실무 적용까지 단계별로 정리해보겠습니다.

모듈화 예시

1. 모듈(Module)이란?

모듈(Module)은 Python에서 재사용 가능한 코드 단위를 의미하며, .py 확장자를 가진 하나의 Python 파일입니다. 함수, 클래스, 변수 등을 정의해두고 다른 파일에서 import 하여 활용할 수 있도록 설계됩니다.

모듈을 사용하는 목적은 다음과 같습니다:

코드를 논리적으로 분리하고 재사용 가능하게 만듦
유지보수와 협업을 쉽게 함
중복을 줄이고 코드 품질을 향상시킴

예시: math 모듈 사용하기

import math

print(math.sqrt(16))  # 출력: 4.0
print(math.pi)        # 출력: 3.141592...

모듈은 크게 표준 라이브러리 모듈, 외부 패키지 모듈, 사용자 정의 모듈로 구분됩니다. Python에는 수많은 표준 라이브러리 모듈이 존재합니다. 또한, 자신만의 .py 파일을 만들어 원하는 기능을 정의해두는 경우 다른 스크립트에서 import 하여 자유롭게 사용할 수 있습니다.

2. import와 from 구문의 차이

Python에서 모듈을 불러올 때 가장 많이 사용하는 방식은 import와 from입니다. 두 구문의 차이를 명확히 이해하면 가독성과 성능 모두를 챙길 수 있습니다.

import 구문

전체 모듈을 가져올 때 사용합니다.

import datetime
print(datetime.datetime.now())

from 구문

모듈 내에서 특정 항목만 선택적으로 가져올 수 있습니다.

from datetime import datetime
print(datetime.now())

비교 정리

구문 형태	설명	장점
import module	전체 모듈 가져오기	충돌 방지, 명확한 참조
from module import name	특정 요소만 가져오기	코드 간결화, 빠른 접근

3. as 키워드로 별칭 사용하기

as 키워드를 사용하면 모듈이나 함수에 짧고 직관적인 별칭(alias) 을 붙일 수 있습니다.

import pandas as pd
import numpy as np

df = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
print(df)

별칭은 특히 외부 패키지 사용 시 코드의 길이를 줄이고, 협업 시 공통된 약속(alias convention) 으로 읽기 쉬운 코드를 만드는 데 유용합니다.

4. 표준 라이브러리 vs 외부 패키지

Python은 math, datetime, os, json 등 수백 개의 표준 라이브러리 모듈을 내장하고 있으며, 추가적으로 pandas, numpy, requests 등의 외부 패키지는 pip를 통해 설치하여 사용할 수 있습니다.

외부 패키지 설치 예시 (터미널)

pip install requests

설치 후 Python에서 import 하여 사용합니다:

import requests
response = requests.get("https://example.com")
print(response.status_code)

외부 패키지는 데이터 분석, 웹 개발, 머신러닝, 네트워크 처리 등 다양한 분야에서 핵심 도구로 사용됩니다.

5. `name == 'main'`의 의미

Python 모듈을 작성하다 보면, 종종 다음과 같은 코드를 보게 됩니다:

if __name__ == '__main__':
    main()

이 구문은 해당 Python 파일이 직접 실행되었는지, 아니면 다른 모듈에서 import 되었는지를 구분하는 조건입니다.

핵심 원리

Python은 스크립트를 실행할 때, 특수 변수 __name__을 자동으로 정의합니다.

모듈이 직접 실행되는 경우: __name__ == '__main__'
다른 모듈에 의해 import 되는 경우: __name__ == '모듈이름'

실무 활용 예시

def main():
    print("이 모듈은 단독 실행 중입니다.")

if __name__ == '__main__':
    main()

이 구조를 활용하면 다음과 같은 이점이 있습니다:

모듈 재사용과 독립 실행이 모두 가능
단위 테스트 또는 예제 실행 시 직접 실행 여부를 구분 가능
협업 시 의도치 않게 실행되는 것을 방지함

이러한 패턴은 특히 라이브러리나 유틸리티 모듈을 작성할 때 필수적인 방어적 코드 구조입니다.

이는 모듈을 재사용할 수 있게 만들면서도, 독립 실행도 가능한 구조를 제공하는 Python의 핵심 기법입니다.

6. 실무에서의 모듈화 전략

Python 프로젝트가 커질수록 코드의 가독성과 유지보수성을 높이기 위해 모듈화(Modularization) 전략이 필수적입니다. 모듈화는 코드를 기능 단위로 논리적으로 분리하고, 각 구성 요소를 재사용성과 독립성 있게 설계하는 과정을 의미합니다.

모듈화 전략의 핵심 원칙

단일 책임 원칙 (SRP): 하나의 모듈은 하나의 명확한 역할만 담당해야 함
의존성 최소화: 모듈 간 결합도는 낮추고 응집도는 높인다
재사용성: 여러 프로젝트나 상황에서 모듈을 재활용 가능하게 구성

구조적 예시

my_project/
├── main.py                    # 실행 진입점
├── config.py                  # 설정값, 환경변수
├── utils/                     # 도우미 함수 모음
│   ├── __init__.py
│   ├── preprocessing.py       # 데이터 전처리 관련 함수
│   └── visualization.py       # 시각화 도구 함수
├── models/                    # 모델 구조 및 학습 코드
│   ├── __init__.py
│   └── regression.py
└── pipelines/                # 워크플로우 구성
    └── train_pipeline.py

실무 적용 팁

공통 유틸리티는 utils 디렉토리에 통합
외부 노출 대상은 __init__.py에 명시적으로 정의 (__all__ 활용)
디렉토리 구조만으로도 프로젝트의 흐름이 한눈에 보이도록 설계

`init.py` 파일에는 무엇을 작성해야 할까?

__init__.py는 디렉토리를 Python 패키지로 인식시키는 파일로, Python 3.3 이상에서는 생략 가능하지만, 명시적으로 정의하는 것이 바람직합니다. 보통 다음과 같은 내용을 포함합니다:

공개할 모듈 또는 함수/클래스 지정

__all__ = ['preprocessing', 'visualization']

from utils import \* 시 여기에 명시된 모듈만 import 됩니다.

하위 모듈/클래스 import로 편의성 향상

from .preprocessing import clean_data
from .visualization import plot_chart

사용자가 utils.clean\_data()처럼 사용할 수 있도록 인터페이스 제공

공통 상수, 버전 정보, 초기화 코드 등

VERSION = '1.0.0'

초기화 작업 (예: 로깅, 설정 로딩)

import logging logging.basicConfig(level=logging.INFO)

이러한 모듈화 전략은 프로젝트의 확장성과 협업 생산성을 높이며, 유지보수에 드는 비용을 획기적으로 줄이는 핵심 기법입니다.

마무리

이번 글에서는 Python에서 모듈과 패키지를 어떻게 사용하는지, 그리고 import, from, as의 차이와 활용법까지 정리했습니다.

모듈: 코드의 재사용 단위 (.py 파일)
패키지: 모듈을 폴더 단위로 구성한 것
import/from/as: 다양한 방식으로 모듈 불러오기
__name__ == '__main__': 모듈의 실행 여부 구분
모듈화 전략과 __init__.py 작성 방법

모듈화는 Python 프로젝트를 더욱 효율적이고 견고하게 설계하는 데 핵심 역할을 합니다.

실무에서의 코드 구성력을 높이기 위해 반드시 익혀야 할 중요한 요소입니다.

Python의 예외 처리: try, except, finally 그리고 예외 정의하기

python2ai — Mon, 17 Mar 2025 12:37:12 +0900

Python을 활용한 개발에서는 예외(Exception) 처리가 필수적인 요소입니다. 예외 처리를 적절하게 활용하면 프로그램이 갑작스럽게 종료되는 것을 방지하고, 예상치 못한 오류를 보다 효율적으로 관리할 수 있습니다. 이번 글에서는 try-except 구조, finally 블록, 그리고 사용자 정의 예외를 다루며, 실무에서 활용할 수 있는 예외 처리 기법을 익혀보겠습니다.

1. 예외(Exception)란 무엇인가?

예외(Exception)는 프로그램 실행 중 발생하는 예상치 못한 상황을 의미합니다. 예외가 발생하면 프로그램이 즉시 종료될 수 있으므로, 이를 적절하게 처리하는 것이 중요합니다.

예외 처리는 단순히 오류를 회피하는 것이 아니라, 코드의 안정성을 높이고 예외적인 상황에서도 정상적인 흐름을 유지하도록 하는 핵심적인 기법입니다.

(1) 예외와 오류의 차이

오류(Error)와 예외(Exception)는 비슷한 개념처럼 보일 수 있지만, 실제로는 다릅니다. 오류는 보통 프로그램이 복구할 수 없는 심각한 문제이며, 예외는 적절한 처리를 통해 해결할 수 있는 문제입니다.

예를 들어, SyntaxError는 Python 코드가 문법적으로 잘못되었을 때 발생하는 오류이며, ZeroDivisionError는 0으로 나누기를 시도할 때 발생하는 예외입니다.

Python에서 발생하는 대표적인 오류와 예외는 다음과 같습니다:

구분	설명
오류(Error)	치명적인 문제로, 보통 해결할 수 없음 (예: 메모리 부족)
예외(Exception)	프로그래밍적으로 해결 가능한 오류 (예: 0으로 나누기)

(2) 예외 발생 예시

다음 코드에서는 0으로 나누는 연산을 수행하려고 할 때 ZeroDivisionError 예외가 발생합니다.

print(10 / 0)  # ZeroDivisionError 발생

이러한 예외를 처리하지 않으면 프로그램이 즉시 종료되므로, 예외 처리가 필요합니다.

또한, 사용자의 입력을 숫자로 변환하는 과정에서 발생할 수 있는 ValueError 예외를 살펴보겠습니다.

num = int("Python")  # ValueError 발생

이처럼 프로그램이 실행 중 예기치 않은 상황에 직면했을 때, 예외 처리를 활용하면 프로그램의 흐름을 보다 안정적으로 유지할 수 있습니다.

2. try-except 구조: 기본적인 예외 처리

예외 처리는 프로그램이 예상치 못한 상황에서도 원활하게 실행될 수 있도록 돕는 중요한 기법입니다. Python에서는 try-except 구조를 사용하여 예외를 감지하고 적절히 대응할 수 있습니다. 적절한 예외 처리는 프로그램의 신뢰성을 높이고, 유지보수를 더욱 용이하게 만듭니다.

(1) 기본 try-except 구조

try:
    x = 10 / 0  # 예외 발생
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다!")

출력:

0으로 나눌 수 없습니다!

(2) 여러 개의 예외 처리

하나의 try 블록에서 여러 개의 예외를 처리할 수도 있습니다.

try:
    num = int("Python")  # 문자열을 정수로 변환 시도
except ValueError:
    print("올바른 숫자를 입력하세요!")
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다!")

출력:

올바른 숫자를 입력하세요!

(3) 모든 예외 처리하기

모든 예외를 포괄적으로 처리하려면 Exception을 사용하면 됩니다.

try:
    print(10 / 0)
except Exception as e:
    print(f"예외 발생: {e}")

출력:

예외 발생: division by zero

⚠️ 주의: except Exception:을 남용하면 원인을 명확히 알 수 없으므로, 구체적인 예외를 명시하는 것이 권장됩니다.

2-1. try-except와 if-else의 차이점

예외 처리는 if-else 조건문을 사용하여 오류를 방지하는 것과 차이가 있습니다. if-else는 사전에 오류 발생 가능성을 검사하는 방식이며, try-except는 오류가 발생한 후 이를 처리하는 방식입니다.

if-else를 활용한 오류 방지

def divide(a, b):
    if b == 0:
        return "0으로 나눌 수 없습니다!"
    return a / b

print(divide(10, 2))  # 출력: 5.0
print(divide(10, 0))  # 출력: 0으로 나눌 수 없습니다!

위 코드에서는 if 문을 사용하여 0으로 나누는 경우를 사전에 방지합니다. 하지만 실수로 예외를 고려하지 못하면 프로그램이 종료될 수 있습니다.

try-except를 활용한 예외 처리

def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return "0으로 나눌 수 없습니다!"

print(divide(10, 2))  # 출력: 5.0
print(divide(10, 0))  # 출력: 0으로 나눌 수 없습니다!

try-except를 사용하면 ZeroDivisionError가 발생하더라도 프로그램이 강제 종료되지 않고, 적절한 오류 메시지를 반환할 수 있습니다.

언제 if-else와 try-except를 사용해야 할까?

오류를 사전에 방지할 수 있는 경우 → if-else 사용
예외가 발생할 가능성이 있으며 이를 대비해야 하는 경우 → try-except 사용

예를 들어, 사용자의 입력 값을 검증하는 경우 if-else가 적절하지만, 네트워크 연결이나 파일 입출력 작업처럼 예측할 수 없는 상황에서는 try-except가 더 효과적입니다.

3. finally 블록 활용: 예외 발생 여부와 관계없이 실행되는 코드

finally 블록은 예외 발생 여부와 관계없이 항상 실행되는 코드를 포함하는 블록입니다. 주로 파일 닫기, 데이터베이스 연결 종료, 네트워크 연결 해제 등과 같은 리소스 정리를 보장하는 역할을 합니다.

finally 블록이 필요한 이유

일반적으로 예외가 발생하면 해당 코드 블록이 실행을 중단하고 except 블록으로 넘어가지만, 리소스 정리가 필요한 경우 예외 발생 여부와 관계없이 반드시 실행되어야 하는 코드가 있습니다. 예를 들어, 파일을 열어 데이터를 읽고 난 후에는 예외가 발생하든 그렇지 않든 반드시 파일을 닫아야 합니다.

try:
    file = open("data.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("파일을 찾을 수 없습니다!")
finally:
    print("파일을 닫습니다.")
    file.close()

출력:

파일을 찾을 수 없습니다!
파일을 닫습니다.

이처럼 finally 블록을 활용하면 자원 정리(Cleanup) 를 보장할 수 있습니다.

4. 사용자 정의 예외 (Custom Exception)

Python에서는 기본적으로 다양한 내장 예외를 제공하지만, 경우에 따라 특정한 비즈니스 로직이나 프로젝트의 요구사항에 맞춘 예외를 직접 정의해야 하는 경우가 있습니다. 사용자 정의 예외를 활용하면 보다 직관적이고 유지보수하기 쉬운 예외 처리 시스템을 구축할 수 있습니다.

(1) 사용자 정의 예외가 필요한 이유

표준 예외로 처리하기 어려운 특정한 로직이 있을 때
예외 메시지를 커스터마이징하고, 보다 의미 있는 오류 메시지를 제공할 때
특정한 예외를 잡아서 일괄적으로 처리하고 싶을 때 기본 제공 예외 외에도, 상황에 맞는 사용자 정의 예외를 만들어 활용할 수 있습니다.

(2) 사용자 정의 예외 생성하기

class NegativeNumberError(Exception):
    """음수를 입력했을 때 발생하는 예외"""
    pass

def check_positive(number):
    if number < 0:
        raise NegativeNumberError("음수는 허용되지 않습니다!")
    return number

try:
    check_positive(-5)
except NegativeNumberError as e:
    print(f"예외 발생: {e}")

출력:

예외 발생: 음수는 허용되지 않습니다!

사용자 정의 예외를 활용하면 보다 직관적인 예외 처리가 가능해집니다.

5. 예외 처리 베스트 프랙티스

효율적인 예외 처리는 단순히 try-except를 추가하는 것이 아니라, 코드의 안정성과 유지보수성을 고려한 전략적인 접근이 필요합니다. 잘못된 예외 처리는 오히려 버그를 숨기거나 디버깅을 어렵게 만들 수 있습니다. Python에서 예외 처리를 효과적으로 수행하기 위한 몇 가지 베스트 프랙티스를 소개합니다.

✅ 구체적인 예외를 명시하라 (except Exception: 사용 최소화)

✅ 필요한 경우만 예외를 처리하라 (불필요한 try-except 사용 금지)

✅ finally 블록을 사용하여 리소스를 정리하라 (파일, 네트워크 연결 닫기)

✅ 사용자 정의 예외를 적극 활용하라 (보다 명확한 예외 처리 가능)

마무리

Python의 예외 처리는 코드의 안정성을 높이고, 예상치 못한 상황을 효율적으로 관리할 수 있도록 도와줍니다.

try-except 구문을 활용하여 예외 발생 시 프로그램이 종료되지 않도록 방지할 수 있습니다.
finally 블록을 사용하여 자원 정리를 보장할 수 있습니다.
사용자 정의 예외를 만들어 특정한 상황에 맞는 예외 처리를 구현할 수 있습니다.

실제 프로젝트에서 예외 처리를 효과적으로 적용하여, 보다 신뢰할 수 있는 Python 코드를 작성해봅시다!

Python 함수 심화: 람다 함수, *args와 **kwargs, 함수형 프로그래밍

python2ai — Fri, 14 Mar 2025 14:22:02 +0900

전전 글에서 Python의 함수 개념과 기본적인 사용법을 다루었습니다. 이제 한 단계 더 나아가, 람다 함수(Lambda Function), 가변 매개변수(*args, **kwargs), 함수형 프로그래밍을 활용하는 방법을 심도 있게 살펴보겠습니다. 이러한 개념을 숙달하면 Python 코드의 가독성, 재사용성, 확장성을 극대화할 수 있으며, 특히 데이터 분석 및 고급 소프트웨어 개발에서 필수적인 역량이 됩니다.

1. 람다 함수 (Lambda Function)

람다 함수는 이름 없이 간단한 연산을 수행하는 익명 함수로, 주로 고차 함수에서 사용됩니다. 가독성과 유지보수성을 고려하여 사용 범위를 신중히 결정하는 것이 중요합니다.

1-1. 람다 함수 기본 문법

# 일반 함수
def add(a, b):
    return a + b

# 람다 함수로 변환
add_lambda = lambda a, b: a + b

print(add(3, 5))  # 출력: 8
print(add_lambda(3, 5))  # 출력: 8

1-2. 람다 함수의 활용

람다 함수는 map(), filter(), sorted() 같은 고차 함수와 함께 사용되며, 특히 데이터 변환 및 필터링 작업에서 강력한 성능을 발휘합니다.

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

# map()과 함께 사용 (각 요소를 제곱)
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 출력: [1, 4, 9, 16, 25]

# filter()와 함께 사용 (짝수만 필터링)
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # 출력: [2, 4]

람다 함수는 한 줄로 표현 가능한 간단한 연산에 적합하지만, 복잡한 로직을 포함하면 가독성이 떨어질 수 있으므로 주의가 필요합니다.

2. 가변 매개변수 (*args, **kwargs)

Python에서는 함수의 매개변수 개수를 유동적으로 받을 수 있도록 *args와 **kwargs를 제공합니다. 이를 활용하면 정해진 개수 이상의 인자를 처리할 수 있으며, 함수의 재사용성을 높일 수 있습니다.

(1) *args: 여러 개의 위치 인자 받기

*args는 여러 개의 위치 인자를 튜플 형태로 전달받아 동적으로 처리할 수 있습니다.

def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4, 5))  # 출력: 15

(2) **kwargs: 여러 개의 키워드 인자 받기

**kwargs는 여러 개의 키워드 인자를 딕셔너리 형태로 전달받아 유연한 함수 호출을 가능하게 합니다.

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=30, city="Seoul")
# 출력:
# name: Alice
# age: 30
# city: Seoul

(3) *args와 **kwargs 함께 사용하기

이 두 가지를 조합하면, 위치 인자와 키워드 인자를 모두 수용하는 강력한 함수를 설계할 수 있습니다.

def function_example(a, b, *args, **kwargs):
    print(f"a: {a}, b: {b}")
    print("추가 위치 인자:", args)
    print("추가 키워드 인자:", kwargs)

function_example(1, 2, 3, 4, name="Alice", age=25)

출력:

a: 1, b: 2
추가 위치 인자: (3, 4)
추가 키워드 인자: {'name': 'Alice', 'age': 25}

이러한 기법을 사용하면 함수의 유연성을 극대화할 수 있으며, 다양한 입력을 처리하는 범용 함수 작성이 가능합니다.

3. 함수형 프로그래밍 (Functional Programming)

함수형 프로그래밍은 함수를 일급 객체로 다루며, 고차 함수를 적극적으로 활용하는 패러다임입니다. Python에서는 map(), filter(), reduce() 등의 함수를 제공하여 함수형 프로그래밍을 지원합니다.

(1) map(): 모든 요소에 함수 적용

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 출력: [1, 4, 9, 16, 25]

(2) filter(): 조건을 만족하는 요소만 필터링

evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # 출력: [2, 4]

(3) reduce(): 연속적인 연산 수행

reduce()는 functools 모듈에서 제공되며, 리스트의 모든 값을 누적하여 연산합니다.

from functools import reduce

# 리스트의 모든 요소를 곱하기
def multiply(x, y):
    return x * y

result = reduce(multiply, [1, 2, 3, 4, 5])
print(result)  # 출력: 120

이러한 함수형 프로그래밍 기법을 활용하면 코드를 간결하게 유지하면서도 강력한 데이터 처리를 수행할 수 있습니다.

마무리

이번 글에서는 람다 함수, 가변 매개변수, 함수형 프로그래밍을 활용하는 방법을 심도 있게 살펴보았습니다.

람다 함수는 간단한 연산을 수행하는 익명 함수로 활용할 수 있습니다.
*args, **kwargs는 다양한 개수의 인자를 처리하는 유연한 함수 작성에 유용합니다.
map(), filter(), reduce()를 활용한 함수형 프로그래밍 기법은 데이터 분석 및 처리에서 강력한 도구가 될 수 있습니다.

이제 Python의 고급 함수를 실무에서 활용하여, 보다 효율적인 코드를 작성해봅시다!

Python의 주요 데이터 구조: 리스트, 튜플, 딕셔너리, 집합

python2ai — Wed, 12 Mar 2025 15:15:25 +0900

Python에서는 데이터를 효율적으로 저장하고 관리하기 위해 다양한 내장 데이터 구조를 제공합니다. 특히, 리스트(List), 튜플(Tuple), 딕셔너리(Dictionary), 집합(Set)은 Python에서 가장 많이 활용되는 데이터 구조입니다. 각 구조의 특성과 활용법을 이해하면 보다 효율적인 코드 작성을 할 수 있습니다.

파이썬의 주요 데이터 구조

1. 리스트(List)

리스트는 Python에서 가장 많이 사용하는 데이터 구조로, 순서가 있는 가변(mutable) 자료형입니다. 즉, 요소의 추가, 삭제, 변경이 가능합니다. 또한, 데이터 분석과 알고리즘 구현에서 필수적인 자료형으로 활용됩니다.

1-1. 리스트 생성 및 기본 연산

# 리스트 생성
numbers = [1, 2, 3, 4, 5]
names = ["Alice", "Bob", "Charlie"]

# 리스트 요소 접근 (인덱싱)
print(numbers[0])  # 출력: 1
print(names[-1])   # 출력: Charlie

# 리스트 슬라이싱 (부분 데이터 추출)
print(numbers[1:4])  # 출력: [2, 3, 4]

1-2. 리스트 주요 메서드

(1) append()

append() 메서드는 리스트의 끝에 새로운 요소를 추가합니다.

numbers = [1, 2, 3]
numbers.append(4)
print(numbers)  # 출력: [1, 2, 3, 4]

(2) insert()

insert() 메서드는 특정 인덱스에 요소를 삽입합니다.

numbers = [1, 2, 4]
numbers.insert(2, 3)  # 첫번째 값이 인덱스, 두번째 값이 데이터
print(numbers)  # 출력: [1, 2, 3, 4]

(3) remove()

remove() 메서드는 리스트에서 특정 값을 찾아 제거합니다.

numbers = [1, 2, 3, 4]
numbers.remove(2)
print(numbers)  # 출력: [1, 3, 4]

(4) pop()

pop() 메서드는 리스트의 마지막 요소를 제거하고 반환합니다.

numbers = [1, 2, 3, 4]
popped_value = numbers.pop()
print(popped_value)  # 출력: 4
print(numbers)  # 출력: [1, 2, 3]

(5) len()

len() 함수는 리스트의 길이를 반환합니다.

numbers = [1, 2, 3, 4]
print(len(numbers))  # 출력: 4

종합 예시 :

# 요소 추가 및 삽입
numbers.append(6)  # 리스트 끝에 추가
numbers.insert(2, 10)  # 특정 위치에 추가

# 요소 삭제
del numbers[1]  # 특정 인덱스 요소 삭제
numbers.remove(10)  # 특정 값 삭제
pop_value = numbers.pop()  # 마지막 요소 반환 후 삭제

# 리스트 길이 확인
print(len(numbers))

1-3. 리스트 활용 예제

# 리스트 컴프리헨션 활용 (조건을 만족하는 요소 필터링)
squares = [x**2 for x in numbers if x % 2 == 0]
print(squares)  # 짝수의 제곱 리스트 출력

리스트는 다른 프로그래밍 언어의 배열과 유사한 기능을 하며, 반복적인 데이터 처리를 위한 핵심적인 역할을 합니다.

2. 튜플(Tuple)

튜플은 리스트와 유사하지만 불변(immutable)한 자료형입니다. 즉, 생성된 이후 값을 변경할 수 없습니다. 데이터 보호가 중요한 경우 튜플을 사용하면 메모리 사용량이 줄고, 코드의 안정성이 향상됩니다.

2-1. 튜플 생성 및 접근

# 튜플 생성
fruits = ("사과", "바나나", "오렌지")

# 튜플 요소 접근
print(fruits[0])  # 출력: 사과

# 튜플은 불변하므로 값 변경 불가
# fruits[0] = "포도"  # 오류 발생

2-2. 튜플 활용 예제

# 여러 개의 값을 반환하는 함수
def get_coordinates():
    return (37.7749, -122.4194)  # 위도, 경도 반환

latitude, longitude = get_coordinates()
print(latitude, longitude)

튜플은 데이터 무결성이 중요한 경우, 예를 들어 DB에서 조회된 레코드 데이터를 변경할 수 없게 유지할 때 활용됩니다.

3. 딕셔너리(Dictionary)

딕셔너리는 키-값(key-value) 쌍으로 이루어진 데이터 구조로, 빠른 검색 속도가 강점입니다. 대량의 데이터를 효율적으로 저장하고 검색하는 데 매우 유용합니다.

3-1. 딕셔너리 생성 및 요소 접근

# 딕셔너리 생성
person = {"name": "Alice", "age": 25, "city": "Seoul"}

# 키를 사용한 값 조회
print(person["name"])  # 출력: Alice

# 값 변경
person["age"] = 26

3-2. 딕셔너리 주요 메서드

(1) keys()

keys() 메서드는 딕셔너리의 모든 키를 반환합니다.

person = {"name": "Alice", "age": 25}
print(person.keys())  # 출력: dict_keys(['name', 'age'])

(2) values()

values() 메서드는 딕셔너리의 모든 값을 반환합니다.

print(person.values())  # 출력: dict_values(['Alice', 25])

(3) items()

items() 메서드는 키-값 쌍을 튜플 형태로 반환합니다.

print(person.items())
# 출력: dict_items([('name', 'Alice'), ('age', 25)])

(4) get()

get() 메서드는 키에 해당하는 값을 반환하며, 존재하지 않을 경우 기본값을 반환합니다.

print(person.get("name"))  # 출력: Alice
print(person.get("city", "Unknown"))  # 출력: Unknown

(5) update()

update() 메서드는 기존 딕셔너리에 새로운 키-값을 추가하거나 기존 값을 변경합니다.

person.update({"city": "Seoul"})
print(person)  # 출력: {'name': 'Alice', 'age': 25, 'city': 'Seoul'}

종합 예시 :

# 요소 추가 및 삭제
person["job"] = "Engineer"
del person["city"]

# 키 존재 여부 확인
if "name" in person:
    print("이름 정보가 있습니다.")

# 딕셔너리 반복문 활용
for key, value in person.items():
    print(f"{key}: {value}")

딕셔너리는 JSON 형태의 데이터를 다룰 때 필수적인 자료형입니다.

4. 집합(Set)

집합은 중복을 허용하지 않고, 순서가 없는 데이터 구조입니다. 중복된 데이터를 제거하거나, 집합 연산을 수행할 때 유용합니다.

4-1. 집합 생성 및 기본 연산

# 집합 생성
numbers = {1, 2, 3, 4, 5, 5, 5}  # 중복 요소 자동 제거
print(numbers)  # 출력: {1, 2, 3, 4, 5}

# 집합 연산
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
print(A | B)  # 합집합 {1, 2, 3, 4, 5, 6}
print(A & B)  # 교집합 {3, 4}
print(A - B)  # 차집합 {1, 2}

4-2. 집합 주요 메서드

(1) add()

add() 메서드는 집합에 새로운 요소를 추가합니다.

numbers = {1, 2, 3}
numbers.add(4)
print(numbers)  # 출력: {1, 2, 3, 4}

(2) remove()

remove() 메서드는 특정 요소를 제거하며, 요소가 없을 경우 오류를 발생시킵니다.

numbers.remove(2)
print(numbers)  # 출력: {1, 3, 4}

(3) discard()

discard() 메서드는 특정 요소를 제거하지만, 요소가 없을 경우 오류를 발생시키지 않습니다.

numbers.discard(10)  # 오류 발생 X

(4) union() (합집합)

두 개의 집합을 합쳐 새로운 집합을 반환합니다.

A = {1, 2, 3}
B = {3, 4, 5}
print(A.union(B))  # 출력: {1, 2, 3, 4, 5}

(5) intersection() (교집합)

두 개의 집합에서 공통 요소만 반환합니다.

print(A.intersection(B))  # 출력: {3}

(6) difference() (차집합)

첫 번째 집합에서 두 번째 집합의 요소를 제거합니다.

print(A.difference(B))  # 출력: {1, 2}

리스트 -> 집합 활용 예시 :

# 리스트에서 중복 제거
items = ["apple", "banana", "apple", "orange"]
unique_items = set(items)
print(unique_items)  # 출력: {'banana', 'orange', 'apple'}

집합은 데이터를 다루면서 중복을 제거하거나, 그룹 간 비교를 수행할 때 필수적인 자료형입니다.

5. 데이터 구조 선택 가이드

데이터 구조를 선택할 때는 데이터의 특성, 변경 가능 여부, 검색 속도, 중복 처리 방식 등을 고려해야 합니다. 각 구조가 가지는 장점을 잘 이해하면, 성능을 최적화하고 코드의 유지보수성을 높일 수 있습니다. 다음은 주요 데이터 구조의 선택 기준입니다. 각 데이터 구조는 특정 상황에서 더 적합한 경우가 있습니다.

데이터 구조	특징	사용 사례
리스트(List)	순서 O, 변경 O, 인덱싱 O	시퀀스 데이터 저장, 반복문 활용, 대량 데이터 처리
튜플(Tuple)	순서 O, 변경 X, 메모리 효율적	불변 데이터 저장, 함수에서 여러 값 반환
딕셔너리(Dictionary)	키-값 저장, 검색 속도 빠름	JSON 데이터 처리, 매핑 관계 저장, 캐싱 시스템
집합(Set)	중복 X, 순서 X, 빠른 포함 검사	중복 제거, 집합 연산, 데이터 필터링

실제 데이터 분석에서는 딕셔너리와 리스트를 조합하여 JSON 데이터를 처리하거나, 집합을 활용해 중복을 제거하는 방식이 많이 사용됩니다. 상황에 맞게 적절한 데이터 구조를 선택한다면 보다 더 효율적인 프로그래밍이 될 것입니다.

마무리

Python의 리스트, 튜플, 딕셔너리, 집합은 각각 고유한 특성을 가지며, 데이터 분석, 알고리즘 문제 해결, 대량의 데이터를 효율적으로 관리할 때 필수적인 자료형입니다.

실제 데이터 분석에서는 JSON, CSV 데이터 처리와 함께, 딕셔너리와 리스트의 조합이 자주 사용되며, 중복된 데이터를 필터링할 때는 집합(Set) 이 강력한 도구로 활용됩니다.

각 데이터 구조의 특성을 정확히 이해하고 상황에 맞게 선택하는 것은 효율적인 프로그래밍의 핵심 요소입니다. 하지만 직접 경험해 본 바로는, list와 dictionary 두 가지를 가장 많이 사용하는 것 같습니다. 앞으로는 저도 상황에 맞게 tuple과 set을 사용해보도록 노력해야겠습니다..

Python 함수: 정의, 호출, 매개변수, 반환값

python2ai — Tue, 11 Mar 2025 13:12:50 +0900

함수란 무엇인가?

함수(Function)는 특정 연산을 수행하는 코드 블록이며, 모듈화된 프로그래밍의 핵심 요소입니다. Python에서는 함수를 활용하여 코드의 재사용성, 유지보수성, 가독성을 극대화할 수 있습니다. 또한, Python의 동적 타이핑 시스템과 결합하면 보다 유연하고 강력한 프로그래밍이 가능합니다.

함수를 사용하면 다음과 같은 이점이 있습니다:

중복 코드 제거: 동일한 로직을 여러 번 작성할 필요 없이, 함수를 호출하여 재사용할 수 있습니다.
가독성 향상: 프로그램의 흐름을 이해하기 쉬워지며, 코드가 논리적으로 구분됩니다.
디버깅 및 유지보수 용이: 문제가 발생했을 때 특정 함수만 수정하면 되므로, 코드 관리가 효율적입니다.

함수 예시

1. 함수 정의 및 호출

Python에서 함수는 def 키워드를 사용하여 선언하며, 특정 시점에서 호출하여 실행할 수 있습니다.

# 함수 정의
def greet():
    """사용자에게 인사하는 함수."""
    print("안녕하세요!")

# 함수 호출
greet()  # 출력: 안녕하세요!

함수를 호출하면 내부 코드가 실행되며, 호출되지 않는 한 실행되지 않습니다. 이는 프로그램을 모듈화하고 특정 기능을 독립적으로 관리하는 데 유용합니다.

2. 함수의 매개변수와 인자

함수를 호출할 때 전달하는 값을 인자(argument) 라고 하며, 함수 내부에서 인자를 받아들이는 변수를 매개변수(parameter) 라고 합니다. 매개변수는 함수가 외부로부터 값을 받아 처리할 수 있도록 도와주는 역할을 합니다. 함수는 매개변수를 활용하여 동적으로 값을 전달받을 수 있습니다. 이를 통해 보다 유연한 프로그램 설계가 가능합니다.

# 매개변수를 사용하는 함수
def greet(name):
    """이름을 입력받아 인사하는 함수."""
    print(f"안녕하세요, {name}님!")

# 인자 전달
greet("철수")  # 출력: 안녕하세요, 철수님!

다중 매개변수 활용

Python에서는 여러 개의 매개변수를 정의하여 복잡한 연산을 수행할 수 있습니다.

def add(a, b):
    """두 숫자를 더한 값을 반환하는 함수."""
    return a + b

result = add(3, 5)
print(result)  # 출력: 8

3. 기본값을 갖는 매개변수

함수를 정의할 때 특정 매개변수에 기본값을 설정하면, 호출 시 해당 인자를 생략해도 자동으로 지정된 기본값이 사용됩니다. 이를 활용하면 함수 호출을 더욱 유연하게 만들 수 있습니다. 예를 들어, 자주 사용하는 기본값을 지정해두면, 불필요한 인자 입력을 줄이고 가독성을 높일 수 있습니다.

매개변수에 기본값을 설정하면, 인자를 전달하지 않았을 때 기본값이 자동으로 적용됩니다.

def introduce(name, age = 20):
    """이름과 나이를 입력받아 자기소개하는 함수."""
    print(f"저는 {name}이고, {age}살입니다.")

introduce("지민")  # 기본값 사용 (age=20)
introduce("윤아", 25)  # 기본값 변경 (age=25)

4. 타입 힌트(Type Hinting) 사용하기

Python 3.5부터 등장한 타입 힌트(Type Hinting)를 활용하면 코드의 가독성과 안정성을 높일 수 있습니다. 함수의 매개변수와 반환값의 타입을 명시적으로 지정하면, 개발자가 함수의 사용 방식을 더욱 쉽게 이해할 수 있습니다.

# 타입 힌트를 추가한 함수 정의
def add(a: int, b: int) -> int:
    return a + b

def greet(name: str) -> None:
    print(f"안녕하세요, {name}님!")

Python의 타입 힌트(Type Hinting)를 사용하면 코드의 가독성을 높이고, 오류를 사전에 방지할 수 있습니다. 위 코드에서 -> int는 반환값이 정수형(int)임을 명시합니다. 타입 힌트는 정적 분석 도구(mypy)와 함께 사용하면 더욱 강력한 기능을 제공합니다. 예를 들어, 아래와 같은 코드가 있다고 가정해 봅시다.

# example.py

def add(a: int, b: int) -> int:
    return a + b

print(add(3, 5))   # 정상 작동
print(add("3", 5)) # 실행하면 오류 발생!

Python은 동적 타입 언어이므로 실행하기 전까지 타입 오류를 감지하지 못합니다. 하지만 mypy를 사용하면 실행 전에 오류를 발견할 수 있습니다.

터미널에서 다음 명령어를 실행하면 타입 검사가 가능합니다.

mypy example.py

출력 결과:

example.py:5: error: Argument 1 to "add" has incompatible type "str"; expected "int"
Found 1 error in 1 file (checked 1 source file)

이처럼 mypy를 활용하면 실행 전에 타입 오류를 사전에 방지할 수 있습니다.

5. 키워드 인자

키워드 인자(Keyword Argument)는 함수를 호출할 때 매개변수의 이름을 명시적으로 지정하여 값을 전달하는 방식입니다. 이를 사용하면 매개변수의 순서를 신경 쓰지 않고도 원하는 값을 정확하게 전달할 수 있어 코드의 가독성이 향상됩니다.

키워드 인자의 장점

순서에 의존하지 않음: 매개변수의 순서가 변경되더라도 함수 호출에 영향을 주지 않음
가독성 향상: 코드의 의미를 더욱 명확하게 표현할 수 있음
유연한 함수 호출: 필요에 따라 특정 매개변수만 선택적으로 제공 가능

키워드 인자 예제

def describe_pet(animal: str, name: str) -> None:
    """반려동물의 종류와 이름을 출력하는 함수."""
    print(f"{name}은(는) {animal}입니다.")

# 키워드 인자 사용
describe_pet(name="쿠키", animal="강아지")  # 순서를 바꿔도 정상 작동
describe_pet(animal="고양이", name="나비")  # 더욱 가독성이 높아짐

출력:

쿠키은(는) 강아지입니다.
나비은(는) 고양이입니다.

키워드 인자와 위치 인자 혼합 사용

위치 인자와 키워드 인자를 함께 사용할 수도 있지만, 위치 인자는 항상 키워드 인자보다 먼저 와야 합니다.

def order_food(main: str, side: str, drink: str) -> None:
    print(f"메인 요리: {main}, 사이드: {side}, 음료: {drink}")

# 위치 인자 + 키워드 인자 혼합 사용
order_food("스테이크", side="샐러드", drink="콜라")  # 정상 작동

# 키워드 인자가 위치 인자보다 먼저 오면 오류 발생
# order_food(side="샐러드", "스테이크", drink="콜라")  # 오류 발생!

6. 가변 매개변수 (*args, **kwargs)

가변 매개변수를 사용하면 인자의 개수가 변할 수 있으며, 함수의 확장성을 극대화할 수 있습니다.

# *args: 여러 개의 위치 인자를 받을 때 사용
def sum_all(*args: int) -> int:
    """입력된 모든 숫자의 합을 반환하는 함수."""
    return sum(args)

print(sum_all(1, 2, 3, 4))  # 출력: 10

# **kwargs: 여러 개의 키워드 인자를 받을 때 사용
def print_info(**kwargs: dict) -> None:
    """사용자의 정보를 출력하는 함수."""
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="철수", age=30, city="서울")
# 출력:
# name: 철수
# age: 30
# city: 서울

7. 람다 함수 (Lambda Function)

람다 함수는 익명 함수(Anonymous Function)로, 간단한 연산을 수행할 때 유용합니다. 고차 함수(Higher-order Function) 와 결합하면 더욱 강력한 기능을 제공합니다.

# 일반 함수
def add(a: int, b: int) -> int:
    return a + b

# 람다 함수
add_lambda = lambda a, b: a + b

print(add_lambda(3, 7))  # 출력: 10

람다 함수는 map(), filter(), sorted() 등의 내장 함수와 함께 사용할 때 더욱 강력합니다.

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 출력: [1, 4, 9, 16, 25]

8. 함수의 반환값 (return)

return 문을 사용하여 함수에서 값을 반환할 수 있습니다. 반환값이 있는 함수는 결과를 변수에 저장하거나 다른 함수의 입력값으로 활용할 수 있어, 코드의 재사용성과 확장성이 높아집니다.

def multiply(a: int, b: int) -> int:
    return a * b

result = multiply(4, 5)
print(result)  # 출력: 20

9. 함수의 응용 사례

실무에서는 함수를 활용하여 데이터 분석, 웹 개발, AI 모델링 등 다양한 작업을 수행합니다. 예를 들어, 특정 조건을 만족하는 데이터를 필터링하는 함수를 작성할 수 있습니다.

def is_even(number: int) -> bool:
    """주어진 숫자가 짝수인지 판별하는 함수."""
    return number % 2 == 0

print(is_even(10))  # 출력: True
print(is_even(7))   # 출력: False

마무리

Python에서 함수는 코드를 깔끔하게 정리하고, 유지보수를 쉽게 만들어 주는 강력한 도구입니다. 함수의 개념을 명확하게 이해하고 활용하면, 보다 체계적인 프로그램을 작성할 수 있으며, 코드의 재사용성과 확장성을 극대화할 수 있습니다.

특히, 함수의 매개변수와 반환값을 명확히 정의하고, 타입 힌트를 적극 활용하면 더욱 안정적인 코드를 작성할 수 있습니다. 실무에서는 함수형 프로그래밍 패러다임을 적용하거나, API 설계, 데이터 분석, AI 모델링 등 다양한 분야에서 함수를 활용할 수 있습니다.

Python의 함수 개념을 충분히 익히고 나면, 더 복잡한 기능을 가진 프로그램을 보다 체계적으로 구축할 수 있습니다. 함수는 단순한 문법 요소를 넘어, 유지보수성과 가독성이 뛰어난 소프트웨어를 설계하는 데 필수적인 요소이므로, 꾸준한 연습을 통해 익숙해지는 것이 중요합니다.

Python 제어문: 조건문과 반복문

python2ai — Sat, 8 Mar 2025 17:31:28 +0900

Python에서 제어문(Control Flow Statements)은 프로그램의 논리를 설계하고 실행 흐름을 조작하는 필수적인 도구입니다. 프로그래밍에서 제어문은 단순한 코드 실행을 넘어 효율적인 연산, 자동화, 알고리즘 최적화의 핵심 역할을 수행합니다. 조건에 따라 특정 코드 블록을 실행하거나 반복을 수행함으로써, 유연하고 강력한 프로그램을 만들 수 있습니다.

이번 글에서는 조건문(if문)과 반복문(for문, while문)을 단순한 문법적 이해를 넘어 실제 활용에 초점을 맞춰 설명하며, 프로덕션 코드에서 효율성을 극대화하는 방법까지 다루겠습니다.

조건문과 반복문을 마구 혼용한 예시

1. 조건문 (if, elif, else)

조건문은 프로그램의 흐름을 동적으로 결정하는 중요한 역할을 합니다. 특정 조건이 만족될 경우 코드가 실행되며, 이를 통해 의사 결정 로직을 프로그래밍적으로 구현할 수 있습니다. 예를 들어, 로그인 시스템에서 비밀번호 검증, AI 모델의 분류 기준, 데이터 처리 중 특정 조건에 따라 다른 작업을 수행하는 등의 경우에 활용됩니다.

Python의 조건문은 Boolean(참/거짓) 평가를 기반으로 동작하며, True인 경우 해당 코드 블록이 실행됩니다.

1.1 if문 기본 사용법

x = 10
if x > 5:
    print("x는 5보다 큽니다.")

✅ 결과: x는 5보다 큽니다.

조건이 True이면 코드 블록이 실행됩니다. 여기서 x > 5가 True이므로 print문이 실행됩니다.

1.2 if-else문

x = 3
if x > 5:
    print("x는 5보다 큽니다.")
else:
    print("x는 5 이하입니다.")

✅ 결과: x는 5 이하입니다.

조건이 False일 때 else 블록이 실행되어 예외 처리를 할 수 있습니다.

1.3 if-elif-else문

score = 85
if score >= 90:
    print("A 학점")
elif score >= 80:
    print("B 학점")
elif score >= 70:
    print("C 학점")
else:
    print("F 학점")

✅ 결과: B 학점

여러 개의 조건을 순차적으로 평가할 수 있으며, 가장 먼저 True인 블록이 실행됩니다.

1.4 중첩 if문

x = 10
y = 5
if x > 5:
    if y > 3:
        print("x는 5보다 크고, y는 3보다 큽니다.")

✅ 결과: x는 5보다 크고, y는 3보다 큽니다.

2. 반복문 (for, while)

반복문은 동일한 작업을 반복 수행하는 과정에서 코드 중복을 방지하고, 실행 효율을 극대화하는 역할을 합니다. 수많은 데이터를 처리하는 데이터 분석, 대규모 시스템의 요청 처리, 그래픽 연산 등에서 핵심적으로 사용됩니다.

2.1 for문 기본 사용법

for i in range(5):
    print(i)

✅ 결과:

range(5)는 0부터 4까지 5번 반복하며 i에 해당 숫자를 할당합니다.

2.2 리스트 및 문자열 순회 (for문)

fruits = ["사과", "바나나", "체리"]
for fruit in fruits:
    print(fruit)

✅ 결과:

사과
바나나
체리

컬렉션(리스트, 튜플, 딕셔너리 등)의 요소를 하나씩 순회할 때 사용됩니다.

또한, 문자열도 리스트처럼 순회할 수 있습니다. 각 문자가 개별 요소로 처리됩니다.

text = "Python"
for char in text:
    print(char)

✅ 결과:

P
y
t
h
o
n

이렇게 하면 문자열의 각 문자를 개별적으로 접근할 수 있어, 문자열 분석 및 변환 작업에서 유용하게 활용할 수 있습니다.

2.3 while문 기본 사용법

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

✅ 결과:

while문은 조건이 True인 동안 실행됩니다. 적절한 종료 조건이 없으면 무한 루프가 발생할 수 있습니다.

2.4 while문의 무한 루프와 주의점

while True:
    print("이 코드는 계속 실행됩니다!")
    break

✅ 결과: 루프가 한 번 실행된 후 종료됨

while 1: 이런 식으로도 사용할 수 있는데, 1이 True로 평가되어 동일한 무한 루프가 생성됩니다. 무한 루프가 필요할 경우 반드시 break문을 활용하여 제어해야 합니다.

2.5 break와 continue문

break문은 반복문을 즉시 종료할 때 사용됩니다. 특정 조건이 만족되면 반복을 중단하고, 이후의 반복문 코드는 실행되지 않습니다.

for i in range(5):
    if i == 2:
        break
    print(i)

✅ 결과:

0
1

반복문이 i == 2 조건을 만나면 break문이 실행되어 루프가 종료됩니다.

continue문은 현재 반복을 건너뛰고 다음 반복을 수행할 때 사용됩니다.

for i in range(5):
    if i == 2:
        continue
    print(i)

✅ 결과:

break: 반복문 즉시 종료
continue: 해당 반복을 건너뛰고 다음 반복 수행

2.6 중첩 반복문

중첩 반복문(Nested Loop)이란 하나의 반복문 안에 또 다른 반복문이 포함된 구조를 의미합니다. 이러한 구조는 이차원 데이터 처리, 다중 조건 검사, 테이블 생성, 행렬 연산 등에서 유용하게 활용됩니다.

내부 반복문(inner loop)은 외부 반복문(outer loop)이 한 번 실행될 때마다 전체를 반복합니다. 이를 통해 이중, 삼중 이상의 반복 구조를 구현할 수 있으며, 특정 패턴이나 데이터 구조를 다룰 때 강력한 도구로 사용됩니다.

중첩 반복문의 기본 예제

for i in range(3):  # 바깥 루프 (행)
    for j in range(2):  # 안쪽 루프 (열)
        print(f"i: {i}, j: {j}")

✅ 결과:

i: 0, j: 0
i: 0, j: 1
i: 1, j: 0
i: 1, j: 1
i: 2, j: 0
i: 2, j: 1

활용 예제: 구구단 출력

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

✅ 결과 (일부):

2 x 1 = 2
2 x 2 = 4
...
9 x 8 = 72
9 x 9 = 81

주의: 중첩 반복문을 사용할 때는 불필요한 반복을 최소화해야 하며, 반복 횟수가 커질수록 성능에 영향을 미칠 수 있습니다. 필요에 따라 break나 continue를 활용하여 제어할 수도 있습니다.

마무리

제어문을 효과적으로 사용하면 프로그램의 구조적 설계가 가능하며, 코드의 유지보수성을 극대화할 수 있습니다.

✔ 조건문은 데이터 흐름을 결정하고, 다양한 입력값에 대한 논리를 구현하는 데 필수적입니다.
✔ 반복문은 자동화를 통해 실행 효율을 높이며, 대규모 데이터 처리 및 알고리즘 구현에서 중요한 역할을 합니다.

이러한 개념을 확실히 익히고 나면, 더 복잡한 알고리즘과 시스템 설계를 보다 유연하고 효율적으로 수행할 수 있습니다.

다음 글에서는 함수(Function)의 개념과 활용을 다뤄보겠습니다!

Python 기초부터 AI까지!

python2ai — Thu, 6 Mar 2025 10:24:22 +0900

제가 공부했던 그리고 공부하고 있는 내용 전부 기록하려 합니다.

파이썬 기초부터 요즘 핫한 LLM 활용 방법까지 작성해보겠습니다.

궁금한 점이 있다면 댓글로 질문해주세요!

Python 기본 문법과 변수, 데이터 타입

python2ai — Thu, 6 Mar 2025 10:02:33 +0900

Python을 다루기 위해서는 먼저 변수와 데이터 타입을 이해하는 것이 중요합니다.
본 글에서는 Python의 변수 개념과 다양한 데이터 타입을 설명하고, 각 데이터 타입별 연산 결과를 비교해 보겠습니다.

Python Variable

1. 변수(Variable)란?

변수는 데이터를 저장하는 공간입니다. Python에서는 변수를 선언할 때 자료형을 명시할 필요 없이, 값을 할당하면 자동으로 타입이 지정됩니다.

변수 선언 예제

x = 10        # 정수 (int)
y = 3.14      # 실수 (float)
name = "Alice" # 문자열 (str)
is_python = True  # 불리언 (bool)

Python에서는 = 연산자를 사용하여 변수를 선언하고 값을 할당합니다.

변수 이름 규칙

영문자(A-Z, a-z), 숫자(0-9), 밑줄(_) 사용 가능
숫자로 시작할 수 없음 (예: 2name ❌, name2 ✅)
대소문자 구별 (Name과 name은 다른 변수)
예약어 사용 불가 (예: class, def, if 등)

2. 데이터 타입(Data Types)

Python의 주요 데이터 타입은 다음과 같습니다.

2.1 기본 데이터 타입

데이터 타입	설명	예제
`int`	정수형 데이터	`x = 10`
`float`	실수형 데이터	`y = 3.14`
`str`	문자열 데이터	`name = "Alice"`
`bool`	참/거짓 값	`is_python = True`

2.2 컬렉션(Collection) 데이터 타입

데이터 타입	설명	예제
`list`	여러 값을 순서대로 저장 (변경 가능)	`numbers = [1, 2, 3]`
`tuple`	여러 값을 순서대로 저장 (변경 불가)	`coordinates = (10, 20)`
`dict`	키-값 쌍 저장	`person = {"name": "Alice", "age": 25}`
`set`	중복 없는 데이터 저장	`unique_nums = {1, 2, 3}`

3. 데이터 타입별 연산과 결과

각 데이터 타입별로 + 연산을 수행하면 어떻게 될까요?

3.1 숫자형 연산 (`int`, `float`)

x = 10  # int
y = 3.14  # float
print(x + y)  # 결과: 13.14

정수와 실수를 더하면 자동으로 float 형으로 변환됩니다.

3.2 문자열 연산 (`str`)

s1 = "Hello"
s2 = "Python"
print(s1 + " " + s2)  # 결과: "Hello Python"

문자열끼리 + 연산을 하면 이어 붙이기가 됩니다.
참고로, 숫자형과 문자열을 연산하려 하면 오류가 발생합니다..

3.3 리스트 연산 (`list`)

list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 + list2)  # 결과: [1, 2, 3, 4, 5, 6]

리스트끼리 + 연산을 하면 요소가 합쳐진 새로운 리스트가 생성됩니다.

3.4 튜플 연산 (`tuple`)

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
print(tuple1 + tuple2)  # 결과: (1, 2, 3, 4, 5, 6)

튜플도 리스트처럼 + 연산이 가능합니다.

3.5 딕셔너리 연산 (`dict`)

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
dict1.update(dict2)
print(dict1)  # 결과: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

딕셔너리는 + 연산이 불가능하며, update()를 사용하여 병합해야 합니다.

3.6 집합 연산 (`set`)

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 | set2)  # 결과: {1, 2, 3, 4, 5} (합집합)

집합은 + 연산이 불가능하지만, | (합집합), & (교집합), - (차집합) 등의 연산이 가능합니다.

마무리

이번 글에서는 Python의 변수와 다양한 데이터 타입을 다루고, 각 데이터 타입별로 + 연산을 수행했을 때의 결과를 확인했습니다.

다음 글에서는 제어문(조건문과 반복문)을 다뤄보겠습니다!

나혼자 코딩

Python 클래스와 객체 이해하기: OOP의 기초부터 실무 활용까지

1. 클래스와 객체란?

2. 생성자 __init__()

3. 인스턴스 변수와 메서드

4. self의 의미

5. 클래스 변수 vs 인스턴스 변수

6. 상속과 오버라이딩

마무리

Python 파일 입출력 완전 정복: open(), read(), write()

1. 파일 열기: open() 함수

주요 인자:

2. 파일 읽기: read(), readline(), readlines()

(1) 전체 읽기: read()

(2) 한 줄씩 읽기: readline()

(3) 모든 줄 리스트로 읽기: readlines()

3. 파일 쓰기: write(), writelines()

(1) 문자열 쓰기: write()

(2) 리스트 쓰기: writelines()

4. 파일 열기 모드 정리

5. with 문과 파일 자동 닫기

6. CSV 파일 간단히 다루기

CSV 읽기

CSV 쓰기

마무리

Python 모듈과 패키지 이해하기: import, from, as의 활용법

1. 모듈(Module)이란?

예시: math 모듈 사용하기

2. import와 from 구문의 차이

import 구문

from 구문

비교 정리

3. as 키워드로 별칭 사용하기

4. 표준 라이브러리 vs 외부 패키지

외부 패키지 설치 예시 (터미널)

5. __name__ == '__main__'의 의미

핵심 원리

실무 활용 예시

6. 실무에서의 모듈화 전략

모듈화 전략의 핵심 원칙

구조적 예시

실무 적용 팁

__init__.py 파일에는 무엇을 작성해야 할까?

마무리

Python의 예외 처리: try, except, finally 그리고 예외 정의하기

1. 예외(Exception)란 무엇인가?

(1) 예외와 오류의 차이

(2) 예외 발생 예시

2. try-except 구조: 기본적인 예외 처리

(1) 기본 try-except 구조

(2) 여러 개의 예외 처리

(3) 모든 예외 처리하기

2-1. try-except와 if-else의 차이점

if-else를 활용한 오류 방지

try-except를 활용한 예외 처리

언제 if-else와 try-except를 사용해야 할까?

3. finally 블록 활용: 예외 발생 여부와 관계없이 실행되는 코드

finally 블록이 필요한 이유

4. 사용자 정의 예외 (Custom Exception)

(1) 사용자 정의 예외가 필요한 이유

(2) 사용자 정의 예외 생성하기

5. 예외 처리 베스트 프랙티스

마무리

Python 함수 심화: 람다 함수, *args와 **kwargs, 함수형 프로그래밍

1. 람다 함수 (Lambda Function)

1-1. 람다 함수 기본 문법

1-2. 람다 함수의 활용

2. 가변 매개변수 (*args, **kwargs)

(1) *args: 여러 개의 위치 인자 받기

(2) **kwargs: 여러 개의 키워드 인자 받기

(3) *args와 **kwargs 함께 사용하기

3. 함수형 프로그래밍 (Functional Programming)

(1) map(): 모든 요소에 함수 적용

(2) filter(): 조건을 만족하는 요소만 필터링

(3) reduce(): 연속적인 연산 수행

마무리

Python의 주요 데이터 구조: 리스트, 튜플, 딕셔너리, 집합

1. 리스트(List)

1-1. 리스트 생성 및 기본 연산

1-2. 리스트 주요 메서드

2. 생성자 `init()`

1. 파일 열기: `open()` 함수

2. 파일 읽기: `read()`, `readline()`, `readlines()`

(1) 전체 읽기: `read()`

(2) 한 줄씩 읽기: `readline()`

(3) 모든 줄 리스트로 읽기: `readlines()`

3. 파일 쓰기: `write()`, `writelines()`

(1) 문자열 쓰기: `write()`

(2) 리스트 쓰기: `writelines()`

5. `with` 문과 파일 자동 닫기

5. `name == 'main'`의 의미

`init.py` 파일에는 무엇을 작성해야 할까?

3.1 숫자형 연산 (`int`, `float`)