Python基础

print("Hello")                 # 输出：Hello
print(123)                     # 输出：123
print("我", "爱", "Python")     # 输出：我 爱 Python（多值默认空格分隔）
print(1 + 2 + 3)               # 输出：6（先求值再打印）

name, age = "小红", 18
print("我叫", name)             # 输出：我叫 小红

print("A", "B", "C")              # 输出：A B C（默认 sep=" "）
print("A", "B", "C", sep="-")     # 输出：A-B-C
print("A", "B", "C", sep="")      # 输出：ABC
print(2024, 1, 15, sep="/")       # 输出：2024/1/15

print("第一行")                    # 默认 end="\n"，打印后换行
print("第一行", end="")            # 不换行
print("苹果", end=", ")            # 用自定义结尾拼接
print("香蕉")                      # 输出：苹果, 香蕉
print("加载中", end=""); print(".", end=""); print(".")   # 输出：加载中..

name, age, score = "张三", 25, 95.5
print(f"我叫{name}，今年{age}岁，考了{score}分")   # 推荐：f-string，Python 3.6+
print(f"1+1={1 + 1}")                             # {} 内可直接写表达式 → 1+1=2
print(f"平均分：{score / 3:.2f}")                  # :.2f 保留 2 位小数

print("我叫{}，今年{}岁".format(name, age))        # str.format()，老写法
print("我叫{0}，今年{1}岁".format(name, age))      # 可指定位置
print("我叫%s，今年%d岁" % (name, age))            # % 格式化，已不推荐

name, value = "苹果", 1234.5678
print(f"{name:>10}|")       # 右对齐，宽度 10 → '       苹果|'
print(f"{name:<10}|")       # 左对齐
print(f"{name:^10}|")       # 居中对齐
print(f"{value:,.2f}")      # 千分位 + 2 位小数 → 1,234.57
print(f"{0.256:.2%}")       # 百分比（乘 100 加 %）→ 25.60%
print(f"{7:03d}")           # 补零到 3 位 → 007
print(f"{value:.2e}")       # 科学计数法 → 1.23e+03
print(f"{value=}")          # Python 3.8+：调试用，输出 'value=1234.5678'
print(f"{name!r}")          # !r 调用 repr() → '苹果'

# 单行注释：# 之后的内容被忽略
age = 18  # 也可以在代码后面注释

"""
三引号包裹的是多行字符串，常作模块/函数/类的文档字符串（docstring）
"""

def calculate(radius):
    """计算圆面积：π × r²（函数文档）"""
    return 3.14159 * radius ** 2

# TODO: 待实现的功能
# FIXME: 已知问题

name = input("请输入你的名字：")     # 显示提示并等待输入，返回字符串
print(f"你好，{name}")

age = input("你几岁？")
print(type(age))                    # <class 'str'>：input() 永远返回字符串
# age + 1 → TypeError

age = int(input("你几岁？"))         # 需要数字时显式转换
price = float(input("价格是多少？"))

print("=== 自我介绍小程序 ===")
name = input("你叫什么名字？")
age = int(input("你几岁了？"))          # 需要参与比较/运算时立刻转换
city = input("你住在哪个城市？")

print(f"\n姓名：{name}")
print(f"年龄：{age}岁")
print(f"城市：{city}")
print(f"\n{name}，你好！欢迎来自{city}的{age}岁的你！")

# 推荐
user_name = "小明"          # 变量小写 + 下划线（snake_case）
total_score = 95
PI = 3.14159                # 常量全大写
result = 10 + 20            # 运算符两侧加空格
print(1, 2, 3)              # 逗号后加空格

# 不推荐
totalScore = 95             # 驼峰是 Java 风格
result=10+20                # 太挤

user_name = "张三"     # 只能含字母、数字、下划线
age2 = 20             # 可以含数字，但不能以数字开头
_private = "私有"      # 可以下划线开头（约定表示内部使用）

# 2age = 20           # 非法：以数字开头
# user-name = "张三"   # 非法：连字符会被当成减号
# for = 10            # 非法：关键字不能作变量名

x = 10
a = b = c = 0                  # 链式赋值：三个变量都是 0
x, y, z = 1, 2, 3              # 元组解包：x=1, y=2, z=3
name, age = "小红", 18

a, b = 10, 20
a, b = b, a                    # 交换变量：先算右侧 (b, a)，再赋给左侧，无需临时变量
print(a, b)                    # 输出：20 10

name = "小明"                     # 双引号
message = '你好'                  # 单引号，与双引号等价
multi = """这是
多行字符串"""
fruits = ["苹果", "香蕉", "橙子"]
point = (10, 20)                  # 坐标点
person = {"name": "张三", "age": 25}
unique = {1, 2, 3, 3}             # {1, 2, 3}：自动去重

int("18")          # 18
int(3.9)           # 3：int() 直接截断小数，不是四舍五入（四舍五入用 round()）
int(True)          # 1
float("99.9")      # 99.9
float(10)          # 10.0
str(18)            # "18"：拼接字符串前必须转换，或用 f-string
str([1, 2, 3])     # "[1, 2, 3]"

bool(0)          # False（0、0.0 都是 False，-1 等负数为 True）
bool("")         # False（"0" 是字符串，为 True）
bool([])         # False（空 list / tuple / dict / set 都是 False）
bool(None)       # False

price = float(input("价格："))     # 输入 "99.9" → 99.9
quantity = int(input("数量："))    # 输入 "3" → 3
print(f"总价：{price * quantity}")

age = 18
message = "我今年" + str(age) + "岁"   # 字符串拼接前必须 str()，用 f-string 更省事

name = input("姓名：")
if name:         # 非空字符串即真，等价 if name != ""
    print(f"你好，{name}！")

print(10 + 3)    # 13
print(10 - 3)    # 7
print(10 * 3)    # 30
print(10 / 3)    # 3.3333...：除法结果总是 float
print(10 // 3)   # 3：整除，向下取整
print(10 % 3)    # 1：取余，常用于判断奇偶、能否整除
print(2 ** 3)    # 8：幂运算

True and False    # False：两边都真才真
True or False     # True：一边为真即真
not True          # False：取反

age, has_id = 20, True
can_enter = age >= 18 and has_id     # 输出：True(年满18且持有证件可入场)

score = 85
if 80 <= score < 90:                 # 链式比较，等价 score >= 80 and score < 90
    print("良好")

x = 10
x += 5     # x = x + 5 → 15
x -= 3     # 12
x *= 2     # 24
x /= 4     # 6.0
x //= 2    # 3.0
x %= 2     # 1.0

count = 0
count += 1          # 计数器的标准写法

age = 18
if age >= 18:
    print("你成年了")     # 属于 if 块
    print("可以投票")     # 仍属于 if 块
print("程序结束")         # 缩进回退，总会执行

for i in range(3):
    print(f"第{i}次")     # 属于循环体

import keyword
print(keyword.kwlist)
# if, else, elif, for, while, break, continue, def, class, return,
# import, from, as, try, except, finally, raise, with, lambda,
# in, is, not, and, or, pass, global, nonlocal, del, yield, assert,
# True, False, None

if_condition = 10    # 想用关键字含义作名字时，加下划线或改名
class_name = "A"

# 括号内可直接换行（推荐）
total = (1 + 2 + 3 + 4 +
         5 + 6 + 7 + 8)
fruits = ["苹果", "香蕉",
          "橙子", "葡萄"]

# 反斜杠续行：\ 之后不能有任何字符（包括空格和注释）
total = 1 + 2 + \
        3 + 4

x = 10; y = 20        # 分号可在一行写多条语句，但不推荐，可读性差

person = ("张三", 25, "北京")
name, age, city = person                 # 按位置解包
print(f"{name}，{age}岁，来自{city}")

name, age, _, job = ("李四", 30, "上海", "程序员")   # _ 接收并忽略不需要的值
name, age, *others = ("王五", 28, "广州", "设计师", "本科")
print(name, age)                         # 输出：王五 28
print(others)                            # 输出：['广州', '设计师', '本科']：* 收集剩余值

0b1010    # 二进制，等于 10
0o12      # 八进制，等于 10
0xFF      # 十六进制，等于 255（常用于颜色代码、内存地址）

num = 255
bin(num)             # '0b11111111'
oct(num)             # '0o377'
hex(num)             # '0xff'
int('0b11111111', 2)   # 255：int(字符串, 进制) 转回十进制
int('0o377', 8)        # 255
int('FF', 16)          # 255（可省略 0x）

color = "FF0000"
r, g, b = int(color[0:2], 16), int(color[2:4], 16), int(color[4:6], 16)
print(f"RGB: ({r}, {g}, {b})")     # 输出：RGB: (255, 0, 0)

10 / 3       # 3.3333333333333335：/ 总是返回 float，即使能整除（10 / 2 → 5.0）
10 // 3      # 3：整除，向下取整
-10 // 3     # -4：向下取整（-3.5 → -4），不是向零取整
10 % 3       # 1：取余
divmod(10, 3)   # (3, 1)：同时得到商和余数
2 ** 3       # 8：幂运算
9 ** 0.5     # 3.0：开平方
pow(2, 3)    # 8：等价 2 ** 3
pow(2, 3, 5) # 3：模幂，等价 (2 ** 3) % 5

# 优先级（高→低）：() > ** > * / // % > + -
2 + 3 * 4 ** 2 / 8 - 1   # 7.0；不确定时一律加括号

num % 2 == 0              # 判断偶数
num % 5 == 0              # 判断能否被 5 整除

total_seconds = 3665
hours = total_seconds // 3600
minutes = (total_seconds % 3600) // 60
seconds = total_seconds % 60
print(f"{hours}小时{minutes}分钟{seconds}秒")   # 1小时1分钟5秒

future = 10000 * (1 + 0.05) ** 10     # 复利：本金 × (1 + 利率)^年数

abs(-5)              # 5
round(3.14159)       # 3：默认取整
round(3.14159, 2)    # 3.14：保留 2 位小数
max(1, 5, 3)         # 5
min(1, 5, 3)         # 1
sum([1, 2, 3])       # 6

scores = [85, 92, 78, 96, 88]
average = sum(scores) / len(scores)
print(f"最高分：{max(scores)}，最低分：{min(scores)}，平均分：{average:.2f}")

import math
math.pi              # 3.141592653589793
math.e               # 2.718281828459045
math.ceil(3.14)      # 4：向上取整
math.floor(3.99)     # 3：向下取整
math.sqrt(16)        # 4.0
math.pow(2, 3)       # 8.0（返回 float）
math.log(10)         # 自然对数，以 e 为底
math.log10(100)      # 2.0
math.sin(math.pi/2)  # 1.0：三角函数参数是弧度
math.radians(90)     # 角度转弧度 → 1.5707...
math.degrees(math.pi)  # 弧度转角度
math.factorial(5)    # 120

# 两点间距离
distance = math.sqrt((3 - 0)**2 + (4 - 0)**2)   # 5.0

import random
random.random()               # [0.0, 1.0) 随机浮点数
random.randint(1, 10)         # [1, 10] 随机整数，两端都包含
random.uniform(1.0, 10.0)     # [1.0, 10.0] 随机浮点数
random.choice(['red', 'green', 'blue'])   # 从序列随机选一个
random.shuffle(numbers)       # 原地打乱列表
random.sample(range(1, 46), 6)            # 不重复抽 6 个

import string
''.join(random.choices(string.ascii_letters + string.digits, k=8))   # 8 位随机密码

int(3.9)         # 3：截断，不是四舍五入
int("123")       # 123
int("0xFF", 16)  # 255
float(10)        # 10.0
float("3.14")    # 3.14
round(3.9)       # 4：四舍五入用 round()

10 + 3.5         # 13.5：int 与 float 混合运算，结果自动提升为 float

loan = float(input("贷款金额（元）："))
years = int(input("贷款年限："))
rate = float(input("年利率（%）：")) / 100

monthly_rate = rate / 12
months = years * 12
monthly_payment = loan * monthly_rate * (1 + monthly_rate) ** months / \
                  ((1 + monthly_rate) ** months - 1)

print(f"月供：{monthly_payment:.2f}元")
print(f"总还款：{monthly_payment * months:.2f}元")
print(f"总利息：{monthly_payment * months - loan:.2f}元")

print("1. 千克转磅  2. 千米转英里  3. 摄氏度转华氏度")
choice = int(input("选择（1-3）："))

if choice == 1:
    kg = float(input("输入千克："))
    print(f"{kg}千克 = {kg * 2.20462:.2f}磅")
elif choice == 2:
    km = float(input("输入千米："))
    print(f"{km}千米 = {km * 0.621371:.2f}英里")
elif choice == 3:
    c = float(input("输入摄氏度："))
    print(f"{c}°C = {c * 9/5 + 32:.1f}°F")

import random
input("按回车掷骰子...")
die1, die2 = random.randint(1, 6), random.randint(1, 6)
total = die1 + die2
print(f"第一个骰子：{die1}\n第二个骰子：{die2}\n总点数：{total}")

if total in (7, 11):
    print("你赢了！")
elif total in (2, 3, 12):
    print("你输了！")
else:
    print("再来一次！")

poem = '''
床前明月光，
疑是地上霜。
'''

doc = """
这是多行字符串
保留所有格式
"""

name, age, score = "小明", 18, 95.5
print(f"我叫{name}，今年{age}岁，考了{score}分")
print(f"明年我{age + 1}岁")
print(f"平均分：{(90 + 95 + 88) / 3:.2f}")   # 保留2位小数

print(f"|{name:10}|")     # 默认左对齐，宽度10
print(f"|{name:<10}|")    # 左对齐
print(f"|{name:>10}|")    # 右对齐
print(f"|{name:^10}|")    # 居中
print(f"|{name:*^10}|")   # 用 * 填充

text = "Hello, World!"
print(text[0:5])    # Hello
print(text[:5])     # Hello（省略起始=从头）
print(text[7:])     # World!（省略结束=到尾）
print(text[:])      # Hello, World!（整体复制）
print(text[::2])    # Hlo ol!（步长2）
print(text[::-1])   # !dlroW ,olleH（反转）

"hello.py".startswith("hello")  # True
"hello.py".endswith(".py")      # True
"llo" in "hello.py"             # True（包含）
"abc" not in "hello.py"         # True

"123".isdigit()     # True（全数字）
"abc".isalpha()     # True（全字母）
"abc123".isalnum()  # True（字母或数字）
"   ".isspace()     # True（全空白）
"hello".islower()   # True
"HELLO".isupper()   # True

password = input("请输入密码：")

if len(password) < 8:
    print("密码太短，至少8位")
elif not any(c.isdigit() for c in password):
    print("密码必须包含数字")
elif not any(c.isalpha() for c in password):
    print("密码必须包含字母")
elif password.islower() or password.isupper():
    print("密码必须包含大小写字母")
else:
    print("密码强度：强")

students = [("张三", 90, 85, 92), ("李四", 88, 92, 87), ("王五", 95, 89, 91)]

print("姓名\t语文\t数学\t英语\t平均分")
print("-" * 40)
for name, chinese, math, english in students:
    avg = (chinese + math + english) / 3
    print(f"{name}\t{chinese}\t{math}\t{english}\t{avg:.1f}")

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers[2:5]    # [2, 3, 4]
numbers[:3]     # [0, 1, 2]      前3个
numbers[7:]     # [7, 8, 9]      从索引7到末尾
numbers[:]      # 整体浅拷贝
numbers[::2]    # [0, 2, 4, 6, 8]
numbers[1::2]   # [1, 3, 5, 7, 9]
numbers[::-1]   # [9, 8, ..., 0] 反转

numbers = [3, 1, 4, 1, 5, 9, 2]
numbers.sort()                  # 原地升序，返回 None
numbers.sort(reverse=True)      # 原地降序
sorted_numbers = sorted(numbers) # 内置函数，返回新列表，原列表不变

students = [("张三", 90), ("李四", 85), ("王五", 95)]
students.sort(key=lambda s: s[1], reverse=True)   # 按第2个元素（成绩）降序
sorted(["pear", "apple", "fig"], key=len)         # ['fig', 'pear', 'apple']

numbers = [1, 2, 3, 4, 5]
len(numbers)        # 5
max(numbers), min(numbers), sum(numbers)   # 5 1 15

copy1 = numbers.copy()   # 浅拷贝
copy2 = numbers[:]       # 浅拷贝
copy3 = list(numbers)    # 浅拷贝

import copy

a = [1, [2, 3]]
b = a.copy()          # 浅拷贝：外层独立，内层对象仍共用
b[1].append(4)
print(a)              # [1, [2, 3, 4]]  内层被改动

c = copy.deepcopy(a)  # 深拷贝：递归复制，完全独立
c[1].append(5)
print(a)              # [1, [2, 3, 4]]  不受影响

fruits = ["苹果", "香蕉", "橙子"]

for fruit in fruits:              # 只要元素值
    print(fruit)

for i, fruit in enumerate(fruits):  # 同时要索引和元素（推荐）
    print(f"{i}: {fruit}")

for i in range(len(fruits)):      # 需按下标修改元素时用
    fruits[i] = fruits[i].upper()

for i, fruit in enumerate(fruits, 1):  # 起始编号可指定，如从1开始
    print(f"{i}. {fruit}")

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix[1][2])   # 6，第一个索引是行，第二个是列

for row in matrix:          # 外层遍历行，内层遍历列
    for item in row:
        print(item, end=" ")
    print()

scores = []
while True:
    score = input("输入成绩（输入q退出）：")
    if score == 'q':
        break
    scores.append(float(score))

if scores:
    print(f"总分：{sum(scores)}")
    print(f"平均分：{sum(scores) / len(scores):.2f}")
    print(f"最高分：{max(scores)}，最低分：{min(scores)}")

numbers = [1, 2, 2, 3, 3, 3, 4, 4, 5]

unique = list(set(numbers))   # 简单，但不保证顺序

unique = []                   # 保持原顺序
for num in numbers:
    if num not in unique:
        unique.append(num)

cart = []
products = {1: ("苹果", 5.0), 2: ("香蕉", 3.0), 3: ("橙子", 4.0)}

while True:
    for id, (name, price) in products.items():
        print(f"{id}. {name} - ¥{price}")
    choice = input("选择商品（输入0结账）：")
    if choice == "0":
        break
    id = int(choice)
    if id in products:
        cart.append(products[id])

total = sum(price for name, price in cart)
print(f"总计：¥{total}")

todo_list = []

while True:
    print("\n=== 待办事项 ===")
    print("1. 添加任务  2. 查看任务  3. 完成任务  4. 退出")
    choice = input("选择操作：")

    if choice == "1":
        todo_list.append(input("输入任务："))
        print("任务已添加")
    elif choice == "2":
        if todo_list:
            for i, task in enumerate(todo_list, 1):
                print(f"{i}. {task}")
        else:
            print("暂无任务")
    elif choice == "3":
        num = int(input("完成第几个任务？")) - 1
        if 0 <= num < len(todo_list):
            print(f"完成：{todo_list.pop(num)}")   # pop 返回被删元素
    elif choice == "4":
        break

numbers = [1, 2, 3, 2, 4, 3, 5, 1]
duplicates, seen = [], []
for num in numbers:
    if num in seen and num not in duplicates:
        duplicates.append(num)
    seen.append(num)
print(duplicates)   # [2, 3, 1]

numbers = [1, 2, 3, 4, 5]
for num in numbers:            # 错误：删除后索引前移，元素被跳过
    if num % 2 == 0:
        numbers.remove(num)

numbers = [1, 2, 3, 4, 5]
numbers = [n for n in numbers if n % 2 != 0]   # 正确：重建新列表

for i in range(len(numbers) - 1, -1, -1):      # 正确：倒序遍历删除
    if numbers[i] % 2 == 0:
        del numbers[i]

empty = ()            # 空元组，或 tuple()
mixed = (1, "hello", 3.14, True)   # 支持混合类型
point = 1, 2, 3       # 括号可省略（不推荐）
single = (1,)         # 单元素元组必须带逗号

print(type((1,)))   # <class 'tuple'>；type((1)) 是 int，没逗号不算元组

tuple([1, 2, 3])    # (1, 2, 3)，从列表转换
tuple("Python")     # ('P', 'y', 't', 'h', 'o', 'n')
tuple(range(5))     # (0, 1, 2, 3, 4)

fruits = ("苹果", "香蕉", "橙子", "葡萄")
print(fruits[0], fruits[-1])    # 苹果 葡萄
print(fruits[1:3])              # ('香蕉', '橙子')
print(fruits[::2])              # ('苹果', '橙子')

t1, t2 = (1, 2, 3), (4, 5, 6)
t1 + t2        # (1, 2, 3, 4, 5, 6)，拼接生成新元组
(1, 2) * 3     # (1, 2, 1, 2, 1, 2)，重复

fruits.index("香蕉")   # 首次出现的索引
fruits.count("香蕉")   # 出现次数
"苹果" in fruits       # True
len(fruits), max(fruits), min(fruits), sum(fruits)   # 通用函数同样适用

x, y = (10, 20)               # 10 20
a, b = 1, 2
a, b = b, a                   # 交换变量，无需临时变量

numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers   # first=1 middle=[2, 3, 4]（列表） last=5
name, age, *_ = ("张三", 25, "北京", "程序员")   # _ 表示忽略剩余值

def get_student():
    return "小明", 18, 95     # 实为返回一个元组

name, age, score = get_student()   # 函数多返回值靠元组解包接收

import math

points = [(0, 0), (10, 20), (30, 40), (50, 60)]

def distance(p1, p2):
    x1, y1 = p1
    x2, y2 = p2
    return math.sqrt((x2-x1)**2 + (y2-y1)**2)

for i in range(len(points) - 1):          # 相邻点距离
    print(f"{points[i]} 到 {points[i+1]} 距离：{distance(points[i], points[i+1]):.2f}")

students = [("张三", 18, "male", 95), ("李四", 19, "female", 92)]

print("姓名\t年龄\t性别\t成绩")
print("-" * 30)
for name, age, gender, score in students:   # 每行直接解包
    gender_cn = "男" if gender == "male" else "女"
    print(f"{name}\t{age}\t{gender_cn}\t{score}")

student = {"name": "小明", "age": 18}
student["age"] = 19          # key 存在则修改
student["score"] = 95        # key 不存在则新增

del student["score"]         # 按键删除，不存在抛 KeyError
age = student.pop("age")     # 删除并返回 value，可给默认值 pop("age", 0)
item = student.popitem()     # 删除并返回最后一对 (key, value)（3.7+ 保证顺序）
student.clear()              # 清空

original = {"a": 1}
copy1 = original.copy()        # 浅拷贝
copy2 = dict(original)         # 浅拷贝

import copy
nested = {"a": {"b": 1}}
deep = copy.deepcopy(nested)   # 深拷贝，嵌套对象也独立

for key in student:               # 默认遍历 key
    print(key, student[key])

for value in student.values():    # 遍历 value
    print(value)

for key, value in student.items():  # 同时遍历（最常用）
    print(f"{key}: {value}")

from collections import defaultdict

counts = defaultdict(int)     # 不存在的 key 自动取 int() = 0
counts["apple"] += 1          # 不会 KeyError

groups = defaultdict(list)    # 默认值为列表
groups["fruits"].append("apple")

words = "apple banana apple orange banana apple".split()

word_count = {}
for word in words:
    word_count[word] = word_count.get(word, 0) + 1
# {'apple': 3, 'banana': 2, 'orange': 1}

from collections import Counter
Counter(words)   # Counter({'apple': 3, 'banana': 2, 'orange': 1})

students = {
    "张三": {"语文": 90, "数学": 95, "英语": 88},
    "李四": {"语文": 88, "数学": 92, "英语": 90},
}

for name, scores in students.items():
    avg = sum(scores.values()) / len(scores)
    print(f"{name}\t{avg:.1f}")

for subject in ["语文", "数学", "英语"]:   # 每科平均
    avg = sum(s[subject] for s in students.values()) / len(students)
    print(f"{subject}平均分：{avg:.1f}")

inventory = {
    "apple": {"price": 5.0, "quantity": 100},
    "banana": {"price": 3.0, "quantity": 150},
}

def sell(product, quantity):
    if product not in inventory:
        return "商品不存在"
    item = inventory[product]
    if item["quantity"] < quantity:
        return "库存不足"
    item["quantity"] -= quantity
    return f"售出{quantity}个{product}，总价¥{item['price'] * quantity}"