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 = r"C:\new\test"
print(raw)  # Output: C:\new\test

# windows_paths.py
# 不使用原始字符串时,你需要对每个反斜杠转义
path1 = "C:\\Users\\John\\Documents\\file.txt"
 
# 使用原始字符串时,反斜杠可以自然书写
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 (first character)
print(text[1])  # Output: y (second character)
print(text[5])  # Output: n (sixth character)

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

# negative_indexing.py
text = "Python"
 
print(text[-1])  # Output: n (last character)
print(text[-2])  # Output: o (second-to-last)
print(text[-6])  # Output: P (first character)

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"
 
# 整个字符串中每隔一个取一个字符
print(text[::2])  # Output: Pto rgamn
 
# 从索引 0 到 6,每隔一个取一个字符
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 is beyond end)
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
 
# 检查是否为标题格式
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
 
# 在第一次出现之后查找下一次出现
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
 
# 统计某个字符
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)  # 变成 19,不是 20!
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 (修改后的版本)