国内常用镜像源

清华大学 ：https://pypi.tuna.tsinghua.edu.cn/simple/

阿里云：http://mirrors.aliyun.com/pypi/simple/

中国科学技术大学 ：http://pypi.mirrors.ustc.edu.cn/simple/

华中科技大学：http://pypi.hustunique.com/

豆瓣源：http://pypi.douban.com/simple/

腾讯源：http://mirrors.cloud.tencent.com/pypi/simple

华为镜像源：https://repo.huaweicloud.com/repository/pypi/simple/

数据类型

数字型： bool int float
⾮数字型： str list tuple set dict
⽇期型： time datetime

例子：

sno=1
age=18
sname="小明"
high=1.786
print(f"{sname}学号为{sno},年龄为{age}岁,身高为{high}米")
print(f"{sname}学号为{sno:05d}，年龄为{age}岁，身高为{high:.2f}米")

1	f'{value}'格式化输出

输⼊

使⽤ input 函数来接收⽤⼾从键盘输⼊ ,input 输⼊的内容是字符串型

passwd=input(“ 请输⼊密码： “) print(type(passwd)) 我们使⽤ int() 、 float() 、 str() 等转换。

运算符

算数： + - * / %( 取余 ) **( 幂 ) //( 取商 )
⽐较： == != > >= < <=
赋值： = += -= *= /= **= //=
逻辑： and or not

流程控制

选择结构 if

sex="女"
 if sex=="男":
 print("打游戏")
 elif sex=="女":
 print("去逛街")
 else:
 print("其他")

循环结构 while 和 for

# 循环输出1-10数字
i= 1
 while  i<=10:
 print(i)
 i+=1
 # 字符串可以直接循环输出里面的字符
names="hello world*你好"
 for i in names:
 print(i)
 # 数值范围
for i in range(10): 
print(i)

字符串 (String)

拼接 * 复制 “”” 保留格式
字符串的索引截取，变量名 [ 头下标 : 尾下标 ]
索引值以 0 为开始值，-1 为从末尾的开始位置。

#索引切片
s="abcsdfsdf"
print(s[2])
print(s[0:4]) #做切片的时候，是左闭右开的，也就是不包括右边数字对应的下标索引
print(s[2:]) 
print(s[0:6:2]) #步长为2

字符串函数	含义
len(str)	获取字符串长度
str.find(‘str’,int1,int2)	字符查找 ,找到返回索引，没找到返回-1.。int1，int2分别代表开始索引和结束索引
str.rfind()	代表从右侧开始查找
str.isdigit()	所有字符都是数字
str.count()	统计字符串里某个字符或子字符串出现的次数

Python 中的字符 ASCII 码运算

ASCII码表

在 Python 中，字符的 ASCII 码运算可以通过 ord() 和 chr() 函数实现，允许你对字符进行数值操作。以下是详细解释和示例：

核心函数

ord(char) - 获取字符的 ASCII 码值

1
2
3

print(ord('A'))  # 输出: 65 (大写字母 A)
print(ord('a'))  # 输出: 97 (小写字母 a)
print(ord('0'))  # 输出: 48 (数字 0)

chr(code) - 将 ASCII 码转换为字符

1
2
3

print(chr(65))  # 输出: 'A'
print(chr(97))  # 输出: 'a'
print(chr(48))  # 输出: '0'

ASCII 码运算示例

1. 字符大小写转换

# 大写转小写
char = 'B'
lower_char = chr(ord(char) + 32)
print(lower_char)  # 输出: 'b'

# 小写转大写
char = 'z'
upper_char = chr(ord(char) - 32)
print(upper_char)  # 输出: 'Z'

2. 字符移位（凯撒密码）

def caesar_cipher(text, shift):
    result = ""
    for char in text:
        if char.isalpha():
            base = ord('A') if char.isupper() else ord('a')
            shifted = (ord(char) - base + shift) % 26 + base
            result += chr(shifted)
        else:
            result += char
    return result

encrypted = caesar_cipher("Hello, World!", 3)
print(encrypted)  # 输出: "Khoor, Zruog!"

decrypted = caesar_cipher(encrypted, -3)
print(decrypted)  # 输出: "Hello, World!"

3. 字符比较

char1 = 'a'
char2 = 'z'

# 比较 ASCII 码值
print(ord(char1) < ord(char2))  # 输出: True (97 < 122)

4. 计算字符位置

letter = 'G'
position = ord(letter) - ord('A') + 1
print(f"'{letter}' 是字母表中的第 {position} 个字母")
# 输出: 'G' 是字母表中的第 7 个字母

5. 生成字母序列

# 生成 A 到 Z
uppercase = [chr(i) for i in range(ord('A'), ord('Z')+1)]
print(uppercase)  # ['A', 'B', 'C', ..., 'Z']

# 生成 a 到 z
lowercase = [chr(i) for i in range(ord('a'), ord('z')+1)]
print(lowercase)  # ['a', 'b', 'c', ..., 'z']

ASCII 码表摘要

字符范围	ASCII 范围	示例
数字 0-9	48-57	`ord('0') = 48`
大写字母 A-Z	65-90	`ord('A') = 65`
小写字母 a-z	97-122	`ord('a') = 97`
特殊符号	32-47, 58-64, 91-96, 123-126	`ord('@') = 64`

重要注意事项

Unicode 支持：
- Python 3 使用 Unicode，ord() 返回 Unicode 码点
- ASCII 字符的 Unicode 码点与 ASCII 值相同

超出 ASCII 范围：

1
2
3

# 处理非 ASCII 字符
print(ord('中'))  # 输出: 20013 (中文字符的 Unicode)
print(chr(20013))  # 输出: '中'

边界检查：

# 确保在有效范围内操作
try:
    print(chr(ord('z') + 1))  # 超出小写字母范围
except ValueError as e:
    print(f"错误: {e}")

实际应用场景

数据加密/解密：实现简单的替换密码
文本处理：大小写转换、字符分类
算法实现：排序、搜索、字符串比较
编码转换：在不同字符编码间转换
输入验证：检查字符类型和范围

# 实用函数：检查字符是否为数字
def is_digit(char):
    return ord('0') <= ord(char) <= ord('9')

print(is_digit('5'))  # 输出: True
print(is_digit('a'))  # 输出: False

list （列表）

List （列表）是 Python 中使⽤最频繁的数据类型。

专⻔⽤于存储⼀串数据，存储的数据称为元素

列表⽤ [] 定义，元素之间⽤逗号分隔

列表可以完成⼤多数集合类的数据结构实现。列表中元素的类型可以不相同，它⽀持数字，字符串甚⾄可以包含列表（所谓嵌套）。列表和字符串⼀样，索引从 0 开始，列表同样可以被索引和截取，列表被截取后返回⼀个包含所需元素的新列表。

List 可以使⽤ + 操作符进⾏拼接。
⽤星号 * 是重复操作
创建空列表： []

列表的常⽤操作

分类	关键字/函数/方法	说明
增加	列表.append(值)	向列表末尾追加单个元素
	列表.extend(值1,值2···，值n)	向列表后面追加多个元素
	列表.insert(index,值)	将某个元素插放到指定位置
	列表.pop(index)	删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系
	del 列表[1:2]	按照切片指定索引删除列表元素
	列表.clear()	按照切片指定索引删除列表元素
修改	列表[索引]=值	修改指定索引的数据，数据不存在会报错
查询	列表[索引]	根据索引取值，索引不存在会报错
	列表.index(值)	根据值取索引，值不存在会报错
	列表.count(值）	返回列表中包含某个值的个数
	列表.sort()	将列表中的元素进行排序，reverse=True代表降序
	列表.reverse()	列表的反转，用来改变原列表的先后顺序
	len(列表)	列表长度（元素个数）
	max(列表）	返回列表元素最大值
	min(列表)	返回列表元素最小值
	sum(列表)	返回列表元素的总和

字符串与列表转换

split 分割字符串为列表
join 拼接列表为字符串

txt = "Google#Run,oob#Taobao#Facebook"
stxt=txt.split("#") #列表类型
print(stxt[2]) #同字符串一样切片

for i in stxt:
print(i) #单词打印而不是字符打印
n=".".join(stxt) #字符串类型
print(n)

tuple （元组）只读的列表。

tuple1 = (1,2,34,5,6)
print(type(tuple1))
print(tuple1[3])
for i in tuple1:
 	print(i)

set （集合）⽆序，去掉重复数据。

set1 = {1,2,3,4,5,5,4,3,2,1}
print(type(set1))
print(set1)
set2.add(66666)
set2.remove(55)

不能使用下标访问set，所以修改操作一般为remove操作 + add操作

问题：如何定义一个空集合？

1 2	set1=set() # 正确的类型声明是类型关键字()

正确的类型声明是类型关键字()

dict （字典）

字典（ dict ）是 Python 中另⼀个⾮常有⽤的内置数据类型。

字典是键 (key) : 值 (value) 的集合。
在同⼀个字典中，键 (key) 必须是唯⼀的。重复的后面的会覆盖前面的
创建空字典使⽤ { } 。

分类	函数	说明
增加	dict[key]=value	键不存在，会添加键值对
修改	dict[key]=value	键存在，会修改键值对
删除	pop/del/clear	没有索引
查询	dict .keys()	获取所有键，是一个视图
	dict.values()	获取所有值，是一个视图
	dict.items()	获取键值对

在Python中，for i in dict: 循环迭代的是字典的键‌。在Python中，字典是一种键值对集合，每个键对应一个值。当你使用 for i in dict: 语法时，循环会遍历字典中的所有键，并将每个键依次赋值给变量 i‌12。

此外，Python还提供了其他几种遍历字典的方法：

‌遍历键‌：使用 .keys() 方法，例如 for key in dict.keys():。
‌遍历值‌：使用 .values() 方法，例如 for value in dict.values():。
‌遍历键值对‌：使用 .items() 方法，例如 for key, value in dict.items():‌12。

推导式

推导式格式为：表达式 for 变量 in 输⼊源 if 条件

推导式格式为：表达式 for 变量 in 输⼊源 if 条件 for 变量 in 输⼊源 if 条件

# 给定一个列表,将每一位数字变成它的平方 alist = [1, 2, 3, 4, 5, 6, 7]
# 输出结果：[1, 4, 9, 16, 25, 36, 49]
alist = [1, 2, 3, 4, 5, 6, 7]
print([i**2 for i in alist])
print([i**2 for i in alist if i+2>5])
print({i**2 for i in alist})
print(tuple((i**2 for i in alist)))
print({i**2:f"test{i}" for i in alist})
#推导 30 以内可以被 3 整除的整数为列表：
print([i for i in range(30) if i % 3 == 0])

数据源使⽤字典

d1={"张三":20,"李四":30,"王五":40}
 # 推导列表
print([i for i in d1.values()])
 # 推导字典
print({i:i**2 for i in d1.values() if i>20})
 # 推导集合
print({i for i in d1.values() if i>20})
 # 推导元组
print(tuple((i for i in d1.values() if i>20)))
 # 二重循环 提取数字为列表[45,67,45,34,65,78]
l1=[[45,67,45,"hhh"],[34,65,78,"test"]]
print([j for i in l1 for j in i if type(j)==int])

list 、tuple、set、dict的区别

在 Python 中，list（列表）、tuple（元组）、set（集合）和 dict（字典）是四种核心数据结构，它们在特性、用途和性能上有显著区别：

📋 1. List（列表）

特性：有序集合，可变（可修改）
语法：[元素1, 元素2, ...]
特点：
- 保持元素插入顺序
- 允许重复元素
- 元素可以是不同类型
- 通过索引访问（list[0]）

操作：

1
2
3

fruits = ["apple", "banana", "cherry"]
fruits.append("orange")    # 添加元素
fruits[1] = "mango"       # 修改元素

时间复杂度：
- 访问：O(1)
- 插入/删除末尾：O(1)
- 插入/删除中间：O(n)
使用场景：需要保持顺序且可能修改的数据集合

📦 2. Tuple（元组）

特性：有序集合，不可变（创建后不能修改）
语法：(元素1, 元素2, ...) 或单元素 (元素,)
特点：
- 比列表更节省内存
- 可哈希（可作为字典键）
- 保持元素插入顺序
- 允许重复元素

操作：

1
2
3

colors = ("red", "green", "blue")
print(colors[0])          # 访问元素
# colors[1] = "yellow"    # 错误！不可修改

时间复杂度：访问 O(1)
使用场景：固定数据集合（如坐标点、数据库记录）、字典键

🧺 3. Set（集合）

特性：无序集合，可变，元素唯一
语法：{元素1, 元素2, ...} 或 set(iterable)
特点：
- 自动去重
- 不支持索引访问
- 只能包含可哈希对象（不可变类型）
- 支持集合运算（并集、交集等）

操作：

vowels = {"a", "e", "i", "o", "u"}
vowels.add("y")           # 添加元素
vowels.discard("i")       # 删除元素
print("a" in vowels)      # 成员检测

时间复杂度：
- 添加/删除/成员检测：平均 O(1)
使用场景：去重、成员检测、集合运算

📖 4. Dict（字典）

特性：键值对集合，无序（Python 3.7+ 保持插入顺序），可变
语法：{键1: 值1, 键2: 值2, ...}
特点：
- 键必须是可哈希对象（通常为不可变类型）
- 键唯一，值可重复
- 通过键快速访问值

操作：

1
2
3

person = {"name": "Alice", "age": 30}
person["email"] = "alice@example.com"  # 添加/修改
print(person.get("age"))               # 访问值

时间复杂度：
- 访问/添加/删除：平均 O(1)
使用场景：键值映射、快速查找、JSON 数据表示

🆚 核心区别总结

特性	List	Tuple	Set	Dict
有序性	✔️ 保持顺序	✔️ 保持顺序	❌ 无序	❌ 无序（3.6+ 保持插入顺序）
可变性	✔️ 可变	❌ 不可变	✔️ 可变	✔️ 可变
元素唯一性	❌ 允许重复	❌ 允许重复	✔️ 唯一	键唯一，值可重复
索引访问	✔️ 支持	✔️ 支持	❌ 不支持	通过键访问
内存效率	一般	✅ 较高	中等	中等
典型操作	增删改查	只读访问	集合运算/去重	键值查找
可哈希性	❌ 不可哈希	✅ 可哈希	❌ 不可哈希	❌ 不可哈希
空对象创建	`[]`	`()`	`set()`	`{}`

💡 选择指南

需要有序且可修改 → 用 List
需要有序且不可变 → 用 Tuple（更安全、更快）
需要去重/成员检测 → 用 Set
需要键值映射 → 用 Dict

⚡ 性能对比（10万元素操作）

操作	List	Tuple	Set	Dict
查找元素	O(n)	O(n)	O(1)	O(1)
插入元素	O(1)*	N/A	O(1)	O(1)
内存占用(MB)	~8.5	~7.2	~4.2	~4.8

列表插入末尾为 O(1)，插入中间为 O(n)

函数

函数代码块以 def 关键词开头

return [ 表达式 ] 结束函数并返回，返回⼀个或多个值给调⽤⽅，不带表达式的 return 相当于返回 None ，多个值为元组。

# 声明
def sayHello():
 	print("你好")
 # 调用
sayHello()

不定⻓参数

加了星号 * 的参数会以元组 (tuple) 的形式导⼊，存放所有未命名的变量参数。
加了两个星号 ** 的参数会以字典的形式导⼊。

def getNumTuple(n1,*n):
 	print(n1)
 	print(n)
    pass
getNumTuple(8,9,90,100,"hello",True,3.5)


def getNumDict(n1,**n):
 	print(n1)
 	print(n)
    pass
getNumDict(8,age=40,name="周杰伦")

值传递与引⽤传递

值传递：传递的是数值，适⽤于实参类型为不可变类型（ int,float,bool,str,tuple ）
引⽤传递：传递的是地址，适⽤于实参类型为可变类型（ list,set,dict,class ）
函数传参，能不传就不传，实在不行在传参。

main 函数– 程序的⼊⼝

1 2	if __name__=="__main__": print("test")

File( ⽂件 ) 读写

如果文件不存在，它会帮忙创建一个。

mode参数：

w：覆盖写
a(append)：追加

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（Python 3 不支持）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

默认为文本模式，如果要以二进制模式打开，加上 b 。

⽂本⽂件写

with open("D:\\wtest.txt",mode='w',encoding='UTF-8') as  f :
 f.write("ccccccccccccccc\n")
 f.write("ccccccccccccccc\n")
 f.close()

⽂本⽂件读
1
2
3
4
5
with open("/root/python/test.txt",mode='r',encoding='UTF-8') as f:
result = f.read()
# resutl = f.readlines()
print(resutl)
f.close()
1. “相对路径不起作用”的真相：
  - 问题不在 open()，而在于当前工作目录(CWD) 与你的预期不同
  - CWD 是运行脚本时的终端路径，不是脚本所在路径

Python 库 : 标准库扩展库⾃定义库

在 python ⽤ import 或者 from … import 来导⼊相应的库。

fieldnames在写的时候要提前准备好fieldnames列表，读的时候不用准备。

import csv
 #写csv文件
with open("/root/python/user.csv",mode="w", encoding="UTF-8") as f:
 result=csv.DictWriter(f,fieldnames=["id","passwd","bat"]) #fieldnames在写的时候要提前准备好fieldnames列表，读的时候不用准备。
 result.writeheader()
 result.writerows(data)
 f.close()
 #读csv文件
result = csv.DictReader(f)

异常

一般是整个项目开发完，基础功能开发完，才开始做异常。不让整个程序崩溃。
这种异常一般是给用户提示用的。

程序崩溃

try:
 	x = int(input("请输入一个数字: "))
 	z=100/x
 	print("ok")
except ValueError:
 	print("您输入的不是数字,请再次尝试输入！")
except ZeroDivisionError:
 	print("除数不能为零")
except Exception as e:
 	print("未知错误")
 	print(e)

⾃定义异常

使⽤ raise 语句抛出⼀个指定的异常 raise Exception(“ 不能是负数 “)

让程序崩溃，发生异常

⾯向对象 OOP 封装、继承、多态

类是抽象的，对象是具体的，先有类才有对象

封装

类及对象包含属性和⽅法

属性：静态特征全局变量成员

给类定义私有属性可以通过在属性名前加上双下划线__来定义一个私有属性。这样做可以防止这个属性被外部代码直接访问和修改，从而保护类的内部状态。私有属性在类的外部是不可见的，但仍然可以在类的内部方法中使用。
⽅法：动态特征函数功能
魔法⽅法：不需要调⽤就可以⾃动执⾏。
作⽤：初始化对象的成员 ( 给对象添加属性 )

 #类定义
class People:
 name=""
 age=0
 def __init__(self,xingming,nianling):
 self.name=xingming
 self.age=nianling
 def show(self):
 print(f"姓名是{self.name},年龄是{self.age}")
 #调用
if __name__=="__main__":
 ldh=People("刘德华",50)
 ldh.show()

继承

class ⼦类名 ( ⽗类名 ):

⼦类直接具备⽗类的属性和⽅法

解决代码重⽤问题，提⾼开发效率

class Student(People):
 grade=""
 def __init__(self, xingming, nianling,nianji):
 super().__init__(xingming,nianling)
 self.grade=nianji
 def test(self):
 print(f"年级是{self.grade}")
 # 方法重写
def show(self):
 print(f"姓名是{self.name},年龄是{self.age},年级是{self.grade}")

多态

多态从字⾯上理解就是⼀个事物可以呈现多种状态。

没有继承就没有多态。

多态是能⾃⼰进⾏判断该去执⾏什么 , 创建⼀个列表来体现 , ⾯向对象的列表。

l1=[ldh,zjl]
 for i in l1:
 # 多态
print(i.name)
 i.show()

类的专有方法

init : 构造函数，在生成对象时调用
del : 析构函数，释放对象时使用
repr : 打印，转换
setitem : 按照索引赋值
getitem: 按照索引获取值
len: 获得长度
cmp: 比较运算
call: 函数调用
add: 加运算
sub: 减运算
mul: 乘运算
truediv: 除运算
mod: 求余运算
pow: 乘方

作业：

定义⼀个⽔果类，定义属性（名称和颜⾊），使⽤魔法⽅法，然后通过⽔果类，创建苹果对象、橘⼦对象、西⽠对象并分别添加上颜⾊属性，定义⼀个⽅法分别输出如：

红⾊的苹果真好吃

橙⾊的橘⼦真好吃

绿⾊的西⽠真好吃

猫类 Cat 。属性 : ⽑的颜⾊ color ，品种 breed ，亲和度 love 。⽅法 : 吃饭 eat()

狗类 Dog 。属性 : ⽑的颜⾊ color ，品种 breed ，忠诚度 loyal 。⽅法 : 吃饭 eat()

要求 : 使⽤封装、继承和多态

根据以上要求抽取⽗类为 Animal

重写 eat ⽅法

输出打印如下：

有⼀只亲和度是 10 级的花⾊的波斯猫正在吃⻥ …..

有⼀只忠诚度是 9 级的⿊⾊的藏獒正在啃⻣头 …..

有⼀只亲和度是 8 级的⽩⾊的加菲猫正在吃⻥ …..

有⼀只忠诚度是 6 级的棕⾊的茶杯⽝正在啃⻣头 …..

time&datetime 库

Python 中处理时间的标准库

提供获取系统时间并格式化输出功能
提供系统级精确计时功能，⽤于程序性能分析

time 库

包含三类函数

时间获取： localtime()
时间格式化： strftime() strptime() string format time 格式化字符串 string parse time 解析字符串
程序计时： sleep() perf_counter()

import time
 # 日期类型与字符串直接互相转化
t1= time.localtime()
 print(time.strftime("%Y-%m-%d %H:%M:%S",t1))
 timeStr = '2018-01-26 12:55:20'
 t2=time.strptime(timeStr, "%Y-%m-%d %H:%M:%S")
 #测试程序执行时间差
t_start = time.perf_counter()
 print("测试")
 #开始休眠
time.sleep(5)
 print("休眠完毕")
 t_end =  time.perf_counter()
 print( t_end-t_start )
 import datetime
 t = datetime.datetime.now()
 print(datetime.datetime.strftime(t,"%Y-%m-%d %H:%M:%S"))
 print(datetime.datetime.strptime("20230211","%Y%m%d"))

连接 MySQL 操作

pymysql 是在 Python3.x 版本中⽤于连接 MySQL 服务器的⼀个库在 vscode 终端下⾯直接运⾏ pip3 install pymysql 安装即可

import  pymysql
 # 连接database
 conn = pymysql.connect(
 host="127.0.0.1",
 user="root",password="root123456",
 database="test",
 charset="utf8")
 print("打开数据库")
 #关闭数据库
conn.close()
 print("关闭数据库")

结构操作

# 使用预处理语句创建表
sql1 = """create table if not exists MovieType(
 tid int primary key,
 tname varchar(20),
 tcontent varchar(500),
 tdate datetime
 )"""
 baoma.execute(sql1)
 print("操作成功")

数据增删改操作

c="insert into MovieType values(1,'喜剧','这是一种搞笑的视频',now())"
 result=baoma.execute(c)
 conn.commit() #需要提交才到数据库，有错则rollback
 print("插入成功")

数据查询操作

baoma.fetchone(): 执⾏完毕返回的结果集默认以元组显⽰

baoma.fetchall(): 元组的元组

import  pymysql
 sql = "select * from MovieType order by tdate desc"
 baoma.execute(sql)
 # data = baoma.fetchone()#读一行
# print(data)
 data = baoma.fetchall()#读所有
print(data)
 for  i in  data:
 print(i[0],i[1])

上机练习 9

灵活使⽤ pymyql 来完成创建表、添加数据、查询数据

create table if not exists MovieType(
 tid int primary key,
 tname varchar(20),
 tcontent varchar(200),
 tdate datetime
 )
 insert into MovieType values(1,'喜剧','这是一个搞笑的电影',now())
 insert into MovieType values(2,'动作','这是一个打斗的电影',now())
 select * from MovieType

查询数据时⽇期处理成如下格式：

1 喜剧这是⼀个搞笑的电影 2023 年 08 ⽉ 21 ⽇

2 动作这是⼀个打⽃的电影 2023 年 08 ⽉ 21 ⽇

三层架构–面向对象思想

os库

os （ operating system ）是 Python 程序与操作系统进⾏交互的接⼝

1 、 os.listdir （）返回对应⽬录下的所有⽂件及⽂件夹

2 、 os.mkdir （）创建⽬录（只⽀持⼀层创建）即新建⼀个路径

3 、 os.open （）创建⽂件相当于全局函数 open() （ IO 流） os.open(“t.txt”,os.O_CREAT)

4 、 os.remove （⽂件名或路径）删除⽂件

5 、 os.rmdir （）删除⽬录

6 、 os.system （）执⾏终端命令 os.system(“touch a.txt”)

pandas库

Pandas 是 Python 语⾔的⼀个扩展程序库，⽤于数据分析。

Pandas 名字衍⽣⾃术语 “panel data” （⾯板数据）

Pandas 可以从各种⽂件格式⽐如 CSV 、 JSON 、 Excel

Pandas 数据结构 - DataFrame

data = {"Site":["Google", "Runoob", "Wiki"], "Age":[10, 12, 13],"sss":[22,33,44]}
df = pd.DataFrame(data)
print(df.loc[1]) #一行
print(df.loc[[0,1]]) # 多行
print(df["Age"]) # 一列
print(df[["Age","Site"]]) # 多列
print(df["Age"][1]) # 一个值
print(df[(df.Age>11) & (df.sss>35)])# 带条件筛选
print(df[(df.Age>11) & (df.sss>35)]["Age"])
print(df[(df.Age.astype(int)>11) & (df.sss>35)])#如果需要转换数据类型如下
#修改值-查出来后，右侧给左侧赋值即可，不存在的列即为添加
df["Age"]=100
df["Age"][1]=99
 #添加列
df["tid"]=2
df["Score"]=[90,40,99]
df.insert(1,"Sex",["男","女","男"])
 # 1代表列 0代表行
df.drop(1,axis=0,inplace=True)
df.drop([0,1],axis=0,inplace=True)
df.drop("Age",axis=1,inplace=True)
df.drop(df[df.Age>10].index,axis=0,inplace=True)

Pandas CSV ⽂件

df = pd.read_csv("/root/shell/douban.csv")
df = df[["id","title","rate"]]
df.to_csv("/root/python/db.csv",index=False)
df.to_csv("/root/python/db.csv",mode="a", header=False, index=False)#追加

Pandas JSON

json.loads() 函数是将字符串转化为字典

import pandas as pd
d2 = [
 {"class": "Year 1", "student number": 20, "room": "Yellow"},
 {"class": "Year 2", "student number": 25, "room": "Blue"}
 ]
df = pd.DataFrame(d2)
print(df)

Pandas excel ⽂件

sheet_name 指定了读取 excel ⾥⾯的哪⼀个 sheet
usecols 指定了读取哪些列 nrows 指定了总共读取多少⾏
header 指定了列名在第⼏⾏，并且只读取这⼀⾏往下的数据
index_col 指定了 index 在第⼏列
engine=”openpyxl” 指定了使⽤什么引擎来读取 excel ⽂件

安装： pip3 install openpyxl

import pandas as pd
df = pd.read_excel("student.xlsx",sheet_name="Sheet1",header=1)
print(df)
df.to_excel("student1.xlsx",sheet_name="xs",index=False)

Numpy

NumPy（Numerical Python）是 Python 中用于科学计算的基础且极其核心的库。它提供了一个强大的 N 维数组对象以及一系列操作这些数组的函数和工具。几乎所有处理数值数据的 Python 库（如 Pandas, SciPy, Matplotlib, scikit-learn, TensorFlow, PyTorch 等）都建立在 NumPy 之上或与其深度集成。

以下是 NumPy 的关键特性和介绍：

核心对象：ndarray (N-dimensional array)
- 多维同质数组： 这是 NumPy 的核心数据结构。它是一个包含相同类型元素的表格（通常是数字），可以通过非负整数元组进行索引。
- 维度 (axes)： 数组有维度。例如：
  - 一维数组：[1, 2, 3] (1 个轴)
  - 二维数组：[[1, 2, 3], [4, 5, 6]] (2 个轴：行、列)
  - 三维数组：想象一个立方体的数据 (3 个轴)。
- 形状 (shape)： 一个表示每个维度大小的元组。例如，上面的二维数组形状是 (2, 3)（2 行，3 列）。
- 数据类型 (dtype)： 数组中元素的类型，如 int32, int64, float32, float64, bool_, string_ 等。定义类型对于内存占用和计算效率至关重要。
- 内存效率与速度： ndarray 在内存中连续存储（或按特定步幅存储），并使用编译后的低级代码（C/Fortran）进行操作，这比 Python 原生的列表 (list) 处理数值数据要快得多，内存效率高得多，尤其是对于大型数据集。

矢量化操作 (Vectorization)

NumPy 最重要的特性之一。它允许你对整个数组执行操作（加、减、乘、除、比较、函数应用等），无需编写显式的循环。
优势：
- 简洁性： 代码更短，更易读，更接近数学表达式。
- 高性能： 底层使用高效的预编译例程，避免了 Python 循环的解释器开销。

示例：

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

# 矢量化加法 - 对整个数组操作
c = a + b  # 结果: array([6, 8, 10, 12])

# 矢量化乘法
d = a * 2  # 结果: array([2, 4, 6, 8])

# 数学函数作用于整个数组
e = np.sin(a)  # 计算每个元素的正弦值

广播 (Broadcasting)

这是一组强大的规则，允许 NumPy 对形状不同的数组执行算术运算。
核心思想：将较小的数组“广播”到较大数组的形状，使它们具有兼容的形状，然后进行逐元素操作。
规则（简化）：
1. 如果两个数组维度数不同，小维度数组的形状会在其左边填充 1。
2. 如果两个数组在某个维度上的大小相同，或者其中一个的大小为 1，则认为它们在该维度上是兼容的。
3. 数组只能在所有维度都兼容的情况下广播。
4. 广播后，每个数组的行为就像它拥有和最大数组一样的形状。

示例：

a = np.array([[1, 2, 3],  # shape (2, 3)
              [4, 5, 6]])
b = np.array([10, 20, 30])  # shape (3,) -> 广播为 (1, 3) -> (2, 3)

c = a + b
# 结果：
# [[1+10, 2+20, 3+30],
#  [4+10, 5+20, 6+30]]
# = [[11, 22, 33],
#    [14, 25, 36]]

丰富的函数库
- 数学运算： np.add(), np.subtract(), np.multiply(), np.divide(), np.exp(), np.log(), np.sin(), np.cos(), np.sum(), np.mean(), np.std(), np.min(), np.max() 等。
- 线性代数： np.dot() (点积/矩阵乘法), np.linalg.inv() (矩阵求逆), np.linalg.det() (行列式), np.linalg.eig() (特征值/特征向量) 等 (主要在 numpy.linalg 子模块)。
- 数组操作： np.reshape(), np.concatenate(), np.split(), np.transpose(), np.sort(), np.ravel() (展平), 切片、索引（基础索引、布尔索引、花式索引）。
- 随机数生成： np.random.rand(), np.random.randn(), np.random.randint(), np.random.normal() 等 (在 numpy.random 子模块)。
- 逻辑运算： np.logical_and(), np.logical_or(), np.logical_not(), 比较运算符 (==, !=, <, >, <=, >=) 返回布尔数组。
- 文件 I/O： np.loadtxt(), np.savetxt(), np.load() (用于 .npy 格式), np.save() (用于 .npy 格式)，方便读写数组数据。
与其他库的互操作性
- NumPy 数组是 Python 科学计算生态系统的通用数据交换格式。
- Pandas 的 DataFrame 和 Series 可以轻松转换为 NumPy 数组 (.values 或 .to_numpy())。
- SciPy 为科学计算（优化、积分、插值、信号处理等）提供了更多高级函数，通常直接操作 NumPy 数组。
- Matplotlib 等绘图库直接接受 NumPy 数组进行绘图。
- scikit-learn、TensorFlow、PyTorch 等机器学习/深度学习框架的核心数据结构通常基于或兼容 NumPy 数组 (numpy.ndarray 或能与之转换的 tensor 类型)。

Matplotlib

Matplotlib 是 Python 生态系统中最核心的数据可视化库，由 John D. Hunter 于 2003 年创建。它提供了类似 MATLAB 的绘图接口，同时具备 Python 的灵活性和强大功能，已成为科学计算、数据分析和机器学习领域的标准可视化工具。

核心特点

全面的图表支持：
- 基础图表：折线图、散点图、柱状图、饼图、直方图
- 高级图表：等高线图、热力图、3D图、矢量场图
- 统计图表：箱线图、误差棒图、小提琴图
- 地理绘图：基础地图投影（需配合 Basemap 或 Cartopy）
多平台兼容：
- Jupyter Notebook 内嵌显示
- 独立的 GUI 窗口
- 多种格式导出：PNG, PDF, SVG, EPS 等
- Web 应用集成（通过 Agg 后端）
高度可定制：
- 细粒度控制每个图表元素
- 支持 LaTeX 数学公式
- 丰富的样式和颜色配置
与科学计算栈无缝集成：
- 原生支持 NumPy 数组
- 与 Pandas DataFrame 深度集成
- 作为 Seaborn、Plotly 等高级库的基础

关键对象

Figure（图形）：顶级容器，相当于画布
Axes（坐标系）：实际绘图区域，包含坐标轴、标题等
Axis（坐标轴）：处理刻度、标签和网格线
Artist（艺术家）：所有可见元素的基类

基本使用模式

1. 快速绘图（pyplot 方式）

import matplotlib.pyplot as plt
import numpy as np

# 创建数据
x = np.linspace(0, 10, 100)
y = np.sin(x)

# 创建图形
plt.figure(figsize=(8, 4))  # 设置图形大小

# 绘制折线图
plt.plot(x, y, label='sin(x)', color='blue', linestyle='-', linewidth=2)

# 添加标题和标签
plt.title('Sine Wave')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')

# 添加图例和网格
plt.legend()
plt.grid(True, linestyle='--', alpha=0.7)

# 显示图形
plt.show()

2. 面向对象方式（推荐用于复杂图表）

# 创建图形和坐标系
fig, ax = plt.subplots(figsize=(10, 6))

# 在坐标系上绘图
ax.plot(x, np.sin(x), label='Sine', color='royalblue')
ax.plot(x, np.cos(x), label='Cosine', color='crimson', linestyle='--')

# 设置坐标系属性
ax.set_title('Trigonometric Functions')
ax.set_xlabel('X values')
ax.set_ylabel('Function values')
ax.legend(loc='upper right')
ax.grid(True, alpha=0.3)

# 设置坐标轴范围
ax.set_xlim(0, 10)
ax.set_ylim(-1.5, 1.5)

# 添加注释
ax.annotate('Local max', xy=(np.pi/2, 1), xytext=(4, 1.2),
            arrowprops=dict(facecolor='black', shrink=0.05))

# 保存高质量图片
fig.savefig('trig_functions.png', dpi=300, bbox_inches='tight')

常用图表类型示例

1. 多子图布局

fig, axes = plt.subplots(2, 2, figsize=(12, 8))

# 子图1：散点图
x = np.random.randn(100)
y = np.random.randn(100)
colors = np.random.rand(100)
sizes = 100 * np.random.rand(100)
axes[0, 0].scatter(x, y, c=colors, s=sizes, alpha=0.6)
axes[0, 0].set_title('Scatter Plot')

# 子图2：柱状图
categories = ['A', 'B', 'C', 'D']
values = [25, 40, 30, 45]
axes[0, 1].bar(categories, values, color=['skyblue', 'salmon', 'lightgreen', 'gold'])
axes[0, 1].set_title('Bar Chart')

# 子图3：直方图
data = np.random.randn(1000)
axes[1, 0].hist(data, bins=30, color='purple', alpha=0.7)
axes[1, 0].set_title('Histogram')

# 子图4：饼图
sizes = [15, 30, 25, 20]
explode = (0, 0.1, 0, 0)  # 突出第二部分
axes[1, 1].pie(sizes, explode=explode, labels=categories, autopct='%1.1f%%',
               shadow=True, startangle=90)
axes[1, 1].set_title('Pie Chart')

plt.tight_layout()  # 自动调整子图间距
plt.show()

2. 高级可视化：3D 曲面图

from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

# 创建数据
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

# 绘制3D曲面
surf = ax.plot_surface(X, Y, Z, cmap='viridis', edgecolor='none', alpha=0.8)

# 添加等高线
ax.contour(X, Y, Z, 10, offset=-1, cmap='coolwarm')

# 添加标签
ax.set_title('3D Surface Plot')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')

# 添加颜色条
fig.colorbar(surf, shrink=0.5, aspect=5)

plt.show()

unittest

unittest 是 Python 标准库中的一个单元测试框架，也称为 PyUnit（受 JUnit 启发）。它提供了一套完整的工具来编写、组织和运行测试用例，帮助开发者验证代码的正确性，确保代码在修改或扩展后仍然能按预期工作。

核心组件

1. TestCase 类

每个测试用例都继承自 unittest.TestCase。
测试方法必须以 test_ 开头，例如 test_addition()。
包含断言方法（如 assertEqual、assertTrue 等）来验证预期结果。

import unittest
 
class MyTestCase(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(1 + 1, 2)

2. TestSuite 类

用于组合多个测试用例或测试套件，形成更大的测试集合。
可以通过 addTest() 方法动态添加测试。

1 2	suite = unittest.TestSuite() suite.addTest(MyTestCase("test_addition"))

3. TestLoader 类

自动发现和加载测试用例。
可以扫描指定目录或模块，查找所有继承自 TestCase 的类和方法。

1 2	loader = unittest.TestLoader() suite = loader.discover("tests", pattern="test_*.py")

4. TextTestRunner 类

用于运行测试套件并输出结果。
支持多种输出格式（如文本、XML、HTML 等）。

1 2	runner = unittest.TextTestRunner() runner.run(suite)

常用断言方法

方法	描述
`assertEqual(a, b)`	验证 `a == b`
`assertNotEqual(a, b)`	验证 `a != b`
`assertTrue(x)`	验证 `x` 为真
`assertFalse(x)`	验证 `x` 为假
`assertIs(a, b)`	验证 `a` 和 `b` 是同一个对象
`assertIsNot(a, b)`	验证 `a` 和 `b` 不是同一个对象
`assertIsNone(x)`	验证 `x` 是 `None`
`assertIsNotNone(x)`	验证 `x` 不是 `None`
`assertIn(a, b)`	验证 `a` 在 `b` 中
`assertNotIn(a, b)`	验证 `a` 不在 `b` 中
`assertRaises(exc, fun, args, *kwargs)`	验证 `fun(args, *kwargs)` 抛出异常 `exc`

测试夹具（Fixtures）

**setUp()**：在每个测试方法运行前执行，用于初始化测试环境。
**tearDown()**：在每个测试方法运行后执行，用于清理测试环境。
setUpClass() 和 **tearDownClass()**：在类级别执行，分别用于类级别的初始化和清理（需使用 @classmethod 装饰器）。

class MyTestCase(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("类级别的初始化")
 
    def setUp(self):
        print("每个测试前的初始化")
 
    def test_example(self):
        print("运行测试")
 
    def tearDown(self):
        print("每个测试后的清理")
 
    @classmethod
    def tearDownClass(cls):
        print("类级别的清理")

运行测试

1. 命令行运行

使用 python -m unittest 运行测试。

可以指定模块、类或方法：

1
2
3

python -m unittest tests.test_module
python -m unittest tests.test_module.MyTestCase
python -m unittest tests.test_module.MyTestCase.test_method

2. 发现测试

使用

discover

选项自动发现测试：

1 2	bash python -m unittest discover -s tests -p "test_*.py"

示例：完整测试流程

# 文件：math_operations.py
def add(a, b):
    return a + b
 
def subtract(a, b):
    return a - b
 
# 文件：tests/test_math_operations.py
import unittest
from math_operations import add, subtract
 
class TestMathOperations(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(1, 2), 3)
 
    def test_subtract(self):
        self.assertEqual(subtract(5, 3), 2)
 
if __name__ == "__main__":
    unittest.main()

运行测试：

bash


python -m unittest tests.test_math_operations

输出：

..
----------------------------------------------------------------------
Ran 2 tests in 0.000s
 
OK

优点

内置支持：unittest 是 Python 标准库的一部分，无需额外安装。
结构清晰：通过继承 TestCase 和方法命名约定，测试代码结构清晰。
功能丰富：提供多种断言方法和测试夹具，满足复杂测试需求。
易于集成：可以与持续集成工具（如 Jenkins、GitHub Actions）无缝集成。

适用场景

单元测试：验证单个函数或方法的正确性。
集成测试：验证多个模块或组件的交互。
回归测试：确保代码修改后不会引入新的问题。

总结

unittest 是 Python 中功能强大且易于使用的单元测试框架，适合大多数 Python 项目的测试需求。通过合理组织测试用例和利用测试夹具，可以显著提高代码的可靠性和可维护性。

Setuptools：Python 打包与分发的核心工具

Setuptools 是 Python 生态系统中最重要且广泛使用的包构建工具，它扩展了 Python 标准库中的 distutils 模块，为开发者提供了强大的项目打包、依赖管理和分发能力。几乎所有现代 Python 包都依赖于 Setuptools 进行构建和分发。

核心功能与价值

1. 项目打包

将 Python 代码组织成可分发的格式（源码包、wheel 等）
自动包含项目文件和非代码资源
支持复杂项目结构（命名空间包、多包项目）

2. 依赖管理

声明项目依赖（install_requires）
指定可选依赖组（extras_require）
自动解决依赖关系树

3. 元数据管理

定义项目元数据（名称、版本、作者等）
提供分类信息（PyPI 分类器）
支持许可证和项目URL

4. 可执行文件创建

自动生成平台相关的可执行脚本
通过入口点（entry points）创建命令行工具

5. 扩展构建

编译和打包 C/C++ 扩展
集成 Cython 等工具

核心组件解析

1. `setup.py` - 项目构建脚本

from setuptools import setup, find_packages

setup(
    name="my_project",  # 包名称
    version="1.0.0",    # 版本号
    author="Your Name",
    author_email="your@email.com",
    description="A short description of your project",
    long_description=open("README.md").read(),
    long_description_content_type="text/markdown",
    url="https://github.com/you/my_project",
    packages=find_packages(where="src"),  # 自动发现包
    package_dir={"": "src"},             # 包位置
    install_requires=[                   # 依赖声明
        "requests>=2.25.1",
        "numpy"
    ],
    extras_require={                     # 可选依赖组
        "dev": ["pytest", "flake8"],
        "plot": ["matplotlib"]
    },
    classifiers=[                        # PyPI 分类器
        "Programming Language :: Python :: 3",
        "License :: OSI Approved :: MIT License",
        "Operating System :: OS Independent",
    ],
    python_requires=">=3.6",            # Python 版本要求
    entry_points={                       # 命令行入口点
        "console_scripts": [
            "mycli=my_project.cli:main"
        ]
    },
    include_package_data=True,          # 包含数据文件
    package_data={"my_project": ["data/*.json"]}
)

2. `setup.cfg` - 声明式配置（推荐）

[metadata]
name = my_project
version = attr: my_project.__version__
author = Your Name
author_email = your@email.com
description = Project description
long_description = file: README.md
long_description_content_type = text/markdown
url = https://github.com/you/my_project
license = MIT
license_file = LICENSE.txt
classifiers =
    Programming Language :: Python :: 3
    License :: OSI Approved :: MIT License

[options]
package_dir =
    = src
packages = find:
install_requires =
    requests>=2.25.1
    numpy
python_requires = >=3.6
include_package_data = True

[options.packages.find]
where = src

[options.extras_require]
dev = pytest; flake8
plot = matplotlib

[options.entry_points]
console_scripts =
    mycli = my_project.cli:main

3. `pyproject.toml` - 现代构建配置（PEP 517/518）

[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "my_project"
version = "1.0.0"
authors = [
    {name = "Your Name", email = "your@email.com"}
]
description = "Project description"
readme = "README.md"
requires-python = ">=3.6"
license = {text = "MIT"}
classifiers = [
    "Programming Language :: Python :: 3",
    "License :: OSI Approved :: MIT License"
]

dependencies = [
    "requests>=2.25.1",
    "numpy"
]

[project.optional-dependencies]
dev = ["pytest", "flake8"]
plot = ["matplotlib"]

[project.scripts]
mycli = "my_project.cli:main"

关键功能详解

1. 包发现与组织

# 自动发现所有包
packages = find_packages(where="src")

# 包含指定包
packages = ["my_pkg", "my_pkg.subpkg"]

# 命名空间包
packages = find_namespace_packages(include=["my_namespace.*"])

2. 依赖管理最佳实践

install_requires = [
    # 基本要求
    "requests>=2.25.1",
    
    # 版本约束示例
    "numpy>=1.18; python_version>'3.6'",
    "numpy>=1.16; python_version<='3.6'",
    
    # 环境标记
    "pywin32 >= 1.0; platform_system=='Windows'"
]

extras_require = {
    "test": ["pytest", "pytest-cov"],
    "docs": ["sphinx", "sphinx-rtd-theme"],
    "all": ["pandas", "matplotlib"]
}

3. 入口点机制

entry_points = {
    # 命令行工具
    "console_scripts": [
        "mycli = my_pkg.cli:main"
    ],
    
    # GUI 应用
    "gui_scripts": [
        "myapp = my_pkg.gui:launch"
    ],
    
    # 插件系统
    "my_framework.plugins": [
        "csv_import = my_pkg.plugins.csv:CSVImporter",
        "json_export = my_pkg.plugins.json:JSONExporter"
    ],
    
    # 测试框架集成
    "pytest11": [
        "myplugin = my_pkg.pytest_plugin"
    ]
}

4. 数据文件与资源管理

# 包含包内数据文件
package_data = {
    "my_pkg": ["data/*.csv", "templates/*.html"]
}

# 包含项目级数据文件
data_files = [
    ("config", ["conf/app.cfg"]),
    ("/etc/myapp", ["system/myapp.conf"]),
    ("share/icons", ["icons/app_icon.png"])
]

# 使用MANIFEST.in控制源码分发内容
include_package_data = True

工作流程与命令

1. 开发模式安装

1 2	# 可编辑安装（代码变更实时生效） pip install -e .

2. 构建分发包

# 安装构建工具
pip install build

# 构建源码分发（sdist）和wheel包
python -m build

3. 发布到PyPI

# 安装发布工具
pip install twine

# 上传到PyPI
twine upload dist/*

4. 常用开发命令

# 安装开发依赖
pip install -e ".[dev]"

# 运行测试
pytest

# 生成文档
sphinx-build docs build/docs

现代打包最佳实践

1. 项目结构推荐

my_project/
├── src/
│   └── my_pkg/
│       ├── __init__.py
│       ├── module.py
│       └── data/
│           └── config.json
├── tests/
│   ├── test_module.py
│   └── conftest.py
├── docs/
│   └── conf.py
├── .gitignore
├── pyproject.toml       # PEP 518 构建配置
├── setup.cfg            # 主要配置
├── setup.py             # 最小化（可选）
├── LICENSE
└── README.md

2. 版本管理策略

# 在 __init__.py 中定义版本
__version__ = "1.2.3"

# setup.cfg 中动态获取版本
[metadata]
version = attr: my_pkg.__version__

3. 兼容性处理

# 处理不同Python版本的依赖
install_requires = [
    "importlib_metadata; python_version<'3.8'",
    "typing_extensions; python_version<'3.8'"
]

# 平台特定依赖
extras_require = {
    ":sys_platform == 'win32'": ["pywin32"],
    ":sys_platform == 'darwin'": ["pyobjc"]
}

高级功能

1. C扩展集成

from setuptools import Extension, setup

module = Extension(
    "my_extension",
    sources=["src/extension.c"],
    include_dirs=["include"],
    libraries=["m"],  # 链接数学库
    define_macros=[("DEBUG", "1")],
    extra_compile_args=["-O3"]
)

setup(
    ...,
    ext_modules=[module]
)

2. 自定义构建命令

from setuptools import setup
from setuptools.command.build_py import build_py

class CustomBuild(build_py):
    """自定义构建过程"""
    def run(self):
        # 预处理步骤
        self.run_command("generate_protos")
        # 标准构建
        super().run()

setup(
    ...,
    cmdclass={
        "build_py": CustomBuild,
        "generate_protos": GenerateProtosCommand
    }
)

3. 动态元数据

# setup.py 中动态生成元数据
import re

def get_version():
    """从文件读取版本号"""
    with open("src/my_pkg/__init__.py") as f:
        match = re.search(r'__version__ = ["\'](.+)["\']', f.read())
    return match.group(1)

setup(
    version=get_version(),
    ...
)

常见问题解决

1. 包找不到问题

1
2
3

# 正确设置包目录
package_dir = {"": "src"}
packages = find_packages(where="src")

2. 数据文件未包含

ini

# setup.cfg 中启用包数据
[options]
include_package_data = True

# 添加 MANIFEST.in
include *.txt
recursive-include docs *.rst

3. 入口点不工作

# 确保函数路径正确
entry_points = {
    "console_scripts": [
        "mycli = my_pkg.cli:main_function"
    ]
}

生态系统整合

与 pip 集成：Setuptools 是 pip 安装过程的核心组件
与 virtualenv 协作：在隔离环境中构建和测试
与 tox 配合：跨多Python版本测试
与 cibuildwheel 集成：构建跨平台二进制wheel
与 Sphinx 结合：自动生成文档

演进与未来

PEP 517/518：现代构建系统标准
pyproject.toml 支持：逐步替代 setup.py
静态元数据：减少动态执行需求
构建隔离：更安全的构建环境

Jupyter 介绍

Jupyter 是一个开源的交互式计算环境，广泛应用于数据科学、机器学习、科学计算和教育领域。它支持多种编程语言（如 Python、R、Julia 等），允许用户以交互式的方式编写代码、运行实验、可视化数据并记录结果。以下是 Jupyter 的核心特性和应用场景的详细介绍。

核心组件

1. Jupyter Notebook

交互式文档：以 .ipynb 文件格式存储，包含代码、文本（Markdown）、公式（LaTeX）、图表和多媒体内容。
代码单元格（Code Cells）：逐行或分块执行代码，实时查看输出结果。
Markdown 单元格：支持富文本格式，用于解释代码、记录实验步骤或撰写报告。
输出可视化：直接在 Notebook 中显示图表（如 Matplotlib、Plotly）和交互式控件（如 ipywidgets）。

2. JupyterLab

下一代界面

：基于 Web 的交互式开发环境（IDE），提供更强大的功能：
- 多窗口布局：同时打开多个 Notebook、终端、文本编辑器等。
- 文件浏览器：直接管理项目文件和目录。
- 扩展支持：通过插件扩展功能（如调试器、Git 集成）。
兼容性：完全兼容 Jupyter Notebook，支持所有 Notebook 文件。

3. Jupyter Kernel

计算引擎

：负责执行代码的核心组件，支持多种编程语言：
- IPython Kernel：Python 的默认内核。
- IRKernel：R 语言支持。
- IJulia：Julia 语言支持。
- 其他内核：如 Bash、Scala、Go 等。

主要功能

1. 交互式计算

实时反馈：代码单元格执行后立即显示结果，适合快速迭代和调试。
魔法命令（Magic Commands）：IPython 提供的特殊命令（如 %timeit 测量代码性能）。

2. 数据可视化

静态图表：通过 Matplotlib、Seaborn 等库生成。
交互式图表：支持 Plotly、Bokeh 等库，允许用户缩放、平移和筛选数据。

3. 协作与分享

Notebook 导出：支持导出为 HTML、PDF、LaTeX、Python 脚本等格式。
在线共享：通过 JupyterHub 或平台（如 Google Colab、Binder）共享 Notebook。
版本控制：与 Git 集成，方便团队协作和代码管理。

4. 教育与研究

教学工具：通过 Markdown 单元格编写教程，结合代码示例和可视化。
实验记录：记录实验步骤、参数和结果，方便复现和分享。

应用场景

1. 数据科学

数据清洗与探索性分析（EDA）。
机器学习模型训练与评估。
结果可视化与报告生成。

2. 科学计算

数值模拟与算法开发。
科学实验数据的分析与可视化。

3. 教育与培训

编程教学（如 Python、R 入门）。
数据科学课程实践。

4. 技术文档

编写技术文档或教程，结合代码示例和解释。

安装与使用

1. 安装 Jupyter

通过 pip 安装
1
2
bash
pip install notebook

通过 conda 安装

1 2	bash conda install -c conda-forge notebook

安装 JupyterLab

：
1
2
bash
pip install jupyterlab

2. 启动 Jupyter

启动 Notebook
1
2
bash
jupyter notebook
启动 JupyterLab
1
2
bash
jupyter lab
默认会在浏览器中打开 http://localhost:8888。

3. 创建 Notebook

在 Jupyter 界面中，点击 New → Python 3（或其他内核）创建新 Notebook。

高级功能

1. JupyterHub

多用户支持：允许多个用户同时使用 Jupyter Notebook，适合教育机构或企业。
部署方式：可通过 Docker、Kubernetes 等容器化技术部署。

2. Binder

免费在线环境：将 GitHub 仓库中的 Notebook 直接转换为可交互的在线环境。
示例：访问 mybinder.org 并输入仓库 URL。

3. 扩展与插件

JupyterLab 扩展：如调试器、Git 集成、表格编辑器等。
Notebook 扩展：如代码折叠、目录生成等。

与其他工具的集成

1. 与 Git 集成

通过 nbdime 工具比较和合并 Notebook 版本。
在 JupyterLab 中直接使用 Git 插件。

2. 与云平台集成

Google Colab：免费在线 Jupyter 环境，支持 GPU/TPU。
AWS SageMaker：托管 Jupyter Notebook，支持大规模计算。

3. 与大数据工具集成

Spark：通过 PySpark 内核在 Jupyter 中运行 Spark 作业。
Dask：用于并行计算，支持大规模数据处理。

优缺点分析

优点

交互性强：适合快速迭代和实验。
可视化丰富：支持多种图表和交互式控件。
文档化：结合代码和文本，方便记录和分享。
多语言支持：支持 Python、R、Julia 等多种语言。

缺点

性能问题：对于大规模数据处理，Notebook 可能不如脚本高效。
版本控制困难：Notebook 文件是 JSON 格式，直接使用 Git 可能产生冲突。
安全性：默认情况下，Jupyter 服务器可能暴露在公网，需注意配置。

总结

Jupyter 是一个功能强大且灵活的交互式计算环境，适合数据科学、科学计算和教育领域。通过 Jupyter Notebook 和 JupyterLab，用户可以以交互式的方式编写代码、可视化数据并记录结果。尽管存在一些性能和版本控制的挑战，但通过合理使用工具和最佳实践，Jupyter 可以显著提高工作效率和协作能力。

国内常用镜像源

数据类型

输⼊

运算符

流程控制

选择结构 if

循环结构 while 和 for

字符串 (String)

Python 中的字符 ASCII 码运算

ASCII码表

核心函数

ASCII 码运算示例

1. 字符大小写转换

2. 字符移位（凯撒密码）

3. 字符比较

4. 计算字符位置

5. 生成字母序列

ASCII 码表摘要

重要注意事项

实际应用场景

list （列表）

列表的常⽤操作

字符串与列表转换

tuple （元组）只读的列表。

set （集合） ⽆序，去掉重复数据。

dict （字典）

推导式

list 、tuple、set、dict的区别

📋 1. List（列表）

📦 2. Tuple（元组）

🧺 3. Set（集合）

📖 4. Dict（字典）

🆚 核心区别总结

💡 选择指南

⚡ 性能对比（10万元素操作）

函数

值传递与引⽤传递

main 函数– 程序的⼊⼝

File( ⽂件 ) 读写

Python 库 : 标准库 扩展库 ⾃定义库

异常

⾯向对象 OOP 封装、继承、多态

封装

继承

多态

类的专有方法

time&datetime 库

time 库

连接 MySQL 操作

结构操作

数据增删改操作

数据查询操作

三层架构–面向对象思想

os库

pandas库

Pandas 数据结构 - DataFrame

Pandas CSV ⽂件

Pandas JSON

Pandas excel ⽂件

Numpy

Matplotlib

核心特点

关键对象

基本使用模式

1. 快速绘图（pyplot 方式）

2. 面向对象方式（推荐用于复杂图表）

常用图表类型示例

1. 多子图布局

2. 高级可视化：3D 曲面图

unittest

核心组件

1. TestCase 类

2. TestSuite 类

3. TestLoader 类

4. TextTestRunner 类

常用断言方法

测试夹具（Fixtures）

运行测试

1. 命令行运行

2. 发现测试

set （集合）⽆序，去掉重复数据。

Python 库 : 标准库扩展库⾃定义库

1. `setup.py` - 项目构建脚本

2. `setup.cfg` - 声明式配置（推荐）

3. `pyproject.toml` - 现代构建配置（PEP 517/518）