Python之数据容器

0.1定义

数据容器：一种可以存储多个元素的Python数据类型

数据容器根据特点的不同，如： 是否支持重复元素 是否可以修改 是否有序，等

分为5类，分别是： 列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

0.2函数与方法简单区分

在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法 方法和函数功能一样， 有传入参数，有返回值，只是方法的使用格式不同：

函数的使用：

方法的使用：

一.列表（List）

1.定义：

也可以创建数值列表：

list(range( ......))

2.查：

（1）利用下标：

正向索引：

反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3......）

嵌套索引：

（2） 查找某元素的下标    

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

语法：列表.index(元素)        

3.列表各类方法：

编号	使用方式	作用
1	列表.append(元素)	向列表中追加一个元素
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
3	列表.insert(下标, 元素)	在指定下标处，插入指定的元素
4	del 列表[下标] del 列表	删除列表指定下标元素 删除整个列表（从空间上删除了）
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	删除一个不确定其位置的元素用remove 从前向后，删除此元素第一个匹配项
7	列表.clear()	清空列表数据
8	列表.count(元素)	统计此元素在列表中出现的次数
9	列表.index(元素)	查找指定元素在列表的下标 找不到报错ValueError
10	len(列表)	统计容器内有多少元素

11.                   列表.sort(key=None,reverse=False)

key：表示指定从每个元素中提取一个用于比较的键
reverse：可选参数，如果将其指定为True表示降序排序，如果为False表示升序排序，默认为升序

name = [2,6,7,9,4,0,98,23]
print("原列表：" ,name)
name.sort()
print("升序后的列表",name)
name.sort(reverse=True)
print("降序序后的列表",name)
"""
原列表： [2, 6, 7, 9, 4, 0, 98, 23]
升序后的列表 [0, 2, 4, 6, 7, 9, 23, 98]
降序序后的列表 [98, 23, 9, 7, 6, 4, 2, 0]
"""#对于字符串排序，默认是先排序大写在小写
char = ['cat','Tom','Angela','pet']
char.sort() #默认区分字母大小写
print("区分字母大小写：",char)
char.sort(key=str.lower) #不区分字母大小写
print("不区分字母大小写：",char)
"""区分字母大小写： ['Angela', 'Tom', 'cat', 'pet']
不区分字母大小写： ['Angela', 'cat', 'pet', 'Tom']
"""

12.内置的函数（不是方法）sorted

sorted列表,key=None,reverse=False)

grade = [98,99,97,100,88,76,94,95]
grade_as = sorted(grade)
print("升序：",grade_as)
grade_des = sorted(grade,reverse = True)
print("降序：",grade_des)
print("原序列：",grade)
"""升序： [76, 88, 94, 95, 97, 98, 99, 100]
降序： [100, 99, 98, 97, 95, 94, 88, 76]
原序列： [98, 99, 97, 100, 88, 76, 94, 95]
"""

4.列表推导式

（1）生成指定范围的数值列表

        list = [Expression for var in range]

语法说明：
        list：表示生成的列表名称
        Expression：表达式，用于计算新列表的元素
        var：循环变量
        range：采用range()函数生成的range对象

import random
randomnumber = [random.randint(10,100)for i in range(10)]
print("生成的随机数为：",randomnumber)
#生成的随机数为： [23, 77, 10, 79, 91, 97, 85, 46, 50, 17]

（2）根据列表生成指定需求的列表

        newlist = [Expression for var in list]

语法说明：

        newlist：表示新生成的列表名称
        Expression：表达式，用于计算新列表的元素
        var：变量，值为后面列表的每个元素值

        list：用于生成新列表的原列表

#例如，定义一个记录商品价格的列表，用列表推导式生成一个将全部价格打五折的列表。
price = [1200,5330,2988,6200,1998,8888]
sale = [int(x*0.5)for x in price]
print("原价格：",price)
print("五折后的价格：",sale)
# 原价格： [1200, 5330, 2988, 6200, 1998, 8888]
# 五折后的价格： [600, 2665, 1494, 3100, 999, 4444]

（3）从列表中选择符合条件的元素组成新的列表

        newlist = [Expression for var in list if condition]
语法说明：
        newlist：表示新生成的列表名称
        Expression：表达式，用于计算新列表的元素
        var：变量，值为后面列表的每个元素值
        list：用于生成新列表的原列表
        condition：条件表达式，用于指定筛选条件

#例如定义一个记录商品价格的列表用列表推导式生成一个商品价格高于5000元的列表，代码如下：price = [1200,5330,2988,6200,1998,8888]
sale = [x for x in price if x > 5000]
print("原列表：",price)
print("价格高于5000的：",sale)
# 原列表： [1200, 5330, 2988, 6200, 1998, 8888]
# 价格高于5000的： [5330, 6200, 8888]

5.列表的循环

（1）直接取出数据

print("2017~2018赛季NBA西部联盟前八名：")
team = ["休斯顿 火箭","金州 勇士","波特兰 开拓者","犹他 爵士","新奥尔良 鹈鹕","圣安东尼奥 马刺","俄克拉荷马城 雷霆","明尼苏达 森林狼"]
for item in team:print(item,end=" ")
#休斯顿 火箭 金州 勇士 波特兰 开拓者 犹他 爵士 
#新奥尔良 鹈鹕 圣安东尼奥 马刺 俄克拉荷马城 雷霆 明尼苏达 森林狼

（2）使用for循环和enumerate()函数实现
使用for循环和enumerate()函数可以实现输出索引值和元素内容，语法格式如下：

        for index,item in enumerate(listname) :
语法说明：
        index：用于保存元素的索引
        item：用于保存获取到的元素值，要输出元素内容时直接输出该变量即可
        listname：为列表名称

print("2017~2018赛季NBA西部联盟前八名：")
team = ["休斯顿 火箭","金州 勇士","波特兰 开拓者","犹他 爵士","新奥尔良 鹈鹕","圣安东尼奥 马刺","俄克拉荷马城 雷霆","明尼苏达 森林狼"]
for index,item in enumerate(team):print(index + 1,item)
#     2017~2018赛季NBA西部联盟前八名：
# 1 休斯顿 火箭
# 2 金州 勇士
# 3 波特兰 开拓者
# 4 犹他 爵士
# 5 新奥尔良 鹈鹕
# 6 圣安东尼奥 马刺
# 7 俄克拉荷马城 雷霆
# 8 明尼苏达 森林狼

6.二维列表创建及应用

（1）创建：

直接定义：

利用for循环：

arr = []
for i in range(4):arr.append([j for j in range(5)])
print(arr)
#[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

（2）应用:

str1 = "千山鸟飞绝"
str2 = "万径人踪灭"
str3 = "孤舟蓑笠翁"
str4 = "独钓寒江雪"
verse = [list(str1),list(str2),list(str3),list(str4)]
print("\n--横版--\n")
for i in range(4):for j in range(5):if j == 4:print(verse[i][j])else:print(verse[i][j],end="")
verse.reverse()
print("\n--竖版--\n")
for i in range(5):for j in range(4):if j == 3:print(verse[j][i])else:print(verse[j][i],end="")
# --横版--# 千山鸟飞绝
# 万径人踪灭
# 孤舟蓑笠翁
# 独钓寒江雪# --竖版--# 独孤万千
# 钓舟径山
# 寒蓑人鸟
# 江笠踪飞
# 雪翁灭绝

7..总结：

可以容纳多个元素（上限为2**63-1、9223372036854775807个）

可以容纳不同类型的元素（混装）

数据是有序存储的（有下标序号）

允许重复数据存在

可以修改（增加或删除元素等）

二.元组

一旦定义完成，就不可修改 所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了

1.创建

注意事项：

2.方法

编号	方法	作用
1	index()	查找某个数据，如果数据存在返回对应的下标，否则报错
2	count()	统计某个数据在当前元组出现的次数
3	len(元组)	统计元组内的元素个数

3.删除整个数组

        del 元组

4.修改

        不可修个单个，但可以重新对整个元组赋值

coffeename = ("蓝山","卡布奇诺","曼特宁","摩卡","麝香猫","哥伦比亚")
coffeename = ("蓝山","卡布奇诺","曼特宁","摩卡","拿铁","哥伦比亚")
print("新元组",coffeename)
#新元组 ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '拿铁', '哥伦比亚')

5.拼接

元组可以连接组合，例如，实现在已经存在的元组结尾处添加一个新元组。

ukguzheng = ("蓝山","卡布奇诺","曼特宁","摩卡")
print("原元组：",ukguzheng)
ukguzheng = ukguzheng +("麝香猫","哥伦比亚")
print("组合后：",ukguzheng)
# 原元组： ('蓝山', '卡布奇诺', '曼特宁', '摩卡')
# 组合后： ('蓝山', '卡布奇诺', '曼特宁', '摩卡', '麝香猫', '哥伦比亚')

PS：在进行元组连接时，连接的内容必须都是元组

6.元组推导式：同列表，把【】换成（）

7.总结：

可以容纳多个数据

可以容纳不同类型的数据（混装）

数据是有序存储的（下标索引）

允许重复数据存在

不可以修改（增加或删除元素等）

支持for循环

三.字符串

1.性质：同元组一样，字符串是一个：无法修改的数据容器。

所以：

        修改指定下标的字符    （如：字符串[0] = “a”）

        移除特定下标的字符    （如：del 字符串[0]、字符串.remove()、字符串.pop()等）

        追加字符等        （如：字符串.append()） 均无法完成。

如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改

2.常用方法

编号	操作	说明
1	字符串[下标]	根据下标索引取出特定位置字符
2	字符串.index(字符串）	查找给定字符的第一个匹配项的下标
3	字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
4	字符串.split(字符串)	按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表
5	字符串.strip() 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
6	字符串.count(字符串)	统计字符串内某字符串的出现次数
7	len(字符串)	统计字符串的字符个数

四.集合（set）

1.性质：不支持元素的重复（自带去重功能）、并且内容无序，所以不支持查询

2.创建：

3.常用方法

编号	操作	说明
1	集合.add(元素)	集合内添加一个元素
2	集合.remove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素，同时集合本身被修改，元素被移除
4	集合.clear()	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集 原有的2个集合内容不变
6	集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变
8	len(集合)	得到一个整数，记录了集合的元素数量

关于并集和差集：

set1 = {1,2,3}
set2 = {1,5,6}
set3  = set1.difference(set2)print("set1和set2的差集是:",set3)
set1.difference_update(set2)
print("更改set1为set1和set2的差集：",set1)set4  = set1.union(set2)
print("set1和set2的并集是:",set4)
"""set1和set2的差集是: {2, 3}
更改set1为set1和set2的差集： {2, 3}
set1和set2的并集是: {1, 2, 3, 5, 6}
"""

4.总结：

五.字典（dic）

1.创建：

（2）字典的套用

这种思维很重要！！！

2.查

字典同集合一样，不可以使用下标索引

3.常用方法

编号	操作	说明
1	字典[Key]	获取指定Key对应的Value值
2	字典[Key] = Value	没有key就是添加或更新键值对
3	字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
4	字典.clear()	清空字典
5	字典.keys()	获取字典的全部Key，可用于for循环遍历字典
6	len(字典)	计算字典内的元素数量

4.总结：

可以容纳多个数据

可以容纳不同类型的数据

每一份数据是KeyValue键值对

可以通过Key获取到Value，

Key不可重复（重复会覆盖）

不支持下标索引

可以修改（增加或删除更新元素等）

支持for循环，

不支持while循环

六.序列的切片

1.定义序列：

        内容连续、有序，可使用下标索引的一类数据容器 列表、元组、字符串，均可以可以视为序列。

2.切片操作：

切片：从一个序列中，取出一个子序列

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

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

步长是负数：

str = "万过薪月，员序程马黑来，nohtyP学"
new_str = str[9:4:-1]
print(new_str)#黑马程序员

七总结：

八.容器通用功能总览