Python数据容器详解

数据容器

数据容器是一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等

在Python中有不同的数据容器，他们有不同的特性，分为五类：列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)

list 列表

定义

list_name1 = [name1,name2,name3,...]
list_a = []
list_b = list()

以方括号作为表示，用逗号隔开，元素之间可以是不同的数据类型，支持嵌套，后面两种都是定义空列表的方式

例如

list_name2 = [[1,2,3],[3,4,5]]

使用

数组是利用下标索引进行访问的，有两种标号方式，一种是从左到右，依次标号为0，1，2，…；第二种是从右到左，一次标号为-1，-2，-3，…；

当我们想要进行取出数据时，可以利用方括号+下标的方式取出，例如

list_1 = list_name1[0]
list_2 = list_name2[0][1]

方法

这里的方法其实就类似于函数，但是需要配合数据容器进行使用

查找下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index(元素)

list_name3 = ['name1','name2','name3']
print(list_name3.index('name2'))  # 结果会输出 1

列表修改

功能：修改列表中元素的值

语法：列表[下标] = 值

list_name3[2] = 'name4'

插入

语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素

list_name3.insert(2,'name3')
print(list_name3) # 结果 ['name1','name2','name3','name4']

追加

语法：列表.append(元素)，将指定元素，追加到列表的尾部

list_name3.append('name5')

语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

list_name4 = ['name6','name7']
list_name3.append(list_name4)
print(list_name3) # 结果 ['name1','name2','name3','name4''name5','name6','name7']

删除

1. del 列表[下标]

   del list_name3[6]
   

2. 列表.pop(下标)

   list_name3.pop(5)
   

修改

1. 删除第一个匹配的元素 列表.remove(元素)

   list_name3.remove('name5')
   

2. 清空列表 列表.clear()

   list_name4.clear()
   

3. 统计某元素在列表内的数量 列表.count(元素)

   list_name3.count('name2')
   

查询

统计列表内，有多少元素

语法：len(列表)

可以得到一个int数字，表示列表内的元素数量

print(len(list_name3)) # 结果是 4

需要注意的是，方法其实非常多，也不需要死记硬背，用的多的自然会记下来，我们只需要知道有这样一个方法即可，要用的时候，只需要查一下

循环遍历

1. while

   index = 0
   while index < len(列表):
       元素 = 列表[index]
       处理
       idnex += 1
   

   这是列表一个简单的遍历，如果没有理解可以看一下之前流程控制的章节

2. for

   for 临时变量 in 容器
   	处理
   

   这里与上面不同的是，临时变量可以直接使用，类似于while循环中的元素，也相对便利，了解C++的朋友也可以认为这是简化版的范围for，感兴趣的朋友可以选择性阅读

tuple 元组

列表是可修改的，元组是不可修改的，同样的，也可以包含不同类型的元素

定义

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

tuple1 = (e1,e2,e3,...)
tuple2 = ()
tuple3 = tuple()
tuple4 = (e1,)
tuple5 = (e1)

tuple2和tuple3都是空元组，tuple4是只含一个元素的元组，需要注意的是当元组只有一个数据时，这个数据之后需要添加逗号，否则就不是元组类型，而是他本身的类型

操作

元组由于不可修改的特性，所以其操作方法非常少

方法	说明
index()	查找元组内数据，存在则返回下标，不存在则报错
count()	统计某个元素在元组内出现的次数
len()	统计元组内元素的个数

其余的特性除了修改元组内容基本上都和列表一样

str 字符串

对于字符串来说，他只是字符的容器，因此同样也支持下标的访问，他的内容也无法进行修改，我们只能对旧字符串操作之后得到新的字符串，原来的字符串是无法修改的

方法

查找下标

语法：字符串.index(字符串)

str1 = "rick and morty"
print(str1.index("and")) # 结果是5

替换

语法：字符串.replace(字符串1，字符串2）

功能：将字符串内的全部：字符串1，替换为字符串2

注意：不是修改字符串本身，而是得到了一个新字符串

str2 = str1.replace("and","or")
print(str2) # 结果是 rick or morty

分割

语法：字符串.split(分隔符字符串）

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

list1 = str1.split(' ')
print(list1) # 结果是 ['rick','and','morty']

去除前后空格

语法：字符串.strip()

str3 = "  rick and morty  "
str4 = str3.strip()

去除前后指定字符

语法：字符串.strip(字符串)

str5 = "_~rick and morty~_"
str6 = str5.strip("_~")

需要注意的是这里本质上是从传入的两个字符依次比较，删除相同的字符

统计字符串出现次数

语法：字符串.count(字符串)

count1 = str1.count('and')

统计字符串长度

语法：len(字符串)

len1 = len(str1)

序列的切片

序列

序列是指内容连续、有序，可以使用下标引用的一类数据容器，而列表、元组、字符串都是序列

序列的切片

这里切片的含义是从一个序列中取出一个子序列

语法：序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

起始下标表示从何处开始，可以留空，留空视作从头开始

结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

步长表示，依次取元素的间隔

步长1表示，一个个取元素

步长2表示，每次跳过1个元素取

步长N表示，每次跳过N-1个元素取

步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意：此操作不会影响序列本身，而是会得到一个新的序列

例如

list1 = [1,2,3,4,5]
list2 = list1[1:4] # 从下标1开始取到4结束，前闭后开

这个操作对列表、元组、字符串是通用的

同时非常灵活，根据需求，起始位置，结束位置，步长（正反序）都是可以自行控制的

set 集合

集合的概念类似于数学上集合的定义，具有不重复，无序的特点

那我们其实可以利用这个特点做去重的工作

定义

set1 = {e1,e2,...}
set2 = set()

在定义集合时哪怕e1和e2相同，他也会自动帮你去重

方法

因为集合是无序的，所以集合不支持下标索引访问

添加

语法：集合.add(元素)。将指定元素，添加到集合内

set1 = {'e1','e2'}
set1.add('e3')

移除

语法：集合.remove(元素)，将指定元素，从集合内移除

set1.remove('e2')

随机取出

语法：集合.pop()，功能，从集合中随机取出一个元素

elemment = set1.pop()

需要注意的是这个操作之后，集合本身也会被修改，元素被移除

清空

语法：集合.clear()，功能，清空集合

set1.clear()

差集

语法：集合1.difference(集合2)

set3 = set2.difference(set1)

结果是得到一个新集合，集合1和集合2不变

消除差集

语法：集合1.difference_update(集合2)

set1.difference_update(set2)

简单说就是在set1中消除set2中也有的元素

并集

语法：集合1.union(集合2)

set3 = set1.union(set2)

结果会得到新集合，集合1和集合2不变

其余的len()和遍历与其他容器相同

dict 字典

字典实际上就是类似于生活中的字典，是由键值对组成，键是指key，关键字的意思，值是值value

定义

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对

例如

dict1 = {key:val,key:val,...}
dict2 = dict()
dict3 = {}

1. key和value可以是任意类型的数据（key不可为字典）

2. key不可重复，重复会对原有数据覆盖

访问

字典同样是无序的，无法用下标访问，但是可以利用key来访问

例如

dict1 = {'Summer':17,'Morty':14,'Rick':60}
print(dict1['Morty']) # 结果是14

除此之外，字典是可以嵌套字典（列表等）的，放在value的地方，我们可以以此来理解之后的JSON数据，以后会讲到

方法

方法	说明
dict1[‘Jerry’] = 36	添加元素，字典被修改
dict1[‘Rick’] = 61	更新元素，字典被修改
dict1.pop(‘Jerry’)	删除元素
dict1.clear()	清空字典
dict1.keys()	获取全部的key
for key in dict1.keys()	遍历字典

字典不支持下标索引，所以同样不可以用while循环遍历

总结

	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	key : value key：除字典外任意类型 Value：任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景	以key检索value的数据记录场景