Python初学者学习记录——python数据容器

一、数据容器入门

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

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

              · 是否支持重复元素

              · 是否可以修改

              · 是否有序，等

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

二、列表的定义语法

        1、基本语法：

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

            · 以 [] 作为标识

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

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

# 使用[]的方式定义列表
name_list = ['itheima', 'itcast', 'python']
print(name_list)
print(type(name_list))

# 存储不同类型的数据
my_list = ['itheima', 666, True]
print(my_list)
print(type(my_list))

# 嵌套列表
my_list2 = [[1, 2, 3], [4, 5, 6]]
print(my_list2)
print(type(my_list2))

 

三、列表的下标索引

        1、可以使用列表的下标索引来取出特定位置的数据，列表中的每一个元素，都有其位置的下标索引，从前向后的方向，从0开始，依次递增。或者还可以反向索引，也就是从后向前，从-1开始，依次递减。

        2、嵌套列表的下标索引：列表[下标][下标]

# 列表的下标索引
name_list = ['itheima', 'itcast', 'python']
print(name_list[0])
print(name_list[1])
print(name_list[2], "\n")

# 反向索引
print(name_list[-1])
print(name_list[-2])
print(name_list[-3], "\n")

# 嵌套列表的下标索引
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[0][0], end ='')
print(my_list[0][1], end ='')
print(my_list[0][2], end ='')
print(my_list[1][0], end ='')
print(my_list[1][1], end ='')
print(my_list[1][2])

 

四、列表的常用方法

        1、列表的查询功能

              · 查找某元素的下标

                功能：查找指定元素在列表的下标，如果找不到，报错ValueError

                语法：列表.index(元素)

                index就是列表对象（变量）内置的方法（函数）

# 列表的查询功能
my_list = ['itcast', 'itheima', 'python']
# 查找某元素在列表中的下标索引，语法：列表.index(元素)
index = my_list.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")

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

 

        2、列表的修改功能

              ①修改特定位置（索引）的元素值：

                语法：列表[下标]=值

                可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

              ②插入元素：

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

              ③追加元素：

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

              ④追加元素方式2：

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

              ⑤删除元素：

                语法1：del 列表[下标]    语法2：列表.pop(下标)

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

                语法：列表.remove(元素)

              ⑦清空列表内容：

                语法：列表.clear()

              ⑧统计某元素在列表内的数量：

                语法：列表.count(元素)

              ⑨统计列表内，有多少个元素

                语法：len(列表)，可以得到一个int型数字，表示列表内的元素数量

"""
列表的修改功能
"""


my_list = ["itcast", "itheima", "python"]

# ①修改特定下标索引的数据值，语法：列表[下标]=值
my_list[0] = "传智教育"
print(f"列表被修改元素值后，结果是：{my_list}\n")

# ②在指定下标位置，插入指定元素，语法：列表.insert(下标, 元素)
my_list.insert(2, "IT黑马")
print(f"列表被插入元素值后，结果是：{my_list}\n")

# ③追加元素，语法：列表.append(元素)
my_list.append("年薪百万")
print(f"列表被追加元素后，结果是：{my_list}\n")

# ④追加元素方式2，语法：列表.extend(其它数据容器)
new_list = [1, 2, 3]
my_list.extend(new_list)
print(f"列表在追加了一个新的列表后，结果是：{my_list}\n")

# ⑤删除元素，语法1：del 列表[下标]   语法2：列表.pop(下标)
del my_list[7]
print(f"列表在删除了一个元素后，结果是：{my_list}")
element = my_list.pop(4)
print(f"在列表中删除的元素是：{element}")
print(f"列表在删除了一个元素后，结果是：{my_list}\n")

# ⑥删除某元素在列表中的第一个匹配项
my_list.remove("IT黑马")
print(f"通过remove方法移除元素后，结果是：{my_list}\n")

# ⑦清空列表内容，语法：列表.clear()
my_list.clear()
print(f"列表清空后，结果是：{my_list}\n")

# ⑧统计列表中某元素的数量，列表.count(元素)
my_list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
count = my_list.count(3)
print(f"列表中3的数量为：{count}\n")

# ⑨统计列表内，有多少个元素，语法：len(列表)
length = len(my_list)
print(f"列表中共有：{length}个元素")

        3、列表的方法——总览

        

        4、列表的特点

        ①可以容纳多个元素（上限为2**63-1、9223372036854775807个）

        ②可以容纳不同类型的元素（混装）

        ③数据是有序存储的（有下标序号）

        ④允许重复数据存在

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

五、列表的常用操作练习

# 练习案例：常用功能练习

"""
    有一个列表，内容是：[21, 25, 21, 23, 22, 20]，记录的是一批学生的年龄
    请通过列表的功能（方法），对其进行：
    1、定义这个列表，并用变量接受它
    2、追加一个数字31，到列表的尾部
    3、追加一个新列表[29, 33, 30]
    4、取出第一个元素（应是：21）
    5、取出最后一个元素（应是：30）
    6、查找元素31，在列表中的下标位置
"""

# 1、定义这个列表，并用变量接受它
my_list = [21, 25, 21, 23, 22, 20]
print(f"列表的内容为：{my_list}")
# 2、追加一个数字31，到列表的尾部
my_list.append(31)
print(f"追加31后，列表结果为：{my_list}")
# 3、追加一个新列表[29, 33, 30]
my_list.extend([29, 33, 30])
print(f"追加新列表[29, 33, 30]后，列表结果为：{my_list}")
# 4、取出第一个元素（应是：21）
element1 = my_list[0]
print(f"取出的第一个元素为：{element1}")
print(f"取出第一个元素后，列表结果为：{my_list}")
# 5、取出最后一个元素（应是：30）
element2 = my_list[-1]
print(f"取出的最后一个元素为：{element2}")
print(f"取出最后一个元素后，列表结果为：{my_list}")
# 6、查找元素31，在列表中的下标位置
index = my_list.index(31)
print(f"元素31的下标是：{index}")

 

六、列表（list）的循环遍历

        1、列表的遍历——while循环和for循环

              将数据容器内的元素依次取出进行处理的行为，称之为：遍历、迭代

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

              · 在循环控制上：

                        · while循环可以自定循环条件，并自行控制

                        · for循环不可以自定循环条件，只可以一个个从容器内取出数据

              · 在无限循环上：

                        · while循环可以通过条件控制做到无限循环

                        · for循环理论上不可以，因为被遍历的容器容量不是无限的

              · 在使用场景上：

                        · while循环适用于任何想要循环的场景

                        · for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

# 列表的遍历

# 使用while循环
def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    my_list = ["传智教育", "黑马程序员", "Python"]
    # 定义一个变量用来标记列表的下标
    index = 0
    while index < len(my_list):
        element = my_list[index]
        print(element)
        index += 1


# 使用for循环
def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    my_list = ["传智教育", "黑马程序员", "Python"]
    """
        for循环会依次从数据容器中取出元素
        for循环的语法：
        for 临时变量 in 数据容器：
            对临时变量进行处理
    """
    for element in my_list:
        print(element)

# 调用函数
list_while_func()
list_for_func()

 

        3、练习案例——取出列表内的偶数

# 练习案例————取出列表内的偶数
"""
    定义一个列表，内容是：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    · 遍历列表，取出列表内的偶数，并存入一个新的列表对象中
    · 使用while循环和for循环各操作一次
"""

# 定义一个列表
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 使用while循环
# 定义一个新的空列表
new_list = []
index = 0
while index < len(my_list):
    element = my_list[index]
    if element % 2 == 0:
        new_list.append(element)
    index += 1
print(f"通过while循环，从列表{my_list}中取出偶数，组成新列表{new_list}")

# 使用for循环
# 定义一个新的空列表
new_list = []
for element in my_list:
    if element % 2 == 0:
        new_list.append(element)
print(f"通过for循环，从列表{my_list}中取出偶数，组成新列表{new_list}")

七、元组（tuple）的定义和操作

        1、为什么需要元组？

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

        2、元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于：元组一旦定义完成，就不可以修改。所以当需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了。

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

              

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

 

        4、注意事项：只有一个元素的元组，元素后必须要添加一个逗号，否则就是不是元组

# 定义3个元素的元组
t1 = (1, 'Hello', True)
print(f"t1的类型是：{type(t1)}，内容是：{t1}")

# 定义1个元素的元组
t2 = ('Hello', ) # 必须要求逗号，否则就不是元组了
print(f"t1的类型是：{type(t2)}，内容是：{t2}")
# 演示没有逗号
t2 = ('Hello') #没逗号，不是元组，是字符串
print(f"t1的类型是：{type(t2)}，内容是：{t2}")

 

        5、元组的相关操作

           取元组中元素的操作和列表一样：元组[下标]；嵌套元组的话：元组[下标][下标]

        

# 定义一个元组t
t = ("传智教育", "黑马程序员", "黑马程序员", "Python")

# 元组的操作：index查找方法
location = t.index("黑马程序员")
print(f"在元组t中查找黑马程序员的下标是：{location}")

# 元组的操作：count统计方法
count = t.count("黑马程序员")
print(f"元组t中统计黑马程序员的数量是：{count}")

# 元组的操作：len函数统计元组中元素的数量
num = len(t)
print(f"元组t中的元素数量是：{num}")

# 元组的遍历：while循环
print("用while循环遍历元组t中的元素是：", end ='')
index = 0
while index < len(t):
    element = t[index]
    print(element, end =' ')
    index += 1

print() # 换行

# 元组的遍历：for循环
print("用for循环遍历元组t中的元素是：", end ='')
for element in t:
    print(element, end=' ')

 

        6、元组的注意事项：

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

# 定义一个元组t
t = ("传智教育", "黑马程序员", "黑马程序员", "Python")

# 修改元组内容，会直接报错
t[0] = "itcast"
print(t)

 

              · 可以修改元组内嵌套的列表的内容（修改元素、增加、删除）

# 定义元组
t = (1, 2, ["itheima", "itcast"])

# 修改元组中列表的内容
print(f"元组t中的内容是：{t}")
t[2][0] = "黑马程序员"
t[2][1] = "传智教育"
print(f"修改后元组t中的内容是：{t}")

 

        7、练习案例——元组的基本操作

# 练习案例————元组的基本操作
"""
    定义一个元组，内容是：('周杰伦', 11, ['football', 'music'])
    记录的是一个学生的信息（姓名、年龄、爱好）

    请通过元组的功能（方法），对其进行
    1、查询其年龄所在的下标位置
    2、查询学生的姓名
    3、删除学生爱好中的football和music
    4、增加爱好：coding到爱好list内
"""

# 定义一个元组
message = ('周杰伦', 11, ['football', 'music'])

# 1、查询其年龄所在的下标位置
print(f"年龄所在的下标位置是：{message.index(11)}")

# 2、查询学生的姓名
index = message.index("周杰伦")
print(f"姓名所在的下标位置是：{index}")
print(f"学生的姓名是：{message[index]}")

# 3、删除学生爱好中的football和music
message[2].remove("football") # 按值删除
print(f"元组message中的内容为：{message}")
message[2].pop(0) # 按下标删除
print(f"元组message中的内容为：{message}")

# 4、增加爱好：coding到爱好list内
message[2].insert(0, 'coding')
print(f"元组message中的内容为：{message}")

 

八、字符串的定义和操作

        1、字符串也是一类数据容器，字符串是字符的容器，一个字符串可以存放任意数量的字符；它和其它容器如：列表、元组一样，字符串也可以通过下标进行访问。

              · 从前向后，下标从0开始

              · 从后向前，下标从-1开始

        2、同元组一样，字符串是一个：无法修改的数据容器。如果必须要进行修改操作，只能得到一个新的字符串，旧的字符串是无法修改的。

        3、字符串的常用操作

              ①查找特定字符串的下标索引值

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

              ②字符串的替换

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

                功能：将字符串内的全部：字符串1，替换为字符串2

                注意：不是修改字符串本身，而是得到了一个新的字符串

              ③字符串的分割

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

                功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

                注意：字符串本身不变，而是得到了一个列表对象

              ④字符串的规整操作1（去首尾空格）

                语法：字符串.strip()

                

              ⑤字符串的规整操作2（去首尾指定字符串）

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

                

                注意，传入的是"12"  其实就是："1"和"2"都会移除，是按照单个字符。

              ⑥统计字符串中某字符串的出现次数

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

              ⑦统计字符串的长度

                语法：len(字符串)

# 字符串的常用操作

my_str = "itcast and itheima"

# ①查找特定字符串的下标索引值，语法：字符串.index(字符串)
value = my_str.index("and")
print(f"查找and的起始下标是：{value}\n")

# ②字符串的替换，语法：字符串.replace(字符串1, 字符串2)
new_my_str = my_str.replace("and", "or")
print(f"将字符串{my_str}进行替换后得到：{new_my_str}\n")

# ③字符串的分割，语法：字符串.split(分隔符字符串)
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split分割后得到：{my_str_list}")
print(f"{my_str_list}类型是：{type(my_str_list)}\n")

# ④字符串的规整操作1，语法：字符串.strip()
my_str2 = "  itheima and itcast  "
new_my_str2 = my_str2.strip()
print(f"字符串{my_str2}进行规整操作后得到：{new_my_str2}")

# ⑤字符串的规整操作2，语法：字符串.strip(字符串)
my_str3 = "12itheima and itcast21"
new_my_str3 = my_str3.strip("12")
print(f"字符串{my_str3}进行规整操作后得到：{new_my_str3}\n")

# ⑥统计字符串中某字符出现的次数，语法：字符串.count(字符串)
my_str4 = "itcast and itheima"
count = my_str4.count("it")
print(f"字符串{my_str4}中it出现的次数是：{count}\n")

# ⑦统计字符串中的长度，语法：len(字符串)
length = len(my_str4)
print(f"字符串{my_str4}的长度是：{length}")

 

        4、字符串常用操作汇总

        

        5、字符串的遍历

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

# 字符串的遍历————while循环和for循环实现

# 定义一个字符串
my_str = "学Python，年薪百万"

# while循环实现
index = 0
while index < len(my_str):
    element = my_str[index]
    print(element, end ='')
    index += 1

print() # 空一行

# for循环实现
for element in my_str:
    print(element, end ='')

 

        6、字符串的特点

              · 只可以存储字符串

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

              · 支持下标索引

              · 允许重复字符串存在

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

              · 支持while循环的for循环

九、字符串的练习——分割字符串

# 练习案例————分割字符串
"""
    给定一个字符串："itheima itcast boxuegu"
    · 统计字符串内有多少个"it"字符
    · 将字符串内的空格，全部替换为字符："|"
    · 并按照"|"进行字符串分割，得到列表
"""

# 定义字符串
my_str = "itheima itcast boxuegu"

# 统计字符串内有多少个"it"字符
num = my_str.count("it")
print(f"字符串{my_str}中it的个数是：{num}\n")

# 将字符串内的空格，全部替换为字符："|"
new_str = my_str.replace(" ", "|")
print(f"字符串{my_str}经过替换后得到：{new_str}\n")

# 并按照"|"进行字符串分割，得到列表
my_list = new_str.split("|")
print(f"字符串{new_str}用|分隔后得到：{my_list}")

 

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

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

        2、序列的常用操作——切片

              切片：从一个序列中，取出一个子序列

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

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

              · 起始下标表示从何处开始，可以留空，留空视为从头开始

              · 结束下标（不含本身）表示何处结束，可以留空，留空视为截取到结尾

              · 步长表示，依次取元素的间隔，注意如果步长为负数，表示反向取（起始下标和结束下标也要反向标记）

                注意：切片操作不会影响序列本身，而是会得到一个新的序列（元组、字符串都是不可修改的）

# 序列的切片

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

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

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

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

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

# 对元组进行切片，从头开始，到最后结束，步长为-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result7 = my_tuple[::-2]
print(f"新的序列为：{result7}")

 

十一、序列的切片练习

# 练习案例————序列的切片实践
"""
    有字符串："万百薪年，员序程马黑来，nohtyP学"
    · 请使用学过的任何方式，得到"黑马程序员"
"""

# 定义字符串
my_str = "万百薪年，员序程马黑来，nohtyP学"

# 1、倒序字符串，切片取出
result1 = my_str[::-1][9:14]
print(f"结果1为：{result1}")

print()  # 空一行

# 2、切片取出，然后倒序
result2 = my_str[5:10][::-1]
print(f"结果2为：{result2}")

print()  # 空一行

# 3、反向切片取出
result3 = my_str[9:4:-1]
print(f"结果3为：{result3}")

print()  # 空一行

# 4、split分隔"，"得到列表，再取出第二个元素（字符串），再用replace替换"来"为空，倒序字符串
result4 = my_str.split("，")[1].replace("来", "")[::-1]
print(f"结果4为：{result4}")

 

十二、集合（set）的定义和操作

        1、列表、元组、字符串支持重复元素且有序，而集合不支持元素的重复（自带去重功能）、并且内部是无序的

              基本语法：

              

# 定义集合
my_set = {"传智教育", "黑马程序员", "Python","传智教育", "黑马程序员", "Python","传智教育", "黑马程序员", "Python"}
my_set_empty = set()  # 定义空集合
print(my_set)  # 会去重、乱序
print(my_set_empty)

 

        2、集合的常用操作——修改

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

              ①添加新元素

                语法：集合.add(元素)，将指定元素，添加到集合内

              ②移除元素

                语法：集合.remove(元素)，将指定元素，从集合内移除

              ③从集合中随机取出元素

                语法：集合.pop()，从集合中随机取出一个元素

              ④清空集合

                语法：集合.clear()

              ⑤取出2个集合的差集

                语法：集合1.difference(集合2)，取出集合1和集合2的差集（集合1有而集合2没有的）

              ⑥消除2个集合的差集

                语法：集合1.difference_update(集合2)，对比集合1和集合2，在集合1内，删除和集合2相同的元素。集合1被修改，集合2不变

              ⑦2个集合合并

                语法：集合1.union(集合2)，将集合1和集合2组合成新集合

              ⑧统计集合元素的数量

                语法：len(集合)

# 定义集合
my_set = {"传智教育", "黑马程序员", "Python","传智教育", "黑马程序员", "Python","传智教育", "黑马程序员", "Python"}
my_set_empty = set()  # 定义空集合
print(my_set)  # 会去重、乱序
print(my_set_empty)

# ①添加新元素，语法：集合.add(元素)
my_set.add("itcast")
my_set.add("传智教育")
print(f"my_set添加元素后结果为：{my_set}")

# ②移除元素，语法：集合.remove(元素)
my_set.remove("黑马程序员")
print(f"my_set移除元素后结果为：{my_set}")

# ③随机取出一个元素，语法：集合.pop()
element = my_set.pop()
print(f"从my_set中随机取出的元素为：{element}，取出元素后结果为：{my_set}")

# ④清空集合，语法：集合.clear()
my_set.clear()
print(f"清空后的集合为：{my_set}")

print()   # 空一行

# ⑤取出2个集合的差集，语法：集合1.difference(集合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个集合的差集，语法：集合1.difference_update(集合2)
set1.difference_update(set2)
print(f"消除差集后，set1的内容是：{set1}")
print(f"消除差集后，set2的内容是：{set2}")

print()  # 空一行

# ⑦2个集合合并，语法：集合1.union(集合2)
set4 = {1, 2, 3}
set5 = {1, 5, 6}
set6 = set4.union(set5)
print(f"set4和set5合并后的结果是：{set6}")
print(f"合并后，set4的内容是：{set4}")
print(f"合并后，set5的内容是：{set5}")

# ⑧统计集合元素数量，语法：len(集合)
set7 = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4}
length = len(set7)
print(f"set6的元素数量是：{length}")

 

        3、集合的遍历

              集合不支持下标索引，不能用while循环。可以使用for循环

# 集合的遍历

my_set = {"传智教育", "黑马程序员", "Python","传智教育", "黑马程序员", "Python","传智教育", "黑马程序员", "Python"}
print(f"集合中的元素有：{my_set}")
for element in my_set:
    print(element)

 

        4、集合的常用操作总结

        

        5、集合的特点

              · 可以容纳多个数据

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

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

              · 不允许重复数据存在

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

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

十三、集合的练习——信息去重

# 练习案例————信息去重
"""
    有如下列表对象：
    my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客', 'itheima', 'itcast', 'itheima', 'itcast', 'best']

    请：
    · 定义一个集合
    · 通过for循环遍历列表
    · 在for循环中将列表的元素添加至集合
    · 最终得到元素去重后的集合对象，并打印输出
"""

# 已知my_list列表
my_list = ['黑马程序员', '传智播客', '黑马程序员', '传智播客',
           'itheima', 'itcast', 'itheima', 'itcast', 'best']

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

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

# 最终得到元素去重后的集合对象，并打印输出
print(f"有列表：{my_list}")
print(f"存入集合后结果是：{my_set}")

十四、字典的定义

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

        

        2、字典数据的获取

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

# 定义字典
my_dict = {"王力鸿": 99, "周杰伦": 88, "林俊杰": 77}

value1 = my_dict["王力鸿"]
value2 = my_dict["周杰伦"]
value3 = my_dict["林俊杰"]
print(value1, value2, value3)

 

        3、字典的嵌套

              字典的key和value可以是任意数据类型（key不可以是字典）

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

# 从嵌套的字典中获取数据
score1 = stu_score_dict["王力鸿"]["数学"]
print(f"王力鸿的数学成绩是：{score1}")

score2 = stu_score_dict["林俊杰"]["英语"]
print(f"林俊杰的英语成绩是：{score2}")

score3 = stu_score_dict["周杰伦"]["语文"]
print(f"周杰伦的语文成绩是：{score3}")

 

        4、注意事项

              · 键对值的key和value可以是任意类型（key不可以为字典）

              · 字典内key不允许重复，重复添加等同于覆盖原有数据

              · 字典不可以使用下标索引，而是通过key检索value

十五、字典的常用操作

        1、字典的常用操作

              ①新增元素：

                语法：字典[key] = value，结果：字典被修改，新增了元素

              ②更新元素：

                语法：字典[key] = value，结果：字典被修改，元素被更新

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

              ③删除元素

                语法：字典.pop(key)，结果：获得指定key的value，同时字典被修改，指定key的数据被删除

              ④清空字典

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

              ⑤获取全部的key

                语法：字典.keys()，结果是：得到字典中的全部key

              ⑥统计字典内的元素数量

                语法：len(字典)

# 字典的常用操作演示

my_dict = {"周杰伦": 99, "林俊杰": 88, "张学友":77}
print(f"字典内容是：{my_dict}")

# ①新增元素，语法：字典[key] = value
my_dict["王力红"] = 66
print(f"字典新增元素后结果是：{my_dict}")

# ②更新元素，语法：字典[key] = value
my_dict["周杰伦"] = 33
print(f"字典更新元素后结果是：{my_dict}")

# ③删除元素，语法：字典.pop(key)
value = my_dict.pop("周杰伦")
print(f"删除元素的value是：{value}，删除元素后的字典是：{my_dict}")

# ④清空字典，字典.clear()
my_dict.clear()
print(f"字典被清空后结果是：{my_dict}\n")

my_dict = {"周杰伦": 99, "林俊杰": 88, "张学友":77}
print(f"字典的内容是：{my_dict}")
# ⑤获取全部的key，语法：字典.keys()
keys = my_dict.keys()
print(f"字典中的全部key是：{keys}")

# ⑥统计字典内的元素数量，语法：len(字典)
length = len(my_dict)
print(f"字典内的元素数量是：{length}")

        2、字典的遍历

my_dict = {"周杰伦": 99, "林俊杰": 88, "张学友":77}
print(f"字典内容是：{my_dict}")

# 遍历字典，通过for循环，不能用while循环
# 方式1：通过获取到全部的key来完成遍历
keys = my_dict.keys()
print(f"字典中的全部key是：{keys}")
for key in keys:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dict[key]}")

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

 

        3、字典的常用方法总结

        

        4、字典的特点

              · 可以容纳多个数据

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

              · 每一份数据是key和value键值对

              · 可以通过key获取到value，key不可重复（重复会覆盖）

              · 不支持下标索引

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

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

十六、字典的练习

        有如下员工信息，请使用字典完成数据的记录

        并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元

        

# 练习案例————升职加薪

# 定义字典
my_dict = {
    "王力鸿": {
        "部门": "科技部", "工资": 3000, "级别": 1
    }, "周杰伦": {
        "部门": "市场部", "工资": 5000, "级别": 2
    }, "林俊杰": {
        "部门": "市场部", "工资": 7000, "级别": 3
    }, "张学友": {
        "部门": "科技部", "工资": 4000, "级别": 1
    }, "刘德华": {
        "部门": "市场部", "工资": 6000, "级别": 2
    }
}

# 输出全体员工当前信息
print(f"全体员工当前信息如下：\n{my_dict}")

# 将所有级别为1级的员工工资上升1000，级别上升1级
for name in my_dict:
    if my_dict[name]["级别"] == 1:
        my_dict[name]["级别"] += 1
        my_dict[name]["工资"] += 1000
print(f"全部级别为1的员工完成升值加薪后，当前全体员工的信息是：\n{my_dict}")

 

十七、5类数据容器的总结对比

        1、数据容器分类

              ①是否支持下标索引：

                      · 支持：列表、元组、字符串 —— 序列类型

                      · 不支持：集合、字典 —— 非序列类型

              ②是否支持重复元素：

                      · 支持：列表、元组、字符串 —— 序列类型

                      · 不支持：集合、字典 —— 非序列类型

              ③是否可以修改：

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

                      · 不支持：元组、字符串

        

十八、数据容器的通用操作

        1、遍历

              列表、元组、字符串支持while循环和for循环进行遍历；集合、字典支持for循环进行遍历，不支持while循环进行遍历。

        2、通用统计功能

              len(容器)：统计容器的元素个数

              max(容器)：统计容器的最大元素

              min(容器)：统计容器的最小元素

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

print()  # 空一行
# 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)}")

print()  # 空一行
# 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)}")

 

        3、通用转换功能

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

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

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

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

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}

# 类型转换：容器转列表
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)}")  # 会抛弃value值，只保留key值

print() # 空一行
# 类型转换：容器转元组
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)}")  # 会抛弃value值，只保留key值

print()  # 空一行
# 类型转换：容器转字符串
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)}")  # 转换后："{1, 2, 3, 4, 5}"
print(f"字典转字符串的结果是：{str(my_dict)}")  # 转换后："{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}"

print()  # 空一行
# 类型转换：容器转集合
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)}")  # 转换后：会乱序、去重、会抛弃value值，只保留key值

 

        4、通用排序功能

              sorted(容器, reverse = True)：将给定容器进行排序（从大到小），省略 reverse = True 就是从小到大排序，排序后的结果会转成列表

my_list = [1, 3, 2, 5, 4]
my_tuple = (1, 4, 3, 2, 5)
my_str = "agcfedb"
my_set = {3, 2, 1, 5, 4}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# 进行排序操作，语法：sorted(容器, reverse = True)
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)}")  # 会丢失value值

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)}")  # 会丢失value值

 

        5、容器通用功能总览