Python 기초 완전정복

# 설치 확인
python --version
# 출력 예: Python 3.12.1

# pip (패키지 관리자) 확인
pip --version

# Homebrew 설치 (이미 있다면 생략)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Python 3 설치
brew install python

# 확인
python3 --version

sudo apt update
sudo apt install python3 python3-pip python3-venv

# 확인
python3 --version

print("Hello, World!")

# 작은따옴표도 동일하게 동작합니다
print('안녕하세요, 파이썬!')

# 여러 값을 쉼표로 구분하면 공백으로 연결됩니다
print("나이:", 25, "살")

# sep 인자로 구분자를 변경할 수 있습니다
print("2024", "01", "15", sep="-")

# end 인자로 줄바꿈 대신 다른 문자를 지정합니다
print("Hello", end=" ")
print("World")

# 빈 줄 출력
print()

# 한 줄 주석: 샵(#) 뒤에 작성합니다
print("실행됩니다")  # 코드 끝에도 주석을 달 수 있습니다

# 여러 줄 주석: 각 줄 앞에 #를 붙입니다
# 이 코드는 인사말을 출력하는 프로그램입니다.
# 작성자: 홍길동
# 작성일: 2024-01-15

"""
큰따옴표 세 개로 감싸면 여러 줄 문자열(docstring)입니다.
이것도 주석처럼 사용되기도 합니다.
주로 함수나 클래스의 설명에 사용됩니다.
"""

# 이름을 입력받아 인사하기
name = input("이름을 입력하세요: ")
print("안녕하세요,", name, "님!")

# 나이를 입력받아 출력하기 (숫자로 변환)
age = int(input("나이를 입력하세요: "))
print("내년에는", age + 1, "살이 됩니다!")

# 변수에 값 할당하기
name = "김민수"          # 문자열(str)
age = 25                  # 정수(int)
height = 175.5            # 실수(float)
is_student = True         # 불리언(bool)

# 변수 값 출력
print(name)      # 김민수
print(age)       # 25
print(height)    # 175.5

# 변수 값 변경 (재할당)
age = 26
print(age)       # 26

# 여러 변수에 동시에 값 할당
x, y, z = 1, 2, 3
a = b = c = 0

# 정수 (int) - 소수점 없는 숫자
age = 25
print(type(age))          # <class 'int'>

# 실수 (float) - 소수점 있는 숫자
price = 19900.50
print(type(price))        # <class 'float'>

# 문자열 (str) - 텍스트 데이터
greeting = "안녕하세요"
print(type(greeting))     # <class 'str'>

# 불리언 (bool) - 참(True) 또는 거짓(False)
is_active = True
print(type(is_active))    # <class 'bool'>

# None - 값이 없음을 나타내는 특수 타입
result = None
print(type(result))       # <class 'NoneType'>

# 문자열 → 정수
num_str = "42"
num_int = int(num_str)
print(num_int + 8)           # 50

# 문자열 → 실수
pi_str = "3.14"
pi_float = float(pi_str)
print(pi_float)               # 3.14

# 숫자 → 문자열
age = 25
age_str = str(age)
print("나이: " + age_str)      # 나이: 25

# 정수 ↔ 실수
print(float(10))              # 10.0
print(int(3.99))             # 3 (소수점 버림, 반올림 아님!)

# 불리언 변환
print(bool(0))               # False
print(bool(1))               # True
print(bool(""))              # False (빈 문자열)
print(bool("hello"))         # True (비어있지 않으면 True)

# 기본 산술 연산
print(10 + 3)     # 13
print(10 - 3)     # 7
print(10 * 3)     # 30
print(10 / 3)     # 3.3333333333333335
print(10 // 3)    # 3  (소수점 버림)
print(10 % 3)     # 1  (나머지)
print(2 ** 10)    # 1024 (2의 10승)

# 실전 활용: 시간 변환
total_minutes = 135
hours = total_minutes // 60     # 2시간
minutes = total_minutes % 60    # 15분
print(f"{total_minutes}분 = {hours}시간 {minutes}분")
# 135분 = 2시간 15분

score = 100

score += 10    # score = score + 10  → 110
score -= 20    # score = score - 20  → 90
score *= 2     # score = score * 2   → 180
score //= 3    # score = score // 3  → 60
score %= 7     # score = score % 7   → 4
score **= 3    # score = score ** 3  → 64

print(score)   # 64

x = 10
y = 20

print(x == y)    # False (같다)
print(x != y)    # True  (같지 않다)
print(x > y)     # False (크다)
print(x < y)     # True  (작다)
print(x >= 10)   # True  (크거나 같다)
print(x <= 5)    # False (작거나 같다)

# 파이썬만의 특별한 연쇄 비교
age = 25
print(18 <= age <= 65)   # True (다른 언어에서는 불가)

age = 25
has_id = True

# and : 둘 다 True일 때 True
print(age >= 18 and has_id)     # True

# or : 하나라도 True이면 True
print(age < 18 or has_id)       # True

# not : 반대로 뒤집기
print(not has_id)                # False

# 복합 조건
score = 85
grade = "A"
print(score >= 80 and grade == "A")   # True

# 작은따옴표와 큰따옴표 모두 가능
s1 = 'Hello'
s2 = "World"

# 따옴표 안에 따옴표가 필요할 때
s3 = "It's a beautiful day"     # 큰따옴표로 감싸기
s4 = 'He said "Hello"'           # 작은따옴표로 감싸기
s5 = 'It\'s a beautiful day'     # 이스케이프 문자 사용

# 여러 줄 문자열 (삼중 따옴표)
poem = """첫 번째 줄
두 번째 줄
세 번째 줄"""
print(poem)

text = "Python"
#        P  y  t  h  o  n
# 인덱스: 0  1  2  3  4  5
# 음수: -6 -5 -4 -3 -2 -1

# 인덱싱: 특정 위치의 글자 하나
print(text[0])     # P (첫 번째 글자)
print(text[5])     # n (마지막 글자)
print(text[-1])    # n (뒤에서 첫 번째)
print(text[-2])    # o (뒤에서 두 번째)

# 슬라이싱: [시작:끝] (끝 인덱스는 포함 안 됨!)
print(text[0:3])   # Pyt (0, 1, 2번)
print(text[2:])    # thon (2번부터 끝까지)
print(text[:4])    # Pyth (처음부터 3번까지)
print(text[::2])   # Pto (2칸씩 건너뛰기)
print(text[::-1])  # nohtyP (뒤집기!)

msg = "  Hello, Python World!  "

# 대소문자 변환
print(msg.upper())            # "  HELLO, PYTHON WORLD!  "
print(msg.lower())            # "  hello, python world!  "
print(msg.title())            # "  Hello, Python World!  "

# 공백 제거
print(msg.strip())            # "Hello, Python World!"
print(msg.lstrip())           # "Hello, Python World!  "
print(msg.rstrip())           # "  Hello, Python World!"

# 치환
print(msg.replace("Python", "Java"))
# "  Hello, Java World!  "

# 분리와 결합
fruits = "사과,바나나,포도,딸기"
fruit_list = fruits.split(",")
print(fruit_list)             # ['사과', '바나나', '포도', '딸기']

print(" / ".join(fruit_list))
# "사과 / 바나나 / 포도 / 딸기"

# 검색
print(msg.find("Python"))     # 9 (시작 위치)
print(msg.find("Java"))       # -1 (못 찾으면 -1)
print(msg.count("l"))         # 2
print(msg.startswith("  He")) # True
print(msg.endswith("!  "))    # True

# 검증
print("12345".isdigit())      # True (숫자로만 구성?)
print("hello".isalpha())      # True (문자로만 구성?)
print("abc123".isalnum())     # True (문자+숫자?)

# 리스트 생성
fruits = ["사과", "바나나", "포도", "딸기"]
numbers = [1, 2, 3, 4, 5]
mixed = ["hello", 42, 3.14, True, None]
empty = []

# 인덱싱 (문자열과 동일한 방식)
print(fruits[0])     # 사과
print(fruits[-1])    # 딸기

# 슬라이싱
print(fruits[1:3])   # ['바나나', '포도']

# 길이 확인
print(len(fruits))   # 4

colors = ["빨강", "파랑", "노랑"]

# 값 변경
colors[1] = "초록"
print(colors)    # ['빨강', '초록', '노랑']

# 추가
colors.append("보라")           # 끝에 추가
colors.insert(1, "주황")        # 특정 위치에 삽입
colors.extend(["검정", "흰색"])  # 여러 개 한번에 추가
print(colors)
# ['빨강', '주황', '초록', '노랑', '보라', '검정', '흰색']

# 삭제
colors.remove("초록")            # 값으로 삭제
popped = colors.pop()            # 마지막 요소 꺼내기 (반환+삭제)
print(popped)                    # 흰색
popped2 = colors.pop(0)          # 특정 위치 요소 꺼내기
print(popped2)                   # 빨강
del colors[0]                    # 인덱스로 삭제 (반환 없음)

# 전체 비우기
colors.clear()
print(colors)    # []

scores = [85, 92, 78, 96, 64, 88]

# 정렬 (원본 변경)
scores.sort()                    # 오름차순
print(scores)    # [64, 78, 85, 88, 92, 96]

scores.sort(reverse=True)       # 내림차순
print(scores)    # [96, 92, 88, 85, 78, 64]

# 정렬 (원본 유지, 새 리스트 반환)
original = [3, 1, 4, 1, 5]
sorted_list = sorted(original)
print(original)     # [3, 1, 4, 1, 5] (원본 유지)
print(sorted_list)  # [1, 1, 3, 4, 5] (새 리스트)

# 검색
print(88 in scores)     # True  (포함 여부)
print(100 in scores)    # False
print(scores.index(88)) # 2 (위치 찾기)
print(scores.count(88)) # 1 (등장 횟수)

# 뒤집기
scores.reverse()
print(scores)    # [64, 78, 85, 88, 92, 96]

# 리스트 합치기
a = [1, 2, 3]
b = [4, 5, 6]
print(a + b)        # [1, 2, 3, 4, 5, 6]

# 리스트 반복
print(a * 3)        # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 중첩 리스트 (2차원)
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix[1][2])  # 6 (2행 3열)

# 리스트 복사 (주의!)
original = [1, 2, 3]
shallow = original         # 같은 객체를 가리킴 (복사 아님!)
deep = original.copy()     # 진짜 복사 (새 객체 생성)
deep2 = original[:]        # 슬라이싱으로도 복사 가능

# 튜플 생성
point = (3, 5)
colors = ("빨강", "초록", "파랑")
single = (42,)    # 요소가 하나일 때 반드시 쉼표 필요!

# 인덱싱, 슬라이싱은 리스트와 동일
print(colors[0])     # 빨강
print(colors[1:])    # ('초록', '파랑')

# 값 변경 시도 → 에러!
# colors[0] = "노랑"   # TypeError 발생!

# 언패킹 (여러 변수에 한번에 할당)
x, y = point
print(f"x={x}, y={y}")  # x=3, y=5

# 함수에서 여러 값 반환 시 튜플 활용
def min_max(numbers):
    return min(numbers), max(numbers)

lo, hi = min_max([3, 7, 1, 9, 2])
print(f"최소: {lo}, 최대: {hi}")  # 최소: 1, 최대: 9

# 집합 생성 - 중복 자동 제거!
numbers = {1, 2, 3, 2, 1, 4}
print(numbers)       # {1, 2, 3, 4} (중복 제거됨)

# 리스트에서 중복 제거하는 가장 쉬운 방법!
names = ["김", "이", "박", "김", "이"]
unique_names = list(set(names))
print(unique_names)  # ['김', '이', '박'] (순서 변경 가능)

# 집합 연산
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}              차집합 (a에만 있는 것)
print(a ^ b)    # {1, 2, 5, 6}        대칭차집합

# 추가 / 삭제
a.add(10)
a.discard(1)     # 없어도 에러 없음
a.remove(2)      # 없으면 KeyError 발생

# 딕셔너리 생성
person = {
    "name": "김민수",
    "age": 25,
    "city": "서울",
    "hobbies": ["독서", "코딩", "등산"]
}

# 값 접근
print(person["name"])           # 김민수
print(person.get("age"))       # 25
print(person.get("email", "없음"))  # 없음 (키가 없을 때 기본값)

# 값 추가 / 수정
person["email"] = "minsu@mail.com"   # 추가
person["age"] = 26                     # 수정

# 삭제
del person["city"]
removed = person.pop("email")

# 키/값/쌍 조회
print(person.keys())     # dict_keys(['name', 'age', 'hobbies'])
print(person.values())   # dict_values(['김민수', 26, [...]])
print(person.items())    # dict_items([('name', '김민수'), ...])

# 포함 여부 확인 (키 기준)
print("name" in person)   # True
print("phone" in person)  # False

scores = {"국어": 90, "영어": 85, "수학": 92, "과학": 88}

# 키만 순회
for subject in scores:
    print(subject, scores[subject])

# 키-값 쌍 동시 순회 (가장 많이 사용!)
for subject, score in scores.items():
    print(f"{subject}: {score}점")

# 값만 순회
total = 0
for score in scores.values():
    total += score
print(f"총점: {total}, 평균: {total / len(scores)}")

# 학생 관리 시스템
students = {
    "S001": {
        "name": "김민수",
        "scores": {"국어": 90, "수학": 85}
    },
    "S002": {
        "name": "이영희",
        "scores": {"국어": 95, "수학": 92}
    }
}

# 중첩 접근
print(students["S001"]["name"])              # 김민수
print(students["S002"]["scores"]["수학"])    # 92

# 전체 학생 정보 출력
for sid, info in students.items():
    avg = sum(info["scores"].values()) / len(info["scores"])
    print(f"{sid} {info['name']} - 평균: {avg}")

age = 20

# 기본 if
if age >= 18:
    print("성인입니다.")

# if-else
if age >= 18:
    print("성인입니다.")
else:
    print("미성년자입니다.")

# if-elif-else (다중 조건)
score = 85

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(f"점수: {score}, 등급: {grade}")
# 점수: 85, 등급: B

# 복합 조건 (and, or, not)
age = 25
has_license = True

if age >= 18 and has_license:
    print("운전할 수 있습니다.")
elif age >= 18 and not has_license:
    print("면허를 먼저 취득하세요.")
else:
    print("아직 운전할 수 없는 나이입니다.")

# in 연산자로 포함 여부 확인
fruit = "사과"
if fruit in ["사과", "배", "포도"]:
    print(f"{fruit}는(은) 과일 목록에 있습니다.")

age = 20

# 기존 if-else
if age >= 18:
    status = "성인"
else:
    status = "미성년"

# 삼항 연산자로 한 줄 처리
status = "성인" if age >= 18 else "미성년"
print(status)  # 성인

# 실전 활용
score = 75
result = "합격" if score >= 60 else "불합격"
print(result)  # 합격

# 리스트 순회
fruits = ["사과", "바나나", "포도"]
for fruit in fruits:
    print(f"과일: {fruit}")

# range() 함수로 숫자 반복
for i in range(5):          # 0, 1, 2, 3, 4
    print(i, end=" ")
print()  # 0 1 2 3 4

for i in range(1, 6):       # 1, 2, 3, 4, 5
    print(i, end=" ")
print()  # 1 2 3 4 5

for i in range(0, 10, 2):  # 0, 2, 4, 6, 8 (2씩 증가)
    print(i, end=" ")
print()  # 0 2 4 6 8

# enumerate(): 인덱스와 값을 함께 얻기
for idx, fruit in enumerate(fruits):
    print(f"{idx}번: {fruit}")
# 0번: 사과
# 1번: 바나나
# 2번: 포도

# 문자열 순회
for char in "Python":
    print(char, end="-")
# P-y-t-h-o-n-

# 기본 while
count = 0
while count < 5:
    print(count, end=" ")
    count += 1
# 0 1 2 3 4

# 사용자 입력 반복 (실전 패턴)
while True:
    answer = input("계속하시겠습니까? (y/n): ")
    if answer.lower() == "n":
        print("종료합니다.")
        break
    print("계속 진행...")

# break: 반복문 즉시 탈출
for i in range(10):
    if i == 5:
        print("5를 만나서 중단!")
        break
    print(i, end=" ")
# 0 1 2 3 4 5를 만나서 중단!

# continue: 이번 반복만 건너뛰고 다음으로
for i in range(10):
    if i % 2 == 0:   # 짝수이면
        continue       # 건너뛰기
    print(i, end=" ")
# 1 3 5 7 9 (홀수만 출력)

# for-else: break 없이 정상 종료되면 else 실행
numbers = [2, 4, 6, 8]
for num in numbers:
    if num % 2 != 0:
        print(f"홀수 발견: {num}")
        break
else:
    print("모두 짝수입니다!")
# 모두 짝수입니다!

# 중첩 for문으로 구구단 출력
for dan in range(2, 10):
    print(f"--- {dan}단 ---")
    for i in range(1, 10):
        print(f"{dan} x {i} = {dan * i}")
    print()

# 기존 방식: for문으로 제곱 리스트 만들기
squares = []
for i in range(1, 6):
    squares.append(i ** 2)
print(squares)  # [1, 4, 9, 16, 25]

# 리스트 컴프리헨션: 같은 결과를 한 줄로!
squares = [i ** 2 for i in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# 조건 필터링: 짝수만 골라서 제곱
even_sq = [i ** 2 for i in range(1, 11) if i % 2 == 0]
print(even_sq)  # [4, 16, 36, 64, 100]

# if-else와 함께: 홀짝 분류
labels = ["짝" if i % 2 == 0 else "홀" for i in range(1, 6)]
print(labels)   # ['홀', '짝', '홀', '짝', '홀']

# 문자열에서 모음만 추출
text = "Hello Python World"
vowels = [c for c in text if c.lower() in "aeiou"]
print(vowels)   # ['e', 'o', 'y', 'o', 'o']

# 딕셔너리 컴프리헨션
sq_dict = {x: x**2 for x in range(1, 6)}
print(sq_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 두 리스트를 딕셔너리로 합치기
keys = ["name", "age", "city"]
values = ["김민수", 25, "서울"]
person = {k: v for k, v in zip(keys, values)}
print(person)   # {'name': '김민수', 'age': 25, 'city': '서울'}

# 집합 컴프리헨션
unique_lengths = {len(word) for word in ["hi", "hello", "hey", "ho"]}
print(unique_lengths)  # {2, 5, 3}

# 함수 정의: def 키워드 사용
def greet(name):
    """이름을 받아 인사하는 함수"""
    print(f"안녕하세요, {name}님!")

# 함수 호출
greet("김민수")   # 안녕하세요, 김민수님!
greet("이영희")   # 안녕하세요, 이영희님!

# 반환값이 있는 함수
def add(a, b):
    """두 수를 더한 결과를 반환"""
    return a + b

result = add(3, 5)
print(result)      # 8

# 여러 값 반환 (튜플)
def calc(a, b):
    return a + b, a - b, a * b, a / b

add_r, sub_r, mul_r, div_r = calc(10, 3)
print(f"합:{add_r} 차:{sub_r} 곱:{mul_r} 몫:{div_r:.2f}")
# 합:13 차:7 곱:30 몫:3.33

# 기본값(Default) 매개변수
def introduce(name, age=20, city="서울"):
    print(f"{name}, {age}세, {city}")

introduce("김민수")              # 김민수, 20세, 서울
introduce("이영희", 25)          # 이영희, 25세, 서울
introduce("박철수", 30, "부산") # 박철수, 30세, 부산

# 키워드 인자: 순서 상관없이 이름으로 전달
introduce(city="대전", name="정수진", age=28)
# 정수진, 28세, 대전

# *args: 가변 위치 인자 (튜플로 받음)
def total(*numbers):
    print(f"인자: {numbers}")
    return sum(numbers)

print(total(1, 2, 3))         # 인자: (1, 2, 3) → 6
print(total(10, 20, 30, 40))  # 인자: (10, 20, 30, 40) → 100

# **kwargs: 가변 키워드 인자 (딕셔너리로 받음)
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="김민수", age=25, city="서울")
# name: 김민수
# age: 25
# city: 서울

x = 10  # 전역 변수 (global)

def my_func():
    y = 20  # 지역 변수 (local) - 함수 안에서만 존재
    print(f"함수 안: x={x}, y={y}")

my_func()           # 함수 안: x=10, y=20
print(f"함수 밖: x={x}")
# print(y)          # NameError! y는 함수 밖에서 접근 불가

# global 키워드로 전역 변수 수정
counter = 0
def increment():
    global counter
    counter += 1

increment()
increment()
print(counter)  # 2

# 일반 함수
def square(x):
    return x ** 2

# 같은 기능의 람다 함수
square = lambda x: x ** 2
print(square(5))  # 25

# 실전 활용: 정렬 기준 지정
students = [
    {"name": "김민수", "score": 85},
    {"name": "이영희", "score": 92},
    {"name": "박철수", "score": 78},
]

# 점수 기준 내림차순 정렬
students.sort(key=lambda s: s["score"], reverse=True)
for s in students:
    print(f"{s['name']}: {s['score']}점")
# 이영희: 92점
# 김민수: 85점
# 박철수: 78점

# map(): 모든 요소에 함수 적용
numbers = [1, 2, 3, 4, 5]
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]

# zip(): 여러 리스트를 병렬로 묶기
names = ["김", "이", "박"]
scores = [90, 85, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score}점")

class Dog:
    """강아지를 나타내는 클래스"""

    # 생성자: 인스턴스가 만들어질 때 자동 호출
    def __init__(self, name, breed, age):
        self.name = name      # 인스턴스 속성
        self.breed = breed
        self.age = age

    # 메서드 (인스턴스 함수)
    def bark(self):
        print(f"{self.name}: 멍멍!")

    def info(self):
        print(f"이름: {self.name}, 견종: {self.breed}, 나이: {self.age}세")

# 인스턴스(객체) 생성
my_dog = Dog("초코", "골든리트리버", 3)
your_dog = Dog("뭉치", "시바견", 5)

# 메서드 호출
my_dog.bark()   # 초코: 멍멍!
my_dog.info()   # 이름: 초코, 견종: 골든리트리버, 나이: 3세

# 속성 접근
print(my_dog.name)    # 초코
my_dog.age = 4        # 속성 수정

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

    def __str__(self):
        # print()로 출력할 때 사용
        return f"{self.name} - {self.price:,}원"

    def __repr__(self):
        # 개발자용 상세 표현
        return f"Product('{self.name}', {self.price})"

item = Product("무선 키보드", 45000)
print(item)       # 무선 키보드 - 45,000원
print(repr(item)) # Product('무선 키보드', 45000)

# 부모 클래스
class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def speak(self):
        print(f"{self.name}: {self.sound}")

    def info(self):
        print(f"동물 이름: {self.name}")

# 자식 클래스: Animal을 상속
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, "멍멍")  # 부모 생성자 호출
        self.breed = breed

    def fetch(self):
        print(f"{self.name}가 공을 물어옵니다!")

class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name, "야옹")
        self.color = color

    def purr(self):
        print(f"{self.name}가 그르릉 소리를 냅니다.")

# 사용
dog = Dog("초코", "골든리트리버")
cat = Cat("나비", "흰색")

dog.speak()    # 초코: 멍멍 (부모 메서드 사용)
dog.fetch()    # 초코가 공을 물어옵니다! (자식 고유 메서드)
cat.speak()    # 나비: 야옹
cat.purr()     # 나비가 그르릉 소리를 냅니다.

class Shape:
    def area(self):
        raise NotImplementedError("하위 클래스에서 구현하세요")

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

# 다형성: 같은 메서드를 서로 다르게 동작
shapes = [Circle(5), Rectangle(4, 6), Circle(3)]
for shape in shapes:
    print(f"{shape.__class__.__name__} 넓이: {shape.area():.2f}")
# Circle 넓이: 78.54
# Rectangle 넓이: 24.00
# Circle 넓이: 28.27

# 모듈 전체 import
import math
print(math.pi)           # 3.141592653589793
print(math.sqrt(16))     # 4.0
print(math.ceil(3.2))    # 4
print(math.floor(3.8))   # 3

# 별칭(alias) 사용
import datetime as dt
now = dt.datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))

# 특정 요소만 import
from random import randint, choice
print(randint(1, 100))          # 1~100 사이 랜덤 정수
print(choice(["가위", "바위", "보"]))  # 랜덤 선택

# 유용한 내장 모듈들
import os            # 운영체제 상호작용
import json          # JSON 처리
import csv           # CSV 파일 처리
import re            # 정규표현식
import collections   # 고급 자료구조
import itertools     # 반복 도구

# my_utils.py (모듈 파일)
def greet(name):
    return f"안녕하세요, {name}님!"

def add_tax(price, rate=0.1):
    return price * (1 + rate)

PI = 3.14159

# main.py (사용하는 파일)
import my_utils

print(my_utils.greet("김민수"))     # 안녕하세요, 김민수님!
print(my_utils.add_tax(10000))     # 11000.0
print(my_utils.PI)                  # 3.14159

# 파일 쓰기 (w: write - 기존 내용 덮어쓰기)
with open("hello.txt", "w", encoding="utf-8") as f:
    f.write("안녕하세요!\n")
    f.write("파이썬 파일 입출력입니다.\n")
    f.write("재미있죠?\n")

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

# 줄 단위로 읽기
with open("hello.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())    # strip()으로 줄바꿈 제거

# 파일 추가 (a: append - 기존 내용 뒤에 추가)
with open("hello.txt", "a", encoding="utf-8") as f:
    f.write("추가된 내용입니다.\n")

import json

# 딕셔너리 → JSON 파일 저장
data = {
    "name": "김민수",
    "age": 25,
    "scores": [90, 85, 92],
    "is_student": True
}

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 = json.load(f)

print(loaded["name"])     # 김민수
print(loaded["scores"])   # [90, 85, 92]

# 기본 try-except
try:
    num = int(input("숫자를 입력하세요: "))
    result = 100 / num
    print(f"결과: {result}")
except ValueError:
    print("숫자를 입력해야 합니다!")
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다!")
except Exception as e:
    print(f"예상치 못한 에러: {e}")
else:
    print("에러 없이 성공!")         # 예외 없을 때만 실행
finally:
    print("항상 실행되는 코드")       # 예외 여부와 무관하게 항상 실행

def get_positive_int(prompt):
    """양의 정수를 입력받을 때까지 반복"""
    while True:
        try:
            value = int(input(prompt))
            if value <= 0:
                print("양의 정수를 입력해주세요.")
                continue
            return value
        except ValueError:
            print("올바른 숫자를 입력해주세요.")

age = get_positive_int("나이를 입력하세요: ")
print(f"입력된 나이: {age}")

numbers = [3, 7, 1, 9, 2, 5]

# 수학 관련
print(len(numbers))      # 6  (길이)
print(sum(numbers))      # 27 (합계)
print(min(numbers))      # 1  (최소)
print(max(numbers))      # 9  (최대)
print(abs(-42))          # 42 (절대값)
print(round(3.7))        # 4  (반올림)
print(round(3.14159, 2)) # 3.14 (소수점 2자리)
print(pow(2, 10))        # 1024 (거듭제곱)

# 정렬/반전
print(sorted(numbers))              # [1, 2, 3, 5, 7, 9]
print(sorted(numbers, reverse=True)) # [9, 7, 5, 3, 2, 1]
print(list(reversed(numbers)))      # [5, 2, 9, 1, 7, 3]

# 타입 확인/변환
print(type(42))           # <class 'int'>
print(isinstance(42, int)) # True

# any / all
print(any([False, False, True]))  # True  (하나라도 True?)
print(all([True, True, True]))    # True  (모두 True?)
print(all([True, False, True]))   # False

# enumerate, zip, range (이미 배움)
# map, filter (이미 배움)

name = "김민수"
age = 25
score = 88.5

# 기본 사용
print(f"이름: {name}, 나이: {age}")

# 표현식 사용
print(f"내년 나이: {age + 1}")
print(f"이름 길이: {len(name)}")

# 서식 지정
print(f"점수: {score:.1f}")           # 소수점 1자리: 88.5
print(f"비율: {score/100:.2%}")       # 퍼센트: 88.50%
print(f"가격: {45000:,}원")            # 천단위 쉼표: 45,000원
print(f"번호: {42:05d}")              # 0 채우기: 00042

# 정렬
print(f"{name:10}|")     # 왼쪽 정렬: '김민수       |'
print(f"{name:>10}|")    # 오른쪽 정렬: '       김민수|'
print(f"{name:^10}|")    # 가운데 정렬: '   김민수    |'

# .format() 메서드 (Python 2.7+)
print("이름: {}, 나이: {}".format(name, age))
print("이름: {n}, 나이: {a}".format(n=name, a=age))

# % 연산자 (오래된 방식, 레거시 코드에서 볼 수 있음)
print("이름: %s, 나이: %d" % (name, age))

import re

text = "연락처: 010-1234-5678, 이메일: test@mail.com"

# 패턴 검색
phone = re.search(r'\d{3}-\d{4}-\d{4}', text)
if phone:
    print(f"전화번호: {phone.group()}")
# 전화번호: 010-1234-5678

# 이메일 추출
email = re.search(r'[\w.+-]+@[\w-]+\.[\w.]+', text)
if email:
    print(f"이메일: {email.group()}")
# 이메일: test@mail.com

# 모든 숫자 찾기
numbers = re.findall(r'\d+', text)
print(numbers)  # ['010', '1234', '5678']

# 패턴 치환
masked = re.sub(r'\d{4}-\d{4}', '****-****', text)
print(masked)
# 연락처: 010-****-****, 이메일: test@mail.com

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

# 가상환경 활성화
# Windows:
myenv\Scripts\activate
# macOS / Linux:
source myenv/bin/activate

# 활성화되면 프롬프트에 (myenv)가 표시됩니다
# (myenv) $

# 패키지 설치
pip install requests
pip install pandas numpy matplotlib

# 설치된 패키지 목록
pip list
pip freeze

# requirements.txt로 저장 / 복원
pip freeze > requirements.txt
pip install -r requirements.txt

# 가상환경 비활성화
deactivate

import json
import os

FILE_NAME = "contacts.json"

def load_contacts():
    """파일에서 연락처 불러오기"""
    if os.path.exists(FILE_NAME):
        with open(FILE_NAME, "r", encoding="utf-8") as f:
            return json.load(f)
    return {}

def save_contacts(contacts):
    """파일에 연락처 저장"""
    with open(FILE_NAME, "w", encoding="utf-8") as f:
        json.dump(contacts, f, ensure_ascii=False, indent=2)

def add_contact(contacts):
    """연락처 추가"""
    name = input("이름: ").strip()
    phone = input("전화번호: ").strip()
    email = input("이메일: ").strip()
    contacts[name] = {"phone": phone, "email": email}
    save_contacts(contacts)
    print(f"✓ '{name}' 추가 완료!")

def search_contact(contacts):
    """연락처 검색"""
    keyword = input("검색어: ").strip()
    found = {k: v for k, v in contacts.items()
             if keyword in k}
    if found:
        for name, info in found.items():
            print(f"  {name} | {info['phone']} | {info['email']}")
    else:
        print("검색 결과가 없습니다.")

def list_contacts(contacts):
    """전체 목록 출력"""
    if not contacts:
        print("연락처가 비어 있습니다.")
        return
    print(f"\n{'이름':<10} {'전화번호':<16} {'이메일'}")
    print("-" * 50)
    for name, info in contacts.items():
        print(f"{name:10} {info['phone']:16} {info['email']}")

def main():
    contacts = load_contacts()
    print("=== 연락처 관리 프로그램 ===")

    while True:
        print("\n[1] 추가  [2] 검색  [3] 목록  [4] 종료")
        choice = input("선택: ").strip()

        if choice == "1":
            add_contact(contacts)
        elif choice == "2":
            search_contact(contacts)
        elif choice == "3":
            list_contacts(contacts)
        elif choice == "4":
            print("프로그램을 종료합니다.")
            break
        else:
            print("올바른 번호를 선택해주세요.")

if __name__ == "__main__":
    main()

class Student:
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores  # dict: {"국어": 90, "수학": 85, ...}

    def average(self):
        return sum(self.scores.values()) / len(self.scores)

    def grade(self):
        avg = self.average()
        if avg >= 90: return "A"
        elif avg >= 80: return "B"
        elif avg >= 70: return "C"
        elif avg >= 60: return "D"
        else: return "F"

    def __str__(self):
        return f"{self.name:6} | 평균: {self.average():6.1f} | 등급: {self.grade()}"

# 학생 데이터
students = [
    Student("김민수", {"국어": 90, "영어": 85, "수학": 92}),
    Student("이영희", {"국어": 78, "영어": 92, "수학": 88}),
    Student("박철수", {"국어": 65, "영어": 70, "수학": 55}),
    Student("정수진", {"국어": 95, "영어": 98, "수학": 97}),
    Student("최동현", {"국어": 82, "영어": 75, "수학": 80}),
]

# 전체 성적표
print("=== 성적 분석 결과 ===")
for s in students:
    print(s)

# 전체 평균
class_avg = sum(s.average() for s in students) / len(students)
print(f"\n전체 평균: {class_avg:.1f}")

# 1등 찾기
top = max(students, key=lambda s: s.average())
print(f"1등: {top.name} ({top.average():.1f}점)")

# 등급별 인원수
from collections import Counter
grade_counts = Counter(s.grade() for s in students)
print(f"등급 분포: {dict(grade_counts)}")

import re
from collections import Counter

def analyze_text(text):
    """텍스트의 단어 빈도를 분석하는 함수"""
    # 소문자 변환 후 단어 추출
    words = re.findall(r'[가-힣a-zA-Z]+', text.lower())

    # 기본 통계
    print(f"총 단어 수: {len(words)}")
    print(f"고유 단어 수: {len(set(words))}")

    # 빈도수 상위 10개
    counter = Counter(words)
    print("\n--- 빈도수 TOP 10 ---")
    for word, count in counter.most_common(10):
        bar = "█" * count
        print(f"{word:10} {count:3}회 {bar}")

# 예시 텍스트
sample = """
파이썬은 배우기 쉬운 프로그래밍 언어입니다.
파이썬은 데이터 분석에 많이 사용됩니다.
파이썬으로 웹 개발도 할 수 있고 인공지능 개발도 할 수 있습니다.
프로그래밍을 처음 배우는 사람에게 파이썬을 추천합니다.
"""

analyze_text(sample)

# ==============================================
#   Python 치트시트 - 한눈에 보는 핵심 문법
# ==============================================

# ── 1. 변수 & 데이터 타입 ──
x = 10              # int   (정수)
y = 3.14            # float (실수)
s = "hello"         # str   (문자열)
b = True             # bool  (불리언)
n = None             # NoneType (값 없음)
type(x)              # 타입 확인
int() float() str() bool()  # 타입 변환

# ── 2. 문자열 ──
s = "Hello World"
s[0]  s[-1]  s[1:5]  s[::-1]    # 인덱싱 & 슬라이싱
s.upper()  s.lower()  s.strip()   # 변환
s.split()  s.replace("a", "b")    # 분리 & 치환
s.find("sub")  s.count("l")       # 검색
f"name: {name}, age: {age}"      # f-string 포매팅

# ── 3. 리스트 ──
lst = [1, 2, 3]
lst.append(x)  lst.insert(i, x)  lst.extend(other)
lst.pop()  lst.remove(x)  del lst[i]  lst.clear()
lst.sort()  lst.reverse()  lst.copy()
len(lst)  x in lst  lst.index(x)  lst.count(x)

# ── 4. 딕셔너리 ──
d = {"key": "value"}
d["key"]  d.get("key", default)
d.keys()  d.values()  d.items()
d.pop("key")  d.update(other)  "key" in d

# ── 5. 튜플 & 집합 ──
t = (1, 2, 3)            # 불변(immutable)
s = {1, 2, 3}            # 중복 불허, 순서 없음
s1 | s2   s1 & s2   s1 - s2   # 합/교/차집합

# ── 6. 조건문 ──
if 조건A:
    ...
elif 조건B:
    ...
else:
    ...
result = A if 조건 else B     # 삼항 연산자

# ── 7. 반복문 ──
for item in iterable:
    ...
for i in range(start, stop, step):
    ...
for idx, val in enumerate(lst):
    ...
while 조건:
    ...
break   continue              # 흐름 제어

# ── 8. 컴프리헨션 ──
[x**2 for x in range(10)]             # 리스트
[x for x in lst if x > 0]            # 필터
{k: v for k, v in items}             # 딕셔너리
{x for x in lst}                     # 집합

# ── 9. 함수 ──
def func(a, b=10, *args, **kwargs):
    """docstring"""
    return result
lambda x: x ** 2                      # 익명 함수

# ── 10. 클래스 ──
class MyClass(ParentClass):
    def __init__(self, value):
        super().__init__()
        self.value = value
    def method(self):
        return self.value

# ── 11. 예외 처리 ──
try:
    ...
except ErrorType as e:
    ...
else:        # 에러 없을 때
    ...
finally:     # 항상 실행
    ...

# ── 12. 파일 I/O ──
with open("file.txt", "r", encoding="utf-8") as f:
    content = f.read()
# 모드: r(읽기) w(쓰기-덮어씀) a(추가) rb/wb(바이너리)

# ── 13. 유용한 내장 함수 ──
print()  input()  len()  type()  range()
int()  float()  str()  list()  dict()  set()  tuple()
sum()  min()  max()  abs()  round()  sorted()
enumerate()  zip()  map()  filter()
any()  all()  isinstance()  hasattr()

# ── 14. 모듈 import ──
import module
from module import func
import module as alias