493 lines
11 KiB
Markdown
493 lines
11 KiB
Markdown
# Python基本数据结构
|
||
|
||
# 列表(List)
|
||
|
||
列表是一个有序的可变集合，可以存储不同类型的元素。列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据。而且列表是有序的，有索引值，可切片，方便取值。
|
||
|
||
## 定义列表
|
||
|
||
```python
|
||
fruits = ["apple", "banana", "cherry"]
|
||
print(fruits)
|
||
|
||
# Output:
|
||
['apple', 'banana', 'cherry']
|
||
```
|
||
|
||
## 增加元素
|
||
|
||
```python
|
||
# 1. 按照索引的位置去增加
|
||
fruits.insert(1, "kiwi")
|
||
|
||
# 2. 在最末尾添加
|
||
fruits.append("orange")
|
||
|
||
# 3. 用迭代的方式去添加
|
||
fruits.extend(['a','b','c'])
|
||
# 可以立即为再传递一个List进去，然后依次添加到末尾,而append会把括号里的当成一个整体添加到末尾
|
||
|
||
# Output:
|
||
['apple', 'kiwi', 'banana', 'cherry', 'orange', 'a', 'b', 'c']
|
||
```
|
||
|
||
## 删除元素
|
||
|
||
```python
|
||
# 1. 删除制定的具体元素
|
||
fruits.remove("cherry")
|
||
|
||
# 2. 按照索引位置去删除
|
||
fruits.pop() # 默认是删除最后一个，可以加上索引。并且有返回值，返回值为删除的元素
|
||
fruits.pop(1)
|
||
|
||
# 3. 使用切片范围删除
|
||
del fruits[1:3] # 没有返回值
|
||
|
||
# 4. 清空列表
|
||
fruits.clear()
|
||
|
||
# 5. 删除列表
|
||
del fruits
|
||
|
||
# clear是清空列表的内容，变成一个空列表，而del是删除列表本身，后续无法再次调用...
|
||
|
||
# Output:
|
||
['apple', 'banana', 'cherry']
|
||
['apple', 'kiwi', 'banana', 'cherry', 'orange', 'a', 'b', 'c']
|
||
[]
|
||
```
|
||
|
||
## 修改元素
|
||
|
||
```python
|
||
# 1. 按照索引修改某个元素的值
|
||
fruits = ["apple", "banana", "cherry"]
|
||
fruits[1] = "orange"
|
||
print(fruits)
|
||
|
||
# Output:
|
||
['apple', 'orange', 'cherry']
|
||
|
||
# 2. 按照切片范围修改
|
||
fruits[0:2] = ['kiwi','orange']
|
||
print(fruits)
|
||
|
||
# Output:
|
||
['kiwi', 'orange', 'cherry']
|
||
```
|
||
|
||
## 查找元素
|
||
|
||
```python
|
||
# 1. index(element)：返回元素的索引
|
||
fruits = ["apple", "banana", "cherry"]
|
||
index_of_apple = fruits.index("apple")
|
||
print(index_of_apple)
|
||
|
||
# Output:
|
||
0
|
||
|
||
# 2. count(element)：返回元素出现的次数
|
||
count_of_cherry = fruits.count("cherry")
|
||
print(count_of_cherry)
|
||
|
||
# Output:
|
||
1
|
||
```
|
||
|
||
## 列表的切片
|
||
|
||
切片是按照一定的索引规律分割列表从而组成一个新的列表，类似与我们字符串中讲到的切片
|
||
|
||
```python
|
||
li = [1,2,4,5,4,2,4]
|
||
sub_li = li[2:5]
|
||
print(sub_li)
|
||
|
||
# Output:
|
||
[4, 5, 4]
|
||
```
|
||
|
||
## 其他操作
|
||
|
||
```python
|
||
li = [1,2,4,5,4,2,4]
|
||
# 1. 统计某个元素出现的次数
|
||
print (li.count(4))
|
||
|
||
# 2. 从列表中找出某个值第一个匹配项的索引位置
|
||
print (li.index(2))
|
||
|
||
# 3. 对列表进行排序
|
||
li.sort()
|
||
print(li)
|
||
|
||
# 4. 将列表中的元素反向存放
|
||
li.reverse()
|
||
print (li)
|
||
|
||
# Output:
|
||
3
|
||
1
|
||
[1, 2, 2, 4, 4, 4, 5]
|
||
[5, 4, 4, 4, 2, 2, 1]
|
||
```
|
||
|
||
# 元组(Tuple)
|
||
|
||
有序的不可变集合，也被被称为只读列表，即数据可以被查询，但不能被修改。
|
||
|
||
## 定义元组
|
||
|
||
```python
|
||
tuple = (1,2,3,'a','b','c')
|
||
print(tuple)
|
||
print(tuple[1])
|
||
|
||
# 可以删除元素吗?
|
||
tuple.pop()
|
||
|
||
# Output:
|
||
AttributeError: 'tuple' object has no attribute 'pop'
|
||
```
|
||
|
||
## 可变元组
|
||
|
||
tuple其实不可变的是地址空间，如果地址空间里存的是可变的数据类型的话，比如列表就是可变的
|
||
|
||
```python
|
||
tuple = (1, 2, 3, [1, 4, 7])
|
||
print(tuple)
|
||
tuple[3][2] = 100
|
||
print(tuple)
|
||
|
||
# Output:
|
||
(1, 2, 3, [1, 4, 7])
|
||
(1, 2, 3, [1, 4, 100])
|
||
```
|
||
|
||
在元组tuple中，包含一个list类型的数据，由于list是可以变的，所以我们可以更改元组里list的值，但是元组本身的地址空间是不变的。
|
||
|
||
<img src="./03.python更多数据类型/image-20240904095734746.png" alt="image-20240904095734746" style="zoom:80%;" />
|
||
|
||
# 字典(Dict)
|
||
|
||
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
|
||
|
||
不过在Python 3.6版本以后，字典会保留插入顺序，变成有序数据结构。
|
||
|
||
而且键是具有唯一性的，每个键只能出现一次，但是值没有限制，在一个字典中可以出现多个相同的值。
|
||
|
||
## 定义字典
|
||
|
||
```python
|
||
dic = {'name':'nls','age':18,'job':'teacher'}
|
||
print(dic)
|
||
print(dic['name'])
|
||
print(dic['age'])
|
||
print(dic['job'])
|
||
|
||
# Output:
|
||
{'name': 'nls', 'age': 18, 'job': 'teacher'}
|
||
nls
|
||
18
|
||
teacher
|
||
```
|
||
|
||
## 增加键值
|
||
|
||
```python
|
||
dic = {'name':'nls','age':18,'job':'teacher'}
|
||
|
||
# 1. 直接通过键值对来增加
|
||
dic['hobby'] = 'study' # 如果键已经存在，那么就会替换原来的值
|
||
|
||
print(dic)
|
||
# Output: {'name': 'nls', 'age': 18, 'job': 'teacher', 'hobby': 'study'}
|
||
|
||
# 2. 在字典中添加键值对时，如果指定的键已经存在则不做任何操作,如果原字典中不存在指定的键值对，则会添加。
|
||
dic.setdefault('name','牛老师')
|
||
dic.setdefault('gender','男')
|
||
print(dic)
|
||
|
||
# Output:
|
||
{'name': 'nls', 'age': 18, 'job': 'teacher', 'hobby': 'study', 'gender': '男'}
|
||
```
|
||
|
||
## 删除键值
|
||
|
||
```python
|
||
dic = {'name':'nls','age':18,'job':'teacher'}
|
||
|
||
# 1. 删除指定的键,并且返回对应的值
|
||
name = dic.pop('job')
|
||
hobby = dic.pop('hobby','查无此项') # 可以在后面加上一个异常处理，如果key不存在，就输出后面的内容
|
||
print(dic)
|
||
print(name)
|
||
print(hobby)
|
||
|
||
# Output:
|
||
{'name': 'nls', 'age': 18}
|
||
teacher
|
||
查无此项
|
||
|
||
# 2. 使用del关键字删除指定的键值对
|
||
del dic['name']
|
||
|
||
# 3. 删除最后插入的键值对
|
||
dic_pop = dic.popitem()
|
||
print(dic_pop)
|
||
|
||
# 4. 清空字典
|
||
dic.clear()
|
||
print(dic)
|
||
|
||
# Output: {}
|
||
```
|
||
|
||
## 修改键值
|
||
|
||
```python
|
||
dic = {'name':'nls','age':18,'job':'teacher'}
|
||
dic['age'] = 25
|
||
|
||
print(dic)
|
||
|
||
# Output:
|
||
{'name': 'nls', 'age': 25, 'job': 'teacher'}
|
||
```
|
||
|
||
## 查找键值
|
||
|
||
```python
|
||
dic = {'name':'nls','age':18,'job':'teacher'}
|
||
# 1. 直接通过键名获取，如果不存在会报错
|
||
value = dic['name']
|
||
print(value)
|
||
|
||
# 2. 使用get方法获取键值,若不存在则返回 None，可以自定义异常返回值
|
||
value = dic.get('job','查无此项')
|
||
print(value)
|
||
|
||
# Output:
|
||
nls
|
||
teacher
|
||
|
||
# 3. IN关键字，存在返回True，反之False
|
||
exists = "name" in dic
|
||
print(exists)
|
||
|
||
# Output:
|
||
True
|
||
```
|
||
|
||
## 其他操作
|
||
|
||
```python
|
||
dic = {'name':'nls','age':18,"phone":['1888888888','0511-10101010']}
|
||
# 字典里面的value也可以是容器类型的数据，比如列表，字典等等...但是key必须是不可变的
|
||
print(dic)
|
||
|
||
# 1. 对键和值进行迭代操作
|
||
for i in dic.items():
|
||
# 将键和值作为元祖列出
|
||
print(i)
|
||
|
||
for i in dic:
|
||
# 只迭代键
|
||
print(i)
|
||
|
||
# Output:
|
||
('name', 'nls')
|
||
('age', 18)
|
||
('phone', ['1888888888', '0511-10101010'])
|
||
name
|
||
age
|
||
phone
|
||
|
||
# 2. 使用keys()和values()方法获取键值
|
||
keys = dic.keys()
|
||
print(keys,type(keys))
|
||
|
||
value = dic.values()
|
||
print(value,type(value))
|
||
|
||
# Output:
|
||
dict_keys(['name', 'age', 'phone']) <class 'dict_keys'>
|
||
dict_values(['nls', 18, ['1888888888', '0511-10101010']]) <class 'dict_values'>
|
||
```
|
||
|
||
# 集合(Set)
|
||
|
||
集合是**无序**的，**不重复**，**确定性**的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
|
||
|
||
- 去重，把一个列表变成集合，就自动去重了。
|
||
- 关系测试，测试两组数据之前的交集、差集、并集等关系。
|
||
|
||
## 定义集合
|
||
|
||
```python
|
||
set1 = {1,2,3,'a','b','c'} # 推荐方法
|
||
set2 = set({1,2,3})
|
||
|
||
print(set1, set2)
|
||
|
||
# Output:
|
||
{1, 2, 3, 'b', 'c', 'a'} {1, 2, 3}
|
||
```
|
||
|
||
## 增加元素
|
||
|
||
```python
|
||
set1 = {1,2,3,'a','b','c'}
|
||
# 1. 使用add()方法为集合增加元素
|
||
set1.add('d')
|
||
print(set1)
|
||
|
||
# Output:
|
||
{'a', 1, 2, 3, 'c', 'd', 'b'}
|
||
|
||
# 2. 使用update()方法迭代的去增加
|
||
set1.update('e','f')
|
||
# update接收的参数应该是可迭代的数据类型，比如字符串、元组、列表、集合、字典。这些都可以向集合中添加元素，但是整型、浮点型不可以
|
||
set1.update([4,5,6])
|
||
print(set1)
|
||
|
||
# Output:
|
||
{1, 2, 3, 4, 5, 6, 'a', 'd', 'b', 'c', 'f', 'e'}
|
||
```
|
||
|
||
## 删除元素
|
||
|
||
```python
|
||
set1 = {1,2,3,'a','b','c'}
|
||
# 1. 使用remove()方法删除元素
|
||
set1.remove('a')
|
||
|
||
print(set1)
|
||
|
||
# 2. 随机删除某个元素
|
||
set1.pop()
|
||
print(set1)
|
||
|
||
# Output:
|
||
{1, 2, 3, 'c', 'b'}
|
||
{2, 3, 'c', 'b'}
|
||
|
||
# 3. 删除集合本身
|
||
del set1
|
||
```
|
||
|
||
## 查找元素
|
||
|
||
```python
|
||
set1 = {1,2,3,'a','b','c'}
|
||
exists = "a" in set1 # True
|
||
print(exists)
|
||
```
|
||
|
||
## 关系测试
|
||
|
||
### 交集(& 或者 intersection)
|
||
|
||
取出两个集合共有的元素
|
||
|
||
```python
|
||
set1 = {1,2,3,4,5}
|
||
set2 = {3,4,5,6,7}
|
||
|
||
print(set1 & set2)
|
||
print(set1.intersection(set2))
|
||
|
||
# Output:
|
||
{3, 4, 5}
|
||
{3, 4, 5}
|
||
```
|
||
|
||
### 反交集(^ 或者 symmetric_difference)
|
||
|
||
```python
|
||
set1 = {1,2,3,4,5}
|
||
set2 = {3,4,5,6,7}
|
||
|
||
print(set1 ^ set2)
|
||
print(set1.symmetric_difference(set2))
|
||
|
||
# Output:
|
||
{1, 2, 6, 7}
|
||
{1, 2, 6, 7}
|
||
```
|
||
|
||
### 并集(| 或者 union)
|
||
|
||
合并两个集合的所有元素
|
||
|
||
```python
|
||
set1 = {1,2,3,4,5}
|
||
set2 = {3,4,5,6,7}
|
||
|
||
print(set1 | set2)
|
||
print(set2.union(set1))
|
||
|
||
# Output:
|
||
{1, 2, 3, 4, 5, 6, 7}
|
||
{1, 2, 3, 4, 5, 6, 7}
|
||
```
|
||
|
||
### 差集(- 或者 difference)
|
||
|
||
第一个集合去除二者共有的元素
|
||
|
||
```python
|
||
set1 = {1,2,3,4,5}
|
||
set2 = {3,4,5,6,7}
|
||
|
||
print(set1 - set2)
|
||
print(set1.difference(set2))
|
||
|
||
# Output:
|
||
{1, 2}
|
||
{1, 2}
|
||
```
|
||
|
||
### 子集与超集
|
||
|
||
当一个集合的所有元素都在另一个集合里，则称这个集合是另一个集合的子集，另一个集合是这个集合的超集
|
||
|
||
```python
|
||
set1 = {1,2,3}
|
||
set2 = {1,2,3,4,5,6}
|
||
|
||
print(set1 < set2)
|
||
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
|
||
|
||
print(set2 > set1)
|
||
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集
|
||
```
|
||
|
||
## 不可变集合
|
||
|
||
```python
|
||
set1 = {1,2,3,4,5,6}
|
||
|
||
set2 = frozenset(set1)
|
||
print(set2,type(set2))
|
||
|
||
set2.add(7) # 不可以修改,会报错
|
||
|
||
# Output:
|
||
AttributeError: 'frozenset' object has no attribute 'add'
|
||
```
|
||
|
||
# 数据结构的总结
|
||
|
||
| 数据结构 | 描述 | 特性 | 常见操作 | 适用场景 | 优点 | 缺点 |
|
||
| :-------------------- | :--------------- | :--------------------- | :--------------------- | :--------------------------------------- | :-------------------------- | :------------------------------------ |
|
||
| **列表 (List)** | 有序的可变集合 | 有序、可变、支持重复 | 添加、删除、修改、查找 | 需要维护元素顺序的场景，如队列、栈的实现 | 灵活性高，支持多种操作 | 查询复杂度为 O(n)，插入和删除性能较差 |
|
||
| **元组 (Tuple)** | 有序的不可变集合 | 有序、不可变、支持重复 | 查找 | 元素不需要修改的场景，如函数参数、字典键 | 更节省内存，速度较快 | 不支持修改 |
|
||
| **集合 (Set)** | 无序的可变集合 | 无序、可变、不支持重复 | 添加、删除、查找 | 需要去重和快速查找的场景，如集合运算 | 快速查找和去重 | 不支持索引，元素无序 |
|
||
| **字典 (Dictionary)** | 有序的键值对集合 | 有序、可变、键唯一 | 添加、删除、修改、查找 | 需要快速查找和存储键值对的场景，如缓存 | 快速查找（O(1) 平均复杂度） | 键必须是不可变类型，内存开销较大 |
|
||
| **字符串 (String)** | 字符的序列 | 不可变 | 查找、切片、替换 | 文本处理 | 易于使用，内置丰富的方法 | 不可修改，性能较低 |
|
||
|
||
# |