Python基础：16、Python数据容器

news2024/10/19 10:23:08
1）数据容器入门

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

  • 数据容器：一种可以存储多个元素的Python数据类型
  • 数据容器包括：list（列表）、tuple（元组）、str（字符串）、set（集合）、dict（字典）

2）list（列表）

列表内的每一个数据，称为元素

  • 以[]作为标识

  • 列表内每一个元素之间用，逗号隔开

基本语法：

# 字面量
[元素1， 元素2， 元素3， ...]
​
# 定义变量
变量名称 = [元素1， 元素2， 元素3， ...]
​
# 定义空列表
变量名称 = []
变量名称 = list()
# 定义一个列表list
name_list = ["lihua", "xioahua", "xioahong"]
print(name_list)
print(type(name_list))
​
my_list = ["xiaomi", 9527, True]
print(my_list)
print(type(my_list))
​
# 定义一个嵌套的列表
my_list = [["lihua", "xioahua", "xioahong"], ["xiaomi", 9527, True]]
print(my_list)
print(type(my_list))
['lihua', 'xioahua', 'xioahong']
<class 'list'>
['xiaomi', 9527, True]
<class 'list'>
[['lihua', 'xioahua', 'xioahong'], ['xiaomi', 9527, True]]
<class 'list'>

列表下标的索引（正向）

列表下标的索引（反向）

嵌套列表的下标索引

# 定义一个列表list
name_list = ["lihua", "xioahua", "xioahong"]
print(name_list)
print(type(name_list))
​
my_list = ["xiaomi", 9527, True]
print(my_list)
print(type(my_list))
# 定义一个嵌套的列表
my_list = [["lihua", "xioahua", "xioahong"], ["xiaomi", 9527, True]]
print(my_list)
print(type(my_list))
# 通过下标索引取出对应位置的数据
my_list = ["A", "B", "C"]
# 列表[下标索引]，从前到后从0开始，每次+1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 通过下标索引取出数据（倒序取出）
my_list = ["A", "B", "C"]
# 列表[下标索引]，从后到前从-1开始，每次-1
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
# 取出嵌套列表的元素
# 定义一个嵌套的列表
my_list = [["lihua", "xioahua", "xioahong"], ["xiaomi", 9527, True]]
print(my_list[1][1])

注意：下标索引的取值范围不要超出，否则无法取到元素，并且报错

列表的方法：总览（增删改查）

1.查找

语法：列表.index(元素)

my_list = ["abcd", "66E6", "python"]
print(f"列表元素值：{my_list}")
# 1.1 查找元素在列表内的下标索引
index = my_list.index("abcd")
# 1.2 如果被查找的元素不存在，会报错
print(f"abcd在列表中的下标索引值是：{index}")

2.修改

语法：列表[下标] = “元素”

# 2.修改特定下标索引的值
my_list = ["abcd", "66E6", "python"]
my_list[1] = "88C3"
print(f"列表被修改元素后，结果是：{my_list}")

3.插入

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

# 3.在指定下标位置插入新元素：
# 语法：列表.insert(下标， 元素)
my_list = ["abcd", "66E6", "python"]
my_list.insert(1, "xiaomi")
print(f"列表被插入元素后，结果是：{my_list}")

4.追加一个元素

语法：列表.append(元素)

# 4.在列表的尾部追加'''单个'''新元素：
# 语法：列表.append(元素)
my_list = ["abcd", "66E6", "python"]
my_list.append("扣你鸡哇")
print(f"列表在追加元素后，结果是：{my_list}")

5.追加一批元素

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

# 5.在列表的尾部追加'''一批'''新元素
# 语法：列表.extend(其他数据容器)
my_list = ["abcd", "66E6", "python"]
my_list2 = [1, 2, 3]
my_list.extend(my_list2)
print(f"列表在追加了一个新列表后，结果是：{my_list}")

6.删除指定下标索引的元素

语法：

方法一：del 列表[下标]

方法二：列表.pop(下标)

# 6.删除指定下标索引的元素（2种方式）
my_list = ["A", "B", "C"]
print(f"列表元素值：{my_list}")
​
# 6.1 方式一：del 列表[下标]
del my_list[2]
print(f"列表在删除元素后，结果是：{my_list}")
​
# 6.2 方式二：列表.pop(下标)
my_list = ["A", "B", "C"]
str_str = my_list.pop(1)
print(f"通过pop方法取出元素后，列表结果是：{my_list}， 取出的元素是：{str_str}")

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

语法：列表.remove(元素)

# 7.删除某元素在列表中的第一个匹配项
# 语法：列表.remove(元素)
my_list = ["A", "B", "C", "B", "C"]
my_list.remove("B")
print(f"通过remove方法移除元素后，列表结果是：{my_list}")

8.清空列表

语法：列表.clear()

# 8.清空列表
# 语法：列表.clear()
my_list = ["abcd", "66E6", "python"]
my_list.clear()
print(f"列表被清空了，结果是：{my_list}")

9.统计列表内某元素的数量

语法：列表.count(元素)

# 9.统计列表内某元素的数量
# 语法：列表.count(元素)
my_list = ["A", "B", "C", "B", "C"]
num = my_list.count("C")
print(f"列表中C元素的数量是：{num}")

10.统计列表内全部元素的数量

语法： len(列表)

# 10.统计列表内全部元素的数量
# 语法： len(列表)
my_list = ["A", "B", "C", "B", "C"]
count = len(my_list)
print(f"列表中元素的数量是：{count}")
3）list（列表）的遍历
# 使用while循环遍历列表
print("while循环遍历")
def list_while_func():
    my_list = ["A", "B", "C", "D", "E", "F", "G"]
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件：下标索引变量 < 列表的元素数量
    index = 0
    while index < len(my_list):
        # 通过index变量取出对应下标的元素
        element = my_list[index]
        print(f"列表的元素：{element}")
​
        # index每循环一次＋1
        index += 1
​
​
list_while_func()
​
# 使用for循环遍历列表
print("for循环遍历")
def list_for_func():
    my_list = ["A", "B", "C", "D", "E", "F", "G"]
    for x in my_list:
        print(f"列表的元素：{x}")
​
​
list_for_func()

例子：

# 使用while循环遍历列表
print("while循环遍历")
def list_while_func():
    my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    my_list2 = []
    index = 0
    while index < len(my_list):
        # 通过index变量取出对应下标的元素
        element = my_list[index]
        if element % 2 == 0:
            my_list2.append(element)
​
        # index每循环一次＋1
        index += 1
    print(f"列表的元素：{my_list2}")
​
​
list_while_func()
​
# 使用for循环遍历列表
print("for循环遍历")
def list_for_func():
    my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    my_list2 = []
    for x in my_list:
        if x % 2 == 0:
            my_list2.append(x)
​
    print(f"列表的元素：{my_list2}")
​
​
list_for_func()
while循环遍历
列表的元素：[2, 4, 6, 8, 10]
for循环遍历
列表的元素：[2, 4, 6, 8, 10]

4）数据容器：tuple（元组）

定义：

元组定义：定义元组使用小括号，且用逗号隔开各个数据，数据可以是不同的数据类型

# 定义字面量
()
​
# 定义元组变量
变量名称 = (元素， 元素，...)
​
# 定义空元组 
变量名称 = ()        # 方式1
变量名称 = tuple()   # 方式2

# 定义元组
t1 = (1, 2, "xiaomi")
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}，内容是：{t1}")
print(f"t2的类型是：{type(t2)}，内容是：{t2}")
print(f"t3的类型是：{type(t3)}，内容是：{t3}")
t1的类型是：<class 'tuple'>，内容是：(1, 2, 'xiaomi')
t2的类型是：<class 'tuple'>，内容是：()
t3的类型是：<class 'tuple'>，内容是：()

 

# 定义单个元组元素
t4 = ("xiaomi", )
print(f"t4的类型是：{type(t4)}，内容是：{t4}")
t4的类型是：<class 'tuple'>，内容是：('xiaomi',)

 

# 元组的嵌套
t5 = ((1, 2, 3), (4, 5, 6))
print(f"t5的类型是：{type(t5)}，内容是：{t5}")
t5的类型是：<class 'tuple'>，内容是：((1, 2, 3), (4, 5, 6))

 

# 下标索引取出内容
t5 = ((1, 2, 3), (4, 5, 6))
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")
从嵌套元组中取出的数据是：6
 

# 元组的操作：index查找方法
t6 = ("AAA", "BBB", "CCC")
index = t6.index("BBB")
print(f"在元组t6中查找“BBB”的下标是：{index}")
 

在元组t6中查找“BBB”的下标是：1
 

 

# 元组的操作：count统计方法
t7 = ("AAA", "BBB", "CCC", "AAA", "BBB", "CCC")
num = t7.count("BBB")
print(f"在元组t7中统计“BBB”的数量是：{num}")
 

在元组t7中统计“BBB”的数量是：2
 

 

# 元组的操作：len函数统计元组元素数量
t8 = ("AAA", "BBB", "CCC", "AAA", "BBB", "CCC")
num = len(t8)
print(f"在元组t8中元素的数量是：{num}")
 

在元组t8中元素的数量是：6
 

 

# 元组的遍历：while
print("while循环遍历")
t9 = ("AAA", "BBB", "CCC", "AAA", "BBB", "CCC")
index = 0
while index < len(t9):
    print(f"元组的元素有：{t9[index]}")
    index += 1
 

while循环遍历
元组的元素有：AAA
元组的元素有：BBB
元组的元素有：CCC
元组的元素有：AAA
元组的元素有：BBB
元组的元素有：CCC
 

 

# 元组的遍历：for
print("for循环遍历")
t9 = ("AAA", "BBB", "CCC", "AAA", "BBB", "CCC")
for x in t9:
    print(f"元组的元素有：{x}")
 

for循环遍历
元组的元素有：AAA
元组的元素有：BBB
元组的元素有：CCC
元组的元素有：AAA
元组的元素有：BBB
元组的元素有：CCC
 

 

# 定义一个可修改的元组列表
t10 = (1, 2, ["A", "B"])
print(f"t10的内容是：{t10}")
t10[2][0] = "a"
t10[2][1] = "b"
print(f"t10的内容是：{t10}")
 

t10的内容是：(1, 2, ['A', 'B'])
t10的内容是：(1, 2, ['a', 'b'])
 

例子：元组的基本操作
 

 

# 定义一个元组，记录学生的姓名、年龄、爱好
"""
1.查询年龄所在位置
2.查询学生姓名
3.删除学生的其中一个爱好
4.增加一个爱好
"""
​
# 定义元组
# 查询年龄所在位置
student = ("kun", 2.5, ["唱歌", "跳舞", "rap", "篮球"])
index = student.index(2.5)
print(f"年龄在元组中的位置是：{index}")
​
# 询学生姓名
name = student[0]
print(f"学生的姓名是：{name}")
​
# 删除学生的其中一个爱好
print(f"删除前学生的爱好有：{student[2]}")
del student[2][0]
print(f"删除后学生的爱好有：{student[2]}")
​
# 增加一个爱好
student[2].insert(0, "你干嘛")
print(f"增加后元组的元素是：{student}")
 

年龄在元组中的位置是：1
学生的姓名是：kun
删除前学生的爱好有：['唱歌', '跳舞', 'rap', '篮球']
删除后学生的爱好有：['跳舞', 'rap', '篮球']
增加后元组的元素是：('kun', 2.5, ['你干嘛', '跳舞', 'rap', '篮球'])
 

 

5）数据容器：str（字符串）
 

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

 

1.根据下标索引取出特定位置字符
 

语法：字符串[下标]
 

# 演示以数据容器的角色，学习字符串的相关操作
​
# 通过下标索引取值取出特定字符
my_str = "python hello world"
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素是：{value}，取下标为-16的元素是：{value2}")
 

从字符串python hello world取下标为2的元素是：t，取下标为-16的元素是：t
 

2.查找给定字符的第一个匹配项的下标
 

语法：字符串.index(字符串）
 

# index的方法
my_str = "python hello world"
value = my_str.index("hello")
print(f"在字符串{my_str}中查找hello，其起始下标是：{value}")
 

在字符串python hello world中查找hello，其起始下标是：7
 

3.将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
 

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

# replace替换字符串方法，得到新字符串
my_str = "python hello world"
new_my_str = my_str.replace("python", "c")
print(f"将字符串{my_str}进行replace替换后得到：{new_my_str}")
 

将字符串python hello world进行replace替换后得到：c hello world
 

4.按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表
 

语法：字符串.split(字符串)
 

# split方法
my_str = "python hello world"
new_my_str= my_str.split(" ")
print(f"将字符串{my_str}进行split分割后得到：{new_my_str}，数据类型是：{type(new_my_str)}")
 

将字符串python hello world进行split分割后得到：['python', 'hello', 'world']，数据类型是：<class 'list'>
 

5.移除首尾的空格和换行符或指定字符串
 

语法1：字符串.strip()
 

语法2：字符串.strip(字符串)
 

# strip方法
my_str = "   python hello world   "
new_my_str = my_str.strip()   # 不传入参数，默认为：去除首尾空格
print(f"将字符串{my_str}进行strip后得到：{new_my_str}")
​
my_str = "122python hello world211"
new_my_str = my_str.strip("12")   # 不传入参数，默认为：去除首尾空格
print(f"将字符串{my_str}进行strip后得到：{new_my_str}")
 

将字符串   python hello world   进行strip后得到：python hello world
将字符串122python hello world211进行strip后得到：python hello world
 

6.统计字符串内某字符串的出现次数
 

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

# 统计字符串中某字符串出现的次数， count
my_str = "122python hello world211"
count = my_str.count("o")
print(f"字符串{my_str}中“o”出现的次数是：{count}")
 

字符串122python hello world211中“o”出现的次数是：3
 

7.统计字符串的字符个数
 

语法：len(字符串)
 

# 统计字符串的长度，len()
my_str = "python hello world"
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")
 

字符串python hello world的长度是：18
 

 

特点：
 

•只可以存储字符串
 

•长度任意（取决于内存大小）
 

•支持下标索引
 

•允许重复字符串存在
 

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

•支持for循环
 

 

6）数据容器的切片
 

\1. 什么是序列？
 

内容连续、有序，支持下标索引的一类数据容器
 

 

\2. 哪些数据容器可以视为序列？
 

列表、元组、字符串
 

 

\3. 序列如何做切片
 

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

•起始可以省略，省略从头开始
 

•结束可以省略，省略到尾结束
 

•步长可以省略，省略步长为1（可以为负数，表示倒序执行）
 

 

# 演示对序列进行切片操作
​
# 对list进行切片，从1开始，到4结束，步长为1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1: 4]   # 默认步长为1，可不写
print(f"结果1：{result1}")
​
# 对列表进行切片，从3开始，到1结束，步长为-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result2 = my_list[3: 1: -1]
print(f"结果2：{result2}")
​
# 对tuple进行切片，从头开始，到最后结束，步长为1
my_list = (0, 1, 2, 3, 4, 5, 6)
result3 = my_list[:]   # 默认步长为1，可不写
print(f"结果3：{result3}")
​
# 对元组进行切片，从头开始，到最后结束，步长为-2
my_list = (0, 1, 2, 3, 4, 5, 6)
result4 = my_list[:: -2]
print(f"结果4：{result4}")
​
# 对str进行切片，从头开始，到最后结束，步长为2
my_str = "01234567"
result5 = my_str[::2]
print(f"结果5：{result5}")
​
# 对str进行切片，从头开始，到最后结束，步长为-1
my_str = "01234567"
result6 = my_str[::-1]   # 等同于反序
print(f"结果6：{result6}")
 

结果1：[1, 2, 3]
结果2：[3, 2]
结果3：(0, 1, 2, 3, 4, 5, 6)
结果4：(6, 4, 2, 0)
结果5：0246
结果6：76543210
 

 

综合案例：
 

"""
演示序列的切片的练习
“万过薪月，员序程马来，onhtyp学”
"""
my_str = "万过薪月，员序程马黑来，onhtyp学"
​
# 倒序字符串，切片输出
result1 = my_str[::-1][9: 14]
print(f"方式1的结果是：{result1}")
​
# 切片输出，然后倒序
result2 = my_str[5: 10][::-1]
print(f"方式2的结果是：{result2}")
​
# split分割“，”  replace替换“来”为空，倒序字符串
result3 = my_str.split("，")[1].replace("来", "")[::-1]
print(f"方式3的结果是：{result3}")
 

方式1的结果是：黑马程序员
方式2的结果是：黑马程序员
方式3的结果是：黑马程序员
 

 

7）数据容器：set（集合）
 

基本语法：
 

# 定义集合字面量
{元素， 元素，...，元素}
​
# 定义集合变量
变量名称 = {元素， 元素，...，元素}
​
# 定义空集合
变量名称 = set()
 

编号操作说明
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个集合内容不变
8len(集合)得到一个整数，记录了集合的元素数量
 

特点：
 

•可以容纳多个数据
 

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

•数据是无序存储的（不支持下标索引）
 

•不允许重复数据存在
 

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

•支持for循环
 

# 定义集合
my_set = {"aa", "bb", "cc", "aa", "bb", "cc", "aa", "bb", "cc"}
my_set_empty = set()
print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}，类型是：{type(my_set_empty)}")
 

my_set的内容是：{'aa', 'cc', 'bb'}，类型是：<class 'set'>
my_set_empty的内容是：set()，类型是：<class 'set'>
 

1.集合内添加一个元素
 

语法： 集合.add(元素)
 

# 添加新元素 add
my_set = {"aa", "bb", "cc", "aa", "bb", "cc", "aa", "bb", "cc"}
my_set.add("dd")
my_set.add("aa")
print(f"my_set添加元素后的内容是：{my_set}")
 

my_set添加元素后的内容是：{'aa', 'dd', 'cc', 'bb'}
 

2.移除集合内指定的元素
 

语法：集合.remove(元素)
 

# 移除元素 remove
my_set = {"aa", "bb", "cc", "aa", "bb", "cc", "aa", "bb", "cc"}
my_set.remove("bb")
print(f"my_set删除元素后的内容是：{my_set}")
 

my_set删除元素后的内容是：{'aa', 'cc'}
 

3.从集合中随机取出一个元素
 

语法：集合.pop()
 

# 随机取出一个元素 pop
my_set = {"aa", "bb", "cc"}
print(f"my_set随机取出元素前的内容是：{my_set}")
element = my_set.pop()
print(f"my_set随机取出元素是：{element}，取出后的内容是：{my_set}")
 

my_set随机取出元素前的内容是：{'aa', 'cc', 'bb'}
my_set随机取出元素是：aa，取出后的内容是：{'cc', 'bb'}
 

4.将集合清空
 

语法：集合.clear()
 

# 清空集合
my_set = {"aa", "bb", "cc"}
my_set.clear()
print(f"my_set清空后的内容是：{my_set}")
 

my_set清空后的内容是：set()
 

5.得到一个新集合，内含2个集合的差集 原有的2个集合内容不变
 

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

# 取2个集合的差集   difference
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取出差集后，set1的内容：{set1}")
print(f"取出差集后，set2的内容：{set2}")
 

取出差集后的结果是：{2, 3}
取出差集后，set1的内容：{1, 2, 3}
取出差集后，set2的内容：{1, 5, 6}
 

6.在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
 

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

# 消除两个集合的差集   difference_update
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，set1的内容：{set1}")
print(f"消除差集后，set2的内容：{set2}")
 

消除差集后，set1的内容：{2, 3}
消除差集后，set2的内容：{1, 5, 6}
 

7.得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变
 

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

# 2个集合合并为一个  union
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"合并差集后的结果是：{set3}")
print(f"合并差集后，set1的内容：{set1}")
print(f"合并差集后，set2的内容：{set2}")
 

合并差集后的结果是：{1, 2, 3, 5, 6}
合并差集后，set1的内容：{1, 2, 3}
合并差集后，set2的内容：{1, 5, 6}
 

8.得到一个整数，记录了集合的元素数量
 

语法：len(集合)
 

# 统计集合元素数量  len
set1 = {1, 2, 3, 4, 1, 2}
num = len(set1)
print(f"{num}")
 

4
 

9.for循环遍历
 

# 集合的遍历
set1 = {1, 2, 3, 4, 1, 2}
for x in set1:
    print(f"集合str1的元素有：{x}")
 

集合str1的元素有：1
集合str1的元素有：2
集合str1的元素有：3
集合str1的元素有：4
 

 

8）数据容器：dict（字典、映射）
 

# 定义字典字面量
{key:value, key:value,......, key:value}
​
# 定义字典字面量
my_dict = {key:value, key:value,......, key:value}
​
# 定义空字典
my_dict = {}
my_dict = dict{}
 

# 定义字典
my_dict1 = {"A": 99, "B": 88, "C": 77}
​
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}，类型是：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}，类型是：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}，类型是：{type(my_dict3)}")
​
# 定义重复Key的字典
my_dict4 = {"A": 99, "B": 88, "C": 77, "B": 66, "C": 55}
print(f"重复key的字典的内容是：{my_dict4}")  # 重复的字典元素，新的会把老的覆盖掉
​
# 从字典中基于key获取value
my_dict5 = {"A": 99, "B": 88, "C": 77}
print(f"A对应的分数是：{my_dict5["A"]}")
print(f"B对应的分数是：{my_dict5["B"]}")
print(f"C对应的分数是：{my_dict5["C"]}")
​
# 定义嵌套字典
# my_dict6 = {"A": {"语文": 89, "数学": 98, "英语": 35}, "B": {"语文": 75, "数学": 88, "英语": 65}, "C": {"语文": 87, "数学": 65, "英语": 55}}
my_dict6 = {
    "A": {
        "语文": 89,
        "数学": 98,
        "英语": 35
    }, "B": {
        "语文": 75,
        "数学": 88,
        "英语": 65
    }, "C": {
        "语文": 87,
        "数学": 65,
        "英语": 55
    }
}
print(f"学生的考试信息是：{my_dict6}")
​
# 从嵌套字典中获取数据
score = my_dict6["A"]["语文"]
print(f"A的语文成绩是：{score}")
​
 

字典1的内容是：{'A': 99, 'B': 88, 'C': 77}，类型是：<class 'dict'>
字典2的内容是：{}，类型是：<class 'dict'>
字典3的内容是：{}，类型是：<class 'dict'>
​
重复key的字典的内容是：{'A': 99, 'B': 66, 'C': 55}
​
A对应的分数是：99
B对应的分数是：88
C对应的分数是：77
​
学生的考试信息是：{'A': {'语文': 89, '数学': 98, '英语': 35}, 'B': {'语文': 75, '数学': 88, '英语': 65}, 'C': {'语文': 87, '数学': 65, '英语': 55}}
​
A的语文成绩是：89
 

字典的常用操作
 

•新增元素
 

语法：
 

字典[Key] = Value
 

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

 

•更新元素
 

语法：
 

字典[Key] = Value
 

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

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

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

my_dict1 = {"A": 99, "B": 88, "C": 77}
​
# 新增元素
my_dict1["D"] = 66
print(f"my_dict1字典新增后的内容是：{my_dict1}")
​
# 更新元素
my_dict1["B"] = 70
print(f"my_dict1字典更新后的内容是：{my_dict1}")
 

my_dict1字典新增后的内容是：{'A': 99, 'B': 88, 'C': 77, 'D': 66}
my_dict1字典更新后的内容是：{'A': 99, 'B': 70, 'C': 77, 'D': 66}
 

 

# 删除元素  pop
my_dict2 = {"A": 99, "B": 88, "C": 77}
print(f"my_dict2字典删除A前的内容是：{my_dict2}")
score = my_dict2.pop("A")
print(f"my_dict2字典删除A后的内容是：{my_dict2}，A的成绩是：{score}")
 

my_dict2字典删除A前的内容是：{'A': 99, 'B': 88, 'C': 77}
my_dict2字典删除A后的内容是：{'B': 88, 'C': 77}，A的成绩是：99
 

 

# 清空元素   clear
my_dict3 = {"A": 99, "B": 88, "C": 77}
my_dict3.clear()
print(f"my_dict3字典清空后的内容是：{my_dict3}")
 

my_dict3字典清空后的内容是：{}
 

 

# 获取全部的key    keys
my_dict4 = {"A": 99, "B": 88, "C": 77}
keys = my_dict4.keys()
print(f"my_dict4字典key的内容是：{keys}")
 

my_dict4字典key的内容是：dict_keys(['A', 'B', 'C'])
 

 

# 遍历字典
my_dict5 = {"A": 99, "B": 88, "C": 77}
# 方式1  通过获取到全部的key来遍历
keys = my_dict5.keys()
for key in keys:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dict5[key]}")
​
# 方式2  直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict5:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dict5[key]}")
 

字典的key是：A
字典的value是：99
字典的key是：B
字典的value是：88
字典的key是：C
字典的value是：77
字典的key是：A
字典的value是：99
字典的key是：B
字典的value是：88
字典的key是：C
字典的value是：77
 

 

# 统计字典内的元素数量   len
my_dict5 = {"A": 99, "B": 88, "C": 77}
num = len(my_dict5)
print(f"统计字典内的元素数量:{num}")
 

统计字典内的元素数量:3
 

 

特点：
 

•可以容纳多个数据
 

•可以容纳不同类型的数据
 

•每一份数据是KeyValue键值对
 

•可以通过Key获取到Value，Key不可重复（重复会覆盖）
 

•不支持下标索引
 

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

•支持for循环，不支持while循环
 

 

9）数据容器对比总结
 

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

•是否支持下标索引
 

•支持：列表、元组、字符串 - 序列类型
 

•不支持：集合、字典 - 非序列类型
 

•是否支持重复元素：
 

•支持：列表、元组、字符串 - 序列类型
 

•不支持：集合、字典 - 非序列类型
 

•是否可以修改
 

•支持：列表、集合、字典
 

•不支持：元组、字符串
 

 

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

 

基于各类数据容器的特点，它们的应用场景如下：
 

  •  
    列表：一批数据，可修改、可重复的存储场景
     
  •  
    元组：一批数据，不可修改、可重复的存储场景
     
  •  
    字符串：一串字符串的存储场景
     
  •  
    集合：一批数据，去重存储场景
     
  •  
    字典：一批数据，可用Key检索Value的存储场景
     
 

 

10）数据容器的通用操作
 

1））遍历
 

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

2））统计
 

 

 

 

 

3））转换
 

list(容器)
将给定容器转换为列表
 

 

 
 

tuple(容器)
将给定容器转换为元组
 

 

 
 

str(容器)
将给定容器转换为字符串
 

 

 
 

set(容器)
将给定容器转换为集合
 

 
 

4））排序
 

sorted(容器, [reverse=True])
将给定容器进行排序
 

 

 

 

 

注意，排序后都会得到列表（list）对象
 

 

功能总览
 

功能描述
通用for循环遍历容器（字典是遍历key）
max()容器内最大元素
min()容器内最小元素
len()容器元素个数
list()转换为列表
tuple()转换为元组
str()转换为字符串
set()转换为集合
sorted(序列, [reverse=True])排序，reverse=True表示降序 得到一个排好序的列表
 

 

11）字符串比较拓展
 

  1. 字符串的比较：从头到尾，一位位进行比较，其中一位大，后面就无需比较
  2. 单个字符之间确定大小：通过ASCII码表，确定字符对应的码值数字来确定大小
 

# abc和abd比较
print(f"abc < abd,结果是：{'abc' < 'abd'}")
​
# a和ab比较
print(f"a < ab,结果是：{'a' < 'ab'}")
​
# a和A比较
print(f"a > A,结果是：{'a' > 'A'}")
​
# key1和key2比较
print(f"key1 < key2,结果是：{'key1' < 'key2'}")
 

abc < abd,结果是：True
a < ab,结果是：True
a > A,结果是：True
key1 < key2,结果是：True
 


                

        

        

            

            

            

              

                本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2217464.html
              

              如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！
            

            
            

              
            

          


            
相关文章

          
            
                  

                    

                      

                        

                          
                            k8s的安装与部署
                        

                      

                      

                        

                          k8s的安装与部署
                        

                        

                          一、部署 
1、实验环境 
k8s-master172.25.254.200k8s-node1172.25.254.10k8s-node2172.25.254.20docker-node1 172.25.254.100(harbor仓库&#xff09; 
2、相关操作 
1.基础配置 
所有节点关闭selinux和防火墙 
systemctl disabled firewalld
systemctl stop firewalld
grubb…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            商贸物流产业大脑：打造“产-供-销，仓-运-配”全流程供应链
                        

                      

                      

                        

                          商贸物流产业大脑：打造“产-供-销，仓-运-配”全流程供应链
                        

                        

                          商贸物流产业大脑&#xff1a;打造“产-供-销&#xff0c;仓-运-配”全流程供应链 
在全球化竞争日益激烈的今天&#xff0c;商贸物流产业的效率和创新力成为企业能否脱颖而出的关键因素。然而&#xff0c;信息不对称、资源配套不准确、系统独立运作等痛点严重阻碍了商贸物流产…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            # LangGraph 入门（二）- ChatBot demo
                        

                      

                      

                        

                          # LangGraph 入门（二）- ChatBot demo
                        

                        

                          在这个快速入门 demo 中&#xff0c;我们将会使用 langGraph 构建一个基本的对话机器人和可是使用网络搜索的机器人。通过这个 demo 我们来快速对 langgraph 有一定感知。 
概念补充 
顾名思义langGraph是基于图&#xff08;Graph Theory&#xff09;的&#xff0c;如果你学过图…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            【算法】约瑟夫环问题
                        

                      

                      

                        

                          【算法】约瑟夫环问题
                        

                        

                          据说著名的犹太历史学家Josephus有过以下故事&#xff0c; 罗马人占领乔塔帕特&#xff0c; 39个犹太人与Josephus和他的朋友躲在洞中&#xff0c;其中39个犹太人决定自杀&#xff0c; &#xff0c;他们的自杀方式是41个人绕成一圈&#xff0c;第一个人报数1&#xff0c;报数到…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            RK3588的demo板学习
                        

                      

                      

                        

                          RK3588的demo板学习
                        

                        

                          表层的线宽是3.8mil: 换层之后线宽变成了4.2mil:   (说明对于一根线&#xff0c;不同层线宽不同) 经典&#xff1a; 开窗加锡&#xff0c;增强散热&#xff0c;扩大电流&#xff1a; R14的作用&#xff1a;与LDO进行分压&#xff0c;降低LDOP的压差从而减小其散热&#xff1a;第…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            如何系统的从0到1学习大模型？有哪些书籍推荐？
                        

                      

                      

                        

                          如何系统的从0到1学习大模型？有哪些书籍推荐？
                        

                        

                          大模型应用得好&#xff0c;不仅需要海量的基础数据、大规模算力、综合人工智能发展成果的技术&#xff0c;还需要政产学研用各方的共同推进。 
大模型不仅能生成结果、生成数据&#xff0c;更能传递价值观。应用于我国的大模型需要懂中文、懂中国文化、懂中国国情。大模型是全…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            【Linux系统编程】环境基础开发工具使用
                        

                      

                      

                        

                          【Linux系统编程】环境基础开发工具使用
                        

                        

                          目录 
1、Linux软件包管理器yum 
1.1 什么是软件包 
1.2 安装软件 
1.3 查看软件包 
1.4 卸载软件 
2、Linux编辑器-vim 
2.1 vim的概念 
2.2 vim的基本操作 
2.3 vim的配置 
3、Linux编译器-gcc/g 
3.1 gcc编译的过程​编辑​编辑​编辑 
3.2 详解链接 
动态链接 
静态链接 
4…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            纯HTML实现标签页切换
                        

                      

                      

                        

                          纯HTML实现标签页切换
                        

                        

                          纯HTML实现标签页切换 实现原理&#xff1a; 
HTML结构&#xff1a; 使用无序列表&#xff08;<ul>&#xff09;创建标签导航。每个标签是一个列表项&#xff08;<li>&#xff09;&#xff0c;包含一个链接&#xff08;<a>&#xff09;。每个链接指向对应的内…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            商品计划：零售企业的痛点破解与运营优化指南
                        

                      

                      

                        

                          商品计划：零售企业的痛点破解与运营优化指南
                        

                        

                          在现代零售业的激烈竞争中&#xff0c;商品计划不仅是企业盈利的关键&#xff0c;更是解决众多痛点的有效途径。零售企业在运营过程中常常面临各种挑战&#xff0c;如财务问题、库存管理、市场分析等。而科学、系统的商品计划可以帮助企业有效应对这些挑战&#xff0c;提升整体…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            气膜：冰雪产业的创新解决方案—轻空间
                        

                      

                      

                        

                          气膜：冰雪产业的创新解决方案—轻空间
                        

                        

                          随着冰雪运动的普及和发展&#xff0c;如何在不同季节和地区有效开展冰雪项目&#xff0c;成为了行业内的一个重要课题。气膜作为一种新兴的建筑形式&#xff0c;凭借其独特的优势&#xff0c;正在逐渐成为冰雪产业的创新解决方案。 优越的建筑特性 气膜建筑以其轻便、快速搭建…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Web Storage：数据储存机制
                        

                      

                      

                        

                          Web Storage：数据储存机制
                        

                        

                          前言 在HTML5之前&#xff0c;开发人员一般是通过使用Cookie在客户端保存一些简单的信息的。在HTML5发布后&#xff0c;提供了一种新的客户端本地保存数据的方法&#xff0c;那就是Web Storage&#xff0c;它也被分为&#xff1a;LocalStorage和SessionStorage&#xff0c;它允…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            【黑马redis高级篇】持久化
                        

                      

                      

                        

                          【黑马redis高级篇】持久化
                        

                        

                          //来源[01,05]分布式缓存 除了黑马&#xff0c;还参考了别的。  目录 1.单点redis问题及解决方案2.为什么需要持久化&#xff1f;3.Redis持久化有哪些方式呢&#xff1f;为什么我们需要重点学RDB和AOF&#xff1f;4.RDB4.1 定义4.2 触发方式4.2.1手动触发save4.2.2被动触发bgsa…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            软件工程：需求规格说明书（图书管理系统）
                        

                      

                      

                        

                          软件工程：需求规格说明书（图书管理系统）
                        

                        

                          目录 
1 导言 
1.1 编写目的 
1.2 参考资料 
2 项目介绍 
2.1 项目背景 
2.2 项目目标 
3 应用环境 
3.1 系统运行网络环境      ​编辑 
3.2 系统软硬件环境 
4 功能模型 
4.1 功能角色分析 
4.1.1 图书管理员 
4.1.2 普通读者 
4.1.3 邮件系统 
4.2 功能性需求 
4.2.1 预定图…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            AI+Xmind彻底解决你的思维导图
                        

                      

                      

                        

                          AI+Xmind彻底解决你的思维导图
                        

                        

                          在写作领域、老师授课、产品经理等都会使用到思维导图&#xff0c;如果是一个个拖拉撰写太麻烦了。 
本篇内容小索奇就教会大家利用AI结合Xmind制作思维导图。 
先打开我们的AI软件 这里小索奇用ChatGPT&#xff08;可以使用kimi&#xff0c;豆包等大模型都可以&#xff09; 
P…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            中小型医院网站开发：Spring Boot入门
                        

                      

                      

                        

                          中小型医院网站开发：Spring Boot入门
                        

                        

                          2 相关技术简介 2.1 Java技术 Java是一种非常常用的编程语言&#xff0c;在全球编程语言排行版上总是前三。在方兴未艾的计算机技术发展历程中&#xff0c;Java的身影无处不在&#xff0c;并且拥有旺盛的生命力。Java的跨平台能力十分强大&#xff0c;只需一次编译&#xff0c;…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            上市公司资产误定价Misp计算数据-含参考资料及代码（2006-2023年）
                        

                      

                      

                        

                          上市公司资产误定价Misp计算数据-含参考资料及代码（2006-2023年）
                        

                        

                          数据说明&#xff1a;参考《经济研究》期刊游家兴&#xff08;2012&#xff09;老师的做法&#xff0c;先根据行业内所有公司推算出公司的基础价值&#xff0c;进而通过对公司的实际价值与基础价值进行对比&#xff0c; 来衡量公司相对于业内同行的误定价水平&#xff0c;具体大…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            D39【python 接口自动化学习】- python基础之函数
                        

                      

                      

                        

                          D39【python 接口自动化学习】- python基础之函数
                        

                        

                          day39 函数的返回值 
学习日期&#xff1a;20241016 
学习目标&#xff1a;函数&#xfe63;-52 函数的返回值&#xff1a;如何得到函数的执行结果&#xff1f; 
学习笔记&#xff1a; 
return语句 返回值类型 def foo():return abc
var foo()
print(var) #abc# 函数中return函…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            python实现录屏功能
                        

                      

                      

                        

                          python实现录屏功能
                        

                        

                          python实现录屏功能 将生成的avi文件转为mp4格式后删掉avi文件 参考感谢&#xff1a;https://www.cnblogs.com/peachh/p/16549254.html import os
import cv2
import time
import threading
import numpy as np
from PIL import ImageGrab
from pynput import keyboard
from da…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            统一认证与单点登录：简化用户体验的关键解决方案
                        

                      

                      

                        

                          统一认证与单点登录：简化用户体验的关键解决方案
                        

                        

                          引言 
在数字化时代&#xff0c;企业往往需要管理多个应用和系统&#xff0c;随之而来的是用户密码和身份认证管理的复杂性。统一认证&#xff08;Single Sign-On, SSO&#xff09;作为一种身份管理解决方案&#xff0c;不仅可以减少用户在多个系统间切换登录的麻烦&#xff0c…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            选择合适的SSL证书
                        

                      

                      

                        

                          选择合适的SSL证书
                        

                        

                          随着我们在线业务的增长&#xff0c;确保网站安全变得越来越重要。对于许多人来说&#xff0c;保护网站安全的想法似乎令人望而生畏&#xff0c;尤其是在有各种SSL证书可用的情况下。您可能想知道哪一个最适合您的业务需求或如何浏览这些选项。 
除了SSL证书之外&#xff0c;使…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
       
      
        

        

          

            



                
                
                

            

          

          

            



              
推荐文章

              
            

          


          

            


                
                
                
            

          

          

            

              
最新文章

              
            

          

          

            

            
            
            
            

          

        

      

    

    

      

        

                    Copyright @ 2022~2023