先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024c （备注Python）
正文
带有初始值的列表。我们使用len()来查找列表的长度。
fruits = ['banana', 'orange', 'mango', 'lemon'] # 水果列表
vegetables = ['Tomato', 'Potato', 'Cabbage','Onion', 'Carrot'] # 蔬菜列表
animal_products = ['milk', 'meat', 'butter', 'yoghurt'] # 动物产品列表
web_techs = ['HTML', 'CSS', 'JS', 'React','Redux', 'Node', 'MongDB'] # 网络技术
countries = ['Finland', 'Estonia', 'Denmark', 'Sweden', 'Norway']
#打印列表和其长度
print('Fruits:', fruits)
print('Number of fruits:', len(fruits))
print('Vegetables:', vegetables)
print('Number of vegetables:', len(vegetables))
print('Animal products:',animal_products)
print('Number of animal products:', len(animal_products))
print('Web technologies:', web_techs)
print('Number of web technologies:', len(web_techs))
print('Countries:', countries)
print('Number of countries:', len(countries))
输出
Fruits: ['banana', 'orange', 'mango', 'lemon']
Number of fruits: 4
Vegetables: ['Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot']
Number of vegetables: 5
Animal products: ['milk', 'meat', 'butter', 'yoghurt']
Number of animal products: 4
Web technologies: ['HTML', 'CSS', 'JS', 'React', 'Redux', 'Node', 'MongDB']
Number of web technologies: 7
Countries: ['Finland', 'Estonia', 'Denmark', 'Sweden', 'Norway']
Number of countries: 5
- 列表可以包含不同数据类型的项目
lst = [ 'Asabeneh' , 250 , True , { 'country' : 'Finland' , 'city' : 'Helsinki' }] # 包含不同数据类型的列表
使用正索引访问列表项
我们使用它们的索引访问列表中的每个项目，一个列表索引从 0 开始，下图清楚地显示了索引从哪里开始
fruits = ['banana', 'orange', 'mango', 'lemon']
first_fruit = fruits[0] # 我们使用它的索引访问所述第一项
print(first_fruit) # 香蕉
second_fruit = fruits[1]
print(second_fruit) # 橙子
last_fruit = fruits[3]
print(last_fruit) # 柠檬
# 最后一个索引
last_index = len(fruits) - 1
last_fruit = fruits[last_index]
使用负索引访问列表项
负索引表示从末尾开始，-1 表示最后一项，-2 表示倒数第二项。
fruits = ['banana', 'orange', 'mango', 'lemon']
first_fruit = fruits[-4]
last_fruit = fruits[-1]
second_last = fruits[-2]
print(first_fruit) #香蕉
print(last_fruit) # 柠檬
print(second_last) # 芒果
拆箱清单项目
lst = [ 'item' , 'item2' , 'item3' , 'item4' , 'item5' ]
first_item , second_item , third_item , \* rest = lst
print ( first_item ) # item1
print ( second_item ) # item2
print ( third_item ) # item3
print( rest ) # ['item4', 'item5']
# 第一个例子
fruits = [ 'banana' , 'orange' , 'mango' , 'lemon' , 'lime' , 'apple' ]
first_fruit , second_fruit , third_fruit , \* rest = lst
print ( first_fruit ) # 香蕉
print ( second_fruit ) # 橙色
print ( third_fruit ) # 芒果
print ( rest ) # ['lemon','lime','apple']
# 解包列表的第二个例子
first , second , third , \* rest , tenth = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]
print(first) # 1
print(second) # 2
print(third) # 3
print(rest) # [4,5,6,7,8,9]
print(tenth) # 10
#第三个例子约拆包列表
countries = ['Germany', 'France','Belgium','Sweden','Denmark','Finland','Norway','Iceland','Estonia']
gr, fr, bg, sw, \*scandic, es = countries
print(gr)
print(fr)
print(bg)
print(sw)
print(scandic)
print(es)
从列表中切片项目
- 正索引：我们可以通过指定开始、结束和步骤来指定一系列正索引，返回值将是一个新列表。（开始的默认值 = 0，结束 = len(lst) - 1（最后一项），步骤 = 1）
fruits = ['banana', 'orange', 'mango', 'lemon']
all_fruits = fruits[0:4] # 它返回所有水果
# 这也将给出相同的结果与上述一个
all_fruits = fruits[0:] # 如果我们不设置在哪里停止它需要所有的休息
orange_and_mango = fruits[1:3] # 不包括第一个索引
orange_mango_lemon = fruits[1:]
orange_and_lemon = fruits[::2] # 这里我们使用了第三个参数，step。它将需要每 2cnd 项 - ['banana', 'mango']
- 负索引：我们可以通过指定开始、结束和步骤来指定一系列负索引，返回值将是一个新列表。
fruits = ['banana', 'orange', 'mango', 'lemon']
all_fruits = fruits[-4:] # 它返回所有水果
orange_and_mango = fruits[-3:-1] # 它不包括最后一个化指数,['orange', 'mango']
orange_mango_lemon = fruits[-3:] # 这会给开始从-3到结束,['orange', 'mango', 'lemon']
reverse_fruits = fruits[::-1] # 一个否定的步骤会以相反的顺序取列表,['lemon', 'mango', 'orange', 'banana']
修改列表
列表是可变或可修改的有序项集合。让我们修改水果列表。
fruits = ['banana', 'orange', 'mango', 'lemon']
fruits[0] = 'avocado'
print(fruits) # ['avocado', 'orange', 'mango', 'lemon']
fruits[1] = 'apple'
print(fruits) # ['avocado', 'apple', 'mango', 'lemon']
last_index = len(fruits) - 1
fruits[last_index] = 'lime'
print(fruits) # ['avocado', 'apple', 'mango', 'lime']
检查列表中的项目
使用in运算符检查项目是否是列表的成员。请参阅下面的示例。
fruits = ['banana', 'orange', 'mango', 'lemon']
does_exist = 'banana' in fruits
print(does_exist) # 真
does_exist = 'lime' in fruits
print(does_exist) # 假
将项目添加到列表
要将项目添加到现有列表的末尾，我们使用方法append()。
# 语法
lst = list ()
lst.append(item)
fruits = ['banana', 'orange', 'mango', 'lemon']
fruits.append('apple')
print(fruits) # ['banana', 'orange', 'mango', 'lemon', 'apple']
fruits.append('lime') # ['banana', 'orange', 'mango', 'lemon', 'apple', 'lime']
print(fruits)
将项目插入列表
我们可以使用insert()方法在列表中的指定索引处插入单个项目。请注意，其他项目向右移动。该插件（）方法有两个参数：指数和插入项目。
# 语法
lst = [ 'item1' , 'item2' ]
lst.insert(index, item)
fruits = ['banana', 'orange', 'mango', 'lemon']
fruits.insert(2, 'apple') # 在橙子和芒果之间插入苹果
print(fruits) # ['banana', 'orange', 'apple', 'mango', 'lemon']
fruits.insert(3, 'lime') # ['banana', 'orange', 'apple', 'lime', 'mango', 'lemon']
print(fruits)
从列表中删除项目
remove 方法从列表中删除指定的项目
# 语法
lst = [ 'item1' , 'item2' ]
lst.remove(item)
fruits = ['banana', 'orange', 'mango', 'lemon', 'banana']
fruits.remove('banana')
print(fruits) # ['orange', 'mango', 'lemon', 'banana'] - this method removes the first occurrence of the item in the list
fruits.remove('lemon')
print(fruits) # ['orange', 'mango', 'banana']
使用 Pop 删除项目
的弹出（）方法删除指定索引，（或如果未指定索引中的最后一项）：
# 语法
lst = [ 'item1' , 'item2' ]
lst . pop () # 最后一项
lst.pop(index)
fruits = ['banana', 'orange', 'mango', 'lemon']
fruits.pop()
print(fruits) # ['banana', 'orange', 'mango']
fruits.pop(0)
print(fruits) # ['orange', 'mango']
标题使用 Del 删除项目
该删除关键字删除指定索引和它也可以被用于删除索引范围内的物品。它也可以完全删除列表
# 语法
lst = [ 'item1' , 'item2' ]
del lst [ index ] # 只有一个项目
del lst # 彻底删除列表
fruits = ['banana', 'orange', 'mango', 'lemon', 'kiwi', 'lime']
del fruits[0]
print(fruits) # ['orange', 'mango', 'lemon', 'kiwi', 'lime']
del fruits[1]
print(fruits) # ['orange', 'lemon', 'kiwi', 'lime']
del fruits[1:3] # # 这会删除给定索引之间的项目，因此它不会删除索引为 3 的项目！
print(fruits) # ['orange', 'lime']
del fruits
print(fruits) # 这应该给：NameError：名字“水果”没有定义
清除清单项目
在明确的（）方法清空列表：
# 语法
lst = [ 'item1' , 'item2' ]
lst.clear()
fruits = ['banana', 'orange', 'mango', 'lemon']
fruits.clear()
print(fruits) # []
复制列表
可以通过以下方式将列表重新分配给新变量来复制列表：list2 = list1。现在，list2 是对list1 的引用，我们在list2 中所做的任何更改也将修改原来的list2，但是在很多情况下，我们不喜欢修改原始版本，而是喜欢拥有不同的副本。避免上述问题的一种方法是使用copy()。
# 语法
lst = [ 'item1' , 'item2' ]
lst_copy = lst . copy()
fruits = ['banana', 'orange', 'mango', 'lemon']
fruits_copy = fruits.copy()
print(fruits_copy) # ['banana', 'orange', 'mango', 'lemon']
加盟名单
在 Python 中有多种方法可以连接或连接两个或多个列表。
- 加号运算符 (+)
# 语法
list3 = list1 + list2
positive_numbers = [1, 2, 3, 4, 5]
zero = [0]
negative_numbers = [-5,-4,-3,-2,-1]
integers = negative_numbers + zero + positive_numbers
print(integers) # [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
fruits = ['banana', 'orange', 'mango', 'lemon']
vegetables = ['Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot']
fruits_and_vegetables = fruits + vegetables
print(fruits_and_vegetables ) # ['banana', 'orange', 'mango', 'lemon', 'Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot']
- 使用extend() 方法连接extend()方法允许在列表中附加列表。请参阅下面的示例。
# 语法
list1 = [ 'item1' , 'item2' ]
list2 = [ 'item3' , 'item4' , 'item5' ]
list1.extend(list2)
num1 = [ 0 , 1 , 2 , 3 ]
num2 = [ 4 , 5 , 6 ]
num1。extend ( num2 )
print ( 'Numbers:' , num1 ) # Numbers: [0, 1, 2, 3, 4, 5, 6]
negative_numbers = [ - 5 , - 4 , - 3 , - 2 , - 1 ]
positive_numbers =[ 1 , 2 , 3 , 4 , 5 ]
zero = [ 0 ]
negative_numbers.extend(zero)
negative_numbers.extend(positive_numbers)
print('Integers:', negative_numbers) # Integers: [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
fruits = ['banana', 'orange', 'mango', 'lemon']
vegetables = ['Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot']
fruits.extend(vegetables)
print('Fruits and vegetables:', fruits ) # 水果蔬菜: ['banana', 'orange', 'mango', 'lemon', 'Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot']
计算列表中的项目
的计数（）方法返回的项目在列表中显示的次数：
# 语法
lst = [ 'item1' , 'item2' ]
lst.count(item)
fruits = ['banana', 'orange', 'mango', 'lemon']
print(fruits.count('orange')) # 1
ages = [22, 19, 24, 25, 26, 24, 25, 24]
print(ages.count(24)) # 3
查找项目的索引
的索引（）方法返回在列表中的项目的索引：
# 语法
lst = [ 'item1' , 'item2' ]
lst.index(item)
Fruits = [ 'banana' , 'orange' , 'mango' , 'lemon' ]
print ( fruits . index ( 'orange' )) # 1
ages = [ 22 , 19 , 24 , 25 , 26 , 24 , 25 , 24 ]
print(ages.index(24)) ＃2，第一次出现
反转列表
在反向（）方法将反转的列表的顺序。
# 语法
lst = [ 'item1' , 'item2' ]
lst.reverse()
fruits = ['banana', 'orange', 'mango', 'lemon']
fruits.reverse()
print(fruits) # ['lemon', 'mango', 'orange', 'banana']
ages = [22, 19, 24, 25, 26, 24, 25, 24]
ages.reverse()
print(ages) # [24, 25, 24, 26, 25, 24, 19, 22]
排序列表项
要对列表进行排序，我们可以使用sort()方法或sorted()内置函数，该排序（）方法进行重新排序升序排列列表项，并修改原来的列表中，如果sort()方法的参数reverse 等于 true，它将按降序排列列表。
- sort()：此方法修改原始列表
# 语法
lst = [ 'item1' , 'item2' ]
lst . sort () #升序
lst . sort ( reverse = True ) # 降序
例子：
fruits = ['banana', 'orange', 'mango', 'lemon']
fruits.sort()
print(fruits) # 按字母顺序排序, ['banana', 'lemon', 'mango', 'orange']
fruits.sort(reverse=True)
print(fruits) # ['orange', 'mango', 'lemon', 'banana']
ages = [22, 19, 24, 25, 26, 24, 25, 24]
ages.sort()
print(ages) # [19, 22, 24, 24, 24, 25, 25, 26]
ages.sort(reverse=True)
print(ages) # [26, 25, 25, 24, 24, 24, 22, 19]
- sorted()：在不修改原列表的情况下返回有序列表 示例：
fruits = ['banana', 'orange', 'mango', 'lemon']
print(sorted(fruits)) # ['banana', 'lemon', 'mango', 'orange']
# Reverse order
fruits = ['banana', 'orange', 'mango', 'lemon']
fruits = sorted(fruits,reverse=True)
print(fruits) # ['orange', 'mango', 'lemon', 'banana']
你很勤奋，你已经取得了很多成就。您刚刚完成了第 5 天的挑战，距离通往卓越之路还有 5 个步骤。
第 6 天 - 元组
元组是有序且不可更改（不可变）的不同数据类型的集合，元组用圆括号 () 书写，一旦创建了一个元组，我们就不能改变它的值。我们不能在元组中使用 add、insert、remove 方法，因为它不可修改（可变），与列表不同，元组的方法很少。
与元组相关的方法：
- tuple(): 创建一个空元组
- count()：计算元组中指定项的个数
- index()：在元组中查找指定项的索引
- 运算符：连接两个或多个元组并创建一个新元组
创建元组
- 空元组：创建一个空元组
# 语法
empty_tuple = ()
# 或使用元组构造函数
empty_tuple = tuple ()
- 具有初始值的元组
# 语法
tpl = ( 'item1' , 'item2' , 'item3' )
水果 =（'香蕉'，'橙色'，'芒果'，'柠檬'）
元组长度
我们使用len()方法来获取元组的长度。
# 语法
tpl = ( 'item1' , 'item2' , 'item3' )
len ( tpl )
访问元组项目
- 正索引与列表数据类型类似，我们使用正索引或负索引来访问元组项。
# 语法
tpl = ( 'item1' , 'item2' , 'item3' )
first_item = tpl [ 0 ]
second_item = tpl [ 1 ]
水果 =（'香蕉'，'桔子'，'芒果'，'柠檬'） first_fruit = 水果[ 0 ] second_fruit = 水果[ 1 ] last_index = LEN（水果）- 1 last_fruit = 水果[ las_index ]
- 负索引 负索引表示从末尾开始，-1 表示最后一项，-2 表示倒数第二，列表/元组长度的负数表示第一项。
元组负索引
# 语法
tpl = ( 'item1' , 'item2' , 'item3' , 'item4' )
first_item = tpl [ - 4 ]
second_item = tpl [ - 3 ]
水果 =（'香蕉'，'桔子'，'芒果'，'柠檬'）
first_fruit = 水果[ - 4 ]
second_fruit = 水果[ - 3 ]
last_fruit = 水果[ - 1 ]
切片元组
我们可以通过指定一个索引范围来切出一个子元组从哪里开始和哪里结束在元组中，返回值将是一个具有指定项的新元组。
- 正指数范围
# 语法
tpl = ( 'item1' , 'item2' , 'item3' , 'item4' )
all_items = tpl [ 0 : 4 ] # 所有项目
all_items = tpl [ 0 :] # 所有项目
middle_two_items = tpl [ 1 : 3 ] # 不包括索引 3 处的项目
水果 =（'香蕉'，'桔子'，'芒果'，'柠檬'）
all_fruits = 水果[ 0：4 ] ＃所有项目
all_fruits = 水果[ 0：] ＃所有项目
orange_mango = 水果[ 1：3 ] ＃没有按'不包括索引 3
处的 项目orange_to_the_rest = 水果[ 1 :]
- 负指数范围
# 语法
tpl = ( 'item1' , 'item2' , 'item3' , 'item4' )
all_items = tpl [ - 4 :] # 所有项目
middle_two_items = tpl [ - 3 : - 1 ] # 不包括索引 3 处的项目(-1)
水果 =（'香蕉'，'桔子'，'芒果'，'柠檬'）
all_fruits = 水果[ - 4：] ＃所有项目
orange_mango = 水果[ - 3：- 1 ] ＃不在索引3包括项
orange_to_the_rest = 水果[ - 3 :]
将元组更改为列表
我们可以将元组更改为列表，将列表更改为元组。元组是不可变的，如果我们想修改一个元组，我们应该把它改成一个列表。
# 语法
tpl = ( 'item1' , 'item2' , 'item3' , 'item4' )
lst = list ( tpl )
水果 =（'香蕉'，'橙色'，'芒果'，'柠檬'）
水果 = 列表（水果）
水果[ 0 ] = '苹果'
打印（水果） #['苹果'，'橙色'，'芒果' , 'lemon']
fruits = tuple ( fruits )
print ( fruits ) #('apple', 'orange', 'mango', 'lemon')
检查元组中的项目
我们可以使用in检查元组中是否存在项目，它返回一个布尔值。
# 语法
tpl = ( 'item1' , 'item2' , 'item3' , 'item4' )
'item2' in tpl # True
水果 =（“香蕉”，“桔子”，“芒果”，“柠檬”）
打印（“橙色” 在 水果）＃真
打印（“苹果” 在 水果）＃假
水果[ 0 ] = “苹果” ＃类型错误： “元组”对象不支持项目分配
加入元组
我们可以使用 + 运算符连接两个或多个元组
＃语法
TPL1 =（'ITEM1' ，'ITEM2' ，'项目3' ）
TPL2 =（'ITEM4' ，'ITEM5' ，'ITEM6' ）
TPL3 = TPL1 + TPL2
Fruits = ( 'banana' , 'orange' , 'mango' , 'lemon' )
蔬菜 = ( 'Tomato' , 'Potato' , 'Cabbage' , 'Onion' , 'Carrot' )
fruits_and_vegetables = 水果 + 蔬菜
删除元组
不可能删除元组中的单个项目，但可以使用del删除元组本身。
# 语法
tpl1 = ( 'item1' , 'item2' , 'item3' )
del tpl1
水果 =（'香蕉'，'橙色'，'芒果'，'柠檬'）
德尔 水果
你真勇敢，走到这一步。您刚刚完成了第 6 天的挑战，距离通往卓越之路还有 6 个步骤。
第 7 天 - 集合
Set 是项目的集合，集合的数学定义也适用于 Python，而Set 是无序和无索引的不同元素的集合，在Python组用于存储唯一的项目，就可以找到工会，交集，差，对称差，子集，超集和分离集集之间。
创建一个集合
我们使用大括号 {} 来创建一个集合或set()内置函数。
- 创建一个空集
# 语法
st = {}
# 或
st = set ()
- 使用初始项创建集合
# 语法
st = { 'item1' , 'item2' , 'item3' , 'item4' }
例子：
# 语法
水果 = { 'banana' , 'orange' , 'mango' , 'lemon' }
获取 Set 的长度
我们使用len()方法来查找集合的长度。
# 语法
st = { 'item1' , 'item2' , 'item3' , 'item4' }
len ( set )
例子：
水果 = { '香蕉'，'橙色'，'芒果'，'柠檬' }
len（水果）
访问集合中的项目
我们使用循环来访问项目。我们将在循环部分看到这一点
检查项目
为了检查我们在成员资格运算符中使用的列表中是否存在项目。
# 语法
st = { 'item1' , 'item2' , 'item3' , 'item4' }
print ( "Does set st contains item3?" , 'item3' in st ) # set st 包含 item3 吗？真的
例子：
水果 = { “香蕉”，“桔子”，“芒果”，“柠檬” }
打印（“芒果” 在 水果）＃真
将项目添加到集合
一旦创建了一个集合，我们就不能更改任何项目，我们也可以添加其他项目。
- 使用add()添加一项
语法
st = { ‘item1’ , ‘item2’ , ‘item3’ , ‘item4’ }
st . 添加（‘item5’）
例子：
水果 = { '香蕉'，'橙色'，'芒果'，'柠檬' }
水果。添加（'石灰'）
- 使用添加多个项目的update（） 的更新（）允许多个项目添加到组。该更新（）接受一个列表参数。
# 语法
st = { 'item1' , 'item2' , 'item3' , 'item4' }
st . 更新（[ 'item5'，'item6'，'item7' ]）
例子：
Fruits = { 'banana' , 'orange' , 'mango' , 'lemon' }
蔬菜 = ( 'tomato' , 'potato' , 'cabbage' , 'onion' , 'carrot' )
水果。更新（蔬菜）
从集合中删除项目
我们可以使用remove()方法从集合中删除一个项目，如果未找到该项目，remove()方法将引发错误，因此最好检查该项目是否存在于给定集合中。但是，discard()方法不会引发任何错误。
# 语法
st = { 'item1' , 'item2' , 'item3' , 'item4' }
st . 删除（'item2'）
pop() 方法从列表中随机删除一个项目，并返回删除的项目。
例子：
水果 = { '香蕉'，'橙色'，'芒果'，'柠檬' }
水果。pop () # 从集合中随机删除一个项目
如果我们对删除的项目感兴趣。
水果 = { '香蕉'，'橙色'，'芒果'，'柠檬' } 已
移除_项目 = 水果。流行()
清除集合中的项目
如果我们想清除或清空集合，我们使用clear方法。
# 语法
st = { 'item1' , 'item2' , 'item3' , 'item4' }
st . 清除()
例子：
水果 = { '香蕉'，'橙色'，'芒果'，'柠檬' }
水果。清除（）
打印（水果）#设置（）
删除集合
如果我们想删除集合本身，我们使用del运算符。
# 语法
st = { 'item1' , 'item2' , 'item3' , 'item4' }
del st
例子：
水果 = { “香蕉”，“桔子”，“芒果”，“柠檬” }
德尔 水果
将列表转换为集合
我们可以将 list 转换为 set 并将 set 转换为 list，将列表转换为 set 会删除重复项，并且只会保留唯一项。
# 语法
lst = [ 'item1' , 'item2' , 'item3' , 'item4' , 'item1' ]
st = set ( lst ) # {'item2', 'item4', 'item1', 'item3'} -顺序是随机的，因为集合通常是无序的
例子：
水果 = [ '香蕉' , '橙色' , '芒果' , '柠檬' , '橙色' , '香蕉' ]
水果 = 设置(水果) # {'芒果', '柠檬', '香蕉', '橙色' }
连接集
我们可以使用union()或update()方法连接两个集合。
- Union 这个方法返回一个新的集合
# 语法
st1 = { 'item1' , 'item2' , 'item3' , 'item4' }
st2 = { 'item5' , 'item6' , 'item7' , 'item8' }
st3 = st1 . 联合（st2）
例子：
水果 = { '香蕉'，'橙色'，'芒果'，'柠檬' }
蔬菜 = { '番茄'，'马铃薯'，'卷心菜'，'洋葱'，'胡萝卜' }
打印（水果。联合（蔬菜） ) # {'lemon', 'carrot', 'tomato', 'banana', 'mango', 'orange', 'cabbage', 'potato', 'onion'}
- 更新此方法将一个集合插入给定的集合
# 语法
st1 = { 'item1' , 'item2' , 'item3' , 'item4' }
st2 = { 'item5' , 'item6' , 'item7' , 'item8' }
st1 . update ( st2 ) # st2 内容添加到 st1
例子：
水果 = { '香蕉' , '橙色' , '芒果' , '柠檬' }
蔬菜 = { '番茄' , '马铃薯' , '卷心菜' , '洋葱' , '胡萝卜' }
水果。更新（蔬菜）
打印（水果）# {'lemon', 'carrot', 'tomato', 'banana', 'mango', 'orange', 'cabbage', 'potato', 'onion'}
查找交叉项
交集返回两个集合中的一组项目。看例子
# 语法
st1 = { 'item1' , 'item2' , 'item3' , 'item4' }
st2 = { 'item3' , 'item2' }
st1 . 交集( st2 ) # {'item3', 'item2'}
例子：
Whole_numbers = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }
even_numbers = { 0 , 2 , 4 , 6 , 8 , 10 }
whole_numbers。交集( even_numbers ) # {0, 2, 4, 6, 8, 10}
python = { 'p' , 'y' , 't' , 'h' , 'o' , 'n' }
龙 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇。交叉点（龙） #{'o', 'n'}
检查子集和超集
一个集合可以是其他集合的子集或超集：
- 子集：issubset()
- 超级集：issuperset
# 语法
st1 = { 'item1' , 'item2' , 'item3' , 'item4' }
st2 = { 'item2' , 'item3' }
st2 . issubset ( st1 ) #真
st1。issuperset ( st2 ) # 真
例子：
Whole_numbers = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }
even_numbers = { 0 , 2 , 4 , 6 , 8 , 10 }
whole_numbers。issubset ( even_numbers ) # False，因为它是一个超集
whole_numbers。issuperset (even_numbers ) # 真
python = { 'p' , 'y' , 't' , 'h' , 'o' , 'n' }
龙 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇。issubset ( dragon ) # False
检查两组之间的差异
它返回两组之间的差异。
# 语法
st1 = { 'item1' , 'item2' , 'item3' , 'item4' }
st2 = { 'item2' , 'item3' }
st2 . 差（ST1）＃集（）
ST1。差异( st2 ) # {'item1', 'item4'} => st1\st2
例子：
Whole_numbers = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }
even_numbers = { 0 , 2 , 4 , 6 , 8 , 10 }
whole_numbers。差异( even_numbers ) # {1, 3, 5, 7, 9}
python = { 'p' , 'y' , 't' , 'o' , 'n' }
龙 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇。差异( dragon ) # {'p', 'y', 't'} - 结果是无序的（集合的特征）
dragon。差异( python ) # {'d', 'r', 'a', 'g'}
寻找两个集合之间的对称差异
它返回两个集合之间的对称差异，这意味着它返回一个包含两个集合中所有项目的集合，除了两个集合中都存在的项目，数学上： (A\B) ∪ (B\A)
# 语法
st1 = { 'item1' , 'item2' , 'item3' , 'item4' }
st2 = { 'item2' , 'item3' }
# 意思是 (A\B)∪(B\A)
st2 . symmetric_difference（ST1）＃{ 'ITEM1'， 'ITEM4'}
例子：
Whole_numbers = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }
some_numbers = { 1 , 2 , 3 , 4 , 5 }
whole_numbers。symmetric_difference（some_numbers）＃{0，6，7，8，9，10}
python = { 'p' , 'y' , 't' , 'h' , 'o' , 'n' }
龙 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇。symmetry_difference ( dragon ) # {'r', 't', 'p', 'y', 'g', 'a', 'd', 'h'}
连接集
如果两个集合没有一个或多个公共项，我们称它们为不相交的集合。我们可以使用isdisjoint()方法检查两个集合是联合还是不相交。
# 语法
st1 = { 'item1' , 'item2' , 'item3' , 'item4' }
st2 = { 'item2' , 'item3' }
st2 . isdisjoint ( st1 ) # 假
例子：
even_numbers = { 0 , 2 , 4 , 6 , 8 }
even_numbers = { 1 , 3 , 5 , 7 , 9 }
even_numbers . isdisjoint ( odd_numbers ) # 真，因为没有共同项
python = { 'p' , 'y' , 't' , 'h' , 'o' , 'n' }
龙 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇。isdisjoint ( dragon ) # False，有共同项{'o', 'n'}
你是一颗冉冉升起的新星。您刚刚完成了第 7 天的挑战，您在通往伟大的道路上领先了 7 步。
第 8 天 - 字典
字典是无序、可修改（可变）成对（键：值）数据类型的集合。
创建字典
要创建字典，我们使用大括号 {} 或dict()内置函数。
# 语法
empty_dict = {}
# 包含数据值的字典
dct = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
例子：
person = {
'first\_name' : 'Asabeneh' ,
'last\_name' : 'Yetayeh' ,
'age' : 250 ,
'country' : 'Finland' ,
'is\_marred' : True ,
'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
'address' :{
'street' : 'Space street' ,
“邮政编码”：“02210”
}
}
上面的字典显示一个值可以是任何数据类型：字符串、布尔值、列表、元组、集合或字典。
字典长度
它检查字典中“键：值”对的数量。
# 语法
dct = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
print ( len ( dct )) # 4
例子：
person = {
'first\_name' : 'Asabeneh' ,
'last\_name' : 'Yetayeh' ,
'age' : 250 ,
'country' : 'Finland' ,
'is\_marred' : True ,
'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
'address' :{
'street' : 'Space street' ,
“邮政编码”：“02210”
}
}
打印（len（人））#7
访问字典项目
我们可以通过引用它的键名来访问字典项。
# 语法
dct = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
print ( dct [ 'key1' ]) # value1
打印( dct [ 'key4' ]) # value4
例子：
person = {
'first\_name' : 'Asabeneh' ,
'last\_name' : 'Yetayeh' ,
'age' : 250 ,
'country' : 'Finland' ,
'is\_marred' : True ,
'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
'address' :{
'street' : 'Space street' ,
“邮政编码”：“02210”
}
}
print ( person [ 'first\_name' ]) # Asabeneh
print ( person [ 'country' ]) # Finland
print ( person [ 'skills' ]) # ['JavaScript', 'React', 'Node', 'MongoDB', ' Python']
print ( person [ 'skills' ][ 0 ]) # JavaScript
print ( person [ 'address' ][ 'street']) # 太空街
打印( person [ 'city' ]) ＃ 错误
如果键不存在，按键名访问项目会引发错误，为了避免这个错误，首先我们必须检查一个键是否存在，或者我们可以使用get方法，如果键不存在，get 方法返回 None，这是一个 NoneType 对象数据类型。
person = {
'first\_name' : 'Asabeneh' ,
'last\_name' : 'Yetayeh' ,
'age' : 250 ,
'country' : 'Finland' ,
'is\_marred' : True ,
'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
'address' :{
'street' : 'Space street' ,
“邮政编码”：“02210”
}
}
打印（人，得到（'FIRST\_NAME' ））＃Asabeneh
打印（人。获得（'国家'）） ＃芬兰
印刷（人。获得（'技能'））＃[ 'HTML'， 'CSS'， 'JavaScript的' ， '阵营'， '节点'， 'MongoDB的'， 'Python的']
打印（人。获得（'城市'）） ＃无
将项目添加到字典
我们可以向字典中添加新的键值对
# 语法
dct = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
dct [ 'key5' ] = 'value5'
例子：
person = {
'first\_name' : 'Asabeneh' ,
'last\_name' : 'Yetayeh' ,
'age' : 250 ,
'country' : 'Finland' ,
'is\_marred' : True ,
'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
'address' :{
'street' : 'Space street' ,
“邮政编码”：“02210”
}
}
人[ 'job\_title' ] = '讲师'
人[ '技能' ]。追加（'HTML'）
打印（人）
修改字典中的项目
我们可以修改字典中的项目
# 语法
dct = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
dct [ 'key1' ] = 'value-one'
例子：
person = {
**一、Python所有方向的学习路线**
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。
**二、Python必备开发工具**
工具都帮大家整理好了，安装就可直接上手！
**三、最新Python学习笔记**
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。
**四、Python视频合集**
观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
**五、实战案例**
纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
**六、面试宝典**
###### **简历模板**
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
e2' , 'key3' : 'value3' , 'key4' : 'value4' }
dct [ 'key1' ] = 'value-one'
例子：
person = {
**一、Python所有方向的学习路线**
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。
**二、Python必备开发工具**
工具都帮大家整理好了，安装就可直接上手！
**三、最新Python学习笔记**
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。
**四、Python视频合集**
观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
**五、实战案例**
纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
**六、面试宝典**
###### **简历模板**
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）**
[外链图片转存中...(img-2MLkCBx5-1713539732992)]
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
1363
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
