5.Python 数据容器(list 列表、tuple 元组、str 字符串、set 集合、dict(字典)、序列切片)

一、数据容器概述

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

  • 数据容器根据特点的不同,如:是否支持重复元素、是否可以修改、是否有序等,分为 5 类,分别是:列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)


二、list 列表

1、列表的特点
  1. 可以容纳多个元素,上限为 2**63-1(9223372036854775807) 个

  2. 可以容纳不同类型的元素(混装)

  3. 数据是有序存储的(支持下标索引)

  4. 允许重复数据存在

  5. 可以修改(增加或删除元素等)

  6. 支持 for 循环和 while 遍历

2、列表的定义
(1)基本格式
  • 定义字面量
python 复制代码
[【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...]
  • 定义变量
python 复制代码
【变量名】 = [【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...]
  • 定义空列表
python 复制代码
【变量名】 = []
python 复制代码
# 或
【变量名】 = list()
(2)解析
  • 列表元组使用 [],且使用逗号(,)隔开各个元素,元素可以是不同的数据类型
(3)基本使用
python 复制代码
list1 = ["jack", "smith", "tom"]

print(list1)
print(type(list1))

print("------------------------------")

list2 = ["Hello World", 123, True]

print(list2)
print(type(list2))

print("------------------------------")

# 定义嵌套列表
list3 = [[1, 2, 3], [4, 5, 6]]

print(list3)
print(type(list3))
  • 输出结果

    ['jack', 'smith', 'tom']
    <class 'list'>

    ['Hello World', 123, True]
    <class 'list'>

    [[1, 2, 3], [4, 5, 6]]
    <class 'list'>

3、列表的下标索引
(1)基本介绍
  • 列表中的每一个元素,都有其位置下标索引,从前向后的方向,从 0 开始,依次递增,只需要按照下标索引,即可取得对应位置的元素
- 元素 1 元素 2 元素 3 元素 4 元素 5
索引 0 1 2 3 4
  • 或者,可以反向索引,也就是从后向前,从 -1 开始,依次递减
- 元素 1 元素 2 元素 3 元素 4 元素 5
索引 -5 -4 -3 -2 -1
  • 如果列表是嵌套的列表,同样支持下标索引
- 元素 1 元素 2 元素 3 元素 4 元素 5
二层索引 0 1 0 1 2
一层索引 - 0 - - 1
(2)列表元素取出
python 复制代码
【列表】[【下标】]
  • 嵌套列表元素取出
python 复制代码
【列表】[【下标】][【下标】]
(3)基本使用
python 复制代码
list1 = ["jack", "smith", "tom"]
print(list1[0])
print(list1[1])
print(list1[2])

print("------------------------------")

print(list1[-1])
print(list1[-2])
print(list1[-3])

print("------------------------------")

list2 = [[1, 2, 3], [4, 5, 6]]
print(list2[0])
print(list2[1][1])
  • 输出结果

    jack
    smith
    tom

    tom
    smith
    jack

    [1, 2, 3]
    5

5、列表方法引入
(1)列表方法概述
  • 列表除了可以定义和使用下标索引获取值以外,列表也提供了一系列功能,如插入元素、删除元素、清空列表、修改元素、统计元素个数等等,这些功能都称之为列表的方法

  • 函数是一个封装的代码单元,可以提供特定功能,在 Python 中,如果将函数定义为 class(类)的成员,那么函数会称之为方法

  • 函数与方法功能一样,有传入参数,有返回值,只是使用格式不同

(2)函数与方法的使用
  • 函数的使用
python 复制代码
def add(num1, num2):
    return num1 + num2

print(add(10, 20)) # 30
  • 方法的使用
python 复制代码
class Calculator:

    def add(self, num1, num2):
        return num1 + num2

calculator = Calculator()
print(calculator.add(30, 40)) # 70
5、列表的常用操作方法
(1)基本介绍
方法 说明
【列表】.index(【元素】) 查找指定元素的下标,找不到则报错
len(【列表】) 统计列表内有多少元素
【列表】.count(【元素】) 统计指定元素在列表中出现的次数
【列表】.insert(【下标】, 【元素】) 在指定下标处,插入指定元素
【列表】.append(【元素】) 向列表末尾追加一个元素
【列表】.extend(【数据容器】) 将数据容器的元素依次取出,追加到列表尾部
del 【列表】[【下标】] 删除列表中指定下标的元素
【列表】.pop(【下标】) 删除列表中指定下标的元素
【列表】.remove(【元素】) 删除列表中指定元素的第一个匹配项
【列表】.clear() 清空列表
(2)基本使用
python 复制代码
name_list = ["jack", "smith", "tom"]
print(name_list)

# 列表的查询
print("列表的查询 ------------------------------")

print("index:", name_list.index("jack"))

print("len:", len(name_list))

print("count:", name_list.count("tom"))

# 列表的修改
print("列表的修改 ------------------------------")

name_list[1] = "mery"
print(name_list)

name_list.insert(1, "jerry")
print("insert -----", name_list)

name_list.append("david")
print("append:", name_list)

name_list.extend(["zhangsan", "lsii"])
print("extend:", name_list)

del name_list[-1]
print("del:", name_list)

name_list.pop(-1)
print("pop:", name_list)

name_list.remove("jerry")
print("remove:", name_list)

name_list.clear()
print("clear:", name_list)
  • 输出结果

    ['jack', 'smith', 'tom']
    列表的查询 ------------------------------
    index: 0
    len: 3
    count: 1
    列表的修改 ------------------------------
    ['jack', 'mery', 'tom']
    insert ----- ['jack', 'jerry', 'mery', 'tom']
    append: ['jack', 'jerry', 'mery', 'tom', 'david']
    extend: ['jack', 'jerry', 'mery', 'tom', 'david', 'zhangsan', 'lsii']
    del: ['jack', 'jerry', 'mery', 'tom', 'david', 'zhangsan']
    pop: ['jack', 'jerry', 'mery', 'tom', 'david']
    remove: ['jack', 'mery', 'tom', 'david']
    clear: []

6、列表的遍历
(1)概述
  • 将容器内的元素依次取出进行处理的行为称之为遍历或迭代
(2)遍历的方式
  • while 循环
  1. 定义一个变量表示下标,从 0 开始

  2. 循环条件为:【下标】 < 【列表的元素数量】

  3. 取出列表的元素方式为:【列表】[【下标】]

  • for 循环(for 循环更加适合对列表等数据容器进行遍历)
python 复制代码
for 【临时变量】 in 【数据容器】: 
    【执行的代码块】
  1. 从容器内,依次取出元素并赋值到临时变量上

  2. 在每一次的循环中,可以对临时变量(元素)进行处理

(3)具体实现
python 复制代码
name_list = ["jack", "tom", "smith"]

print("for 循环遍历 ------------------------------")

for x in name_list:
    print(x)

print("while 循环遍历 ------------------------------")

index = 0
while index < len(name_list):
    print(name_list[index])
    index += 1
  • 输出结果

    for 循环遍历 ------------------------------
    jack
    tom
    smith
    while 循环遍历 ------------------------------
    jack
    tom
    smith

(4)while 循环和 for 循环对比
条件 对比
在循环控制上 while 循环可以自定循环条件,并自行控制 for 循环不可以自定循环条件,只可以一个个从容器内取出数据
在无限循环上 while 循环可以通过条件控制做到无限循环 for 循环理论上不可以,因为被遍历的容器容量不是无限的
在使用场景上 while 循环适用于任何想要循环的场景 for 循环适用于遍历数据容器的场景或简单的固定次数循环场景

三、tuple 元组

1、元组的特点
  1. 可以容纳多个元素

  2. 可以容纳不同类型的元素(混装)

  3. 数据是有序存储的(支持下标索引)

  4. 允许重复数据存在

  5. 不可以修改(增加或删除元素等)

  6. 支持 for 循环和 while 遍历

  • 多数特性和列表一致,不同点在于不可修改
2、元组的定义
(1)基本格式
  • 定义字面量
python 复制代码
(【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...)
  • 定义变量
python 复制代码
【变量名】 = (【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...)
  • 定义空元组
python 复制代码
【变量名】 = ()
python 复制代码
【变量名】 = ()
  • 定义一个元素的元组
python 复制代码
# 或
【变量名】 = (【元素】, ) # 元组只有一个元素,这个元素后面要添加逗号
(2)解析
  • 定义元组使用 (),且使用逗号(,)隔开各个元素,元素可以是不同的数据类型
(3)基本使用
python 复制代码
tuple1 = ("jack", "smith", "tom")

print(tuple1)
print(type(tuple1))

print("------------------------------")

tuple2 = ("Hello World", 123, True)

print(tuple2)
print(type(tuple2))

print("------------------------------")

# 定义嵌套元组
tuple3 = ((1, 2, 3), (4, 5, 6))

print(tuple3)
print(type(tuple3))

print("------------------------------")

# 定义一个元素的元组
tuple4 = ("Hello World", )

print(tuple4)
print(type(tuple4))
  • 输出结果

    ('jack', 'smith', 'tom')
    <class 'tuple'>

    ('Hello World', 123, True)
    <class 'tuple'>

    ((1, 2, 3), (4, 5, 6))
    <class 'tuple'>

    ('Hello World',)
    <class 'tuple'>

3、元组的下标索引
  • 同列表
4、元组的常用操作方法
(1)基本介绍
方法 说明
【元组】.index(【元素】) 查找指定元素的下标,找不到则报错
len(【元组】) 统计元组内有多少元素
【元组】.count(【元素】) 统计指定元素在元组中出现的次数
  • 注:由于元组不可修改的特性,所以其操作方法非常少
(2)基本使用
python 复制代码
name_tuple = ("jack", "smith", "tom")
print(name_tuple)

# 元组的查询
print("元组的查询 ------------------------------")

print("index:", name_tuple.index("jack"))

print("count:", name_tuple.count("tom"))

print("len:", len(name_tuple))
  • 输出结果

    ('jack', 'smith', 'tom')
    元组的查询 ------------------------------
    index: 0
    count: 1
    len: 3

5、元组的遍历
  • 同列表
6、元组的注意事项
  • 不可以修改元组的内容,否则会直接报错
python 复制代码
tuple1 = (1, 2, 3)

tuple1[0] = 10 # 报错
  • 可以修改元组内的 list 的内容
python 复制代码
tuple2 = (1, 2, [3, 4])

print(tuple2) # (1, 2, [3, 4])

tuple2[2][0] = 10
print(tuple2) # (1, 2, [10, 4])
  • 不可以替换元组内的 list 为其它 list 或其它类型
python 复制代码
tuple3 = (1, 2, [3, 4])

tuple3[2] = [5, 6] # 报错

四、str 字符串

1、再认字符串
  • 字符串同样也是数据容器的一员,字符串是字符的容器,一个字符串可以存放任意数量的字符,如,字符串"Hello World"
- H e l l o W o r l d
索引 0 1 2 3 4 5 6 7 8 9 10
2、字符串的特点
  1. 只可以存储字符串

  2. 长度任意(取决于内存大小)

  3. 支持下标索引

  4. 在内部允许重复字符串存在

  5. 不可以修改(增加或删除元素等)

  6. 支持遍历

3、字符串的下标索引
  • 同列表和元组
4、字符串的常用操作方法
(1)基本介绍
方法 说明
【字符串】.index(【指定字符串】) 查找指定字符串的下标,找不到则报错
【字符串】.replace(【指定字符串 1】, 【指定字符串 2】) 将字符串内的指定字符串 1,替换为指定字符串 2 不会修改原字符串,而是得到一个新的字符串
【字符串】.split(【指定字符串】) 按照指定字符串,对字符串进行分隔 不会修改原字符串,而是得到一个新的列表
【字符串】.strip() 【字符串】.strip(【指定字符串】) 移除首尾的空格和换行符 移除首尾的指定字符串,按照指定字符串的单个字符来确定移除 不会修改原字符串,而是得到一个新的字符串
【字符串】.count(【指定字符串】) 统计指定字符串在字符串中出现的次数
len(【字符串】) 统计字符串的字符个数
【字符串】.splitlines(【keepends】) 按行(\r、\r\n、\n)分割,返回一个以各行作为元素的列表 keepends 默认为 False,不包含换行符,为 True 则保留换行符
(2)基本使用
python 复制代码
my_str1: Hello And World
my_str2:   Hello And World  
my_str3: 12Hello And World21
my_str4: Hello
123

------------------------------
my_str1 - index: 6
my_str1 - replace: Hello And Python
my_str1 - split: ['Hello', 'And', 'World']
my_str2 - strip: Hello And World
my_str3 - strip: Hello And World
my_str1 - count: 3
my_str1 - splitlines: ['Hello', 'World', '123']
len - my_str1: 15
  • 输出结果

    my_str1: Hello And World
    my_str2: Hello And World
    my_str3: 12Hello And World21
    my_str4: Hello
    123


    my_str1 - index: 6
    my_str1 - replace: Hello And Python
    my_str1 - split: ['Hello', 'And', 'World']
    my_str2 - strip: Hello And World
    my_str3 - strip: Hello And World
    my_str1 - count: 3
    my_str1 - splitlines: ['Hello', 'World', '123']
    len - my_str1: 15

5、字符串的遍历
  • 同列表和元组
6、字符串的注意事项
  • 不可以修改字符串的内容,否则会直接报错
python 复制代码
my_str = "Hello World"

my_str[0] = "A" # 报错

五、序列切片

1、概述
(1)序列概述
  • 序列是指内容连续、有序,可使用下标索引的一类数据容器,列表、元组、字符串,均可以可以视为序列
(2)切片概述
  • 序列支持切片,即列表、元组、字符串,均支持进行切片操作

  • 切片操作是从一个序列中,取出一个子序列

2、基本格式
  • 从指定位置开始,依次取出元素,到指定位置结束,得到一个新序列
python 复制代码
【序列】[【起始下标】:【结束下标(不含)】:【步长】]
参数 说明
起始下标 表示从何处开始,可以留空,留空视作从头开始
结束下标(不含) 表示何处结束,可以留空,留空视作取到结尾
步长 表示依次取元素的间隔,可以留空,留空视作 1
步长 说明
1 表示一个个取
2 表示每次跳过 1 个元素取
N 表示每次跳过 N-1 个元素取
负数 表示反向取,此时起始下标和结束下标也要反向标记
  • 注:切片操作不会影响序列本身,而是会得到一个新的序列
3、基本使用
python 复制代码
my_list = [0, 1, 2, 3, 4, 5, 6]
print("my_list:", list)

print("对 list 进行切片")

# 对 list 进行切片,从下标 1 开始,到下标 4 结束,步长为 1
new_list1 = my_list[1:4]
print("new_list1:", new_list1)

# 对 list 进行切片,从下标 3 开始,到下标 1 结束,步长为 -1
new_list2 = my_list[3:1:-1]
print("new_list1:", new_list2)

print("------------------------------")

my_tuple = [0, 1, 2, 3, 4, 5, 6]
print("my_tuple:", list)

print("对 tuple 进行切片")

# 对 tuple 进行切片,从头开始,到尾结束,步长为 1
new_tuple1 = my_tuple[:]
print("new_tuple1:", new_tuple1)

# 对 tuple 进行切片,从头开始,到尾结束,步长为 -2
new_tuple2 = my_tuple[::-2]
print("new_tuple2:", new_tuple2)

print("------------------------------")

my_str = "0123456"
print("my_str:", my_str)

print("对 str 进行切片")

# 对 str 进行切片,从头开始,到尾结束,步长为 2
new_str1 = my_str[::2]
print("new_str1:", new_str1)

# 对 str 进行切片,从头开始,到尾结束,步长为 -1
# 等同于将序列反转
new_str2 = my_str[::-1]
print("new_str2:", new_str2)
  • 输出结果

    my_list: <class 'list'>
    对 list 进行切片
    new_list1: [1, 2, 3]
    new_list1: [3, 2]

    my_tuple: <class 'list'>
    对 tuple 进行切片
    new_tuple1: [0, 1, 2, 3, 4, 5, 6]
    new_tuple2: [6, 4, 2, 0]

    my_str: 0123456
    对 str 进行切片
    new_str1: 0246
    new_str2: 6543210


六、set 集合

1、集合的特点
  1. 可以容纳多个元素

  2. 可以容纳不同类型的元素(混装)

  3. 数据是无序存储的(不支持下标索引)

  4. 不允许重复数据存在

  5. 可以修改(增加或删除元素等)

  6. 支持 for 循环遍历,因为不支持下标索引,所以不支持 while 循环遍历

2、集合的定义
(1)基本格式
  • 定义字面量
python 复制代码
{【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...}
  • 定义变量
python 复制代码
【变量名】 = {【元素 1】, 【元素 2】, 【元素 3】, 【元素 4】...}
  • 定义空集合
python 复制代码
【变量名】 = set()
(2)解析
  • 定义集合使用 {},且使用逗号(,)隔开各个元素,元素有类型限制
(3)基本使用
python 复制代码
set1 = {"jack", "smith", "tom", "jack", "smith", "tom"}

print(set1)
print(type(set1))
  • 输出结果

    {'tom', 'smith', 'jack'}
    <class 'set'>

3、集合的常用操作方法
(1)基本介绍
方法 说明
【集合】.add(【元素】) 向集合内添加一个元素,集合本身被修改
【集合】.remove(【元素】) 移除集合内指定的元素,集合本身被修改
【集合】.pop() 从集合中随机取出一个元素,集合本身被修改
len(【集合】) 统计集合的元素个数
【集合】.clear() 清空集合,集合本身被修改
【集合 1】.difference(【集合 2】) 得到集合 1 和集合 2 的差集(集合 1 有而集合 2 没有的) 得到一个新集合,集合 1 和集合 2 不变
【集合 1】.difference_update(【集合 2】) 在集合 1 中删除集合 2 中存在的元素,集合 1 被修改,集合 2 不变
【集合 1】.union(【集合 2】) 得到一个新集合,内含集合 1 和集合 2 的全部元素,集合 1 和集合 2 不变
(2)基本使用
python 复制代码
my_set1 = {1, 2, 3, 4, 5}
my_set2 = {4, 5, 6, 7, 8}
my_set3 = {"jack", "tom", "smith"}

print("my_set1:", my_set1)
print("my_set2:", my_set2)
print("my_set3:", my_set3)

print("------------------------------")

my_set1.add(10)
print("my_set1 - add:", my_set1)

my_set1.remove(1)
print("my_set1 - remove:", my_set1)

element = my_set1.pop()
print("my_set1 - pop:", my_set1)

print("len - my_set1:", len(my_set1))

my_set3.clear()
print("my_set3 - clear:", my_set3)

print("difference ------------------------------")

new_set1 = my_set1.difference(my_set2)
print("new_set1:", new_set1)
print("my_set1:", my_set1)
print("my_set2:", my_set2)

print("difference_update ------------------------------")

my_set1.difference_update(my_set2)
print("my_set1:", my_set1)
print("my_set2:", my_set2)

print("union ------------------------------")

new_set2 = my_set1.union(my_set2)
print("new_set2:", new_set2)
print("my_set1:", my_set1)
print("my_set2:", my_set2)
  • 输出结果

    my_set1: {1, 2, 3, 4, 5}
    my_set2: {4, 5, 6, 7, 8}
    my_set3: {'jack', 'smith', 'tom'}

    my_set1 - add: {1, 2, 3, 4, 5, 10}
    my_set1 - remove: {2, 3, 4, 5, 10}
    my_set1 - pop: {3, 4, 5, 10}
    len - my_set1: 4
    my_set3 - clear: set()
    difference ------------------------------
    new_set1: {10, 3}
    my_set1: {3, 4, 5, 10}
    my_set2: {4, 5, 6, 7, 8}
    difference_update ------------------------------
    my_set1: {3, 10}
    my_set2: {4, 5, 6, 7, 8}
    union ------------------------------
    new_set2: {3, 4, 5, 6, 7, 8, 10}
    my_set1: {3, 10}
    my_set2: {4, 5, 6, 7, 8}


七、dict(字典)

1、字典的特点
  • 生活中的字典是通过字去找到对应的含义,Python 中的字典是通过 key 去找到对应 value
  1. 可以容纳多个数据

  2. 可以容纳不同类型的数据

  3. 每一份数据是 key value 键值对

  4. 可以通过 key 获取到 value,key 不可重复(重复会覆盖)

  5. 不支持下标索引

  6. 可以修改,支持 for 循环,不支持 while 循环

2、字典的定义
(1)基本格式
  • 定义字面量
python 复制代码
{【key 1】: 【value 1】, 【key 2】: 【value 2】, 【key 3】: 【value 3】...}
  • 定义变量
python 复制代码
【变量名】 = {【key 1】: 【value 1】, 【key 2】: 【value 2】, 【key 3】: 【value 3】...}
  • 定义空字典
python 复制代码
【变量名】 = {}
python 复制代码
# 或
【变量名】 = dist()
(2)解析
  • 定义字典使用大括号({}),且使用逗号(,)隔开各个元素

  • 每一个元素是一个键值对,每一个键值对包含 key 和 value,用冒号(:)分隔

  • key 和 value 可以是任意类型的数据,所以字典可以嵌套,但 key 不可为字典

  • key 不可重复,重复会对原有数据进行覆盖

(3)基本使用
python 复制代码
dist1 = {1: "jack", 2: "smith", 3: "tom"}

print(dist1)
print(type(dist1))

print("------------------------------")

# 定义嵌套字典
dist2 = {
    "jack": {"age": 18, "height(cm)": 170},
    "smith": {"age": 20, "height(cm)": 180},
    "tom": {"age": 25, "height(cm)": 175}
}

print(dist2)
print(type(dist2))
  • 输出结果

    {1: 'jack', 2: 'smith', 3: 'tom'}
    <class 'dict'>

    {'jack': {'age': 18, 'height(cm)': 170}, 'smith': {'age': 20, 'height(cm)': 180}, 'tom': {'age': 25, 'height(cm)': 175}}
    <class 'dict'>

3、字典元素的获取
(1)基本介绍
python 复制代码
【字典】[【key】]
  • 字典同集合一样,不可以使用下标索引,但是字典可以通过 key 来取得对应的 value
(2)基本使用
python 复制代码
dist1 = {1: "jack", 2: "smith", 3: "tom"}

print(dist1[1])
print(dist1[3])

print("------------------------------")

# 定义嵌套字典
dist2 = {
    "jack": {"age": 18, "height(cm)": 170},
    "smith": {"age": 20, "height(cm)": 180},
    "tom": {"age": 25, "height(cm)": 175}
}

print(dist2["jack"])
print(dist2["tom"])

print(dist2["smith"]["age"])
print(dist2["tom"]["age"])
  • 输出结果

    jack
    tom

    {'age': 18, 'height(cm)': 170}
    {'age': 25, 'height(cm)': 175}
    20
    25

4、字典的常用操作方法
(1)基本介绍
方法 说明
【字典】[【key】] = 【value】 新增 / 修改元素
【字典】.pop(key) 删除元素,获取指定 key 对应的 value
【字典】.clear() 清空元素
【字典】.keys() 获取全部的 key
len(【字典】) 获取字典内的元素数量
(2)基本使用
python 复制代码
stu_score = {
    "jack": 50,
    "tom": 60,
    "smith": 70,
}

print(stu_score)

print("新增 / 修改元素 ------------------------------")

stu_score["jerry"] = 80
print(stu_score)

stu_score["jerry"] = 90
print(stu_score)

print("删除元素 ------------------------------")

print(stu_score.pop("jerry"))
print(stu_score)

print("获取全部的 key ------------------------------")

keys = stu_score.keys()
print(keys)

print("获取字典内的元素数量 ------------------------------")

print(len(stu_score))

print("清空元素 ------------------------------")

stu_score.clear()
print(stu_score)
  • 输出结果

    {'jack': 50, 'tom': 60, 'smith': 70}
    新增 / 修改元素 ------------------------------
    {'jack': 50, 'tom': 60, 'smith': 70, 'jerry': 80}
    {'jack': 50, 'tom': 60, 'smith': 70, 'jerry': 90}
    删除元素 ------------------------------
    90
    {'jack': 50, 'tom': 60, 'smith': 70}
    获取全部的 key ------------------------------
    dict_keys(['jack', 'tom', 'smith'])
    获取字典内的元素数量 ------------------------------
    3
    清空元素 ------------------------------
    {}

5、字典的遍历
(1)基本介绍
  1. 通过获取到全部的 key 来完成遍历

  2. 直接对字进行 for 循环,每一次环都是直接得到 key

(2)基本使用
python 复制代码
stu_score = {
    "jack": 50,
    "tom": 60,
    "smith": 70,
}

for key in stu_score.keys():
    print(f"{key}: {stu_score[key]}")

print("------------------------------")

for key in stu_score:
    print(f"{key}: {stu_score[key]}")
  • 输出结果

    jack: 50
    tom: 60
    smith: 70

    jack: 50
    tom: 60
    smith: 70


八、数据容器对比

1、数据容器分类
  • 是否支持下标索引
  1. 支持:列表、元组、字符串 - 序列类型

  2. 不支持:集合、字典 - 非序列类型

  • 是否支持重复元素
  1. 支持:列表、元组、字符串 - 序列类型

  2. 不支持:集合、字典 - 非序列类型

  • 是否可以修改
  1. 支持:列表、集合、字典

  2. 不支持:元组、字符串

2、数据容器特点对比
- 元素类型 下标索引 重复元素 可修改 元素有序 使用场景
列表 任意类型 支持 支持 一批可修改、可重复的数据
元素 任意类型 支持 支持 一批不可修改、可重复的数据
字符串 仅字符类型 支持 支持 一串字符
集合 任意类型 不支持 不支持 一批不可重复的数据
字典 key:除字典外任意类型 value:任意类型 不支持 不支持 一批键值对数据
相关推荐
非概念几秒前
stm32学习笔记----51单片机和stm32单片机的区别
笔记·stm32·单片机·学习·51单片机
封步宇AIGC12 分钟前
量化交易系统开发-实时行情自动化交易-3.4.1.2.A股交易数据
人工智能·python·机器学习·数据挖掘
何曾参静谧13 分钟前
「Py」Python基础篇 之 Python都可以做哪些自动化?
开发语言·python·自动化
Prejudices17 分钟前
C++如何调用Python脚本
开发语言·c++·python
我狠狠地刷刷刷刷刷29 分钟前
中文分词模拟器
开发语言·python·算法
Jam-Young43 分钟前
Python的装饰器
开发语言·python
Mr.咕咕1 小时前
Django 搭建数据管理web——商品管理
前端·python·django
韭菜盖饭1 小时前
LeetCode每日一题3261---统计满足 K 约束的子字符串数量 II
数据结构·算法·leetcode
AnFany1 小时前
LeetCode【0028】找出字符串中第一个匹配项的下标
python·算法·leetcode·字符串·kmp·字符串匹配
无敌最俊朗@1 小时前
stm32学习之路——八种GPIO口工作模式
c语言·stm32·单片机·学习