# 기본 입력
name = input()

# 프롬프트와 함께 입력 받기
age = input("나이를 입력하세요: ")

# 숫자 입력 받기 (문자열을 숫자로 변환)
number = int(input("숫자를 입력하세요: "))
float_number = float(input("실수를 입력하세요: "))

# 여러 값 한번에 입력 받기 (공백으로 구분)
x, y = map(int, input("두 정수를 입력하세요: ").split())
print(f"입력한 두 수의 합: {x + y}")

# 여러 값 한번에 입력 받기 (쉼표로 구분)
a, b, c = map(float, input("세 실수를 쉼표로 구분하여 입력하세요: ").split(','))
print(f"평균: {(a + b + c) / 3}")

# 리스트로 여러 값 입력 받기
numbers = list(map(int, input("여러 숫자를 입력하세요: ").split()))
print(f"입력한 숫자들: {numbers}")
print(f"합계: {sum(numbers)}")

# 숫자 입력 검증
while True:
    try:
        age = int(input("나이를 입력하세요: "))
        if age < 0 or age > 150:
            print("유효한 나이 범위가 아닙니다. 다시 입력하세요.")
            continue
        break
    except ValueError:
        print("숫자만 입력하세요.")

print(f"입력한 나이: {age}")

# 선택지 입력 검증
valid_options = ['A', 'B', 'C']
while True:
    choice = input(f"옵션을 선택하세요 ({'/'.join(valid_options)}): ").upper()
    if choice in valid_options:
        break
    print("유효하지 않은 옵션입니다. 다시 입력하세요.")

print(f"선택한 옵션: {choice}")

# 단순 출력
print("Hello, World!")

# 변수 출력
name = "Alice"
age = 25
print(name, age)

# 구분자(sep) 지정
print("Hello", "World", sep="-")  # Hello-World

# 끝문자(end) 지정
print("Hello", end="! ")  # Hello! 
print("World")  # World

# 여러 줄 출력
print("""
첫 번째 줄
두 번째 줄
세 번째 줄
""")

# 변수와 텍스트 함께 출력
print("이름:", name, "나이:", age)

name = "Alice"
age = 25
height = 165.5

# 1. % 연산자 사용 (오래된 방식)
print("이름: %s, 나이: %d, 키: %.1f" % (name, age, height))

# 2. format() 메서드 사용
print("이름: {}, 나이: {}, 키: {:.1f}".format(name, age, height))

# 인덱스 지정
print("이름: {0}, 나이: {1}, 키: {2:.1f}".format(name, age, height))
print("나이: {1}, 이름: {0}, 키: {2:.1f}".format(name, age, height))

# 이름 지정
print("이름: {n}, 나이: {a}, 키: {h:.1f}".format(n=name, a=age, h=height))

# 3. f-string (Python 3.6+, 가장 권장됨)
print(f"이름: {name}, 나이: {age}, 키: {height:.1f}")

# f-string 내 표현식 사용
print(f"내년 나이: {age + 1}")
print(f"인치 단위 키: {height / 2.54:.2f}inch")

# f-string 내 딕셔너리 사용
person = {'name': 'Bob', 'age': 30}
print(f"이름: {person['name']}, 나이: {person['age']}")

# 정렬 및 채움 문자
print(f"{'왼쪽 정렬':<15}|")  # 왼쪽 정렬      |
print(f"{'오른쪽 정렬':>15}|")  #     오른쪽 정렬|
print(f"{'가운데 정렬':^15}|")  #   가운데 정렬  |
print(f"{'0으로 채움':0>15}|")  # 00000000000으로 채움|

# 천 단위 구분기호
amount = 1234567890
print(f"금액: {amount:,}")  # 금액: 1,234,567,890

# 10진수 (기본)
print(f"{42}")  # 42

# 2진수
print(f"{42:b}")  # 101010

# 8진수
print(f"{42:o}")  # 52

# 16진수 (소문자)
print(f"{42:x}")  # 2a

# 16진수 (대문자)
print(f"{42:X}")  # 2A

# 지수 표기법
print(f"{1234567:e}")  # 1.234567e+06

# 백분율
print(f"{0.25:%}")  # 25.000000%
print(f"{0.25:.0%}")  # 25%

# 소수점 자릿수 지정
pi = 3.14159265359
print(f"{pi:.2f}")  # 3.14
print(f"{pi:.4f}")  # 3.1416

# 출력 너비 지정
for i in range(1, 11):
    print(f"{i:2d} {i*i:3d} {i*i*i:4d}")

# 파일 쓰기 (write mode)
with open('example.txt', 'w', encoding='utf-8') as f:
    f.write('첫 번째 줄\n')
    f.write('두 번째 줄\n')
    
    # 여러 줄 한번에 쓰기
    lines = ['세 번째 줄\n', '네 번째 줄\n', '다섯 번째 줄\n']
    f.writelines(lines)

# 파일 읽기 (read mode)
with open('example.txt', 'r', encoding='utf-8') as f:
    # 파일 전체 읽기
    content = f.read()
    print(content)

# 한 줄씩 읽기
with open('example.txt', 'r', encoding='utf-8') as f:
    first_line = f.readline()  # 한 줄 읽기
    print(first_line, end='')  # 이미 \n이 포함되어 있음
    
    # 모든 줄 읽기
    for line in f:  # 파일 객체는 이터러블
        print(line, end='')
        
# 모든 줄을 리스트로 읽기
with open('example.txt', 'r', encoding='utf-8') as f:
    lines = f.readlines()  # 줄 단위로 리스트 반환
    print(lines)  # ['첫 번째 줄\n', '두 번째 줄\n', ...]

# 파일에 내용 추가 (append mode)
with open('example.txt', 'a', encoding='utf-8') as f:
    f.write('추가된 줄\n')

# 'w': 쓰기 모드 (파일이 있으면 내용 지우고 새로 작성)
with open('file.txt', 'w', encoding='utf-8') as f:
    f.write('새로운 내용\n')

# 'r': 읽기 모드 (기본값)
with open('file.txt', 'r', encoding='utf-8') as f:
    content = f.read()

# 'a': 추가 모드 (파일 끝에 내용 추가)
with open('file.txt', 'a', encoding='utf-8') as f:
    f.write('추가 내용\n')

# 'x': 배타적 생성 모드 (파일이 이미 있으면 실패)
try:
    with open('new_file.txt', 'x', encoding='utf-8') as f:
        f.write('새 파일 내용\n')
except FileExistsError:
    print('파일이 이미 존재합니다.')

# 'b': 바이너리 모드 (텍스트 모드와 함께 사용)
with open('binary.dat', 'wb') as f:  # 바이너리 쓰기
    f.write(b'Binary data')

with open('binary.dat', 'rb') as f:  # 바이너리 읽기
    binary_data = f.read()

# '+': 읽기/쓰기 모드 (다른 모드와 함께 사용)
with open('file.txt', 'r+', encoding='utf-8') as f:  # 읽기+쓰기
    content = f.read()
    f.write('파일 끝에 추가\n')

with open('file.txt', 'w+', encoding='utf-8') as f:  # 쓰기+읽기
    f.write('새 내용\n')
    f.seek(0)  # 파일 포인터를 처음으로 이동
    content = f.read()

with open('example.txt', 'r+', encoding='utf-8') as f:
    # 현재 위치 확인
    pos = f.tell()
    print(f"현재 위치: {pos}")
    
    # 위치 이동
    f.seek(10)  # 10번째 바이트로 이동
    print(f"10번째 위치의 문자: {f.read(1)}")
    
    # 처음으로 이동
    f.seek(0)
    print(f"처음으로 이동 후 읽기: {f.read(5)}")
    
    # 상대적 이동
    f.seek(0)  # 먼저 처음으로 이동
    f.read(5)  # 5글자 읽기
    f.seek(10, 1)  # 현재 위치에서 10바이트 앞으로
    print(f"상대 이동 후 읽기: {f.read(5)}")
    
    # 파일 끝으로 이동
    f.seek(0, 2)  # 2는 파일 끝을 의미
    print(f"파일 끝 위치: {f.tell()}")

import csv

# CSV 파일 쓰기
data = [
    ['이름', '나이', '직업'],
    ['김철수', 28, '개발자'],
    ['이영희', 32, '디자이너'],
    ['박지민', 24, '학생']
]

with open('data.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f)
    writer.writerows(data)  # 여러 행 한번에 쓰기
    
    # 또는 행별로 쓰기
    # for row in data:
    #     writer.writerow(row)

# CSV 파일 읽기
with open('data.csv', 'r', encoding='utf-8') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

# 딕셔너리로 CSV 처리
dict_data = [
    {'이름': '김철수', '나이': 28, '직업': '개발자'},
    {'이름': '이영희', '나이': 32, '직업': '디자이너'},
    {'이름': '박지민', '나이': 24, '직업': '학생'}
]

with open('dict_data.csv', 'w', newline='', encoding='utf-8') as f:
    fieldnames = ['이름', '나이', '직업']
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    
    writer.writeheader()  # 헤더 쓰기
    writer.writerows(dict_data)  # 데이터 쓰기

# 딕셔너리로 CSV 읽기
with open('dict_data.csv', 'r', encoding='utf-8') as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['이름']}는 {row['나이']}세 {row['직업']}입니다.")

import json

# JSON 파일 쓰기
data = {
    'name': 'Kim',
    'age': 25,
    'skills': ['Python', 'JavaScript'],
    'active': True,
    'details': {
        'email': '[email protected]',
        'phone': '010-1234-5678'
    }
}

with open('data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, ensure_ascii=False, indent=2)  # 한글 그대로 저장, 들여쓰기 적용

# JSON 파일 읽기
with open('data.json', 'r', encoding='utf-8') as f:
    loaded_data = json.load(f)
    print(loaded_data['name'])
    print(loaded_data['skills'][0])
    print(loaded_data['details']['email'])

# JSON 문자열 변환
json_str = json.dumps(data, ensure_ascii=False)
print(json_str)

# JSON 문자열 파싱
parsed_data = json.loads(json_str)
print(parsed_data['age'])

# 바이너리 데이터 쓰기
with open('binary.dat', 'wb') as f:
    # 바이트 데이터 쓰기
    f.write(b'Hello, binary world!')
    
    # 정수 값을 바이트로 변환하여 쓰기
    import struct
    numbers = [1, 2, 3, 4, 5]
    for num in numbers:
        f.write(struct.pack('i', num))  # 'i'는 4바이트 정수 형식

# 바이너리 데이터 읽기
with open('binary.dat', 'rb') as f:
    # 처음 21바이트 읽기 (문자열)
    text = f.read(21)
    print(text)  # b'Hello, binary world!'
    
    # 4바이트씩 읽어서 정수로 변환
    import struct
    numbers = []
    while True:
        data = f.read(4)  # 4바이트 읽기
        if not data:  # 파일 끝이면 종료
            break
        number = struct.unpack('i', data)[0]
        numbers.append(number)
    
    print(numbers)  # [1, 2, 3, 4, 5]

import os
import shutil

# 파일 존재 여부 확인
if os.path.exists('example.txt'):
    print('파일이 존재합니다.')

# 파일인지 디렉토리인지 확인
if os.path.isfile('example.txt'):
    print('파일입니다.')
elif os.path.isdir('example_dir'):
    print('디렉토리입니다.')

# 파일 크기 확인
if os.path.exists('example.txt'):
    size = os.path.getsize('example.txt')
    print(f'파일 크기: {size} 바이트')

# 파일 이름 변경
if os.path.exists('example.txt'):
    os.rename('example.txt', 'new_name.txt')

# 파일 복사
if os.path.exists('new_name.txt'):
    shutil.copy('new_name.txt', 'copy.txt')

# 파일 이동
if os.path.exists('copy.txt'):
    if not os.path.exists('temp'):
        os.mkdir('temp')  # 디렉토리 생성
    shutil.move('copy.txt', 'temp/moved.txt')

# 파일 삭제
if os.path.exists('new_name.txt'):
    os.remove('new_name.txt')

# 디렉토리 생성
if not os.path.exists('new_dir'):
    os.mkdir('new_dir')  # 단일 디렉토리 생성
    # os.makedirs('path/to/nested/dir')  # 중첩 디렉토리 생성

# 디렉토리 삭제
if os.path.exists('new_dir'):
    os.rmdir('new_dir')  # 빈 디렉토리만 삭제 가능
    # shutil.rmtree('dir_with_files')  # 파일이 있는 디렉토리 삭제

# 현재 작업 디렉토리
current_dir = os.getcwd()
print(f'현재 디렉토리: {current_dir}')

# 디렉토리 내용 나열
if os.path.exists('.'):
    files = os.listdir('.')
    print('현재 디렉토리 내용:')
    for file in files:
        print(f'- {file}')

import sys

# 표준 출력 (Standard Output)
sys.stdout.write("표준 출력에 직접 쓰기\n")
print("print 함수는 sys.stdout에 출력합니다.")

# 표준 오류 (Standard Error)
sys.stderr.write("오류 메시지를 출력합니다.\n")

# 표준 입력 (Standard Input)
print("이름을 입력하세요:")
name = sys.stdin.readline().strip()  # input() 함수의 기본 동작
print(f"입력한 이름: {name}")

# 출력 리다이렉션 예제
original_stdout = sys.stdout  # 원래 stdout 저장

# 파일로 출력 리다이렉션
with open('output.txt', 'w', encoding='utf-8') as f:
    sys.stdout = f  # stdout을 파일로 변경
    print("이 내용은 파일에 기록됩니다.")
    print("이 내용도 파일에 기록됩니다.")

sys.stdout = original_stdout  # stdout 복원
print("다시 콘솔에 출력됩니다.")

import pickle

# 복잡한 객체 생성
data = {
    'name': 'Alice',
    'age': 30,
    'grades': [85, 90, 92],
    'details': {
        'address': '서울시 강남구',
        'phone': '010-1234-5678'
    }
}

# 객체 직렬화 (저장)
with open('data.pkl', 'wb') as f:
    pickle.dump(data, f)

# 객체 역직렬화 (로드)
with open('data.pkl', 'rb') as f:
    loaded_data = pickle.load(f)

print(loaded_data)
print(f"이름: {loaded_data['name']}")
print(f"상세 정보: {loaded_data['details']}")

# 여러 객체 직렬화
objects = [
    [1, 2, 3, 4],
    {'a': 1, 'b': 2},
    'Hello, Pickle',
    (5, 6, 7)
]

with open('multiple.pkl', 'wb') as f:
    for obj in objects:
        pickle.dump(obj, f)

# 여러 객체 역직렬화
with open('multiple.pkl', 'rb') as f:
    try:
        while True:
            obj = pickle.load(f)
            print(obj)
    except EOFError:
        # 파일 끝에 도달하면 EOFError 발생
        pass

from io import StringIO, BytesIO

# 문자열 기반 파일 객체
output = StringIO()
output.write('First line.\n')
output.write('Second line.\n')

# 현재 값 얻기
contents = output.getvalue()
print(contents)

# 처음으로 위치 이동
output.seek(0)

# 읽기
print(output.read())

# 닫기
output.close()

# 초기 내용으로 생성
input = StringIO('Initial value.\nAnother line.\n')
print(input.read())
input.close()

# 바이너리 데이터용 BytesIO
binary_output = BytesIO()
binary_output.write(b'Binary data\n')
binary_output.write(b'More binary data\n')

# 처음으로 이동
binary_output.seek(0)
print(binary_output.read())
binary_output.close()