第一阶段-第六章 Python的数据容器

最新推荐文章于 2024-02-28 09:43:02 发布
最新推荐文章于 2024-02-28 09:43:02 发布
阅读量627 收藏 7
点赞数 1
分类专栏： Python入门(黑马)的学习笔记 文章标签： python 开发语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60146935/article/details/131673162
版权

目录


  说明：该文章是学习 黑马程序员在B站上分享的视频 黑马程序员python教程，8天python从入门到精通而记录的笔记，笔记来源于本人。 若有侵权，请联系本人删除。笔记难免可能出现错误或笔误，若读者发现笔记有错误，欢迎在评论里批评指正。此笔记对应的doc文件的百度网盘下载链接为 Python入门(黑马)的学习笔记，提取码：1b3k。
在这里插入图片描述
在这里插入图片描述

一、数据容器入门

  1.学习目标

  了解数据容器是什么。

  2.为什么要学习数据容器

在这里插入图片描述

  3.什么是数据容器

在这里插入图片描述

  4.本小节的总结

在这里插入图片描述

二、数据容器：list（列表）

  2.1列表的定义

  1.学习目标

  掌握列表的定义格式。

  2.为什么需要列表

在这里插入图片描述

  3.列表的定义

在这里插入图片描述
在这里插入图片描述

  4.本节的代码演示

  先打开软件，创建一个名为“06_Python的数据容器”的文件夹，并创建一个名为“01_list列表”的py文件。
在这里插入图片描述在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

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

# 定义一个列表list
my_list = ["itheima", "itcast", "python"]
print(my_list)
print(type(my_list))

my_list = ["itheima", 666, True]
print(my_list)
print(type(my_list))

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

在这里插入图片描述

  5.本小节的总结

在这里插入图片描述

  2.2 列表的下标索引

  1.学习目标

  掌握使用列表的下标索引从列表中取出元素。

  2.列表索引的语法与作用

在这里插入图片描述在这里插入图片描述

  3.嵌套列表的索引

  如列表[1][1]就是取出列表中第2个元素（此时的元素也是一个列表）中的第2个元素。
在这里插入图片描述

  4.本节的代码演示

  进行代码的演示（为了便于管理文件，先将本节之前的代码文件改成“01_1_ list列表的定义”）：
在这里插入图片描述
在这里插入图片描述
  创建一个名为“01_2_列表的下标索引”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

"""
演示数据容器之：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])

在这里插入图片描述

  5.本小节的总结

在这里插入图片描述

  2.3 列表的常用操作

  1.学习目标

  掌握列表的常用操作（方法）和特点。

  2. 列表的常用操作（方法）

在这里插入图片描述

  3.方法——定义在类里面的函数

在这里插入图片描述

  4. 列表的查询功能（index方法）、修改功能（方法）、插入功能（insert方法）、追加功能（append方法、extend方法）、删除元素（del或pop）、删除某元素在列表中的第一个匹配项（remove方法）、清空列表（clear）、统计某元素在列表内的数量（count）、统计列表里的元素个数（len语法）

  通过index方法，我们可以接收一个传入的参数，这个参数就是要查找的元素。把元素传进去就会得到一个返回值，这个返回值就会告诉你这个元素在列表中的下标是多少。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
  注：pop会把取出的元素作为返回值，进行输出。
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  5.本节的代码演示

  先打开软件，创建一个名为“01_3_ list列表的常用操作”的py文件。
在这里插入图片描述在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。可以体会列表list的查询功能方法index的语法。

"""
演示数据容器之：list列表的常用操作
"""

mylist = ["itcast","itheima","python"]
# 1.1查找某元素在列表内的下标素引
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")

在这里插入图片描述
  如果被查找的元素不存在，会 ** ！！报错！！ ** ，如下重新编写代码并运行，可发现报错提示：在列表中没有找到”Hello”。

"""
演示数据容器之：list列表的常用操作
"""

mylist = ["itcast","itheima","python"]
# 1.1查找某元素在列表内的下标素引
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")

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

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），体会列表的修改功能。

"""
演示数据容器之：list列表的常用操作
"""

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

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

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），体会列表的插入功能。

"""
演示数据容器之：list列表的常用操作
"""

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

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

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

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），体会列表追加一个元素的功能。

"""
演示数据容器之：list列表的常用操作
"""

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

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

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

# 4.在列表的尾部追加'''单个'''新元素
mylist.append("黑马程序员")
print(f"列表在追加了元素后，结果是：{mylist}")

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），体会列表追加一批元素的功能。

"""
演示数据容器之：list列表的常用操作
"""

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

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

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

# # 4.在列表的尾部追加'''单个'''新元素
# mylist.append("黑马程序员")
# print(f"列表在追加了元素后，结果是：{mylist}")

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

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），体会列表的删除元素功能。并可以验证pop会把取出的元素作为返回值，进行输出。

"""
演示数据容器之：list列表的常用操作
"""

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

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

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

# # 4.在列表的尾部追加'''单个'''新元素
# mylist.append("黑马程序员")
# print(f"列表在追加了元素后，结果是：{mylist}")

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

# 6.删除指定下标索引的元素(2种方式)
# 6.1 方式1:de1列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 6.2 方式2：列表.pop(下标)
mylist = ["itcast", "itheima", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist},取出的元素是：{element}")

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），体会删除某元素在列表中的第一个匹配项的功能。

"""
演示数据容器之：list列表的常用操作
"""

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

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

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

# # 4.在列表的尾部追加'''单个'''新元素
# mylist.append("黑马程序员")
# print(f"列表在追加了元素后，结果是：{mylist}")

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

# # 6.删除指定下标索引的元素(2种方式)
# # 6.1 方式1:de1列表[下标]
# del mylist[2]
# print(f"列表删除元素后结果是：{mylist}")
# # 6.2 方式2：列表.pop(下标)
# mylist = ["itcast", "itheima", "python"]
# element = mylist.pop(2)
# print(f"通过pop方法取出元素后列表内容：{mylist},取出的元素是：{element}")

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

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），体会清空列表的功能。

"""
演示数据容器之：list列表的常用操作
"""

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

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

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

# # 4.在列表的尾部追加'''单个'''新元素
# mylist.append("黑马程序员")
# print(f"列表在追加了元素后，结果是：{mylist}")

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

# # 6.删除指定下标索引的元素(2种方式)
# # 6.1 方式1:de1列表[下标]
# del mylist[2]
# print(f"列表删除元素后结果是：{mylist}")
# # 6.2 方式2：列表.pop(下标)
# mylist = ["itcast", "itheima", "python"]
# element = mylist.pop(2)
# print(f"通过pop方法取出元素后列表内容：{mylist},取出的元素是：{element}")

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

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

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），体会列表中指定元素的计数功能。

"""
演示数据容器之：list列表的常用操作
"""

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

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

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

# # 4.在列表的尾部追加'''单个'''新元素
# mylist.append("黑马程序员")
# print(f"列表在追加了元素后，结果是：{mylist}")

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

# # 6.删除指定下标索引的元素(2种方式)
# # 6.1 方式1:de1列表[下标]
# del mylist[2]
# print(f"列表删除元素后结果是：{mylist}")
# # 6.2 方式2：列表.pop(下标)
# mylist = ["itcast", "itheima", "python"]
# element = mylist.pop(2)
# print(f"通过pop方法取出元素后列表内容：{mylist},取出的元素是：{element}")

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

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

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

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），体会统计列表中全部元素的功能。

"""
演示数据容器之：list列表的常用操作
"""

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

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

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

# # 4.在列表的尾部追加'''单个'''新元素
# mylist.append("黑马程序员")
# print(f"列表在追加了元素后，结果是：{mylist}")

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

# # 6.删除指定下标索引的元素(2种方式)
# # 6.1 方式1:de1列表[下标]
# del mylist[2]
# print(f"列表删除元素后结果是：{mylist}")
# # 6.2 方式2：列表.pop(下标)
# mylist = ["itcast", "itheima", "python"]
# element = mylist.pop(2)
# print(f"通过pop方法取出元素后列表内容：{mylist},取出的元素是：{element}")

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

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

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

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

在这里插入图片描述

  6.本小节的总结（含常见列表使用方法表、列表的特点）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述

  7.练习案例：list列表常用功能练习

在这里插入图片描述
  创建一个名为“01_4_ list列表常用操作课后练习”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

"""
演示list常用操作的课后练习
"""

# 1.定义这个列表，并用变量接收它，内容是：[21,25,21,23,22,20]
mylist = [21, 25, 21, 23, 22, 20]

# 2.追加一个数字31，到列表的尾部
mylist.append(31)

# 3.追加一个新列表[29,33,30]，到列表的尾部
mylist.extend([29, 33, 30])

# 4.取出第一个元素(应是：21)
num1 = mylist[0]
print(f"从列表中取出来第一个元素，应该是21，实际上是：{num1}")

# 5.取出最后一个元素(应是：30)
num2 = mylist[-1]
print(f"从列表中取出来最后一个元素，应该是30，实际上是：{num2}")

# 6.查找元素31，在列表中的下标位置
index = mylist.index(31)
print(f"元素31在列表的下标位置是：{index}")
print(f"最后列表的内容是：{mylist}")

在这里插入图片描述

三、list（列表）的遍历

  1.学习目标

  掌握使用while循环，遍历列表的元素;掌握使用for循环，遍历列表的元素。

  2.什么是遍历（迭代）以及列表的遍历之while循环

在这里插入图片描述

  3.列表的遍历之for循环

在这里插入图片描述

  4.本节的代码演示

  创建一个名为“02_Iist列表的循环”的py文件。
在这里插入图片描述在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。从中学会while循环对列表的遍历。

"""
演示对list列表的循坏，使用while和for循环2种方式
"""


# 1.使用while循环对list列表进行遍历
def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return:None
    """
    my_list = ["传智教育", "黑马程序员", "Python"]

    # 循坏控制变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件：下标索引变量<列表的元素数量
    # 定义一个变量用来标记列表的下标
    index = 0  # 初始值为0
    while index < len(my_list):
        # 通过index变量取出对应下标的元素
        element = my_list[index]
        print(f"列表的元素：{element}")

        # 至关重要将循环变量(index)每一次循坏都+1
        index += 1


list_while_func()

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释），从中学会for循环对列表的遍历。

"""
演示对list列表的循坏，使用while和for循环2种方式
"""


# # 1.使用while循环对list列表进行遍历
# def list_while_func():
#     """
#     使用while循环遍历列表的演示函数
#     :return:None
#     """
#     my_list = ["传智教育", "黑马程序员", "Python"]
#
#     # 循坏控制变量通过下标索引来控制，默认0
#     # 每一次循环将下标索引变量+1
#     # 循环条件：下标索引变量<列表的元素数量
#     # 定义一个变量用来标记列表的下标
#     index = 0  # 初始值为0
#     while index < len(my_list):
#         # 通过index变量取出对应下标的元素
#         element = my_list[index]
#         print(f"列表的元素：{element}")
#
#         # 至关重要将循环变量(index)每一次循坏都+1
#         index += 1
#
#
# list_while_func()

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


list_for_func()

在这里插入图片描述

  5.while循环和for循环的对比

在这里插入图片描述

  6.本小节的总结

在这里插入图片描述

  7. 练习案例：取出列表内的偶数

在这里插入图片描述

四、数据容器：tuple（元组）

  1.学习目标

  掌握元组的定义格式；掌握元组的特点；掌握元组的常见操作。

  2.为什么需要元组

在这里插入图片描述
  元组可理解成只读的list。

  3.元组的定义语法

在这里插入图片描述

  4. 元组的相关操作(index、count、len)

在这里插入图片描述
在这里插入图片描述

  5.本节的代码演示

  创建一个名为“03_ tuple元组”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。在编程中要学会元组的定义方法，需要注意的是，其中仅含一个元素的元组的定义语法，要在后面加逗号。

"""
演示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的内容是：{t4}")
t4 = ("hello",)
print(f"t4的类型是：{type(t4)},t4的内容是：{t4}")

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释）。代码如下，可参考注释进行理解。在编程中要学会元组的嵌套以及在嵌套情况下如何取内层里的元素。

"""
演示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的内容是：{t4}")
# t4 = ("hello",)
# print(f"t4的类型是：{type(t4)},t4的内容是：{t4}")

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

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

在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释）。代码如下，可参考注释进行理解。在编程中要学会元组的相关操作以及遍历。

"""
演示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的内容是：{t4}")
# t4 = ("hello",)
# print(f"t4的类型是：{type(t4)},t4的内容是：{t4}")

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

# 元组的操作：index查找方法
t6 = ("传智教育", "黑马程序员", "Python")
index = t6.index("黑马程序员")
print(f"在元组t6中查找 黑马程序员 的下标是：{index}")

# 元组的操作：count统计方法
t7 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = t7.count("黑马程序员")
print(f"在元组t7中统计黑马程序员的数量有：{num}个")

# 元组的操作：len函数统计元组元素数量
t8 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "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"元组t8的元素有：{element}")

在这里插入图片描述
  如果尝试修改元组的数据，会报错，这是一个错误示例。
在这里插入图片描述
  如下重新编写代码并运行（使用快捷键Ctr+/可快速注释）。代码如下，可参考注释进行理解。在编程中可发现：可以修改元组内的列表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的内容是：{t4}")
# t4 = ("hello",)
# print(f"t4的类型是：{type(t4)},t4的内容是：{t4}")

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

# # 元组的操作：index查找方法
# t6 = ("传智教育", "黑马程序员", "Python")
# index = t6.index("黑马程序员")
# print(f"在元组t6中查找 黑马程序员 的下标是：{index}")
#
# # 元组的操作：count统计方法
# t7 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
# num = t7.count("黑马程序员")
# print(f"在元组t7中统计黑马程序员的数量有：{num}个")
#
# # 元组的操作：len函数统计元组元素数量
# t8 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "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"元组t8的元素有：{element}")

# # 修改元组内容        由于元组不可修改，显然这是一个错误示例
# t8[0] = "itcast"

# 定义一个元组
t9 = (1, 2, ["itheima", "itcast"])
print(f"t9的内容是：{t9}")
t9[2][0] = "黑马程序员"
t9[2][1] = "传智教育"
print(f"t9的内容是：{t9}")

在这里插入图片描述

  6.元组的特点

在这里插入图片描述

  7.本小节的总结

在这里插入图片描述

  8. 练习案例：元组的基本操作

在这里插入图片描述

五、数据容器：str（字符串）

  1.学习目标

  掌握字符串的常见操作。

  2.字符串的下标（索引）

在这里插入图片描述在这里插入图片描述

  3.字符串的常用操作（索引index、替换replace、分割split、规整操作strip、统计count与len）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
  另外，count可用于统计字符串中某字符串的出现次数, len可用于统计字符串的长度, 具体使用方法与列表一样，本节也进行了代码的演示。

  4.字符串的遍历

在这里插入图片描述

  5.本节的代码演示

  先打开软件，创建一个名为“04_字符串”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

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

my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素的值是：{value},取下标为-16的元素的值是：{value2}")

# 字符串不可修改，下面的操作  ！！不可！！  完成
# my_str[2] = "H"

# index方法
valve = my_str.index("and")
print(f"在字符串{my_str}中查找and,其起始下标是：{valve}")

# replace方法
new_my_str = my_str.replace("it", "程序")
print(f"将字符串{my_str},进行替换后得到：{new_my_str}")

# split方法
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list},类型是：{type(my_str_list)}")

# strip方法
my_str = "  itheima and itcast  "
new_my_str = my_str.strip()  # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")
my_str = "12itheima and itcast21"

new_my_str = my_str.strip("12")  # 去除首尾的数字1和2
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")

# 统计字符串中某字符串的出现次数, count
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")

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

在这里插入图片描述

  6．字符串的特点

在这里插入图片描述

  7.本小节的总结

在这里插入图片描述

  8. 练习案例：分割字符串

在这里插入图片描述
  进行代码的演示（为了便于管理文件，先将本节之前的代码文件改成“04_1_字符串”）：
在这里插入图片描述在这里插入图片描述
  创建一个名为“04_2_字符串课后练习”的py文件。
在这里插入图片描述在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

"""
字符串课后练习演示
"itheima itcast boxuegu"
"""

my_str = "itheima itcast boxuegu"
# 统计字符串内有多少个"1t"字符
num = my_str.count("it")
print(f"字符串{my_str}中有{num}个it字符")

# 将字符串内的空格，全部替换为字符：”|”
new_my_str = my_str.replace(" ", "|")
print(f"字符串{my_str}被替换空格后，结果是：{new_my_str}")

# 并按照”|”进行字符串分割，得到列表
my_str_list = new_my_str.split("|")
print(f"字符串{new_my_str}按照|分割后结果是：{my_str_list}")

在这里插入图片描述

六、数据容器（序列）的切片

  1.学习目标

  了解什么是序列;掌握序列的切片操作。

  2. 什么是序列

在这里插入图片描述

  3.序列的常用操作（切片）

在这里插入图片描述
  注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组或字符串），这是因为元组和字符串是不支持修改的。

  4.本节的代码演示

  先打开软件，创建一个名为“05_序列和切片”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

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

# 对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_1ist = [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}")

在这里插入图片描述

  5.本小节的总结

在这里插入图片描述

  6.练习案例：序列的切片实践

在这里插入图片描述
  进行代码的演示（为了便于管理文件，先将本节之前的代码文件改成“05_1_序列和切片”）：
在这里插入图片描述
在这里插入图片描述
  创建一个名为“05_2_序列切片课后练习”的py文件。
在这里插入图片描述在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

"""
演示序列的切片的课后练习
"万过薪月，员序程马黑来，nohtyP学"
"""

my_str = "万过薪月，员序程马黑来，nohtyP学"
# 倒序字符串，切片取出
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}")

在这里插入图片描述

七、数据容器：set（集合）

  1.学习目标

  掌握集合的定义格式；掌握集合的特点；掌握集合的常见操作。

  2.为什么使用集合

在这里插入图片描述

  3.集合的定义

在这里插入图片描述
  注：由于集合是无序的，所以它不是序列。

  4.集合的常用操作（添加元素add、移除元素remove、随机取元素pop、清空clear、取差集difference、消除差集difference_update、合并集合union、统计元素个数len）

在这里插入图片描述
在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

  5.集合的特点

在这里插入图片描述
  注：其实也能支持while循环，可参考代码演示或者b站上的一条弹幕。

  6.本节的代码演示

  先打开软件，创建一个名为“06_集合”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

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

# 定义集合
my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
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("Python")
my_set.add("传智教育")
print(f"my_set添加元素后结果是：{my_set}")

# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后，结果是：{my_set}")

# 随机取出一个元素
my_set = {"传智教育", "黑马程序员", "itheima"}
element = my_set.pop()
print(f"集合被取出元素是：{element},取出元素后：{my_set}")

# 清空集合，clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_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}
set1.difference_update(set2)
print(f"消除差集后，set1的内容：{set1}")
print(f"消除差集后，set2的内容：{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}")

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

# 集合的遍历
# 集合不支持下标索引，while循环不能像常规的while循环一样进行遍历    while循环需要改变循环条件
# 可以用刷0r循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")

my_set = {"传智教育", "黑马程序员", "itheima"}   # b站一大佬给的弹幕提示
while my_set != set():
    a = my_set.pop()
    print(a)

在这里插入图片描述

  7.本小节的总结

在这里插入图片描述在这里插入图片描述

  8. 练习案例：信息去重

在这里插入图片描述
  进行代码的演示（为了便于管理文件，先将本节之前的代码文件改成“06_1_集合”）：
在这里插入图片描述
在这里插入图片描述
  创建一个名为“06_2_集合课后练习-信息去重”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

"""
演示集合的课后练习题
my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客',
           'itheima', 'itcast', 'itheima', 'itcast', 'best']
"""

my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客',
           'itheima', 'itcast', 'itheima', 'itcast', 'best']

# 定义一个空集合
my_set = set()

# 通过f0下循环遍历列表
for element in my_list:
    # 在for下循环中将列表的元素添加至集合
    my_set.add(element)

# 最终得到元素去重后的集合对象，并打印输出
print(f"列表的内容是：{my_list}")
print(f"通过for循环后，得到的集合对象是：{my_set}")

在这里插入图片描述

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

  8.1 字典的定义

  1.学习目标

  掌握字典的定义格式。

  2. 为什么使用字典

在这里插入图片描述在这里插入图片描述在这里插入图片描述

  3. 字典的定义（键值对）

在这里插入图片描述
  注：Python中字典的Key是不可以重复的，如果真定义相同的Key，后面的会把前面的覆盖。

  4. 字典数据的获取

在这里插入图片描述

  5. 字典的嵌套

在这里插入图片描述
在这里插入图片描述
  注：格式可参考演示。

  6.本节的代码演示

  先打开软件，创建一个名为“07_1_字典的定义”的py文件。
在这里插入图片描述在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

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

# 定义字典
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的字典    注：Python中字典的Key是不可以重复的，如果真定义相同的Key，后面的会把前面的覆盖。
# my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
# print(f"重复key的字典的内容是：{my_dict1}")

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

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

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

在这里插入图片描述

  7.本小节的总结

在这里插入图片描述

  8.2 字典的常用操作

  1.学习目标

  掌握字典的常用操作；掌握字典的特点。

  2.字典的常用操作（新增元素、更新元素、删除元素pop、清空元素clear、获取字典的键keys、统计元素len、遍历）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述

  3.字典的特点

在这里插入图片描述

  4.本节的代码演示

  先打开软件，创建一个名为“07_2_字典的常用操作”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

"""
演示字典的常用操作
"""
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}")

# 清空元素，clear
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"字典的valve是：{my_dict[key]}")
# 方式2：直接对字典进付or循环，每一次循坏都是直接得到key
for key in my_dict:
    print(f"2字典的key是：{key}")
    print(f"2字典的valve是：{my_dict[key]}")

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

在这里插入图片描述

  5.本小节的总结

在这里插入图片描述

  6. 练习案例：升职加薪

在这里插入图片描述
  创建一个名为“07_3_字典课后练习”的py文件。
在这里插入图片描述在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

"""
演示字典的课后练习：升职加薪，对所有级别为1级的员工，级别上升1级，薪水增加加080元
"""

# 组织字典记录数据
info_dict = {
    "王力鸿": {
        "部门": "科技部",
        "工资": 3000,
        "级别": 1
    },
    "周杰轮": {
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    "林俊节": {
        "部门": "市场部",
        "工资": 3000,
        "级别": 1
    },
    "张学油": {
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    "刘德滑": {
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    }
}

print(f"员工在升值加薪之前的结果：{info_dict}")

# for循环遍历字典
for name in info_dict:
    # if条件判惭符合条件员工
    if info_dict[name]["级别"] == 1:
        # 升职加薪操作
        # 获取到员工的信息字典
        employee_info_dict = info_dict[name]
        # 修改员工的信息
        employee_info_dict["级别"] = 2  # 级别+1
        employee_info_dict["工资"] += 1000  # 工资+1000
        # 将员工的信息更新回1nfo_dict
        info_dict[name] = employee_info_dict

# 输出结果
print(f"对员工进行升级加薪后的结果是：{info_dict}")

在这里插入图片描述

九、数据容器对比总结

  1.数据容器分类

在这里插入图片描述

  2.数据容器特点对比

在这里插入图片描述

  3.本小节的总结

在这里插入图片描述

十、数据容器的通用操作

  1.数据容器的通用操作（遍历、统计、类型转换、通用排序sorted）

在这里插入图片描述在这里插入图片描述
  注：其实集合可以使用while循环进行遍历，详细见那一节的演示。
在这里插入图片描述在这里插入图片描述在这里插入图片描述
  sorted的第一个参数是被排序的容器，第二个参数是一个有默认值的参数,叫做reverse，它是反转的意思,默认为False, 如果想让容器的排序结果进行反转，可以传递一个True。这样，就能控制容器进行从小到大的排序，或者反过来从大到小的排序。另外需要注意的是，排序的结果对象为列表。

  2.本节的代码演示

  先打开软件，创建一个名为“08_数据容器的通用功能”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

"""
演示数据容器的通用功能
"""
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)}")

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

# 类型转换：容器转列表
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)}")  # 结果："[1, 2, 3, 4, 5]"
print(f"元组转字符串的结果是：{str(my_tuple)}")  # 结果："(1, 2, 3, 4, 5)"
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)}")

# 进行容器的排序           排序的结果对象为列表
my_1ist = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "bdcefga"
my_set = {3, 1, 2, 5, 4}
# 正向排序
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}
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)}")

在这里插入图片描述

十一、字符串大小比较

  1.ASCII码表

在这里插入图片描述

  2.字符串比较

在这里插入图片描述

  3.本节的代码演示

  先打开软件，创建一个名为“09_字符串大小比较”的py文件。
在这里插入图片描述
在这里插入图片描述
  编写代码并运行。代码如下，可参考注释进行理解。

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

# 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'}")

在这里插入图片描述

  4.本小节的总结

在这里插入图片描述
  好了，本章的笔记到此结束，谢谢大家阅读。

知乎云烟
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Python第一阶段笔记汇总.docx
02-06
第一章Python基本 6 一Python 简介 6 (一) Python 定义 6 (二) Python程序的执行方式 7 (三)Linux常用命令 7 (四)执行过程 8 (五)解释器类型 8 (六)调试 9 二 数据基本运算 9 (一)pycharm常用快捷键(编译器...
lrucacheleetcode-leetcode:leetcode(python)
06-29
第一次学习 Leetcode。 选择 Python 以便我可以快速浏览 leetcode，只关注算法。 从 2015-03-18 开始。 结束于？。 内容 标题接受难度 1 两和 17.7% 中 2 两个数相加 22.1% 中 3 无重复字符的最长子串 21.1% 中 4 两...
python中的容器
LongHongYu908的博客
12-29 2475
python中的容器
Python的容器
m0_61858762的博客
06-29 6572
Python的容器篇
Python中的容器类型详解
最新发布
weixin_68789096的博客
02-28 994
Python是一种功能丰富的编程语言，提供了多种内置的容器类型，帮助开发者有效地组织和管理数据。容器类型是存储一组数据的数据结构，每种类型都有其独特的特性和用途。🔍本文将深入探讨Python中的主要容器类型：列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set），并提供使用示例，帮助读者全面理解和掌握它们。
Python之数据容器
m0_60121089的博客
10-23 2773
列表的定义语法：[元素，元素，元素，...]元素：数据容器内的每一份数据，都称之为元素。元素的数据类型无限制，甚至元素可以是列表，这样就定义了嵌套列表。字典可以提供基于Key检索Value的场景实现，就像查字典一样。字典的定义语法：# 定义字典my_dict = {"张三":99,"李四":88,"王五":77}# 内容：{'张三': 99, '李四': 88, '王五': 77},类型：
Python-数据容器
m0_74416307的博客
07-05 417
用中括号[]括成，逗号隔开元素1,元素2,元素3,......用括号()括成，逗号隔开元素1,元素2,元素3,......注意：元组只有一个数据时，此数据后需添加逗号是字符的容器，可存放任意数量字符。内容连续，有序，支持下标索引的一类数据容器。如：列表，元组，字符串。
python---数据容器
简单点的博客
03-27 896
python数据容器的定义
leetcode寻找最近的-leetcode-python:用Python刷leetcode+GitBook
07-01
1.两数之和 2.两数相加 3.无重复字符的最长子串 4.寻找两个有序数组的中位数 5.最长回文子串 6.Z字形变换 7.整数反转 8.字符串转换整数 (atoi) 9.回文数 10.正则表达式匹配 11.盛最多水的容器 12.整数转罗马数字 13....
《Python编程案例》教案-第17次课-游戏开发(一)-安装Pygame第三方库.doc
06-13
《Python编程案例教程》 教案 课时分配表 "章序 "课程内容 "课时 "备注 " "1 "走进Python编程世界 "4 " " "2 "Python编程基础知识 "6 " " "3 "流程控制语句 "6 " " "4 "数据容器 "8 " " "5 "函数 "8 " " "6 "面向...
leetcode括号生成python-algs:算法和数据结构
07-07
leetcode括号生成python algs 算法集合。有的用的js，有的用python，合在一起了 btreeTravers：二叉树的三种遍历方式（递归、非递归） sort：常用排序算法实现 alg-1 未分类1 1：动态连通性 2：只有两个主键的数组...
第六章：python数据容器
dldldltty的博客
01-17 735
第六章：python数据容器
【Python】Python中数据容器
X_H学Java的博客
04-14 746
Python中的列表，元组，字典都是常用的类型，本文介绍了Python中的列表，元组，字典的操作
六、Python数据容器
zz3035786953的博客
03-05 746
六、Python数据容器
Python数据容器
长风破浪
07-15 247
Python中的数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。数据容器根据特点的不同分为5类，分别是：列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)
Python数据容器详解
ye_yumo的博客
12-19 983
以方括号作为表示，用逗号隔开，元素之间可以是不同的数据类型，支持嵌套，后面两种都是定义空列表的方式例如定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型tuple2和tuple3都是空元组，tuple4是只含一个元素的元组，需要注意的是当元组只有一个数据时，这个数据之后需要添加逗号，否则就不是元组类型，而是他本身的类型在定义集合时哪怕e1和e2相同，他也会自动帮你去重字典的定义，同样使用{}，不过存储的元素是一个个的：键值对例如dict3 = {}
python数据容器详解
qq_49231165的博客
02-07 1363
python数据容器详解，包括列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict），对以上数据容器进行讲解对比
Python-容器类型
weixin_43336407的博客
07-08 1823
容器总结：字符串、列表、字典、元组、结合 容器的基本基础知识
Python第二章知识点
09-08
Python第二章的主要知识点包括： 1. 数据类型：Python提供了多种数据类型，包括整数(int)、浮点数(float)、布尔值(bool)、字符串(str)等。 2. 变量：变量是用于存储数据的容器。在Python中，可以通过赋值语句将值赋给变量，并且不需要事先声明变量的类型。 3. 运算符：Python支持常见的数学运算符（如加减乘除）、比较运算符（如等于、大于、小于等）、逻辑运算符（如与、或、非等）等。 4. 字符串：字符串是由字符组成的序列，在Python中可以使用单引号或双引号括起来表示。可以对字符串进行切片、拼接、格式化等操作。 5. 列表：列表是一种有序的、可变的数据类型，可以包含任意类型的数据。可以通过索引访问和修改列表中的元素，还可以进行切片操作。 6. 元组：元组和列表类似，但是元组是不可变的，即元组创建后不能修改其中的元素。 7. 字典：字典是一种无序的键值对集合，可以根据键获取对应的值。字典中的键必须是唯一的，值可以是任意类型。 8. 条件语句：条件语句用于根据条件执行不同的代码块。Python中的条件语句包括if语句、elif语句和else语句。 9. 循环语句：循环语句用于重复执行一段代码。Python中的循环语句包括for循环和while循环。 10. 函数：函数是一段可重复使用的代码块，可以接收参数并返回结果。在Python中可以使用def关键字定义函数。 这些是Python第二章的主要知识点，希望对你有帮助！如有更多问题，请继续提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

知乎云烟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值