Python第八章数据容器

第八章数据容器

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

数据容器根据特点的不同，如：

是否支持重复元素
是否可以修改
是否有序，等

分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

8.1 序列list、tuple、str

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

列表、元组、字符串，均可以可以视为序列。

8.1.1 列表list

(1) list的定义

语法如下

# 字面量
[元素1, 元素2, 元素3, 元素4, 元素5...]

# 变量
my_list = [元素1, 元素2, 元素3, 元素4, 元素5...]

# 空列表
empty_list1 = []
empty_list2 = list()

下面是演示

1、字面量

# 字面量
[1, "hello", 1.23, [1, 3, "world"]]

【注意】列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套（元素可以为数据容器）

2、定义list变量

# 定义变量
my_list = [1, "hello", 1.23, [1, 3, "world"]]
print(f"my_list为{my_list}")  # my_list为[1, 'hello', 1.23, [1, 3, 'world']]
print(type(my_list))  # <class 'list'>

3、定义空列表

# 定义空列表
empty_list1 = []
print(f"empty_list1为{empty_list1}")  # empty_list1为[]
print(type(empty_list1))  # <class 'list'>
empty_list2 = list()
print(f"empty_list2为{empty_list2}")  # empty_list2为[]
print(type(empty_list2))  # <class 'list'>

(2) list的下标

1、正常使用，正向索引

name_list = ["jack", "mary", "bob"]
print(name_list[1])  # mary

my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][1])  # 5

2、反向索引

如果索引是负数的话，表示反向，-1表示最后一个数据，-2表示倒数第二个数据，以此类推

name_list = ["jack", 'mary', 'bob']
print(name_list[-1])  # bob
print(name_list[-2])  # mary
print(name_list[-3])  # jack

3、下标越界

name_list = ["jack", 'mary', 'bob']
print(name_list[4]) # IndexError: list index out of range

(3) list的常用方法

类型	编号	使用方式	作用
增	1	列表.append(元素)	向列表中追加一个元素
	2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
	3	列表.insert(下标, 元素)	在指定下标处，插入指定的元素
删	4	del 列表[下标]	删除列表指定下标元素
	5	列表.pop(下标)	删除列表指定下标元素
	6	列表.remove(元素)	从前向后，删除此元素第一个匹配项
	7	列表.clear()	清空列表
改	-	列表[下标] = 新元素	直接使用下标修改元素
查	8	列表.count(元素)	统计此元素在列表中出现的次数
	9	列表.index(元素)	查找指定元素在列表的下标找不到报错ValueError
	10	len(列表)	统计容器内有多少元素
排序	11	列表.sort(key = , reverse = )	对列表进行排序(只有列表有这个功能)，指定排序规则，是否倒序，当然可以使用通用的sorted(list)
	12	列表.reverse()	倒序
运算	13	列表1 + 列表2	列表可以相加，得到新的列表

【经验】学习编程，不仅仅是Python语言本身，以后根据方向，会学习更多的框架技术。除了经常用的，大多数是记忆不下来的。
我们要做的是，有一个模糊印象，知晓有这样的用法即可。需要的时候，随时查阅资料即可。

下面逐一演示

【增操作】

1、列表.insert(下标, 元素)插入

语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素
如果insert的下标越界了，那么插在最后面

my_list = [1, 2, 3]
my_list.insert(1, "hello")
print(my_list) # [1, 'hello', 2, 3]

# 下标越界，插在最后面
my_list = [1, 2, 3]
my_list.insert(5, "str")
print(my_list)  # [1, 2, 3, 'str']

2、列表.append(下标, 元素)追加

语法：列表.append(元素)，将指定元素，追加到列表的尾部
如果append的是一个容器，那么容器看做一个元素

my_list = [1, 2, 3]
my_list.append("hello")
print(my_list)  # [1, 2, 3, 'hello']

# append列表时，列表看做一个元素
my_list = [1, 2, 3]
my_list.append(["jack", "mary"])
print(my_list)  # [1, 2, 3, ['jack', 'mary']]

3、列表.extend(数据容器)扩展

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

my_list = [1, 2, 3]
my_list.extend(["jack", "mary"])
print(my_list)  # [1, 2, 3, 'jack', 'mary']

参数是字符串，那么将字符串看做一个容器

my_list = [1, 2, 3]
my_list.extend("str")
print(my_list)  # [1, 2, 3, 's', 't', 'r']

参数只能是容器，是单个元素会报错

my_list = [1, 2, 3]
my_list.extend(4)
print(my_list)  # TypeError: 'int' object is not iterable

【删操作】

4、del 列表[下标]删除

语法del 列表[下标]，删除后没有返回值

my_list = [1, 2, 3]
del my_list[1]
print(my_list)  # [1, 3]

5、列表.pop(下标)

列表.pop(下标)，返回删除后的值

my_list = [1, 2, 3]
element = my_list.pop(1)
print(my_list)  # [1, 3]
print(element)  # 2

6、列表.remove(元素)

删除某元素在列表中的第一个匹配项

my_list = [1, "hello", 3, 2, 3, "hello"]
my_list.remove("hello")
print(my_list)  # [1, 3, 2, 3, 'hello']

7、列表.clear()

情况列表

my_list = [1, 2, 3]
print(my_list)  # [1, 2, 3]
my_list.clear()
print(my_list)  # []

【改操作】

列表[下标] = new value

直接用下标修改

【查操作】

8、列表.index(元素) 查找下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index(元素)

my_list = ["jack", 2, "mary", 1, "bob"]
print(my_list.index(1))  # 3

# print(my_list.index("lucy"))  # ValueError: 'lucy' is not in list

9、列表.count(元素)

统计元素在列表中的个数

my_list = [1, "hello", 2, "hello", 3]
print(my_list.count("hello"))  # 2

10、len(列表)

查看列表的长度

my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # 5

【排序操作】

11、sort排序

# 元组列表怎么排序
my_list = [
    ("mary", 18),
    ("bob", 20),
    ("lucy", 31),
    ("lisa", 22)
]

my_list.sort(key=lambda elem: elem[1])
print(my_list) # [('mary', 18), ('bob', 20), ('lisa', 22), ('lucy', 31)]

【说明】元组不能直接排序，可以使用sort进行排序

# 元组列表怎么排序
my_list = [
    ("mary", 18),
    ("bob", 20),
    ("lucy", 31),
    ("lisa", 22)
]

# reverse可以设置反向排序
my_list.sort(key=lambda elem: elem[1], reverse=True)
print(my_list)  # [('lucy', 31), ('lisa', 22), ('bob', 20), ('mary', 18)]

12、reverse()方法

list = [1, 2, 3]
list.reverse()
print(list)  # [3, 2, 1]

(4) list特点

可以容纳多个元素（上限为2⁶³-1、9223372036854775807个）
可以容纳不同类型的元素（混装）
数据是有序存储的（有下标序号）
允许重复数据存在
可以修改（增加或删除元素等）

(5) list的遍历

无非是两种方式

while遍历
for遍历（常用）

下面逐一演示

1、while遍历list

语法

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

实例

def while_list(my_list):
    index = 0
    while index < len(my_list):
        print(str(my_list[index]) + " ", end='')
        index += 1

2、for遍历list

语法

for elem in list:
	对elem进行处理

实例

def for_list(my_list):
    for elem in my_list:
        print(str(elem) + " ", end='')

8.1.2 元组tuple

元组同列表一样，都是可以封装多个、不同类型的元素在内。

但最大的不同点在于：元组一旦定义完成，就不可修改

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

(1) 元组的定义

# 定义元组字面量
(元素, 元素, 元素, 元素, 元素...)

# 元组变量
tuple_var = (元素, 元素, 元素, 元素, 元素...)

# 定义空元组
empty_tuple = ()
empty_tuple = tuple()

下面逐一演示

1、元组字面量

# 定义元组字面量
(1, 2, "hello", 4, 5)

2、元组变量

# 元组变量
tuple_var = (1, 2, "hello", 4, 5)
print(tuple_var)  # (1, 2, 'hello', 4, 5)
print(type(tuple_var))  # <class 'tuple'>

【注意】如果定义只有一个元素的元组的时候，后面需要加上,

tuple_var = ("val")
print(tuple_var, type(tuple_var))  # val <class 'str'>

tuple_var = ("val",)
print(tuple_var, type(tuple_var))  # ('val',) <class 'tuple'>

定义嵌套元组

tuple_var = ((1, 2, 3), "hello", [1, 2, 3])
print(tuple_var) # ((1, 2, 3), 'hello', [1, 2, 3])

3、空元祖

# 定义空元组
empty_tuple1 = ()
print(empty_tuple1)  # ()
print(type(empty_tuple1))  # <class 'tuple'>
empty_tuple2 = tuple()
print(empty_tuple2)  # ()
print(type(empty_tuple2))  # <class 'tuple'>

(2) 元组的下标

正向下标

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[3])  # 4

my_tuple = ((1, 2, 3), 2, (4, 5, 6))
print(my_tuple[0][1])  # 2

反向下标：-1表示最后一个元素

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[-4])  # 2
my_tuple = ((1, 2, 3), 2, (4, 5, 6))
print(my_tuple[-1][-2])  # 5

(3) 元组的常用方法

元组由于不可修改的特性，所以其操作方法非常少。只有查（但是元组可以修改内部序列的元素）

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

【查操作】

1、元组.index(元素)

查找第一个相等的元素的下标，如果没有则报错

my_tuple = (1, 2, 3, "hello", 4, "hello")
print(my_tuple.index("hello"))  # 3

如果差找不到报错

my_tuple = (1, 2, 3, "hello", 4, "hello")
print(my_tuple.index("world"))  # ValueError: tuple.index(x): x not in tuple

2、元组.count(元素)

查找某个元素的数量

my_tuple = (1, 2, 3, "hello", 4, "hello")
print(my_tuple.count("hello"))  # 2

3、len(元组)

元组的长度

my_tuple = (1, 2, 3, "hello", 4, "hello")
print(len(my_tuple))  # 6

【改操作】

1、可以修改元组内的list的内容（修改元素、增加、删除、反转等）

my_tuple = (1, 2, ["hello", "world"])
my_tuple[2][0] = "jack"
print(my_tuple) # (1, 2, ['jack', 'world'])

2、不可以替换list为其它list或其它类型

my_tuple = (1, 2, ["hello", "world"])
my_tuple[2] = ["jack", "world"]
print(my_tuple) # TypeError: 'tuple' object does not support item assignment

(4) 元组的遍历

两个方法：

while方法
for方法

1、while方法

my_tuple = (1, 2, 3, 4, 5)
index = 0
while index < len(my_tuple):
    print(f"{my_tuple[index]} ", end='') # 1 2 3 4 5 
    index += 1

2、for方法

my_tuple = (1, 2, 3, 4, 5)
for num in my_tuple:
    print(f"{num} ", end='') # 1 2 3 4 5

(5) 元组特点

经过上述对元组的学习，可以总结出列表有如下特点：

可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是有序存储的（下标索引）
允许重复数据存在
不可以修改（增加或删除元素等）
支持for循环

8.1.3 字符串str

【说明】本节是以序列的视角来看字符串的

字符串是字符的容器，一个字符串可以存放任意数量的字符。

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

所以：

修改指定下标的字符（如：字符串[0] = “a”）
移除特定下标的字符（如：del 字符串[0]、字符串.remove()、字符串.pop()等）
追加字符等（如：字符串.append()）

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

(1) 字符串的下标

正向下标

str = "hello, world"
print(str[0], str[3]) # h l

for i in range(len(str)):
    print(f"{str[i]} ", end='') # h e l l o ,   w o r l d

反向下标

str = "hello, world"
print(str[-1], str[-5])  # d w
for i in range(1, len(str) + 1):
    print(f"{str[-i]} ", end='')  # d l r o w   , o l l e h

(2) 字符串的常用方法

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

下面逐一演示

【查操作】

1、字符串[下标]

查看字符串的某个元素
越界则出错

my_str = "abc"
print(my_str[0])  # a
print(my_str[4])  # IndexError: string index out of range

2、字符串.index(字符串)

查看某个匹配的字符串的下标

my_str = "hello, world"
print(my_str.index("lo"))  # 3

3、字符串.count(字符串)

统计字符串内字符串的出现次数

my_str = "abcabcbcaaaa"
print(my_str.count("bc"))  # 3, 表示有3个bc

4、len(字符串)

统计字符串的长度

my_str = "abcabcbcaaaa"
print(len(my_str))  # 12

【构造新字符串操作】

5、字符串.replace(旧字符串, 新字符串)

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

my_str = "hello, world"
new_str = my_str.replace('l', 'm')
print(my_str)  # hello, world 原先的字符串是不会改变的
print(new_str)  # hemmo, wormd

6、字符串.split(字符串)

分割字符串，结果是list类型的

my_str = "hello, world, love, lll"
split_str = my_str.split('l')
print(my_str)  # hello, world, love, lll
print(split_str)  # ['he', '', 'o, wor', 'd, ', 'ove, ', '', '', '']
print(type(split_str))  # <class 'list'>

7、字符串.strip()、字符串.strip(字符串)

移除首尾的空格和换行符或指定字符串
如果没有参数就是空行

my_str = "   this is a string    "
new_str = my_str.strip()
print(my_str)  # '   this is a string    '
print(new_str)  # 'this is a string', delete the space when no arguments

如果有字符串参数，则移除收尾属于参数字符串容器的符号

my_str = "123abc123abcl231"
new_str = my_str.strip("123")
print(my_str)  # 123abc123abcl231
print(new_str)  # abc123abcl, 将首尾的 '1' '2' '3'移除了

(3) 字符串的遍历

两种方式

while遍历
for遍历

1、while循环遍历

my_str = "abcdefg"
index = 0
while index < len(my_str):
    print(f"{my_str[index]} ", end='')
    index += 1

2、for循环遍历

my_str = "abcdefg"
for ch in my_str:
    print(f"{ch} ", end='')

(4) 字符串特点

作为数据容器，字符串有如下特点：

只可以存储字符串
长度任意（取决于内存大小）
支持下标索引
允许重复字符串存在
不可以修改（增加或删除元素等）
支持for循环

8.1.4 序列切片

序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求

序列支持切片，即：列表、元组、字符串，均支持进行切片操作

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

语法：

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

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

起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
- 步长1表示，一个个取元素
- 步长2表示，每次跳过1个元素取
- 步长N表示，每次跳过N-1个元素取
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

【注意】切片操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

下面是演示

【步长为正数】

1、list切片

my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]  # 从下标[1,4)
print(result1)  # [1, 2, 3]
print(type(result1))  # <class 'list'>

2、tuple切片

my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]  # 从头到尾，步长为1
print(result2)  # (0, 1, 2, 3, 4, 5, 6)
print(type(result2))  # <class 'tuple'>

3、str切片

my_str = "1234567"
result3 = my_str[::2]  # 从头到尾，步长为2
print(result3)  # 1357
print(type(result3))  # <class 'str'>

【步长为负数】步长为负数的话，表示从后往前切片

my_str = "01234567"
result4 = my_str[::-1]
print(result4)  # 76543210,相当于倒置

my_list = [0, 1, 2, 3, 4, 5, 6, 7]
result5 = my_list[3:1:-1]  # 从[3, 1), 步长为1
print(result5)  # [3, 2]

my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(result6)  # (6, 4, 2, 0)

【技巧】步长为负数的话，很容易实现逆转

如上

my_str = "01234567"
result4 = my_str[::-1]
print(result4)  # 76543210

很容易地实现了倒置

【终止位置为负数】

str = "helloworld"
print(str[:-3]) # hellowo

-3表示倒数第三个字符，也就是将最后三个字符去掉

8.2 非序列set、dict

【说明】这里将dict和set两种类型的归到一类了，实际上有些牵强，只是为了文章结构合理

8.2.1 集合set

集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序

(1) 集合的定义

# 定义集合字面量
{元素1, 元素2, 元素3, 元素4...}

# 定义集合变量
set_var = {元素1, 元素2, 元素3, 元素4...}
 
 # 定义空集合
 empty_set = set()

1、定义集合字面量

{1, 2, 3, 4, 5}

2、定义集合变量

my_set = {1, 2, 3, 4, 1, 3, 1, 5}
print(my_set)  # {1, 2, 3, 4, 5}
print(type(my_set))  # <class 'set'>

3、定义空集合

empty_set = set()
print(empty_set)  # set()
print(type(empty_set))  # <class 'set'>

(2) 集合的常用方法

类型	编号	操作	说明
增	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(集合)	得到一个整数，记录了集合的元素数量

【增操作】

1、集合.add(元素)

将指定元素，添加到集合内
结果：集合本身被修改，添加了新元素

my_set = {"str1", "str2"}
my_set.add("str3")
print(my_set) # {'str1', 'str3', 'str2'}

【删操作】

2、集合.remove(元素)

语法：集合.remove(元素)，将指定元素，从集合内移除
结果：集合本身被修改，移除了元素

my_set = {"str1", "str2", "str3"}
my_set.remove("str2")
print(my_set) # {'str1', 'str3'}

如果集合中没有参数元素，会报错

my_set = {"str1", "str2", "str3"}
my_set.remove("str4")  # KeyError: 'str4'

3、集合.pop()

语法：集合.pop()，功能，从集合中随机取出一个元素
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

my_set = {"str1", "str2", "str3"}
element = my_set.pop()
print(my_set)  # {'str1', 'str3'}
print(element)  # str2

4、集合.clear()

语法：集合.clear()，功能，清空集合
结果：集合本身被清空

my_set = {"str1", "str2", "str3"}
print(my_set)  # {'str2', 'str1', 'str3'}
my_set.clear()
print(my_set)  # set()

5、集合1.difference(集合2)

功能：取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变

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

6、集合1.difference_update(集合2)

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

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

【合并操作】

7、集合1.union(集合2)

功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变

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

【查看操作】

8、len(集合)

功能：统计集合内有多少元素
结果：得到一个整数结果

set1 = {1, 2, 3}
print(len(set1))  # 3

(3) 遍历集合

集合不支持下标，不能使用while遍历，只能使用for遍历

my_set = {1, 2, 5, 6, 3, 4}
for elem in my_set:
    print(f"{elem} ", end='') # 1 2 3 4 5 6

(4) 集合的特点

经过上述对集合的学习，可以总结出集合有如下特点：

可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是无序存储的（不支持下标索引）
不允许重复数据存在
可以修改（增加或删除元素等）
支持for循环

8.2.2 字典dict

(1) 字典的定义

# 定义字典字面量
{key1: val1, key2: val2, key3: val3 ...}

# 定义字典变量
my_dict = {key1: val1, key2: val2, key3: val3 ...}

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

下面逐一演示

1、定义字典字面量

{"chinese": 99, "math": 98, "English": 97}

2、定义字典变量

my_dict = {"chinese": 99, "math": 98, "English": 97}
print(my_dict)  # {'chinese': 99, 'math': 98, 'English': 97}
print(type(my_dict))  # <class 'dict'>

字典是可以嵌套的

stu_score = {
    "mary": {"chinese": 99, "math": 98, "English": 95},
    "jack": {"chinese": 97, "math": 92, "English": 94},
    "lucy": {"chinese": 94, "math": 95, "English": 93},
}
print(stu_score)

3、定义空字典

empty_dict = {}
print(empty_dict)  # {}
print(type(empty_dict))  # <class 'dict'>
empty_dict = dict()
print(empty_dict)  # {}
print(type(empty_dict))  # <class 'dict'>

(2) 字典元素的获取

字典可以通过Key值来取得对应的Value

scores = {"chinese": 99, "math": 98, "English": 97}
print(scores["chinese"])  # 99
print(scores["math"])  # 98
print(scores["English"])  # 97

如果没有key值的话，会报错

scores = {"chinese": 99, "math": 98, "English": 97}
print(scores["physics"]) # KeyError: 'physics'

嵌套字典数据的获取

stu_score = {
    "mary": {"chinese": 99, "math": 98, "English": 95},
    "jack": {"chinese": 97, "math": 92, "English": 94},
    "lucy": {"chinese": 94, "math": 95, "English": 93},
}
print(stu_score["mary"]["math"])  # 98
print(stu_score["jack"]["English"])  # 94
print(stu_score["lucy"]["chinese"])  # 94

字典的key值不一定是字符串，可以是数字

my_dict = {0: "val2"}
print(my_dict)  # {0: 'val2'}
print(my_dict[0])  # val2

(3) 字典的常用函数

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

【增操作】

1、字典[Key] = Value（字典原本不存在该key值）

结果：字典被修改，新增了元素

scores = {"chinese": 99, "math": 98, "English": 97}
scores["chinese"] = 100
print(scores)  # {'chinese': 100, 'math': 98, 'English': 97}

【改操作】

1、字典[Key] = Value（字典原本存在该key值）

结果：字典被修改，元素被更新
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

scores = {"chinese": 99, "math": 98, "English": 97}
scores["history"] = 95
print(scores)  # {'chinese': 99, 'math': 98, 'English': 97, 'history': 95}

【删除操作】

2、字典.pop(Key)

获得指定Key的Value，同时字典被修改，指定Key的数据被删除

scores = {"chinese": 99, "math": 98, "English": 97}
value = scores.pop("math")
print(scores)  # {'chinese': 99, 'English': 97}
print(value)  # 98

3、字典.clear()

结果：字典被修改，元素被清空

scores = {"chinese": 99, "math": 98, "English": 97}
scores.clear()
print(scores)  # {}

【查操作】

4、字典.keys()

结果：得到字典中的全部Key

scores = {"chinese": 99, "math": 98, "English": 97}
keys = scores.keys() 
print(keys)   # dict_keys(['chinese', 'math', 'English'])

5、len(字典)

结果：得到一个整数，表示字典内元素（键值对）的数量

scores = {"chinese": 99, "math": 98, "English": 97}
print(len(scores))  # 3

(4) 字典的遍历

字典不支持下标，因此不能使用while遍历，只能用for循环遍历

scores = {"chinese": 99, "math": 98, "English": 97, "history": 95}
for key in scores.keys():
    print(f"{key}:{scores[key]}")
"""
chinese:99
math:98
English:97
history:95
"""

scores = {"chinese": 99, "math": 98, "English": 97, "history": 95}
for elem in scores:
    print(f"{elem} ", end='') # chinese math English history

【说明】当直接for in dict的时候，得到的数据都是key值

(5) 字典的特点

经过上述对字典的学习，可以总结出字典有如下特点：

可以容纳多个数据
可以容纳不同类型的数据
每一份数据是KeyValue键值对
可以通过Key获取到Value，Key不可重复（重复会覆盖）
不支持下标索引
可以修改（增加或删除更新元素等）
支持for循环，不支持while循环

8.3 数据容器对比

数据容器可以从以下视角进行简单的分类：

是否支持下标索引
- 支持：列表、元组、字符串 - 序列类型
- 不支持：集合、字典 - 非序列类型
是否支持重复元素：
- 支持：列表、元组、字符串 - 序列类型
- 不支持：集合、字典 - 非序列类型
是否可以修改
- 支持：列表、集合、字典
- 不支持：元组、字符串

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

8.4 容器的通用操作

首先，在遍历上：

5类数据容器都支持for循环遍历
列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

除了遍历这个共性外，数据容器可以通用非常多的功能方法

类型	功能	描述
一般函数	max	容器内最大元素
	min()	容器内最小元素
	len()	容器元素个数
	sorted(序列, [reverse=True])	排序，reverse=True表示降序得到一个排好序的列表
类型转换	list()	转换为列表
	tuple()	转换为元组
	str()	转换为字符串
	set()	转换为集合
运算操作	+	只有list，str，tuple可以使用

【一般函数】

1、max最大元素

【说明】dict比较的是key的大小，字符串比较的是每个字符的ASCII码

my_list = [1, 3, 2, 5, 4]
my_tuple = (1, 4, 5, 3, 2)
my_str = "edabcdf"
my_dict = {"key1": 12, "key3": "lucy", "key2": 9.84}
my_set = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}

print(max(my_list))  # 5
print(max(my_tuple))  # 5
print(max(my_str))  # f
print(max(my_dict))  # key3
print(max(my_set))  # 10

2、min最小元素

my_list = [1, 3, 2, 5, 4]
my_tuple = (1, 4, 5, 3, 2)
my_str = "edabcdf"
my_dict = {"key1": 12, "key3": "lucy", "key2": 9.84}
my_set = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}

print(min(my_list))  # 1
print(min(my_tuple))  # 1
print(min(my_str))  # a
print(min(my_dict))  # key1
print(min(my_set))  # 1

3、len长度

my_list = [1, 3, 2, 5, 4]
my_tuple = (1, 4, 5, 3, 2)
my_str = "edabcdf"
my_dict = {"key1": 12, "key3": "lucy", "key2": 9.84}
my_set = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}

print(len(my_list))  # 5
print(len(my_tuple))  # 5
print(len(my_str))  # 7
print(len(my_dict))  # 3
print(len(my_set))  # 10

4、sorted排序

【说明】排序后都会得到list对象

默认正序排序

my_list = [1, 3, 2, 5, 4]
my_tuple = (1, 4, 5, 3, 2)
my_str = "edabcdf"
my_dict = {"key1": 12, "key3": "lucy", "key2": 9.84}
my_set = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}

print(sorted(my_list))  # [1, 2, 3, 4, 5]
print(sorted(my_tuple))  # [1, 2, 3, 4, 5]
print(sorted(my_str))  # ['a', 'b', 'c', 'd', 'd', 'e', 'f']
print(sorted(my_dict))  # ['key1', 'key2', 'key3']
print(sorted(my_set))  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

倒序排序，reverse = True

my_list = [1, 3, 2, 5, 4]
my_tuple = (1, 4, 5, 3, 2)
my_str = "edabcdf"
my_dict = {"key1": 12, "key3": "lucy", "key2": 9.84}
my_set = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}

print(sorted(my_list, reverse=True))  # [5, 4, 3, 2, 1]
print(sorted(my_tuple, reverse=True))  # [5, 4, 3, 2, 1]
print(sorted(my_str, reverse=True))  # ['f', 'e', 'd', 'd', 'c', 'b', 'a']
print(sorted(my_dict, reverse=True))  # ['key3', 'key2', 'key1']
print(sorted(my_set, reverse=True))  # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

【强制类型转换】

5、转换成list类型

【说明】dict只能转换key

my_list = [1, 3, 2, 5, 4]
my_tuple = (1, 4, 5, 3, 2)
my_str = "edabcdf"
my_dict = {"key1": 12, "key3": "lucy", "key2": 9.84}
my_set = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}

print(list(my_list))  # [1, 3, 2, 5, 4]
print(list(my_tuple))  # [1, 4, 5, 3, 2]
print(list(my_str))  # ['e', 'd', 'a', 'b', 'c', 'd', 'f']
print(list(my_dict))  # ['key1', 'key3', 'key2']
print(list(my_set))  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

6、都转换成tuple类型

my_list = [1, 3, 2, 5, 4]
my_tuple = (1, 4, 5, 3, 2)
my_str = "edabcdf"
my_dict = {"key1": 12, "key3": "lucy", "key2": 9.84}
my_set = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}

print(tuple(my_list))  # (1, 3, 2, 5, 4)
print(tuple(my_tuple))  # (1, 4, 5, 3, 2)
print(tuple(my_str))  # ('e', 'd', 'a', 'b', 'c', 'd', 'f')
print(tuple(my_dict))  # ('key1', 'key3', 'key2')
print(tuple(my_set))  # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

7、都转换成str类型

看起来输出没变，实际上都转换成字符串了

my_list = [1, 3, 2, 5, 4]
my_tuple = (1, 4, 5, 3, 2)
my_str = "edabcdf"
my_dict = {"key1": 12, "key3": "lucy", "key2": 9.84}
my_set = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}

print(str(my_list))  # [1, 3, 2, 5, 4]
print(str(my_tuple))  # (1, 4, 5, 3, 2)
print(str(my_str))  # edabcdf
print(str(my_dict))  # {'key1': 12, 'key3': 'lucy', 'key2': 9.84}
print(str(my_set))  # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

8、都转换成set类型

【说明】转换成set类型会自动去重

my_list = [1, 3, 2, 5, 4, 1, 3, 5]
my_tuple = (1, 4, 5, 3, 2, 2, 3, 5)
my_str = "edabcdf"
my_dict = {"key1": 12, "key3": "lucy", "key2": 9.84}
my_set = {1, 3, 5, 7, 9, 9, 7, 5, 3, 1}

print(set(my_list))  # {1, 2, 3, 4, 5}
print(set(my_tuple))  # {1, 2, 3, 4, 5}
print(set(my_str))  # {'a', 'f', 'b', 'c', 'd', 'e'}
print(set(my_dict))  # {'key2', 'key3', 'key1'}
print(set(my_set))  # {1, 3, 5, 7, 9}

【运算操作】

相加：只有list，tuple，str可以相加

list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = list1 + list2
print(result)  # [1, 2, 3, 4, 5, 6]

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
result = tuple1 + tuple2
print(result)  # (1, 2, 3, 4, 5, 6)

str1 = "123"
str2 = "456"
print(str1 + str2) # 123456

# set不能相加
# set1 = {1, 2, 3}
# set2 = {4, 5, 6}
# print(set1 + set2)
# dict1 = {"key1", "val1"}
# dict2 = {"key2", "val2"}
# print(dict1 + dict2)

posted @ 2023-10-07 11:36 Crispy·Candy 阅读(46) 评论(0) 编辑收藏举报

刷新页面返回顶部

酥心糖

Python第八章数据容器

第八章数据容器

8.1 序列list、tuple、str

8.1.1 列表list

(1) list的定义

(2) list的下标

(3) list的常用方法

(4) list特点

(5) list的遍历

8.1.2 元组tuple

(1) 元组的定义

(2) 元组的下标

(3) 元组的常用方法

(4) 元组的遍历

(5) 元组特点

8.1.3 字符串str

(1) 字符串的下标

(2) 字符串的常用方法

(3) 字符串的遍历

(4) 字符串特点

8.1.4 序列切片

8.2 非序列set、dict

8.2.1 集合set

(1) 集合的定义

(2) 集合的常用方法

(3) 遍历集合

(4) 集合的特点

8.2.2 字典dict

(1) 字典的定义

(2) 字典元素的获取

(3) 字典的常用函数

(4) 字典的遍历

(5) 字典的特点

8.3 数据容器对比

8.4 容器的通用操作

公告

酥心糖

Python第八章 数据容器

第八章 数据容器

8.1 序列list、tuple、str

8.1.1 列表list

(1) list的定义

(2) list的下标

(3) list的常用方法

(4) list特点

(5) list的遍历

8.1.2 元组tuple

(1) 元组的定义

(2) 元组的下标

(3) 元组的常用方法

(4) 元组的遍历

(5) 元组特点

8.1.3 字符串str

(1) 字符串的下标

(2) 字符串的常用方法

(3) 字符串的遍历

(4) 字符串特点

8.1.4 序列切片

8.2 非序列set、dict

8.2.1 集合set

(1) 集合的定义

(2) 集合的常用方法

(3) 遍历集合

(4) 集合的特点

8.2.2 字典dict

(1) 字典的定义

(2) 字典元素的获取

(3) 字典的常用函数

(4) 字典的遍历

(5) 字典的特点

8.3 数据容器对比

8.4 容器的通用操作

公告

Python第八章数据容器

第八章数据容器