Python
Python 由荷兰国家数学与计算机科学研究中心的吉多·范罗苏姆于1990年代初设计，作为一门叫做ABC语言的替代品。 Python 提供了高效的高级数据结构，还能简单有效地面向对象编程，随着版本的不断更新和语言新功能的添加，逐渐被用于独立的、大型项目的开发。
官方文档：Python 教程
基础
Hello World
python
print("Hello World!")运行： python helloworld.py
注释
单行注释： # [注释内容] 多行注释："""[注释内容]""" 或者 '''[注释内容]'''
基本运算
| 运算符 | 说明 |
|---|---|
| + | 加法 |
| - | 减法 |
| * | 乘法 |
| / | 除法 |
| % | 取余 |
| ** | 幂运算 |
| // | 取整 |
python
print("2 + 2 =", 2 + 2) # 输出 2 + 2 = 4
print("2 - 2 =", 2 - 2) # 输出 2 - 2 = 0
print("2 * 2 =", 2 * 2) # 输出 2 * 2 = 4
print("2 / 2 =", 2 / 2) # 输出 2 / 2 = 1
print("5 % 3 =", 5 % 3) # 输出 5 % 3 = 2
print("2 ** 3 =", 2 ** 3) # 输出 2 ** 3 = 8
print("5 // 3 =", 5 // 3) # 输出 5 // 3 = 1赋值
标识符的规则：
- 不与系统已有库、类、函数、关键字等同名
- 不以数字开头
- 不要以双下划线开头并结尾
__xxx__ - 命名要尽量意义明了
- 可使用驼峰或者蛇形（下划线）命名
<variableName> = <expression>
python
a = 1
print("a =", a) # 输出 a = 1赋值语句也能和基本运算组合
<variableName> <operator>= <expression> => <variableName> = <variableName> <operator> <variableName>
比较运算
| 运算符 | 说明 |
|---|---|
| > | 大于 |
| < | 小于 |
| >= | 大于等于 |
| <= | 小于等于 |
| == | 等于 |
| != | 不等于 |
python
print("1 == 1 =>", 1 == 1) # 输出 1 == 1 => True
print("1 != 1 =>", 1 != 1) # 输出 1 != 1 => False
print("1 > 1 =>", 1 > 1) # 输出 1 > 1 => False
print("1 < 1 =>", 1 < 1) # 输出 1 < 1 => False
print("1 >= 1 =>", 1 >= 1) # 输出 1 >= 1 => True
print("1 <= 1 =>", 1 <= 1) # 输出 1 <= 1 => True逻辑运算
| 运算符 | 说明 |
|---|---|
| and | 与 |
| or | 或 |
| not | 非 |
python
print("True and False =>", True and False) # 输出 True and False => False
print("True and True =>", True and True) # 输出 True and True => True
print("True or False =>", True or False) # 输出 True or False => True
print("False or False =>", False or False) # 输出 False or False => False
print("not True =>", not True) # 输出 not True => False位运算
Python 同样也支持使用:
&（按位与） 、 |（按位或） 、 ^（按位异或） 、 ~（按位取反） 、 >>（右移） 、 <<（左移）
python
# 按位与运算
a = 60 # 二进制表示为 0011 1100
b = 13 # 二进制表示为 0000 1101
result = a & b # 结果为 12，二进制表示为 0000 1100
# 按位或运算
result = a | b # 结果为 61，二进制表示为 0011 1101
# 按位异或运算
result = a ^ b # 结果为 49，二进制表示为 0011 0001
# 按位取反运算
result = ~a # 结果为 -61，二进制表示为 1100 0011
# 注意：这里是32位整数的补码形式
# 左移运算
result = a << 2 # 结果为 240，二进制表示为 1111 0000
# 右移运算
result = a >> 2 # 结果为 15，二进制表示为 0000 1111Python 支持直接写二进制、八进制和十六进制1
0b11表示 30o77表示 630xFF表示 255
成员判断
| 运算符 | 说明 |
|---|---|
| in | 在...中 |
| not in | 不在...中 |
python
print("Hello" in "Hello World!") # 输出 True
print("hello" in "Hello World!") # 输出 False
print("Hello" not in "Hello World!") # 输出 False
print("hello" not in "Hello World!") # 输出 True常用函数
| 函数名 | 说明 |
|---|---|
type(<value>) | 返回某个值的数据类型 |
len(<collection>) | 返回某个集合的长度 |
min(<collection>) | 返回某个集合的最小值 |
max(<collection>) | 返回某个集合的最大值 |
sum(<collection>) | 返回某个集合的和 |
input() | 获取用户输入 |
数据类型
基本数据类型
| 类型名 | 说明 |
|---|---|
int | 整数 |
float | 浮点数 |
str | 字符串 |
bool | 布尔值 |
bytes | 字节串 |
tuple | 元组 |
list | 列表 |
set | 集合 |
dict | 字典 |
字符串
TIP
Python 对引号不敏感，支持使用 " 或者 ' 定义字符串。
python
print(type("string")) # 输出 <class 'str'>
print(len("string")) # 输出 6
print("string"[4]) # 输出 n
print("string"[-1]) # 输出 g，负数表示从右到左
# print("string"[6]) # 抛出错误 IndexError: string index out of range
# print("string"[-7]) # 抛出错误 IndexError: string index out of range常用方法
| 方法名 | 说明 |
|---|---|
find/index | 查询子串在字符串中的位置，找不到返回 -1 |
count | 统计子串在字符串中出现的次数 |
replace(old, new) | 替换字符串 |
strip(chars) | 去除首尾匹配内容（默认匹配空串）后的字符串 |
split(pattern) | 按照指定分隔符分割字符串 |
startswith(prefix) | 判断字符串是否以指定前缀开头 |
endswith(suffix) | 判断字符串是否以指定后缀结尾 |
upper() | 转换字符串为大写 |
lower() | 转换字符串为小写 |
isupper() | 判断字符串是否全为大写 |
islower() | 判断字符串是否全为小写 |
title() | 所有单词首字母大写 |
capitalize() | 首字母大写 |
isdigest() | 判断字符串是否为数字 |
isalpha() | 判断字符串是否全为字母 |
ord() | 获取一个字符的字符串的 ASCII 码 |
python
print("string".find("ing")) # 输出 3
print("hello world!".count("o")) # 输出 2
print("hello word!".replace("word", "world")) # 输出 hello world!
print(" hello ".strip()) # 输出 “hello”
print(" hello ".strip("\t \nh")) # 输出 “ello”
print("hello world!".split("l")) # 输出 ['he', '', 'o wor', 'd!']
print("hello world!".split("l", 2)) # 输出 ['he', '', 'o world!']
print("hello world!".startswith("hello")) # 输出 True
print("hello world!".endswith("world")) # 输出 True
print("Hello World!".upper().isupper()) # 输出 True
print("Hello World!".lower().islower()) # 输出 True
print("hello world!".title()) # 输出 Hello World!
print("hello world!".capitalize()) # 输出 Hello world!
print("123456".isdigit()) # 输出 True
print("helloworld".isalpha()) # 输出 True
print("hello world!".isalpha()) # 输出 False字符串运算
python
print("abc" * 3) # 输出 abcabcabc
print("abc" + "abc") # 输出 abcabc
# 切片 [x:y:z] （x 默认为 0，y 默认为字符串长度，z 默认为 1，xy 可以为负数）
print("string"[::]) # 输出 spring
print("string"[1:5:]) # 输出 prin
print("string"[1:5:1]) # 输出 prin
print("string"[1:5:2]) # 输出 pi
print("string"[:5]) # 输出 strin
print("string"[1:]) # 输出 tring
print("string"[-2:]) # 输出 ng
print("string"[:-2]) # 输出 stri列表
定义: [<value>, ... <value>]
常用方法
| 方法名 | 说明 |
|---|---|
append() | 在列表末尾添加元素 |
extend() | 在列表末尾添加多个元素 |
insert() | 在指定位置插入元素 |
pop() | 删除指定位置元素（默认最后一个），如果为空则抛出 IndexError |
remove() | 删除指定元素（如果有多个则删除第一个） |
index() | 返回指定元素在列表中的位置（如果有多个则返回第一个） |
count() | 统计指定元素在列表中出现的次数 |
srot() | 对列表进行排序（默认升序） |
reverse() | 对列表进行反转 |
clear() | 清空列表 |
copy() | 复制列表 |
python
arr = [1, "2"]
arr.append(3) # arr is [1, '2', 3]
arr.extend([4, 5]) # arr is [1, '2', 3, 4, 5]
arr.extend("78") # arr is [1, '2', 3, 4, 5, '7', '8']
arr.insert(0, 0) # arr is [0, 1, '2', 3, 4, 5, '7', '8']
arr.insert(-1, 9) # arr is [0, 1, '2', 3, 4, 5, '7', 9, '8']
print(arr.pop()) # 输出 8
print(arr.pop(0)) # 输出 0
arr.remove(1) # arr is ['2', 3, 4, 5, '7', 9]
# 使用 Python 关键字
del arr[1] # arr is ['2', 4, 5, '7', 9]
print(arr.index(5)) # 输出 2
arr.append(4)
print(arr.count(4)) # 输出 2
arr = [1, 2, 3]
print(sum(arr)) # 输出 6
print(min(arr)) # 输出 1
print(max(arr)) # 输出 3
arr.reverse() # ass is [3, 2, 1]
sorted(arr) # 不修改元素本身的排序，arr is [3, 2, 1]
arr.sort() # arr is [1, 2, 3]
arr1 = [1, 2, 3]
arr2 = arr1
arr3 = arr1.copy()
arr1.pop()
# arr1 is [1, 2]
# arr2 is [1, 2]
# arr3 is [1, 2, 3]TIP
sum|min|max| 只支持纯数值列表（只包含数值）min|max也支持纯字符串列表sort只支持纯数值或者纯字符串列表- 列表也支持切片，和字符串类似
运算和扩展
python
arr = [1, 2] * 2 # arr is [1, 2, 1, 2]
arr = [1, 2] + [3, 4] # arr is [1, 2, 3, 4]元组
数据的有序集合，定义后无法修改
使用 (<value>, ..., <valueN>) 定义，可以不加 ()
python
t1 = (1, 2, 3)
t2 = 1, 2, 4
print(type(t1)) # 输出 <class 'tuple'>
print(type(t2)) # 输出 <class 'tuple'>
x, y, z = t1 # x = 1, y = 2, z = 3集合（set）
集合内的元素是无序且不重复的。
集合使用
hash方法判断元素是否重复。集合不允许直接插入字典元素，因为字典没有实现
__hash__方法，能添加到集合的元素都必须是可哈希的。
创建方法：
set1 = {1, 2, 3, "aa"}set2 = set([1, 2, 3, "aa"])set3 = forzenset([1, 2, 3, "aa"])
注意
使用 forzenset 定义的集合不能被修改。没有 pop、update、xxx_update 等方法。
常用方法
| 函数名 | 说明 |
|---|---|
add | 向集合中添加元素 |
update | 向集合中添加多个元素 |
clear | 清空集合 |
copy | 拷贝整个集合（浅拷贝） |
pop | 随机弹出一个元素（因为集合无序，集合没有元素会报错） |
remove | 移除指定元素（没有报错） |
discard | 移除指定元素（不会报错） |
intersection、& | 交集 |
union、| | 并集 |
difference、- | 差 |
symmetric_difference、^ | 交叉补集 |
intersection_update | 交集并更新结果（&=） |
union_update | 并集并更新结果（|=） |
difference_update | 差集并更新结果（-=） |
symmetric_difference_update | 交叉补集（^=） |
交叉补集
两个集合互不存在在对方的元素。
set1 ^ set2 => (set1 | set2) - (set1 & set2)
字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
{key1 : value1, key2 : value2}
dict
dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。 字典定义时如果键重复则最后的一个键值对会替换前面的，值不需要唯一。
python
user = {'name': 'Wen Flower', 'age': 23, 'class': '2211'}
del user['class'] # 删除元素
user.clear() # 清空字典
del user # 删除字典常用函数
| 函数名 | 说明 |
|---|---|
len(dict) | 计算字典元素个数 |
str(dict) | 输出字典可打印的字符串表示 |
type(variable) | 返回输入的变量类型，如果变量是字典则返回 <class 'dict'> |
:::
len(dict)
python
user = { 'name': 'Wen', 'age': 23}
print(len(user)) # 输出 2str(dict)
python
user = { 'name': 'Wen', 'age': 23}
print(str(user)) # 输出 {'name': 'Wen', 'age': 23}type(variable)
python
user = { 'name': 'Wen', 'age': 23}
print(type(user)) # 输出 <class 'dict'>常用方法
| 方法名 | 说明 |
|---|---|
dict.clear() | 删除字典内所有元素 |
dict.copy() | 返回一个字典的浅复制 |
dict.fromkeys() | 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 |
dict.get() | 返回指定键的值，如果值不在字典中返回默认值 |
dict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
dict.keys() | 以列表返回一个字典所有的键 |
dict.pop() | 删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。 |
dict.popitem() | 随机返回并删除字典中的一对键和值 |
dict.setdefault() | 和 get()类似, 但如果键不存在于字典中，将会添加键并将值设为 default |
dict.update() | 把字典 dict2 的键/值对更新到 dict 里 |
dict.values() | 以列表返回字典中的所有值 |
强制转换
- 任何数据类型都能通过
string()强制转换为字符串类型 - 不是任何字符串都能通过
类型名()强制转为其它类型 - 整型可无损转为浮点型，但浮点型转整型会丢失小数点后的数据
- 列表和元组可以互相无损装换
读取输入
python
__in = input()
print(__in)格式化输出
python
print("%s is %d" % ('Wen', 23)) # 输出 Wen is 23
user = {'name': 'Wen', 'age': 23}
print("%(name)s is %(age)d" %user) # 输出 Wen is 23语句
分支语句
if
text
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……三目运算
v = x if y else z
如果 y 为真则 v 赋值为 x 否则赋值为 z
python
if 1 > 0 :
print("1 > 0 is True")
else:
print("1 > 0 is False")match
接受一个表达式并把它的值与一个或多个 case 块给出的一系列模式进行比较。
语法上类似其它的语言的 switch 语法，但是 match 是只匹配一个分支，通过
_匹配其它分支。
简单匹配
python
status = 200
match status:
case 500:
print("Error")
case 404:
print("Not Found")
case 200:
print("Success")
case 301 | 302: # 可通过 | 或 or 匹配多个值
print("Redirect")
case _:
print("Other")读取元组的值
python
point = (int(input("x:")), int(input("y:")), int(input("z:")))
match point:
case (0, 0, 0):
print("原点")
case (x, 0, 0):
print(f"X 轴上：{x}")
case (0, y, 0):
print(f"Y 轴上：{y}")
case (0, 0, z):
print(f"Z 轴上：{z}")
case (x, y, z):
print(f"三维坐标：({x}, {y}, {z})")
case _:
print("不是一个三维坐标")循环语句
for
格式
text
for 变量名 in 集合:
执行语句提供函数 range 生成集合
- 如果只有一个参数 x，则表示
[0, x)步长为 1 - 如果有两个参数 x, y，则表示
[x, y)步长为 1 - 如果有三个参数 x, y, z，则表示
[x, y)步长为 z
列表推导表达式：
[值表达式 for 变量 in 集合 if 条件]
one = [i for i in range(100) if i % 10 == 1 or i//10 == 1]
while
格式
text
while 布尔表达式:
执行语句（布尔表示为 True 执行）
可使用 continue 直接跳过剩下的执行语句直接判断下一次布尔表达式
可使用 break 直接结束 while 循环排序算法实现
冒泡排序
对长度为 n 的列表进行遍历，遍历 n 次，每一次遍历将元素和后一个元素比较，如果比后一个大（如果是降序排序这是比后一个小）则和后一个元素进行交换，每一次遍历的次数逐步减少，因为每一次遍历，都会有一个相对最大值到达了正确的位置。
python
l = [int(i) for i in input("请输入列表，使用英文分号分割:").split(",")]
ll = len(l)
for i in range(ll):
for j in range(ll - i - 1):
if l[j] > l[j + 1]:
l[j], l[j + 1] = l[j + 1], l[j]
print(l)快速排序
循环小技巧
遍历字典
通过调用字典的 items() 就能同时获取到字典的 Key 和 Value
python
user = {
"Name": "张三",
"Age": 24
}
for k, v in user.items():
print("key = %s, v = %s" % (k, v))遍历列表
使用 enumerate() 方法直接获取元素的索引和值。
直接遍历列表只能获取到列表的值。
python
l = ["张三", "李四"]
for i, v in enumerate(l):
print("i = %s, v = %s" % (i, v))同时遍历多个序列
python
l1 = ["张三", "李四"]
l2 = [24, 25]
for name, age in zip(l1, l2):
print("name = %s, age = %s" % (name, age));其它
可以使用：reversed() 函数反转列表 可使用：set() 对列表去重（会导致无序）
生成器
通过使用 yield 关键字将一个函数转变为生成器函数。简单说就是生成器函数调用后返回的是一个迭代器。
通过自定义生成器实现 range 方法
python
def custom_range(start, stop):
while start < stop:
yield start
start += 1
for i in custom_range(1, 10):
print(i)yield 语句也可以是一个表达式，它的返回值，是使用生成器实例调用 send 方法的值，因为启动生成器时，yield 还没执行到，所以启动时要使用 None 参数。
错误处理
模块
一个个 Python 文件就是一个模块
- Python 使用
import 文件名（不要扩展名）导入其它 Python 文件（模块） - 可通过
__name__获取模块名，如果是程序入口（也就是直接执行这个文件）则是__main__