# 输出字符串
print("Hello, World!")

# 输出数字
print(42)

# 输出变量
name = "Python"
print(name)

# 连接字符串
print("Hello, " + "World!")

# 连接字符串和变量
name = "Python"
print("Hello, " + name + "!")

# 注意：+运算符要求两边类型一致
# 错误示例：print("The answer is " + 42)  # 会报错
# 正确示例：print("The answer is " + str(42))  # 需要转换为字符串

# 用逗号分隔多个值
print("Hello", "World")  # 输出：Hello World

# 混合不同类型
name = "Python"
age = 30
print("Name:", name, "Age:", age)  # 输出：Name: Python Age: 30

# 与+的区别
print("Hello" + "World")  # 输出：HelloWorld（无空格）
print("Hello", "World")  # 输出：Hello World（有空格）

# 使用sep参数
print("a", "b", "c", sep=", ")  # 输出：a, b, c

# 使用end参数
print("Hello", end=" ")
print("World")  # 输出：Hello World（在同一行）

# 基本输入
name = input()
print("Hello, " + name)

# 带提示信息的输入
name = input("请输入你的名字：")
print("你好，" + name)

# 输入数字需要转换类型
age = input("请输入你的年龄：")
age = int(age)  # 转换为整数
print("你明年就" + str(age + 1) + "岁了")

# 清晰的提示
username = input("请输入用户名：")
password = input("请输入密码：")

# 提示中包含默认值
default_name = "Guest"
name = input(f"请输入你的名字（默认：{default_name}）：")
if not name:
    name = default_name
print("你好，" + name)

# 这是一个单行注释
print("Hello, World!")  # 行尾注释

# 注释可以解释代码的功能
x = 10  # 定义变量x并赋值为10
y = 20  # 定义变量y并赋值为20
print(x + y)  # 输出x和y的和

'''这是一个多行注释
可以跨越多行
用于解释复杂的代码块
'''

"""这也是一个多行注释
使用双引号三引号
效果与单引号三引号相同
"""

print("Hello, World!")

def calculate_area(radius):
    """计算圆的面积

    参数:
        radius: 圆的半径

    返回:
        圆的面积
    """
    import math
    return math.pi * radius ** 2

# 调用函数
area = calculate_area(5)
print(f"半径为5的圆的面积是: {area}")

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Python基础示例：print、input和注释的使用
"""

# 获取用户输入
name = input("请输入你的名字：")
age = input("请输入你的年龄：")

# 转换年龄为整数
try:
    age = int(age)
except ValueError:
    print("年龄输入错误，使用默认值18")
    age = 18

# 计算出生年份
import datetime
current_year = datetime.datetime.now().year
birth_year = current_year - age

# 输出结果
print("\n--- 个人信息 ---")
print("姓名:", name)
print("年龄:", age)
print("出生年份:", birth_year)
print("\n欢迎学习Python！")

# f-string基本用法
name = "Alice"
age = 25
print(f"My name is {name}, and I am {age} years old.")
# 输出：My name is Alice, and I am 25 years old.

# f-string中的表达式
x = 10
y = 20
print(f"The sum of {x} and {y} is {x + y}.")
# 输出：The sum of 10 and 20 is 30.

# 调用函数
def get_greeting():
    return "Hello"

print(f"{get_greeting()}, world!")
# 输出：Hello, world!

# 数字格式化
pi = 3.1415926535
print(f"Pi is approximately {pi:.2f}.")  # 保留两位小数
# 输出：Pi is approximately 3.14.

# 宽度控制
number = 42
print(f"The number is {number:5d}.")  # 宽度为5
# 输出：The number is    42.

# 对齐
print(f"Left-aligned: {number:<10d}")  # 左对齐
print(f"Right-aligned: {number:>10d}")  # 右对齐
print(f"Centered: {number:^10d}")  # 居中对齐

# 嵌套f-string
name = "Alice"
age = 25
print(f"{name} is {age} years old, which is {f'{age * 12}'} months.")
# 输出：Alice is 25 years old, which is 300 months.

# 字典
person = {"name": "Alice", "age": 25}
print(f"Name: {person['name']}, Age: {person['age']}")
# 输出：Name: Alice, Age: 25

# 对象
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 25)
print(f"Name: {person.name}, Age: {person.age}")
# 输出：Name: Alice, Age: 25

# 转义大括号
print(f"{{Hello}} world")
# 输出：{Hello} world

# 多行f-string
message = f"""
Name: {name}
Age: {age}
Occupation: Programmer
"""
print(message)

# str.format()
name = "Alice"
age = 25
print("My name is {}, and I am {} years old.".format(name, age))

# f-string
print(f"My name is {name}, and I am {age} years old.")

# %格式化
name = "Alice"
age = 25
print("My name is %s, and I am %d years old." % (name, age))

# f-string
print(f"My name is {name}, and I am {age} years old.")

# 注意引号的使用
print(f"He said, 'Hello!'")
print(f'He said, "Hello!"')

# 避免过于复杂的表达式
# 不推荐：
print(f"The result is {sum([x**2 for x in range(100)])}")

# 推荐：
result = sum([x**2 for x in range(100)])
print(f"The result is {result}")

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Python f-string格式化字符串综合示例
"""

def calculate_area(radius):
    """计算圆的面积"""
    import math
    return math.pi * radius ** 2

def main():
    # 基本用法
    name = "Alice"
    age = 25
    print(f"=== 基本用法 ===")
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"Next year, I'll be {age + 1} years old.")
    
    # 数字格式化
    print(f"\n=== 数字格式化 ===")
    pi = 3.1415926535
    print(f"Pi: {pi:.4f}")  # 保留4位小数
    
    # 宽度和对齐
    print(f"\n=== 宽度和对齐 ===")
    numbers = [1, 10, 100, 1000]
    for num in numbers:
        print(f"Number: {num:5d}")
    
    # 字典和对象
    print(f"\n=== 字典和对象 ===")
    person = {"name": "Bob", "age": 30}
    print(f"Person: {person['name']}, {person['age']}")
    
    # 调用函数
    print(f"\n=== 调用函数 ===")
    radius = 5
    print(f"Area of circle with radius {radius}: {calculate_area(radius):.2f}")

if __name__ == "__main__":
    main()

# 基本用法
text = "  Hello, World!  "
print(f"'{text.strip()}'")  # 输出：'Hello, World!'

# 移除换行符
text = "\nHello\n"
print(f"'{text.strip()}'")  # 输出：'Hello'

# 移除制表符
text = "\tHello\t"
print(f"'{text.strip()}'")  # 输出：'Hello'

# 移除指定的字符
text = "***Hello***"
print(text.strip('*'))  # 输出：Hello

# 移除多个字符
text = "##Hello@@"
print(text.strip('#@'))  # 输出：Hello

# 移除数字
text = "123Hello456"
print(text.strip('0123456789'))  # 输出：Hello

text = "  Hello  "
print(f"'{text.lstrip()}'")  # 输出：'Hello  '
print(f"'{text.rstrip()}'")  # 输出：'  Hello'

name = "  python  "
result = name.strip().title()
print(result)  # 输出：Python

# 更多链式调用
text = "\n\tHello World!   \n"
result = text.strip().lower().replace("world", "python")
print(result)  # 输出：hello python!

# 处理用户输入
username = input("请输入用户名：").strip().lower()
print(f"欢迎, {username}!")

# 处理文件读取
with open("file.txt", "r") as f:
    for line in f:
        line = line.strip()
        if line:
            print(line)

# 数据清洗
data = "  JOHN@EMAIL.COM  "
email = data.strip().lower()
print(email)  # 输出：john@email.com

text = "Hello, World!"

print(text.upper())  # 输出：HELLO, WORLD!
print(text.lower())  # 输出：hello, world!
print(text.title())  # 输出：Hello, World!
print(text.capitalize())  # 输出：Hello, world!
print(text.swapcase())  # 输出：hELLO, wORLD!

text = "Hello, World!"

# 查找
print(text.find("World"))  # 输出：7
print(text.index("World"))  # 输出：7
print(text.count("o"))  # 输出：2

# 替换
print(text.replace("World", "Python"))  # 输出：Hello, Python!

text = "apple,banana,cherry"

# 分割
fruits = text.split(",")
print(fruits)  # 输出：['apple', 'banana', 'cherry']

# 连接
words = ["Hello", "World"]
print(" ".join(words))  # 输出：Hello World
print("-".join(words))  # 输出：Hello-World

text = "Hello123"

print(text.isalpha())  # 输出：False（包含数字）
print(text.isdigit())  # 输出：False
print(text.isalnum())  # 输出：True（全是字母或数字）
print(text.isupper())  # 输出：False
print(text.islower())  # 输出：False
print(text.isspace())  # 输出：False

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
字符串处理综合示例
"""

def process_user_input():
    """处理用户输入"""
    # 获取用户输入
    name = input("请输入姓名：").strip()
    email = input("请输入邮箱：").strip().lower()

    # 验证
    if not name:
        print("姓名不能为空")
        return

    if "@" not in email:
        print("邮箱格式不正确")
        return

    # 格式化输出
    print(f"\n用户信息：")
    print(f"姓名: {name.title()}")
    print(f"邮箱: {email}")

def process_text_file():
    """处理文本文件"""
    # 模拟文本数据
    lines = [
        "  APPLE  ",
        "  BANANA  ",
        "  CHERRY  ",
    ]

    # 处理每一行
    processed = []
    for line in lines:
        # 移除空白，转换为小写，首字母大写
        item = line.strip().lower().title()
        processed.append(item)

    print("\n处理后的水果列表：")
    for i, item in enumerate(processed, 1):
        print(f"{i}. {item}")

def data_cleaning():
    """数据清洗示例"""
    # 原始数据
    data = ["  JOHN@EMAIL.COM  ", "  JANE@EMAIL.COM  ", "  BOB@EMAIL.COM  "]

    # 清洗数据
    cleaned = []
    for item in data:
        email = item.strip().lower()
        cleaned.append(email)

    print("\n清洗后的邮箱列表：")
    for email in cleaned:
        print(f"  {email}")

if __name__ == "__main__":
    process_user_input()
    process_text_file()
    data_cleaning()

text = "  Hello  "
new_text = text.strip()
print(f"原字符串: '{text}'")  # 输出：'  Hello  '（未改变）
print(f"新字符串: '{new_text}'")  # 输出：'Hello'

text = "  \t\nHello  \n\t  "
print(f"'{text.strip()}'")  # 输出：'Hello'

text = "  Hello, World!  "

# 先strip再title
print(text.strip().title())  # 输出：Hello, World!

# 先title再strip
print(text.title().strip())  # 输出：Hello, World!

# 整数和浮点数运算时，整数自动转换为浮点数
result = 10 + 3.5
print(result)  # 输出：13.5
print(type(result))  # 输出：<class 'float'>

# 布尔值与整数运算
result = True + 5
print(result)  # 输出：6
result = False + 10
print(result)  # 输出：10

# 转换为整数
print(int(3.7))  # 输出：3
print(int("42"))  # 输出：42
print(int("1010", 2))  # 二进制转换为整数：输出：10

# 转换为浮点数
print(float(10))  # 输出：10.0
print(float("3.14"))  # 输出：3.14

# 转换为字符串
print(str(42))  # 输出："42"
print(str(3.14))  # 输出："3.14"

# 列表转元组
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出：(1, 2, 3)

# 元组转列表
my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # 输出：[1, 2, 3]

# 列表转集合
my_list = [1, 2, 2, 3, 3]
my_set = set(my_list)
print(my_set)  # 输出：{1, 2, 3}

# 字典键转列表
my_dict = {"a": 1, "b": 2, "c": 3}
keys = list(my_dict.keys())
values = list(my_dict.values())
items = list(my_dict.items())
print(keys)  # 输出：['a', 'b', 'c']
print(values)  # 输出：[1, 2, 3]
print(items)  # 输出：[('a', 1), ('b', 2), ('c', 3)]

# 字符串转列表
text = "hello"
char_list = list(text)
print(char_list)  # 输出：['h', 'e', 'l', 'l', 'o']

# 字符串分割为列表
text = "apple,banana,cherry"
fruits = text.split(",")
print(fruits)  # 输出：['apple', 'banana', 'cherry']

# 列表转字符串
fruits = ['apple', 'banana', 'cherry']
text = ",".join(fruits)
print(text)  # 输出：apple,banana,cherry

x = 10                # 自动推断为int
x = 3.14              # 现在变为float
print(x)              # 输出：3.14

# 使用构造函数
x = int(3.14)      # 输出：3
y = float(10)      # 输出：10.0
z = str(42)        # 输出："42"

# 自动检查范围
x = 100000
# Python中字符是Unicode，不存在溢出问题
c = chr(x)
print(c)  # 输出：成功的Unicode字符

# 字符串转整数失败
try:
    result = int("abc")
except ValueError as e:
    print(f"转换失败: {e}")

# 安全转换
def safe_int(value, default=0):
    try:
        return int(value)
    except (ValueError, TypeError):
        return default

print(safe_int("123"))    # 输出：123
print(safe_int("abc"))    # 输出：0
print(safe_int(None))     # 输出：0

# 浮点数转整数
print(int(3.9999))  # 输出：3（直接截断，不是四舍五入）
print(int(-3.9999))  # 输出：-3

# 四舍五入
print(round(3.5))  # 输出：4
print(round(3.4))  # 输出：3
print(round(-3.5))  # 输出：-4（银行家舍入）

# 字符串与字节的转换
text = "你好"
encoded = text.encode('utf-8')
print(encoded)  # 输出：b'\xe4\xbd\xa0\xe5\xa5\xbd'

decoded = encoded.decode('utf-8')
print(decoded)  # 输出：你好

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Python类型转换综合示例
"""

def type_conversion_demo():
    """演示各种类型转换"""

    # 基本类型转换
    print("=== 基本类型转换 ===")
    print(f"int(3.14) = {int(3.14)}")
    print(f"float(10) = {float(10)}")
    print(f"str(100) = {str(100)}")
    print(f"bool(1) = {bool(1)}")
    print(f"bool(0) = {bool(0)}")

    # 容器类型转换
    print("\n=== 容器类型转换 ===")
    my_list = [1, 2, 3, 3, 4]
    print(f"list to set: {set(my_list)}")
    print(f"list to tuple: {tuple(my_list)}")
    print(f"list to str: {''.join(map(str, my_list))}")

    # 字符串转换
    print("\n=== 字符串转换 ===")
    text = "123"
    print(f"str to int: {int(text)}")
    print(f"str to float: {float(text)}")

    text = "hello world"
    print(f"upper: {text.upper()}")
    print(f"title: Python类型转换机制及与C++对比

def safe_conversion():
    """安全转换示例"""

    def to_int(value, default=0):
        """安全转换为整数"""
        try:
            return int(value)
        except (ValueError, TypeError):
            return default

    def to_float(value, default=0.0):
        """安全转换为浮点数"""
        try:
            return float(value)
        except (ValueError, TypeError):
            return default

    # 测试
    test_values = ["123", "3.14", "abc", None, "", [1, 2, 3]]

    print("\n=== 安全转换测试 ===")
    for val in test_values:
        print(f"to_int({val}) = {to_int(val)}, to_float({val}) = {to_float(val)}")

def practice():
    """练习题"""
    print("\n=== 练习 ===")

    # 问题1：如何将二进制字符串转换为整数
    binary = "1010"
    print(f"二进制 '{binary}' 转整数: {int(binary, 2)}")

    # 问题2：如何将整数转换为十六进制字符串
    num = 255
    print(f"整数 {num} 转十六进制: {hex(num)}")

    # 问题3：如何将字符串列表转换为整数列表
    str_list = ["1", "2", "3"]
    int_list = [int(x) for x in str_list]
    print(f"字符串列表 {str_list} 转整数列表: {int_list}")

if __name__ == "__main__":
    type_conversion_demo()
    safe_conversion()
    practice()

# 处理前后空白
text = "  123  "
print(int(text.strip()))  # 输出：123

# 处理逗号
text = "1,234"
print(int(text.replace(",", "")))  # 输出：1234

# 处理货币格式
price = "$19.99"
cleaned = price.replace("$", "").replace(",", "")
print(float(cleaned))  # 输出：19.99

# 二进制
print(int("1010", 2))  # 输出：10
print(bin(10))  # 输出：0b1010

# 十六进制
print(int("FF", 16))  # 输出：255
print(hex(255))  # 输出：0xff

# 八进制
print(int("77", 8))  # 输出：63
print(oct(63))  # 输出：0o77

round(number, ndigits)

# 基本四舍五入
print(round(3.14159))      # 输出：3
print(round(3.5))          # 输出：4
print(round(3.14159, 2))   # 输出：3.14
print(round(3.14159, 4))   # 输出：3.1416

# 负数四舍五入到整数
print(round(-3.5))         # 输出：-4
print(round(-3.4))         # 输出：-3

# 负数四舍五入到小数位
print(round(-3.14159, 2))  # 输出：-3.14
print(round(-3.14159, 3))  # 输出：-3.142

# 浮点数精度问题
print(round(2.5))   # 输出：2（不是3！）
print(round(1.5))   # 输出：2

# 原因：浮点数在计算机中无法精确表示
print(0.1 + 0.2)    # 输出：0.30000000000000004

# 银行家舍入规则：四舍六入五成双
print(round(2.5))   # 输出：2
print(round(3.5))   # 输出：4
print(round(4.5))   # 输出：4
print(round(5.5))   # 输出：6

# 原理：当要舍弃的部分恰好是0.5时，
# 看前一位是奇数则进位，偶数则舍弃

from decimal import Decimal, ROUND_HALF_UP

# 使用Decimal进行精确运算
print(round(Decimal('2.5')))  # 输出：3

# 指定舍入模式
result = Decimal('2.5').quantize(Decimal('1'), rounding=ROUND_HALF_UP)
print(result)  # 输出：3

from decimal import Decimal, ROUND_HALF_UP

def calculate_price(price, tax_rate):
    """计算含税价格"""
    p = Decimal(str(price))
    t = Decimal(str(tax_rate))
    total = (p * (1 + t)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
    return total

# 测试
print(calculate_price(99.99, 0.07))  # 输出：106.99
print(calculate_price(100.00, 0.05))  # 输出：105.00

from decimal import Decimal, ROUND_HALF_UP

def calculate_percentage(value, total):
    """计算百分比"""
    if total == 0:
        return Decimal('0.00')
    percentage = (Decimal(str(value)) / Decimal(str(total)) * 100)
    return percentage.quantize(Decimal('0.1'), rounding=ROUND_HALF_UP)

# 测试
print(calculate_percentage(1, 3))   # 输出：33.3
print(calculate_percentage(2, 3))   # 输出：66.7

from decimal import Decimal

def calculate_average(numbers):
    """计算平均值并四舍五入"""
    if not numbers:
        return 0
    total = sum(Decimal(str(n)) for n in numbers)
    avg = total / len(numbers)
    return float(round(avg, 2))

# 测试
print(calculate_average([1, 2, 3, 4, 5]))  # 输出：3.0
print(calculate_average([1.5, 2.5, 3.5]))   # 输出：2.5

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
四舍五入综合示例
"""
from decimal import Decimal, ROUND_HALF_UP

def basic_round_demo():
    """基本round函数演示"""
    print("=== 基本round函数 ===")
    print(f"round(3.14159) = {round(3.14159)}")
    print(f"round(3.14159, 2) = {round(3.14159, 2)}")
    print(f"round(3.14159, 4) = {round(3.14159, 4)}")

def precision_demo():
    """精度问题演示"""
    print("\n=== 精度问题 ===")
    print(f"0.1 + 0.2 = {0.1 + 0.2}")  # 不是0.3
    print(f"round(2.675, 2) = {round(2.675, 2)}")  # 不是2.68

def decimal_demo():
    """Decimal精确计算演示"""
    print("\n=== Decimal精确计算 ===")

    # 基本用法
    print(f"Decimal('2.5') = {Decimal('2.5')}")
    print(f"round(Decimal('2.5')) = {round(Decimal('2.5'))}")

    # 四舍五入到指定位数
    num = Decimal('3.14159')
    print(f"quantize(Decimal('0.01')) = {num.quantize(Decimal('0.01'))}")
    print(f"quantize(Decimal('0.001')) = {num.quantize(Decimal('0.001'))}")

def financial_calculation():
    """金融计算示例"""
    print("\n=== 金融计算 ===")

    def format_currency(amount):
        """格式化货币"""
        return Decimal(str(amount)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)

    # 商品价格
    items = [
        {"name": "苹果", "price": 3.50, "quantity": 2},
        {"name": "香蕉", "price": 2.99, "quantity": 3},
        {"name": "橙子", "price": 4.25, "quantity": 1},
    ]

    subtotal = sum(Decimal(str(item['price'])) * item['quantity'] for item in items)
    tax = subtotal * Decimal('0.07')
    total = subtotal + tax

    print(f"小计: ${format_currency(subtotal)}")
    print(f"税 (7%): ${format_currency(tax)}")
    print(f"总计: ${format_currency(total)}")

if __name__ == "__main__":
    basic_round_demo()
    precision_demo()
    decimal_demo()
    financial_calculation()

# 不好：使用round()
price = 0.01 * 3
print(round(price, 2))  # 可能得到0.03或0.04

# 好：使用Decimal
from decimal import Decimal
price = Decimal('0.01') * 3
print(price)  # 精确的0.03

# Python的round使用银行家舍入
# 不是传统的"四舍五入"

# 传统四舍五入：
# round(2.5) = 3
# round(3.5) = 4

# Python银行家舍入：
# round(2.5) = 2（因为2是偶数）
# round(3.5) = 4（因为3是奇数）

# 对列表中的数值四舍五入
numbers = [1.234, 2.567, 3.891]
rounded = [round(n, 2) for n in numbers]
print(rounded)  # 输出：[1.23, 2.57, 3.89]

# 使用map
rounded = list(map(lambda x: round(x, 2), numbers))
print(rounded)  # 输出：[1.23, 2.57, 3.89]

# Python函数定义
def greet():
    print("Hello, World!")

# 调用函数
greet()  # 输出：Hello, World!

# 带参数的函数
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # 输出：Hello, Alice!

# 多个参数
def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 输出：8

# 默认参数
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")  # 输出：Hello, Alice!
greet("Bob", "Hi")  # 输出：Hi, Bob!

# 默认参数要紧跟在必需参数后面
# 错误示例：def func(a=1, b)  # SyntaxError

# 关键字参数
def introduce(name, age, city):
    print(f"I am {name}, {age} years old, from {city}")

# 使用关键字参数调用
introduce(age=25, name="Alice", city="Beijing")

# Python函数定义
def add(a, b):
    return a + b

def func():
    if condition:
        do_something()
    else:
        do_other()

# Python不需要指定返回类型
def get_value():
    return 42

# 没有返回值的函数返回None
def print_message():
    print("Hello")

print(print_message())  # 输出：Hello\nNone

# 正确的缩进
def correct_indent():
    print("This is inside the function")
    if True:
        print("This is inside the if block")
    print("Back to the function level")

# 错误的缩进会导致SyntaxError
# def wrong_indent():
# print("This will cause an error")

# 4个空格是PEP 8推荐的标准
def four_spaces():
    print("Four spaces is standard")

# 也可以使用Tab，但不要混用
def tab_indent():
        print("Tab indentation")

def outer_function():
    print("Outer function")

    def inner_function():
        print("Inner function")

        def deeply_nested():
            print("Deeply nested")

        deeply_nested()

    inner_function()

def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3))  # 输出：6
print(sum_all(1, 2, 3, 4, 5))  # 输出：15

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=25, city="Beijing")
# 输出：
# name: Alice
# age: 25
# city: Beijing

def func(required, *args, **kwargs):
    print(f"Required: {required}")
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

func(1, 2, 3, name="Alice", age=25)
# 输出：
# Required: 1
# Args: (2, 3)
# Kwargs: {'name': 'Alice', 'age': 25}

def calculate_area(radius):
    """Calculate the area of a circle.

    Args:
        radius: The radius of the circle.

    Returns:
        The area of the circle.
    """
    import math
    return math.pi * radius ** 2

print(calculate_area.__doc__)

def greet(name: str) -> str:
    return f"Hello, {name}"

# 多个参数和返回类型
def add(a: int, b: int) -> int:
    return a + b

# 混合类型注解
from typing import List, Union

def process(items: List[Union[int, str]]) -> List[str]:
    return [str(item) for item in items]

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Python函数定义综合示例
"""

def basic_operations(a, b):
    """基本数学运算"""
    return {
        'sum': a + b,
        'difference': a - b,
        'product': a * b,
        'quotient': a / b if b != 0 else None
    }

def with_defaults(name, greeting="Hello", punctuation="!"):
    """带默认参数的函数"""
    return f"{greeting}, {name}{punctuation}"

def variable_args(*args, operation="sum"):
    """可变参数函数"""
    if operation == "sum":
        return sum(args)
    elif operation == "product":
        result = 1
        for num in args:
            result *= num
        return result
    else:
        return None

def keyword_args(**kwargs):
    """关键字参数函数"""
    return "\n".join(f"{key}: {value}" for key, value in kwargs.items())

def demo():
    """演示函数"""
    # 基本运算
    print("=== 基本运算 ===")
    result = basic_operations(10, 5)
    for op, value in result.items():
        print(f"{op}: {value}")

    # 默认参数
    print("\n=== 默认参数 ===")
    print(with_defaults("Alice"))
    print(with_defaults("Bob", "Hi"))
    print(with_defaults("Charlie", "Hey", "^^^"))

    # 可变参数
    print("\n=== 可变参数 ===")
    print(f"Sum: {variable_args(1, 2, 3, 4, 5)}")
    print(f"Product: {variable_args(1, 2, 3, 4, 5, operation='product')}")

    # 关键字参数
    print("\n=== 关键字参数 ===")
    print(keyword_args(name="Alice", age=25, city="Beijing"))

if __name__ == "__main__":
    demo()

# 错误：混用空格和Tab
def mixed_indent():
    print("Space")  # 空格
        print("Tab")  # Tab - 会导致错误

# 错误：默认参数是可变对象
def wrong_func(items=[]):  # 危险！
    items.append(1)
    return items

# 正确：使用None作为默认值
def correct_func(items=None):
    if items is None:
        items = []
    items.append(1)
    return items

# 错误：函数在定义之前被调用
greet()  # NameError: name 'greet' is not defined

def greet():
    print("Hello!")

# 直接计算
>>> 2 + 2
4

# 变量赋值
>>> x = 10
>>> y = 20
>>> x + y
30

# 调用函数
>>> print("Hello, World!")
Hello, World!

>>> exit()
# 或者
>>> quit()
# 或者按 Ctrl+D（Linux/Mac）或 Ctrl+Z（Windows）

# 测试函数
>>> def add(a, b):
...     return a + b
...
>>> add(3, 5)
8

# 测试类
>>> class Person:
...     def __init__(self, name):
...         self.name = name
...
>>> p = Person("Alice")
>>> p.name
'Alice'

# 导入库
>>> import pandas as pd
>>> import numpy as np

# 创建数据
>>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
>>> df
   A  B
0  1  4
1  2  5
2  3  6

# 简单分析
>>> df.mean()
A    2.0
B    5.0
dtype: float64

# 快速测试算法
>>> def quicksort(arr):
...     if len(arr) <= 1:
...         return arr
...     pivot = arr[len(arr) // 2]
...     left = [x for x in arr if x < pivot]
...     middle = [x for x in arr if x == pivot]
...     right = [x for x in arr if x > pivot]
...     return quicksort(left) + middle + quicksort(right)
...
>>> quicksort([3, 6, 8, 10, 1, 2, 1])
[1, 1, 2, 3, 6, 8, 10]

>>> help(print)
Help on built-in function print in module builtins:

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
...

>>> help(str.strip)
Help on method_descriptor:
...

>>> x = 10
>>> type(x)
<class 'int'>

>>> dir(x)
['__abs__', '__add__', '__and__', '__bool__', ...]

>>> x.__doc__
"int([x]) -> integer\nint(x, base=10) -> integer\n..."

>>> # 使用上下箭头键浏览历史
>>> # 或使用 %history 魔法命令
>>> %history
x = 10
type(x)
dir(x)

# 计时命令
>>> %timeit [x**2 for x in range(1000)]
1000 loops, best of 3: ... per loop

# 执行外部脚本
>>> %run script.py

# 查看环境变量
>>> %env

# 计时整个单元
>>> %%timeit
... x = [i**2 for i in range(1000)]
... y = [i**2 for i in range(1000)]
...

# 写入文件
%%writefile my_script.py
def hello():
    print("Hello, World!")

# 查看所有魔法命令
>>> %magic

# 快速调试
>>> %pdb on

# 设置选项
>>> %config IPCompleter.greedy=True

# 导入数据处理库
>>> import pandas as pd
>>> import matplotlib.pyplot as plt

# 创建示例数据
>>> data = {'Name': ['Alice', 'Bob', 'Charlie'],
...          'Age': [25, 30, 35],
...          'Score': [85, 90, 95]}
>>> df = pd.DataFrame(data)

# 数据探索
>>> df.describe()
>>> df.head()
>>> df.info()

# 数据处理
>>> df['Age_group'] = pd.cut(df['Age'], bins=[20, 30, 40], labels=['20-30', '30-40'])

# 测试排序算法
>>> import random
>>> data = [random.randint(0, 100) for _ in range(20)]

>>> def bubble_sort(arr):
...     n = len(arr)
...     for i in range(n):
...         for j in range(0, n-i-1):
...             if arr[j] > arr[j+1]:
...                 arr[j], arr[j+1] = arr[j+1], arr[j]
...     return arr
...
>>> bubble_sort(data.copy())

>>> x = 10  # 定义变量
>>> # 关闭解释器后重新打开
>>> x  # 会报错，x未定义

# 适合交互式测试
>>> result = simple_function(data)

# 大规模处理建议写脚本
# python my_script.py

>>> %pdb on
>>> # 代码出错时会自动进入调试模式
>>> (Pdb) help

# 无副作用：纯函数
def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 输出：8
# 函数外部没有任何改变

# 有副作用：修改全局变量
counter = 0

def increment():
    global counter
    counter += 1
    return counter

print(increment())  # 输出：1
print(counter)      # 输出：1（全局变量被修改）

# 全局变量
total = 0

def add_to_total(value):
    global total
    total += value
    return total

print(add_to_total(10))  # 输出：10
print(total)              # 输出：10（全局变量被修改）

# 修改列表参数
def modify_list(lst):
    lst.append(4)
    lst[0] = 100

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # 输出：[100, 2, 3, 4]（原列表被修改）

# 打印输出
def log_message(message):
    print(f"[LOG] {message}")

log_message("Hello")  # 产生副作用：向控制台输出

# 文件操作
def write_file(filename, content):
    with open(filename, 'w') as f:
        f.write(content)

write_file('test.txt', 'Hello')  # 产生副作用：写入文件

# 修改字典
def update_config(config, key, value):
    config[key] = value

config = {'debug': False}
update_config(config, 'debug', True)
print(config)  # 输出：{'debug': True}

# 难以测试的示例
counter = 0

def increment_and_return():
    global counter
    counter += 1
    if counter > 10:
        raise ValueError("Counter exceeded")
    return counter

# 测试需要重置全局状态
def test_increment_and_return():
    global counter
    counter = 0  # 需要重置状态
    assert increment_and_return() == 1
    counter = 0  # 需要再次重置

# 不好的方式
def add_item_bad(items, item):
    items.append(item)
    return items

# 好的方式：返回新列表
def add_item_good(items, item):
    return items + [item]

# 使用
my_list = [1, 2, 3]
new_list = add_item_good(my_list, 4)
print(my_list)  # 输出：[1, 2, 3]（原列表不变）
print(new_list)  # 输出：[1, 2, 3, 4]

from typing import Tuple

# 使用元组而非列表
def process_coordinates(coord: Tuple[int, int]) -> Tuple[int, int]:
    x, y = coord
    return (x + 1, y + 1)

# 或使用 dataclass 定义不可变对象
from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
    x: int
    y: int

    def translate(self, dx: int, dy: int) -> 'Point':
        return Point(self.x + dx, self.y + dy)

p = Point(1, 2)
p2 = p.translate(1, 1)
print(p)   # 输出：Point(x=1, y=2)（原对象不变）
print(p2)  # 输出：Point(x=2, y=3)

# 不好的方式：依赖全局变量
total = 0

def calculate_tax(amount, rate):
    global total
    tax = amount * rate
    total += tax
    return tax

# 好的方式：显式传递和返回状态
def calculate_tax_good(amount, rate, total=0):
    tax = amount * rate
    return tax, total + tax

tax, new_total = calculate_tax_good(100, 0.1, 0)
print(tax)       # 输出：10.0
print(new_total) # 输出：10.0

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
函数副作用综合示例
"""

# 示例1：使用纯函数处理数据
def pure_filter_positive(numbers):
    """纯函数：过滤正数，不修改原列表"""
    return [n for n in numbers if n > 0]

numbers = [-1, 2, -3, 4, 5]
positive_nums = pure_filter_positive(numbers)
print(f"Original: {numbers}")      # 输出：[-1, 2, -3, 4, 5]
print(f"Filtered: {positive_nums}")  # 输出：[2, 4, 5]

# 示例2：使用类封装副作用
class Counter:
    def __init__(self):
        self._count = 0

    def increment(self):
        self._count += 1
        return self._count

    @property
    def count(self):
        return self._count

counter = Counter()
print(counter.increment())  # 输出：1
print(counter.increment())  # 输出：2
print(counter.count)        # 输出：2

# 示例3：日志记录器
class Logger:
    def __init__(self):
        self._logs = []

    def log(self, message):
        self._logs.append(message)
        print(f"[LOG] {message}")

    def get_logs(self):
        return self._logs.copy()  # 返回副本，避免直接访问内部状态

logger = Logger()
logger.log("Start processing")
logger.log("Processing complete")
print(logger.get_logs())  # 输出：['Start processing', 'Processing complete']

# 示例4：配置管理器
class Config:
    def __init__(self, initial_config=None):
        self._config = initial_config or {}

    def get(self, key, default=None):
        return self._config.get(key, default)

    def set(self, key, value):
        self._config[key] = value

    def update(self, **kwargs):
        self._config.update(kwargs)

    @property
    def config(self):
        return self._config.copy()  # 返回副本

config = Config({'debug': False, 'log_level': 'INFO'})
print(config.get('debug'))  # 输出：False
config.set('debug', True)
config.update(timeout=30)
print(config.config)  # 输出：{'debug': True, 'log_level': 'INFO', 'timeout': 30}

# 危险：全局变量可以在任何地方被修改
global_data = {"user": None}

def login(username):
    global_data["user"] = username  # 副作用

def logout():
    global_data["user"] = None  # 副作用

# 更好的方式：使用类或显式传递状态

# 默认参数为可变对象的问题
def add_to_list(item, items=[]):  # 危险！
    items.append(item)
    return items

print(add_to_list(1))  # 输出：[1]
print(add_to_list(2))  # 输出：[1, 2]（预期之外！）

# 正确做法
def add_to_list_fixed(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

# 使用装饰器追踪副作用
def trace(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

@trace
def modify_and_return(value):
    return value * 2

modify_and_return(5)

# 全局变量
global_var = 10

def func():
    # 局部变量
    local_var = 20
    print(f"Inside function: global_var = {global_var}")
    print(f"Inside function: local_var = {local_var}")

func()
print(f"Outside function: global_var = {global_var}")
# print(local_var)  # NameError: name 'local_var' is not defined

# 【全局作用域 Global】：整个文件顶层的变量
x = "global"

def outer():
    # 【嵌套外层作用域 Enclosing】：outer 函数内部，独立于全局 x
    x = "enclosing"

    def inner():
        # 【本地作用域 Local】：inner 函数内部，独立于外层所有 x
        x = "local"
        # 查找规则：优先用自己内部的 Local x → 输出 local
        print(f"Inner: x = {x}")

    # 调用 inner，执行完后，inner 的本地 x 就销毁了
    inner()
    # 查找规则：outer 自己的 Enclosing x → 输出 enclosing
    print(f"Outer: x = {x}")

# 调用 outer，执行完后，outer 的嵌套 x 就销毁了
outer()
# 查找规则：全局作用域的 Global x → 输出 global
print(f"Global: x = {x}")

counter = 0

def increment():
    global counter
    counter += 1
    return counter

print(increment())  # 输出：1
print(counter)      # 输出：1
print(increment())  # 输出：2
print(counter)      # 输出：2

# 没有global关键字
x = 10

def func_without_global():
    x = 20  # 创建新的局部变量，不影响全局变量
    return x

print(func_without_global())  # 输出：20
print(x)  # 输出：10（全局变量未改变）

# 有global关键字
def func_with_global():
    global x
    x = 20  # 修改全局变量
    return x

print(func_with_global())  # 输出：20
print(x)  # 输出：20（全局变量被改变）

def test():
    x += 1  # 报错！因为你想修改全局 x，但没声明 global
test()

count = 0
name = "original"

def update():
    global count, name
    count += 1
    name = "updated"

update()
print(f"count = {count}, name = {name}")  # 输出：count = 1, name = updated

# 不推荐：使用全局变量
total = 0

def add_to_total(value):
    global total
    total += value

# 推荐：使用参数和返回值
def add_to_total_good(value, total=0):
    return total + value

total = add_to_total_good(10, 0)
total = add_to_total_good(20, total)

# 使用类封装相关状态
class Counter:
    def __init__(self):
        self._count = 0

    def increment(self):
        self._count += 1

    @property
    def count(self):
        return self._count

counter = Counter()
counter.increment()
counter.increment()
print(counter.count)  # 输出：2

def create_counter():
    count = 0

    def increment():
        nonlocal count
        count += 1
        return count

    return increment

counter = create_counter()
print(counter())  # 输出：1
print(counter())  # 输出：2

def outer():
    x = 10

    def inner():
        nonlocal x
        x = 20

    inner()
    print(f"Outer: x = {x}")  # 输出：Outer: x = 20

outer()

# global：作用于全局变量
x = "global"

def func1():
    global x
    x = "modified global"

# nonlocal：作用于外层函数的变量
def outer():
    x = "enclosing"

    def inner():
        nonlocal x
        x = "modified enclosing"

    inner()
    print(f"Inside outer: x = {x}")  # 输出：Inside outer: x = modified enclosing

func1()
print(f"Global: x = {x}")  # 输出：Global: x = modified global
outer()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
全局变量综合示例
"""

# 示例1：配置管理器（使用类而非全局变量）
class Config:
    _instance = None
    _config = {}

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def set(self, key, value):
        self._config[key] = value

    def get(self, key, default=None):
        return self._config.get(key, default)

config1 = Config()
config2 = Config()

config1.set("debug", True)
print(config2.get("debug"))  # 输出：True（单例模式）
print(config1 is config2)    # 输出：True

# 示例2：使用函数闭包替代全局变量
def create_logger():
    logs = []

    def log(message):
        logs.append(message)
        return logs

    return log

logger = create_logger()
logger("Message 1")
logger("Message 2")
print(logger([]))  # 输出：['Message 1', 'Message 2']

# 示例3：状态机
class StateMachine:
    def __init__(self):
        self._state = "idle"
        self._transitions = {
            "idle": {"start": "running"},
            "running": {"stop": "idle", "pause": "paused"},
            "paused": {"resume": "running", "stop": "idle"}
        }

    def transition(self, action):
        if action in self._transitions.get(self._state, {}):
            self._state = self._transitions[self._state][action]
            return True
        return False

    @property
    def state(self):
        return self._state

sm = StateMachine()
print(sm.state)        # 输出：idle
sm.transition("start")
print(sm.state)        # 输出：running
sm.transition("pause")
print(sm.state)        # 输出：paused

import threading

# 全局变量在多线程环境下不安全
counter = 0

def increment_ntimes(n):
    for _ in range(n):
        global counter
        counter += 1

# 创建两个线程同时修改全局变量
t1 = threading.Thread(target=increment_ntimes, args=(100000,))
t2 = threading.Thread(target=increment_ntimes, args=(100000,))

t1.start()
t2.start()
t1.join()
t2.join()

print(counter)  # 可能不是200000（存在竞态条件）

# mymodule.py
# module_level_var = "initial"

# main.py
# import mymodule
# print(mymodule.module_level_var)  # 输出：initial
# mymodule.module_level_var = "modified"  # 可以修改模块级变量

# 使用globals()查看所有全局变量
x = 10
y = "hello"

def show_globals():
    for key, value in globals().items():
        if not key.startswith('_'):
            print(f"{key}: {value}")

show_globals()

x = 10

if x > 5:
    print("x大于5")  # 输出：x大于5

x = 3

if x > 5:
    print("x大于5")
else:
    print("x不大于5")  # 输出：x不大于5

score = 85

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")  # 输出：良好
elif score >= 70:
    print("中等")
else:
    print("及格")

if x > 0:
    # ...
elif x == 0:
    # ...
else:
    # ...

# 使用 == 比较，使用 and, or, not
if x == 10 and y > 5:
    # ...

x, y = 10, 20

print(x == y)   # False
print(x != y)   # True
print(x < y)    # True
print(x > y)    # False
print(x <= y)   # True
print(x >= y)   # False

x, y, z = 10, 20, 30

# and：所有条件都为True时结果为True
print(x < y and y < z)  # True

# or：任意一个条件为True时结果为True
print(x > y or y < z)   # True

# not：取反
print(not x > y)        # True

fruits = ["apple", "banana", "cherry"]

print("apple" in fruits)      # True
print("orange" not in fruits) # True

x = 10

if x > 0:
    print("x是正数")
    if x > 5:
        print("x大于5")
    else:
        print("x不大于5")
else:
    print("x是负数或零")

# 判断三角形类型
def triangle_type(a, b, c):
    if a + b > c and a + c > b and b + c > a:
        if a == b == c:
            return "等边三角形"
        elif a == b or b == c or a == c:
            return "等腰三角形"
        else:
            return "普通三角形"
    else:
        return "不能构成三角形"

print(triangle_type(3, 4, 5))   # 普通三角形
print(triangle_type(3, 3, 3))   # 等边三角形

# Python的三元表达式
x = 10
result = "x大于5" if x > 5 else "x不大于5"
print(result)  # 输出：x大于5

score = 85
result = "优秀" if score >= 90 else "良好" if score >= 80 else "及格" if score >= 60 else "不及格"
print(result)  # 输出：良好

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
条件语句综合示例
"""

def check_number(n):
    """判断数字的性质"""
    if n > 0:
        if n % 2 == 0:
            return "正偶数"
        else:
            return "正奇数"
    elif n < 0:
        if n % 2 == 0:
            return "负偶数"
        else:
            return "负奇数"
    else:
        return "零"

def grade_student(score):
    """根据分数评定等级"""
    if score < 0 or score > 100:
        return "无效分数"
    elif score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

def traffic_light_control(color):
    """交通灯控制"""
    if color == "red":
        return "停"
    elif color == "yellow":
        return "慢"
    elif color == "green":
        return "行"
    else:
        return "无效信号"

def demo():
    """演示"""
    # 数字判断
    print("=== 数字判断 ===")
    for n in [-5, 0, 5, 10]:
        print(f"{n}: {check_number(n)}")

    # 成绩评定
    print("\n=== 成绩评定 ===")
    scores = [95, 85, 75, 65, 55, 105]
    for score in scores:
        print(f"{score}分: {grade_student(score)}")

    # 交通灯
    print("\n=== 交通灯 ===")
    for color in ["red", "yellow", "green", "blue"]:
        print(f"{color}: {traffic_light_control(color)}")

if __name__ == "__main__":
    demo()