Python 프로그램 입출력(Program I/O) 개념 정리

1️⃣ 명령줄 인수 (Command Line Arguments)

파이썬 프로그램은 sys.argv를 통해 명령줄 인수를 받을 수 있다.

# 기본 명령줄 인수 처리
import sys

def main():
    # argv[0]은 스크립트 이름
    # argv[1:]은 실제 인수들
    args = sys.argv[1:]
    print(f"프로그램 이름: {sys.argv[0]}")
    print(f"전달된 인수 개수: {len(args)}")
    
    for i, arg in enumerate(args, 1):
        print(f"인수 {i}: {arg}")

if __name__ == "__main__":
    main()

명령줄 인수 예시

# example_args.py
import sys

def main():
    if len(sys.argv) < 2:
        print("사용법: python example_args.py [인수1] [인수2] ...")
        sys.exit(1)
    
    args = sys.argv[1:]
    
    # 인수의 합계 계산 (모든 인수를 숫자로 변환 시도)
    try:
        numbers = [float(arg) for arg in args]
        total = sum(numbers)
        print(f"인수 합계: {total}")
    except ValueError:
        print("숫자가 아닌 인수가 포함되어 있습니다.")

if __name__ == "__main__":
    main()

실행 예시:

$ python example_args.py 10 20 30
프로그램 이름: example_args.py
전달된 인수 개수: 3
인수 합계: 60.0

2️⃣ argparse 모듈 사용

더 복잡한 명령줄 인수 처리를 위해 argparse 모듈을 사용할 수 있다.

import argparse

def main():
    # 파서 생성
    parser = argparse.ArgumentParser(description='프로그램 설명')
    
    # 인수 추가
    parser.add_argument('--name', type=str, help='이름을 입력하세요')
    parser.add_argument('--age', type=int, help='나이를 입력하세요')
    
    # 인수 파싱
    args = parser.parse_args()
    
    # 인수 사용
    if args.name:
        print(f"이름: {args.name}")
    if args.age:
        print(f"나이: {args.age}")

if __name__ == "__main__":
    main()

argparse 고급 기능

import argparse

def main():
    # 파서 생성 (프로그램 설명 및 에필로그 추가)
    parser = argparse.ArgumentParser(
        description='사용자 정보를 처리하는 프로그램',
        epilog='예시: python program.py --name 홍길동 --age 30 --hobbies 독서 등산'
    )
    
    # 필수 위치 인수
    parser.add_argument('command', choices=['create', 'update', 'delete'],
                       help='수행할 명령 (create, update, delete)')
                       
    # 옵션 인수 (선택적)
    parser.add_argument('--name', '-n', type=str, help='사용자 이름')
    parser.add_argument('--age', '-a', type=int, help='사용자 나이')
    
    # 기본값이 있는 인수
    parser.add_argument('--language', default='Python', help='선호하는 프로그래밍 언어 (기본값: Python)')
    
    # bool 형식의 플래그 인수
    parser.add_argument('--verbose', '-v', action='store_true', help='상세 출력 모드 활성화')
    
    # 파일 타입 인수
    parser.add_argument('--output', type=argparse.FileType('w'), help='출력 파일')
    
    # 여러 값을 받는 인수
    parser.add_argument('--hobbies', nargs='+', help='취미 목록 (공백으로 구분)')
    
    # 고정된 개수의 인수
    parser.add_argument('--coordinates', nargs=2, type=float, help='x, y 좌표 (2개의 값)')
    
    # 인수 파싱
    args = parser.parse_args()
    
    # 상세 출력 모드일 경우 모든 인수 출력
    if args.verbose:
        print("프로그램 실행 정보:")
        for arg, value in vars(args).items():
            print(f"  {arg}: {value}")
    
    # 명령 처리
    print(f"명령 '{args.command}' 실행 중...")
    
    # 이름과 나이가 모두 제공된 경우에만 사용자 정보 출력
    if args.name and args.age:
        print(f"사용자: {args.name}, {args.age}세")
        print(f"선호 언어: {args.language}")
        
        if args.hobbies:
            print(f"취미: {', '.join(args.hobbies)}")
            
        if args.coordinates:
            print(f"좌표: ({args.coordinates[0]}, {args.coordinates[1]})")
    
    # 출력 파일이 제공된 경우 파일에 출력
    if args.output:
        args.output.write(f"처리된 명령: {args.command}\n")
        if args.name:
            args.output.write(f"사용자: {args.name}\n")
        args.output.close()
        print(f"출력이 파일에 저장되었습니다.")

if __name__ == "__main__":
    main()

argparse 서브명령어

import argparse

def create_user(args):
    print(f"사용자 생성: {args.name}, {args.age}세")

def update_user(args):
    print(f"사용자 업데이트: ID {args.id}")
    if args.name:
        print(f"이름 변경: {args.name}")
    if args.age:
        print(f"나이 변경: {args.age}")

def delete_user(args):
    print(f"사용자 삭제: ID {args.id}")
    if args.force:
        print("강제 삭제 모드")

def main():
    # 메인 파서 생성
    parser = argparse.ArgumentParser(description='사용자 관리 시스템')
    subparsers = parser.add_subparsers(dest='command', help='수행할 명령')
    
    # create 서브명령어 설정
    create_parser = subparsers.add_parser('create', help='사용자 생성')
    create_parser.add_argument('--name', required=True, help='사용자 이름')
    create_parser.add_argument('--age', type=int, required=True, help='사용자 나이')
    create_parser.set_defaults(func=create_user)
    
    # update 서브명령어 설정
    update_parser = subparsers.add_parser('update', help='사용자 정보 업데이트')
    update_parser.add_argument('--id', type=int, required=True, help='사용자 ID')
    update_parser.add_argument('--name', help='새 이름')
    update_parser.add_argument('--age', type=int, help='새 나이')
    update_parser.set_defaults(func=update_user)
    
    # delete 서브명령어 설정
    delete_parser = subparsers.add_parser('delete', help='사용자 삭제')
    delete_parser.add_argument('--id', type=int, required=True, help='사용자 ID')
    delete_parser.add_argument('--force', '-f', action='store_true', help='확인 없이 강제 삭제')
    delete_parser.set_defaults(func=delete_user)
    
    # 인수 파싱
    args = parser.parse_args()
    
    # 서브명령어에 따른 함수 실행
    if hasattr(args, 'func'):
        args.func(args)
    else:
        parser.print_help()

if __name__ == "__main__":
    main()

3️⃣ 환경 변수 사용

import os

# 환경 변수 읽기
path = os.environ.get('PATH')
home = os.environ.get('HOME')

# 기본값으로 환경 변수 읽기
user = os.environ.get('USER', 'unknown')
debug = os.environ.get('DEBUG', 'False')

# 환경 변수 설정
os.environ['MY_VAR'] = 'value'
os.environ['APP_ENV'] = 'development'

# 환경 변수 삭제
if 'TEMP_VAR' in os.environ:
    del os.environ['TEMP_VAR']

# 환경 변수 활용 예시
debug_mode = os.environ.get('DEBUG', 'False').lower() in ('true', '1', 'yes')
if debug_mode:
    print("디버그 모드가 활성화되었습니다.")

# 환경 변수에 따른 설정 변경
env = os.environ.get('APP_ENV', 'development')
if env == 'production':
    db_host = os.environ.get('DB_HOST_PROD')
    log_level = 'ERROR'
elif env == 'staging':
    db_host = os.environ.get('DB_HOST_STAGING')
    log_level = 'WARNING'
else:  # development
    db_host = os.environ.get('DB_HOST_DEV', 'localhost')
    log_level = 'DEBUG'

print(f"환경: {env}, 데이터베이스 호스트: {db_host}, 로그 레벨: {log_level}")

# 모든 환경 변수 출력
print("\n--- 환경 변수 목록 ---")
for key, value in sorted(os.environ.items()):
    # 값이 너무 길면 잘라서 표시
    if len(value) > 50:
        value = value[:47] + "..."
    print(f"{key}: {value}")

dotenv 모듈을 사용한 환경 변수 관리

# pip install python-dotenv로 먼저 설치 필요
from dotenv import load_dotenv
import os

# .env 파일 로드
load_dotenv()  # 프로젝트 루트의 .env 파일 로드
# load_dotenv("/path/to/specific/.env")  # 특정 경로의 .env 파일 로드

# 환경 변수 사용
database_url = os.environ.get("DATABASE_URL")
api_key = os.environ.get("API_KEY")
debug = os.environ.get("DEBUG", "False").lower() == "true"

print(f"데이터베이스 URL: {database_url}")
print(f"API 키: {api_key}")
print(f"디버그 모드: {debug}")

# .env 파일 예시:
# DATABASE_URL=postgresql://user:password@localhost/dbname
# API_KEY=your_secret_api_key
# DEBUG=True

4️⃣ 표준 입출력 리다이렉션

import sys

# 표준 출력을 파일로 리다이렉션
with open('output.txt', 'w', encoding='utf-8') as f:
    # 원래 표준 출력 저장
    original_stdout = sys.stdout
    sys.stdout = f
    
    print("이 내용은 파일로 저장됩니다.")
    print("여러 줄의 출력이")
    print("모두 파일에 기록됩니다.")
    
    # 표준 출력 복구
    sys.stdout = original_stdout

print("이제 콘솔에 출력됩니다.")

# 표준 오류 리다이렉션
with open('error.log', 'w', encoding='utf-8') as f:
    original_stderr = sys.stderr
    sys.stderr = f
    
    print("에러 메시지", file=sys.stderr)
    
    sys.stderr = original_stderr

# 표준 입력을 파일에서 읽기
with open('input.txt', 'r', encoding='utf-8') as f:
    original_stdin = sys.stdin
    sys.stdin = f
    
    # 파일에서 입력 읽기
    line = input("프롬프트는 무시됩니다: ")
    print(f"파일에서 읽은 줄: {line}")
    
    # 여러 줄 읽기
    lines = []
    try:
        while True:
    line = input()
            lines.append(line)
    except EOFError:
        pass
    
    sys.stdin = original_stdin

print(f"파일에서 총 {len(lines)}줄을 읽었습니다.")

컨텍스트 관리자를 사용한 표준 스트림 리다이렉션

import sys
import contextlib

# 표준 출력 리다이렉션 컨텍스트 관리자
@contextlib.contextmanager
def redirect_stdout(new_target):
    old_target = sys.stdout
    sys.stdout = new_target
    try:
        yield new_target
    finally:
        sys.stdout = old_target

# 표준 입력 리다이렉션 컨텍스트 관리자
@contextlib.contextmanager
def redirect_stdin(new_target):
    old_target = sys.stdin
    sys.stdin = new_target
    try:
        yield new_target
    finally:
        sys.stdin = old_target

# 사용 예시
with open('output.txt', 'w', encoding='utf-8') as f:
    with redirect_stdout(f):
        print("이 내용은 파일로 리다이렉션됩니다.")
        print("컨텍스트가 종료되면 자동으로 복구됩니다.")

print("이제 다시 콘솔에 출력됩니다.")

# 문자열 버퍼로 표준 출력 리다이렉션
from io import StringIO

output_buffer = StringIO()
with redirect_stdout(output_buffer):
    print("이 내용은 버퍼에 저장됩니다.")
    print("나중에 처리할 수 있습니다.")

# 캡쳐된 출력 가져오기
captured_output = output_buffer.getvalue()
print(f"캡쳐된 출력: {captured_output}")

5️⃣ 로깅 (Logging)

import logging

# 기본 로깅 설정
logging.basicConfig(
    level=logging.INFO,  # 로깅 레벨 설정
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)

# 로그 메시지 출력
logging.debug("디버그 메시지 - 개발 중에만 필요한 세부 정보")
logging.info("정보 메시지 - 정상 작동 확인")
logging.warning("경고 메시지 - 잠재적 문제 알림")
logging.error("오류 메시지 - 프로그램이 작업을 수행할 수 없음")
logging.critical("심각한 오류 - 프로그램이 계속 실행될 수 없음")

# 로그 레벨 (낮은 것부터 높은 순)
# DEBUG(10) < INFO(20) < WARNING(30) < ERROR(40) < CRITICAL(50)

파일 로깅 및 고급 설정

import logging
import logging.handlers
import os
from datetime import datetime

# 로그 디렉토리 생성
log_dir = 'logs'
if not os.path.exists(log_dir):
    os.makedirs(log_dir)

# 현재 날짜로 로그 파일 이름 생성
today = datetime.now().strftime('%Y-%m-%d')
log_file = os.path.join(log_dir, f'app_{today}.log')

# 로거 생성
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG)  # 로거 자체의 레벨 설정

# 파일 핸들러 생성 (파일에 로그 기록)
file_handler = logging.FileHandler(log_file, encoding='utf-8')
file_handler.setLevel(logging.DEBUG)  # 모든 로그 저장

# 회전 파일 핸들러 (파일 크기에 따라 로그 파일 분할)
# max_bytes: 최대 파일 크기, backup_count: 보관할 이전 로그 파일 수
rotating_handler = logging.handlers.RotatingFileHandler(
    os.path.join(log_dir, 'rotating.log'),
    maxBytes=10000,  # 10KB
    backupCount=5,
    encoding='utf-8'
)
rotating_handler.setLevel(logging.INFO)

# 시간 기반 회전 핸들러 (매일 자정에 새 로그 파일 생성)
timed_handler = logging.handlers.TimedRotatingFileHandler(
    os.path.join(log_dir, 'daily.log'),
    when='midnight',
    interval=1,  # 1일마다
    backupCount=7,  # 1주일치 보관
    encoding='utf-8'
)
timed_handler.setLevel(logging.WARNING)

# 콘솔 핸들러 (터미널에 로그 출력)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)  # 정보 레벨 이상만 콘솔에 출력

# 포맷터 생성
formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)

# 핸들러에 포맷터 추가
file_handler.setFormatter(formatter)
rotating_handler.setFormatter(formatter)
timed_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 로거에 핸들러 추가
logger.addHandler(file_handler)
logger.addHandler(rotating_handler)
logger.addHandler(timed_handler)
logger.addHandler(console_handler)

# 로그 메시지 출력
logger.debug("디버그 메시지 - 파일에만 기록")
logger.info("정보 메시지 - 파일과 콘솔에 출력")
logger.warning("경고 메시지 - 모든 핸들러에 출력")
logger.error("오류 메시지")
logger.critical("심각한 오류 메시지")

# 예외 정보 포함
try:
    result = 10 / 0
except Exception as e:
    logger.exception("예외 발생: 0으로 나누기 시도")  # traceback 자동 포함

6️⃣ 외부 프로세스 실행 및 입출력

import subprocess

# 간단한 명령 실행
result = subprocess.run(['echo', 'Hello, World!'], capture_output=True, text=True)
print(f"반환 코드: {result.returncode}")
print(f"표준 출력: {result.stdout}")
print(f"표준 오류: {result.stderr}")

# 쉘 명령 실행
result = subprocess.run('ls -l | grep ".py"', shell=True, capture_output=True, text=True)
print(f"파이썬 파일 목록:\n{result.stdout}")

# 명령 실행 시 입력 제공
input_data = "Hello from Python"
result = subprocess.run(['cat'], input=input_data, capture_output=True, text=True)
print(f"'cat' 명령 결과: {result.stdout}")

# 예외 처리
try:
    result = subprocess.run(['non_existent_command'], check=True)  # check=True는 오류 시 예외 발생
except subprocess.CalledProcessError as e:
    print(f"명령 실행 중 오류 발생: {e}")
except FileNotFoundError as e:
    print(f"명령을 찾을 수 없음: {e}")

# 현재 환경 변수를 상속받아 특정 변수만 추가 또는 변경
import os
env = os.environ.copy()
env['CUSTOM_VAR'] = 'value'

result = subprocess.run(['env'], env=env, capture_output=True, text=True)
print("환경 변수 목록 중 사용자 정의 변수:")
for line in result.stdout.splitlines():
    if line.startswith('CUSTOM_VAR='):
        print(line)

Popen을 사용한 고급 프로세스 제어

import subprocess
import time

# Popen으로 프로세스 시작
process = subprocess.Popen(
    ['ping', 'localhost'],
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    text=True
)

# 비동기적으로 다른 작업 수행 가능
print("프로세스가 실행 중입니다...")
time.sleep(2)

# 프로세스 상태 확인
if process.poll() is None:
    print("프로세스가 아직 실행 중입니다.")
    
    # 실행 중인 프로세스에서 실시간으로 출력 읽기
    for i in range(5):  # 5줄만 읽기
        output = process.stdout.readline()
        if output:
            print(f"실시간 출력: {output.strip()}")
        else:
            break
    
    # 필요하면 프로세스 종료
    process.terminate()
    try:
        process.wait(timeout=5)  # 5초 동안 종료 대기
    except subprocess.TimeoutExpired:
        print("프로세스가 정상적으로 종료되지 않아 강제 종료합니다.")
        process.kill()

# 프로세스 완료 기다리기 및 출력 읽기
stdout, stderr = process.communicate()
print(f"반환 코드: {process.returncode}")
print(f"표준 출력 일부: {stdout[:100]}")  # 처음 100자만 표시
print(f"표준 오류: {stderr}")

# 파이프라인 구현 (여러 명령 연결)
ps_process = subprocess.Popen(['ps', 'aux'], stdout=subprocess.PIPE, text=True)
grep_process = subprocess.Popen(['grep', 'python'], stdin=ps_process.stdout, stdout=subprocess.PIPE, text=True)
ps_process.stdout.close()  # ps_process의 stdout을 닫아서 EOF 신호 전달

output, _ = grep_process.communicate()
print("\nPython 관련 프로세스:")
print(output)

주요 팁

✅ 프로그램 입출력 모범 사례:

명령줄 인수는 argparse를 사용하여 체계적으로 구성한다
각 인수에 도움말 메시지를 항상 제공한다
민감한 정보(비밀번호, API 키 등)는 환경 변수로 관리한다
환경 변수는 항상 기본값과 함께 사용한다 (os.environ.get('VAR', 'default'))
로깅은 print 대신 logging 모듈을 활용한다
로그 레벨을 적절히 구분하여 디버깅과 운영을 구분한다
외부 프로세스 실행 시 subprocess.run()의 check=True 옵션을 사용하여 오류를 확인한다
외부 명령 실행 시 사용자 입력을 직접 전달하지 않고 인수 리스트를 사용한다 (명령어 주입 공격 방지)
표준 입출력 리다이렉션 후에는 반드시 원래 상태로 복구한다
장기 실행 프로세스는 시간 초과 처리 로직을 구현한다

KR_ProgramIO - somaz94/python-study GitHub Wiki

Python 프로그램 입출력(Program I/O) 개념 정리

1️⃣ 명령줄 인수 (Command Line Arguments)

명령줄 인수 예시

2️⃣ argparse 모듈 사용

argparse 고급 기능

argparse 서브명령어

3️⃣ 환경 변수 사용

dotenv 모듈을 사용한 환경 변수 관리

4️⃣ 표준 입출력 리다이렉션

컨텍스트 관리자를 사용한 표준 스트림 리다이렉션

5️⃣ 로깅 (Logging)

파일 로깅 및 고급 설정

6️⃣ 외부 프로세스 실행 및 입출력

Popen을 사용한 고급 프로세스 제어

주요 팁

⚠️ GitHub.com Fallback ⚠️

KR_ProgramIO - somaz94/python-study GitHub Wiki

Python 프로그램 입출력(Program I/O) 개념 정리

1️⃣ 명령줄 인수 (Command Line Arguments)

명령줄 인수 예시

2️⃣ argparse 모듈 사용

argparse 고급 기능

argparse 서브명령어

3️⃣ 환경 변수 사용

dotenv 모듈을 사용한 환경 변수 관리

4️⃣ 표준 입출력 리다이렉션

컨텍스트 관리자를 사용한 표준 스트림 리다이렉션

5️⃣ 로깅 (Logging)

파일 로깅 및 고급 설정

6️⃣ 외부 프로세스 실행 및 입출력

Popen을 사용한 고급 프로세스 제어

주요 팁

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️