1. 变量
变量是代数的思想，是用来缓存数据和功能占位的，具备动态性和可变性；
使用的变量必须声明，在声明变量时不需要指定变量类型。
1.1 变量声明
变量是缓存数据的标识符。
在python中，变量是用赋值语句创建，用来绑定一个数据的有名对象
1.1.1 命名规则
-
变量名只能包含字母、数字和下划线（_）
-
不能以数字开头
-
严格区分大小写
-
不能使用保留字，如下图所示
-
见明字义
name = "xxx" #姓名用name定义 print(name)
1.1.2 命名约定
a a1 abc ABC a1b2c3d4
one_hundred count _a __ABC__
getNameAge get_name_age GetNameAge
# 小驼峰 匈牙利命名法 大驼峰
-
通常使用小写字母。
-
多个单词时，用匈牙利命名法或驼峰法。
-
简短、有意义，见名只意。
-
纯大写字母一般表示常量，如PI = 3.14159。
-
变量名用名词，函数名用谓词（动词+名词），如 phone / update_phone。
-
类名采用驼峰形式，如MyClass。
1.2 变量赋值
使用=对变量进行赋值。
-
语法
变量名 = 数字类型 变量名 = 表达式 变量名1 = 变量名2 = 变量名3 = 数字类型 变量名1, 变量名2, 变量名3 = 数字类型1, 数字类型2, 数字类型3 -
示例
one_hundred = 99 + 1 a = b = c = 200 a, b = 100, 200 counter = 100 # 整型变量 miles = 1000.0 # 浮点型变量 name = "jack" # 字符串 print (counter) print (miles) print (name) -
说明
-
第一次赋值是创建变量，同时绑定表达式执行结果
-
后续再赋值，会改变原有变量的绑定关系
-
变量本身是没有类型，它绑定的对象才有类型
-
变量在使用之前，必须先进行赋值
-
变量赋值是一个自右向左的运算，将=右边表达式结果赋值给变量
-
1.3 基础变量类型
Python中的变量就是变量，它没有类型，我们所说的"类型"是变量指向的内存中对象的类型。我们可以使用type小函数用于获取一个变量或值的类型。
python中的数据类型：
-
字符串 str
-
数字
-
整数 int
-
浮点数 float
-
布尔数 bool
-
-
容器
-
列表 list
-
元组 tuple
-
字典 dict
-
集合 set / 固定集合 frozenset
-
字节串 bytes / 字节数组 bytearray
-
按照是否可修改划分分为：
-
不可变数据：Number（数字）、String（字符串）、Tuple（元组）
-
可变数据：List（列表）、Dictionary（字典）、Set（集合）
1.3.1 字符串类型
用引号引起来的就是字符串，即便是空或者空格。
1.3.1.1 基本特征
-
引号引起来的：单引号、双引号、三引号（三个单引号或双引号）；
-
三引号是字符串模板，所见即所得，可以包含单引号和双引号；
-
使用反斜杠\对字符进行转义
\' 代表单引号 \" 代表双引号 \n 代表换行符 \\ 代表反斜杠 \t 代表缩进 -
字符串前加r表示原始字符串，不转义；
r'c:\window\user\data'
1.3.1.2 运算
-
字符串连接用 "+"；
-
相邻的两个或多个 字符串字面值 会自动合并
'Py' 'thon' -
字符串多次重复， 如 ：
'abc' * 3 '---' * 10
1.3.1.3 访问
-
索引访问：从0开始，支持负数
'abc' * 3 '---' * 10 -
支持切片：参数是start、end、step，下标从0开始，支持负数
str[[start]:[end]:[step]]案例如下：
'nimenhaowoshidada'[:2] 'nimenhaowoshidada'[1:5:2] 'nimenhaowoshidada'[::-1]step为负值说明是反方向走
1.3.1.4 关系判断
-
in 和 not in：判断是否包含指定的子字符串
str = r'c:\window\ruser\data' print('window' in str)
1.3.1.5格式化表达式
1.3.1.5.1 占位符
-
作用
生成具有一定格式的字符串
-
语法规则
格式化字符串 % 参数1 # 或者 格式化字符串 % (参数1, 参数2, 参数3) -
占位符和类型码
占位符和类型码 说明 %s 转成字符串, 使用 str(x) 函数转换(常用) %d 转成十进制的整数(常用) %o 转成八进制的整数 %x,%X 转成十六进制的整数 %e,%E 转成指数格式的浮点数 %f,%F 转成小数格式的浮点数(常用) %g,%G 转成指数格式或小数格式的浮点数 %% 转成一个% %m.nf m是指总宽度，默认右对齐，加个 - 表示左对齐，n 是指保留的小数点位数
-
示例1
-
代码
fmt = """ 甲方:_____%s_____ 乙方:_____%s_____ ....... 金额:_%d__ """ s = fmt % ("小明", '公司', 10000) print(s) -
输出效果：
甲方:_____小明_____ 乙方:_____公司_____ ....... 金额:_10000__ -
示例2
-
代码
print("------%F------" % 3.1415) print("------%g------" % 3.1415) print("------%e------" % 3.1415) print("------%e------" % 31.415) print("------%g------" % 3141523274812374281342374324.23748123742183472) # 按照指定的宽度打印，并保留指定的小数位数 print("------%30.2f------" % 3141523274814.23748123742183472) print("------%30.2f------" % 3144814.3472) print("------%-30.2f------" % 14) -
输出结果
------3.141500------ ------3.1415------ ------3.141500e+00------ ------3.141500e+01------ ------3.14152e+27------ ------ 3141523274814.24------ ------ 3144814.35------ ------14.00 ------
-
1.3.1.6.2 f-string
f-string 格式化字符串以 $f$ 开头，字符串中的表达式用 {} 包起来。
x = 1
y = 2.3
print(f'{x+1}') #2
x = 1
print(f'{x+1=}') #x+1=2
d = 12
print(f'abc{d}') # 其中的{}中为变量或表达式
# 可以使用:对变量进一步格式化
pi = 3.1415
print(f'{s:.2f}') # 3.141.3.1.7 常见API
-
方法的调用语法
对象.方法名(参数) -
常见API
详见文档： 内置类型 — Python 3.13.3 文档
-
示例
1. str.lower(): #将字符串转换为小写 text = "Hello, World!" print(text.lower()) # 输出: hello, world! 2. str.upper(): #将字符串转换为大写 text = "Hello, World!" print(text.upper()) # 输出: HELLO, WORLD! 3. str.strip(): #移除字符串两端的空白字符 text = " Hello, World! " print(text.strip()) # 输出: Hello, World! 4. str.split(): #将字符串拆分为列表 text = "Hello, World!" print(text.split()) # 输出: ['Hello,', 'World!'] text = "Hello,World!" print(text.split(',')) # 输出: ['Hello', 'World!'] 5. str.join(): #将列表中的字符串连接为一个字符串 words = ['Hello', 'World'] print(" ".join(words)) # 输出: Hello World words = ['apple', 'banana', 'cherry'] print(", ".join(words)) # 输出: apple, banana, cherry 6. str.replace(): #替换字符串中的子字符串 text = "Hello, World!" print(text.replace("World", "Python")) # 输出: Hello, Python! 7. str.find(): #查找子字符串，返回第一次出现的位置 text = "Hello, World!" print(text.find("World")) # 输出: 7 print(text.find("Python")) # 输出: -1（如果未找到则返回 -1） 8. str.startswith(): #检查字符串是否以指定子字符串开头 text = "Hello, World!" print(text.startswith("Hello")) # 输出: True print(text.startswith("World")) # 输出: False 9. str.endswith(): #检查字符串是否以指定子字符串结尾 text = "Hello, World!" print(text.endswith("World!")) # 输出: True print(text.endswith("Hello")) # 输出: False 10. str.isdigit(): #检查字符串是否只包含数字字符 text1 = "12345" text2 = "12345abc" print(text1.isdigit()) # 输出: True print(text2.isdigit()) # 输出: False 11. str.isalpha(): #检查字符串是否只包含字母字符 text1 = "Hello" text2 = "Hello123" print(text1.isalpha()) # 输出: True print(text2.isalpha()) # 输出: False 12. str.isalnum(): #检查字符串是否只包含字母和数字字符 text1 = "Hello123" text2 = "Hello 123" print(text1.isalnum()) # 输出: True print(text2.isalnum()) # 输出: False 13. str.title(): #将字符串中的每个单词的首字母转换为大写 text = "hello, world!" print(text.title()) # 输出: Hello, World! 14. str.capitalize(): #将字符串的首字母转换为大写 text = "hello, world!" print(text.capitalize()) # 输出: Hello, world! 15. str.count(): #计算子字符串在字符串中出现的次数 text = "Hello, World! Hello, Python!" print(text.count("Hello")) # 输出: 2 print(text.count("Python")) # 输出: 1 16. str.format(): #格式化字符串 name = "John" age = 30 print("My name is {} and I am {} years old.".format(name, age)) # 输出: My name is John and I am 30 years old. print(f"My name is {name} and I am {age} years old.") # 输出: My name is John and I am 30 years old. (使用 f-string)
1.3.2 数字类型
Python 中的基本的数字类型
-
整数 int
-
浮点数(小数) float
-
布尔类型数 bool
1.3.2.1 整数
int
## 十进制的写法
100 0 -5
## 二进制的写法 0b 开头 后跟 0~1
0b1101
## 八进制的写法 0o开头 后跟 0~7
0o777 等于 0b111111111 等于 511
## 十六进制的写法 0x 开头 后跟 0~9, a-f, A-F
0xA1B2C3D41.3.2.2 浮点数
float
## 小数写法
3.14 0.14 .14 3.0 3. 0.0
## 科学计数法
6.18E-1 # 等同于 0.618
2.9979E8 # 等同于 299790000.01.3.2.3 布尔类型
Bool
-
表示真假、对错、黑白等；
-
只有2个值True和False；
-
类型转换使用bool()方法
-
非0都是True
-
0、0.0、-0.0、空字符串、空列表、空字典、空集合、空元组、None等都是False；
1.3.2.4 复数
complex 数学知识：
# 创建一个复数 a，其实部为 1，虚部为 2
a = 1 + 2j
print(a)输出：
(1+2j)1.3.2.5 数字类型转换
-
可以使用0b、0o、0x等表示二进制、八进制、十六进制
-
bin()：转换为二进制
-
oct()：转换为八进制
-
int()：转换为十进制整数
-
hex()：转换为十六进制
-
float()：转换为浮点数
-
complex(x)：将x转换到一个复数，实数部分为 x，虚数部分为 0。
-
complex(x, y)：将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。
-
bool(x)：将 x 转化为布尔值
1.3.3 字节串
bytes
字节串是通过在字符串前加上"b"来表示的：
byte_string = b'hello'
print(byte_string) # 输出: b'hello'
print(type(byte_string)) # 输出: <class 'bytes'>字节串通常用于表示二进制数据，比如网络通信、加密解密、协议解析、文件操作等场景。
1.3.4 空值
空值用 None 表示，类型为 NoneType
none_value = None
print(none_value) # 输出: None
print(type(none_value)) # 输出: <class 'NoneType'>-
None 表示没有值或缺失的值。
-
通常用于函数没有返回值的情况，或者用作可选参数的默认值。
1.4 复合类型初识
Python 支持多种复合数据类型，可将不同值组合在一起。
1.4.1 列表类型
list
列表是用方括号标注、逗号分隔的一组值，可以（我的意思是不要）包含不同类型的元素：
-
列表内的数据有先后顺序关系
-
列表是可变的容器
1.4.1.1 列表创建
-
字面值
L = [] # 创建一个空的列表 L = ['北京', '上海', '广州', '西安'] # 创建一个含有4个字符串的列表 L = [1, 'Two', 3.14, True, False, None] L = [1, 2, [3.1, 3.2], 4] # 含有四个元素的列表，第三个元素是列表 L2 = [ ['姓名','语文成绩','数学成绩'], ['小明', 90, 100], ['小红', 59, 26] ] -
构造函数list
list() # 创建一个空的列表，等同于 [] list(可迭代对象) # 用可迭代对象创建一个列表示例
L = list() # L = [] L = list("ABC") # L = ['A', 'B', 'C'] L = list(range(5)) # L = [0, 1, 2, 3, 4]
1.4.1.2 列表运算
列表list同字符串str都是序列, 他们的运算规则基本相同。
-
+ 用于拼接列表
[1, 2, 3] + [4, 5, 6] # [1, 2, 3, 4, 5, 6] -
+= 追加
语法列表 += 可迭代对象
L = [1, 2, 3] L += [4, 5] # L = [1, 2, 3, 4, 5] L = [1, 2, 3] L += "ABC" # L = [1, 2, 3, 'A', 'B', 'C'] L += range(2) -
* 用于生产重复的列表
[1, 2] * 3 # [1, 2, 1, 2, 1, 2] L = [5, 6] L *= 3 # L = [5, 6, 5, 6, 5, 6] -
== 、!= 用于比较
[1, 2] * 3 # [1, 2, 1, 2, 1, 2] L = [5, 6] L *= 3 # L = [5, 6, 5, 6, 5, 6] -
in 、not in 用于判断一个数据元素是否在列表中
"hello" in [1, "hello", 'world'] True 'm0nesy' in ['niko', 'donk'] False
1.4.1.3 列表访问
1.4.1.3.1 索引
列表[整数表达式]
L = [1, 2, 3, 4, 5, 6]
print(L[0]) # 1
print(L[-1]) # 6与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )1.4.1.3.2 反向索引
索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )1.4.1.3.3 切片
列表[(开始索引b):(终止索引e)(: (步长s))] () 里的内容代表可以省略
x = [1, 2, 3, 4, 5, 6, 7, 8]
y1 = x[:4] # y1 = [1, 2, 3, 4]
y2 = x[::2] # y2 = [1, 3, 5, 7]
y3 = x[::-1] # y3 = [8, 7, 6, 5, 4, 3, 2, 1]
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
list = ['openAI', 'donk', "Zhihu", "Taobao", "Wiki"]
# 读取第二位
print (list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print (list[1:-2])
# 从下标2开始(包含2)到最后一个
print (list[2:])
# 从下标0开始到下标3结束(左闭右开)
print (list[:3])1.4.1.4 列表操作
增、删、改、查（就是列表访问）
1.4.1.4.1 添加数据
-
方法
| 方法名(L代表列表) | 说明 |
|---|---|
| L.append(x) | 向列表的末尾追加单个数据 |
| L.insert(index, obj) | 将某个数据obj 插入到 index这个索引位置的数据之前 |
| L.extend(可迭代对象) | 等同于: L += 可迭代对象 |
-
示例
mylist1 = [1, 3, 4] # 目标是变成 [1, 2, 3, 4, 5] mylist1.append(5) # mylist1 = [1, 3, 4, 5] mylist1.insert(1, 2) # mylist1 = [1, 2, 3, 4, 5] mylist1.extend(range(6, 10)) # mylist1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
1.4.1.4.2 修改数据
-
用索引赋值可以改变列表内的数据
列表[整数表达式] = 表达式 -
示例
mylist2 = [1, 1.99, 3] # 把1.99 改为2 mylist2[1] = 2 # mylist2 = [1, 2, 3]
1.4.1.4.3 删除数据
-
方法
方法 说明 L.remove(x) 从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错 L.pop() 根据索引删除元素，并返回该元素。若不提供索引，默认删除最后一个元素 L.clear() 清空列表 -
示例
L = [1, 2, 3, 4, 2, 2, 3, 4] L.remove(3) # L = [1, 2, 4, 2, 2, 3, 4] L.remove(3) # L = [1, 2, 4, 2, 2, 4] L.remove(3) # 报错了 L.clear() # L = []
-
-
del 语句删除指定位置的数据元素
-
语法
del 变量名 # 删除变量，同时解除变量绑定的对象 del 列表[整数表达式] -
示例
L = ['张飞', '赵云', '鲁班7号', '孙悟空'] del L[2] # L = ['张飞', '赵云', '孙悟空'] del L # 删除 L 变量
-
1.4.1.5 常见API
可变容器操作：内置类型 — Python 3.13.3 文档
举例如下：
| 序号 | 函数 |
|---|---|
| 1 | len(list)列表元素个数 |
| 2 | max(list)返回列表元素最大值 |
| 3 | min(list)返回列表元素最小值 |
| 4 | list(seq)将元组转换为列表 |
1.4.2 元组类型
tuple
元组用来存储有序数据，多个值用逗号隔开。
-
元组使用小括号 ( )，虽然圆括号可有可无；
-
元组的元素多为异质的，不可变的（immutable），通过解包或索引访问；
-
列表的元素多为同质的，可变的（mutable），可迭代访问；
1.4.2.1 元组创建
-
创建元组的字面值
用小括号() 括起来，单个元素括起来后加逗号来区分单个元素还是元组
t = () # 空元组
t = (100,) # 一个元素的元组，
t = 100, # 一个元素的元组，在元素后面添加逗号，否则括号会被当作运算符
t = (1, 2, 3) # 含有三个数据元素的元组
t = ( 'niko', 2004) # 存放不同类型的元组
t = 1, 2, 3 # 含有三个数据元素的元组-
创建元组的函数 tuple
t = tuple() # t = () t = tuple(range(5)) # t = (0, 1, 2, 3, 4)
1.4.2.2 元组操作
元组是不可变容器，相对来讲操作少一些。
1.4.2.2.1 删除元组
元组中的元素值是不允许删除的，但可以用del删除元组
tup = ('openAI', 'jack', 100, 200)
print (tup)
del tup
print (tup) #name 'tup' is not defined1.4.2.2.2 查看元组
元组的元素访问可以像列表一样通过下标、切割等方式去访问。。
tup1 = ('python', 'jack', 100, 200)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print (tup1[0])#python
print (tup2[1:5])#(2, 3, 4, 5)
print (tup2[:4])#(1, 2, 3, 4)
print (tup2[2:])#(3, 4, 5, 6, 7)1.4.2.2.3 解包技能
必备技能
序列解包：解构赋值，左侧变量与右侧序列元素的数量应相等
fruit = ('apple', 'pear', 'peach')
f1, f2, f3 = fruit
print(f1, f2, f3)1.4.2.3 元组运算
元组中的元素值是不允许修改的，但可以对元组进行连接组合
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
t = (1, 2, 3) + (4, 5, 6)
t += (7, 8, 9) # 等同于 t = t + (7, 8, 9)
t = t * 2
t *= 2
5 in t1.4.2.4 元组不可变
不可变指的是变量指向的内存中的内容不可变，但是变量的指向是可以改变的。
tup = (1, 2, 3, 4, 5, 6, 7)
tup[1] = 100
print(tup)#报错'tuple' object does not support item assignment变量是可以重新赋值的
tup1 = (12, 34.56)
tup1 = (12, 100)
tup11.4.2.5 元组常用API
通用操作：https://docs.python.org/zh-cn/3.13/library/stdtypes.html#common-sequence-operations
Python元组包含了以下内置函数
| 序号 | 方法 | 描述 |
|---|---|---|
| 1 | len(tuple) | 返回元组中元素个数。 |
| 2 | max(tuple) | 返回元组中元素最大值。 |
| 3 | min(tuple) | 返回元组中元素最小值。 |
| 4 | tuple(list) | 将列表转换为元组。 |
元组常用的方法
| 运算 | 结果 |
|---|---|
| s.index(x[, i[, j]]) | x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前） |
| s.count(x) | x 在 s 中出现的总次数 |
1.4.3 字典dict
-
字典是可变容器，可存储任意类型对象
-
字典以键(key)-值(value)对的形式进行映射，键值对用冒号分割，对之间用逗号分割
-
d = {key1 : value1, key2 : value2, key3 : value3 }
-
字典的数据是无序的
-
字典的键只能用不可变类型，且不能重复
-
字典的数据用键进行索引，不能用整数进行索引
1.4.3.1 字典创建
-
创建字典的字面值
d = {} # 创建空字典
d = {'name': "weimingze", "age": 35}
d = {'a': [1, 2, 3]}
d = {'b': {"bb": 222}}
d = {1:'壹', 2:'贰', 5:'伍'}
d = {(1, 2, 3):'壹贰伍'}-
以下写法会存在问题
d = {'a': 1, 'b': 2, 'a': 3} # 字典的键不能重复 d = {'a': 3, 'b': 2}
d = {[1, 2, 3]: 'a'} # TypeError: unhashable type: 'list'-
字典的创建函数 dict()
d = dict() # d = {}
d = dict([("name", "小王"), ("age", 35)]) # {'name': '小王', 'age': 35}
d = dict(a=1, b=2, c=3) # {'a':1, 'b':2, 'c':3}
d = dict([1, 2, 3, 4]) # 错1.4.3.2 字典操作
增、删、改、查
1.4.3.2.1 增加或修改
添加和修改字典的元素
-
语法
字典[键key] = 表达式键不存在, 就添加
键存在, 会改变键对应的值
-
示例
d = {} d['name'] = 'tarena' # 添加键值对 d['age'] = 18 # d = {'name': 'tarena', 'age': 18} d['age'] = 19 # 改变键对应的值
1.4.3.2.2 访问值
-
字典的键索引
-
语法
字典[键key] -
示例
d = {'one': 1, 'two': 2} print(d['two']) -
如果键不存在，会报错
mydic = {'Name': 'jack', 'Age': 7, 'Class': 'First'} print (mydic['Alice']) # KeyError: 'Alice'
-
1.4.3.2.3 in/not in
in用于判断一个键是否存在于字典中,存在返回True, 否则返回False
-
示例
d = dict(a=1, b=2) # d = {'a': 1, 'b': 2} print('a' in d) # True print(1 in d) # False print('hello' not in d) # True
1.4.3.2.4 删除元素
能删单一的元素也能清空字典，显式删除一个字典用del命令
-
语法
del 字典[键]-
示例
mydic = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del mydic['Name'] # 删除键 'Name'
mydic.clear() # 清空字典
print (mydic['Age'])
print (mydic['School'])
del mydic # 删除字典1.4.3.3 字典特性
-
不允许同一个键出现两次，否则后一个覆盖前一个
mydic = {'Name': 'jack', 'Age': 27, 'Name': 'karen'} print (mydic['Name']) -
键必须不可变，可以用数字、字符串或元组，列表不行
mydic1 = {97:"a",98:"b"} mydic2 = {"name":"karen","age":27} mydic3 = {['Name']: 'karen', 'Age': 27} print(mydic3[['Name']]) #报错unhashable type: 'list'
1.4.3.4 常用API
官方文档：https://docs.python.org/zh-cn/3.13/library/stdtypes.html#mapping-types-dict
操作字典的函数：
| 序号 | 函数 | 描述 |
|---|---|---|
| 1 | len(dict) | 计算字典元素个数，即键的总数。 |
| 2 | str(dict) | 输出字典，可以打印的字符串表示。 |
| 3 | type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
字典的方法：
| 序号 | 函数及描述 |
|---|---|
| 1 | dict.clear()删除字典内所有元素 |
| 2 | dict.copy()返回一个字典的浅复制 |
| 4 | dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值 |
| 5 | key in dict如果键在字典dict里返回true，否则返回false |
| 6 | dict.items()以列表返回一个视图对象 |
| 7 | dict.keys()返回一个视图对象 |
| 9 | dict.update(dict2)把字典dict2的键/值对更新到dict里 |
| 10 | dict.values()返回一个视图对象 |
| 11 | pop(key,default)删除字典 key（键）所对应的值，返回被删除的值。 |
1.4.4 set/ frozenset
集合set和固定集合frozenset
set的元素值必须是不可变的，set中可以存储int、str、tuple等不可变类型，但不能存储 list、dict 等可变类型。
-
集合是可变的容器，固定集合是不可变的集合
-
集合相当于只有键没有值的字典，当然你也可以理解为键和值相等
-
集合内的数据都是唯一的，不可变的
1.4.4.1 集合创建
-
创建集合的方式
空集合 set()
非空集合用 {} 括起来，值用逗号分隔开
s = set() # 用函数空集合 s = {1, 2, 3, 4} # 创建非空集合的字面值 s = set(range(5)) # 调用 set(可迭代对象) 来创建集合 s = {0, 1, 2, 3, 4} s = set("ABC") # s = {'B', 'C', 'A'} s = set("ABCCCCCCC") # s = {'B', 'C', 'A'} s = set(['ABC']) # s = {'ABC'} 使用 set()函数从列表创建集合 s = set((4, 5, 6, 7))# 使用 set()函数从元组创建集合 -
创建固定集合frozensets的方式
fs = frozenset() # 空固定集合 fs = frozenset() fs = frozenset([1, 2, 3]) # fs = frozenset({1, 2, 3})
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
1.4.4.2 集合操作
1.4.4.2.1 添加元素
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
-
s.add( x ) 添加元素到集合。
-
s.update( x ) 添加元素到集合，且参数可以是列表、元组、字典等，x 可以有多个，用逗号分开。
s1 = set((4, 5, 6, 7))
s1.add(100)
print(s1)
s1.update([200,300])
print(s1)1.4.4.2.2 删除元素
-
s.remove( x )：将元素 x 从集合 s 中移除，不存在会发生错误。
-
s.discard( x )：将元素 x 从集合 s 中移除，不存在也不会发生错误。
-
s.pop()：对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
s1 = {10, 20, 30}
s1.remove(20)
print(s1)
s1.remove(40)#报错
s1 = {10, 20, 30}
s1.discard(20)
print(s1)
s1.discard(40)
s1 = {10, 20, 30}
s1.pop()
print(s1)
del s1 # 也可以直接删除整个集合1.4.4.2.3 访问与修改
集合是无序的、不可重复的数据结构，不能通过索引来访问其元素。所以也没有对应的修改功能。
TODO：需要通过便利或者迭代器去访问。
1.4.4.2.4 in/not in
x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
s1 = {10, 20, 30}
print(20 in s1)1.4.4.3 常用API
集合的方法
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集，并更新到集合。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
| len() | 计算集合元素个数 |
示例：
# 1.len()
s1 = {10, 20, 30}
print(len(s1))
#2. clear()
s1 = {10, 20, 30}
s1.clear()
print(s1)
#3.union()
set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = {5, 6, 7}
result = set1.union(set2, set3)
print(result) 1.5 可变与不可变
Python中，变量的值分为可变（mutable）或 不可变（immutable），该特征决定了变量在赋值、修改时的行为和性能。
1.5.1 不可变类型
不可变类型的值一旦创建，就无法改变。任何试图修改不可变对象的操作都会创建一个新的对象。常见不可变类型包括：
-
数值类型：int、float、complex
数字的值一旦赋值，不能被修改。
x = 10 print(id(x), hex(id(x))) x = x + 5 # 会创建一个新的整数对象，并将其赋值给 x print(id(x), hex(id(x)))id()：获取变量引用的内存地址；
hex()：转换为16进制；
-
字符串
字符串是不可变的，任何试图修改字符串内容的操作都会生成一个新的字符串。
s = "hello" print(id(s)) s = s + " world" # 创建一个新的字符串对象并赋值给 s print(id(s)) -
元组
元组是不可变的容器类型，一旦创建，其内容不能更改。
t = (1, 2, 3) # t[0] = 10 # 会抛出 TypeError: 'tuple' object does not support item assignment -
冻结集合
frozenset 是不可变版本的集合，一旦创建，无法修改其元素。
fs = frozenset([1, 2, 3]) # fs.add(4) # 会抛出 AttributeError: 'frozenset' object has no attribute 'add' -
布尔值
布尔值
True和False也属于不可变类型。flag = True flag = False # 这不是修改，而是创建了一个新的布尔值并赋值给flag -
字节串和None
字节串和None为不可变类型。
1.5.2 可变类型
可变类型的值在创建后可以被修改。常见的可变类型：
-
列表
列表是可变的，可以在原地修改其元素、添加或删除元素。
lst = [1, 2, 3] lst[0] = 10 # 修改原列表的元素 lst.append(4) # 添加新的元素 -
字典
字典也是可变类型，可以修改其键值对。
d = {'a': 1, 'b': 2} d['a'] = 10 # 修改字典中键 'a' 对应的值 d['c'] = 3 # 添加新的键值对 -
集合
s = {1, 2, 3} s.add(4) # 添加元素 s.remove(2) # 删除元素集合是可变的，可以添加或删除元素。
-
自定义对象
自定义类的实例如果没有在类中明确限制其属性，可以修改实例的属性值，因此对象实例也是可变的。
class MyClass: def __init__(self): self.value = 0 obj = MyClass() obj.value = 10 # 修改对象的属性
1.5.3 二者区别
-
内存管理
-
对不可变类型改值时，Python会创建一个新的对象，并将该对象的引用赋给原来的变量。
-
对可变类型修改内容时，不会创建新的对象，而是直接在原地进行修改。
变量引用 浅拷贝 深拷贝
-
-
行为差异
-
不可变对象的引用在修改后总会指向一个新对象，而可变对象的引用在修改时仍然指向原始对象。
-
-
作为字典键
-
不可变类型具有固定的哈希值，可以作为字典的键。
-
可变类型哈希值可能变化，不能作为字典的键。
d = {} d[(1, 2)] = "tuple key" # 元组是不可变的，可以作为字典的键 d[[1, 2]] = "list key" # 会抛出 TypeError: unhashable type: 'list' -
-
特别注意
以上是基于修改而不是赋值，重新赋值操作都会指向新的对象引用。
1.6 类型判断
使用isinstance判断类型变量
a = 1
print(isinstance(a, int)) #判断是否属于指定类型
str1 = 'abc'
print(isinstance(str1, (int, str))) #判断是否属于多个类型之一1.7 类型转换
这里只是总结一下常见类型转换的函数：
| 函数 | 说明 | 示例 |
|---|---|---|
| int(x) | 将 x 转换为整数类型。 | int("10") → 10 |
| float(x) | 将 x 转换为浮点数类型。 | float("3.14") → 3.14 |
| str(x) | 将 x 转换为字符串类型。 | str(123) → "123" |
| list(x) | 将 x 转换为列表类型，x 必须是可迭代对象。 | list((1, 2, 3)) → [1, 2, 3] |
| tuple(x) | 将 x 转换为元组类型，x 必须是可迭代对象。 | tuple([1, 2, 3]) → (1, 2, 3) |
| set(x) | 将 x 转换为集合类型，x 必须是可迭代对象。 | set([1, 2, 3]) → {1, 2, 3} |
| dict(x) | 将 x 转换为字典类型，x 必须是可迭代的键值对序列（如列表、元组）。 | dict([('a', 1), ('b', 2)]) → {'a': 1, 'b': 2} |
| bool(x) | 将 x 转换为布尔类型，x 的值可以是任何对象，返回 True 或 False。 | bool(0) → False ； bool("abc") → True |
| frozenset(x) | 将 x 转换为冻结集合，x 必须是可迭代对象。 | frozenset([1, 2, 3]) → frozenset({1, 2, 3}) |
| bytes(x) | 将 x 转换为字节串类型，x 可以是字符串、字节数组等。 | bytes("hello", "utf-8") → b'hello' |
| complex(x) | 将 x 转换为复数类型。 | complex(2) → (2+0j) |
| chr(x) | 将整数 x 转换为对应的字符，x 是 Unicode 码点。 | chr(97) → 'a' |
| ord(x) | 将字符 x 转换为对应的整数，x 是一个单一字符。 | ord('a') → 97 |
| eval(x) | 将字符串 x 作为 Python 表达式进行求值并返回结果。 | eval('3 + 4') → 7 |
| set(x) | 将可迭代对象 x 转换为集合。 | set([1, 2, 2, 3]) → {1, 2, 3} |
注意事项：
-
并不是所有类型都可以直接转换。如：
int("hello") # 会抛出 ValueError: invalid literal for int() with base 10: 'hello' -
类型转换可能会引发错误或丢失信息，比如浮点数转换为整数时，小数部分会丢失。
扫一扫
3293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
