5. 문자열을 사용해 텍스트 다루기

# string_basics.py
greeting = 'Hello, World!'
message = "Python is great!"
 
print(greeting)  # Output: Hello, World!
print(message)   # Output: Python is great!

# quotes_in_strings.py
# 문자열 안에 작은따옴표가 있을 때는 큰따옴표 사용
sentence = "It's a beautiful day!"
print(sentence)  # Output: It's a beautiful day!
 
# 문자열 안에 큰따옴표가 있을 때는 작은따옴표 사용
quote = 'She said, "Hello!"'
print(quote)  # Output: She said, "Hello!"

# escaping_quotes.py
# 작은따옴표로 둘러싸인 문자열 안에서 작은따옴표 이스케이프하기
sentence = 'It\'s a beautiful day!'
print(sentence)  # Output: It's a beautiful day!
 
# 큰따옴표로 둘러싸인 문자열 안에서 큰따옴표 이스케이프하기
quote = "She said, \"Hello!\""
print(quote)  # Output: She said, "Hello!"

# multiline_strings.py
poem = """Roses are red,
Violets are blue,
Python is awesome,
And so are you!"""
 
print(poem)
# Output:
# Roses are red,
# Violets are blue,
# Python is awesome,
# And so are you!

# triple_quotes_convenience.py
dialogue = '''The teacher said, "Don't forget: it's important to practice!"'''
print(dialogue)  # Output: The teacher said, "Don't forget: it's important to practice!"

# escape_sequences.py
# 새 줄: 다음 줄로 이동
print("First line\nSecond line")
# Output:
# First line
# Second line
 
# 탭: 가로 방향의 간격을 삽입
print("Name:\tJohn\nAge:\t25")
# Output:
# Name:	John
# Age:	25
 
# 백슬래시 자체를 포함하기
path = "C:\\Users\\Documents"
print(path)  # Output: C:\Users\Documents

# raw_strings.py
# 일반 문자열: 백슬래시는 이스케이프 시퀀스를 유발
regular = "C:\new\test"
print(regular)  # Output: C:
                #         ew   est
                # (\n은 새 줄, \t는 탭이 됨)
 
# raw 문자열: 백슬래시를 있는 그대로 사용
raw = r"C:\new\test"
print(raw)  # Output: C:\new\test

# windows_paths.py
# raw 문자열이 아니면, 모든 백슬래시를 이스케이프해야 함
path1 = "C:\\Users\\John\\Documents\\file.txt"
 
# raw 문자열을 사용하면 백슬래시를 자연스럽게 쓸 수 있음
path2 = r"C:\Users\John\Documents\file.txt"
 
print(path1)  # Output: C:\Users\John\Documents\file.txt
print(path2)  # Output: C:\Users\John\Documents\file.txt

# string_concatenation.py
first_name = "John"
last_name = "Smith"
 
# + 로 문자열 결합하기
full_name = first_name + " " + last_name
print(full_name)  # Output: John Smith
 
# 더 긴 문자열 만들기
greeting = "Hello, " + full_name + "!"
print(greeting)  # Output: Hello, John Smith!

# concatenation_spacing.py
word1 = "Hello"
word2 = "World"
 
# 공백 없이
no_space = word1 + word2
print(no_space)  # Output: HelloWorld
 
# 공백 포함
with_space = word1 + " " + word2
print(with_space)  # Output: Hello World

# multiple_concatenation.py
address = "123" + " " + "Main" + " " + "Street"
print(address)  # Output: 123 Main Street

# concatenation_error.py
age = 25
# 이것은 에러를 발생시킵니다:
# message = "I am " + age + " years old"  # TypeError!
 
# 숫자를 먼저 문자열로 변환해야 합니다
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

# string_repetition.py
separator = "-" * 20
print(separator)  # Output: --------------------
 
# 패턴 만들기
pattern = "abc" * 3
print(pattern)  # Output: abcabcabc
 
# 출력 서식 지정에 유용
print("=" * 30)
print("Important Message")
print("=" * 30)
# Output:
# ==============================
# Important Message
# ==============================

# repetition_examples.py
# 0번 반복하면 빈 문자열이 됩니다
nothing = "Hello" * 0
print(nothing)      # Output: (empty string)
print(len(nothing)) # Output: 0
 
# 1번 반복은 원래 문자열과 같습니다
once = "Hello" * 1
print(once)  # Output: Hello
 
# 더 큰 반복
many = "Go! " * 5
print(many)  # Output: Go! Go! Go! Go! Go!

# practical_repetition.py
# 간단한 텍스트 박스 만들기
width = 40
border = "=" * width
title = "Welcome"
padding = " " * ((width - len(title)) // 2)
 
print(border)
print(padding + title)
print(border)
# Output:
# ========================================
#                 Welcome
# ========================================

# combined_operations.py
# 먼저 반복이 수행되고, 그 다음 이어 붙이기
result = "=" * 10 + " Title " + "=" * 10
print(result)  # Output: ========== Title ==========
 
# 괄호를 사용해 순서를 제어
repeated_phrase = ("Hello " + "World ") * 3
print(repeated_phrase)  # Output: Hello World Hello World Hello World

# string_indexing.py
text = "Python"
 
# 인덱스로 개별 문자 접근하기
print(text[0])  # Output: P (첫 번째 문자)
print(text[1])  # Output: y (두 번째 문자)
print(text[5])  # Output: n (여섯 번째 문자)

String:  P  y  t  h  o  n
Index:   0  1  2  3  4  5

# negative_indexing.py
text = "Python"
 
print(text[-1])  # Output: n (마지막 문자)
print(text[-2])  # Output: o (끝에서 두 번째)
print(text[-6])  # Output: P (첫 번째 문자)

String:    P  y  t  h  o  n
Positive:  0  1  2  3  4  5
Negative: -6 -5 -4 -3 -2 -1

# index_error.py
text = "Python"
 
# 이것은 문제없음
print(text[5])  # Output: n
 
# 인덱스 6은 존재하지 않기 때문에 에러 발생
# print(text[6])  # IndexError: string index out of range

string[start:stop]

# basic_slicing.py
text = "Python Programming"
 
# 인덱스 0부터 6 직전까지 추출
print(text[0:6])  # Output: Python
 
# 인덱스 7부터 18 직전까지 추출
print(text[7:18])  # Output: Programming
 
# 중간 부분 추출
print(text[7:11])  # Output: Prog

 P  y  t  h  o  n
 0  1  2  3  4  5  6

# omitting_indices.py
text = "Python Programming"
 
# 처음부터 인덱스 6 직전까지
print(text[:6])  # Output: Python
 
# 인덱스 7부터 끝까지
print(text[7:])  # Output: Programming
 
# 전체 문자열 (처음부터 끝까지)
print(text[:])  # Output: Python Programming

# negative_slice_indices.py
text = "Python Programming"
 
# 마지막 11글자
print(text[-11:])  # Output: Programming
 
# 마지막 11글자를 제외한 나머지
print(text[:-11])  # Output: Python
 
# 마지막 7글자
print(text[-7:])  # Output: ramming
 
# 인덱스 7부터 끝에서 세 번째 글자 직전까지
print(text[7:-3])  # Output: Programm (마지막 'ing' 직전에서 멈춤)

# removing_suffix.py
filename = "document.txt"
 
# 마지막 4글자(.txt)를 제외한 모든 부분 얻기
name_without_extension = filename[:-4]
print(name_without_extension)  # Output: document

string[start:stop:step]

# slicing_with_step.py
text = "Python Programming"
 
# 문자열 전체에서 한 글자마다 하나씩 건너뛰기 (2글자 간격)
print(text[::2])  # Output: Pto rgamn
 
# 인덱스 0부터 6 직전까지 2글자 간격
print(text[0:6:2])  # Output: Pto
 
# 3글자 간격
print(text[::3])  # Output: Ph oai

# reversing_strings.py
text = "Python"
 
# 전체 문자열 뒤집기
reversed_text = text[::-1]
print(reversed_text)  # Output: nohtyP
 
# 실용 예: 회문(palindrome) 검사
word = "radar"
if word == word[::-1]:
    print(f"{word} is a palindrome!")  # Output: radar is a palindrome!

# safe_slicing.py
text = "Python"
 
# 모두 에러 없이 동작
print(text[0:100])   # Output: Python (끝에서 멈춤)
print(text[10:20])   # Output: (빈 문자열 - 시작이 끝보다 뒤)
print(text[-100:3])  # Output: Pyt (시작이 0으로 조정됨)

# practical_slicing.py
text = "Hello, World!"
 
# 앞 5글자
print(text[:5])  # Output: Hello
 
# 마지막 6글자
print(text[-6:])  # Output: World!
 
# 첫 글자와 마지막 글자를 제외한 모든 글자
print(text[1:-1])  # Output: ello, World
 
# 한 글자씩 건너뛰기
print(text[::2])  # Output: Hlo ol!
 
# 문자열 뒤집기
print(text[::-1])  # Output: !dlroW ,olleH

# method_basics.py
text = "hello"
 
# 문자열에서 메서드 호출하기
result = text.upper()
print(result)  # Output: HELLO
 
# 원래 문자열은 변경되지 않습니다 (이에 대해서는 5.8절에서 설명합니다)
print(text)  # Output: hello

# method_chaining.py
text = "  hello world  "
 
# 여러 메서드 연쇄 호출
result = text.strip().upper().replace("WORLD", "PYTHON")
print(result)  # Output: HELLO PYTHON

# case_methods.py
text = "Python Programming"
 
# 모두 대문자로 변환
print(text.upper())  # Output: PYTHON PROGRAMMING
 
# 모두 소문자로 변환
print(text.lower())  # Output: python programming
 
# 첫 글자만 대문자, 나머지는 소문자
print(text.capitalize())  # Output: Python programming
 
# 각 단어의 첫 글자를 대문자로
print(text.title())  # Output: Python Programming

# case_normalization.py
# 사용자 입력을 흉내 냄
user_input = "YES"
 
# 대소문자에 상관없는 비교
if user_input.lower() == "yes":
    print("User confirmed!")  # Output: User confirmed!
 
# 또 다른 방식: upper() 사용
command = "start"
if command.upper() == "START":
    print("Starting process...")  # Output: Starting process...

# title_case.py
name = "john smith"
print(name.title())  # Output: John Smith
 
book = "the great gatsby"
print(book.title())  # Output: The Great Gatsby

# title_limitations.py
text = "it's a beautiful day"
print(text.title())  # Output: It'S A Beautiful Day (S에 대문자 주의)
 
# 더 정교한 제목 표기는 별도의 로직이 필요할 수 있습니다

# capitalize_examples.py
sentence = "python is great"
print(sentence.capitalize())  # Output: Python is great
 
# 주의: 첫 글자만 대문자
multi_word = "hello world"
print(multi_word.capitalize())  # Output: Hello world (Hello World가 아님)

# case_checking.py
text1 = "HELLO"
text2 = "hello"
text3 = "Hello World"
 
# 모든 문자가 대문자인지 확인
print(text1.isupper())  # Output: True
print(text2.isupper())  # Output: False
 
# 모든 문자가 소문자인지 확인
print(text1.islower())  # Output: False
print(text2.islower())  # Output: True
 
# 문자열이 title case 인지 확인
print(text3.istitle())  # Output: True
print(text2.istitle())  # Output: False

# case_checking_conditions.py
password = "SECRET123"
 
if password.isupper():
    print("Password is all uppercase")  # Output: Password is all uppercase

# whitespace_removal.py
text = "   Hello, World!   "
 
# 양쪽 끝의 공백 제거
print(text.strip())  # Output: Hello, World!
 
# 왼쪽(시작 부분)의 공백 제거
print(text.lstrip())  # Output: Hello, World!   
 
# 오른쪽(끝 부분)의 공백 제거
print(text.rstrip())  # Output:    Hello, World!

# cleaning_input.py
# 여분의 공백이 있는 사용자 입력을 흉내 냄
user_name = "  John Smith  "
 
# 입력 정리
clean_name = user_name.strip()
print(f"Welcome, {clean_name}!")  # Output: Welcome, John Smith!

# strip_all_whitespace.py
text = "\n\t  Hello  \t\n"
print(repr(text))  # Output: '\n\t  Hello  \t\n'
 
cleaned = text.strip()
print(repr(cleaned))  # Output: 'Hello'

# strip_edges_only.py
text = "  Hello   World  "
print(text.strip())  # Output: Hello   World (중간의 공백은 그대로)

# 여러 다른 문자 제거하기
text = "...Hello!!!"
cleaned = text.strip(".!")
print(cleaned)  # Output: Hello

# strip_character_set.py
text = "xxxyyyHelloyyyxxx"
 
# 양끝에서 x 또는 y 를 모두 제거
result = text.strip("xy")
print(result)  # Output: Hello

# practical_text_cleaning.py
# 사용자 입력 정리 및 표준화
user_email = "  JohnSmith@EXAMPLE.com  "
clean_email = user_email.strip().lower()
print(clean_email)  # Output: johnsmith@example.com
 
# 이름을 올바른 형식으로 만들기
raw_name = "  john smith  "
formatted_name = raw_name.strip().title()
print(formatted_name)  # Output: John Smith
 
# 명령 처리 (대소문자 무시)
command = "  START  "
if command.strip().upper() == "START":
    print("Command recognized!")  # Output: Command recognized!

# find_method.py
text = "Python is great. Python is powerful."
 
# "Python" 이 처음 나타나는 위치 찾기
position = text.find("Python")
print(position)  # Output: 0 (문자열의 시작 위치)
 
# "great" 찾기
position = text.find("great")
print(position)  # Output: 10
 
# 존재하지 않는 문자열 찾기
position = text.find("Java")
print(position)  # Output: -1 (찾지 못함)

# safe_searching.py
text = "Hello, World!"
 
# 부분 문자열이 존재하는지 확인
if text.find("World") != -1:
    print("Found 'World'!")  # Output: Found 'World'!
 
if text.find("Python") == -1:
    print("'Python' not found")  # Output: 'Python' not found

# find_with_start.py
text = "Python is great. Python is powerful."
 
# 첫 번째 등장 위치
first = text.find("Python")
print(first)  # Output: 0
 
# 첫 번째 이후 위치에서 다음 "Python" 찾기
second = text.find("Python", first + 1)
print(second)  # Output: 17

# index_method.py
text = "Hello, World!"
 
# 이 호출은 문제없음
position = text.index("World")
print(position)  # Output: 7
 
# 이것은 ValueError 를 발생시킵니다:
# position = text.index("Python")  # ValueError: substring not found

# choosing_find_vs_index.py
text = "Python Programming"
 
# 안전한 확인을 위해 find() 사용
if text.find("Java") != -1:
    print("Found Java")
else:
    print("Java not found")  # Output: Java not found
 
# 반드시 존재한다고 알 때는 index() 사용
position = text.index("Python")  # Python 이 있다는 것을 알고 있음
print(f"Found at position {position}")  # Output: Found at position 0

# rfind_method.py
text = "Python is great. Python is powerful."
 
# "Python" 의 마지막 등장 위치 찾기
last_position = text.rfind("Python")
print(last_position)  # Output: 17
 
# find() 는 첫 번째 등장 위치를 반환
first_position = text.find("Python")
print(first_position)  # Output: 0

# last_occurrence.py
filename = "document.backup.txt"
 
# 마지막 점(.) 찾기 (파일 확장자 얻기)
last_dot = filename.rfind(".")
if last_dot != -1:
    extension = filename[last_dot:]
    print(extension)  # Output: .txt

# count_method.py
text = "Python is great. Python is powerful. Python is fun."
 
# "Python" 이 몇 번 등장하는지 세기
count = text.count("Python")
print(count)  # Output: 3
 
# 문자 하나를 세기
letter_count = text.count("o")
print(f"Letter 'o' appears {letter_count} times")  # Output: Letter 'o' appears 4 times

# count_in_range.py
text = "abcabcabc"
 
# 전체 문자열에서 "abc" 세기
total = text.count("abc")
print(total)  # Output: 3
 
# 처음 6글자에서만 "abc" 세기
partial = text.count("abc", 0, 6)
print(partial)  # Output: 2

# replace_method.py
text = "I love Java. Java is great."
 
# 모든 "Java" 를 "Python" 으로 교체
new_text = text.replace("Java", "Python")
print(new_text)  # Output: I love Python. Python is great.
 
# 원래 문자열은 변경되지 않음
print(text)  # Output: I love Java. Java is great.

# limited_replace.py
text = "one one one one"
 
# 처음 2번만 교체
result = text.replace("one", "two", 2)
print(result)  # Output: two two one one

# case_sensitive_replace.py
text = "Python is great. python is powerful."
 
# 대문자 P인 "Python" 만 교체
result = text.replace("Python", "Java")
print(result)  # Output: Java is great. python is powerful.

# case_insensitive_approach.py
text = "Python is great. python is powerful."
 
# 모두 소문자로 바꾼 뒤 교체하면, 원래의 대소문자 정보는 사라짐
result = text.lower().replace("python", "java")
print(result)  # Output: java is great. java is powerful.

# practical_search_replace.py
# 데이터 정리: 불필요한 문자 제거
phone = "123-456-7890"
clean_phone = phone.replace("-", "")
print(clean_phone)  # Output: 1234567890
 
# 단어 가리기(검열)
message = "This is a bad word and another bad word."
censored = message.replace("bad", "***")
print(censored)  # Output: This is a *** word and another *** word.
 
# 파일 확장자 추출
filename = "document.txt"
dot_position = filename.rfind(".")
if dot_position != -1:
    extension = filename[dot_position + 1:]
    print(f"File type: {extension}")  # Output: File type: txt
 
# 단어 등장 횟수 세기(단순한 방법)
text = "Python is fun. I love Python. Python rocks!"
word = "Python"
occurrences = text.count(word)
print(f"'{word}' appears {occurrences} times")  # Output: 'Python' appears 3 times

# string_to_number.py
# 문자열을 정수로 변환
age_text = "25"
age = int(age_text)
print(age)        # Output: 25
print(type(age))  # Output: <class 'int'>
 
# 문자열을 실수로 변환
price_text = "19.99"
price = float(price_text)
print(price)        # Output: 19.99
print(type(price))  # Output: <class 'float'>

# user_input_conversion.py
# 사용자 입력을 흉내 냄 (실제 코드에서는 input() 사용)
user_age = "30"
user_height = "5.9"
 
# 숫자로 변환해서 수학 연산 가능하게 만들기
age = int(user_age)
height = float(user_height)
 
# 이제 계산을 수행할 수 있음
print(f"In 10 years, you'll be {age + 10}")  # Output: In 10 years, you'll be 40
print(f"Your height in meters: {height * 0.3048:.2f}")  # Output: Your height in meters: 1.80

# conversion_errors.py
# 이것들은 문제없음
print(int("123"))      # Output: 123
print(float("3.14"))   # Output: 3.14
 
# 이것들은 ValueError 를 발생시킴:
# print(int("hello"))     # ValueError: invalid literal for int()
# print(int("12.5"))      # ValueError: invalid literal for int() with base 10
# print(float("12.5.3"))  # ValueError: could not convert string to float

# whitespace_handling.py
# 공백이 있어도 모두 잘 동작함
print(int("  42  "))      # Output: 42
print(float("  3.14  "))  # Output: 3.14
 
# 안전을 위해 strip() 과 변환을 결합
user_input = "  100  "
number = int(user_input.strip())
print(number)  # Output: 100

# number_to_string.py
age = 25
height = 5.9
 
# 숫자를 문자열로 변환
age_text = str(age)
height_text = str(height)
 
print(type(age_text))     # Output: <class 'str'>
print(type(height_text))  # Output: <class 'str'>
 
# 이제 다른 문자열과 이어 붙일 수 있음
message = "I am " + str(age) + " years old"
print(message)  # Output: I am 25 years old

# concatenation_with_numbers.py
score = 95
total = 100
 
# 이어 붙이기를 위해서는 숫자를 문자열로 변환해야 함
result = "Score: " + str(score) + "/" + str(total)
print(result)  # Output: Score: 95/100
 
# 대안: f-string 사용 (6장에서 자세히 다룹니다)
result = f"Score: {score}/{total}"
print(result)  # Output: Score: 95/100

# int_float_conversion.py
# 실수에서 정수로 (소수 부분을 잘라냄)
price = 19.99
price_int = int(price)
print(price_int)  # Output: 19 (소수 부분이 잘리고, 반올림되지 않음)
 
# 정수에서 실수로
age = 25
age_float = float(age)
print(age_float)  # Output: 25.0

# truncation_not_rounding.py
print(int(3.9))   # Output: 3 (4가 아님!)
print(int(3.1))   # Output: 3
print(int(-3.9))  # Output: -3 (0을 향해 잘라냄)
 
# 반올림하려면 먼저 round() 를 사용합니다 (4장에서 다룹니다)
print(int(round(3.9)))  # Output: 4

# practical_conversions.py
# 사용자 입력 읽고 처리하기
# (input() 을 흉내 냄 - 실제 코드에서는 input() 사용)
user_input = "42"
 
# 숫자로 변환해서 계산 수행
number = int(user_input)
doubled = number * 2
print(f"Double of {number} is {doubled}")  # Output: Double of 42 is 84
 
# 형식 있는 출력 만들기
name = "John"
age = 30
height = 5.9
 
# 방법 1: 숫자를 문자열로 변환
info = name + " is " + str(age) + " years old and " + str(height) + " feet tall"
print(info)  # Output: John is 30 years old and 5.9 feet tall
 
# 방법 2: f-string 사용 (더 읽기 쉬움 - 6장에서 다룸)
info = f"{name} is {age} years old and {height} feet tall"
print(info)  # Output: John is 30 years old and 5.9 feet tall
 
# 파일에서 읽은 데이터 처리 (미리보기)
data_line = "100,200,300"  # CSV 파일에서 읽은 한 줄을 흉내 냄
numbers = data_line.split(",")  # 문자열 리스트로 분리
total = int(numbers[0]) + int(numbers[1]) + int(numbers[2])
print(f"Total: {total}")  # Output: Total: 600

# conversion_pitfalls.py
# 함정 1: 숫자가 아닌 문자열을 변환하려고 시도
# text = "hello"
# number = int(text)  # ValueError!
 
# 함정 2: 변환하지 않고 바로 산술 연산을 하려는 경우
age_text = "25"
# next_year = age_text + 1  # TypeError: can only concatenate str to str
 
# 올바른 방법:
age = int(age_text)
next_year = age + 1
print(next_year)  # Output: 26
 
# 함정 3: int() 사용으로 정밀도 손실
price = 19.99
price_int = int(price)  # 20이 아니라 19가 됨!
print(price_int)  # Output: 19
 
# 함정 4: 콤마나 통화 기호가 있는 문자열을 그대로 변환하려는 경우
# price_text = "$1,234.56"
# price = float(price_text)  # ValueError!
 
# 먼저 문자열을 정리해야 합니다:
price_text = "$1,234.56"
clean_price = price_text.replace("$", "").replace(",", "")
price = float(clean_price)
print(price)  # Output: 1234.56

# in_operator.py
text = "Python is a powerful programming language"
 
# 부분 문자열이 존재하는지 확인
print("Python" in text)      # Output: True
print("powerful" in text)    # Output: True
print("Java" in text)        # Output: False

# in_vs_find.py
text = "Hello, World!"
 
# in 사용 (명확하고 읽기 좋음)
if "World" in text:
    print("Found World!")  # Output: Found World!
 
# find 사용 (덜 읽기 좋음)
if text.find("World") != -1:
    print("Found World!")  # Output: Found World!

# case_sensitivity.py
text = "Python Programming"
 
print("python" in text)   # Output: False (소문자 'p')
print("Python" in text)   # Output: True (대문자 'P')
 
# 대소문자를 무시하고 검사하려면 먼저 소문자로 변환
print("python" in text.lower())  # Output: True

# not_in_operator.py
text = "Python is great"
 
print("Java" not in text)     # Output: True (Java 는 없음)
print("Python" not in text)   # Output: False (Python 은 있음)

# validation_examples.py
# 사용자 이름에 허용되지 않는 공백이 있는지 검사
username = "john_smith"
 
if " " not in username:
    print("Username is valid (no spaces)")  # Output: Username is valid (no spaces)

# string_checking_methods.py
text = "Python"
 
# 특정 문자열로 시작하는지 확인
print(text.startswith("Py"))   # Output: True
print(text.startswith("Ja"))   # Output: False
 
# 특정 문자열로 끝나는지 확인
print(text.endswith("on"))     # Output: True
print(text.endswith("ing"))    # Output: False
 
# in 을 사용하는 것보다 더 정확한 경우가 많음
filename = "report.txt"
print(filename.endswith(".txt"))  # Output: True
print(".txt" in filename)         # Output: True (하지만 덜 정확한 방법)
 
# startswith/endswith 는 여러 옵션을 한 번에 검사할 수 있음
filename = "document.pdf"
print(filename.endswith((".pdf", ".doc", ".txt")))  # Output: True

# immutability_basics.py
text = "Hello"
 
# 이 코드는 문자열을 바꾸는 것처럼 보이지만 실제로는 그렇지 않습니다
text = text + " World"
print(text)  # Output: Hello World
 
# 실제로는 다음과 같은 일이 일어납니다:
# 1. Python은 새로운 문자열 "Hello World" 를 생성합니다
# 2. 변수 'text' 는 이제 이 새로운 문자열을 가리킵니다
# 3. 원래의 "Hello" 문자열은 (가비지 컬렉션되기 전까지) 그대로 존재합니다

# cannot_modify_characters.py
text = "Hello"
 
# 이것은 에러를 발생시킵니다:
# text[0] = "J"  # TypeError: 'str' object does not support item assignment
 
# 대신 새로운 문자열을 만들어야 합니다
text = "J" + text[1:]
print(text)  # Output: Jello

# lists_are_mutable.py
# 리스트 미리보기 (13장에서 자세히 다룸)
numbers = [1, 2, 3]
numbers[0] = 10  # 리스트에서는 문제가 없음
print(numbers)   # Output: [10, 2, 3]
 
# 하지만 문자열은 허용하지 않습니다:
text = "Hello"
# text[0] = "J"  # 문자열에서는 TypeError!

# methods_return_new_strings.py
original = "hello world"
 
# 이 메서드들은 모두 새 문자열을 반환합니다
uppercase = original.upper()
capitalized = original.capitalize()
replaced = original.replace("world", "Python")
 
# 원래 문자열은 변경되지 않음
print(original)      # Output: hello world
print(uppercase)     # Output: HELLO WORLD
print(capitalized)   # Output: Hello world
print(replaced)      # Output: hello Python

# keeping_changes.py
text = "  hello  "
 
# 잘못된 예: 결과를 사용하지 않음
text.strip()
print(text)  # Output:   hello   (공백이 그대로 남아 있음!)
 
# 올바른 예: 결과를 할당
text = text.strip()
print(text)  # Output: hello (공백이 제거됨)

# common_mistake.py
message = "python programming"
 
# 실수: 메서드를 호출하지만 결과를 사용하지 않음
message.upper()
message.replace("python", "Python")
print(message)  # Output: python programming (변경되지 않음!)
 
# 올바른 방법: 결과를 할당
message = message.upper()
message = message.replace("PYTHON", "Python")
print(message)  # Output: Python PROGRAMMING

# safe_sharing.py
original = "Hello"
copy = original  # 두 변수 모두 같은 문자열을 가리킴
 
# 문자열은 불변이기 때문에, 이렇게 공유해도 안전합니다
copy = copy + " World"
 
print(original)  # Output: Hello (변경되지 않음)
print(copy)      # Output: Hello World (새 문자열)

# new_objects.py
text = "Python"
 
# 각 연산은 새로운 문자열 객체를 생성
result1 = text.upper()
result2 = text.lower()
result3 = text.replace("P", "J")
 
# 모두 다른 객체
print(id(text))     # 어떤 메모리 주소
print(id(result1))  # 다른 메모리 주소
print(id(result2))  # 또 다른 메모리 주소
print(id(result3))  # 또 다른 메모리 주소

# inefficient_string_building.py
# 이 코드는 많은 임시 문자열 객체를 생성합니다
result = ""
for i in range(5):
    result = result + str(i)  # 매번 새로운 문자열 생성
print(result)  # Output: 01234
 
# 더 효율적인 방법 (많은 이어 붙이기가 필요할 때):
# 리스트와 join 사용 (6장에서 배웁니다)
parts = []
for i in range(5):
    parts.append(str(i))
result = "".join(parts)
print(result)  # Output: 01234

# safe_function_arguments.py
def process_text(text):
    # 어떤 연산이든 새 문자열을 생성합니다
    text = text.upper()
    text = text.replace("A", "X")
    return text
 
original = "banana"
result = process_text(original)
 
print(original)  # Output: banana (변경되지 않음)
print(result)    # Output: BXNXNX (변경된 버전)