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、正常使用,正向索引

image-20230925155809400

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表示倒数第二个数据,以此类推

image-20230925155710511

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特点

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

(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) 元组特点

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

  1. 可以容纳多个数据
  2. 可以容纳不同类型的数据(混装)
  3. 数据是有序存储的(下标索引)
  4. 允许重复数据存在
  5. 不可以修改(增加或删除元素等)
  6. 支持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) 字符串的遍历

两种方式

  1. while遍历
  2. 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) 字符串特点

作为数据容器,字符串有如下特点:

  1. 只可以存储字符串
  2. 长度任意(取决于内存大小)
  3. 支持下标索引
  4. 允许重复字符串存在
  5. 不可以修改(增加或删除元素等)
  6. 支持for循环

8.1.4 序列切片

image-20230925184543418image-20230925184547434

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

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

切片:从一个序列中,取出一个子序列

语法

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

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

  • 起始下标表示从何处开始,可以留空,留空视作从头开始
  • 结束下标(不含)表示何处结束,可以留空,留空视作截取到结尾
  • 步长表示,依次取元素的间隔
    • 步长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) 集合的特点

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

  1. 可以容纳多个数据
  2. 可以容纳不同类型的数据(混装)
  3. 数据是无序存储的(不支持下标索引)
  4. 不允许重复数据存在
  5. 可以修改(增加或删除元素等)
  6. 支持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) 字典的特点

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

  1. 可以容纳多个数据
  2. 可以容纳不同类型的数据
  3. 每一份数据是KeyValue键值对
  4. 可以通过Key获取到Value,Key不可重复(重复会覆盖)
  5. 不支持下标索引
  6. 可以修改(增加或删除更新元素等)
  7. 支持for循环,不支持while循环

8.3 数据容器对比

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

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

8.4 容器的通用操作

首先,在遍历上:

  1. 5类数据容器都支持for循环遍历
  2. 列表、元组、字符串支持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  阅读(47)  评论(0编辑  收藏  举报