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 (2 文字目)
print(text[5])  # Output: n (6 文字目)

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 (最後から 2 番目)
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 から、末尾から 3 文字目の手前まで
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"
 
# 文字列全体から 1 文字おきに取り出す
print(text[::2])  # Output: Pto rgamn
 
# インデックス 0 から 6 まで、1 文字おき
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
 
# 実用例: 回文かどうかの判定
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: (empty string - start が末尾より後ろ)
print(text[-100:3])  # Output: Pyt (start が 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
 
# 1 文字おき
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
 
# 最初の 1 文字を大文字にし、残りを小文字にする
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
 
# 最初の 1 文字だけが大文字になる点に注意
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
 
# 文字列がタイトルケースかどうか
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
 
# 最初の出現位置の次から検索して、2 回目の出現位置を探す
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() との比較 (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
 
# 1 文字のカウント
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."
 
# これは "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
# float から int への変換 (小数部分を切り捨てる)
price = 19.99
price_int = int(price)
print(price_int)  # Output: 19 (小数部分は削除され、丸められない)
 
# int から float への変換
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 ファイルの 1 行をシミュレート
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 (加工されたバージョン)