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

使用示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
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

注意事项

  1. 精度问题：浮点数运算可能存在微小误差（如 math.sin(math.pi) 实际输出 1.2246467991473532e-16 而非 0）。
  2. 异常处理：负数开平方会引发 ValueError，建议用 try-except 捕获。
  3. 性能：对于大量计算，考虑使用 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
1
2
3
4
5
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字符串是不可变对象，不能直接修改某个字符
  • 必须通过创建新字符串实现”修改”
    内存对象会发生变化
1
2
3
4
5
s = "Python"
# s[0] = 'J'  # 错误！会引发TypeError

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

常用更新方法

1
2
3
4
5
# 替换子串
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实现百分比进度： 
1
2
3
4
5
6
7
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、二进制、八进制数和十六进制数的效果：（整体效果)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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
我摘这里搞个是咧捏： 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/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()}")  # 支持方法调用

格式化规范：

1
2
3
4
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 = """第一行
第二行
    第三行(带缩进)"""

文档字符串示例

1
2
3
4
5
6
7
8
9
10
11
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字符
  • 支持多语言字符
1
2
3
4
5
s = "中文 Español Français"
print(s)  # 正常显示多语言

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

编码转换

1
2
3
4
5
# 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()

1
2
3
4
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     ' (左对齐)
  1. 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()那样切出空行
  1. partition() 和 rpartition()

  • 都是切三段的刀，找到第一个指定分隔符切成：

    • 分隔符前 | 分隔符自己 | 分隔符后

  • partition() - 从左往右找

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

  • rpartition() - 从右往左找

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

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

  1. 字符串填充

  • 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左右对齐

关键要点总结

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

列表

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

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

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

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

1
2
3
4
5
6
7
8
# 空列表
empty_list = []

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

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

Python3 列表完全指南

1. 列表基础

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

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

1
2
3
4
5
6
7
8
# 空列表
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开始）

切片操作

1
2
3
4
5
6
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"  # 直接通过索引修改

极高的效率

添加元素

1
2
3
4
5
6
7
8
9
# 末尾添加
fruits.append("orange")

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

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

删除元素

1
2
3
4
5
6
7
8
9
# 按索引删除
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. 列表推导式

简洁创建列表的方式：

1
2
3
4
5
# 创建平方数列表
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. 注意事项

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

    1
    2
    3
    4
    5
    def modify(lst):
        lst.append(1)

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

  2. 浅拷贝问题：

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

  3. 性能考虑：

    • append()/pop()是O(1)操作
    • insert(0, x)/remove()是O(n)操作

  4. 内存效率：

    • 列表比元组占用更多内存
    • 大数据集考虑使用生成器或NumPy数组

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

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

1
2
3
4
5
6
7
8
9
10
11
# 同时遍历索引和值
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 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
不信你看嘛╭(╯^╰)╮

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

Python3 元组完全指南

1. 元组基础

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

创建元组

1
2
3
4
5
6
7
8
9
10
11
12
13
## 空元组
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开始）

切片操作

1
2
3
4
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

重新赋值

1
2
3
4
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. 字典键（因为不可变）：

    1
    dict_with_tuple = {(1,2): "value"}

  2. 函数多返回值：

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

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

  3. 保护数据不被修改：

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

9. 性能比较

1
2
3
4
5
6
7
8
9
10
11
12
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中的键值对集合，用花括号{}表示，键值对用冒号:分隔。

创建字典

1
2
3
4
5
6
7
8
9
10
11
12
# 空字典
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，键不存在会报错

安全访问方法

1
2
3
4
5
6
7
# 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'  # 添加新键

合并字典

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

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

4. 删除元素

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

各种删除方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 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. 字典视图对象

三种视图方法

1
2
3
4
5
6
7
8
9
10
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. 字典推导式

创建字典的简洁方式

1
2
3
4
5
6
7
8
9
# 基本形式
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转换

1
2
3
4
5
6
7
import json

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

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

9. 高级技巧

默认字典

1
2
3
4
5
6
from collections import defaultdict

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

有序字典

1
2
3
4
from collections import OrderedDict

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

合并多个字典

1
2
3
4
5
# Python 3.5+
combined = {**dict1, **dict2, **dict3}

# Python 3.9+
combined = dict1 | dict2 | dict3

10. 性能与内存

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

11. 常见错误与解决

  1. KeyError异常

    1
    2
    3
    4
    5
    # 错误方式
    value = my_dict['nonexistent_key']

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

  2. 可变对象作为键

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

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

  3. 字典比较顺序

    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() 而不是 { }，因为 { } 是用来创建一个空字典。里面有初始值那你随意

1
2
3
4
5
6
7
8
9
# 空集合
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 ) #参数可以是列表，元组，字典等

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

1
2
3
4
5
6
7
fruits = {'apple', 'banana'}	#原有集合

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

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

移除元素

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

1
2
3
4
5
6
7
8
9
10
11
# 安全移除（元素不存在不报错）
fruits.discard('apple')

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

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

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

3. 集合运算

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

基本运算

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

示例

1
2
3
4
5
6
7
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) 
1
2
3
4
5
6
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. 集合推导式

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

1
2
3
4
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）

1
2
3
4
5
6
7
# 创建不可变集合
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. 不可哈希元素：

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

  2. 顺序不可靠：

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

  3. 空集合陷阱：

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

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

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