Python数据容器总结

在学习python数据容器之后，写了这一篇总结，来巩固我的所学，并且分享给大家。

简单来讲，数据容器即一种可以容纳多个数据的数据类型。数据容器分为列表(list)，元组(turple)，字符串(str)，集合(set)，字典(dict).

列表(list)

定义

# 定义空列表
lst = []
lst = list()

在列表中存储的数据类型可以是不同的数据类型，因此列表也支持嵌套.

索引

从左往右：0，1，2……

从右往左：-1，-2，-3……

列表的方法

如果将函数定义为类的成员，就称为方法.

• 查询

index方法是列表对象内置的方法，可以返回指定元素在列表中的下标.

mylist = [1,2,3,4,5]
print(mylist.index(4))

查询到的下标索引是正向索引.

• 修改

mylist[2] = 9
print(mylist)

取到索引用等号赋值即可.

• 插入

insert方法（2个参数）

用于在指定的下标位置插入指定的元素

# 在索引为2的位置插入元素10
mylist.insert(2,10)
print(mylist)

• 追加

1.append方法（1个参数）

用于将元素添加到列表的尾部

mylist.append(666)

2.extend方法

mylist = [1,2,3]
mylist.extend([4,5,6])
print(mylist)   [1,2,3,4,5,6]

与append类似，区别就是append是每次添加单个元素，而extend是每次添加多个元素

• 删除

1.del关键字

del mylist[3]
print(mylist)

2.pop方法

# 将索引为2的元素移除并赋值给element
element = mylist.pop(2)
print(element)
print(mylist)

3.remove(参数是被删掉的元素)方法

remove方法总是删除第一个与参数相同的元素

mylist.remove(666)
print(mylist)

4.clear清空列表

mylist.clear()
print(mylist)

循环

• while循环遍历

mylist = [1,2,3,4,5]
index = 0
while index < len(mylist):
    element = mylist[index]
    print(element)
    index += 1

• for循环遍历

for element in mylist:
    print(i)

对比：

• 在循环控制上：while循环可以自定循环条件，并自行控制；for循环不可以自定循环条件，只能一个个从容器中取出数据

• 在无限循环上：while循环可以通过条件做到无限循环，for循环理论上来说不能做到无限循环，因为容器容量不是无限的

• 在使用场景上：while循环适用于一切场景；for循环适用于遍历数据容器的场景或简单的固定次数循环场景

元组(turple)

列表可以被修改，但是元组一旦定义完成，就不能修改

元组可以理解成只读的列表

定义

(, , , , , ,)
t = ()
t = turple()

如果要定义只有一个元素的元组，要在元素后面加上,，例如：

t1 = ("hello",)

否则t1就不是元组了

方法

• index方法

t = (1,1,2,2,2,3,"liu")
index = t.index("liu")
print(index)

• count方法

统计元组中某个元素出现的次数

sum = t.count(2)
print(sum)

• len方法

计算元组的长度

num = len(t)
print(num)

遍历

• while循环

index = 0
while index < len(t):
    print(t[index])
    index += 1

• for循环

for elem in t:
    print(elem)

注意：如果对元组进行修改，程序会报错；但是如果元组内嵌套了list列表，那么可以修改列表中的内容，例如：

t0 = (1,2,[5,6,7])
t0[2][0] = 3
print(t0)

字符串(str)

一个字符串可以存放任意数量的字符，是不可修改的

支持下标访问（->从0开始，<-从-1开始）

方法

• index方法

找到特定字符的索引

str = "liurunze is the most handsome boy in the world"
value = str.index("handsome")
# 输出 21

• replace方法

用来实现字符串的替换

没有修改字符串本身，而是得到了一个新的字符串

mystr = "liurunze is the"
newstr = mystr.replace("the", "handsome")
print(newstr)

• split方法

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

字符串本身不变，而是会得到一个列表对象

str = "liu run ze i s hand some"
lst = str.split(" ")
print(lst)

• strip方法

不传参数：去除头和尾的空格以及换行符

str = "  liurunze  "
print(str)
newstr = str.strip()
print(newstr)

传参数：去除头和尾指定的字符

str = "12liurunze21"
print(str)
newstr = str.strip("12")
print(newstr)

这里并不是只能去除字符串"12"，而是将字符串"12"划分为2个子串，分别去除字符串"1"和字符串"2"

• count方法

str = "liuliuliururnurur"
print(count("ur"))

统计字符串出现的次数

• len方法

str = "liurunze"
print(len(str))

统计字符串的长度

遍历：

• while循环

• for循环

序列

序列是指内容连续、有序，可使用下标索引的一类数据容器

列表、元组、字符串，均可作为序列

切片操作

序列[起始下标:结束下表:步长]

• 起始下标表示从何处开始，如果为空表示从头开始

• 结束下表表示从何处结束（不包含），如果留空表示截取到尾

• 步长表示取元素的间隔（默认是1），步长为N表示每跳过N-1个元素取，步长如果为负数表示反向取

对序列进行切片操作不会影响序列本身，而会生成一个新的序列

lst = [1,2,3,4,5]
result = lst[1:4]
print(result)

从头到尾切片：

tpl = (1,2,3,4,5)
result2 = tpl[:]
print(result2)

改变步长：

str = "01234567"
result3 = str[::2]
print(result3)

改变步长为负数：

str = "012345"
result4 = str[::-1]
print(result4)

等同于将序列反转

lst = [1,3,5,7,9]
lst2 = lst[4:1:-1]
print(lst2)

元组切片

tpl = (0,1,2,3,4,5,6)
ret = tpl[::-2]
print(ret)

集合(set)

集合中的元素不能重复

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

但是集合是允许修改的

方法

• add方法

添加元素

set1 = {1,1,2,3,4,5,6,6,6,6}
set0 = set1.add(9)
print(set0)

• remove方法

删除元素

set0.remove(2)
print(set0)

• pop方法

随机取出一个元素

print(set0.pop())

• clear方法

清空集合

set0.clear()

• difference方法

取2个集合的差集

原有的集合不变，会产生一个新的集合

set1 = {1,2,3,4}
set2 = {3,4,5,6}
set3 = set1.difference(set2)
print(set3)     # {1,2}

• difference_update方法

在集合1内，删除和集合2相同的元素

集合1会被修改，集合2不变

set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(set1)     # {2,3}
print(set2)     # {1,5,6}

• union方法

合并集合

得到新集合，原来的两个集合不变

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set3)     # {1,2,3,5,6} (顺序不能确定)

还有len方法与集合的遍历就不再介绍

但是要注意while循环不能遍历set，只能用for循环遍历，因为set不支持下标访问

字典(dict)

存储的元素是键值对

定义

mydict = dict()     # 定义空字典
mydict2 = {}        # 定义空字典

字典不允许Key的重复，后者会覆盖前者的Value

字典也没有下标索引

dict1 = {"zhangjiahao":99,"liurunze":59,"zhuyunhe":98}
score = dict1["zhangjiahao"]
print(score)

Key和Value可以是任意数据类型（Key不可为字典）

定义嵌套字典：

studict = {"zhangjiahao":{"操作系统":99,"OOP":99,"高等数学":99}
          "liurunze":{"操作系统":59,"OOP":59,"高等数学":59}
          "zhuyunhe":{"操作系统":99,"OOP":99,"高等数学":99}}
# 记录zhuyunhe OOP的成绩
score = studict["zhuyunhe"]["OOP"]
print(score)

常用操作

• 新增元素

字典[Key] = Value

• 更新元素

同上，即如果Key不存在，则创建这个Key；如果已经存在，则更新其Value值

• 删除元素

pop(Key)

获得指定的Key的Value，字典中删除相应的键值对

• 清空元素

dict1.clear()

• 获取全部的Key

keys方法

keystotal = dict1.keys()
print(keystotal)

• 遍历字典

方式1：获取全部的key来完成遍历

for key in keystotal:
    print(key)
    print(dict1[key])

方式2：直接对字典for循环遍历

for key in dict1:
    print(key)
    print(dict1[key])

• 统计字典元素数量

len方法

数据容器总结

数据容器对比

• 是否支持下标索引

  支持：列表，元组，字符串——序列类型

  不支持：集合，字典——非序列类型

• 是否支持重复元素

  支持：列表，元组，字符串——序列类型

  不支持：集合，字典——非序列类型

• 是否可以修改

  支持：列表，集合，字典

  不支持：元组，字符串

数据容器的通用操作

• 都支持for循环遍历

• 都支持len统计元素个数

• max,min都可以分别找到最大元素和最小元素

容器之间可以相互转化，但是不能转换为字典

通用排序功能：

sorted(容器, [reverse = True])

默认reverse = False，是从小到大排序，如果reverse = True，则为降序排列

而且排序后的结果全部都会存入到列表对象当中

---------------------------------------------------------------------------------------------------------------------------------

全都是自己总结的，如果有错误，烦请指正，感谢！