微信
支付宝
# 3. Python容器 ### 先总结😁😁 \*\*数据容器分类：\*\* \* 是否支持下标索引 \* 支持：列表、元组、字符串 -- 序列类型 \* 不支持：集合、字典 - -非序列类型 \* 是否支持重复元素： \* 支持：列表、元组、字符串 - 序列类型 \* 不支持：集合、字典 - 非序列类型 \* 是否可以修改 \* 支持：列表、集合、字典 \* 不支持：元组、字符串 \*\*数据容器特点对比：\*\* \| \*\* \*\* \| \*\*列表\*\* \| \*\*元组\*\* \| \*\*字符串\*\* \| \*\*集合\*\* \| \*\*字典\*\* \| \| -------- \| -------------------------------- \| ---------------------------------- \| ------------------ \| ---------------------- \| ---------------------------------------------- \| \| 元素数量 \| 支持多个 \| 支持多个 \| 支持多个 \| 支持多个 \| 支持多个 \| \| 元素类型 \| 任意 \| 任意 \| 仅字符 \| 任意 \| Key：ValueKey：除字典外任意类型Value：任意类型 \| \| 下标索引 \| 支持 \| 支持 \| 支持 \| 不支持 \| 不支持 \| \| 重复元素 \| 支持 \| 支持 \| 支持 \| 不支持 \| 不支持 \| \| 可修改性 \| 支持 \| 不支持 \| 不支持 \| 支持 \| 支持 \| \| 数据有序 \| 是 \| 是 \| 是 \| 否 \| 否 \| \| 使用场景 \| 可修改、可重复的一批数据记录场景 \| 不可修改、可重复的一批数据记录场景 \| 一串字符的记录场景 \| 不可重复的数据记录场景 \| 以Key检索Value的数据记录场景 \| \*\*特点：\*\*基于各类数据容器的特点，它们的应用场景如下： \* 列表：一批数据，可修改、可重复的存储场景 \* 元组：一批数据，不可修改、可重复的存储场景 \* 字符串：一串字符串的存储场景集合：一批数据，去重存储场景 \* 字典：一批数据，可用Key检索Value的存储场景 \*\*容器通用功能总览\*\* \| \*\*功能\*\* \| \*\*描述\*\* \| \| ---------------------------- \| -------------------------------------------------- \| \| 通用for循环 \| 遍历容器（字典是遍历key） \| \| max \| 容器内最大元素 \| \| min() \| 容器内最小元素 \| \| len() \| 容器元素个数 \| \| list() \| 转换为列表 \| \| tuple() \| 转换为元组 \| \| str() \| 转换为字符串 \| \| set() \| 转换为集合 \| \| sorted(序列, \[reverse=True\]) \| 排序，reverse=True表示降序得到一个排好序的list列表 \| \`\`\`python """ 演示数据容器的通用功能 """ 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)}") # 进行容器的排序 my_list = \[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)}") # 输出key，value丢失，顺序混乱 \`\`\` ### 1. Python中的数据容器 一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。数据容器根据特点的不同，如：是否支持重复元素是否可以修改是否有序，等分为5类，分别是： \*\*列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）\*\* ### 2. 函数和方法 函数是一个封装的代码单元，可以提供特定功能。在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法。 方法和函数功能一样， 有传入参数，有返回值，只是方法的使用格式不同： \> 函数的使用：num = add(1,2) \> \> 方法的使用：student = Student() \> \> num = student.add(1,2) \`\`\`python # 函数 def add(x,y): return x + y # 方法：在类中的函数 class Student: def add(self, x, y); return x +y \`\`\` ### 3. 列表（list） 列表内的每一个数据，称之为元素。 \* 以 \[ \] 作为标识。 \* 列表内每一个元素之间用逗号隔开。 \* 列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套。 \* 元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表。 \*\*基本语法\*\*  \`\`\`python # 定义一个列表 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)) \`\`\` \*\*列表的下标（索引）\*\* 正向索引：从前向后的方向，从0开始，依次递增  反向索引：从后向前，下标索引为：-1、-2、-3，依次递减。 !\[image-20240307163859584\](https://hgh-typora-image.oss-cn-guangzhou.aliyuncs.com/img/image-20240307163859584.png) \*\*嵌套列表的下标（索引）\*\* !\[image-20240307164128160\](https://hgh-typora-image.oss-cn-guangzhou.aliyuncs.com/img/image-20240307164128160.png) \`\`\`python # 定义一个嵌套的列表 my_list = \[ \[1, 2, 3\], \[4, 5, 6\]\] print(my_list) print(type(my_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\]) \`\`\` \*\*列表的常用操作（方法）\*\* 查询：列表.index(元素) 修改：列表\[下标\] = 值 插入：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素 追加1：列表.append(元素)，将指定元素，追加到列表的尾部 追加2：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部 删除1：del 列表\[下标\] 删除2：列表.pop(下标) 删除某元素在列表中的第一个匹配项：列表.remove(元素) 清空列表内容：列表.clear() 统计某元素在列表内的数量：列表.count(元素) 统计列表内，有多少元素：len(列表) ，可以得到一个int数字，表示列表内的元素数量 \| \*\*编号\*\* \| \*\*使用方式\*\* \| \*\*作用\*\* \| \| -------- \| ----------------------- \| -------------------------------------------- \| \| 1 \| 列表.append(元素) \| 向列表中追加一个元素 \| \| 2 \| 列表.extend(容器) \| 将数据容器的内容依次取出，追加到列表尾部 \| \| 3 \| 列表.insert(下标, 元素) \| 在指定下标处，插入指定的元素 \| \| 4 \| del 列表\[下标\] \| 删除列表指定下标元素 \| \| 5 \| 列表.pop(下标) \| 删除列表指定下标元素 \| \| 6 \| 列表.remove(元素) \| 从前向后，删除此元素第一个匹配项 \| \| 7 \| 列表.clear() \| 清空列表 \| \| 8 \| 列表.count(元素) \| 统计此元素在列表中出现的次数 \| \| 9 \| 列表.index(元素) \| 查找指定元素在列表的下标找不到报错ValueError \| \| 10 \| len(列表) \| 统计容器内有多少元素 \| \*\*列表的特点\*\* \* 可以容纳多个元素（上限为2\^63\^-1、9223372036854775807个） \* 可以容纳不同类型的元素（混装） \* 数据是有序存储的（有下标序号） \* 允许重复数据存在 \* 可以修改（增加或删除元素等） \`\`\`python """ 演示数据容器之：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种方式） mylist = \["itcast", "itheima", "python"\] # 6.1 方式1：del 列表\[下标\] 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"列表中itheima的数量是：{count}") # 10. 统计列表中全部的元素数量 mylist = \["itcast", "itheima", "itcast", "itheima", "python"\] count = len(mylist) print(f"列表的元素数量总共有：{count}个") \`\`\` \*\*列表的遍历 - while循环和for循环\*\* 既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。 while循环和for循环的对比： \* 在循环控制上： \* while循环可以自定循环条件，并自行控制 \* for循环不可以自定循环条件，只可以一个个从容器内取出数据 \* 在无限循环上： \* while循环可以通过条件控制做到无限循环 \* for循环理论上不可以，因为被遍历的容器容量不是无限的 \* 在使用场景上： \* while循环适用于任何想要循环的场景 \* for循环适用于，遍历数据容器的场景或简单的固定次数循环场景 \`\`\`python """ 演示使用while和for循环遍历列表 """ def list_while_func(): """ 使用while循环遍历列表的演示函数 :return: None """ my_list = \[1,2,3,4,5\] # 循环控制变量：通过下标索引来控制，默认0 # 每一次循环将下标+1 index = 0 while index \< len(my_list): # 通过index变量取出对应下标的元素 element = my_list\[index\] print(f"列表元素有：{element}") list_while_func() def list_for_func(): """ 使用for循环遍历列表的演示函数 :return: """ my_list = \[1,2,3,4\] # for 临时变量 in 数据容器： for element in my_list: print(f"列表元素有：{element}") list_for_func() \`\`\` ### 4.元组（tuple) 元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于：元组一旦定义完成，就不可修改。所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了。 \*\*定义：\*\*定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。  \*\*注意：\*\*元组只有一个数据，这个数据后面要添加逗号 \`\`\`python # 定义单个元素的元素 t4 = ("hello", ) print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}") \`\`\` \*\*元组的嵌套：\*\* \`\`\`python t5 = ( (1, 2, 3), (4, 5, 6) ) print(f"t5的类型是：{type(t5)}, 内容是：{t5}") \`\`\` \*\*元组的常用操作：\*\*元组由于不可修改的特性，所以其操作方法非常少 \| \*\*编号\*\* \| \*\*方法\*\* \| \*\*作用\*\* \| \| -------- \| --------- \| -------------------------------------------------- \| \| 1 \| index() \| 查找某个数据，如果数据存在返回对应的下标，否则报错 \| \| 2 \| count() \| 统计某个数据在当前元组出现的次数 \| \| 3 \| len(元组) \| 统计元组内的元素个数 \| \*\*注意事项：\*\* \* 不可以修改元组的内容，否则会直接报错 \* 可以修改嵌套在元组内的\*\*list\*\*的内容（修改元素、增加、删除、反转等） \* 不可以替换\*\*list\*\*为其它\*\*list\*\*或其它类型 \`\`\`python # 定义一个元组(嵌套一个list列表) t9 = (1, 2, \["hgh", "hgh"\]) print(f"t9的内容是：{t9}") t9\[2\]\[0\] = "6" t9\[2\]\[1\] = "6" print(f"t9的内容是：{t9}") \`\`\` \*\*元组的特点：\*\* \* 可以容纳多个数据 \* 可以容纳不同类型的数据（混装） \* 数据是有序存储的（下标索引） \* 允许重复数据存在 \* \*\*不可以修改\*\*（增加或删除元素等）------多数特性和list一致，不同点在于不可修改的特性。 \* 支持for循环 ### 5. 字符串 字符串是字符的容器，一个字符串可以存放任意数量的字符。尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。但不可否认的是，字符串同样也是数据容器的一员。 !\[image-20240307211058465\](https://hgh-typora-image.oss-cn-guangzhou.aliyuncs.com/img/image-20240307211058465.png) \*\*字符串的下标（索引）\*\* 和其它容器如：列表、元组一样，字符串也可以通过下标进行访问：从前向后，下标从0开始；从后向前，下标从-1开始。 同元组一样，字符串是一个：\*\*无法修改的数据容器\*\*。所以： \* 修改指定下标的字符 （如：字符串\[0\] = "a"） \* 移除特定下标的字符 （如：del 字符串\[0\]、字符串.remove()、字符串.pop()等） \* 追加字符等 （如：字符串.append()） 等等，均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改。 \*\*字符串的常用操作\*\* \* 查找特定字符串的下标索引值：\*\*字符串.index(字符串)\*\* \* 字符串的替换：\*\*字符串.replace(字符串1，字符串2）\*\* \* 功能：将字符串内的全部：字符串1，替换为字符串2 \* 注意：字符串本身并没有被修改，而是得到了一个新字符串 \* 字符串的分割：\*\*字符串.split(分隔符字符串）\*\* \* 功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中 \* 字符串本身不变，而是得到了一个列表对象（字符串按照给定的 \<空格\>进行了分割，变成多个子字符串，并存入一个列表对象中）。 \* 字符串的规整操作（去前后空格）：\*\*字符串.strip()\*\* \* 字符串的规整操作（去前后指定字符串：\*\*字符串.strip(字符串)\*\* \* 传入的是"12" 其实就是："1"和"2"都会移除，是按照单个字符。 \* 统计字符串中某字符串的出现次数：\*\*字符串.count(字符串)\*\* \* 统计字符串的长度：\*\*len(字符串)\*\* \* 注意：数字，字母，符号，中文，空格均算作1个字符 \| \*\*编号\*\* \| \*\*操作\*\* \| \*\*说明\*\* \| \| -------- \| ---------------------------------- \| ------------------------------------------------------------ \| \| 1 \| 字符串\[下标\] \| 根据下标索引取出特定位置字符 \| \| 2 \| 字符串.index(字符串） \| 查找给定字符的第一个匹配项的下标 \| \| 3 \| 字符串.replace(字符串1, 字符串2) \| 将字符串内的全部字符串1，替换为字符串2不会修改原字符串，而是得到一个新的 \| \| 4 \| 字符串.split(字符串) \| 按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表 \| \| 5 \| 字符串.strip()字符串.strip(字符串) \| 移除首尾的空格和换行符或指定字符串 \| \| 6 \| 字符串.count(字符串) \| 统计字符串内某字符串的出现次数 \| \| 7 \| len(字符串) \| 统计字符串的字符个数 \| \`\`\`python """ 演示以数据容器的角色，学习字符串的相关操作 """ my_str = "itheima and itcast" # 通过下标索引取值 value = my_str\[2\] value2 = my_str\[-16\] print(f"从字符串{my_str}取下标为2的元素，。值是：{value},取下标为-16的元素。值是：{value2}") # index方法 value = my_str.index("and") print(f"在字符串{my_str}中查找and，其起始下标是：{value}") # 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") 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}") \`\`\` \*\*字符串的特点：\*\* \* 只可以存储字符串 \* 长度任意（取决于内存大小） \* 支持下标索引 \* 允许重复字符串存在 \* 不可以修改（增加或删除元素等） \* 支持for循环 字符串基本和列表、元组相同 不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。 不同于列表，相同于元组的在于：字符串不可修改 ### 6. 序列 序列是指：内容连续、有序，\*\*可使用下标索引\*\*的一类数据容器。列表、元组、字符串，均可以可以视为序列。 \*\*序列的常用操作 - 切片\*\* 切片：从一个序列中，取出一个子序列。序列支持切片，即：列表、元组、字符串，均支持进行切片操作。 语法：\*\*序列\[起始下标: 结束下标: 步长\]\*\* 表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列： \* 起始下标表示从何处开始，可以留空，留空视作从头开始 \* 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾 \* 步长表示，依次取元素的间隔 \* 步长1表示，一个个取元素 \* 步长2表示，每次跳过1个元素取 \* 步长N表示，每次跳过N-1个元素取 \* 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记） \*\*注意：\*\*此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串） \`\`\`python """ 演示对序列进行切片操作 """ # 对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}") \`\`\` ### 7. 集合（set） 不支持元素的重复（自带去重功能）、并且内容无序的容器。（\*\*去重且无序\*\*） \*\*基本语法：\*\*  \*\*注意：\*\*定义空集合只能用set()，大括号{}已被字典占用 \*\*集合的常用操作 \*\* 首先，因为集合是无序的，所以\*\*集合不支持下标索引访问\*\*但是集合和列表一样，是允许修改的。 \* 添加新元素：\*\*集合.add(元素)\*\*。将指定元素，添加到集合内。 \* 移除元素：\*\*集合.remove(元素)\*\*。将指定元素，从集合内移除。 \* 从集合中==随机==取出元素：\*\*集合.pop()\*\*。会得到一个元素的结果。同时集合本身被修改，元素被移除。 \* 清空集合：\*\*集合.clear()\*\*。 \* 取出2个集合的差集：\*\*集合1.difference(集合2)\*\*。取出集合1和集合2的差集（==集合1有而集合2没有的==） \* 消除2个集合的交集：\*\*集合1.difference_update(集合2)\*\*。删除集合1中和集合2有的元素。（==集合1被修改，集合2不变==） \* 2个集合合并：\*\*集合1.union(集合2)\*\* 。将集合1和集合2组合成新集合（==并集==） \* 查看集合的元素数量：\*\*len(集合)\*\* \*\*注意：\*\*集合支持for循环，但因为集合不支持下标索引，所以也就\*\*不支持使用while循环\*\*。 \| \*\*编号\*\* \| \*\*操作\*\* \| \*\*说明\*\* \| \| -------- \| ------------------------------ \| --------------------------------------------------------- \| \| 1 \| 集合.add(元素) \| 集合内添加一个元素 \| \| 2 \| 集合.remove(元素) \| 移除集合内指定的元素 \| \| 3 \| 集合.pop() \| 从集合中随机取出一个元素 \| \| 4 \| 集合.clear() \| 将集合清空 \| \| 5 \| 集合1.difference(集合2) \| 得到一个新集合，内含2个集合的差集，原有的2个集合内容不变 \| \| 6 \| 集合1.difference_update(集合2) \| 在集合1中，删除集合2中存在的元素，集合1被修改，集合2不变 \| \| 7 \| 集合1.union(集合2) \| 得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变 \| \| 8 \| len(集合) \| 得到一个整数，记录了集合的元素数量 \| \*\*集合的特点：\*\* \* 可以容纳多个数据 \* 可以容纳不同类型的数据（混装） \* 数据是无序存储的（不支持下标索引） \* 不允许重复数据存在 \* 可以修改（增加或删除元素等） \* 支持for循环 \`\`\`python """ 演示数据容器集合的使用 """ # 定义集合 my_set = {"a", "b", "i", "d", "j", "r", "t", "y", "u"} 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"消除差集后，集合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}") # 统计集合元素数量len() set1 = {1, 2, 3, 4, 5, 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}") \`\`\` ### 8. 字典（dict) 字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法： \* 使用{}存储原始，每一个元素是一个键值对 \* 每一个键值对包含Key和Value（用冒号分隔） \* 键值对之间使用逗号分隔 \* Key和Value可以是任意类型的数据（key不可为字典） \* ==Key不可重复，重复会对原有数据覆盖==  \*\*字典的获取：\*\*字典同集合一样，不可以使用下标索引，但是字典可以通过Key值来取得对应的Value \*\*字典的嵌套：\*\*字典的Key和Value可以是任意数据类型（Key不可为字典） \`\`\`python\\ """ 演示数据容器字典的定义 """ # 定义字典 my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77} # 定义空字典 my_dict2 = {} my_dict3 = dict() print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}") # 定义重复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 }, "周杰轮": { "语文": 88, "数学": 86, "英语": 55 }, "林俊节": { "语文": 99, "数学": 96, "英语": 66 } } print(f"学生的考试信息是：{stu_score_dict}") # 从嵌套字典中获取数据 score = stu_score_dict\["周杰轮"\]\["语文"\] print(f"周杰轮的语文分数是：{score}") \`\`\` \*\*字典的常用操作：\*\* \* 新增元素 语法：字典\[Key\] = Value \* 更新元素 语法：字典\[Key\] = Value。（key已存在） \* 删除元素 语法：字典.pop(Key) \* 清空字典 语法：字典.clear() \* 获取全部的key 语法：字典.keys() \* 遍历字典 语法：for key in 字典.keys() \* 计算字典内的全部元素（键值对）数量 语法：len(字典) \| \*\*编号\*\* \| \*\*操作\*\* \| \*\*说明\*\* \| \| -------- \| ----------------- \| --------------------------------------------- \| \| 1 \| 字典\[Key\] \| 获取指定Key对应的Value值 \| \| 2 \| 字典\[Key\] = Value \| 添加或更新键值对 \| \| 3 \| 字典.pop(Key) \| 取出Key对应的Value并在字典内删除此Key的键值对 \| \| 4 \| 字典.clear() \| 清空字典 \| \| 5 \| 字典.keys() \| 获取字典的全部Key，可用于for循环遍历字典 \| \| 6 \| len(字典) \| 计算字典内的元素数量 \| \*\*字典的特点：\*\* \* 可以容纳多个数据 \* 可以容纳不同类型的数据 \* 每一份数据是KeyValue键值对 \* 可以通过Key获取到Value，Key不可重复（重复会覆盖） \* 不支持下标索引 \* 可以修改（增加或删除更新元素等） \* 支持for循环，不支持while循环 \`\`\`python """ 演示字典的常用操作 """ 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"字典的value是：{my_dict\[key\]}") # 方式2：直接对字典进行for循环，每一次循环都是直接得到key for key in my_dict: print(f"2字典的key是:{key}") print(f"2字典的value是：{my_dict\[key\]}") # 统计字典内的元素数量, len()函数 num = len(my_dict) print(f"字典中的元素数量有：{num}个") \`\`\` ### 9. 字符串的大小比较 字符串通过从头到尾，一位位进行比较，其中一位大，后面就无需比较了。 单个字符通过ASCII码表，确定字符对应的码值数字来确定大小。 \`\`\`python """ 演示字符串大小比较 """ # 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'}") \`\`\` ### 10. ASCII码表 在程序中，字符串所用的所有字符如： \* 大小写英文单词 \* 数字 \* 特殊符号(!、\\、\|、@、#、空格等） 都有其对应的ASCII码表值每一个字符都能对应上一个数字的码值。字符串进行比较就是基于数字的码值大小进行比较的。 
本文是原创文章，采用 CC BY-NC-ND 4.0 协议，完整转载请注明来自 Veylor
最近发布
![常用SQL]()
常用SQL
