Python基础技术

print('helloworld')

 #动态类型示例

variable = 10  # 初始为整数类型

print(type(variable))  # 输出: <class 'int'>

variable = "hello"  # 运行时改变为字符串类型

print(type(variable))  # 输出: <class 'str'>

#尝试操作可能引发运行时错误

try:

    result = variable + 5  # 字符串和整数相加，会报错

except TypeError as e:

    print(f"错误: {e}")  # 输出: 错误: can only concatenate str (not "int") to str

 

print(0.1+0.2)                #输出结果是0.30000000000000004

print(round(0.1+0.2,1))       #输出结果是0.3

print(round(0.52+0.1314,3))   #输出结果为0.651

print(round(0.52+0.1314,1))   #输出结果为0.7

print(round(0.7))             #输出结果为1 

x=123+456j

print('实数部分为：',x.real)

print('虚数部分为：',x.image)

s='helloworld'

print(s[0],s[-10],s[4])  #输出结果为h h o

print(s[2:7],s[-8:-3])  #输出结果为llowo llowo

print(s[:5],s[5:])  #输出结果为hello world

num=eval(input('请输入密码：'))
if num==5201314:
print('密码正确，你好先生')
elif num==5211314:
print('密码正确，你好女士')
else： 
print('密码错误')

num=eval(input('请输入密码：'))
print('密码正确，你好先生')if num==5201314 else(print('密码正确，你好女士')if num==5211314 else print('密码错误'))

score=input('请输入成绩等级：')
match score:
	case 'A':
			print('优秀')
	case 'B':
			print('及格')
	case 'C':
			print('不及格')
	case _ :
			pass

s=0
for i in range(1,11):  #range函数：产生一个[n,m)的整数序列
	s+=i
print('1到10的累加和为:',s)

numbers = [4, 6, 8, 9, 10]
target = 7
for num in numbers:
    if num == target:
        print(f"找到了目标数字 {target}")
        break
else:  # 循环正常结束（未被 break）时执行
    print(f"列表中没有找到目标数字 {target}")

s=0
i=1  #初始化变量
while i<=100: #条件判断
	s+=i #语句块
	i+=i #改变变量
print('1到100的累加值为：',s)

attempts = 0

while attempts < 3:

    user_input = input("请输入一个数字（如 123）：")

    if user_input.isdigit(): #str.isdigit()所有字符都是数字

        print(f"有效数字：{user_input}")

        break

    else:

        print("输入无效，请重试。")

        attempts += 1

else:  # 循环正常结束（未 break）时执行

    print("连续3次输入无效，程序退出。")

def fibonacci_recursive(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        seq = fibonacci_recursive(n-1)
        seq.append(seq[-1] + seq[-2])
        return seq
# 示例：生成前10个斐波那契数

print(fibonacci_recursive(10))  # 输出: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

def fibonacci_iterative(n):
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    seq = [0, 1]
    while len(seq) < n:
        seq.append(seq[-1] + seq[-2])
    return seq
# 示例：生成前10个斐波那契数
print(fibonacci_iterative(10))  # 输出: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

  for index,item in enumerate(lst) #输出index和item

#for循环
for i in lst:
	print(i)
#根据索引进行遍历
for i in range(0,len(lst)):
	print(i,lst[i])
#用enumerate函数进行遍历
for index,item in enumerate(lst):
print(index,item)

#使用sort方法在原列表上进行更改
#lst.sort(key=None,reverse=False)
#key代表排序规则，reverse代表排序方式，False代表升序
lst=['banana','apple','Cat','Orange']
lst.sort()
print(lst) #输出：['Cat','Orange','apple','banana']
lst.sort(reverse=True)
print(lst) #输出：['banana','apple','Orange','Cat']
lst.sort(key=str.lower) #字符转为小写后比较
print(lst)  #输出：['apple','banana','Cat','Orange']
#使用内置函数sorted（）生成一个新列表
#sorted(iterable,key=None,revers=False)
#iterable表示排序的对象
new__lst=sorted(lst)
new__lst=sorted(lst,reverse=True)
new__lst=sorted(lst,key=str.lower)
#输出与sort方法的输出相同

#lst=[expression for item in range()]
#lst=[expression for item in range() if condition]
#expression是列表中数据的获取方法，item是元素个数，condition是判断条件
import random
lst=[item for item in range(1,11)]
print(lst) #输出：[1,2,3,4,5,6,7,8,9,10]
lst=[item*item for item in range(1,11)]
print(lst) #输出：[1,4,9,16,25,36,49,64,81,100]
lst=[random.randint(1,100) for _ in range(1,11)] #randint:生成随机整数
print(lst) #输出：[50,25,31,62,46,54,88,84,86,91]
lst=[i for i in range(10) if i%2==0]
print(lst) #输出：[0,2,4,6,8]

#读取二维列表
for row in lst:
	for item in row:
		pass
#生成二维列表
lst=[[j for j in range(5)] for i in range(4)] #j代表几列，i代表几行
for j in lst: #这个二维列表有几行
	for i in j: #这个二维列表每行有几列
		print(i,end='\t')
	print()

#查找
t=(1,2,3,4,5)
print(t[0])  #输出：1
#切片
t2=t[0:5:2] #从元组t的第0位开始取，取到第4位，中间间隔为2
print(t2) #输出（1,3,5）

#for循环
for item in t:
	print(item)
#根据索引进行遍历
for i in range(len(t)):
	print(i,t[i])
#使用enumerate函数枚举遍历
for index,item in enumerate(t):
	print(index,item)

元组名=(i for i in range(a,b))
元组名=tuple(序列)
元组名=(i for i in range(a,b) if 条件)

t=(1,2,3)
print(t.__next__()) #输出：1
print(t.__next__()) #输出：2
print(t.__next__()) #输出：3
print(t) #输出：（）

v=zip(lst1,lst2)

d=dict(v)

#遍历出key与value的元组

for element in d.items():

	pass

#分别遍历出key和value

for key,value in d.items():

	pass

d={key:value for item in range()}

d={key:value for key,value in zip(lst1,lst2)}

#for循环
for item in s:
	pass
#使用enumerate函数
for index,item in enumerate(s)
	print(index,item)

s={i for i in range(a,b)}
s={i for i in range(a,b) if 条件}

def 函数名称(参数列表):

	函数体

	[return返回值列表]

name, age, city = get_user_info()
print(name)  # 输出：Alice
print(age)   # 输出：30
print(city)  # 输出：Beijing
#变量数量与元组元素数量必须一致

#使用星号（*）表达式捕获多个元素
# 示例：获取前1个元素，剩余元素用列表接收
user_info = ("Alice", 30, "Beijing", "female", "programmer")
name, *others = user_info
print(name)    # 输出：Alice
print(others)  # 输出：[30, 'Beijing', 'female', 'programmer']
# 示例：获取中间元素，前后用列表接收
before, city, after = user_info
print(before)  # 输出：['Alice', 30]
print(city)    # 输出：Beijing
print(after)   # 输出：female, programmer（注意：如果after不加'*'这里after只接收最后1个元素）
#用_忽略不需要的元素
user_info = ("Alice", 30, "Beijing")
name, , city = userinfo  # 忽略age
print(name)  # 输出：Alice
print(city)  # 输出：Beijing
#结合*和_忽略多个元素
user_info = ("Alice", 30, "Beijing", "female", "programmer")
name, *_, job = user_info  # 忽略中间的30、Beijing、female
print(name)  # 输出：Alice
print(job)   # 输出：programmer

#对复杂结构（如字典、元组）排序时，用 lambda 指定排序键：
students = [("Alice", 20), ("Bob", 18), ("Charlie", 22)]
# 按年龄排序（第二个元素）
sorted_by_age = sorted(students, key=lambda x: x[1])
print(sorted_by_age)  # 输出：[('Bob', 18), ('Alice', 20), ('Charlie', 22)]
#筛选可迭代对象中符合条件的元素：
numbers = [1, 2, 3, 4, 5, 6]
# 筛选偶数
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出：[2, 4, 6]
#对可迭代对象中的元素做转换：
numbers = [1, 2, 3, 4]
# 计算每个数的平方
squared = list(map(lambda x: x **2, numbers))
print(squared)  # 输出：[1, 4, 9, 16]

#当函数需要返回另一个简单函数时，lambda 可以替代def定义的嵌套函数，使代码更紧凑。
def make_adder(n):
    # 返回一个“加n”的函数
    return lambda x: x + n
add5 = make_adder(5)
print(add5(3))  # 输出：8（3+5）
print(add5(10)) # 输出：15（10+5）

# 用字典存储不同的计算逻辑
operations = {
    "add": lambda a, b: a + b,
    "subtract": lambda a, b: a - b,
    "multiply": lambda a, b: a * b
}
print(operations["add"](2, 3))      # 输出：5
print(operations["subtract"](5, 2)) # 输出：3
# 在字典或列表中需要嵌入简单的操作逻辑时，lambda 可以避免单独定义函数，使代码更集中。

import math  # 导入 math 模块
print(math.pi)  # 通过模块名访问成员
print(math.sqrt(16))  # 调用模块中的函数
# 使用别名简化访问
import math as m
print(m.pi)  # 等价于 math.pi

# 导入指定成员
from math import pi, sqrt
print(pi)  # 直接使用成员名
print(sqrt(16))
# 为成员指定别名
from math import pi as圆周率
print(圆周率)
# 导入所有成员（不推荐）
from math import *
print(cos(0))  # 可以直接使用 math 中的所有公开成员

# 1. 读取文件（r模式）

with open("test.txt", "r", encoding="utf-8") as f:

    content = f.read()  # 读取全部内容（字符串）

    print(content)

# 2. 写入文件（w模式）

with open("test.txt", "w", encoding="utf-8") as f:

    f.write("Hello, World!")  # 覆盖原有内容

# 3. 追加内容（a模式）

with open("test.txt", "a", encoding="utf-8") as f:

    f.write("\nAppend this line.")  # 新增内容到末尾

# 1. 读取图片（二进制文件）

with open("image.png", "rb") as f:

    data = f.read()  # 读取字节流（bytes类型）

# 2. 复制图片（二进制读写）

with open("image.png", "rb") as src, open("copy.png", "wb") as dst:

    dst.write(src.read())  # 直接写入字节流

# 风险：若中间代码报错，可能导致文件未关闭

f = open("test.txt", "r")

content = f.read()

f.close()  # 必须手动调用，否则资源可能泄露

# 安全：无论是否发生异常，文件都会自动关闭

with open("test.txt", "r") as f:

    content = f.read()

# 离开 with 代码块后，f 已自动关闭，无需手动操作

class MyFile:
    def init(self, filename, mode):
        self.filename = filename
        self.mode = mode
        
    def enter(self):
        self.file = open(self.filename, self.mode)
        return self.file  # 返回资源给 as 后的变量

    
    def exit(self, exc_type, exc_val, exc_tb):
        self.file.close()  # 自动释放资源
        # 处理异常（可选）
        if exc_type:
            print(f"发生异常：{exc_val}")
        return False  # 不抑制异常，让其继续传播
# 使用自定义上下文管理器
with MyFile("test.txt", "w") as f:
    f.write("Hello, Context Manager!")

with open("data.csv", "r", encoding="utf-8") as f:

    for line in f:

        print(line.strip())

import sqlite3

with sqlite3.connect("mydb.db") as conn:

    cursor = conn.cursor()

    cursor.execute("SELECT * FROM users")

# 离开代码块后，连接自动关闭

import socket

with socket.socket() as s:

    s.connect(("example.com", 80))

    s.send(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")

# 套接字自动关闭

import threading

lock = threading.Lock()

with lock:

    # 临界区代码（自动获取和释放锁）

    pass

try:
    # 可能触发异常的代码
    num = int(input("请输入数字："))
    result = 10 / num
    print(f"结果：{result}")

except ValueError:
    print("错误：输入不是有效的数字")

except ZeroDivisionError:
    print("错误：除数不能为零")

except Exception as e:
    # 捕获其他未预料的异常
    print(f"发生未知错误：{e}")

try:
    # 可能发生异常的代码块（核心逻辑）
    risky_operation()

except 异常类型1 [as 变量名]:
    # 若发生「异常类型1」，执行此处代码（处理异常）
    handle_error_type1()

except (异常类型2, 异常类型3) [as 变量名]:
    # 若发生「异常类型2」或「异常类型3」，执行此处代码
    handle_error_type2_or_3()

else:
    # 若 try 块无异常，执行此处代码（可选）
    no_error_operation()

finally:
    # 无论是否发生异常，都会执行此处代码（释放资源等）
    must_execute_operation()

def read_file_safely(filename):
    file = None  # 初始化变量，避免未定义错误

    try:
        file = open(filename, "r", encoding="utf-8")
        content = file.read()
        print("文件内容：", content[:100])  # 打印前100字符
        return "读取成功"  # 无异常时返回

    except FileNotFoundError:
        print(f"错误：文件 '{filename}' 不存在")
        return "读取失败"  # 异常时返回

    except UnicodeDecodeError as e:
        print(f"错误：文件编码异常 - {e}")
        return "读取失败"
    else:
        print("额外操作：文件读取无异常，记录日志")  # 仅无异常时执行

    finally:
        # 无论是否异常，确保文件关闭
        if file:
            file.close()
            print("资源释放：文件已关闭")

# 测试：文件存在且正常
read_file_safely("test.txt")

# 测试：文件不存在
read_file_safely("nonexist.txt")

def demo():

      try:

          return 1  # 尝试返回

      finally:

          print("finally 执行了")  # 仍会执行

  demo()  # 输出：finally 执行了，返回值 1

# 定义一个"人"类（模板）
class Person:
    # 属性（特征）
    def init(self, name, age):
        self.name = name  # 姓名
        self.age = age    # 年龄

    

    # 方法（行为）
    def speak(self):
        print(f"我叫{self.name}，今年{self.age}岁")

# 创建对象（具体实例）
person1 = Person("张三", 20)  # 第一个对象
person2 = Person("李四", 30)  # 第二个对象

# 调用对象的方法
person1.speak()  # 输出：我叫张三，今年20岁
person2.speak()  # 输出：我叫李四，今年30岁

#在这个例子中，`Person`是类，`person1`和`person2`是根据该类创建的两个不同对象，它们都有`name`、`age`属性和`speak()`方法，但属性值不同。

class Person:

    # 构造方法：初始化实例属性
    def init(self, name, age):  # name和age是外部传入的参数
        self.name = name  # 定义并初始化实例属性name
        self.age = age    # 定义并初始化实例属性age

    def introduce(self):
        # 通过self访问实例属性
        print(f"我叫{self.name}，今年{self.age}岁")

# 创建对象时，自动调用__init__，传入参数初始化属性
p1 = Person("张三", 20)
p2 = Person("李四", 30)

# 访问实例属性
print(p1.name)  # 输出：张三
print(p2.age)   # 输出：30

# 调用方法（方法内部使用了实例属性）
p1.introduce()  # 输出：我叫张三，今年20岁

  class Person:
      def init(self, name, age=18):  # age默认值为18
          self.name = name
          self.age = age
  p = Person("王五")  # 不传入age，使用默认值18
  print(p.age)  # 输出：18

 p1 = Person("张三", 20)

  p1.gender = "男"  # 动态添加gender属性

# 父类（基类）
class Parent:
    def parent_method(self):
        print("这是父类的方法")

# 子类（派生类），继承自Parent
class Child(Parent):
    def child_method(self):
        print("这是子类的方法")

# 子类对象可以调用父类和自身的方法
c = Child()
c.parent_method()  # 输出：这是父类的方法（继承自父类）
c.child_method()   # 输出：这是子类的方法（自身方法）

class Animal:
    def speak(self):
        print("动物发出声音")

# 子类Dog重写speak方法
class Dog(Animal):
    def speak(self):  # 与父类方法同名
        print("汪汪汪")

# 子类Cat重写speak方法
class Cat(Animal):
    def speak(self):  # 与父类方法同名
        print("喵喵喵")

dog = Dog()
dog.speak()  # 输出：汪汪汪（调用重写后的方法）
cat = Cat()
cat.speak()  # 输出：喵喵喵（调用重写后的方法）

#在构造方法中使用super()
class Person:
    def init(self, name, age):
        self.name = name
        self.age = age

class Student(Person):
    def init(self, name, age, school):
        # 调用父类的__init__方法，初始化name和age
        super().__init__(name, age)
        # 子类新增属性
        self.school = school
    def introduce(self):
        print(f"我叫{self.name}，{self.age}岁，在{self.school}上学")

s = Student("张三", 18, "北京大学")
s.introduce()  # 输出：我叫张三，18岁，在北京大学上学

 

#在重写方法中使用super()

class Animal:
    def move(self):
        print("动物在移动")

class Bird(Animal):
    def move(self):
        # 先调用父类的move方法
        super().move()
        # 再添加子类特有的逻辑
        print("鸟在飞翔")

bird = Bird()
bird.move()

# 输出：
# 动物在移动
# 鸟在飞翔

#定义一个Book类，打印时显示书籍的基本信息
class Book:
    def init(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    # 自定义字符串表示
    def str(self):
        return f"《{self.title}》- 作者：{self.author}（{self.pages}页）"
book = Book("Python编程", "张三", 300)
print(book)  # 自动调用__str__()，输出：《Python编程》- 作者：张三（300页）
print(str(book))  # 同样调用__str__()，输出同上

#定义一个ShoppingCart类，用len()获取购物车中商品数量
class ShoppingCart:
    def init(self):
        self.items = []  # 存储商品的列表

    def add_item(self, item):
        self.items.append(item)

    # 定义len()的返回值为商品数量
    def len(self):
        return len(self.items)

cart = ShoppingCart()
cart.add_item("苹果")
cart.add_item("香蕉")
print(len(cart))  # 自动调用__len__()，输出：2

#定义一个StudentList类，支持用索引访问学生
class StudentList:
    def init(self):
        self.students = []

    # 支持obj[index]取值
    def getitem(self, index):
        return self.students[index]

    # 支持obj[index] = value赋值
    def setitem(self, index, value):
        self.students[index] = value

students = StudentList()
students.students = ["张三", "李四", "王五"]
print(students[0])  # 调用__getitem__()，输出：张三
students[1] = "赵六"  # 调用__setitem__()
print(students[1])  # 输出：赵六

#定义一个Vector类，实现向量的加法
class Vector:
    def init(self, x, y):
        self.x = x
        self.y = y

    # 自定义加法：两个向量的x和y分别相加
    def add(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def str(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(2, 3)
v2 = Vector(4, 5)
v3 = v1 + v2  # 自动调用__add__()
print(v3)  # 输出：Vector(6, 8)

#定义一个Account类，余额为0时视为False
class Account:
    def init(self, balance=0):
        self.balance = balance

    # 余额为0时返回False，否则返回True
    def bool(self):
        return self.balance > 0

acc1 = Account(100)
acc2 = Account(0)

if acc1:
    print("账户1有余额")  # 会执行

if acc2:
    print("账户2有余额")  # 不会执行

#os模块常用功能
import os

# 获取当前工作目录
current_dir = os.getcwd()
print(f"当前工作目录: {current_dir}")

# 列出目录中的文件和文件夹
files = os.listdir(current_dir)
print(f"目录内容: {files}")

# 创建目录
new_dir = "test_dir"
os.mkdir(new_dir)

# 重命名文件/目录
os.rename(new_dir, "new_test_dir")

# 删除目录
os.rmdir("new_test_dir")

# 获取环境变量
path_var = os.environ.get("PATH")
print(f"PATH环境变量: {path_var}")

# 执行系统命令
os.system("echo Hello from system command!")

#sys模块常用功能
import sys

# 获取命令行参数
print(f"命令行参数: {sys.argv}")

# 获取Python解释器版本信息
print(f"Python版本: {sys.version}")

# 获取系统平台
print(f"系统平台: {sys.platform}")

# 标准输出重定向
print("这是标准输出")
sys.stdout.write("这也是标准输出\n")

# 退出程序
sys.exit(0)  # 0表示正常退出，非0表示异常退出

# 获取模块搜索路径
print(f"模块搜索路径: {sys.path}")

#获取当前时间
from datetime import datetime, date, time

# 获取当前日期时间（datetime对象）
now = datetime.now()
print("当前时间:", now)  # 输出：2023-10-15 14:30:45.123456

# 获取当前日期（date对象）
today = date.today()
print("当前日期:", today)  # 输出：2023-10-15

# 单独获取年、月、日、时、分、秒
print("年:", now.year)     # 2023
print("月:", now.month)    # 10
print("日:", now.day)      # 15
print("时:", now.hour)     # 14
print("分:", now.minute)   # 30
print("秒:", now.second)   # 45

#创建指定时间
from datetime import datetime, date, time

# 创建指定日期时间（datetime）
dt = datetime(2023, 10, 1, 8, 30, 0)
print("指定时间:", dt)  # 2023-10-01 08:30:00

# 创建指定日期（date）
d = date(2023, 12, 25)
print("指定日期:", d)  # 2023-12-25

# 创建指定时间（time）
t = time(18, 45, 30)
print("指定时间:", t)  # 18:45:30

#时间格式转换（字符串与datetime互转）
#strftime()：将 datetime 转为字符串（格式化输出）
#strptime()：将字符串转为 datetime（解析输入）
from datetime import datetime

# datetime -> 字符串（格式化）
now = datetime.now()
str1 = now.strftime("%Y-%m-%d %H:%M:%S")  # 年-月-日 时:分:秒
str2 = now.strftime("%Y年%m月%d日 %H时%M分")  # 中文格式
print("格式化后:", str1)  # 2023-10-15 14:30:45
print("中文格式:", str2)  # 2023年10月15日 14时30分

# 字符串 -> datetime（解析）
str_time = "2023-10-01 08:30:00"
dt = datetime.strptime(str_time, "%Y-%m-%d %H:%M:%S")
print("解析后的时间:", dt)  # 2023-10-01 08:30:00

"""

常用格式化符号
%Y：四位数年份（如 2023）
%m：两位数月份（01-12）
%d：两位数日期（01-31）
%H：24小时制小时（00-23）
%M：分钟（00-59）
%S：秒（00-59）

"""

# 时间间隔计算（timedelta）
#timedelta 用于表示时间差，可直接与 datetime 进行加减运算。
from datetime import datetime, timedelta
now = datetime.now()
# 计算3天后的时间
future = now + timedelta(days=3)
print("3天后:", future)  # 2023-10-18 14:30:45.123456
# 计算1小时30分钟前的时间
past = now - timedelta(hours=1, minutes=30)
print("1小时30分钟前:", past)  # 2023-10-15 13:00:45.123456
# 计算两个时间的差
delta = future - past
print("时间差（天）:", delta.days)          # 3
print("时间差（总秒数）:", delta.total_seconds())  # 270000.0（3天×86400秒）

#时区处理
#使用 pytz 库（需安装：pip install pytz）或 Python 3.9+ 的 zoneinfo 处理时区。
from datetime import datetime
import pytz  # 第三方时区库
# 获取纽约时间（UTC-4/UTC-5，随季节变化）
ny_tz = pytz.timezone('America/New_York')
ny_time = datetime.now(ny_tz)
print("纽约时间:", ny_time.strftime("%Y-%m-%d %H:%M:%S"))
# 获取北京时区（UTC+8）
bj_tz = pytz.timezone('Asia/Shanghai')
bj_time = datetime.now(bj_tz)
print("北京时间:", bj_time.strftime("%Y-%m-%d %H:%M:%S"))

import json
# 定义一个 Python 字典（可序列化的对象）

data = {
    "name": "Alice",
    "age": 30,
    "is_student": False,
    "hobbies": ["reading", "hiking"],
    "address": {
        "city": "New York",
        "zipcode": "10001"
    },
    "score": None
}

# 使用 dumps() 转为 JSON 字符串
json_str = json.dumps(data)
print("JSON 字符串:", json_str)
# 输出：{"name": "Alice", "age": 30, "is_student": false, "hobbies": ["reading", "hiking"], "address": {"city": "New York", "zipcode": "10001"}, "score": null}
# 格式化输出（更易读）
pretty_json = json.dumps(data, indent=4, ensure_ascii=False)
print("格式化 JSON:")
print(pretty_json)

"""
dumps() 常用参数：
indent：指定缩进空格数，美化输出
ensure_ascii：默认 True（非 ASCII 字符转义），设为 False 可保留中文等字符
sort_keys：设为 True 可按 key 排序
"""

import json
# JSON 字符串

json_str = '''
{
    "name": "Bob",
    "age": 25,
    "is_student": true,
    "hobbies": ["coding", "gaming"],
    "address": {
        "city": "London",
        "zipcode": "SW1A 1AA"
    },

    "score": null

}
'''
# 使用 loads() 转为 Python 字典
python_data = json.loads(json_str)
print("Python 对象类型:", type(python_data))  # <class 'dict'>
print("姓名:", python_data["name"])          # Bob
print("爱好:", python_data["hobbies"][0])    # coding

import json
data = {"name": "Charlie", "age": 35}
# 序列化并写入文件（dump()）
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=4, ensure_ascii=False)
# 从文件读取并反序列化（load()）
with open("data.json", "r", encoding="utf-8") as f:
    loaded_data = json.load(f)
    print("从文件读取的数据:", loaded_data)  # {'name': 'Charlie', 'age': 35}

import json
class Person:
    def init(self, name, age):
        self.name = name
        self.age = age

# 自定义序列化函数
def person_serializer(obj):
    if isinstance(obj, Person):
        return {"name": obj.name, "age": obj.age, "type": "Person"}
    raise TypeError(f"无法序列化 {type(obj)} 类型的对象")

# 创建自定义对象
person = Person("David", 40)

# 使用 default 参数指定序列化函数
json_str = json.dumps(person, default=person_serializer, indent=4)
print(json_str)

# 输出：
# {
#     "name": "David",
#     "age": 40,
#     "type": "Person"
# }

import random

# 生成 [0.0, 1.0) 之间的随机浮点数

print(random.random())  # 示例：0.783421569

# 生成 [1.5, 3.5] 之间的随机浮点数

print(random.uniform(1.5, 3.5))  # 示例：2.8912345

import random
# 生成 1-10 之间的随机整数（包含1和10）
print(random.randint(1, 10))  # 示例：7
# 从 0-20 中随机选择偶数（步长为2）
print(random.randrange(0, 21, 2))  # 示例：14

import random
fruits = ["苹果", "香蕉", "橙子", "草莓"]

# 随机选择一个水果
print(random.choice(fruits))  # 示例：香蕉

# 带权重随机选择（草莓被选中概率更高）
print(random.choices(fruits, weights=[1, 1, 1, 3], k=2))  # 示例：['草莓', '橙子']

import random

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

random.shuffle(nums)  # 原地打乱

print(nums)  # 示例：[3, 1, 5, 2, 4]

import random
cards = ["红桃A", "黑桃K", "方块Q", "梅花J", "大王"]
# 随机抽取2张不重复的牌
print(random.sample(cards, 2))  # 示例：['黑桃K', '梅花J']

import random
# 设置种子
random.seed(10)
print(random.randint(1, 100))  # 结果固定为 73
# 再次设置相同种子，结果相同
random.seed(10)
print(random.randint(1, 100))  # 仍然输出 73

import random
# 生成均值为0，标准差为1的高斯随机数
print(random.gauss(0, 1))  # 示例：0.283456