坚持不懈续集初学者挑战学习Python编程30天

Posted 2021-10-09 世上本无鬼

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了坚持不懈续集初学者挑战学习Python编程30天相关的知识，希望对你有一定的参考价值。

这里写目录标题

第 5 天 - 列表
第 6 天 - 元组
第 7 天 - 集合
第 8 天 - 字典
第 9 天 - 条件语句
第 10 天 - 循环

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

第 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' ]                      # 水果列表
蔬菜 = [ 'Tomato' , 'Potato' , 'Cabbage' , 'Onion' , 'Carrot' ]       # 蔬菜列表
动物产品 = [ '牛奶'，'肉'，'黄油'，'酸奶']              # 动物产品列表
web_techs  = [ 'html' , 'CSS', 'JS' , 'React' , 'Redux' , 'Node' , 'MongDB' ] # 网络技术
国家 列表= [ '芬兰' , '爱沙尼亚' , '丹麦' , '瑞典' , '挪威' ]

＃打印列表和其长度
打印（“水果：”，水果）
打印（“水果的数量：”，len个（水果））
印刷（“蔬菜：”，蔬菜），
印刷（“蔬菜号码：”，len个（蔬菜））
打印（'动物产品：'，animal_products）
打印（'动物产品的数量：'，len个（animal_products））
打印( 'Web 技术:' , web_techs )
 print ( 'Web 技术数:' , len ( web_techs ))
 print ( '国家:' ,国家)
 print ( '国家数:' , len (国家))

输出
水果：[ '香蕉'、'橙子'、'芒果'、'柠檬' ]
水果数量：4
蔬菜：[ '番茄'、'土豆'、'卷心菜'、'洋葱'、'胡萝卜' ]
蔬菜数量：5
动物产品：[ '牛奶'、'肉'、'黄油'、'酸奶' ]
动物产品数量：4
网络技术：[ ' HTML '、' CSS '、' JS '、' React '、' Redux '、' Node '、' MongDB ' ]
网络技术数量：7
国家：[ '芬兰'、'爱沙尼亚'、'丹麦'、'瑞典'、'挪威' ]
国家数量：5

列表可以包含不同数据类型的项目

 lst  = [ 'Asabeneh' , 250 , True , { 'country' : 'Finland' , 'city' : 'Helsinki' }] # 包含不同数据类型的列表

使用正索引访问列表项

我们使用它们的索引访问列表中的每个项目，一个列表索引从 0 开始，下图清楚地显示了索引从哪里开始

水果 = [ '香蕉'，'桔子'，'芒果'，'柠檬' ]
 first_fruit  = 水果[ 0 ] ＃，我们使用它的索引访问所述第一项
打印（first_fruit）       ＃香蕉
second_fruit  = 水果[ 1 ]
印刷（second_fruit )      # 橙子
last_fruit  = 水果[ 3 ]
打印( last_fruit ) # 柠檬
# 最后一个索引
last_index  =  len ( fruits ) -  1 
last_fruit  =  fruits [ last_index ]

使用负索引访问列表项

负索引表示从末尾开始，-1 表示最后一项，-2 表示倒数第二项。

水果 = [ '香蕉'，'桔子'，'芒果'，'柠檬' ]
 first_fruit  = 水果[ - 4 ]
 last_fruit  = 水果[ - 1 ]
 second_last  = 水果[ - 2 ]
打印（first_fruit）       ＃香蕉
打印（last_fruit）        # 柠檬
印花( 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
打印( rest )            # ['item4', 'item5']

# 第一个例子
fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' , 'lime' , 'apple' ]
 first_fruit , second_fruit , third_fruit , * rest  =  lst 
print ( first_fruit )      # 香蕉
打印( second_fruit )     # 橙色
印花( third_fruit )      # 芒果
印花( rest )           # ['lemon','lime','apple'] 
# 解包列表的第二个例子
first , second , third , * rest , tenth  = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]
打印（第一）           #1
打印（第二）          #2
打印（第三）           #3
打印（休息）            ＃[4,5,6,7,8,9]
打印（第十）           ＃10 
＃第三个例子约拆包列表
国家 = [ '德'，'法国'，'比利时'，'瑞典'，“丹麦' , '芬兰' , '挪威' , '冰岛' , '爱沙尼亚' ]
 gr , fr , bg , sw , * scandic ,es  = 国家
打印(gr )
打印( fr )
打印( bg )
打印( sw )
打印( scandic )
打印( es )

从列表中切片项目

正索引：我们可以通过指定开始、结束和步骤来指定一系列正索引，返回值将是一个新列表。（开始的默认值 = 0，结束 = len(lst) -
1（最后一项），步骤 = 1）

水果 = [ “香蕉”，“桔子”，“芒果”，“柠檬” ]
 all_fruits  = 水果[ 0：4 ] ＃它返回所有水果
＃这也将给出相同的结果与上述一个
all_fruits  = 水果[ 0：] ＃

负索引：我们可以通过指定开始、结束和步骤来指定一系列负索引，返回值将是一个新列表。

水果 = [ '香蕉'，'桔子'，'芒果'，'柠檬' ]
 all_fruits  = 水果[ - 4：] ＃它返回所有水果
orange_and_mango  = 水果[ - 3：- 1 ] ＃它不包括最后一个化指数，[ '桔子'， '芒果'] 
orange_mango_lemon  = 水果[ - 3：] ＃这会给开始从-3到结束，[ '桔子'， '芒果'， '柠檬'] 
reverse_fruits  = 水果[::- 1 ] # 一个否定的步骤会以相反的顺序取列表，['lemon', 'mango', 'orange', 'banana']

修改列表

列表是可变或可修改的有序项集合。让我们修改水果列表。

Fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' ]
水果[ 0 ] =  'avocado' 
print ( fruits )        # ['avocado', 'orange', 'mango', 'lemon']
水果[ 1 ] =  'apple' 
print ( fruits )        # ['avocado', 'apple', 'mango', 'lemon'] 
last_index  =  len ( fruits ) -  1 个
fruits [ last_index ] = 'lime' 
print ( fruits )         # ['avocado', 'apple', 'mango', 'lime']

检查列表中的项目

使用in运算符检查项目是否是列表的成员。请参阅下面的示例。

水果 = [ '香蕉'，'桔子'，'芒果'，'柠檬' ]
 does_exist  =  '香蕉' 在 水果
打印（does_exist）   ＃真
does_exist  =  '石灰' 在 水果
打印（does_exist）   ＃假

将项目添加到列表

要将项目添加到现有列表的末尾，我们使用方法append()。

# 语法
lst  =  list ()
 lst . 追加（项目）

水果 = [ '香蕉'，'橙色'，'芒果'，'柠檬' ]
水果。append ( 'apple' )
 print ( fruits )            # ['banana', 'orange', 'mango', 'lemon', 'apple']
水果. append ( 'lime' )    # ['banana', 'orange', 'mango', 'lemon', 'apple', 'lime']
打印(水果)

将项目插入列表

我们可以使用insert()方法在列表中的指定索引处插入单个项目。请注意，其他项目向右移动。该插件（）方法有两个参数：指数和插入项目。

# 语法
lst  = [ 'item1' , 'item2' ]
 lst . 插入（索引，项目）

水果 = [ '香蕉'，'橙色'，'芒果'，'柠檬' ]
水果。insert ( 2 , 'apple' ) # 在橙子和芒果之间插入苹果
print ( fruits )            # ['banana', 'orange', 'apple', 'mango', 'lemon'] 
fruits . insert ( 3 , 'lime' )    # ['banana', 'orange', 'apple', 'lime', 'mango', 'lemon'

从列表中删除项目

remove 方法从列表中删除指定的项目

# 语法
lst  = [ 'item1' , 'item2' ]
 lst . 删除（项目）

水果 = [ '香蕉'，'橙色'，'芒果'，'柠檬'，'香蕉' ]
水果。remove ( 'banana' )
 print ( fruits )   # ['orange', 'mango', 'lemon', 'banana'] - 此方法删除列表中第一次出现的项目
fruits。remove ( 'lemon' )
 print ( fruits )   # ['orange', 'mango', 'banana']

使用 Pop 删除项目
的弹出（）方法删除指定索引，（或如果未指定索引中的最后一项）：

# 语法
lst  = [ 'item1' , 'item2' ]
 lst . pop ()        # 最后一项
lst . 弹出（索引）

水果 = [ '香蕉'，'橙色'，'芒果'，'柠檬' ]
水果。pop ()
打印（水果）        # ['banana', 'orange', 'mango']

水果。pop ( 0 )
 print ( fruits )        # ['orange', 'mango']

标题使用 Del 删除项目

该删除关键字删除指定索引和它也可以被用于删除索引范围内的物品。它也可以完全删除列表

# 语法
lst  = [ 'item1' , 'item2' ]
 del  lst [ index ] # 只有一个项目
del  lst         # 彻底删除列表

水果 = [ '香蕉'，'桔子'，'芒果'，'柠檬'，'猕猴桃'，'石灰' ]
德尔 水果[ 0 ]
打印（水果）        ＃[ '桔子'， '芒果'， '柠檬'， 'kiwi', 'lime'] 
del  Fruits [ 1 ]
 print ( fruits )        # ['orange', 'lemon', 'kiwi', 'lime'] 
del  Fruits [ 1 : 3 ]     # 这会删除给定索引之间的项目，因此它不会删除索引为 3 的项目！
打印（水果）        ＃[“橙色”，“灰”]
德尔 水果
打印（水果）        ＃这应该给：NameError：名字“水果”没有定义

清除清单项目

在明确的（）方法清空列表：

# 语法
lst  = [ 'item1' , 'item2' ]
 lst . 清除()

水果 = [ '香蕉'，'橙色'，'芒果'，'柠檬' ]
水果。清除（）
打印（水果）        #[]

复制列表

可以通过以下方式将列表重新分配给新变量来复制列表：list2 = list1。现在，list2 是对list1 的引用，我们在list2 中所做的任何更改也将修改原来的list2，但是在很多情况下，我们不喜欢修改原始版本，而是喜欢拥有不同的副本。避免上述问题的一种方法是使用copy()。

# 语法
lst  = [ 'item1' , 'item2' ]
 lst_copy  =  lst . 复制（）

水果 = [ '香蕉'，'橙色'，'芒果'，'柠檬' ]
水果副本 = 水果。copy ()
 print ( fruit_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]
水果 = ['banana' , 'orange' , 'mango' , 'lemon' ]
蔬菜 = [ 'Tomato' , 'Potato' , 'Cabbage' , 'Onion' , 'Carrot' ]
 fruit_and_vegetables  = 水果 + 蔬菜
打印( fruit_and_vegetables ) # [ “香蕉”、“橙子”、“芒果”、“柠檬”、“番茄”、“土豆”、“卷心菜”、“洋葱”、“胡萝卜”]

使用extend() 方法连接extend()方法允许在列表中附加列表。请参阅下面的示例。

# 语法
list1  = [ 'item1' , 'item2' ]
 list2  = [ 'item3' , 'item4' , 'item5' ]
 list1 . 扩展（列表2）

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 ]
零 = [ 0 ]

负数。扩展（零）
 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' ]
蔬菜 = [ '番茄' , '土豆' , '卷心菜' , '洋葱' , '胡萝卜'. 扩展（蔬菜）
打印（'水果和蔬菜：'，水果）#水果和蔬菜：['香蕉'，'橙色'，'芒果'，'柠檬'，'番茄'，'土豆'，'卷心菜'，'洋葱'，'胡萝卜']

计算列表中的项目

的计数（）方法返回的项目在列表中显示的次数：

# 语法
lst  = [ 'item1' , 'item2' ]
 lst . 计数（项目）

水果 = [ '香蕉'，'桔子'，'芒果'，'柠檬' ]
打印（水果。计数（'橙色'））    ＃1
年龄 = [ 22，19，24，25，26，24，25，24 ]
打印（年龄。计数（24））            #3

查找项目的索引

的索引（）方法返回在列表中的项目的索引：

# 语法
lst  = [ 'item1' , 'item2' ]
 lst . 索引（项目）

Fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' ]
 print ( fruits . index ( 'orange' ))    # 1
年龄 = [ 22 , 19 , 24 , 25 , 26 , 24 , 25 , 24 ]
打印（年龄。指数（24））            ＃2，第一次出现

反转列表

在反向（）方法将反转的列表的顺序。

# 语法
lst  = [ 'item1' , 'item2' ]
 lst . 反转()

水果 = [ '香蕉'，'橙色'，'芒果'，'柠檬' ]
水果。reverse ()
 print ( fruits ) # ['lemon', 'mango', 'orange', 'banana'] 
age  = [ 22 , 19 , 24 , 25 , 26 , 24 , 25 , 24 ]
年龄. reverse ()
打印（年龄）# [24, 25, 24, 26, 25, 24, 19, 22]

排序列表项

要对列表进行排序，我们可以使用sort()方法或sorted()内置函数，该排序（）方法进行重新排序升序排列列表项，并修改原来的列表中，如果sort()方法的参数reverse 等于 true，它将按降序排列列表。

sort()：此方法修改原始列表

# 语法
lst  = [ 'item1' , 'item2' ]
 lst . sort ()                 #升序
lst . sort ( reverse = True )     # 降序

例子：

水果 = [ '香蕉'，'橙色'，'芒果'，'柠檬' ]
水果。sort ()
 print ( fruits )              # 按字母顺序排序，['banana', 'lemon', 'mango', 'orange'] 
fruits . sort ( reverse = True )
 print ( fruits ) # ['orange', 'mango', 'lemon', 'banana'] 
ages  = [ 22 , 19 , 24 ,, 24 , 25 , 24 ]
年龄。sort ()
打印( age ) # [19, 22, 24, 24, 24, 25, 25, 26]

年龄。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', 以上是关于坚持不懈续集  初学者挑战学习Python编程30天的主要内容，如果未能解决你的问题，请参考以下文章 
 简洁易懂，初学者挑战学习Python编程30天 
 简洁易懂，初学者挑战学习Python编程30天 
 简洁易懂，初学者挑战学习Python编程30天 
 初学者学习Python编程面临哪些挑战？
 Python学多久能接单赚钱？按照这套路线学习，30天内就可以！
 《挑战30天C++入门极限》引言

坚持不懈续集 初学者挑战学习Python编程30天