python基础语法复习02——复合类型
python基础语法目录
- python基础语法基础类型
文章目录
- python基础语法目录
- 前言
- 一、初识列表 list
-
- 1. 列表基本操作
-
- 1.1 创建列表
- 1.2 列表运算
- 1.3 列表访问
- 1.4 列表增删
- 2 常用函数
- 二、初识元组 tuple
-
- 1. 元组基本操作
-
- 1.1 创建元组
- 1.2 元组访问
- 1.3 元组运算
- 2. 常用函数
- 三、初识字典 dict
-
- 1. 字典基本操作
-
- 1.1 创建字典
- 1.2 增删改查
- 2 常用函数
- 四、初识集合 set
-
- 1.集合基本操作
-
- 1.1 创建集合
- 1.2 增删改查
- 2. 常用函数
- 补充
-
- 类型判断
- 类型转换
- 总结
前言
在之前的学习中，我们已经了解了python的基本类型与一些基本操作。但python常用的类型中除却基本类型外，还有许多复合类型，这些类型大多为一种容器。与其他语言不同的是，原生的python没有数组类型，而被这些容器类型取代了。
在pyhton中想使用数组可以导入array或者numpy
一、初识列表 list
在python中的列表与其他语言中的数组有许多相似之处。但同时，python中的列表有着很多独特的性质。
列表是用方括号标注、逗号分隔的一组值，包含不同类型的元素（但不建议这么做）：
- 列表内的数据有先后顺序关系
- 列表是可变的容器
1. 列表基本操作
1.1 创建列表
- 通过赋值语句创建
L = [] # 可以使用中括号创建一个空的列表
L = [a, 'b', 3, True, False, None] #列表中的元素类型可以是不同类型的
L = [1, 2, [3.1, 3.2], 4] # 列表可以任意嵌套
- 通过构造函数创建
list() # 等同于 []
list(可迭代对象) # 用可迭代对象（通常为元组、字符串、range(起始, 结束[, 步长])等类型）创建一个列表
1.2 列表运算
列表list同字符串str都是序列, 他们的运算规则基本相同。
- 列表的拼接
# 可以通过 + 运算符来拼接列表，返回一个新列表结果为[a,b,c,d]
[a,b] + [c,d] # [a,b,c,d]
形如： 列表 += 可迭代对象 也可拼接列表，但是原地操作，会修改列表本身
l=[1,2,3]
l+="OMG" # [1,2,3,'O','M','G']
l+=range(1,9,3) # [1,2,3,'O','M','G',1,4,7]
l+=['bye',"bye"] # [1,2,3,'O','M','G',1,4,7,'bye','bye']
- 列表的重复
形如： 列表 * 整数 ，用于构造元素高度重复的序列
[o,O] * 3 # [o,O,o,O,o,O]
- 列表的比较
# ==、!= 用于比较两个列表是否相等
['O','w','q'] == ['O','w','q'] # True
['O','w','q'] != ['q','w','O'] # True
- 判断是包含某元素
# in 、not in 用于判断一个数据元素是否在列表中
"two" in [1, "two", 'three'] # True
'哈利波特' not in ['三国演义', '水浒传'] # True
1.3 列表访问
- 索引
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。 同时支持反向索引，从尾部开始，最后一个元素的索引为 -1，往前一位为
-2，以此类推。
形如： 列表[整数表达式]
L = ['a','b','c','d','e']
print(L[0]) # a
print(L[-1]) # e
- 切片
形如： 列表[(开始索引b):(终止索引e)(: (步长s))]，() 里的内容代表可以省略
x = [1, 2, 3, 4, 5, 6, 7, 8]
y1 = x[:4] # y1 = [1, 2, 3, 4]
y2 = x[2::2] # y2 = [3, 5, 7]
y3 = x[7:4:-1] # y3 = [8, 7, 6]
1.4 列表增删
官方文档
- 添加数据
| 方法 | 说明 |
|---|---|
| L.append(x) | 向列表的末尾追加单个数据 |
| L.insert(index, obj) | 将某个数据obj 插入到 index这个索引位置的数据之前 |
| L.extend(可迭代对象) | 等同于: L += 可迭代对象 |
- 修改数据
可以通过索引修改列表
形如： 列表[整数表达式] = 表达式
L = ['O','w','q'] # 把 w 改为 _
L[1] = '_' # L = ['O','_','q']
- 删除数据
| 方法 | 说明 |
|---|---|
| L.remove(x) | 从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错 |
| L.pop() | 根据索引删除元素，并返回该元素。若不提供索引，默认删除最后一个元素 |
| L.clear() | 清空列表 |
- 也可用del 语句进行删除：
del 变量名 # 删除变量，同时解除变量绑定的对象
del 列表[整数表达式]
del 列表[切片表达式] # 等同于 列表[切片表达式] = []
2 常用函数
| 方法 | 说明 |
|---|---|
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
二、初识元组 tuple
元组用来存储有序数据，多个值用逗号隔开。
- 元组使用小括号 ( )，但括号可有可无；
- 元组的元素多为不同类型的，不可变的，通过解包或索引访问；
1. 元组基本操作
1.1 创建元组
# 用小括号() 括起来，单个元素括起来后加逗号来区分单个元素还是元组
t = () # 空元组
t = (11,) # 一个元素的元组，在元素后面添加逗号，否则括号会被当作运算符
t = 11, # 一个元素的元组
t = (11, 45, 14) # 含有三个数据元素的元组
t = ( 'kksk', 1919) # 存放不同类型的元组
t = 11, 45, 14 # 含有三个数据元素的元组
# 也可使用tuple()函数，形如 tuple(可迭代对象)
t = tuple(range(5)) # t = (0, 1, 2, 3, 4)
1.2 元组访问
元组的元素访问可以像列表一样通过下标、切片等方式去访问，这里不再赘述。
- 序列解包：解构赋值，左侧变量与右侧序列元素的数量应相等
book = ('三国演义', '水浒传', '西游记')
b1, b2, b3 = book
print(b1, b2, b3)
1.3 元组运算
元组中的元素值是不允许修改的，但可以对元组本身进行操作，即可对元组本身进行重新赋值。同时，对元组本身进行类似列表的拼接（+），重复（*），比较（==、!=），成员判断（in、not in）是允许的。
2. 常用函数
| 方法 | 说明 |
|---|---|
| len(tuple) | 返回元组中元素个数 |
| max(tuple) | 返回元组中元素最大值 |
| min(tuple) | 返回元组中元素最小值 |
| s.index(x[, i[, j]]) | x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前） |
| s.count(x) | x 在 s 中出现的总次数 |
三、初识字典 dict
- 字典是可变容器，可存储任意类型对象
- 字典以键(key)-值(value)对的形式进行映射，键值对用冒号分割，对之间用逗号分割。基本形式为：d = {key1 : value1, key2 : value2, key3 : value3 }
- 字典的数据是无序的
- 字典的键只能用不可变类型，且不能重复
- 字典的数据用键进行索引，不能用整数进行索引
1. 字典基本操作
1.1 创建字典
- 通过赋值创建
d = {} # 创建空字典
d = {'name': [0, 0, 7], "age": 35} # 指定键值对
d = {'a': {"bb": 'ccc'}} # 字典可以嵌套
d = {(1, 2, 5):'壹贰伍'} # 元组也可作为键
- 通过构造函数创建
d = dict() # 等同于d = {}
d = dict([("name", "小张"), ("age", 23)]) # 可以用两个元素的元组代替键值对
d = dict(a=1, b=2, c=3) # 也可用赋值语句代替键值对
1.2 增删改查
- 添加和修改字典的元素
形如： 字典[键key] = 表达式
键不存在, 就添加
键存在, 会改变键对应的值
d = {}
d['name'] = 'Li Hua' # 添加键值对
d['age'] = 12 # d = {'name': 'Li Hua', 'age': 12}
d['age'] = 13 # 改变键对应的值
- 访问元素
形如： 字典[键key]
如果键不存在，会报错
- 成员判断
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('c' not in D) # True
- 删除元素
| 方法 | 说明 |
|---|---|
| del 字典[键] | 删除键值对 |
| del 字典 | 删除字典 |
| 字典.clear() | 清空集合 |
2 常用函数
| 方法 | 说明 |
|---|---|
| len(dict) | 计算字典元素个数，即键的总数。 |
| str(dict) | 输出字典，可以打印的字符串表示。 |
| type(variable) | 返回输入的变量类型，如果变量是字典就返回字典类型。 |
| dict.copy() | 返回一个字典的浅复制 |
| dict.get(key, default=None) | 返回指定键的值，如果键不在字典中返回 default 设置的默认值 |
| dict.items() | 以列表返回一个视图对象 |
| dict.keys() | 返回一个视图对象 |
| dict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
| dict.values() | 返回一个视图对象 |
| pop(key,default) | 删除字典 key（键）所对应的值，返回被删除的值。 |
四、初识集合 set
集合set和固定集合frozenset
set的元素值必须是不可变的，set中可以存储int、str、tuple等不可变类型，但不能存储 list、dict 等可变类型。
- 集合是可变的容器，固定集合是不可变的集合
- 集合相当于只有键没有值的字典，当然你也可以理解为键和值相等
- 集合内的数据都是唯一的，不可变的
1.集合基本操作
1.1 创建集合
- 创建集合set
空集合 set()
非空集合用 {} 括起来，值用逗号分隔开
创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
s = set() # 用函数创建空集合
s = {1, 2, 3, 4} # 用赋值语句集合
s = set(range(5)) # 调用 set(可迭代对象) 来创建集合
s = set("ABCCCCCCC") # s = {'B', 'C', 'A'}
s = set(['ABC']) # s = {'ABC'} 使用 set()函数从列表创建集合
s = set((1, 4, 7)) # 使用 set()函数从元组创建集合
- 创建固定集合frozensets
fs = frozenset() # 空固定集合
fs = frozenset([1, 2, 3]) # 等同于 fs = frozenset({1, 2, 3})
1.2 增删改查
- 添加元素
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
- s.add( x ) 添加元素到集合。
- s.update( x ) 添加元素到集合，且参数可以是列表、元组、字典等，x 可以有多个，用逗号分开。
- 删除元素
- s.remove( x )：将元素 x 从集合 s 中移除，不存在会发生错误。
- s.discard( x )：将元素 x 从集合 s 中移除，不存在也不会发生错误。
- s.pop()：对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
- 访问元素
集合是无序的、不可重复的数据结构，不能通过索引来访问其元素。所以也没有对应的修改功能。
2. 常用函数
| 方法 | 说明 |
|---|---|
| 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() | 计算集合元素个数 |
补充
类型判断
使用isinstance判断类型变量
num = 100
print(isinstance(num, int)) #判断是否属于指定类型
string = 'aaaa'
print(isinstance(string, (int, str))) #判断是否属于多个类型之一
类型转换
| 方法 | 说明 |
|---|---|
| int(x) | 将 x 转换为整数类型。 |
| float(x) | 将 x 转换为浮点数类型。 |
| str(x) | 将 x 转换为字符串类型。 |
| list(x) | 将 x 转换为列表类型，x 必须是可迭代对象。 |
| tuple(x) | 将 x 转换为元组类型，x 必须是可迭代对象。 |
| set(x) | 将 x 转换为集合类型，x 必须是可迭代对象。 |
| dict(x) | 将 x 转换为字典类型，x 必须是可迭代的键值对序列（如列表、元组）。 |
| bool(x) | 将 x 转换为布尔类型，x 的值可以是任何对象，返回 True 或 False。 |
| frozenset(x) | 将 x 转换为冻结集合，x 必须是可迭代对象。 |
| bytes(x) | 将 x 转换为字节串类型，x 可以是字符串、字节数组等。 |
| complex(x) | 将 x 转换为复数类型。 |
| chr(x) | 将整数 x 转换为对应的字符，x 是 Unicode 码点。 |
| ord(x) | 将字符 x 转换为对应的整数，x 是一个单一字符。 |
| eval(x) | 将字符串 x 作为 Python 表达式进行求值并返回结果。 |
| set(x) | 将可迭代对象 x 转换为集合。 |
- 并不是所有类型都可以直接转换。如：字符串不能转为int
- 类型转换可能会引发错误或丢失信息，比如浮点数转换为整数时，小数部分会丢失。
总结
以上就是文章的全部内容，本文仅仅简单介绍了python的一些常见复合类型，这些复合类型在处理复杂数据结构和算法时尤为关键，能够显著提升代码的可读性和运行效率。理解这些类型的特点和区别，有助于在实际项目中做出更合理的选择。对于希望深入掌握Python的开发者而言，复合类型的灵活运用是进阶学习的必经之路。