Python基础：数据容器

一、数据容器入门

1.1 定义：

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

1.2 类别

数据容器包含五种类型，分别为：列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)。

二、数据容器：list(列表)

2.1 基本定义

类似于c语言中的数组，但不同的是，列表中存储的元素类型可以不同，并且支持嵌套。

特点：

1. 可以容纳不同类型的多个元素。

2. 数据是有序存储的（有下标）。

3. 允许重复数据存在。

4. 可以修改。

举例：

my_list = [ 'hello', 666, True, [ 1, 2, 3 ] ]
print(my_list)
print(type(my_list))

运行结果：

[ 'hello', 666, True, [1, 2, 3] ]
<class 'list'>

2.2 取出、修改元素

列表[下标索引]，从前往后：从0开始每次+1；从后往前：从-1开始，每次-1。

即下例中，my_list[0] 和 my_list[-4]取的是同一个元素。

举例：

my_list = [ 'hello', 666, True,[1,3,5]]
print(my_list)
print(type(my_list))
print(my_list[0])
my_list[1] = 999 # 将第二个元素666改为999
print(my_list[1])
my_list[3][0] = 2 # 将第4个元素列表中的第1个元素改为2
print(my_list)

运行结果：

['hello', 666, True, [1, 3, 5]]
<class 'list'>
hello
999
['hello', 999, True, [2, 3, 5]]

2.3 列表的查询功能（方法）

2.3.1 查询某元素的下标（index）

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

语法：列表.index(元素)

举例：

my_list = [ 'hello', 666, True,[1,3,5]]
index = my_list.index("hello") # 查找指定元素在列表的下标
print(f"hello在列表中的索引值为{index}")

运行结果：hello在列表中的索引值为0

2.3.2 列表的元素插入（insert）

功能：在已有列表中插入元素。

语法：列表.insert(下标，元素)

举例：

my_list = [ 'hello', 666, True,[1,3,5]]
my_list.insert(1,"best") # 插入元素
print(my_list)

运行结果：['hello', 'best', 666, True, [1, 3, 5]]

2.3.3 追加元素（append）

功能：将指定元素追加到列表的尾部

方法1：追加单个元素（append）

语法：列表.append(元素)

举例：

my_list = [ 'hello', 666, True,[1,3,5]]
my_list.append(777) # 将指定元素追加到列表的尾部
print(my_list)

运行结果：['hello',666, True, [1, 3, 5], 777]

方法2：追加多个元素（extend）

语法：列表.extend(其它数据容器)

举例：

my_list = [ 'hello', 666, True,[1,3,5]]
you_list = [ "hi", 123, [1,2,3]]
my_list.extend(you_list) # 也可以my_list.extend(["hi", 123, [1,2,3]])
print(my_list)

运行结果：['hello', 666, True, [1, 3, 5], 'hi', 123, [1, 2, 3]]

2.3.4 根据下标删除元素（pop）

有两种方式

方式1：del（关键字）

语法：del 列表[下标]

举例：

my_list = [ 'hello', 666, True,[1,3,5]]
del my_list[1]
print(my_list)

运行结果：['hello', True, [1, 3, 5]]

方式2：pop

功能：不仅可以删除该元素，还可以将删除的元素作为返回值得到。

语法：列表.pop(下标)

举例：

my_list = [ 'hello', 666, True,[1,3,5]]
my_list.pop(1)
print(my_list)

运行结果：['hello', True, [1, 3, 5]]

2.3.5 根据元素删除对应项（remove）

语法：列表.remove(元素)

举例：

my_list = [ 'hello', 666, True,[1,3,5]]
my_list.remove(666)
print(my_list)

运行结果：['hello', True, [1, 3, 5]]

2.3.6 清空列表（clear）

语法：列表.clear()

举例：

my_list = [ 'hello', 666, True,[1,3,5]]
my_list.clear()
print(my_list)

运行结果：[ ]

2.3.7 统计某元素在列表内的数量（count）

语法：列表.count(元素)

举例：

my_list = [ 'hello', 666, 666,666,True,[1,3,5]]
count = my_list.count(666)
print(f"666在列表中出现了{count}次")

运行结果：666在列表中出现了3次

2.3.8 统计列表中一共有多少个元素

语法：len(列表)

举例：

my_list = [ 'hello', 666, 666,666,True,[1,3,5]]
length = len(my_list)
print(f"列表中一共有{length}个元素")

运行结果：列表中一共有6个元素

总结：

编号	使用方式	作用
1	列表.index(元素)	查找指定元素在列表的下标并返回
2	列表.insert(元素)	在已有列表中插入元素
3	列表.append(元素)	将指定单个元素追加到列表的尾部
4	列表.extend(数据容器)	将指定多个元素追加到列表的尾部
5	列表.pop(下标)；del 列表(下标)	根据下标删除元素
6	列表.remove(元素)	根据元素删除对应项
7	列表.clear()	清空列表
8	列表.count(元素)	统计某元素在列表内的数量
9	len(列表)	统计列表中一共有多少个元素

三、数据容器：tuple(元组)

3.1 基本定义

       元组同列表一样，也可以封装多个、不同类型的元素在内，但不同点在于，元组一旦定义完成，就不可以修改。

定义元组：变量名称 = ( )，与列表定义类似，只是将[ ]改为( )。

注意：若元组有且只有一个数据，在这个数据后面需要加个逗号。如果没有这个逗号，就不是元组类型了

eg：t1 = ( 'hello' , )

3.2 元组的查询功能

除了对元组进行修改/添加的语句不能使用，其余语句使用与列表用法一样。

有index( )，count( )，len( )可以使用。

注意：

1. 对元素进行操作时，用[ ]表示。eg. t1 = ( 1, 2, 3 )  print( t1[0] )   结果为：1

2. 不可以修改元组的内容，但是在元组内嵌套一个列表，则可以修改该列表里的内容；同时，在列表里嵌套的元组是不能被修改的。

四、数据容器：str(字符串)

字符串也可以当作是数据容器，包含了一些单个字符，字符串与元组一样，是不可以修改的，但是可以整体替换。

举例：空格也占一个字符

name = " learnpython"
print(name[0]) # 结果为 空格
print(name[1]) # 结果为l

4.1 字符串的常见操作

4.1.1 字符串的索引（index）

str1 = "learn python"
print(str1.index("python")) # 结果为6 - python这个字符串的首字符索引下标

4.1.2 字符串的替换（replace）

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

功能：将字符串中的所有字符串1，改为字符串2后返回得到的新字符串。

注意：这是替换之后得到了一个新的字符串，原字符串本身是不会被修改的。

举例：

str1 = "learn python"
new_str1 = str1.replace("n","m")
print(f"str1为{str1}，new_str1为{new_str1}")

运行结果：str1为learn python，new_str1为learm pythom

4.1.3 字符串的分割（split）

语法：字符串.split(指定分割符)

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

举例：

str1 = "learn python happy"
str1_list = str1.split(" ")
print(str1_list)

运行结果：['learn', 'python', 'happy']

4.1.4 字符串的规整操作（strip）

语法：

1. 字符串. strip()

去除字符串前后空格和回车（\n）

str2 = " my name is ricy "
print(str2.strip())

运行结果：my name is ricy

2. 字符串.strip(字符串)

去除字符串前后指定的字符串，不论顺序。

str2 = "12my name is ricy21"
print(str2.strip("12"))

运行结果：my name is ricy

注意：

1. 只能去除最前和最尾的相应字符，如果指定的字符串不在最两边，则无效。

2. 不会更改原字符串，而是得到一个新的字符串。

4.1.5 统计字符串中某字符串出现的次数（count）和字符串长度（len）

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

注意：某字符串是要讲究顺序的，例如str.count("it")与str.count("ti")结果不同。

2. 语法：len（字符串）

注意：这个长度的统计包含空格，汉字、英文字符和数字都占1个长度。

4.2 总结

五、数据容器（序列）的切片

5.1 序列的定义

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

上述所学的列表、元组、字符串，均可视为序列。

5.2 序列的常见操作

5.2.1 切片

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

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

功能：表示从序列中，从指定位置开始，依次取出元素，到指定位置结束（不包含结束下标），得到一个新序列，其中，步长表示相邻两数之间的差值。

注意：

1. 步长为负数时表示反向取，同时起始下标和结束下标也要反向标记。（该操作可以用来做倒序）

2. 切片的结果得到的是一个新的序列，不会改变原来的序列。

3. 步长不写的时候默认是1。

4. 当从起始到结束时可以省略不写，只用写一个：即可。

5. 切片操作完成之后，得到的新序列所属数据容器的类型不变。

举例1：共45个字符（包含逗号和空格）

str3 = "1234万 过 薪 月 ， 员 序 程 马 黑 来 ， n o h t y p 学1234"
new_str3 = str3[-5:-42:-2]
print(new_str3)

运行结果：学python，来黑马程序员，月薪过万

六、数据容器：set（集合）

6.1 定义

集合相较于前面所学的数据容器，其特点是：不支持元素重复（自带去重功能）、并且内容无序。集合不是序列。

定义集合：变量名称 = {元素1，元素2，.... }，与列表定义类似，只是将[ ]改为{ }。

注意：定义空集合不能直接set1 = { }，这个是留着定义空字典的，只能set1 = set( )来定义空集合。

6.2 集合的常见操作

6.2.1 集合的修改（add、remove、pop、clear、difference、difference_update）

因为集合是无序的，所以集合不支持：下标索引访问，但可以修改。

1.添加元素

语法：集合.add(元素)、

注意：如果添加的元素在原集合中已经存在，则会去重，添加失败。

2. 移除元素

语法：集合.remove(元素)

3. 取出元素（由于无序，所以是随机取出的）

语法：集合.pop（）

举例：

set1 = {"今天","天气","是晴天","真不错"}
#随机取出一个元素
element = set1.pop()
print(f"取出的元素是{element}，set1中还剩{set1}")

运行结果：取出的元素是今天，set1中还剩{'真不错', '是晴天', '天气'}

4. 清空集合（clear）,参考列表操作。

5. 取出两个集合的差集

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

功能：取出集合1和集合2的差集（即集合1-集合2）并返回，并且不改变集合1与集合2。

举例：

set1 = {"今天","天气","是晴天","真不错"}
set2 = {"今天","天气","是晴天"}
set_dif = set1.difference(set2)
print(f"集合1与集合2的差集为{set_dif}，集合1为{set1}，集合2为{set2}")

运行结果：集合1与集合2的差集为{'真不错'}，集合1为{'真不错', '是晴天', '今天', '天气'}，集合2为{'是晴天', '今天', '天气'}

6. 消除交集部分

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

功能：对比集合1与集合2，在集合1内，删除和集合2相同的元素。集合1会改变，集合2不会改变。

7. 两个集合合并

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

功能：将集合1和集合2组成新集合，得到的是新集合，集合1和集合2不改变。

8. 统计集合元素数量len( )

6.3 总结

七、数据容器：dict（字典）

7.1 定义

字典：通过key（关键字）找到对应的value（值）。

语法：同样使用{ }，但与集合不同的是，其中所存储的元素是一个个的：键值对

eg.my_dict = {key：value，key：value，...}

用法举例：

dict1 = {"小王":99,"小陈":88,"小李":90,"小赵":80}
score = dict1["小王"]
print(f"小王的分数为{score}")

运行结果：小王的分数为99

字典实际上是重新定义了元素的下标

7.2 字典的嵌套

举例：

stu_score = {
    "小王":{"语文":90,"数学":91,"英语":80},
    "小陈":{"语文":81,"数学":90,"英语":79},
    "小李":{"语文":90,"数学":88,"英语":81}
}
score = stu_score["小王"]["语文"]
print(f"小王的语文成绩为{score}")

运行结果：小王的语文成绩为90

注意：

1. key和value可以是任意类型的，key不可以是字典类型。

2. key必须唯一，重复添加相当于覆盖原有数据。

3. 字典不用下标索引，而是用key去找到value。

7.3 字典的常用操作

7.3.1 新增/更新元素

语法：字典[key] = value，结果：字典被修改，新增了元素。

注意：由于字典中key不能重复，所以如果对已存在的key执行操作，则会更新该字典中该key对应的value。

举例：

stu_score = {
    "小王":{"语文":90,"数学":91,"英语":80},
    "小陈":{"语文":81,"数学":90,"英语":79},
    "小李":{"语文":90,"数学":88,"英语":81}
}
stu_score["小赵"] = {"语文":87,"数学":86,"英语":92}
print(stu_score)

运行结果：{'小王': {'语文': 90, '数学': 91, '英语': 80}, '小陈': {'语文': 81, '数学': 90, '英语': 79}, '小李': {'语文': 90, '数学': 88, '英语': 81}, '小赵': {'语文': 87, '数学': 86, '英语': 92}}

7.3.2 取出元素（pop）

语法：字典.pop(key)

功能：获得指定key的value值，同时字典中该key的数据被移除。

7.3.3 清空字典（clear）

语法：字典.clear()

7.3.4 获取全部的key（keys）

语法：字典.keys()，结果：得到字典中全部的key

举例：

dict1 = {"小王":99,"小陈":88,"小李":90,"小赵":80}
keys = dict1.keys()
print(keys)

运行结果：dict_keys(['小王', '小陈', '小李', '小赵'])

7.3.5 遍历字典

举例1：keys与for循环配合

stu_score = {
    "小王":{"语文":90,"数学":91,"英语":80},
    "小陈":{"语文":81,"数学":90,"英语":79},
    "小李":{"语文":90,"数学":88,"英语":81}
}
keys1 = stu_score.keys()
keys2 = stu_score["小王"].keys()
#字典的遍历
for i in keys1:
    for j in keys2:
        print(f"{i}的{j}成绩为{stu_score[i][j]}")

运行结果：

小王的语文成绩为90
小王的数学成绩为91
小王的英语成绩为80
小陈的语文成绩为81
小陈的数学成绩为90
小陈的英语成绩为79
小李的语文成绩为90
小李的数学成绩为88
小李的英语成绩为81

举例2：直接对字典进行for循环，每次循环都是直接得到其对应的key

stu_score = {
    "小王":{"语文":90,"数学":91,"英语":80},
    "小陈":{"语文":81,"数学":90,"英语":79},
    "小李":{"语文":90,"数学":88,"英语":81}
}
#字典的遍历
for i in stu_score:# i取到的为stu_score的key值，即"小王"，"小陈"，"小李"
    for j in stu_score[i]:# j取到的为stu_score[i]的key值，即"语文"，"数学"，"英语"
        print(f"{i}的{j}成绩为{stu_score[i][j]}")

运行结果：

小王的语文成绩为90
小王的数学成绩为91
小王的英语成绩为80
小陈的语文成绩为81
小陈的数学成绩为90
小陈的英语成绩为79
小李的语文成绩为90
小李的数学成绩为88
小李的英语成绩为81

7.4 总结

八、容器的通用操作

8.1 容器之间类型可以相互转换。

语法：list(str1)、list(dict1)、tuple(list)等

注意：

1. 字符串转列表/元组/集合，是将字符串中每一个字符都作为列表中的一个元素。

2. 字典转列表/元组/集合，得到的是key作为列表中的元素；转字符串，可以得到完整的字典。

3. 转换为集合的话，内容会保留，但顺序会变为无序。

4. 不能转换为字典，因为字典的元素需要键值对。

8.2 容器通用排序功能

1. 语法：sorted(容器)

功能：将给定容器进行从小到大排序。

2. 语法：sorted(容器，[reverse = True])

功能：将给定容器进行从大到小排序。

sorted函数有个reverse参数，默认为False，不给的时候是正序，改为True则为倒序。

举例：

list1 = [2,4,9,7,1]
tuple1 = ("a","g","c","e","h")
set1 = {6,2,5,4,7}
dict2 = {"key1":0,"key2":9,"key4":4,"key3":6}
print(sorted(list1))
print(sorted(tuple1))
print(sorted(set1))
print(sorted(dict2))

运行结果：

[1, 2, 4, 7, 9]
['a', 'c', 'e', 'g', 'h']
[2, 4, 5, 6, 7]
['key1', 'key2', 'key3', 'key4']

注意：

1. 对于字典类型，排序是对其key排序。

2. 数字类型和字符类型不能放在一起比较大小来排序，但可以各自比大小。

8.3 总结