Python学习路线 - Python语言基础入门 - 数据容器

数据容器入门

为什么学习数据容器

思考一个问题：如果我想要在程序中，记录5名学生的信息，如姓名。
如何做呢？

数据容器

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

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

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

分为5类，分别是：
列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)

总结：
1.什么是数据容器？
一种可以存储多个元素的Python数据类型
2.Python有哪些数据容器？
list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)
它们各有特点，但都满足可容纳多个元素的特性。

数据容器：list(列表)

列表的定义

基本语法：

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

• 已 [] 作为标识
• 列表内每一个元素之间用，逗号隔开

列表的定义方式：

案例演示：使用[]的方式定义列表

嵌套列表的定义

注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

代码元素：

"""
演示数据容器之：list列表
语法：[元素，元素，....]
"""

# 定义一个列表list
mu_list = ["mry", "study", "python"]
print(mu_list)
print(type(mu_list))

mu_list = ["mry", 123456, True]
print(mu_list)
print(type(mu_list))

# 定义一个嵌套的列表
mu_list = [[1,2,3],[4,5,6]]
print(mu_list)
print(type(mu_list))

总结：
1.列表的定义语法
[元素1, 元素2, 元素3, …]
2.什么是元素？
数据容器内的每一份数据，都称之为元素
3.元素的类型有限制吗？
元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

列表的下标索引

列表的下标(索引)

如何从列表中取出特定位置的数据呢？
我们可以使用：下标索引

如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增
我们只需要按照下标索引，即可取得对应位置的元素。

列表的下标(索引) - 反向

或者，可以反向索引，也就是从后向前：从-1开始，依次递减(-1、-2、-3…)

如图，从后向前，下标索引为：-1、-2、-3，依次递减。

嵌套列表的下标(索引)

如果列表是嵌套的列表，同样支持下标索引

如图，下标就有2个层级了。

代码示例：

"""
演示数据容器之：list列表
语法：[元素，元素，....]
"""

# 通过下标索引取出对应位置的数据
my_list = ["Tom","Lily","Rose"]
# 列表[下标索引]，从前向后从0开始，每次+1，从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范：通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据(倒序取出)
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表的元素
my_list = [[1,2,3],[4,5,6]]
print(my_list[1][1])

总结：
1.列表的下标索引是什么？
列表的每一个元素，都有编号称之为下标索引
从前向后的方向，编号从0开始递增
从后向前的方向，编号从-1开始递减

2.如何通过下标索引取出对应位置的元素呢？
列表[下标]，即可取出
3.下标索引的注意事项：
要注意下标索引的取值范围，超出范围无法取出元素，并且会报错

列表的常用操作

列表的常用操作(方法)

列表除了可以：

• 定义
• 使用下标索引获取值

以外，列表也提供了一系列功能：

• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数

等等功能，这些功能我们都称之为：列表的方法

列表的查询功能(方法)

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

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：
函数的使用：

方法的使用：

• 查找某元素的下标
  功能：查找指定元素在列表的下标，如果找不到，报错ValueError
  语法：列表.index(元素)
  index就是列表对象(变量)内置的方法(函数)

列表的修改功能(方法)

• 修改特定位置(索引)的元素值：
  语法：列表[下标] = 值
  可以使用如上语法，直接对指定下标(正向、反向下标均可)的值进行：重新赋值(修改)
  

• 插入元素
  语法：列表.insert(下标,元素)，在指定的下标位置，插入指定的元素

• 追加元素
  语法：列表.append(元素)，将指定元素，追加到列表的尾部
  

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

• 删除元素
  语法1：del列表[下标]
  语法2：列表.pop(下标)
  

• 删除某元素在列表种的第一匹配项
  语法：列表.remove(元素)
  

• 清空列表内容
  语法：列表.clear()
  

• 统计某元素在列表内的数量
  语法：列表.count(元素)
  

列表的查询功能(方法)

• 统计列表内，有多少元素
  语法：len(列表)
  可以得到一个int数字，表示列表内的元素数量
  

代码示例：

"""
演示数据容器之：list列表的常用操作
"""
mylist = ["myr","study","python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("study")
print(f"study在列表种的下标索引值是：{index}")

# 1.2 如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表种的下标索引值是：{index}")

# 2. 修改特定下标索引的值
mylist[0] = "Tom"
print(f"列表被修改元素值后，结果是：{mylist}")

# 3. 在指定下标位置插入新元素
mylist.insert(1,"best")
print(f"列表插入元素后，结果是：{mylist}")

# 4. 在列表的尾部追加'''单个'''新元素
mylist.append("start")
print(f"列表被修改元素值后，结果是：{mylist}")

# 5. 在列表的尾部追加'''一批'''新元素
mylist2 = [1,2,3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")

# 6. 删除指定下标索引的元素(2种方式)
mylist = ["myr","study","python"]

# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")

# 6.2 方式2：列表.pop(下标)
mylist = ["myr","study","python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}，取出的元素是：{element}")

# 7. 删除某元素在列表种的第一个匹配项
mylist = ["myr","study","myr","study","python"]
mylist.remove("study")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")

# 8. 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")

# 9. 统计列表内某元素的数量
mylist = ["myr","study","myr","study","python"]
count = mylist.count("study")
print(f"列表种study的数量是：{count}")

# 10. 统计列表种全部的元素数量
mylist = ["myr","study","myr","study","python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

运行结果：

D:\python\python-learn\venv\Scripts\python.exe D:\python\python-learn\44_list列表的常用操作.py 
study在列表种的下标索引值是：1
列表被修改元素值后，结果是：['Tom', 'study', 'python']
列表插入元素后，结果是：['Tom', 'best', 'study', 'python']
列表被修改元素值后，结果是：['Tom', 'best', 'study', 'python', 'start']
列表在追加了一个新的列表后，结果是：['Tom', 'best', 'study', 'python', 'start', 1, 2, 3]
列表删除元素后结果是：['myr', 'study']
通过pop方法取出元素后列表内容：['myr', 'study']，取出的元素是：python
通过remove方法移除元素后，列表的结果是：['myr', 'myr', 'study', 'python']
列表被清空了，结果是：[]
列表种study的数量是：2
列表的元素数量总共有：5个

进程已结束，退出代码为 0

总结：

列表的特点

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

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

练习案例：常用功能练习

有一个列表，内容是：[21,25,21,23,22,20]，记录的是一批学生的年龄

请通过列表的功能(方法)，对其进行
1.定义这个列表，并用变量接收它
2.追加一个数字31，到列表的尾部
3.追加一个新列表[29，33，30]，到列表的尾部
4.取出第一个元素(应是：21)
5.取出最后一个元素(应是：30)
6.查找元素31，在列表种的下标位置

"""
列表常用功能练习
"""

mylist = [21,25,21,23,22,20]
mylist.append(31)
mylist.extend([29,33,30])
print(f"列表内容是：{mylist}")
element = mylist[0]
print(f"列表第一个元素是：{element}")
element = mylist[-1]
print(f"列表最后一个元素是：{element}")
index = mylist.index(31)
print(f"元素31在列表中的下标位置是：{index}")

list(列表)的遍历

列表的遍历 - while循环

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。
如何遍历列表的元素呢？

• 可以使用前面学过的while循环

如何在循环中取出列表的元素呢？

• 使用列表[下标]的方式取出

循环条件如何控制？

• 定义一个变量表示下标，从0开始
• 循环条件为 下标值 < 列表的元素数量

列表的遍历 - for循环

除了while循环外，Python种还有另外一种循环形式：for循环。
对比while，for循环更加适合对列表等数据容器进行遍历。

语法：

表示，从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，我们可以对临时变量（元素）进行处理。

代码示例：

"""
演示使用while和for循环遍历列表
"""

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    mylist = ["myr", "study", "python"]
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件：下标索引变量 < 列表的元素数量

    # 定义一个变量用来标记列表的下标
    i = 0  # 初始值为0
    while i < len(mylist):
        # 通过i变量取出对应的下标的元素
        print(f"列表的元素是：{mylist[i]}")
        i += 1

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    mylist = [1,2,3,4,5,6]
    # for 临时变量 in 数据容器:
    for element in mylist:
        print(f"列表的元素有：{element}")

list_while_func()
list_for_func()

while循环和for循环的对比

while循环和for循环，都是循环语句，但细节不同：

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

总结：
1.什么是遍历？
将容器内的元素依次取出，并处理，称之为遍历操作
2.如何遍历列表的元素？
可以使用while或for循环
3.for循环的语法：

4.for循环和while对比

• for循环更简单，while更灵活
• for用于从容器内依次取出元素并处理，while用以任何需要循环的场景

数据容器：tuple(元组)

元组的定义

为什么需要元组

思考：列表是可以修改的。
如果想要传递的信息，不被篡改，列表就不合适了。

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

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

定义元组

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

注意：元组只有一个数据，这个数据后面要添加逗号

元组也支持嵌套：

元组的操作

元组的相关操作

注意事项
元组由于不可修改的特性，所以其操作方法非常少。

元组的相关操作 - 注意事项

• 不可以修改元组的内容，否则会直接报错
  

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

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

元组的特点

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

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

多数特性和list一致，不同点在于不可修改的特性。

总结：
1.元组的定义方式：

• (元素, 元素, 元素, …)
  2.元组的操作方法：
  

3.元组的注意事项：

• 不可修改内容（可以修改内部list的内部元素）
  4.元组的特点：
• 和list基本相同（有序、任意数量元素、允许重复元素），唯一不同在于不可修改。

代码示例：

"""
演示tuple元组的定义和操作
"""

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}，内容是：{t1}")
print(f"t2的类型是：{type(t2)}，内容是：{t2}")
print(f"t3的类型是：{type(t3)}，内容是：{t3}")

# 定义单个元素的元组
t4 = ("hello",)
print(f"t4的类型是：{type(t4)}，内容是：{t4}")
# 元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)}，内容是：{t5}")

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

# 元组的操作：index查找方法
t6 = ("myr", "study", "python")
index = t6.index("study")
print(f"在元组t6中查找study的下标是：{index}")

# 元组的操作：count统计方法
t7 = ("myr", "study","myr", "study", "python")
num = t7.count("study")
print(f"在元组t7中统计study的数量有：{num}个")

# 元组的操作：len函数统计元组元素数量
t8 = ("myr", "study","myr", "study", "python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")

# 元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组的元素有：{t8[index]}")
    index += 1

# 元组的遍历：for
for element in t8:
    print(f"2元组的元素有：{element}")

# 定义一个元组
t9 = (1,2,["myr", "study"])
print(f"t9的内容是：{t9}")  # 结果：t9的内容是：(1, 2, ['myr', 'study'])
t9[2][0] = "Tom"
t9[2][1] = "Go"
print(f"t9的内容是：{t9}")  # 结果：t9的内容是：(1, 2, ['Tom', 'Go'])

# 不可以替换list为其它list或其它类型
# t10 = (1,2,["myr", "study"])
# t10[1] = [1,2,3]
# print(f"t10的内容是：{t10}")

输出结果：

D:\python\python-learn\venv\Scripts\python.exe D:\python\python-learn\tuple元组.py 
t1的类型是：<class 'tuple'>，内容是：(1, 'Hello', True)
t2的类型是：<class 'tuple'>，内容是：()
t3的类型是：<class 'tuple'>，内容是：()
t4的类型是：<class 'tuple'>，内容是：('hello',)
t5的类型是：<class 'tuple'>，内容是：((1, 2, 3), (4, 5, 6))
从嵌套元组中取出的数据是：6
在元组t6中查找study的下标是：1
在元组t7中统计study的数量有：2个
t8元组中的元素有：5个
元组的元素有：myr
元组的元素有：study
元组的元素有：myr
元组的元素有：study
元组的元素有：python
2元组的元素有：myr
2元组的元素有：study
2元组的元素有：myr
2元组的元素有：study
2元组的元素有：python
t9的内容是：(1, 2, ['myr', 'study'])
t9的内容是：(1, 2, ['Tom', 'Go'])

进程已结束，退出代码为 0

数据容器：str(字符串)

再识字符串

尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。
但不可否认的是，字符串同样也是数据容器的一员。

字符串是字符的容器，一个字符串可以存放任意数量的字符。
如，字符串：“itheima”

字符串的下标(索引)

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问

• 从前向后，下标从0开始
• 从后向前，下标从-1开始
  

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

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

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

字符串的常用操作

• 查找特定字符串的下标索引值
  语法：字符串.index(字符串)
  

• 字符串的替换
  语法：字符串.replace(字符串1,字符串2)
  功能：将字符串内的全部：字符串1，替换为字符串2
  注意：不是修改字符串本身，而是得到了一个新字符串哦
  
  可以看到，字符串name本身并没有发生变化
  而是得到了一个新字符串对象

• 字符串的分割
  语法：字符串.split(分隔符字符串)
  功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
  注意：字符串本身不变，而是得到了一个列表对象
  
  可以看到，字符串按照给定的 <空格>进行了分割，变成多个子字符串，并存入一个列表对象中。

• 字符串的规整操作（去前后空格）
  语法：字符串.strip()
  

• 字符串的规整操作（去前后指定字符串）
  语法：字符串.strip(字符串)
  
  注意，传入的是“12” 其实就是：”1”和”2”都会移除，是按照单个字符。

• 统计字符串中某字符串的出现次数
  语法：字符串.count(字符串)
  

• 统计字符串的长度
  语法：len(字符串)
  

可以看出：

• 数字（1、2、3…）
• 字母（mry、MRY等）
• 符号（空格、!、@、#、$等）
• 中文

均算作1个字符

代码示例：

"""
演示以数据容器的角色，学习字符串的相关操作
"""

my_str = "mry and tom"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-9]
print(f"从字符串{my_str}取下标为2的元素值是：{value}，取下标为-9的元素值是：{value2}")
# 结果：从字符串mry and tom取下标为2的元素值是：y，取下标为-9的元素值是：y

# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")
# 结果：在字符串mry and tom中查找and，其起始下标是：4

# replace方法
new_my_str = my_str.replace("a","123")
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")
# 结果：将字符串mry and tom，进行替换后得到：mry 123nd tom

# split方法
my_str = "mry and tom"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}，类型是：{type(my_str_list)}")
# 结果：将字符串mry and tom进行split切分后得到：['mry', 'and', 'tom']，类型是：<class 'list'>

# strip方法
my_str = "   mry and tom   "
new_my_str = my_str.strip()
print(f"字符串{my_str}被strip后，结果是：{new_my_str}")
# 结果：字符串   mry and tom   被strip后，结果是：mry and tom

my_str = "12mry and tom21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果是：{new_my_str}")
# 结果：字符串12mry and tom21被strip('12')后，结果是：mry and tom

# 统计字符中某字符串的出现次数，count
my_str = "mry and tom"
count = my_str.count("a")
print(f"字符串{my_str}中a出现的次数是：{count}")
# 结果：字符串mry and tom中a出现的次数是：1

# 统计字符串的长度 len()
my_str = "1234 mry and tom !@#$ 好好学习"
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")
# 结果：字符串1234 mry and tom !@#$ 好好学习的长度是：26

字符串常用操作汇总

字符串的遍历

同列表、元组一样，字符串也支持while循环和for循环进行遍历

代码演示：

my_str = "mryandtom"

# while循环遍历字符串
index = 0
while index < len(my_str):
    print(f"字符串遍历的元素是：{my_str[index]}")
    index += 1
    
# for循环遍历字符串
for element in my_str:
    print(f"2字符串遍历的元素是：{element}")

输出结果：

my_str = "mryandtom"

# while循环遍历字符串
index = 0
while index < len(my_str):
    print(f"字符串遍历的元素是：{my_str[index]}")
    index += 1

# for循环遍历字符串
for element in my_str:
    print(f"2字符串遍历的元素是：{element}")

字符串的特点

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

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

基本和列表、元组相同
不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。
不同于列表，相同于元组的在于：字符串不可修改

总结：
1.字符串为什么被称之为数据容器呢？
字符串可以看做是字符的容器，支持下标索引等特性
2.字符串有哪些常用操作方法？

3.字符串有哪些特点：

数据容器的切片

序列

序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以视为序列。


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

序列的常用操作 - 切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列。

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

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

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

代码示例：

"""
演示对序列进行切片操作
"""

# 对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4]  # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]  # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")

# 对str进行切片，从头开始，到最后结束，步长2
my_str ="01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]  # 等同于将序列反转了
print(f"结果4：{result4}")

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0,1,2,3,4,5,6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")

# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

总结：
1.什么是序列？
内容连续、有序，支持下标索引的一类数据容器
2.哪些数据容器可以视为序列？
列表、元组、字符串
3.序列如何做切片
序列[起始:结束:步长]

• 起始可以省略，省略从头开始
• 结束可以省略，省略到尾结束
• 步长可以省略，省略步长为1（可以为负数，表示倒序执行）

练习案例：序列的切片实践
有字符串：“好好学习,上向天天来，nohtyP学”

• 请使用学过的任何方式，得到"天天向上"

可用方式参考：

• 倒序字符串，切片取出或切片取出，然后倒序
• split分隔","replace替换"来"为空，倒序字符串

"""
演示序列的切片的课后练习
"""

my_str = "好好学习,上向天天来,nohyP学"

# 倒序字符串且切片取出
result1 = my_str[::-1][8:12]
print(f"方式1结果是：{result1}")

# 切片取出，然后倒序
result2 = my_str[8:4:-1]
print(f"方式2结果是：{result2}")

# split分隔"," replace替换"来"为空，倒序字符串
result3 = my_str.split(",")[1].replace("来","")[::-1]
print(f"方式3结果是：{result3}")

数据容器：set(集合)

为什么使用集合

我们目前接触到了列表、元组、字符串三个数据容器了。基本满足大多数的使用场景。
为何又需要学习新的集合类型呢？

通过特性来分析：

• 列表可修改、支持重复元素且有序
• 元组、字符串不可修改、支持重复元素且有序

同学们，有没有看出一些局限？

局限就在于：它们都支持重复元素。
如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。
而集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序

集合的定义

基本语法：

和列表、元组、字符串等定义基本相同：

• 列表使用：[]
• 元组使用：()
• 字符串使用：“”
• 集合使用：{}

集合的常用操作 - 修改

首先，因为集合是无序的，所以集合不支持：下标索引访问
但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

• 添加新元素
  语法：集合.add(元素)。将指定元素，添加到集合内
  结果：集合本身被修改，添加了新元素
  

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

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

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

• 取出2个集合的差集
  语法：集合1.difference(集合2)，功能：取出集合1和集合2的差集（集合1有而集合2没有的）
  结果：得到一个新集合，集合1和集合2不变
  

• 消除2个集合的差集
  语法：集合1.difference_update(集合2)
  功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
  结果：集合1被修改，集合2不变
  

• 2个集合合并
  语法：集合1.union(集合2)
  功能：将集合1和集合2组合成新集合
  结果：得到新集合，集合1和集合2不变
  

• 查看集合的元素数量
  语法：len(集合)
  功能：统计集合内有多少元素
  结果：得到一个整数结果
  

集合的常用操作 - for循环遍历

集合同样支持使用for循环遍历

要注意：集合不支持下标索引，所以也就不支持使用while循环。

集合常用功能总结

集合的特点

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

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

总结：
1.集合有哪些特点

• 集合内不允许重复元素（去重）
• 集合内元素是无序的（不支持下标索引）

2.集合的定义方式：
{元素, 元素, …, 元素}
3.集合的常用操作

4.如何遍历集合元素

• 可以使用for循环进行变量
• 不可以使用while循环，因为不支持下标索引

5.集合的特点

代码示例：

"""
演示数据容器集合的使用
"""

# 定义集合
my_set = {"myr","study","python","myr","study","python","myr","study","python"}
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.add("Hello")
my_set.add("World")
my_set.add("python")
print(f"my_set添加元素后结果是：{my_set}")
# 结果：my_set添加元素后结果是：{'myr', 'python', 'study', 'Hello', 'World'}

# 移除元素
my_set.remove("Hello")
print(f"my_set移除Hello后，结果是：{my_set}")
# 结果：my_set移除Hello后，结果是：{'World', 'python', 'myr', 'study'}

# 随机取出一个元素
my_set = {"myr","study","python"}
element = my_set.pop()
print(f"集合被取出元素是：{element}，取出元素后：{my_set}")
# 结果：集合被取出元素是：study，取出元素后：{'myr', 'python'}

# 清空集合
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")
# 结果：集合被清空啦，结果是：set()

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

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

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

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

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可用用for循环
set1 = {1,2,3,4,5}
for element in set1:
    print(f"集合的元素有：{element}")

输出结果：

D:\python\python-learn\venv\Scripts\python.exe D:\python\python-learn\50_集合.py 
my_set的内容是：{'python', 'myr', 'study'}，类型是：<class 'set'>
my_set_empty的内容是：set()，类型是：<class 'set'>
my_set添加元素后结果是：{'World', 'Hello', 'myr', 'study', 'python'}
my_set移除Hello后，结果是：{'World', 'myr', 'study', 'python'}
集合被取出元素是：python，取出元素后：{'myr', 'study'}
集合被清空啦，结果是：set()
取出差集后的结果是：{2, 3}
取差集后，原有set1的内容：{1, 2, 3}
取差集后，原有set2的内容：{1, 5, 6}
消除差集后，集合1结果：{2, 3}
消除差集后，集合2结果：{1, 5, 6}
2集合合并结果：{1, 2, 3, 5, 6}
合并后集合1：{1, 2, 3}
合并后集合2：{1, 5, 6}
集合内的元素数量有：5个
集合的元素有：1
集合的元素有：2
集合的元素有：3
集合的元素有：4
集合的元素有：5

进程已结束，退出代码为 0

数据容器：dict(字典、映射)

字典的定义

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

• 使用{}存储原始，每一个元素是一个键值对
• 每一个键值对包含Key和Value（用冒号分隔）
• 键值对之间使用逗号分隔
• Key和Value可以是任意类型的数据（key不可为字典）
• Key不可重复，重复会对原有数据覆盖

字典数据的获取

字典同集合一样，不可以使用下标索引
但是字典可以通过key值来获取对应的value

字典的嵌套

字典的Key和Value可以是任意数据类型（Key不可为字典）
那么，就表明，字典是可以嵌套的
需求如下：记录学生各科的考试信息

代码：

优化一下可读性，可以写成：

代码示例：

"""
演示数据容器字典的定义
"""

# 定义字典
my_dict1 = {"王力宏": 99 , "周杰伦": 88 , "林俊杰": 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_dict1 = {"王力宏": 99 , "王力宏": 88 , "林俊杰": 77}
print(f"重复key的字典的内容是：{my_dict1}")

# 从字典中基于key获取value
my_dict1 = {"王力宏": 99 , "周杰伦": 88 , "林俊杰": 77}
score = my_dict1["王力宏"]
print(f"王力宏的考试分数是：{score}")

# 定义嵌套字典
stu_score_dict = {
    "王力宏": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    } ,
    "周杰伦": {
        "语文": 66,
        "数学": 86,
        "英语": 96
    } ,
    "林俊杰": {
        "语文": 33,
        "数学": 55,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 查看一下周杰伦的语文信息
score = stu_score_dict["周杰伦"]["语文"]
print(f"周杰伦的语文分数是：{score}")

score = stu_score_dict["林俊杰"]["英语"]
print(f"林俊杰的英语分数是：{score}")

输出结果：

D:\python\python-learn\venv\Scripts\python.exe D:\python\python-learn\51_字典.py 
字典1的内容是：{'王力宏': 99, '周杰伦': 88, '林俊杰': 77}，类型：<class 'dict'>
字典2的内容是：{}，类型：<class 'dict'>
字典3的内容是：{}，类型：<class 'dict'>
重复key的字典的内容是：{'王力宏': 88, '林俊杰': 77}
王力宏的考试分数是：99
学生的考试信息是：{'王力宏': {'语文': 77, '数学': 66, '英语': 33}, '周杰伦': {'语文': 66, '数学': 86, '英语': 96}, '林俊杰': {'语文': 33, '数学': 55, '英语': 66}}
周杰伦的语文分数是：66
林俊杰的英语分数是：66

进程已结束，退出代码为 0

总结：
1.为什么使用字典
字典可以提供基于Key检索Value的场景实现
就像查字典一样
2.字典的定义语法

3.字典的注意事项

• 键值对的Key和Value可以是任意类型（Key不可为字典）
• 字典内Key不允许重复，重复添加等同于覆盖原有数据

字典的常用操作

• 新增元素
  语法：字典[Key]=Value，结果：字典被修改，新增了元素
  

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

• 删除元素
  语法：字典.pop(Key)，结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
  

• 清楚字典
  语法：字典.clear()，结果：字典被修改，元素被清空
  

• 获取全部的Key
  语法：字典.keys()，结果：得到字典中的全部Key
  

• 遍历字典
  语法：for key in 字典.keys()
  

• 计算字典内的全部元素（键值对）数量
  语法：len(字典)
  结果：得到一个整数，表示字典内元素（键值对）的数量
  

字典的常用操作总结

字典的特点

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

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

总结：
1.字典的常用操作

2.操作注意

• 新增和更新元素的语法一致，如果Key不存在即新增，如果Key存在即更新（Key不可重复）
  3.字典的特点
  

代码示例：

"""
演示字典的常用操作
"""
my_dict = {"王力宏": 99 , "周杰伦": 88 , "林俊杰": 77}

# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")

# 更新元素
my_dict["周杰伦"] = 33
print(f"字典经过更新元素后，结果：{my_dict}")

# 删除元素
score = my_dict.pop("周杰伦")
print(f"字典中被移除了一个元素，结果：{my_dict}，周杰伦的考试分数是：{score}")

# 清空元素
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")

# 获取全部的Key
my_dict = {"王力宏": 99 , "周杰伦": 88 , "林俊杰": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")

# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dict[key]}")

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dict[key]}")

# 统计字典内的元素数量
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

输出结果：

D:\python\python-learn\venv\Scripts\python.exe D:\python\python-learn\52_字典的常用操作.py 
字典经过新增元素后，结果：{'王力宏': 99, '周杰伦': 88, '林俊杰': 77, '张信哲': 66}
字典经过更新元素后，结果：{'王力宏': 99, '周杰伦': 33, '林俊杰': 77, '张信哲': 66}
字典中被移除了一个元素，结果：{'王力宏': 99, '林俊杰': 77, '张信哲': 66}，周杰伦的考试分数是：33
字典被清空了，内容是：{}
字典的全部keys是：dict_keys(['王力宏', '周杰伦', '林俊杰'])
字典的key是：王力宏
字典的value是：99
字典的key是：周杰伦
字典的value是：88
字典的key是：林俊杰
字典的value是：77
字典的key是：王力宏
字典的value是：99
字典的key是：周杰伦
字典的value是：88
字典的key是：林俊杰
字典的value是：77
字典中的元素数量有：3个

进程已结束，退出代码为 0

数据容器对比总结

数据容器分类

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

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

数据容器特点对比

各容器的使用场景

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

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

数据容器的通用操作

数据容器的通用操作 - 遍历

数据容器尽管各自有各自的特点，但是它们也有通用的一些操作。

首先，在遍历上：

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

尽管遍历的形式各有不同，但是，它们都支持遍历操作。

数据容器的通用统计功能

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

容器的通用转换功能

除了下标索引这个共性外，还可以通用类型转换

容器通用排序功能

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

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

容器通用功能总览

代码示例：

"""
演示数据容器的通用功能
"""
my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefg"
my_set = {1,2,3,4,5}
my_dict = {"key1": 1,"key2": 2,"key3": 3,"key4": 4,"key5": 5}

# len元素个数
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")

# max 最大元素
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")

# min最小元素
print(f"列表 最小的元素是：{min(my_list)}")
print(f"元组 最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是：{min(my_str)}")
print(f"集合 最小的元素是：{min(my_set)}")
print(f"字典 最小的元素是：{min(my_dict)}")

# 类型转换：容器转列表
print(f"列表转列表的结果是：{list(my_list)}")
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表的结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")

# 类型转换：容器转元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组的结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")

# 类型转换：容器转字符串
print(f"列表转字符串的结果是：{str(my_list)}")
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串的结果是：{str(my_str)}")
print(f"集合转字符串的结果是：{str(my_set)}")
print(f"字典转字符串的结果是：{str(my_dict)}")

# 类型转换：容器转集合
print(f"列表转集合的结果是：{set(my_list)}")
print(f"元组转集合的结果是：{set(my_tuple)}")
print(f"字符串转集合的结果是：{set(my_str)}")
print(f"集合转集合的结果是：{set(my_set)}")
print(f"字典转集合的结果是：{set(my_dict)}")

# sorted排序
print(f"列表对象的排序结果是：{sorted(my_list)}")
print(f"元组对象的排序结果是：{sorted(my_tuple)}")
print(f"字符串对象的排序结果是：{sorted(my_str)}")
print(f"集合对象的排序结果是：{sorted(my_set)}")
print(f"字典对象的排序结果是：{sorted(my_dict)}")

print(f"列表对象的反向排序结果是：{sorted(my_list,reverse=True)}")
print(f"元组对象的反向排序结果是：{sorted(my_tuple,reverse=True)}")
print(f"字符串对象的反向排序结果是：{sorted(my_str,reverse=True)}")
print(f"集合对象的反向排序结果是：{sorted(my_set,reverse=True)}")
print(f"字典对象的反向排序结果是：{sorted(my_dict,reverse=True)}")

输出结果：

D:\python\python-learn\venv\Scripts\python.exe D:\python\python-learn\53_数据容器通用功能.py 
列表 元素个数有：5
元组 元素个数有：5
字符串元素个数有：7
集合 元素个数有：5
字典 元素个数有：5
列表 最大的元素是：5
元组 最大的元素是：5
字符串最大的元素是：g
集合 最大的元素是：5
字典 最大的元素是：key5
列表 最小的元素是：1
元组 最小的元素是：1
字符串最小的元素是：a
集合 最小的元素是：1
字典 最小的元素是：key1
列表转列表的结果是：[1, 2, 3, 4, 5]
元组转列表的结果是：[1, 2, 3, 4, 5]
字符串转列表的结果是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
集合转列表的结果是：[1, 2, 3, 4, 5]
字典转列表的结果是：['key1', 'key2', 'key3', 'key4', 'key5']
列表转元组的结果是：(1, 2, 3, 4, 5)
元组转元组的结果是：(1, 2, 3, 4, 5)
字符串转元组的结果是：('a', 'b', 'c', 'd', 'e', 'f', 'g')
集合转元组的结果是：(1, 2, 3, 4, 5)
字典转元组的结果是：('key1', 'key2', 'key3', 'key4', 'key5')
列表转字符串的结果是：[1, 2, 3, 4, 5]
元组转字符串的结果是：(1, 2, 3, 4, 5)
字符串转字符串的结果是：abcdefg
集合转字符串的结果是：{1, 2, 3, 4, 5}
字典转字符串的结果是：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}
列表转集合的结果是：{1, 2, 3, 4, 5}
元组转集合的结果是：{1, 2, 3, 4, 5}
字符串转集合的结果是：{'d', 'g', 'b', 'e', 'c', 'f', 'a'}
集合转集合的结果是：{1, 2, 3, 4, 5}
字典转集合的结果是：{'key2', 'key1', 'key5', 'key4', 'key3'}
列表对象的排序结果是：[1, 2, 3, 4, 5]
元组对象的排序结果是：[1, 2, 3, 4, 5]
字符串对象的排序结果是：['a', 'b', 'c', 'd', 'e', 'f', 'g']
集合对象的排序结果是：[1, 2, 3, 4, 5]
字典对象的排序结果是：['key1', 'key2', 'key3', 'key4', 'key5']
列表对象的反向排序结果是：[5, 4, 3, 2, 1]
元组对象的反向排序结果是：[5, 4, 3, 2, 1]
字符串对象的反向排序结果是：['g', 'f', 'e', 'd', 'c', 'b', 'a']
集合对象的反向排序结果是：[5, 4, 3, 2, 1]
字典对象的反向排序结果是：['key5', 'key4', 'key3', 'key2', 'key1']

进程已结束，退出代码为 0

字符串大小比较

ASCII码表

在程序中，字符串所用的所有字符如：

• 大小写英文单词
• 数字
• 特殊符号(!、\、|、@、#、空格等)
  都有其对应的ASCII码表值

每一个字符都能对应上一个：数字的码值
字符串进行比较就是基于数字的码值大小进行比较的。

字符串比较

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。

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

代码示例：

"""
演示字符串大小比较
"""

# abc 比较 abd
print(f"abd大于abc，结果：{'abd' > 'abc'}")

# a 比较 ab
print(f"ab大于a，结果：{'ab' > 'a'}")

# a 比较 A
print(f"a 大于 A，结果：{'a' > 'A'}")

# key1 比较 key2
print(f"key2 > key1，结果：{'key2' > 'key1'}")