# 默认用UTF-8编码，支持中文
姓名 = "张三"print(姓名)  # 输出：张三# 如需指定其他编码（很少用）
# -*- coding: cp-1252 -*-  # 放在文件第一行

# 合法的变量名
age = 10
my_name = "小明"
_age = 20
MAX_NUM = 100
成绩 = 95  # 支持中文#

2name = "错误"  # 不能以数字开头
my-name = "错误"  # 不能有连字符
if = 5  # 不能用关键字

import keyword
print(keyword.kwlist)  # 打印所有关键字，比如if、for、class等

# 这是单行注释，一行只写一句说明'''
这是多行注释
可以写很多行
'''print("Hello")  # 这也是注释，在代码后面说明

# 正确的缩进（同一代码块缩进一致）
if 5 > 3:print("5比3大")  # 缩进4个空格
    print("条件成立")  # 同样缩进# 错误的缩进（会报错）# 
    if 5 > 3:#     print("正确")#  
         print("错误")  # 缩进不一致

# 用反斜杠换行
total = 10 + 20 + \
        30 + 40print(total)  # 输出：100# 列表/字典里换行不用反斜杠
fruits = ["苹果","香蕉","橘子"]print(fruits)  # 输出：['苹果', '香蕉', '橘子']

a = 100  # 整数（int）
b = 3.14  # 浮点数（float）
c = True  # 布尔值（True/False）
d = 2 + 3j  # 复数（很少用）print(a + b)  # 输出：103.14（不同类型可运算）

# 字符串定义
s1 = "hello"
s2 = 'world'
s3 = """这是
多行
字符串"""# 拼接和重复
print(s1 + " " + s2)  # 输出：hello world
print(s1 * 2)  # 输出：hellohello# 索引（取单个字符）
print(s1[0])  # 输出：h（第1个字符）print(s1[-1])  # 输出：o（最后1个字符）# 切片（取一段字符）
print(s1[1:4])  # 输出：ell（从第2个到第4个）# 原始字符串（不转义）
print(r"c:\test")  # 输出：c:\test（\不转义）

name = input("请输入你的名字：")
print("你好，" + name)  # 输入什么就打印什么# 示例：输入后按回车继续
input("按回车结束...")

a = 1; b = 2; c = a + b
print(c)  # 输出：3（一行写3条语句）

# 默认换行
print("第一行")
print("第二行")# 不换行（用end指定分隔符）
print("苹果", end="、")
print("香蕉", end="、")
print("橘子")  # 输出：苹果、香蕉、橘子

# 导入整个模块import math
print(math.sqrt(16))  # 输出：4.0（计算平方根）# 导入模块中的部分功能
from math import sqrt
print(sqrt(25))  # 输出：5.0（直接用sqrt，不用加math.）

#!/usr/bin/python3
student_id = 2025001    # 整型变量
score = 92.5            # 浮点型变量
student_name = "Lily"   # 字符串print(student_id)  # 输出：2025001print(score)       # 输出：92.5print(student_name)# 输出：Lily

# 变量定义
age = 22               # 整数
weight = 52.3          # 浮点数
hobby = "reading"      # 字符串
is_student = True      # 布尔值# 查看数据类型
print(type(age))        # 输出：<class 'int'>
print(type(weight))     # 输出：<class 'float'>
print(type(hobby))      # 输出：<class 'str'>
print(type(is_student)) # 输出：<class 'bool'>

# 赋值不同数字类型
num1, num2, flag, comp = 50, 3.14, False, 2+5j
print(type(num1), type(num2), type(flag), type(comp))  # 输出：<class 'int'> <class 'float'> <class 'bool'> <class 'complex'># 使用 isinstance 判断类型
num = 200
print(isinstance(num, int))  # 输出：True

>>> 8 + 3  # 加法：
11
>>> 6.5 - 2 # 减法：
4.5
>>> 4 * 9  # 乘法：
36
>>> 7 / 2  # 除法（浮点数）：
3.5
>>> 7 // 2 # 除法（整数）：
3
>>> 19 % 4 # 取余：
3
>>> 3 ** 4 # 乘方：
81

#!/usr/bin/python3
msg = 'Python'  # 定义字符串print(msg)           # 输出完整字符串：Python
print(msg[0:-1])     # 输出第 1 到倒数第 2 个字符：Pytho
print(msg[1])        # 输出第 2 个字符：y
print(msg[3:6])      # 输出第 4 到第 6 个字符：hon
print(msg[4:])       # 输出第 5 个字符到末尾：on
print(msg * 2)       # 复制字符串两次：PythonPython
print(msg + "Learn") # 拼接字符串：PythonLearn

print("""I love
Python
programming""")

# 布尔值与类型
is_open = True
is_closed = Falseprint(type(is_open))  # 输出：<class 'bool'># 转换与运算
print(bool(0.0))       # 输出：False
print(bool('Hello'))   # 输出：True
print(True or False)   # 逻辑或：True
print(10 < 5)          # 比较运算：False# 条件判断应用
count = 5if count > 0:  # count 大于 0，视为 True
print("数量为正数")

#!/usr/bin/python3
shopping_list = ['milk', 3, 12.8, 'bread', 2]
snack_list = ['chocolate', 5]print(shopping_list)            # 输出完整列表：['milk', 3, 12.8, 'bread', 2]print(shopping_list[0])         # 输出第 1 个元素：milkprint(shopping_list[2:4])       # 输出第 3 到第 4 个元素：[12.8, 'bread']print(shopping_list[3:])        # 输出第 4 个元素到末尾：['bread', 2]print(snack_list * 2)           # 复制列表两次：['chocolate', 5, 'chocolate', 5]print(shopping_list + snack_list) # 拼接列表：['milk', 3, 12.8, 'bread', 2, 'chocolate', 5]

nums = [2, 4, 6, 8, 10]
nums[1] = 5  # 修改第 2 个元素
nums[3:5] = [9, 11]  # 修改第 4 到第 5 个元素
print(nums)  # 输出：[2, 5, 6, 9, 11]

nums[2:4] = []  # 删除第 3 到第 4 个元素
print(nums)      # 输出：[2, 5, 11]

# 步长为 2，截取索引 0 到 5 的元素
num_list = [10,20,30,40,50,60]
print(num_list[0:5:2])  # 输出：[10,30,50]# 步长为 -1，逆向读取（翻转列表）
def reverseSentence(sentence):
    words = sentence.split(" ")
    words = words[-1::-1]  # 逆向读取
    new_sentence = ' '.join(words)
    return new_sentence

sentence = 'She loves coding'
print(reverseSentence(sentence))  # 输出：coding loves She

#!/usr/bin/python3
book_info = ('Python Basics', 39.9, 2024, 'John')
author_info = ('John', 45)print(book_info)             # 输出完整元组：('Python Basics', 39.9, 2024, 'John')print(book_info[1])          # 输出第 2 个元素：39.9print(book_info[2:4])        # 输出第 3 到第 4 个元素：(2024, 'John')print(author_info * 2)       # 复制元组两次：('John', 45, 'John', 45)print(book_info + author_info) # 拼接元组：('Python Basics', 39.9, 2024, 'John', 'John', 45)

#!/usr/bin/python3
fruits = {'apple', 'banana', 'orange', 'apple', 'grape'}print(fruits)   # 输出集合（去重）：{'apple', 'banana', 'orange', 'grape'}# 成员测试if 'banana' in fruits:print('香蕉在集合中')else:print('香蕉不在集合中')# 集合运算
set1 = set('abcdef')
set2 = set('cdefgh')print(set1 - set2)     # 差集：{'a', 'b'}print(set1 | set2)     # 并集：{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}print(set1 & set2)     # 交集：{'c', 'd', 'e', 'f'}print(set1 ^ set2)     # 不同时存在的元素：{'a', 'b', 'g', 'h'}

#!/usr/bin/python3
car = {}
car['brand'] = "Toyota"
car['year'] = 2023
phone = {'brand': 'Huawei', 'model': 'Mate 60', 'price': 5999}
print(car['brand'])       # 输出 key='brand' 的值：Toyota
print(car['year'])        # 输出 key='year' 的值：2023
print(phone)              # 输出完整字典：{'brand': 'Huawei', 'model': 'Mate 60', 'price': 5999}print(phone.keys())       # 输出所有 key：dict_keys(['brand', 'model', 'price'])print(phone.values())     # 输出所有 value：dict_values(['Huawei', 'Mate 60', 5999])

# 用键值对序列创建
print(dict([('name', 'Mike'), ('age', 25), ('city', 'Beijing')]))  # 输出：{'name': 'Mike', 'age': 25, 'city': 'Beijing'}
# 用字典推导式创建
print({k: k*2 for k in (1, 2, 3)})  # 输出：{1: 2, 2: 4, 3: 6}
# 用关键字参数创建
print(dict(brand='Apple', product='iPhone', color='black')) 
# 输出：{'brand': 'Apple', 'product': 'iPhone', 'color': 'black'}

# 用 b 前缀创建
data = b"example"print(data)  # 输出：b'example'# 用 bytes() 函数创建（指定编码）
binary_data = bytes("example", encoding="utf-8")
print(binary_data)  # 输出：b'example'# 切片与拼接
print(data[2:5])          # 切片：b'amp'
print(data + b"test")     # 拼接：b'exampletest'# 元素比较（需用整数）
if data[0] == ord("e"):  # ord() 转换字符为整数
print("第一个元素是 'e'")

num1 = 3  # 整数（int）
num2 = 1.5  # 浮点数（float）
result = num1 + num2  # 自动转换：3 → 3.0，再计算
print(result)  # 输出：4.5
print(type(result))  # 输出：<class 'float'>

num = 5
text = "10"
print(num + text)  # 报错：TypeError（int 和 str 不能直接相加）

num = 8
text = "12"  # 字符串（数字格式）

text = int(text)  # 手动转换："12" → 12（整数）
total = num + text

print(total)  # 输出：20print(type(total))  # 输出：<class 'int'>

a = 8
b = 3print(a + b)  # 输出 11
print(a % b)  # 输出 2（8除以3余2）
print(a ** 2) # 输出 64（8的2次方）

a = 5
b = 7print(a < b)   # 输出 True（5小于7）
print(b == 7)  # 输出 True（7等于7）
print(a >= 6)  # 输出 False（5不大于等于6）

c = 4
c += 2  # 等效 c = 4 + 2
print(c)  # 输出 6

c *= 3  # 等效 c = 6 * 3
print(c)  # 输出 18

# 直接在判断中赋值并使用
if (num := len([1,2,3])) > 2:print(f"列表长度是 {num}")  # 输出 列表长度是 3

a = 6  # 0110
b = 3  # 0011
print(a & b)  # 输出 2
print(a << 1) # 输出 12

x = True
y = Falseprint(x and y)  # 输出 False
print(not x)    # 输出 False
print(x or y)   # 输出 True

my_list = [10, 20, 30]print(20 in my_list)      # 输出 True
print(40 not in my_list)  # 输出 True

my_str = "hello"print('h' in my_str)      # 输出 True

a = [1,2]
b = a  # b 和 a 引用同一个列表
print(a is b)  # 输出 True

c = [1,2]  # c 是新列表（内存地址不同）
print(a is c)  # 输出 False
print(a == c)  # 输出 True（值相等，但不是同一对象）

# 无括号：先算 * 再算 +
print(2 + 3 * 4)  # 输出 14（3*4=12，2+12=14）# 有括号：先算括号内
print((2 + 3) * 4)  # 输出 20（2+3=5，5*4=20）# 逻辑运算优先级
print(True or False and False)  # 输出 True（先算 and，再算 or）

# 基础运算
print(5 + 3)   # 加法 → 8
print(10 - 4)  # 减法 → 6
print(3 * 7)   # 乘法 → 21
print(15 / 4)  # 除法（得浮点数）→ 3.75
print(15 // 4) # 取整除（去小数）→ 3
print(15 % 4)  # 取模（余数）→ 3
print(2 **3)  # 幂运算（2的3次方）→ 8# 混合运算（自动转为浮点型）
print(3 + 2.5)  # → 5.5

str1 = 'Hello Python'
str2 = "编程学习"

text = "abcdef"
print(text[0])      # 取第1个字符 → 'a'
print(text[2:5])    # 取索引2到4的字符 → 'cde'
print(text[-3:])    # 取最后3个字符 → 'def'

old_str = "I like cats"
new_str = old_str[:7] + "dogs"  # 替换后半部分
print(new_str)  # 输出：I like dogs

import time
for i in range(101):# \r 使光标回到行首，实现覆盖输出
print(f"\r进度：{i}%", end='')
    time.sleep(0.1)  # 延迟0.1秒

a = "hi"
b = "python"print(a + " " + b)  # 输出：hi python
print(b * 2)        # 输出：pythonpython
print("y" in b)     # 输出：True

name = "小明"
age = 12
print("姓名：%s，年龄：%d岁" % (name, age))  # 输出：姓名：小明，年龄：12岁

score = 95
print(f"得分：{score}，等级：{ '优秀' if score >= 90 else '良好' }")# 输出：得分：95，等级：优秀

multi_line = """这是第一行
这是第二行
    这是缩进的第三行"""
    print(multi_line)# 输出：# 这是第一行# 这是第二行#     这是缩进的第三行

s = "  Hello World  "print(s.strip())          # 输出：Hello World
print(s.replace("World", "Python"))  # 输出：  Hello Python  
print(s.split())          # 输出：["Hello", "World"]（默认按空格拆分）

fruits = ["苹果", "香蕉", "橙子"]  # 字符串列表
mixed = [10, "hello", True, 3.14]  # 混合类型列表
empty = []  # 空列表

colors = ["红", "绿", "蓝", "黄"]
print(colors[0])   # 正向索引 → "红"
print(colors[-2])  # 反向索引 → "蓝"
print(colors[1:3]) # 切片（左闭右开）→ ["绿", "蓝"]
print(colors[:2])  # 从开头到索引1 → ["红", "绿"]
print(colors[2:])  # 从索引2到结尾 → ["蓝", "黄"]

numbers = [1, 2, 3]# 修改元素
numbers[1] = 20
print(numbers)  # 输出：[1, 20, 3]# 添加元素（append() 方法）
numbers.append(4)
print(numbers)  # 输出：[1, 20, 3, 4]# 插入元素（insert() 方法，指定位置）
numbers.insert(0, 0)  # 在索引0插入0
print(numbers)  # 输出：[0, 1, 20, 3, 4]

animals = ["猫", "狗", "兔", "鸟"]# del 语句删除指定索引元素
del animals[2]
print(animals)  # 输出：["猫", "狗", "鸟"]# remove() 方法删除第一个匹配值
animals.remove("狗")
print(animals)  # 输出：["猫", "鸟"]# pop() 方法删除并返回指定索引元素（默认最后一个）
last = animals.pop()
print(last)     # 输出："鸟"
print(animals)  # 输出：["猫"]

a = [1, 2]
b = [3, 4]
print(a + b)        # 组合 → [1, 2, 3, 4]
print(a * 2)        # 重复 → [1, 2, 1, 2]
print(2 in a)       # 判断成员 → True
print(5 not in b)   # 判断非成员 → True

# 嵌套列表（二维列表）
matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]
print(matrix[1])      # 访问第二行 → [4, 5, 6]
print(matrix[0][2])   # 访问第一行第三列 → 3

words = ["banana", "apple", "cherry"]# 排序
words.sort()print(words)  # 输出：["apple", "banana", "cherry"]# 统计
print(words.count("apple"))  # 输出：1# 复制与清空
words_copy = words.copy()
words.clear()print(words)       # 输出：[]
print(words_copy)  # 输出：["apple", "banana", "cherry"]

# 普通元组
t1 = (10, "苹果", True)
t2 = "红", "黄", "蓝"  # 省略括号，仍是元组
print(type(t2))  # 输出：<class 'tuple'># 单元素元组（必须加逗号，否则视为普通括号）
t3 = (5,)  # 正确：元组
t4 = (5)   # 错误：类型为 int
print(type(t3))  # 输出：<class 'tuple'># 空元组
empty_tup = ()

fruits = ("香蕉", "橙子", "葡萄", "芒果")
print(fruits[1])    # 正向索引 → "橙子"
print(fruits[-2])   # 反向索引 → "葡萄"
print(fruits[1:3])  # 切片（左闭右开）→ ("橙子", "葡萄")
print(fruits[:2])   # 从开头到索引1 → ("香蕉", "橙子")

t1 = (1, 2, 3)
t2 = (4, 5)# 以下操作非法（元组不可修改）# t1[0] = 0  # 报错：TypeError# 组合生成新元组
t3 = t1 + t2
print(t3)  # 输出：(1, 2, 3, 4, 5)# 重复生成新元组
t4 = t2 * 2
print(t4)  # 输出：(4, 5, 4, 5)

cities = ("北京", "上海", "广州")
print(cities)  # 输出：("北京", "上海", "广州")
del cities
# print(cities)  # 报错：NameError（元组已被删除）

a = (10, 20)
b = (30, 40)
print(a + b)        # 输出：(10, 20, 30, 40)
print(a * 2)        # 输出：(10, 20, 10, 20)
print(20 in a)      # 输出：True
print(len(b))       # 输出：2

nums = (3, 1, 4, 2)
print(max(nums))  # 输出：4
print(min(nums))  # 输出：1# 列表转元组
lst = ["a", "b"]
t = tuple(lst)
print(t)  # 输出：("a", "b")

# 元组包含列表（可变元素）
t = (1, [2, 3], 4)
t[1].append(5)  # 修改列表内部元素（允许）
print(t)  # 输出：(1, [2, 3, 5], 4)

# 直接定义（键唯一，值可重复）
student = {"name": "张三","age": 18,"gender": "男"}# 用 dict() 函数创建
fruit = dict(name="苹果", color="红色", price=5.8)# 空字典
empty_dict = {}
empty_dict2 = dict()

book = {"title": "Python入门", "author": "李四", "price": 39.9}# 用键访问
print(book["title"])  # 输出：Python入门# 用 get() 方法（推荐）
print(book.get("author"))       # 输出：李四
print(book.get("publisher", "未知"))  # 键不存在，返回默认值：未知

car = {"brand": "丰田", "color": "白色"}# 添加新键值对
car["price"] = 200000
print(car)  # 输出：{"brand": "丰田", "color": "白色", "price": 200000}# 修改已有值
car["color"] = "黑色"
print(car)  # 输出：{"brand": "丰田", "color": "黑色", "price": 200000}# 删除键值对（del 语句）
del car["price"]
print(car)  # 输出：{"brand": "丰田", "color": "黑色"}# 清空字典（clear() 方法）
car.clear()
print(car)  # 输出：{}

phone = {"brand": "华为", "model": "Mate 60", "price": 6999}
print(len(phone))  # 输出：3
print("model" in phone)  # 输出：True# 遍历键值对
for k, v in phone.items():print(f"{k}: {v}")# 输出：# brand: 华为# model: Mate 60# price: 6999

# 合并字典
d1 = {"name": "小明", "age": 12}
d2 = {"age": 13, "gender": "男"}
d1.update(d2)  # 重复键 "age" 被覆盖
print(d1)  # 输出：{"name": "小明", "age": 13, "gender": "男"}# 弹出键值对
d = {"a": 1, "b": 2}
val = d.pop("a")
print(val)  # 输出：1
print(d)    # 输出：{"b": 2}

# 直接创建（自动去重）
fruits = {"苹果", "香蕉", "橙子", "苹果"}
print(fruits)  # 输出：{'苹果', '香蕉', '橙子'}（顺序可能不同）# 从列表创建
nums = set([1, 2, 3, 2])
print(nums)  # 输出：{1, 2, 3}# 空集合
empty_set = set()

colors = {"红", "绿"}# 添加单个元素
colors.add("蓝")
print(colors)  # 输出：{'红', '绿', '蓝'}# 添加多个元素（列表）
colors.update(["黄", "紫"])
print(colors)  # 输出：{'红', '绿', '蓝', '黄', '紫'}（顺序随机）

shapes = {"圆形", "方形", "三角形"}

shapes.remove("方形")
print(shapes)  # 输出：{'圆形', '三角形'}

shapes.discard("菱形")  # 元素不存在，无操作
print(shapes)  # 输出：{'圆形', '三角形'}

removed = shapes.pop()
print(removed)  # 输出：圆形（或三角形，随机）
print(shapes)   # 剩余元素：{'三角形'}（或{'圆形'}）

letters = {"a", "b", "c"}
print(len(letters))  # 输出：3
print("d" in letters)  # 输出：False

letters.clear()
print(letters)  # 输出：set()

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b)  # 并集 → {1, 2, 3, 4, 5, 6}
print(a & b)  # 交集 → {3, 4}
print(a - b)  # 差集 → {1, 2}

# 生成10以内的偶数集合
even_nums = {x for x in range(10) 
if x % 2 == 0}
print(even_nums)  # 输出：{0, 2, 4, 6, 8}

if 条件1:
    代码块1  # 条件1为True时执行
 elif 条件2:
    代码块2  # 条件1为False，条件2为True时执行
 else:
    代码块3  # 所有条件都为False时执行

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

num = 7
if num % 2 == 0:
    print(f"{num}是偶数")
else:
    print(f"{num}是奇数")# 输出：7是奇数

n = 12
if n > 0:
    print("正数")
    if n % 4 == 0:
        print("且能被4整除")
    else:
        print("但不能被4整除")
 else:
     print("非正数")# 输出：# 正数# 且能被4整除

match 变量:
        case 值1:
        代码块1
        case 值2|值3:  # 多值匹配（用|分隔）
        代码块2
        case _:  # 匹配所有未命中的情况（类似default）
        代码块3

weekday = 3
match weekday:
    case 1:print("星期一")
    case 2:print("星期二")
    case 3:print("星期三")
    case 6|7:print("周末")
    case _:
    print("无效数字")# 输出：星期三

while 条件:
    循环体  # 条件为True时执行
else:
    结束块  # 条件为False时执行（可选）

total = 0
i = 1
while i <= 5:
    total += i
    i += 1  # 避免无限循环
    print("总和：", total)  # 输出：总和：15

count = 0
while count < 3:
    print("计数：", count)
    count += 1
else:
    print("计数结束")  # 条件不满足时执行# 输出：# 计数：0# 计数：1# 计数：2# 计数结束

# 简单的无限循环（谨慎运行）# while True:#     print("循环中...")

for 变量 in 可迭代对象:
    循环体
else:
    结束块  # 遍历完成后执行（可选，break终止时不执行）

fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(fruit)# 输出：# 苹果# 香蕉# 橙子

# range(开始, 结束, 步长)，左闭右开
for num in range(2, 10, 2):  # 2,4,6,8
    print(num)# 输出：# 2# 4# 6# 8

for x in range(3):
    print(x)
else:
    print("循环结束")  # 遍历完成后执行# 输出：# 0# 1# 2# 循环结束

for num in range(10):
    if num == 5:
        break  # 遇到5就停止
        print(num)# 输出：0 1 2 3 4（每行一个）

for num in range(5):
    if num == 2:
        continue  # 跳过2
        print(num)# 输出：0 1 3 4（每行一个）

for letter in "abc":
    if letter == "b":
        pass  # 暂不处理，保持结构完整
     else:
         print(letter)# 输出：a c（每行一个）

print("Hello, Python!")  # 输出：Hello, Python!
print('编程很有趣')        # 输出：编程很有趣（单引号也可）

age = 20
score = 95.5
print("年龄：", age)    # 输出：年龄：20
print("分数：", score)  # 输出：分数：95.5

a = 15
b = 4
sum_ab = a + b
product_ab = a * b
print("和：", sum_ab)      # 输出：和：19
print("积：", product_ab)  # 输出：积：60
print("商：", a / b)       # 输出：商：3.75

pets = ["猫", "狗", "兔子"]
print(pets[0])  # 输出第一个元素：猫
print(pets[2])  # 输出第三个元素：兔子# 遍历列表
for pet in pets:
print(pet)# 输出：# 猫# 狗# 兔子

# range(5) 生成 0~4 的数字for num in range(5):print("数字：", num)# 输出：# 数字：0# 数字：1# 数字：2# 数字：3# 数字：4

num = 7if num % 2 == 0:print(num, "是偶数")else:print(num, "是奇数")# 输出：7 是奇数

# 初始值：a=0，b=1
a, b = 0, 1# 输出小于 50 的斐波那契数
while b < 50:
    print(b)
    a, b = b, a + b  # 同时更新 a 和 b（a 变为原来的 b，b 变为原来的 a+b）# 输出：# 1# 1# 2# 3# 5# 8# 13# 21# 34

# 用逗号分隔输出，不换行
a, b = 0, 1
while b < 20:
    print(b, end=', ')
    a, b = b, a + b
# 输出：1, 1, 2, 3, 5, 8, 13, 

# 生成10以内的偶数
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # 输出：[0, 2, 4, 6, 8]

words = ["apple", "Banana", "cherry", "Date"]# 提取长度大于5的单词，并转为小写
long_words = [word.lower() for word in words if len(word) > 5]
print(long_words)  # 输出：["banana", "cherry"]

original = {"a": 1, "b": 2, "c": 3}# 原字典的键作为值，值作为键
swapped = {v: k for k, v in original.items()}
print(swapped)  # 输出：{1: 'a', 2: 'b', 3: 'c'}

numbers = [1, 2, 3, 4, 5]# 生成键为数字，值为数字平方的字典（仅保留偶数）
square_dict = {x: x**2 for x in numbers if x % 2 == 0}
print(square_dict)  # 输出：{2: 4, 4: 16}

text = "hello world"# 提取所有非空格的唯一字符
unique_chars = {c for c in text if c != " "}
print(unique_chars)  # 输出：{'h', 'e', 'l', 'o', 'w', 'r', 'd'}

# 生成1~5的平方数，自动去重（此处无重复）
squares = {x**2 for x in range(1, 6)}
print(squares)  # 输出：{1, 4, 9, 16, 25}

# 推导式返回生成器
gen = (x * 2 for x in range(3))# 转换为元组
doubles = tuple(gen)
print(doubles)  # 输出：(0, 2, 4)

# 生成10以内能被3整除的数字的生成器
filtered_gen = (x for x in range(10) if x % 3 == 0)print(tuple(filtered_gen))  # 输出：(0, 3, 6, 9)

# 从列表创建迭代器
nums = [10, 20, 30]
it = iter(nums)# 用 next() 获取元素
print(next(it))  # 输出：10
print(next(it))  # 输出：20# 用 for 循环遍历（更常用）
for num in it:
    print(num)  # 输出：30（注意：前面已取2个，这里从第三个开始）

it = iter([1, 2])
try:
    print(next(it))  # 1
    print(next(it))  # 2
    print(next(it))  # 无元素，触发异常
 except StopIteration:
      print("迭代结束")

class MyIterator:def __init__(self):
        self.current = 1  # 初始值
        def __iter__(self):
            return self  # 返回自身
        def __next__(self):
            if self.current > 5:
                raise StopIteration  # 终止条件
        value = self.current
        self.current += 1
        return value

# 使用自定义迭代器
my_iter = MyIterator()
for num in my_iter:
    print(num)  # 输出：1 2 3 4 5（每行一个）

def my_generator():
    yield 1  # 第一次调用返回1，暂停
    yield 2  # 第二次调用返回2，暂停
    yield 3  # 第三次调用返回3，结束# 创建生成器（迭代器）
gen = my_generator()
print(next(gen))  # 输出：1
print(next(gen))  # 输出：2
for val in gen:
    print(val)  # 输出：3

# 生成无限偶数序列（仅示例，实际使用需限制终止条件）
def even_numbers():
    n = 0while True:yield n
        n += 2

even_gen = even_numbers()
print(next(even_gen))  # 0
print(next(even_gen))  # 2
print(next(even_gen))  # 4

def fibonacci(max_count):
    a, b = 0, 1
    count = 0
    while count < max_count:
        yield a  # 返回当前值
        a, b = b, a + b  # 更新下一组值
        count += 1# 生成前6个斐波那契数
fib_gen = fibonacci(6)
for num in fib_gen:
    print(num, end=" ")  # 输出：0 1 1 2 3 5

# 传统方式：需手动 close()
file = open("data.txt", "r")
try:
    content = file.read()finally:
    file.close()  # 必须手动关闭，否则可能资源泄露

with 表达式 as 变量:# 资源使用代码块（变量为表达式返回的资源对象）

# 读取文件
with open("note.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()  # 读取所有行
    for line in lines:
        print(line.strip())  # 处理内容# 写入文件
        with open("output.txt", "w") as f:
            f.write("Hello, with!")  # 写入内容# 代码块结束后，文件自动关闭，无需手动操作

# 同时打开两个文件（读和写）
with open("source.txt", "r") as src, open("dest.txt", "w") as dst:
    content = src.read()  # 从源文件读取
    dst.write(content)    # 写入目标文件

import sqlite3

# 连接数据库，自动关闭连接
with sqlite3.connect("test.db") as conn:
    cursor = conn.cursor()
    cursor.execute("CREATE TABLE IF NOT EXISTS users (id INT, name TEXT)")
    cursor.execute("INSERT INTO users VALUES (1, '张三')")
    conn.commit()  # 提交事务

import threading

lock = threading.Lock()# 自动获取和释放锁，避免死锁
with lock:# 临界区代码（多线程环境下安全执行）
    print("线程安全的操作")

import time

class Timer:def __enter__(self):
        self.start = time.time()  # 记录开始时间
        return self  # 返回自身给 as 变量
        def __exit__(self, exc_type, exc_val, exc_tb):
            self.end = time.time()  # 记录结束时间
            print(f"耗时：{self.end - self.start:.2f}秒")# 返回 False 表示不抑制异常（如需捕获异常，可在此处理）
            return False# 使用自定义上下文管理器with Timer() as t:# 模拟耗时操作
            sum(range(10000000))  # 计算 0~9999999 的和

from contextlib import contextmanager

@contextmanager
def log_operation(operation):
    print(f"开始：{operation}")
    yield  # 暂停，执行 with 块中的代码
    print(f"结束：{operation}")# 使用
    with log_operation("数据备份"):
        print("正在备份...")  # 模拟备份操作# 输出：# 开始：数据备份# 正在备份...# 结束：数据备份

def 函数名(参数列表):"""函数文档字符串（可选）"""
    函数体（缩进）
    return 表达式  # 可选，返回结果

def greet():"""输出问候语"""
print("Hello, 函数！")# 调用函数
greet()  # 输出：Hello, 函数！

def add(a, b):"""返回两个数的和"""
    return a + b

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

def modify_num(x):
    x = 10  # 函数内修改，不影响外部
    print("函数内：", x)

num = 5
modify_num(num)
print("函数外：", num)  # 输出：5（外部未变）

def add_item(lst):
    lst.append("new")  # 函数内修改，影响外部
    print("函数内：", lst)

my_list = [1, 2]
add_item(my_list)
print("函数外：", my_list)  # 输出：[1, 2, 'new']（外部已变）

def print_name(name):
    print("姓名：", name)

print_name("张三")  # 正确# print_name()  # 错误：缺少参数

def introduce(name, age):
print(f"我叫{name}，今年{age}岁")# 用关键字参数调用，顺序可换
introduce(age=20, name="李四")  # 输出：我叫李四，今年20岁

def power(base, exp=2):"""计算 base 的 exp 次方，默认平方"""
    return base ** exp

print(power(3))    # 省略 exp，用默认值 2 → 9
print(power(3, 3)) # 传入 exp → 27

def print_args(arg1, *args, **kwargs):
    print("固定参数：", arg1)
    print("不定长位置参数：", args)  # 元组
    print("不定长关键字参数：", kwargs)  # 字典

print_args(1, 2, 3, name="张三", age=18)# 输出：# 固定参数：1# 不定长位置参数：(2, 3)# 不定长关键字参数：{'name': '张三', 'age': 18}