날짜와 시간

In Python 날짜와 시간을 다루는 Methode lernen wir. datetime Modul은 시간 관련 작업의 핵심 도구.

datetime Modul 소개 ⏰

datetime Modul의 주요 Klasse:

• datetime: 날짜와 시간을 함께 다룸
• date: 날짜만 다룸
• time: 시간만 다룸
• timedelta: 시간 차이를 다룸
• timezone: 시간대 정보

현재 날짜와 시간

현재 datetime 얻기

from datetime import datetime

# 현재 날짜와 시간
now = datetime.now()
print(now)  # 2025-11-27 14:30:45.123456

# UTC 현재 시간
utc_now = datetime.utcnow()
print(utc_now)

# 각 요소 접근
print(f'연도: {now.year}')
print(f'월: {now.month}')
print(f'일: {now.day}')
print(f'시: {now.hour}')
print(f'분: {now.minute}')
print(f'초: {now.second}')
print(f'마이크로초: {now.microsecond}')

현재 날짜만 얻기

from datetime import date

# 오늘 날짜
today = date.today()
print(today)  # 2025-11-27

print(f'연도: {today.year}')
print(f'월: {today.month}')
print(f'일: {today.day}')
print(f'요일: {today.weekday()}')  # 0(월) ~ 6(일)
print(f'요일: {today.isoweekday()}')  # 1(월) ~ 7(일)

datetime 객체 생성하기

날짜와 시간 생성

from datetime import datetime, date, time

# 특정 날짜와 시간 생성
dt = datetime(2025, 11, 27, 14, 30, 45)
print(dt)  # 2025-11-27 14:30:45

# 날짜만 생성
d = date(2025, 11, 27)
print(d)  # 2025-11-27

# 시간만 생성
t = time(14, 30, 45)
print(t)  # 14:30:45

# 날짜와 시간 결합
dt_combined = datetime.combine(d, t)
print(dt_combined)  # 2025-11-27 14:30:45

문자열과 datetime 변환 📝

strftime: datetime → 문자열

from datetime import datetime

now = datetime.now()

# 다양한 포맷으로 변환
print(now.strftime('%Y-%m-%d'))  # 2025-11-27
print(now.strftime('%Y년 %m월 %d일'))  # 2025년 11월 27일
print(now.strftime('%H:%M:%S'))  # 14:30:45
print(now.strftime('%Y-%m-%d %H:%M:%S'))  # 2025-11-27 14:30:45
print(now.strftime('%Y/%m/%d %p %I:%M'))  # 2025/11/27 PM 02:30

주요 포맷 코드

코드	의미	예시
%Y	4자리 연도	2025
%y	2자리 연도	25
%m	월 (01-12)	11
%B	월 이름	November
%b	월 이름 축약	Nov
%d	일 (01-31)	27
%A	요일	Wednesday
%a	요일 축약	Wed
%H	시 (00-23)	14
%I	시 (01-12)	02
%M	분 (00-59)	30
%S	초 (00-59)	45
%p	AM/PM	PM
%f	마이크로초	123456

strptime: 문자열 → datetime

from datetime import datetime

# 문자열을 datetime으로 변환
date_str = '2025-11-27'
dt = datetime.strptime(date_str, '%Y-%m-%d')
print(dt)  # 2025-11-27 00:00:00

# 시간 포함
datetime_str = '2025-11-27 14:30:45'
dt = datetime.strptime(datetime_str, '%Y-%m-%d %H:%M:%S')
print(dt)

# 다양한 형식
formats = [
    ('2025/11/27', '%Y/%m/%d'),
    ('11/27/2025', '%m/%d/%Y'),
    ('27-Nov-2025', '%d-%b-%Y'),
    ('2025년 11월 27일', '%Y년 %m월 %d일'),
]

for date_str, fmt in formats:
    dt = datetime.strptime(date_str, fmt)
    print(f'{date_str} → {dt}')

timedelta: 시간 차이 계산 ⏱️

Grundlegend 사용법

from datetime import datetime, timedelta

# timedelta 생성
delta = timedelta(
    days=7,
    hours=3,
    minutes=30,
    seconds=45
)

print(delta)  # 7 days, 3:30:45
print(f'총 초: {delta.total_seconds()}')

날짜 계산

from datetime import datetime, timedelta

now = datetime.now()

# 미래 날짜 계산
tomorrow = now + timedelta(days=1)
next_week = now + timedelta(weeks=1)
next_month = now + timedelta(days=30)
one_hour_later = now + timedelta(hours=1)

print(f'내일: {tomorrow}')
print(f'다음 주: {next_week}')

# 과거 날짜 계산
yesterday = now - timedelta(days=1)
last_week = now - timedelta(weeks=1)

print(f'어제: {yesterday}')
print(f'지난 주: {last_week}')

날짜 차이 계산

from datetime import datetime

# 두 날짜의 차이
birthday = datetime(1990, 5, 15)
now = datetime.now()

age_delta = now - birthday

print(f'살아온 일수: {age_delta.days}')
print(f'살아온 시간: {age_delta.total_seconds() / 3600:.0f}시간')
print(f'나이: {age_delta.days // 365}세')

시간대 (Timezone) 🌍

timezone 사용

from datetime import datetime, timezone, timedelta

# UTC 시간
utc_now = datetime.now(timezone.utc)
print(f'UTC: {utc_now}')

# 특정 시간대 (UTC+9, 한국)
kst = timezone(timedelta(hours=9))
kst_now = datetime.now(kst)
print(f'KST: {kst_now}')

# 시간대 변환
utc_time = datetime(2025, 11, 27, 14, 30, tzinfo=timezone.utc)
kst_time = utc_time.astimezone(kst)
print(f'UTC: {utc_time}')
print(f'KST: {kst_time}')

pytz 라이브러리 (더 정확한 시간대)

# pip install pytz 필요
try:
    import pytz
    from datetime import datetime

    # 시간대 생성
    seoul = pytz.timezone('Asia/Seoul')
    new_york = pytz.timezone('America/New_York')
    london = pytz.timezone('Europe/London')

    # 현재 시간을 각 시간대로
    now = datetime.now()
    seoul_time = seoul.localize(now)

    print(f'서울: {seoul_time}')
    print(f'뉴욕: {seoul_time.astimezone(new_york)}')
    print(f'런던: {seoul_time.astimezone(london)}')

except ImportError:
    print('pytz 설치 필요: pip install pytz')

실전 Beispiel 💡

Beispiel 1: D-day 계산기

from datetime import datetime, date

def calculate_dday(target_date):
    """D-day 계산"""
    if isinstance(target_date, str):
        target_date = datetime.strptime(target_date, '%Y-%m-%d').date()

    today = date.today()
    delta = target_date - today

    if delta.days > 0:
        return f'D-{delta.days}'
    elif delta.days == 0:
        return 'D-Day!'
    else:
        return f'D+{abs(delta.days)}'

# 사용 Beispiel
exam_date = '2025-12-25'
print(f'시험일: {calculate_dday(exam_date)}')

wedding_date = date(2025, 6, 15)
print(f'결혼식: {calculate_dday(wedding_date)}')

Beispiel 2: 나이 계산기

from datetime import date

def calculate_age(birth_date):
    """만 나이 계산"""
    if isinstance(birth_date, str):
        birth_date = datetime.strptime(birth_date, '%Y-%m-%d').date()

    today = date.today()
    age = today.year - birth_date.year

    # 생일이 안 지났으면 1살 빼기
    if today.month < birth_date.month or \
       (today.month == birth_date.month and today.day < birth_date.day):
        age -= 1

    return age

# 사용 Beispiel
birth = '1990-05-15'
age = calculate_age(birth)
print(f'만 나이: {age}세')

Beispiel 3: 근무시간 계산기

from datetime import datetime, timedelta

class WorkTimeCalculator:
    """근무 시간 계산기"""

    def __init__(self):
        self.entries = []

    def clock_in(self, time_str=None):
        """출근 기록"""
        time = datetime.strptime(time_str, '%H:%M') if time_str else datetime.now()
        self.entries.append({'in': time, 'out': None})
        print(f'출근: {time.strftime("%H:%M")}')

    def clock_out(self, time_str=None):
        """퇴근 기록"""
        if not self.entries or self.entries[-1]['out'] is not None:
            print('출근 기록이 없습니다')
            return

        time = datetime.strptime(time_str, '%H:%M') if time_str else datetime.now()
        self.entries[-1]['out'] = time
        print(f'퇴근: {time.strftime("%H:%M")}')

    def get_total_hours(self):
        """총 근무 시간"""
        total = timedelta()

        for entry in self.entries:
            if entry['out']:
                delta = entry['out'] - entry['in']
                total += delta

        hours = total.total_seconds() / 3600
        return hours

    def get_summary(self):
        """근무 요약"""
        total_hours = self.get_total_hours()
        print(f'\n=== 근무 시간 요약 ===')
        print(f'총 근무 시간: {total_hours:.2f}시간')
        print(f'근무 일수: {len(self.entries)}일')
        print(f'일평균: {total_hours/len(self.entries):.2f}시간')

# 사용 Beispiel
calc = WorkTimeCalculator()
calc.clock_in('09:00')
calc.clock_out('18:00')
calc.clock_in('09:30')
calc.clock_out('17:30')
calc.get_summary()

Beispiel 4: 타임스탬프 변환

from datetime import datetime

class TimestampConverter:
    """Unix 타임스탬프 변환기"""

    @staticmethod
    def datetime_to_timestamp(dt):
        """datetime → timestamp"""
        return int(dt.timestamp())

    @staticmethod
    def timestamp_to_datetime(ts):
        """timestamp → datetime"""
        return datetime.fromtimestamp(ts)

    @staticmethod
    def now_timestamp():
        """현재 타임스탬프"""
        return int(datetime.now().timestamp())

# 사용 Beispiel
converter = TimestampConverter()

# 현재 타임스탬프
now_ts = converter.now_timestamp()
print(f'현재 타임스탬프: {now_ts}')

# datetime → timestamp
dt = datetime(2025, 11, 27, 14, 30, 0)
ts = converter.datetime_to_timestamp(dt)
print(f'{dt} → {ts}')

# timestamp → datetime
dt_back = converter.timestamp_to_datetime(ts)
print(f'{ts} → {dt_back}')

Beispiel 5: 날짜 범위 생성기

from datetime import datetime, timedelta

def date_range(start_date, end_date, step_days=1):
    """날짜 범위 생성"""
    if isinstance(start_date, str):
        start_date = datetime.strptime(start_date, '%Y-%m-%d')
    if isinstance(end_date, str):
        end_date = datetime.strptime(end_date, '%Y-%m-%d')

    current = start_date
    while current <= end_date:
        yield current
        current += timedelta(days=step_days)

# 사용 Beispiel
print('2025년 11월 모든 날짜:')
for dt in date_range('2025-11-01', '2025-11-30'):
    print(dt.strftime('%Y-%m-%d %A'))

print('\n격주 화요일:')
start = datetime(2025, 11, 1)
end = datetime(2025, 12, 31)
for dt in date_range(start, end, step_days=14):
    if dt.weekday() == 1:  # 화요일
        print(dt.strftime('%Y-%m-%d'))

Beispiel 6: 회의 시간 관리

from datetime import datetime, timedelta

class Meeting:
    """회의 Klasse"""

    def __init__(self, title, start_time, duration_minutes):
        self.title = title
        self.start_time = start_time
        self.duration = timedelta(minutes=duration_minutes)
        self.end_time = start_time + self.duration

    def __str__(self):
        return (f'{self.title}\n'
                f'시작: {self.start_time.strftime("%H:%M")}\n'
                f'종료: {self.end_time.strftime("%H:%M")}\n'
                f'소요: {self.duration.total_seconds() / 60:.0f}분')

    def is_overlapping(self, other):
        """다른 회의와 겹치는지 확인"""
        return (self.start_time < other.end_time and
                self.end_time > other.start_time)

class Schedule:
    """일정 관리"""

    def __init__(self):
        self.meetings = []

    def add_meeting(self, meeting):
        """회의 추가"""
        for existing in self.meetings:
            if meeting.is_overlapping(existing):
                print(f'⚠️  {existing.title}와 시간이 겹칩니다!')
                return False

        self.meetings.append(meeting)
        print(f'✅ {meeting.title} 추가됨')
        return True

    def show_schedule(self):
        """일정 보기"""
        if not self.meetings:
            print('등록된 회의가 없습니다')
            return

        print('\n=== 오늘의 일정 ===')
        for meeting in sorted(self.meetings, key=lambda m: m.start_time):
            print(f'\n{meeting}')
            print('-' * 30)

# 사용 Beispiel
schedule = Schedule()

# 회의 추가
morning_meeting = Meeting(
    '아침 스탠드업',
    datetime.now().replace(hour=9, minute=0),
    30
)
schedule.add_meeting(morning_meeting)

lunch_meeting = Meeting(
    '점심 미팅',
    datetime.now().replace(hour=12, minute=0),
    60
)
schedule.add_meeting(lunch_meeting)

# 겹치는 회의 시도
overlap_meeting = Meeting(
    '중복 회의',
    datetime.now().replace(hour=12, minute=30),
    30
)
schedule.add_meeting(overlap_meeting)

schedule.show_schedule()

Beispiel 7: 상대적 시간 표시

from datetime import datetime, timedelta

def relative_time(dt):
    """상대적 시간 표시 (예: '3시간 전')"""
    if isinstance(dt, str):
        dt = datetime.strptime(dt, '%Y-%m-%d %H:%M:%S')

    now = datetime.now()
    delta = now - dt

    seconds = delta.total_seconds()

    if seconds < 60:
        return '방금 전'
    elif seconds < 3600:
        minutes = int(seconds / 60)
        return f'{minutes}분 전'
    elif seconds < 86400:
        hours = int(seconds / 3600)
        return f'{hours}시간 전'
    elif seconds < 604800:
        days = int(seconds / 86400)
        return f'{days}일 전'
    elif seconds < 2592000:
        weeks = int(seconds / 604800)
        return f'{weeks}주 전'
    elif seconds < 31536000:
        months = int(seconds / 2592000)
        return f'{months}개월 전'
    else:
        years = int(seconds / 31536000)
        return f'{years}년 전'

# 사용 Beispiel
times = [
    datetime.now() - timedelta(seconds=30),
    datetime.now() - timedelta(minutes=15),
    datetime.now() - timedelta(hours=3),
    datetime.now() - timedelta(days=2),
    datetime.now() - timedelta(weeks=3),
]

for time in times:
    print(f'{time.strftime("%Y-%m-%d %H:%M:%S")} → {relative_time(time)}')

Beispiel 8: 영업일 계산

from datetime import datetime, timedelta

def is_weekend(date):
    """주말인지 확인"""
    return date.weekday() >= 5  # 5=토, 6=일

def add_business_days(start_date, days):
    """영업일 추가 (주말 제외)"""
    current = start_date
    added = 0

    while added < days:
        current += timedelta(days=1)
        if not is_weekend(current):
            added += 1

    return current

def count_business_days(start_date, end_date):
    """영업일 계산"""
    count = 0
    current = start_date

    while current <= end_date:
        if not is_weekend(current):
            count += 1
        current += timedelta(days=1)

    return count

# 사용 Beispiel
today = date.today()
print(f'오늘: {today.strftime("%Y-%m-%d %A")}')

# 5영업일 후
after_5_days = add_business_days(today, 5)
print(f'5영업일 후: {after_5_days.strftime("%Y-%m-%d %A")}')

# 영업일 수 계산
start = date(2025, 11, 1)
end = date(2025, 11, 30)
business_days = count_business_days(start, end)
print(f'11월 영업일: {business_days}일')

날짜 비교 🔍

from datetime import datetime

dt1 = datetime(2025, 11, 27)
dt2 = datetime(2025, 12, 25)

# 비교 연산
print(dt1 < dt2)   # True
print(dt1 > dt2)   # False
print(dt1 == dt2)  # False
print(dt1 != dt2)  # True

# 최대/최소
dates = [
    datetime(2025, 11, 27),
    datetime(2025, 12, 25),
    datetime(2025, 1, 1),
]

print(f'가장 이른 날짜: {min(dates)}')
print(f'가장 늦은 날짜: {max(dates)}')

Häufig gestellte Fragen ❓

Q1: 월말 날짜를 구하는 Methode은?

from datetime import datetime
from calendar import monthrange

def get_last_day_of_month(year, month):
    """특정 월의 마지막 날"""
    last_day = monthrange(year, month)[1]
    return datetime(year, month, last_day)

# 사용 Beispiel
last_day = get_last_day_of_month(2025, 2)
print(last_day)  # 2025-02-28 (2025년은 평년)

Q2: 두 시간이 같은 날인지 확인하는 Methode은?

from datetime import datetime

dt1 = datetime(2025, 11, 27, 9, 0, 0)
dt2 = datetime(2025, 11, 27, 18, 0, 0)

# 날짜만 비교
same_day = dt1.date() == dt2.date()
print(same_day)  # True

Q3: 특정 요일의 날짜를 찾는 Methode은?

from datetime import datetime, timedelta

def next_weekday(start_date, weekday):
    """다음 특정 요일 찾기 (0=월, 6=일)"""
    days_ahead = weekday - start_date.weekday()
    if days_ahead <= 0:
        days_ahead += 7
    return start_date + timedelta(days=days_ahead)

# 다음 금요일 찾기
today = datetime.now()
next_friday = next_weekday(today, 4)  # 4 = 금요일
print(f'다음 금요일: {next_friday.strftime("%Y-%m-%d")}')

Q4: 시간을 반올림하는 Methode은?

from datetime import datetime, timedelta

def round_time(dt, round_to_minutes=15):
    """시간을 특정 분 단위로 반올림"""
    seconds = round_to_minutes * 60
    rounded = dt + timedelta(seconds=seconds/2)
    rounded -= timedelta(
        seconds=rounded.second,
        microseconds=rounded.microsecond
    )
    rounded -= timedelta(minutes=rounded.minute % round_to_minutes)
    return rounded

# 15분 단위로 반올림
now = datetime.now()
rounded = round_time(now, 15)
print(f'원본: {now.strftime("%H:%M:%S")}')
print(f'반올림: {rounded.strftime("%H:%M:%S")}')

Q5: ISO 8601 형식으로 변환하는 Methode은?

from datetime import datetime

now = datetime.now()

# ISO 형식으로 변환
iso_string = now.isoformat()
print(iso_string)  # 2025-11-27T14:30:45.123456

# ISO 형식에서 변환
dt = datetime.fromisoformat('2025-11-27T14:30:45')
print(dt)

Performance-Tipps 🚀

from datetime import datetime
import time

# 현재 시간을 여러 번 사용할 때
# 나쁨: 매번 호출
for i in range(1000):
    now = datetime.now()  # 매번 시스템 호출

# 좋음: 한 번만 호출
now = datetime.now()
for i in range(1000):
    # now 사용
    pass

Nächste Schritte

• JSON과 CSV: 날짜 데이터를 파일로 저장하고 불러오기
• 정규표현식: 날짜 형식 추출과 검증
• dateutil 라이브러리: 더 강력한 날짜 파싱
• arrow 라이브러리: 사람 친화적인 날짜 처리