续集二来啦，希望对你们有帮助，有兴趣的可以去我主页去看第一期的学习内容。

第 5 天 - 列表

Python 中有四种集合数据类型：

• 列表：是一个有序且可变（可修改）的集合。允许重复成员。
• 元组：是有序且不可更改或不可修改（不可变）的集合。允许重复成员。
• Set：是一个无序、无索引且不可修改的集合，但我们可以向集合中添加新项目。不允许重复成员。
• 字典：是一个无序、可变（可修改）和索引的集合。没有重复的成员。

列表是有序且可修改（可变）的不同数据类型的集合。列表可以为空，也可以具有不同的数据类型项。

如何创建列表

在 Python 中，我们可以通过两种方式创建列表：

• 使用列表内置函数

# 语法
lst  =  list ()

empty_list  =  list () # 这是一个空列表，列表中没有项目
print ( len ( empty_list )) # 0

• 使用方括号，[]

# 语法
lst  = []

empty_list  = [] # 这是一个空列表，列表中没有项目
print ( len ( empty_list )) # 0

带有初始值的列表。我们使用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  = {'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' ] =  'Eyob'
人[ '年龄' ] =  252

检查字典中的键

我们使用in运算符来检查字典中是否存在键

# 语法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }print ( 'key2'  in  dct ) # True
print ( ' KEY5' 在 DCT）＃假

从字典中删除键和值对

• pop(key)：删除具有指定键名的项目
• popitem() : 删除最后一项
• del : 删除具有指定键名的项目

# 语法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }dct . pop ( 'key1' ) # 删除 key1 项
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }DCT。弹出项()# 删除最后一项
del  dct [ 'key2' ] # 删除 key2 项

例子：

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”}}
人。pop ( 'first_name' )         # 删除名字项
person。popitem ()                 # 移除地址项
del  person [ 'is_married' ]         # 移除 is_married 项

将字典更改为项目列表

该项目（）方法的改变字典元组的列表。

＃语法
DCT  = { 'KEY1' ：'VALUE1' ，'KEY2' ：'值'，'KEY3' ：'值3' ，'KEY4' ：'VALUE4' }
打印（DCT。项目（））＃dict_items（[（ 'key1', 'value1'), ('key2', 'value2'), ('key3', 'value3'), ('key4', 'value4')])

清除字典

如果我们不想要字典中的项目，我们可以使用clear()方法清除它们

＃语法
DCT  = { 'KEY1' ：'VALUE1' ，'KEY2' ：'值'，'KEY3' ：'值3' ，'KEY4' ：'VALUE4' }
打印（DCT。清晰（）） ＃无

删除字典

如果我们不使用字典，我们可以完全删除它

# 语法dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }del  dct

复制字典

我们可以使用copy()方法复制字典。使用复制我们可以避免原始字典的变异。

# 语法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }dct_copy  =  dct . copy () # {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'}

获取字典键作为列表

该键（）方法为我们提供了AA字典作为一个列表的所有键。

# 语法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }keys  =  dct . 键()
打印(键)      # dict_keys(['key1', 'key2', 'key3', 'key4'])

获取字典值作为列表

该值的方法为我们提供了AA字典作为一个列表的所有值。

# 语法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }values  =  dct . values ()
打印( values )      # dict_values(['value1', 'value2', 'value3', 'value4'])

你是惊人的。现在，您对字典的强大功能感到非常兴奋。您刚刚完成了第 8 天的挑战，距离通往卓越之路还有 8 步。

第 9 天 - 条件语句

默认情况下，Python 脚本中的语句从上到下依次执行。如果处理逻辑需要，可以通过两种方式改变执行的顺序流程：

• 条件执行：如果某个表达式为真，将执行一个或多个语句块
• 重复执行：只要某个表达式为真，一个或多个语句块就会被重复执行。在本节中，我们将介绍if、else、elif语句。我们在前几节中学到的比较和逻辑运算符在这里会很有用。

如果条件

在 python 和其他编程语言中，关键字if用于检查条件是否为真并执行块代码。记住冒号后的缩进。

＃语法
，如果 条件：这 部分 的 代码 运行 的 truthy 条件

示例：1

a  =  3
if  a  >  0 :print ( 'A is a positive number' )# A 是正数

正如你在上面的例子中看到的，3 大于 0，条件为真，块代码被执行，但是，如果条件为假，我们将看不到结果。为了查看虚假条件的结果，我们应该有另一个块，即else。

如果条件为真

如果条件为真，将执行第一个块，否则将运行 else 条件。

＃语法
，如果 条件：这 部分 的 代码 运行 的 truthy 条件
还有：这 部分 的 代码 运行 的 虚假 条件

例子：

a  =  3
如果 a  <  0 :打印( 'A 是负数' )
否则:打印( 'A 是正数' )

上面的条件证明为假，因此执行了 else 块。如果我们的条件超过两个呢？我们可以使用 _ elif_。

如果Elif Else

在日常生活中，我们每天都在做决定。我们不是通过检查一两个条件而是通过多个条件来做出决定，和生活一样，编程也是充满条件的。当我们有多个条件时，我们使用elif。

# 语法
if 条件：代码
elif 条件：代码
else：代码

例子：

a  =  0
if  a  >  0 :print ( 'A is a positive number' )elif  a  <  0 :print ( 'A is a negative number' )else :print ( 'A is zero' )

简写

# 语法
代码 if 条件 else 代码

**例子： **

a  =  3
print ( 'A is positive' ) if  a  >  0  else  print ( 'A is negative' ) # 第一个条件满足，'A is positive' 将被打印

嵌套条件

条件可以嵌套

# 语法
if 条件：代码if 条件：代码

**例子： **

a  =  0
if  a  >  0 :if  a  %  2  ==  0 :print ( 'A is a positive and even integer' )else :print ( 'A is a positive number' )elif  a  ==  0 :print ( 'A为零' )else :打印( 'A 是负数' )

我们可以通过使用逻辑运算符和来避免编写嵌套条件。

If 条件和逻辑运算符

# 语法
if 条件 和 条件：代码

**例子： **

a  =  0
if  a  >  0  and  a  %  2  ==  0 :print ( 'A is an even positive integer' )elif  a  >  0  and  a  %  2  !=   0 :print ( 'A is a positive integer' )elif  a  ==  0：打印（'A 为零'）
否则：打印（'A 为负'）

If 和 Or 逻辑运算符

# 语法
if 条件 或 条件：代码

**例子： **

user  =  'James'
access_level  =  3
if  user  ==  'admin'  or  access_level  >=  4 :print ( '访问被授予！' )else :print ( '访问被拒绝！' )

你做得很好。永远不要放弃，因为伟大的事情需要时间。您刚刚完成了第 9 天的挑战，距离通往伟大之路还有 9 步。

第 10 天 - 循环

生活处处都是例行公事，在编程中，我们也会做很多重复的任务，为了处理重复性任务，编程语言使用循环，Python 编程语言还提供了以下两种循环类型：

1. while 循环
2. for循环

While 循环

我们使用保留字while来创建一个 while 循环，它用于重复执行语句块，直到满足给定条件，当条件变为假时，循环后的代码行将继续执行。

  ＃语法
而 条件：代码 去 这里

例子：

count  =  0
而 count  <  5 :print ( count )count  =  count  +  1
#prints from 0 to 4

在上面的 while 循环中，当 count 为 5 时条件变为假，也就是循环停止的时候，如果我们有兴趣在条件不再为真时运行代码块，我们可以使用else。

  ＃语法
而 条件：代码 去 这里
还有：代码 去 这里

例子：

计数 =  0
而 计数 <  5：打印（计数）计数 = 计数 +  1
否则：打印（计数）

当 count 为 5 时，上述循环条件为假，循环停止，执行 else 语句。结果将打印 5。

中断并继续 - 第 1 部分

• Break：当我们想退出或停止循环时，我们使用 break。

# 语法
while  condition :代码 在 这里if  another_condition :break

例子：

count  =  0
而 count  <  5 :print ( count )count  =  count  +  1 if  count  ==  3 :break

上面的 while 循环只打印 0, 1, 2，但是当它到达 3 时就停止了。

• 继续：使用 continue 语句，我们可以跳过当前迭代，并继续下一个：

 # 语法
while  condition :代码 在 这里if  another_condition :continue

例子：

count  =  0
而 count  <  5：如果 count  ==  3：继续打印（count）count  =  count  +  1

上面的 while 循环只打印 0、1、2 和 4（跳过 3）。

For循环

一对关键字是用来做一个for循环，与其他编程语言类似，但有一些语法差异。循环用于迭代序列（即列表、元组、字典、集合或字符串）。

• 带列表的for循环

＃语法
为 迭代器 在 LST：代码 去 这里

例子：

numbers  = [ 0 , 1 , 2 , 3 , 4 , 5 ]for  number  in  numbers : # number 是引用列表项的临时名称，仅在此循环内有效print ( number )        # 数字将逐行打印, 从 0 到 5

• 带字符串的for循环

＃语法
的 迭代器 中 的字符串：代码 去 这里

例子：

language  =  'Python'
for  letter  in  language :print ( letter )for  i  in  range ( len ( language )):print ( language [ i ])

• 带元组的 for 循环

＃语法
为 迭代器 在 TPL：代码 去 这里

例子：

数字 = ( 0 , 1 , 2 , 3 , 4 , 5 )
对于 数字 中的 数字：打印(数字)

• 带字典的 for 循环循环遍历字典为您提供字典的键。

 ＃语法
为 迭代器 在 DCT：代码 去 这里

例子：

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”}
}
对于 关键 在 人：打印（钥匙）对于 关键的，价值 的 人。items ():print ( key , value ) # 这样我们就可以同时打印出键和值

• 循环设置

＃语法
为 迭代器 在 ST：代码 去 这里

例子：

it_companies  = { 'Facebook' , 'Google' , 'Microsoft' , 'Apple' , 'IBM' , 'Oracle' , 'Amazon' }for  company  in  it_companies :print ( company )

中断并继续 - 第 2 部分

简短提醒： Break：当我们想在循环完成之前停止循环时，我们使用 break。

＃语法
为 迭代器 在 序列：代码 去 这里，如果 条件：破

例子：

numbers  = ( 0 , 1 , 2 , 3 , 4 , 5 )
对于 数字 中的 数字：打印（数字）如果 数字 ==  3：中断

在上面的例子中，循环在到达 3 时停止。

Continue：当我们想跳过循环迭代中的某些步骤时，我们使用 continue。

 ＃语法
为 迭代器 在 序列：代码 去 这里，如果 条件：继续

例子：

数 =（0，1，2，3，4，5）
对 数 中 的数字：打印（数字）如果 数 ==  3：继续打印（'下一步数应该是'，数目 +  1），如果 数 ！=  5 别的 print ( "loop's end" ) # 简写条件需要 if 和 else 语句
打印（'循环外'）

在上面的示例中，如果数字等于 3，则跳过条件之后的步骤（但在循环内），如果还有任何迭代剩余，则循环继续执行。

范围函数

的范围（）函数是一个数字的使用的列表，的范围（开始，结束，步骤）三个参数：开始，结束和增量。默认情况下，它从 0 开始，增量为 1，范围序列至少需要 1 个参数（结束），使用范围创建序列

lst  =  list ( range ( 11 )) print ( lst ) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
st  =  set ( range ( 1 , 11 ))     # 2参数表示序列的开始和结束，步骤设置为默认 1
print ( st ) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}lst  =  list ( range ( 0 , 11 , 2 ))print ( lst ) # [0, 2, 4, 6, 8, 10]
st  =  set ( range ( 0 , 11 , 2 ))print ( st ) # { 0, 2, 4, 6, 8, 10}

＃语法
用于 迭代器 在 范围（开始，结束，步骤）：

例子：

for  number  in  range ( 11 ):print ( number )    # 打印 0 到 10，不包括 11

嵌套 For 循环

我们可以在循环内编写循环。

# 语法
for  x  in  y :for  t  in  x :print ( t )

例子：

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'}
}
对于 关键 在 人：如果 键 ==  “技能”：对 技能 的 人[ “技能” ]：打印（技能）

对于其他

如果我们想在循环结束时执行一些消息，我们使用 else。

＃语法
的 迭代器 在 范围（开始，结束，步）：做 一些
别的：打印（“循环结束”）

例子：

for  number  in  range ( 11 ):print ( number )    # 打印 0 到 10，不包括 11
else :print ( '循环停止于' , number )

经过

在python中需要语句时（分号后），但我们不喜欢在那里执行任何代码，我们可以写pass这个词来避免错误。我们也可以将它用作占位符，用于未来的陈述。

例子：

对于 数目 在 范围（6）：通

你建立了一个重要的里程碑，你势不可挡。继续！您刚刚完成了第 10 天的挑战，距离通往卓越之路还有 10 步。

你们的三连是我坚持更新下去的动力，感谢。

坚持不懈续集 (二) 初学者挑战学习Python编程30天相关推荐

1. 自学入门不在困难，初学者挑战学习Python编程30天 (三)

   坚持坚持再坚持!!! 如果文章对于你有帮助,欢迎收藏.关注.点赞与订阅专栏 有任何疑问欢迎私信 目录 第 11 天 - 函数 定义函数 声明和调用函数 无参数函数 返回值的函数 - 第 1 部分 带参 ...

2. 最终篇：简洁易懂，初学者挑战学习Python编程30天 (五)

   最终篇 第 26 天 - 网络 Python 26.1网页版 Python 26.2Flask 文件夹结构 26.3设置你的项目目录 26.4创建路由 26.5创建模板 26.6Python脚本 26 ...

3. 简洁易懂，初学者挑战学习Python编程30天 (一)

   目录 1.第一天-介绍 1.1为什么是 Python? 1.2环境设置 安装 Python Python Shell 1.3Python基础 Python 语法 Python 缩进 注释 数据类型 检 ...

4. 简洁易懂，初学者挑战学习Python编程30天 (四)

   目录 第 21 天 - 类和对象 21.1创建一个类 21.2创建对象 21.3类构造函数 21.4对象方法 21.5对象默认方法 21.6修改类默认值的方法 21.7继承 21.8Overridin ...

5. 学python编程_学习Python编程，我们应该如何学？学习内容包括哪些？

   点击蓝字"python教程"关注我们,一起学习成长哟! 我想可能很多网友和我有着相似的学习背景,学习Python会有以下的问题: 从零开始,不知道如何下手开始学? 被基本的数据结构 ...

6. 如何零基础学习python语言_零基础如何学习Python编程

   Python是一门简单优雅的计算机程序设计语言,相比于C语言.Java语言,Python编程具有以下特点: 1. Python语法简单,代码可读性高,容易入门: 2. Python代码具有一定的规范性 ...

7. 不是计算机专业学python能找到工作吗-非计算机行业为什么要转行学习Python编程...

   原标题:非计算机行业为什么要转行学习Python编程 现在的年轻人追求个性化选择,比如更为自由的工作时间???.更为多元化的精神激励.更为舒适的生活方式等等.由此互联网行业不仅满足这些条件还有这很好的 ...

8. python 求list最小值的索引_【挑战自学Python编程】第六天：前五天都学了啥？

   摘要 01 基本概念复习 02 函数,方法,语句,单词复习 03 注释 04 后两周学习计划 01基本概念复习 标准数据类型 五种标准数据类型: 数字(Numbers) 字符串(String) 列表( ...

9. python基础学习_35岁零基础学习Python编程是否能学得会并用得上

   首先,学习编程语言并没有年龄上的限制,在当前的工业互联网时代,不论是初级职场人还是资深职场人,学习一门编程语言都是有必要的,从这个角度来看,35岁开始学习编程语言是完全可以的. 虽然说学习Python ...

最新文章

1. 记录一下VsCode配置C/C++运行环境
2. OC__part11.3
3. 自从安上了“AI”，这些商务经理天天按时下班了
4. （推荐）（提供下载）ORACLE常见问题一千问(不怕学不成、就怕心不诚！)
5. python 两点曲线_全方位比较3种数据科学工具的比较：Python、R和SAS（附链接）
6. 发的楷体怎么写_小学生硬笔书法怎么练
7. 实验三：树莓派-暴力破解无线网络密码
8. 图的应用--最短路算法
9. 如何查看XP系统的密匙
10. OutMan——C语言中文件的操作
11. UniApp使用navigateTo无法跳转到tabBar中的页面
12. JS 获取操作删除节点
13. 【VR】详解 Facebook Oculus团队的手势追踪系统——MegaTrack
14. 利用css实现太极图的制作（带旋转动画） （课程实践教学项目）
15. python画位势高度图_气候变化位势高度
16. 前端例程20210802：玻璃拟物化风格（Glassmorphism）设计与实现
17. Java课程中心练习题
18. STM32单片机电源端并联电容的重要性
19. WDF模型驱动程序开发
20. C#中FileStream和StreamWriter/StreamReader的区别

热门文章

1. 中科院团队用算法追上谷歌“量子霸权”：谷歌量子处理器并没有比E级超算快...
2. 视频也能P！谷歌CVPR 2021最新视频P图模型omnimatte
3. 预、自训练之争：谷歌说预训练虽火，但在标注数据上自训练更有效
4. 抢票神器成GitHub热榜第一，支持候补抢票，Python跑起来
5. 利用Python让你的命令行像坤坤一样会打篮球
6. Django源码分析2:本地运行runserver分析
7. 连续数列（总和最大的连续数列）
8. 数据结构-图-遍历-搜索
9. POP3 SMTP DNS DHCP UDP HTTP FTP HTTPS Telnet WIDOWS TFTP 常用协议和默认端口，计算机网络的很需要！！！
10. C语言指针调用函数_只愿与一人十指紧扣_新浪博客