python 学习速查笔记

这一部分主要是数字，字符串，列表，元组，字典，集合的学习笔记。

这篇文章真的很长，累死了，查的时候看大纲mmd

数字

Python 数字数据类型用于存储数值。
数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建：

var1 = 1
var2 = 10

使用del语句删除一些数字对象的引用。
del语句的语法是：

del var1[,var2[,var3[….,varN]]]

使用del语句删除单个或多个对象的引用，例如：

del var
del var_a, var_b

数字类型分类(三类)

类型	描述	示例
整型(int)	不限大小的正负整数	`10`, `-5`, `0x1F`
浮点型(float)	含小数或科学计数法表示的数	`3.14`, `2.5e2`
复数(complex)	实部+虚部（浮点数形式）	`3+4j`, `complex(2,3)`
布尔(bool)	int子类（True=1, False=0）	`True`, `False`

整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作Long类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

我们可以使用十六进制和八进制来代表整数

Python 数字类型转换

数据类型的转换，你只需要将数据类型作为函数名即可。

int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
以下实例将浮点数变量 a 转换为整数：
1
2
3
>>> a = 1.0
>>> int(a)
1
Python 数字运算
Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。
表达式的语法很直白： +, -,*和 /, 和其它语言（如Pascal或C）里一样。例如：
1
2
3
4
5
6
7
8
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # 总是返回一个浮点数
1.6
浮点数运算有精度问题，不同机器上的结果可能不同
在整数除法中，除法/总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符//：
1
2
3
4
5
6
7
8
9
>>> 17 / 3 # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3 # 整数除法返回向下取整后的结果
5
>>> 17 % 3 # ％操作符返回除法的余数
2
>>> 5 * 3 + 2
17
注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
例如：
1
2
3
4
5
6
7
>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>>
等号=用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。
1
2
3
4
>>> width = 20
>>> height = 5*9
>>> width * height
900
Python 可以使用**操作来进行幂运算：
1
2
3
4
>>> 5 ** 2 # 5 的平方
25
>>> 2 ** 7 # 2的7次方
128
变量在使用前必须先”定义”（即赋予变量一个值），否则会出现错误：
1
2
3
4
>>> n # 尝试访问一个未定义的变量
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
不同类型的数混合运算时会将整数转换为浮点数：
1
2
3
4
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5
在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：
1
2
3
4
5
6
7
8
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
以下是 Python 中常用数学函数的详细表格（包含 math 模块和内置函数）：

Python 数学函数速查表

函数/常量	描述	示例	输出结果
内置函数
`abs(x)`	返回绝对值	`abs(-5)`	`5`
`round(x[, n])`	四舍五入（可指定小数位数）	`round(3.14159, 2)`	`3.14`
`pow(x, y)`	计算 x 的 y 次幂（等价于 `x**y`）	`pow(2, 3)`	`8`
`divmod(a, b)`	返回商和余组的元组 `(a//b, a%b)`	`divmod(10, 3)`	`(3, 1)`
math 模块函数	（需 `import math`）
`math.ceil(x)`	向上取整	`math.ceil(4.2)`	`5`
`math.floor(x)`	向下取整	`math.floor(4.9)`	`4`
`math.sqrt(x)`	平方根	`math.sqrt(16)`	`4.0`
`math.exp(x)`	返回 e 的 x 次幂	`math.exp(1)`	`2.718281828459045`
`math.log(x[, base])`	对数运算（默认自然对数，可指定底数）	`math.log(100, 10)`	`2.0`
`math.log10(x)`	以 10 为底的对数	`math.log10(1000)`	`3.0`
`math.sin(x)`	正弦函数（x 为弧度）	`math.sin(math.pi/2)`	`1.0`
`math.cos(x)`	余弦函数	`math.cos(0)`	`1.0`
`math.tan(x)`	正切函数	`math.tan(math.pi/4)`	`0.999...`（≈1.0）
`math.degrees(x)`	弧度转角度	`math.degrees(math.pi)`	`180.0`
`math.radians(x)`	角度转弧度	`math.radians(90)`	`1.570...`（≈π/2）
`math.hypot(x, y)`	计算欧几里得范数（√(x² + y²)）	`math.hypot(3, 4)`	`5.0`
`math.factorial(n)`	阶乘计算	`math.factorial(5)`	`120`
`math.gcd(a, b)`	最大公约数	`math.gcd(36, 60)`	`12`
math 常量
`math.pi`	圆周率 π	`math.pi`	`3.141592653589793`
`math.e`	自然常数 e	`math.e`	`2.718281828459045`
`math.inf`	正无穷大	`math.inf > 1e10`	`True`
`math.nan`	非数字（Not a Number）	`math.isnan(math.nan)`	`True`

使用示例代码

import math

# 计算圆的面积
radius = 5
area = math.pi * math.pow(radius, 2)  # 或 radius**2
print(f"圆面积: {area:.2f}")  # 输出: 圆面积: 78.54

# 解三角形（已知斜边和角度）
hypotenuse = 10
angle_deg = 30
angle_rad = math.radians(angle_deg)
opposite = hypotenuse * math.sin(angle_rad)
print(f"对边长度: {opposite:.2f}")  # 输出: 对边长度: 5.00

注意事项

精度问题：浮点数运算可能存在微小误差（如 math.sin(math.pi) 实际输出 1.2246467991473532e-16 而非 0）。
异常处理：负数开平方会引发 ValueError，建议用 try-except 捕获。
性能：对于大量计算，考虑使用 numpy 替代 math 模块。

建议将此表格保存为快速参考手册！

其他完整函数

字符串

详细网站，详见菜鸟教程

Python 字符串操作完全指南

1. 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：

1	变量[头下标:尾下标]

索引访问

Python 字符串是字符的有序集合，可通过索引访问单个字符
索引从0开始，支持正向索引和反向索引
正向索引：0 到 len(str)-1
反向索引：-1 表示最后一个字符，-len(str) 表示第一个字符

1
2
3

s = "Python"
print(s[0])    # 'P' (第一个字符)
print(s[-1])   # 'n' (最后一个字符)

切片访问

语法：str[start:end:step]
左闭右开区间：包含start，不包含end
省略值：
- start默认为0
- end默认为字符串长度
- step默认为1

s = "Hello World"
print(s[0:5])   # 'Hello'
print(s[6:])    # 'World'
print(s[::2])   # 'HloWrd' (步长为2)
print(s[::-1])  # 'dlroW olleH' (反转字符串)

注意：

索引越界会引发IndexError
注意字长防止越界
切片越界不会报错，会自动调整到有效范围

2. 字符串更新

字符串不可变性

Python字符串是不可变对象，不能直接修改某个字符
必须通过创建新字符串实现”修改”
内存对象会发生变化

s = "Python"
# s[0] = 'J'  # 错误！会引发TypeError

# 正确做法：创建新字符串
s = 'J' + s[1:]  # 'Jython'

常用更新方法

# 替换子串
s = s.replace('Py', 'Ja')  # 'Jython' → 'Jython'

# 拼接字符串
s = s[:2] + 'va' + s[4:]  # 'Jython' → 'Javaon'

3. 转义字符

常见转义字符

在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表：
| 转义字符 | 描述 | 示例 |
|—————|——————————|————————-|
| \\ | 反斜杠 | "C:\\path" |
| \' | 单引号 | 'It\'s' |
| \" | 双引号 | "He said \"Hi\"" |
| \n | 换行 | "Line1\nLine2"|
| \t | 水平制表符 | "Name\tAge" |
| \r | 回车 | "Hello\rWorld"|
| \b | 退格 | "Hel\blo" |
| \uxxxx | Unicode字符 | "\u03A9" (Ω) |
特殊案例，使用\r实现百分比进度：

import time

for i in range(101): # 添加进度条图形和百分比
    bar = '[' + '=' * (i // 2) + ' ' * (50 - i // 2) + ']'
    print(f"\r{bar} {i:3}%", end='', flush=True)
    time.sleep(0.05)
print()

以下实例，我们使用了不同的转义字符来演示单引号、换行符、制表符、退格符、换页符、ASCII、二进制、八进制数和十六进制数的效果：（整体效果)

print('\'Hello, world!\'')  # 输出：'Hello, world!'

print("Hello, world!\nHow are you?")  # 输出：Hello, world!
                                        #       How are you?

print("Hello, world!\tHow are you?")  # 输出：Hello, world!    How are you?

print("Hello,\b world!")  # 输出：Hello world!

print("Hello,\f world!")  # 输出：
                           # Hello,
                           #  world!

print("A 对应的 ASCII 值为：", ord('A'))  # 输出：A 对应的 ASCII 值为： 65

print("\x41 为 A 的 ASCII 代码")  # 输出：A 为 A 的 ASCII 代码

decimal_number = 42
binary_number = bin(decimal_number)  # 十进制转换为二进制
print('转换为二进制:', binary_number)  # 转换为二进制: 0b101010

octal_number = oct(decimal_number)  # 十进制转换为八进制
print('转换为八进制:', octal_number)  # 转换为八进制: 0o52

hexadecimal_number = hex(decimal_number)  # 十进制转换为十六进制
print('转换为十六进制:', hexadecimal_number) # 转换为十六进制: 0x2a

原始字符串

在字符串前加r或R，转义字符不会生效
常用于正则表达式和文件路径

1 2	path = r"C:\new_folder\test.txt" print(path) # 输出: C:\new_folder\test.txt

4. 字符串运算符

基本运算符

不是数字运算符，具有和长得像罢了(ノ￣▽￣)

运算符	描述	示例	结果
`+`	字符串连接	`"Py" + "thon"`	`"Python"`
`*`	重复字符串	`"Hi" * 3`	`"HiHiHi"`
`[]`	索引访问	`"Python"[1]`	`'y'`
`[:]`	切片	`"Python"[1:4]`	`'yth'`
`in`	成员检查	`'Py' in 'Python'`	`True`
`not in`	非成员检查	`'Ruby' not in 'Python'`	`True`

我摘这里搞个是咧捏：

#!/usr/bin/python3
 
a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')

输出结果如下啊

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

比较运算符

字符串按字典序比较（ASCII/Unicode码值）：

1 2	print("apple" < "banana") # True print("Apple" < "apple") # True (大写字母ASCII码更小)

5. 字符串格式化

Python 支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
有点像c欸(｡◕ˇ∀ˇ◕)
各个版本的我都搞下

1. % 格式化 (旧式)

1
2
3

name = "Alice"
age = 25
print("Name: %s, Age: %d" % (name, age))

格式符	说明
`%s`	字符串
`%d`	十进制整数
`%f`	浮点数
`%x`	十六进制整数

2. str.format() (Python 2.6+)

1
2
3

print("Name: {}, Age: {}".format(name, age))
print("Name: {1}, Age: {0}".format(age, name))  # 按索引
print("Name: {n}, Age: {a}".format(n=name, a=age))  # 关键字

3. f-string (Python 3.6+ 推荐)

1
2
3

print(f"Name: {name}, Age: {age}")
print(f"Next year: {age + 1}")  # 支持表达式
print(f"Name: {name.upper()}")  # 支持方法调用

格式化规范：

pi = 3.1415926
print(f"Pi: {pi:.2f}")      # 保留2位小数: Pi: 3.14
print(f"Hex: {255:#0x}")    # 十六进制: Hex: 0xff
print(f"Percent: {0.25:.1%}") # 百分比: Percent: 25.0%

6. 三引号字符串

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

特点

使用三个单引号'''或双引号"""
保留所有格式（换行、缩进等）
常用于多行字符串、文档字符串(docstring)

1
2
3

multi_line = """第一行
第二行
    第三行(带缩进)"""

文档字符串示例

def calculate(a, b):
    """计算两个数的和与差
    
    Args:
        a: 第一个数
        b: 第二个数
    
    Returns:
        返回包含和与差的元组 (sum, difference)
    """
    return a + b, a - b

makedown玩家狂喜(⁎˃ᴗ˂⁎)，所见即所得万岁！！

7. Unicode 字符串

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

Python 3 的字符串

Python 3 中所有字符串默认都是Unicode字符串（str类型）
使用\u转义表示Unicode字符
支持多语言字符

s = "中文 Español Français"
print(s)  # 正常显示多语言

# Unicode码点
print("\u03A9")  # 输出希腊字母Ω

编码转换

# str → bytes
data = "中文".encode("utf-8")  # b'\xe4\xb8\xad\xe6\x96\x87'

# bytes → str
text = data.decode("utf-8")   # '中文'

注意：

文件操作时注意指定编码：open("file.txt", encoding="utf-8")
避免”编码地狱”：统一使用UTF-8编码

8. 字符串内建函数

常用方法

方法	描述	示例	结果
`str.lower()`	转为小写	`"Python".lower()`	`'python'`
`str.upper()`	转为大写	`"Python".upper()`	`'PYTHON'`
`str.strip()`	去除两端空白	`" hello ".strip()`	`'hello'`
`str.split()`	分割字符串	`"a,b,c".split(',')`	`['a', 'b', 'c']`
`str.join(iterable)`	连接序列元素	`','.join(['a', 'b', 'c'])`	`'a,b,c'`
`str.find(sub)`	查找子串位置	`"python".find('th')`	`2`
`str.replace(old, new)`	替换子串	`"hello".replace('l', 'L')`	`'heLLo'`
`str.startswith(prefix)`	检查前缀	`"hello".startswith('he')`	`True`
`str.endswith(suffix)`	检查后缀	`"hello".endswith('lo')`	`True`
`str.isdigit()`	是否全数字	`"123".isdigit()`	`True`
`str.isalpha()`	是否全字母	`"abc".isalpha()`	`True`

重要方法详解

1. split() vs splitlines()

text = "line1\nline2\r\nline3"
print(text.split())        # ['line1', 'line2', 'line3'] (默认按空白分割)
print(text.split('\n'))    # ['line1', 'line2\r', 'line3']
print(text.splitlines())   # ['line1', 'line2', 'line3'] (智能识别换行符)

2. partition() 与 rpartition()

1
2
3

url = "user:pass@domain.com"
print(url.partition('@'))  # ('user:pass', '@', 'domain.com')
print(url.rpartition('.')) # ('user:pass@domain', '.', 'com')

3. 字符串填充

1
2
3

print("42".zfill(5))      # '00042' (左侧补零)
print("hello".center(10, '*'))  # '**hello***' (居中填充)
print("hello".ljust(10))  # 'hello     ' (左对齐)

split() vs splitlines()

split() - 切菜刀
- 默认按空格/换行/制表符切："a b c".split() → ['a','b','c']
- 可以指定切什么："a,b,c".split(',') → ['a','b','c']
- 遇到连续分隔符会切出空字符串："a,,b".split(',') → ['a','','b']
splitlines() - 智能换行切割机
- 专切换行，不管你是\n还是\r\n都能认
- "第一行\n第二行".splitlines() → ['第一行','第二行']
- 不会像split()那样切出空行

partition() 和 rpartition()

都是切三段的刀，找到第一个指定分隔符切成：
- 分隔符前 | 分隔符自己 | 分隔符后

partition() - 从左往右找

1	"账号:密码@网址".partition('@') → ('账号:密码', '@', '网址')

rpartition() - 从右往左找

1	"图片.jpg".rpartition('.') → ('图片', '.', 'jpg')

找不到分隔符时：返回(原字符串, '', '')

字符串填充

zfill() - 补零神器
1
"5".zfill(3) → '005' # 补到3位

center() - 文字居中

1	"hi".center(6,'') → 'hi' # 总长度6，两边用填

ljust()/rjust() - 左右对齐

1 2	"hi".ljust(4) → 'hi ' # 长度4，右边补空格 "hi".rjust(4,'-') → '--hi' # 左边补-

一句话总结

split()：随便切，splitlines()专切换行
partition()：切三段，从左/从右找分隔符
填充方法：zfill补零，center居中，ljust/rjust左右对齐

关键要点总结

不可变性：字符串创建后不能修改，所有”修改”操作都返回新字符串
编码规范：Python 3 默认使用Unicode，处理文件时明确指定编码
性能考虑：
- 避免循环中使用+拼接字符串（使用join()更高效）
- 频繁字符串操作考虑使用io.StringIO
格式化选择：
- Python 3.6+ 优先使用f-string
- 需要兼容旧版本时用str.format()
安全注意：
- 避免用eval()处理字符串
- SQL查询使用参数化而非字符串拼接

列表

这还有多少部分啊啊！！凸(艹皿艹 )，写不动了捏
序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 有6个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

像不像数组啊喵
详细解释点这里，点这里啊，你为什么不点￣へ￣

创建列表（注意列表格式）【很重要所以我先放上来了】

# 空列表
empty_list = []

# 包含不同类型元素的列表
mixed_list = [1, "hello", 3.14, True]

# 嵌套列表
nested_list = [[1, 2], ["a", "b"]]

Python3 列表完全指南

1. 列表基础

列表是Python中最灵活的数据结构，用方括号[]表示，元素用逗号分隔。

创建列表（注意列表格式）

# 空列表
empty_list = []

# 包含不同类型元素的列表
mixed_list = [1, "hello", 3.14, True]

# 嵌套列表
nested_list = [[1, 2], ["a", "b"]]

特点：

有序集合（元素有固定位置）
可变（可以修改内容），这就比呢个啥字符串自由多了吧
可包含任意数据类型，ヾ(ﾟ∀ﾟゞ)z真的吗
支持重复元素

2. 访问列表元素

你看下面的东西，直接搬用吧

索引访问

1
2
3

fruits = ["apple", "banana", "cherry"]
print(fruits[0])   # "apple"（正向索引从0开始）
print(fruits[-1])  # "cherry"（负索引从-1开始）

切片操作

numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])  # [1, 2, 3]（左闭右开）
print(numbers[:3])   # [0, 1, 2]
print(numbers[2:])   # [2, 3, 4, 5]
print(numbers[::2])  # [0, 2, 4]（步长为2）
print(numbers[::-1]) # [5, 4, 3, 2, 1, 0]（反转）

3. 修改列表

更新元素

1 2	fruits = ["apple", "banana", "cherry"] fruits[1] = "blueberry" # 直接通过索引修改

极高的效率

添加元素

# 末尾添加
fruits.append("orange")

# 指定位置插入
fruits.insert(1, "mango")

# 合并列表
fruits.extend(["grape", "pear"])
# 等价于 fruits += ["grape", "pear"]

删除元素

# 按索引删除
del fruits[0]
popped = fruits.pop(1)  # 删除并返回被删元素

# 按值删除
fruits.remove("cherry")  # 只删除第一个匹配项

# 清空列表
fruits.clear()

4. 列表运算符

又称为Python列表脚本操作符︿(￣︶￣)︿
| 运算符 | 描述 | 示例 |
|————|——————————|———————————————|
| + | 列表拼接 | [1,2] + [3,4] → [1,2,3,4]|
| * | 重复列表 | [0]*3 → [0,0,0] |
| in | 成员检测 | 2 in [1,2,3] → True |
| == | 列表比较 | [1,2] == [1,2] → True |

5. 常用列表方法

方法	描述	示例
`len()`	返回列表长度	`len([1,2,3])` → `3`
`sort()`	原地排序	`[3,1,2].sort()` → `[1,2,3]`
`reverse()`	反转列表	`[1,2,3].reverse()` → `[3,2,1]`
`count()`	统计元素出现次数	`[1,2,2].count(2)` → `2`
`index()`	返回元素首次出现的索引	`["a","b"].index("b")` → `1`
`copy()`	浅拷贝列表	`new = old.copy()`

6. 列表推导式

简洁创建列表的方式：

# 创建平方数列表
squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]

# 带条件的推导式
evens = [x for x in range(10) if x%2==0]  # [0, 2, 4, 6, 8]

劲啊，我感觉到了算法题深深的恶意 ╥﹏╥

7. 注意事项

可变性：列表可变，函数可能修改原始列表

def modify(lst):
    lst.append(1)

my_list = []
modify(my_list)  # my_list会被修改

浅拷贝问题：

1
2
3

original = [[1,2], [3,4]]
copied = original.copy()
copied[0][0] = 99  # 也会修改original!

性能考虑：
- append()/pop()是O(1)操作
- insert(0, x)/remove()是O(n)操作
内存效率：
- 列表比元组占用更多内存
- 大数据集考虑使用生成器或NumPy数组

8. 实用技巧（你猜为什么变成二级索引）

直接复制版用吧，这个真的很有用

# 同时遍历索引和值
for index, value in enumerate(["a","b","c"]):
    print(index, value)

# 合并成字符串
words = ["Hello", "world"]
sentence = " ".join(words)  # "Hello world"

# 快速去重（保持顺序）
from collections import OrderedDict
unique = list(OrderedDict.fromkeys([1,2,2,3]))  # [1,2,3]

列表是Python中最常用的数据结构之一，掌握这些操作可以大大提高编码效率！

马上到元组了，呼呼，快结束了捏

元组

吾乃懒汉，讲解在这里了，速速收下

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
不信你看嘛╭(╯^╰)╮

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

Python3 元组完全指南

1. 元组基础

元组是Python的不可变序列，用圆括号()表示，元素用逗号分隔。

创建元组

## 空元组
empty_tuple = ()

## 单元素元组（必须加逗号）
single = (50,)  # 注意逗号
not_tuple = (50)  # 这是整数，不是元组！

## 多元素元组
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5)

## 省略括号创建
tup3 = "a", "b", "c"  # 自动识别为元组

特点：

不可变性（创建后不能修改）这……肯定有他的优势
有序集合（元素有固定位置）这不显得你好找吗
可包含任意数据类型
比列表更节省内存，看见没，用户的内存又不是我的内存

2. 访问元组元素

看着用吧(〃’▽’〃)

索引访问

元组可以使用下标索引来访问元组中的值，如下实例:

1
2
3

tup = ('Google', 'Runoob', 'Taobao')
print(tup[0])   # 'Google'（正向索引从0开始）
print(tup[-1])  # 'Taobao'（负索引从-1开始）

切片操作

numbers = (0, 1, 2, 3, 4, 5)
print(numbers[1:4])  # (1, 2, 3)（左闭右开）
print(numbers[:3])   # (0, 1, 2)
print(numbers[::2])  # (0, 2, 4)（步长为2）

3. 元组操作

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

元组拼接

1
2
3

tup1 = (1, 2, 3)
tup2 = ('a', 'b')
combined = tup1 + tup2  # (1, 2, 3, 'a', 'b')

元组重复

1	tup = ('Hi!',) * 3 # ('Hi!', 'Hi!', 'Hi!')

h和那个啥差不多，别用错了啊

成员检测

1	print(3 in (1, 2, 3)) # True

4. 元组不可变性

无法修改元素

1 2	tup = (1, 2, 3) # tup[0] = 4 # 报错！TypeError

重新赋值

tup = (1, 2, 3)
print(id(tup))  # 内存地址1
tup = (4, 5, 6)  # 创建新元组
print(id(tup))  # 新内存地址

5. 元组内置函数

函数	描述	示例
`len()`	返回元组长度	`len((1,2,3))` → `3`
`max()`	返回最大值	`max((1,3,2))` → `3`
`min()`	返回最小值	`min((1,3,2))` → `1`
`tuple()`	将可迭代对象转为元组	`tuple([1,2,3])` → `(1,2,3)`

6. 元组解包

基本解包

1 2	tup = (1, 2, 3) a, b, c = tup # a=1, b=2, c=3

一一对应

星号解包

1 2	first, *middle, last = (1, 2, 3, 4, 5) # first=1, middle=[2,3,4], last=5

7. 元组与列表对比

特性	元组	列表
可变性	不可变	可变
语法	`()`	`[]`
内存占用	较小	较大
方法	较少	丰富
适用场景	数据保护/字典键/函数返回值	需要频繁修改的数据集合

8. 使用场景

适合使用元组的情况

字典键（因为不可变）：
1
dict_with_tuple = {(1,2): "value"}

函数多返回值：

def get_stats():
    return 10, 20, 30  # 自动打包为元组

min, max, avg = get_stats()  # 解包

保护数据不被修改：

1	CONSTANTS = (3.14, 2.718) # 确保不会被意外修改

9. 性能比较

import sys
import timeit

lst = [1, 2, 3]
tup = (1, 2, 3)

print(sys.getsizeof(lst))  # 通常比元组大
print(sys.getsizeof(tup))

# 创建速度测试
print(timeit.timeit('(1,2,3)'))  # 通常比列表快
print(timeit.timeit('[1,2,3]'))

10. 实用技巧

元组与字符串转换

1 2	chars = tuple("Hello") # ('H', 'e', 'l', 'l', 'o') joined = ''.join(chars) # 'Hello'

命名元组（更高级用法）

1
2
3

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)  # p.x = 11, p.y = 22

元组虽然简单，但在Python编程中非常重要，特别是在需要保证数据不被修改的场景下非常有用！

字典

哈哈哈，文章太长了，颜色都没有了（指的是makedown编辑器）
字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值key=>value对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号{}中 ,格式如下所示：

1	d = {key1 : value1, key2 : value2, key3 : value3 }

看这里看这里，直接跳权威指南学习

Python3 字典完全指南

1. 字典基础

字典是Python中的键值对集合，用花括号{}表示，键值对用冒号:分隔。

创建字典

# 空字典
empty_dict = {}
empty_dict = dict()  # 等效写法

# 带初始值的字典
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 使用dict()构造函数
person = dict(name='Bob', age=30)  # 键不用引号

# 混合类型键值
mixed_dict = {'name': 'Alice', 1: [1,2,3], (1,2): 'tuple key'}

特点：

键必须是不可变类型（字符串/数字/元组）WARING
值可以是任意类型
键唯一，重复键会覆盖前值 注意覆盖关系，类似结构体在内存中的关系
Python 3.7+ 保持插入顺序

2. 访问字典元素（记住上面创建字典的初值）

基本访问

把相应的键放入到方括号中j即可访问，不存在的键会报错

1 2	print(person['name']) # 'Alice' # print(person['job']) # KeyError，键不存在会报错

安全访问方法

# get()方法
print(person.get('name'))     # 'Alice'
print(person.get('job'))      # None（不报错）
print(person.get('job', 'N/A'))  # 'N/A'（指定默认值）

# setdefault()方法
person.setdefault('job', 'Engineer')  # 不存在则添加

3. 修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对

添加/更新元素

1 2	person['age'] = 26 # 更新已有键 person['job'] = 'Engineer' # 添加新键

合并字典

# update()方法
extra_info = {'hobby': 'reading', 'age': 27}
person.update(extra_info)  # age被更新，hobby被添加

# Python 3.9+ 合并运算符
new_person = person | extra_info  # 创建新字典

4. 删除元素

能删单一的元素也能清空字典，清空只需一项操作。

各种删除方法

# del语句
del person['city']  # 删除指定键

# pop()方法
age = person.pop('age')  # 删除并返回值

# popitem()方法（Python 3.7+按LIFO顺序）
key, value = person.popitem()  # 删除最后一项

# clear()方法
person.clear()  # 清空字典

# del删除整个字典
del person  # 字典对象被删除

5. 字典视图对象

三种视图方法

person = {'name': 'Alice', 'age': 25}

# keys() - 键视图
print(person.keys())    # dict_keys(['name', 'age'])

# values() - 值视图
print(person.values())  # dict_values(['Alice', 25])

# items() - 键值对视图
print(person.items())   # dict_items([('name', 'Alice'), ('age', 25)])

视图特性：

动态反映字典变化
可迭代
支持集合操作（Python 3+）

6. 字典推导式

创建字典的简洁方式

# 基本形式
squares = {x: x**2 for x in range(5)}  # {0:0, 1:1, 2:4, 3:9, 4:16}

# 带条件的推导式
even_squares = {x: x**2 for x in range(10) if x % 2 == 0}

# 键值转换
person = {'name': 'alice', 'age': '25'}
upper_person = {k.upper(): v for k, v in person.items()}

7. 常用字典方法

方法	描述	示例
`len()`	返回键值对数量	`len(person)` → `3`
`copy()`	浅拷贝	`new = person.copy()`
`fromkeys()`	用序列创建新字典	`dict.fromkeys(['a','b'], 0)` → `{'a':0, 'b':0}`
`in`	检查键是否存在	`'name' in person` → `True`
`reversed()`	反向迭代键(Python 3.8+)	`list(reversed(person))`

8. 字典与JSON转换

import json

# 字典转JSON字符串
person_json = json.dumps(person)  # '{"name": "Alice", "age": 25}'

# JSON字符串转字典
person_dict = json.loads(person_json)

9. 高级技巧

默认字典

from collections import defaultdict

# 自动初始化不存在的键
word_count = defaultdict(int)  # 默认值0
for word in words:
    word_count[word] += 1

有序字典

from collections import OrderedDict

# 保持插入顺序（Python 3.7+普通字典已有序）
ordered = OrderedDict([('a', 1), ('b', 2)])

合并多个字典

# Python 3.5+
combined = {**dict1, **dict2, **dict3}

# Python 3.9+
combined = dict1 | dict2 | dict3

10. 性能与内存

查找速度：O(1)时间复杂度
内存占用：比列表更大
键哈希：键必须是可哈希对象（不可变类型）

11. 常见错误与解决

KeyError异常

# 错误方式
value = my_dict['nonexistent_key']

# 正确方式
value = my_dict.get('nonexistent_key', default_value)

可变对象作为键

# 错误：列表不可哈希
bad_dict = {['a']: 1}

# 正确：使用元组
good_dict = {('a',): 1}

字典比较顺序

1 2	# Python 3.7+ 字典比较顺序敏感 {'a':1, 'b':2} == {'b':2, 'a':1} # False（Python 3.6及之前可能为True）

字典是Python中最重要和高效的数据结构之一，掌握这些技巧可以大幅提升编程效率！

马上结束了，呜呜(Ｔ▽Ｔ)

集合

集合是一个无序的不重复元素序列。
集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号{ }创建集合，元素之间用逗号,分隔，或者也可以使用set()函数创建集合。

点这个，带你看集合指南

Python3 集合完全指南

1. 集合基础

集合是Python中的无序不重复元素集，用花括号{}表示（空集合必须用set()创建）。

创建集合

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。里面有初始值那你随意

# 空集合
empty_set = set()  # 注意：{} 创建的是空字典

# 带初始值的集合
fruits = {'apple', 'orange', 'banana'}
numbers = {1, 2, 3, 4}

# 从其他序列创建
letters = set('abracadabra')  # {'a', 'b', 'r', 'c', 'd'}

特点：

元素唯一（自动去重）
无序（不记录插入顺序）
可包含不可变类型（数字/字符串/元组）
可变（可增删元素）

到这里我已经很累了

2. 基本操作

添加元素

语法格式如下：

s.add( x )
s.update( x ) #参数可以是列表，元组，字典等

将元素添加到集合中，如果元素已存在，则不进行任何操作。

fruits = {'apple', 'banana'}	#原有集合

# 添加单个元素
fruits.add('orange')  # {'apple', 'banana', 'orange'}

# 添加多个元素
fruits.update(['kiwi', 'mango'])  # 可接受任何可迭代对象

移除元素

s.remove( x )
s.discard( x )
s.pop()

# 安全移除（元素不存在不报错）
fruits.discard('apple')

# 强制移除（元素不存在报KeyError）
fruits.remove('banana')

# 随机移除并返回
random_fruit = fruits.pop()  # 集合为空时报KeyError

# 清空集合
fruits.clear()  # set()

3. 集合运算

要知道一件事，那就是在表格中看你不见的一般是|，这玩意会变成表格边边

基本运算

运算符/方法	描述	示例
`	`或`union()`	并集	`a	b`
`&` 或 `intersection()`	交集	`a & b`
`-` 或 `difference()`	差集	`a - b`
`^` 或 `symmetric_difference()`	对称差集（仅出现在一个集合中的元素）	`a ^ b`

示例

a = {1, 2, 3}
b = {2, 3, 4}

print(a | b)  # {1, 2, 3, 4}
print(a & b)  # {2, 3}
print(a - b)  # {1}
print(a ^ b)  # {1, 4}

4. 集合关系判断

方法	描述	示例
`issubset()` 或 `<=`	判断子集	`a.issubset(b)`
`issuperset()` 或 `>=`	判断超集	`a.issuperset(b)`
`isdisjoint()`	判断无交集	`a.isdisjoint(b)`

a = {1, 2}
b = {1, 2, 3}

print(a <= b)  # True (a是b的子集)
print(b >= a)  # True (b是a的超集)
print(a.isdisjoint({4,5}))  # True (无交集)

5. 集合推导式

类似列表推导式，生成集合：

# 生成字符集合（自动去重）
letters = {char for char in 'abracadabra'}  # {'a', 'b', 'r', 'c', 'd'}

# 带条件的推导式
squares = {x**2 for x in range(10) if x%2==0}  # {0, 4, 16, 36, 64}

6. 不可变集合（frozenset）

# 创建不可变集合
immutable = frozenset([1, 2, 3])

# 特性：
# - 不能增删元素
# - 可哈希（可用作字典键）
# - 支持集合运算

7. 常用方法速查

方法	描述	时间复杂度
`len(s)`	返回元素个数	O(1)
`x in s`	成员检测	O(1)
`copy()`	浅拷贝	O(n)
`difference_update()`	原地差集操作	O(len(b))
`intersection_update()`	原地交集操作	O(len(b))
`symmetric_difference_update()`	原地对称差集操作	O(len(b))

8. 实用技巧

快速去重

1 2	names = ['Alice', 'Bob', 'Alice', 'Charlie'] unique_names = list(set(names)) # 顺序可能改变

元素存在性测试

1
2
3

valid_users = {'Alice', 'Bob', 'Charlie'}
if input('用户名: ') in valid_users:
    print('访问 granted')

集合与字典键转换

1
2
3

# 字典键转集合
keys = {'a':1, 'b':2}.keys()  # dict_keys对象
keys_set = set(keys)  # {'a', 'b'}

9. 性能特点

查找速度：O(1) 时间复杂度
内存占用：比列表更大
适用场景：
- 快速成员检测
- 数据去重
- 数学集合运算

10. 注意事项

不可哈希元素：

1 2	# 错误：列表不可哈希 invalid_set = {[1,2], [3,4]} # TypeError

顺序不可靠：

1 2	# Python 3.7+ 字典保持插入顺序，但集合仍然无序 print({1, 2} == {2, 1}) # True

空集合陷阱：

1 2	empty = {} # 这是字典！ empty = set() # 这才是空集合

集合是处理唯一性数据和数学运算的强大工具，合理使用可以大幅提升代码效率和可读性！

到这里吧，就到这里吧，累了真的

python 学习速查笔记

数字

数字类型分类(三类)

Python 数字类型转换

Python 数字运算

Python 数学函数速查表

使用示例代码

注意事项

字符串

Python 字符串操作完全指南

1. 访问字符串中的值

索引访问

切片访问

2. 字符串更新

字符串不可变性

常用更新方法

3. 转义字符

常见转义字符

原始字符串

4. 字符串运算符

基本运算符

比较运算符

5. 字符串格式化

1. % 格式化 (旧式)

2. str.format() (Python 2.6+)

3. f-string (Python 3.6+ 推荐)

6. 三引号字符串

特点

文档字符串示例

7. Unicode 字符串

Python 3 的字符串

编码转换

8. 字符串内建函数

常用方法

重要方法详解

一句话总结

关键要点总结

列表

创建列表（注意列表格式）【很重要所以我先放上来了】

Python3 列表完全指南

1. 列表基础

创建列表（注意列表格式）

2. 访问列表元素

索引访问

切片操作

3. 修改列表

更新元素

添加元素

删除元素

4. 列表运算符

5. 常用列表方法

6. 列表推导式

7. 注意事项

8. 实用技巧（你猜为什么变成二级索引）

元组

Python3 元组完全指南

1. 元组基础

创建元组

2. 访问元组元素

索引访问

切片操作

3. 元组操作

元组拼接

元组重复

成员检测

4. 元组不可变性

无法修改元素

重新赋值

5. 元组内置函数

6. 元组解包

基本解包

星号解包

7. 元组与列表对比

8. 使用场景

适合使用元组的情况

9. 性能比较

10. 实用技巧

元组与字符串转换

命名元组（更高级用法）

字典