坚持坚持再坚持！！！

如果文章对于你有帮助，欢迎收藏、关注、点赞与订阅专栏

有任何疑问欢迎私信

目录

第 11 天 - 函数定义函数声明和调用函数无参数函数返回值的函数 - 第 1 部分带参数的函数使用键和值传递参数返回值的函数 - 第 2 部分带默认参数的函数任意数量的参数函数中的默认参数和任意数量的参数函数作为另一个函数的参数第 12 天 - 模块什么是模块创建模块导入模块从模块导入函数从模块导入函数并重命名导入内置模块操作系统模块系统模块统计模块数学模块字符串模块随机模块第 13 天 - 列表理解Lambda 函数创建 Lambda 函数另一个函数中的 Lambda 函数第 14 天 - 高阶函数作为参数的函数作为返回值的函数Python 闭包Python 装饰器创建装饰器将多个装饰器应用于单个函数在装饰器函数中接受参数内置高阶函数Python - 地图函数Python - 过滤功能Python - 减少函数第 15 天 - Python 类型错误语法错误名称错误索引错误模块未找到错误属性错误密钥错误类型错误导入错误值错误零分误差第 16 天 - Python 日期时间获取日期时间信息使用strftime格式化日期输出使用strptime 将字符串转换为时间使用日期时间中的日期代表时间的时间对象两个时间点之间的差异使用使用timedelata 的两个时间点之间的差异第 17 天 - 异常处理在 Python 中打包和解包参数开箱包装装箱单在 Python 中传播枚举压缩第 18 天 - 正则表达式常用表达该重模块re模块中的方法使用 RegEx Split 拆分文本编写正则表达式模式方括号正则表达式中的转义字符（\）一次或多次(+)时期（。）零次或多次(*)零次或一次（？）正则表达式中的量词购物车 ^第 19 天 - 文件处理打开文件进行阅读打开文件进行写入和更新删除文件文件类型带有 txt 扩展名的文件带有 json 扩展名的文件将 JSON 更改为字典将字典更改为 JSON保存为 JSON 文件带有 csv 扩展名的文件带有 xlsx 扩展名的文件带有 xml 扩展名的文件第 20 天 - Python 包管理器(PIP)什么是PIP？安装PIP使用 pip 安装包卸载软件包包裹清单显示包画中画冻结从 URL 读取创建包关于包的更多信息

第 11 天 - 函数

到目前为止，我们已经看到了许多内置的 Python 函数。今天，我们将重点介绍自定义函数。什么是函数？在开始制作函数之前，让我们先了解一下什么是函数以及为什么需要它们？

定义函数

函数是设计用于执行特定任务的可重用代码块或编程语句。为了定义或声明一个函数，Python 提供了def关键字。以下是定义函数的语法。只有在调用或调用函数时才执行代码的功能块。

声明和调用函数

当我们创建一个函数时，我们称之为声明一个函数。当我们开始使用它时，我们称它为调用或调用一个函数。函数可以带参数或不带参数声明。

# 语法# 声明函数def function_name ():代码代码# 调用函数function_name ()

无参数函数

函数可以不带参数声明。

例子：

def generate_full_name ():first_name = 'Asabeneh' last_name = 'Yetayeh' space = '' full_name = first_name + space + last_name print ( full_name )generate_full_name () #调用一个函数def add_two_numbers ():num_one = 2 num_two = 3 total = num_one + num_two print ( total )add_two_numbers ()

返回值的函数 - 第 1 部分

函数也可以返回值，如果函数没有return语句，则函数的值为None。让我们使用 return 重写上述函数。从现在开始，当我们调用函数并打印它时，我们会从函数中获取一个值。

def generate_full_name ():first_name = 'Asabeneh' last_name = 'Yetayeh' space = '' full_name = first_name + space + last_name return full_name print ( generate_full_name ())def add_two_numbers ():num_one = 2 num_two = 3 total = num_one + num_two返回 总打印( add_two_numbers () )

带参数的函数

在函数中，我们可以传递不同的数据类型（数字、字符串、布尔值、列表、元组、字典或集合）作为参数

单参数：如果我们的函数接受一个参数，我们应该用一个参数调用我们的函数

# 语法# 声明一个函数def function_name ( parameter ):代码代码# 调用函数print ( function_name ( argument ))

例子：

def greetings ( name ):message = name + ', 欢迎来到 Python for Everyone！' 返回 消息打印（问候（'Asabeneh'））def add_ten ( num ):十 = 10返回 num + 十打印( add_ten ( 90 ))def square_number ( x ):return x * x print ( square_number ( 2 ) )def area_of_circle ( r ):PI = 3.14 area = PI * r ** 2 return area print ( area_of_circle ( 10 ) )def sum_of_numbers ( n ):total = 0 for i in range ( n + 1 ):total += i print ( total )print ( sum_of_numbers ( 10 )) # 55 print ( sum_of_numbers ( 100 )) # 5050

两个参数：一个函数可能有也可能没有一个或多个参数。一个函数也可以有两个或多个参数。如果我们的函数接受参数，我们应该使用参数调用它。让我们检查一个带有两个参数的函数：

# 语法# 声明一个函数def function_name ( para1 , para2 ):代码代码# 调用函数print ( function_name ( arg1 , arg2 ))

例子：

def generate_full_name ( first_name , last_name ):space = ' ' full_name = first_name + space + last_name return full_name print ( 'Full Name: ' , generate_full_name ( 'Asabeneh' , 'Yetayeh' ))def sum_two_numbers ( num_one , num_two ):sum = num_one + num_two return sum print ( '两个数字的和：' , sum_two_numbers ( 1 , 9 ))高清 calculate_age（CURRENT_YEAR，birth_year）：年龄 = CURRENT_YEAR - birth_year回报 年龄;打印（'年龄：'，计算年龄（，18））DEF weight_of_object（质量，重心）：重量 = STR（质量 * 重力）+ “N” ＃的值必须改变到一个字符串第一返回 重量打印（“的物体的重量以牛顿：”，weight_of_object（100，9.81 ))

使用键和值传递参数

如果我们使用键和值传递参数，则参数的顺序无关紧要。

# 语法# 声明一个函数def function_name ( para1 , para2 ):代码代码# 调用函数print ( function_name ( para1 = 'John' , para2 = 'Doe' )) # 这里参数的顺序无关紧要

例子：

def print_fullname ( firstname , lastname ):space = ' ' full_name = firstname + space + lastname print ( full_name )print ( print_fullname ( firstname = 'Asabeneh' , lastname = 'Yetayeh' ))def add_two_numbers ( num1 , num2 ):total = num1 + num2 print ( total )print ( add_two_numbers ( num2 = 3 , num1 = 2 )) # 顺序无所谓

返回值的函数 - 第 2 部分

如果我们不使用函数返回值，那么我们的函数默认返回None。要使用函数返回值，我们使用关键字return后跟我们要返回的变量。我们可以从函数返回任何类型的数据类型。

返回字符串：

示例：

def print_name ( firstname ):return firstname print_name ( 'Asabeneh' ) # Asabenehdef print_full_name ( firstname , lastname ):space = ' ' full_name = firstname + space + lastname return full_name print_full_name ( firstname = 'Asabeneh' , lastname = 'Yetayeh' )

返回一个数字：

例子：

def add_two_numbers ( num1 , num2 ):total = num1 + num2 return total print ( add_two_numbers ( 2 , 3 ))高清 calculate_age（CURRENT_YEAR，birth_year）：年龄 = CURRENT_YEAR - birth_year回报 年龄;打印（'年龄：'，计算年龄（，18））

返回一个布尔值：

示例：

def is_even ( n ):if n % 2 == 0 :print ( 'even' )return True# return 停止函数的进一步执行，类似于 break return False print ( is_even ( 10 )) # True print ( is_even ( 7 ) )) # 错误

返回列表：

示例：

DEF find_even_numbers（Ñ）：找齐 = []为 我 在 范围（Ñ + 1）：如果 我 ％ 2 == 0：找齐。追加（我）返回 找齐打印（find_even_numbers（10））

带默认参数的函数

有时我们在调用函数时将默认值传递给参数。如果我们在调用函数时不传递参数，将使用它们的默认值。

# 语法# 声明一个函数def function_name ( param = value ):代码代码# 调用函数function_name ()function_name ( arg )

例子：

def greetings ( name = 'Peter' ):message = name + '，欢迎大家使用 Python！返回 消息打印（问候（））打印（问候（'Asabeneh'））def generate_full_name ( first_name = 'Asabeneh' , last_name = 'Yetayeh' ):space = ' ' full_name = first_name + space + last_name return full_name打印（生成全名（））打印（生成全名（'大卫'，'史密斯'））DEF calculate_age（birth_year，CURRENT_YEAR = ）：年龄 = CURRENT_YEAR - birth_year返回 年龄;打印（'年龄：'，计算年龄（1821））DEF weight_of_object（质量，重心 = 9.81）：重量 = STR（质量 * 重力）+ “N” ＃的值必须改变到字符串第一返回 重量打印（“牛顿的物体的重量：”，weight_of_object（100） ) # 9.81 - 地球表面的平均重力打印( '以牛顿为单位的物体重量：' , weight_of_object ( 100 , 1.62 ))# 月球表面的重力

任意数量的参数

如果我们不知道传递给函数的参数数量，我们可以通过在参数名称前添加 * 来创建一个可以接受任意数量参数的函数。

# 语法# 声明一个函数def function_name ( * args ):代码代码# 调用函数function_name ( param1 , param2 , param3 ,..)

例子：

def sum_all_nums ( * nums ):total = 0 for num in nums :total += num# 同total = total + num return total print ( sum_all_nums ( 2 , 3 , 5 )) # 10

函数中的默认参数和任意数量的参数

def generate_groups ( team , * args ):print ( team )for i in args :print ( i )print ( generate_groups ( 'Team-1' , 'Asabeneh' , 'Brook' , 'David' , 'Eyob' ))

函数作为另一个函数的参数

#您可以将函数作为参数传递def square_number ( n ):return n * n def do_something ( f , x ):return f ( x )print ( do_something ( square_number , 3 )) # 27

到目前为止，您取得了很多成就。继续！您刚刚完成了第 11 天的挑战，距离通往伟大之路还有 11 步。

第 12 天 - 模块

什么是模块

模块是包含一组代码或一组可以包含在应用程序中的功能的文件。模块可以是包含单个变量、函数或大型代码库的文件。

创建模块

为了创建一个模块，我们在 python 脚本中编写代码并将其保存为 .py 文件。在项目文件夹中创建一个名为 mymodule.py 的文件。让我们在这个文件中写一些代码。

# mymodule.py 文件def generate_full_name ( firstname , lastname ):return firstname + ' ' + lastname

在您的项目目录中创建 main.py 文件并导入 mymodule.py 文件。

导入模块

要导入文件，我们仅使用import关键字和文件名。

# main.py 文件import mymodule print ( mymodule . generate_full_name ( 'Asabeneh' , 'Yetayeh' )) # Asabeneh Yetayeh

从模块导入函数

我们可以在一个文件中包含多个函数，并且可以以不同的方式导入所有函数。

# main.py 文件from mymodule import generate_full_name , sum_two_nums , person ,重力打印( generate_full_name ( 'Asabneh' , 'Yetayeh' ))print ( sum_two_nums ( 1 , 9 ))mass = 100 ;重量 = 质量 * 重力打印（重量）打印（人[ '名字' ]）

从模块导入函数并重命名

在导入过程中，我们可以重命名模块的名称。

＃main.py文件从 MyModule的 进口 generate_full_name 如 全名，sum_two_nums 作为 总，人 作为 p，重力 为 克打印（全名（'Asabneh' ，'Yetayeh' ））打印（总共（1，9））的质量 = 100 ;重量 = 质量 * g打印（重量）打印（p )打印( p [ 'firstname' ])

导入内置模块

像其他编程语言一样，我们也可以通过使用关键字import 导入文件/函数来导入模块。让我们导入我们将大部分时间使用的公共模块。一些常见的内置模块：math、datetime、os、sys、random、statistics、collections、json、re

操作系统模块

使用 python os模块可以自动执行许多操作系统任务。Python 中的 OS 模块提供创建、更改当前工作目录、删除目录（文件夹）、获取其内容、更改和识别当前目录的功能。

# 导入模块import os # 创建目录os . mkdir ( 'directory_name' )# 改变当前目录os . chdir ( 'path' )# 获取当前工作目录os . getcwd ()# 删除目录os . 目录()

系统模块

sys 模块提供用于操作 Python 运行时环境的不同部分的函数和变量。函数 sys.argv 返回传递给 Python 脚本的命令行参数列表。此列表中索引 0 处的项目始终是脚本的名称，索引 1 处是从命令行传递的参数。

script.py 文件示例：

import sys #print(sys.argv[0], argv[1],sys.argv[2]) # 这行会打印出： filename argument1 argument2 print ( 'Welcome {}. Enjoy {} Challenge!' . format ( sys . argv [ 1 ], sys . argv [ 2 ]))

现在要检查这个脚本是如何工作的，我在命令行中写了：

python script.py Asabeneh 30DaysOfPython

结果：

欢迎，享受 30DayOfPython 挑战！

一些有用的 sys 命令：

# 退出 sys sys。exit ()# 要知道最大的整数变量需要sys。maxsize # 要知道环境路径sys . path # 要知道您使用的 python 版本sys。版本

统计模块

统计模块提供数值数据的数理统计功能。此模块中定义的流行统计函数：mean、median、mode、stdev等。

from statistics import * # 导入所有统计模块age = [ 20 , 20 , 4 , 24 , 25 , 22 , 26 , 20 , 23 , 22 , 26 ]print ( mean ( ages )) # ~22.9 print ( median ( ages) ))# 23打印（模式（年龄）） # 20打印（stdev（年龄）） #~2.3

数学模块

包含许多数学运算和常数的模块。

进口 数学打印（数学。PI） ＃3.141592653589793，PI常数打印（数学。SQRT（2）） ＃1.4142135623730951，平方根打印（数学。POW（2，3））＃8.0，指数函数打印（数学。地板（9.81）） ＃9，四舍五入到最低打印（数学。小区（9.81）） # 10，四舍五入到最高打印( math . log10 ( 100 )) # 2，以10为底的对数

现在，我们已经导入了math模块，其中包含许多可以帮助我们进行数学计算的功能。要检查模块具有哪些功能，我们可以使用help(math)或dir(math)。这将显示模块中的可用功能。如果我们只想从模块中导入一个特定的函数，我们按如下方式导入它：

从 数学 导入 pi打印( pi )

也可以一次导入多个函数

从 数学 进口 PI，SQRT，POW，地板，小区，日志10打印（PI） ＃3.141592653589793打印（SQRT（2）） ＃1.4142135623730951打印（POW（2，3）） ＃8.0打印（地板（9.81）） ＃9打印(上限( 9.81 )) ＃10打印（数学。LOG10（100））＃2

但是如果我们想导入 math 模块中的所有函数，我们可以使用 * 。

from math import * print ( pi ) # 3.141592653589793, pi 常数打印( sqrt ( 2 )) # 1.4142135623730951, 平方根打印( pow ( 2 , 3 )) # 8.0, 指数打印( floor ( 9.81 ) 四舍五入)最低的打印( ceil ( 9.81 )) # 10，四舍五入到最高的打印( math .log10 ( 100 ))# 2

当我们导入时，我们还可以重命名函数的名称。

from math import pi as PI print ( PI ) # 3.141592653589793

字符串模块

字符串模块是一个用于多种用途的有用模块。下面的示例显示了 string 模块的一些用法。

进口 字符串打印（串。ascii_letters）＃abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ打印（串。位数） ＃0123456789打印（串。标点符号） ＃“＃$％＆'（）* +， - 。/？：; <=> @ [\] ^_`{|}~

随机模块

到目前为止，您已经熟悉了导入模块。让我们再做一个导入来熟悉它。让我们导入random模块，它给我们一个 0 到 0.9999 之间的随机数… random模块有很多功能，但在本节中我们将只使用random和randint。

from random import random , randint print ( random ()) # 不带任何参数；它返回一个介于 0 和 0.9999 之间的值print ( randint ( 5 , 20 )) # 它返回一个介于 [5, 20] 之间的随机整数

你要走得很远。继续！您刚刚完成了第 12 天的挑战，距离通往伟大之路还有 12 步。

第 13 天 - 列表理解

Python 中的列表推导式是一种从序列创建列表的紧凑方式。这是创建新列表的一种快捷方式。列表理解比使用for循环处理列表快得多。

# 语法[ i for i in iterable if expression ]

示例：1

例如，如果您想将字符串更改为字符列表。您可以使用几种方法。让我们看看其中的一些：

# 一种方式language = 'Python' lst = list ( language ) # 将字符串改为列表print ( type ( lst ))# list print ( lst ) # ['P', 'y', 't', 'h' ， '在']# 第二种方式：list comprehension lst = [ i for i in language ]print ( type ( lst )) # list print ( lst ) # ['P', 'y', 't', 'h', 'o', 'n']

示例：2

例如，如果你想生成一个数字列表

# 生成数字numbers = [ i for i in range ( 11 )] # 生成从 0 到 10 的数字print ( numbers ) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]# 可以在迭代期间进行数学运算squares = [ i * i for i in range ( 11 )]print ( squares ) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]# 也可以创建一个元组列表numbers = [( i , i * i ) for i in range ( 11 )]print ( numbers )# [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

示例：2

列表推导式可以与 if 表达式结合使用

# 生成偶数even_numbers = [ i for i in range ( 21 ) if i % 2 == 0 ] # 生成 0 到 21 范围内的偶数列表print ( even_numbers ) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]# 生成奇数odd_numbers = [ i for i in range ( 21 ) if i % 2 != 0 ] # 生成0到21范围内的奇数print ( odd_numbers ) # [1, 3, 5, 7, 9, 11 , 13, 15, 17, 19] # 过滤数字：让我们从下面的列表中过滤掉正偶数numbers = [ - 8 , - 7 , - 3 , - 1 , 0 ,1 , 3 , 4 , 5 , 7 , 6 , 8 , 10 ]positive_even_numbers = [ i for i in range ( 21 ) if i % 2 == 0 and i > 0 ]print ( positive_even_numbers ) # [2, 4, 6 , 8, 10, 12, 14, 16, 18, 20]# 展平一个三维数组list_of_lists = [[ 1 , 2 , 3 ], [ 4 , 5 , 6 ], [ 7 , 8 , 9 ]]flattened_list = [ number for row in list_of_lists for number in row ]print ( flattened_list )# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Lambda 函数

Lambda 函数是一个没有名字的小型匿名函数。它可以接受任意数量的参数，但只能有一个表达式。Lambda 函数类似于 JavaScript 中的匿名函数。当我们想在另一个函数中编写匿名函数时，我们需要它。

创建 Lambda 函数

要创建 lambda 函数，我们使用lambda关键字，后跟参数，后跟表达式。请参阅下面的语法和示例。Lambda 函数不使用 return，但它显式返回表达式。

# 语法x = lambda param1 , param2 , param3 : param1 + param2 + param2 print ( x ( arg1 , arg2 , arg3 ))

例子：

# 命名函数def add_two_nums ( a , b ):return a + bprint ( add_two_nums ( 2 , 3 ))# 5 # 让我们把上面的函数改成 lambda 函数add_two_nums = lambda a , b : a + b print ( add_two_nums ( 2 , 3 ))# 5# 自调用 lambda 函数( lambda a , b : a + b )( 2 , 3 ) # 5 - 需要将其封装在 print() 中才能在控制台中查看结果square = lambda x : x ** 2 print ( square ( 3 ))# 9 cube = lambda x : x ** 3 print ( cube ( 3 ))# 27# 多个变量multiple_variable = lambda a , b , c : a ** 2 - 3 * b + 4 * c print ( multiple_variable ( 5 , 5 , 3 )) # 22

另一个函数中的 Lambda 函数

在另一个函数中使用 lambda 函数。

def power ( x ):返回 lambda n : x ** ncube = power ( 2 )( 3 ) # 函数 power 现在需要 2 个参数来运行，在单独的圆括号中print ( cube ) # 8 two_power_of_five = power ( 2 )( 5 ) print ( two_power_of_five ) # 32

保持良好的工作。保持势头，天空是极限！您刚刚完成了第 13 天的挑战，距离通往伟大之路还有 13 步。

第 14 天 - 高阶函数

在 Python 中，函数被视为一等公民，允许您对函数执行以下操作：

一个函数可以接受一个或多个函数作为参数一个函数可以作为另一个函数的结果返回一个函数可以修改一个函数可以赋值给一个变量

今天，我们将介绍：

将函数作为参数处理将函数作为另一个函数的返回值返回使用 Python 闭包和装饰器

作为参数的函数

def sum_numbers ( nums ): # 普通函数返回 sum ( nums )# 一个滥用内置 sum 函数的悲伤函数 :<def high_order_function ( f , lst ): # 函数作为参数summation = f ( lst )return summation result = Higher_order_function ( sum_numbers , [ 1 , 2 , 3 , 4 , 5 ])print ( result ) # 15

作为返回值的函数

def square ( x ): # 一个平方函数return x ** 2def cube ( x ): # 一个立方体函数return x ** 3def absolute ( x ): # 一个绝对值函数if x >= 0 :return x else :return - ( x )def Higher_order_function ( type ): # 一个高阶函数返回一个函数if type == 'square' :return square elif type == 'cube' :return cube elif type == 'absolute' :return absoluteresult = Higher_order_function ( 'square' )print ( result ( 3 )) # 9 result = Higher_order_function ( 'cube' )print ( result ( 3 )) # 27 result = Higher_order_function ( 'absolute' )print ( result ( - 3 )) # 3

从上面的例子可以看出，高阶函数根据传递的参数返回不同的函数

Python 闭包

Python 允许嵌套函数访问封闭函数的外部作用域。这被称为闭包。让我们看看闭包在 Python 中是如何工作的。在 Python 中，闭包是通过在另一个封装函数中嵌套一个函数然后返回内部函数来创建的。请参阅下面的示例。

例子：

def add_ten ():十 = 10 def add ( num ):返回 num + 十返回 添加closure_result = add_ten（）打印（closure_result（5）） ＃15打印（closure_result（10）） ＃20

Python 装饰器

装饰器是 Python 中的一种设计模式，它允许用户在不修改其结构的情况下向现有对象添加新功能。装饰器通常在定义要装饰的函数之前调用。

创建装饰器

要创建装饰器函数，我们需要一个带有内部包装函数的外部函数。

例子：

# 普通函数def greeting ():return 'Welcome to Python' def uppercase_decorator ( function ):def wrapper ():func = function ()make_uppercase = func . upper ()return make_uppercase return wrapper g = uppercase_decorator ( greeting )print ( g ()) # 欢迎来到 PYTHON## 让我们用一个装饰器来实现上面的例子'''这个装饰器函数是一个以函数为参数的高阶函数''' def uppercase_decorator ( function ):def wrapper ():func = function ()make_uppercase = func。upper ()return make_uppercase return wrapper @ uppercase_decoratordef greeting ():return 'Welcome to Python' print ( greeting ()) # WELCOME TO PYTHON

将多个装饰器应用于单个函数

'''这些装饰器函数是以函数为参数的高阶函数'''# 第一个装饰器def uppercase_decorator ( function ):def wrapper ():func = function ()make_uppercase = func . upper ()返回 make_uppercase返回 包装器# 第二个装饰器def split_string_decorator ( function ):def wrapper ():func = function ()splitted_string = func . split ()返回 splitted_string返回 包装器@ split_string_decorator@ uppercase_decorator# 在这种情况下，装饰器的顺序很重要 - .upper() 函数不适用于列表def greeting ():return 'Welcome to Python' print ( greeting ()) # WELCOME TO PYTHON

在装饰器函数中接受参数

大多数时候我们需要我们的函数接受参数，所以我们可能需要定义一个接受参数的装饰器。

d

ef decorator_with_parameters ( function ):def wrapper_accepting_parameters ( para1 , para2 , para3 ):function ( para1 , para2 , para3 )print ( "I live in {}" . format ( para3 ))return wrapper_accepting_parameters@ decorator_with_parameters高清 print_full_name（FIRST_NAME，姓氏，国家）：打印（“我是{} {}我爱教”。格式（如first_name，姓氏，国家））print_full_name ( "Asabeneh" , "Yetayeh" , '芬兰' )

内置高阶函数

我们在本部分中介绍的一些内置高阶函数是map()、filter和reduce。Lambda 函数可以作为参数传递，而 lambda 函数的最佳用例是 map、filter 和 reduce 等函数。

Python - 地图函数

map() 函数是一个内置函数，它接受一个函数和 iterable 作为参数。

# 语法映射（函数，可迭代）

示例：1

numbers = [ 1 , 2 , 3 , 4 , 5 ] # iterable def square ( x ):return x ** 2 numbers_squared = map ( square , numbers )print ( list ( numbers_squared ))# [1, 4, 9, 16 , 25] # 让我们用一个 lambda 函数来 应用它numbers_squared = map ( lambda x : x ** 2, numbers )print ( list ( numbers_squared ))# [1, 4, 9, 16, 25]

示例：2

numbers_str = [ '1' , '2' , '3' , '4' , '5' ] # 可迭代numbers_int = map ( int , numbers_str )print ( list ( numbers_int ))# [1, 2, 3, 4, 5]

示例：3

names = [ 'Asabeneh' , 'Lidiya' , 'Ermias' , 'Abraham' ] # 可迭代def change_to_upper ( name ):返回 name。上()names_upper_cased = map ( change_to_upper , names )print ( list ( names_upper_cased ))# ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM']# 让我们用一个 lambda 函数来应用它names_upper_cased = map ( lambda name : name . upper (), names )print ( list ( names_upper_cased ))# ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM']

实际上 map 所做的是迭代一个列表。例如，它将名称更改为大写并返回一个新列表。

Python - 过滤功能

filter() 函数调用指定的函数，该函数为指定的可迭代对象（列表）的每个项目返回布尔值。它过滤满足过滤条件的项目。

# 语法过滤器（函数，可迭代）

示例：1

# 只过滤偶数数字 = [ 1 , 2 , 3 , 4 , 5 ] # iterabledef is_even ( num ):if num % 2 == 0 :return True return Falseeven_numbers = filter ( is_even , numbers )print ( list ( even_numbers )) # [2, 4]

示例：2

数字 = [ 1 , 2 , 3 , 4 , 5 ] # 可迭代def is_odd ( num ):if num % 2 != 0 :return True return False奇数 = 过滤器( is_odd ,数字)打印(列表(奇数)) # [1, 3, 5]

# 过滤长名称names = [ 'Asabeneh' , 'Lidiya' , 'Ermias' , 'Abraham' ] # iterable def is_name_long ( name ):if len ( name ) > 7 :return True return Falselong_names = filter ( is_name_long , names )print ( list ( long_names ))# ['Asabeneh']

Python - 减少函数

在减少（）函数的fucntools模块里定义，我们应该从这个模块导入。与 map 和 filter 一样，它需要两个参数，一个函数和一个可迭代对象。但是，它不会返回另一个可迭代对象，而是返回单个值。

示例：1

numbers_str = [ '1' , '2' , '3' , '4' , '5' ] # iterable def add_two_nums ( x , y ):return int ( x ) + int ( y )total = reduce ( add_two_nums , numbers_str )print ( total )# 15

第 15 天 - Python 类型错误

当我们编写代码时，我们经常会犯错或其他一些常见的错误。如果我们的代码无法运行，Python 解释器将显示一条消息，其中包含有关问题发生位置和错误类型信息的反馈。它有时也会为我们提供可能的修复建议。了解编程语言中不同类型的错误将帮助我们快速调试我们的代码，也可以让我们更好地完成我们的工作。

让我们一一看看最常见的错误类型。首先让我们打开 Python 交互式 shell。转到您的计算机终端并编写“python”。python交互式shell将被打开。

语法错误

示例 1：语法错误

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 打印 '世界你好'文件 “<标准输入>” ，行 1打印 的'Hello World' ^ SyntaxError错误：缺少 括号 中 调用 到 '打印'。 意思是 打印（'你好世界'）？>> >

正如您所看到的，我们犯了一个语法错误，因为我们忘记用括号将字符串括起来，而 Python 已经提出了解决方案。让我们修复它。

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 打印 '世界你好'文件 “<标准输入>” ，行 1打印 的'Hello World' ^ SyntaxError错误：缺少 括号 中 调用 到 '打印'。 意思是 打印（'你好世界'）？>> > 打印（'你好世界'）你好 世界>> >

错误是SyntaxError。修复后，我们的代码顺利执行。让我们看看更多的错误类型。

名称错误

示例 1：名称错误

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 打印（年龄）回溯（最 近期的 通话 最后）：文件 “<标准输入>” ，线 1，在 <模块> NameError：名 “年龄” 是 没有 定义>> >

从上面的消息中可以看出，名称年龄没有定义。是的，我们确实没有定义年龄变量，但我们试图将它打印出来，就像我们已经声明它一样。现在，让我们通过声明它并赋值来解决这个问题。

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 打印（年龄）回溯（最 近期的 通话 最后）：文件 “<标准输入>” ，线 1，在 <模块> NameError：名 '年龄' 被 未 限定>> > 年龄 = 25 >> > 打印（年龄）25 >> >

错误类型是NameError。我们通过定义变量名来调试错误。

索引错误

示例 1：索引错误

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 数 = [ 1，2，3，4，5 ]>> > 号[ 5 ]回溯（最 近期 呼叫 最后):File "<stdin>" , line 1 , in < module > IndexError : list index out of range >> >

在上面的例子中，Python 引发了一个IndexError，因为列表只有从 0 到 4 的索引，所以它超出了范围。

模块未找到错误

示例 1：ModuleNotFoundError

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 进口 数学回溯（最 近期的 通话 最后）：文件 “<标准输入>” ，线 1，在 <模块> ModuleNotFoundError：无 名为 “数学”的模块>> >

在上面的例子中，我故意在数学中添加了一个额外的 s 并且引发了 ModuleNotFoundError。让我们通过从数学中删除额外的 s 来解决它。

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 进口 数学回溯（最 近期的 通话 最后）：文件 “<标准输入>” ，线 1，在 <模块> ModuleNotFoundError：无 名为 “数学”的模块>> > 导入 数学>> >

我们修复了它，所以让我们使用 math 模块中的一些函数。

属性错误

示例 1：属性错误

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 进口 数学回溯（最 近期的 通话 最后）：文件 “<标准输入>” ，线 1，在 <模块> ModuleNotFoundError：无 名为 “数学”的模块>> > 导入 数学>> > 数学。PI回溯（最 近期的 通话 最后）：文件 “<标准输入>” ，线 1，在 <模块> AttributeError的：模块 '数学' 有 没有 属性 'PI' >> >

如你所见，我又犯了一个错误！我尝试从 maths 模块调用 PI 函数，而不是 pi。它引发了一个属性错误，这意味着该功能在模块中不存在。让我们通过从 PI 更改为 pi 来修复它。

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 进口 数学回溯（最 近期的 通话 最后）：文件 “<标准输入>” ，线 1，在 <模块> ModuleNotFoundError：无 名为 “数学”的模块>> > 导入 数学>> > 数学。PI回溯（最 近期的 通话 最后）：文件 “<标准输入>” ，线 1，在 <模块> AttributeError的：模块 '数学' 有 没有 属性 'PI' >> > 数学。圆周率3.141592653589793 >> >

现在，当我们从 math 模块调用 pi 时，我们得到了结果。

密钥错误

示例 1：密钥错误

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > users = {'name' : 'Asab' , 'age' : 250 , 'country' : 'Finland' }>> > users [ 'name' ]'阿萨布' >>>用户[ '县']回溯（最 近期 呼叫 最后）：文件 “<标准输入>” ，线 1，在 <模块> KeyError异常：'县' >> >

如您所见，用于获取字典值的键中存在拼写错误。所以，这是一个关键错误，修复非常简单。我们开工吧！

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > user = {'name' : 'Asab' , 'age' : 250 , 'country' : 'Finland' }>> > user [ 'name' ]'阿萨布' >>>用户[ '县']回溯（最 近期 呼叫 最后）：文件 “<标准输入>” ，线 1，在 <模块> KeyError异常：'县' >> > 用户[ '国家' ]'芬兰'>> >

我们调试了错误，运行了代码并获得了值。

类型错误

示例 1：类型错误

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 4 + '3'回溯（最 近期 呼叫 最后）：文件 “<标准输入>” ，线 1，在 <模块>类型错误： 操作数 类型（小号）为 +：'INT' 和 'STR' >> >

在上面的示例中，由于我们无法向字符串添加数字，因此会引发 TypeError。第一个解决方案是将字符串转换为 int 或 float。另一种解决方案是将数字转换为字符串（结果将是“43”）。让我们遵循第一个修复程序。

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 4 + '3'回溯（最 近期 呼叫 最后）：文件 “<标准输入>” ，线 1，在 <模块>类型错误： 操作数 类型（小号）为 +：'INT' 和 'STR' >> > 4 + INT（'3' ）7 >> > 4 + 浮动（'3' ）7.0 >> >

错误消除，我们得到了预期的结果。

导入错误

示例 1：类型错误

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 从 数学 进口 电力回溯（最 近期的 通话 最后）：文件 “<标准输入>”，线 1，在 <模块>无法 从“数学”导入 名称 “power ” >> >

数学模块中没有名为 power 的函数，它有一个不同的名称：pow。让我们更正一下：

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 从 数学 进口 电力回溯（最 近期的 通话 最后）：文件 “<标准输入>”，线 1，在 <模块>无法 从'math' >> > from math import pow >> > pow ( 2 , 3 )8.0 >> >导入 名称 'power'

值错误

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > INT（'12A' ）回溯（最 近期 呼叫 最后）：文件 “<标准输入>” ，线 1，在 <模块>无效 字面 为 INT（）与 碱 10：'12A' >> >

在这种情况下，我们不能将给定的字符串更改为数字，因为其中包含 ‘a’ 字母。

零分误差

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 1 / 0回溯（最 近期 呼叫 最后）：文件 “<标准输入>” ，线 1，在 <模块> ZeroDivisionError： 按 零>> >

我们不能将一个数除以零。

我们已经介绍了一些 python 错误类型，如果你想查看更多关于它的信息，请查看关于 python 错误类型的 python 文档。如果您擅长阅读错误类型，那么您将能够快速修复错误，并且您还将成为一名更好的程序员。

你很优秀。你成功了一半。

第 16 天 - Python 日期时间

Python 有datetime模块来处理日期和时间。

导入 日期时间打印（目录（日期时间））[ 'MAXYEAR' ，'MINYEAR' ，'__builtins__' ，'__cached__' ，'__doc__' ，'__file__' ，'__loader__' ，'__name__' ，'__PACKAGE__' ，'__spec__' ，'日期'，'日期时间'，' datetime_CAPI'、'sys'、'time'、'timedelta'、'timezone'、'tzinfo' ]

使用 dir 或 help 内置命令可以知道某个模块中的可用功能。如您所见，在 datetime 模块中有许多函数，但我们将重点介绍date、datetime、time和timedelta。让我们一一看看。

获取日期时间信息

from datetime import datetime now = datetime。现在()打印(现在) # -07-08 07:34:46.549883 day = now . 天 # 8月 = 现在。月# 7年 = 现在。年 # 小时 = 现在。小时 # 7分钟 = 现在。分钟 # 38秒 = 现在。第二时间戳 = 现在。时间戳（）打印（日，月，年，小时，分钟）打印（'时间戳'，时间戳）打印（f' {天} / {月} / {年}，{小时}：{分钟} '） #8 /7/, 7:38

时间戳或 Unix 时间戳是从 1970 年 1 月 1 日 UTC 开始经过的秒数。

使用strftime格式化日期输出

from datetime import datetime new_year = datetime ( , 1 , 1 )print ( new_year ) # -01-01 00:00:00 day = new_year。天月 = new_year。月年 = new_year。年小时 = new_year。小时分钟 = new_year。分第二 = new_year。第二打印（日、月、年、小时、分钟）#1 1 0 0打印（f' {天} / {月} / {年} , {小时} : {分钟} '） # 1/1/， 0:0

可以在此处找到使用strftime方法和文档格式化日期时间。

from datetime import datetime # 当前日期和时间now = datetime . 现在()t = 现在。strftime ( "%H:%M:%S" )打印( "time:" , t )time_one = now。strftime ( "%m/%d/%Y, %H:%M:%S" )# mm/dd/YY H:M:S 格式打印( "time one:" , time_one )time_two = now . 时间（"%d/%m/%Y, %H:%M:%S" )# dd/mm/YY H:M:S 格式打印( "time two:" , time_two )

时间：01 :05 :01时间一：12/05/，01:05 :01 第二时间：05/12/，01:05:01

这是我们用来格式化时间的所有strftime符号。此模块的所有格式的示例。

使用strptime 将字符串转换为时间

这是一个有助于理解格式的文档。

from datetime import datetime date_string = "5 December, " print ( "date_string =" , date_string )date_object = datetime。strptime ( date_string , "%d %B, %Y" )打印( "date_object =" , date_object )

date_string = 年 12 月 5 日date_object = -12-05 00:00:00

使用日期时间中的日期

from datetime import date d = date ( , 1 , 1 )print ( d )print ( 'Current date:' , d . today ())# -12-05 # 今天的日期对象today = date . today ()print ( "Current year:" , today . year ) # print ( "Current month:" , today .月）＃12打印（“当前天：” ，今。日）＃5

代表时间的时间对象

from datetime import time # time(hour = 0, minute = 0, second = 0) a = time ()print ( "a =" , a )# time(hour, minute and second) b = time ( 10 , 30 , 50 )print ( "b =" , b )# time(hour, minute and second) c = time ( hours = 10 , minute = 30 , second = 50 )print ( "c =" , c )# time(hour, minute, second, microsecond ) d = time ( 10 , 30 , 50 , 55 )print ( "d =" , d )

输出 a = 00:00:00

b = 10:30:50

c = 10:30:50

d = 10:30:50.55

两个时间点之间的差异使用

today = date ( year = , month = 12 , day = 5 )new_year = date ( year = , month = 1 , day = 1 )time_left_for_newyear = new_year - today # 新年还剩27天，0:00 :00打印（'新年还剩时间：'，time_left_for_newyear）t1 = 日期时间（年 = ，月 = 12，日 = 5，小时 = 0，分钟 = 59，秒 = 0）t2 = 日期时间（年 = ，月 = 1，日 = 1，小时 = 0，分钟 = 0 ,秒 = 0)diff = t2 - t1 print ( 'Time left for new year:' , diff ) # 新年剩余时间：26 天，23:01:00

使用timedelata 的两个时间点之间的差异

从 日期时间 进口 timedelta T1 = timedelta（周= 12，天= 10，小时= 4，秒= 20）T2 = timedelta（天= 7，小时= 5，分钟= 3，秒= 30）T3 = T1 - T2打印( "t3 =" , t3)

date_string = 年 12 月 5 日

date_object = -12-05 00:00:00

t3 = 86 天，22:56:50

第 17 天 - 异常处理

Python 使用try和except来优雅地处理错误。错误的优雅退出（或优雅处理）是一种简单的编程习惯用法 - 程序检测到严重的错误情况并因此以受控方式“优雅退出”。通常，作为优雅退出的一部分，程序会向终端或日志打印描述性错误消息，这使我们的应用程序更加健壮。异常的原因通常在程序本身之外。异常的一个例子可能是不正确的输入、错误的文件名、无法找到文件、IO 设备故障。优雅地处理错误可以防止我们的应用程序崩溃。

我们在上一节中介绍了不同的 Python错误类型。如果我们在我们的程序中使用try和except，那么它不会在这些块中引发错误。

尝试：代码 在 此 块 如果 事情 去 也只是：代码 在 此 块 来看 ，如果 事情 去 错了

例子：

尝试：打印（10 + '5'）除了：打印（'出了点问题'）

在上面的例子中，第二个操作数是一个字符串。我们可以将其更改为 float 或 int 以将其与数字相加以使其工作。但是没有任何更改，将执行第二个块，除了。

例子：

try :name = input ( 'Enter your name:' )year_born = input ( 'Year youbirth :' )age = - year_born print ( f'You are {name } . And your age is {age } .' )除了：打印（'出了点问题'）

在上面的例子中，异常块将运行，我们不知道确切的问题。为了分析问题，我们可以使用 except 的不同错误类型。

在下面的示例中，它将处理错误并告诉我们引发的错误类型。

try :name = input ( 'Enter your name:' )year_born = input ( 'Year youbirth :' )age = - year_born print ( f'You are {name } . And your age is {age } .' )除了 TypeError :打印( '发生类型错误' )除了 ValueError :打印( '发生值错误' )除外 ZeroDivisionError :打印（'发生零除错误'）

输入您的姓名：Asabeneh出生年份：1920出现类型错误

在上面的代码中，输出将是TypeError。现在，让我们添加一个额外的块：

try :name = input ( 'Enter your name:' )year_born = input ( 'Year youbirth :' )age = - int ( year_born )print ( '你是{name}。你的年龄是{age}。' )除了 TypeError :打印( '发生类型错误' )除了 ValueError :打印( '发生值错误' )除了 ZeroDivisionError :打印（“发生零除法错误”）else：打印（“我通常使用 try 块运行”）最后：打印（“我总是运行。”）

输入您的姓名：Asabeneh出生年份：1920你是阿萨贝尼。而你的年龄是 99 岁。我通常使用 try 块运行我总是跑。

它也将上面的代码缩短如下：

try :name = input ( 'Enter your name:' )year_born = input ( 'Year youbirth :' )age = - int ( year_born )print ( 'You are {name}. And your age is {age}.' )除了 异常 为 e :打印( e )

在 Python 中打包和解包参数

我们使用两个运算符：

对于元组

** 用于字典

让我们在下面举个例子。它只需要参数，但我们有列表。我们可以解压缩列表并更改参数。

开箱

拆箱清单

def sum_of_five_nums ( a , b , c , d , e ):返回 a + b + c + d + elst = [ 1 , 2 , 3 , 4 , 5 ]print ( sum_of_five_nums ( lst )) # TypeError: sum_of_five_nums() 缺少 4 个必需的位置参数：'b'、'c'、'd' 和 'e'

当我们运行此代码时，它会引发错误，因为此函数将数字（而不是列表）作为参数。让我们解压/解构列表。

def sum_of_five_nums ( a , b , c , d , e ):返回 a + b + c + d + elst = [ 1 , 2 , 3 , 4 , 5 ]打印( sum_of_five_nums ( * lst )) # 15

我们还可以在期望开始和结束的范围内置函数中使用解包。

numbers = range ( 2 , 7 ) # 带有单独参数的普通调用print ( list ( numbers )) # [2, 3, 4, 5, 6] args = [ 2 , 7 ]numbers = range ( * args ) # call with从列表中解压出来的参数print ( numbers ) # [2, 3, 4, 5,6]

列表或元组也可以这样解包：

country = [ '芬兰' , '瑞典' , '挪威' , '丹麦' , '冰岛' ]fin , sw , nor , * rest = countries print ( fin , sw , nor , rest ) # 芬兰 瑞典 挪威 ['丹麦', '冰岛'] numbers = [ 1 , 2 , 3 , 4 , 5 , 6 , 7]one , * middle , last = numbers print ( one , middle , last ) # 1 [2, 3, 4, 5, 6] 7

解压字典

def unpacking_person_info ( name , country , city , age ):返回 f' {name }住在{country } , {city }。他是{年龄}岁。dct = {'name' : 'Asabeneh' , 'country' : 'Finland' , 'city' : 'Helsinki' , 'age' : 250 }打印(unpacking_person_info（** DCT））＃Asabeneh住在芬兰赫尔辛基。他今年 250 岁。

包装

有时我们永远不知道有多少参数需要传递给 python 函数。我们可以使用打包方法让我们的函数接受无限数量或任意数量的参数。

装箱单

def sum_all ( * args ):s = 0 for i in args :s += i return s print ( sum_all ( 1 , 2 , 3 )) # 6 print ( sum_all ( 1 , 2 , 3 , 4 , 5 , 6 , 7 )) # 28打包字典DEF packing_person_info（** kwargs）：＃检查kwargs的类型，它是一个字典类型＃打印（类型（kwargs）） ＃打印字典项为 键 在 kwargs：打印（“{键} = {kwargs [键]} " )返回 kwargs打印（packing_person_info（名称= “Asabeneh”，国家= “芬兰”，城市= “赫尔辛基”，年龄= 250））

名称 = Asabeneh国家 = 芬兰城市 = 赫尔辛基年龄 = 250{“姓名”：“阿萨本尼”，“国家”：“芬兰”，“城市”：“赫尔辛基”，“年龄”：250}

在 Python 中传播

就像在 JavaScript 中一样，在 Python 中传播是可能的。让我们在下面的例子中检查一下：

lst_one = [ 1 , 2 , 3 ]lst_two = [ 4 , 5 , 6 , 7 ]lst = [ 0 , * list_one , * list_two ]print ( lst ) # [0, 1, 2, 3, 4, 5, 6 , 7] country_lst_one = [ '芬兰' , '瑞典' , '挪威' ]country_lst_two = [ '丹麦' ,'冰岛' ]nordic_countries = [ * country_lst_one , * country_lst_two ]print ( nordic_countries ) # ['芬兰', '瑞典', '挪威', '丹麦', '冰岛']

枚举

如果我们对列表的索引感兴趣，我们使用enumerate内置函数来获取列表中每个项目的索引。

为 索引，项目 在 枚举（[ 20，30，40 ]）：打印（指数，产品）

对于 index，i 在 enumerate ( countries ) 中：print ( 'hi' )if i == 'Finland' :print ( 'The country {i} has been found at index {index}' )

国家芬兰被发现在指数 1。

压缩

有时我们想在循环时组合列表。请参阅下面的示例：

水果 = [ '香蕉'，'橙色'，'芒果'，'柠檬'，'酸橙' ]蔬菜 = [ '番茄'，'马铃薯'，'卷心菜'，'洋葱'，'胡萝卜' ]水果和蔬菜 = []对于 ˚F，v 在 拉链（水果，蔬菜）：fruits_and_veges。追加（{'水果'：'蔬菜' : v })打印（水果和蔬菜）

[{'水果'：'香蕉'，'蔬菜'：'番茄' }，{'水果'：'橙色'，'蔬菜'：'土豆' }，{'水果'：'芒果'，'蔬菜'：'卷心菜' }，{'水果'：'柠檬'，'蔬菜'：'洋葱' }，{'水果'：'酸橙'，'蔬菜'：'胡萝卜' }]

第 18 天 - 正则表达式

常用表达

正则表达式或 RegEx 是一种特殊的文本字符串，有助于在数据中查找模式。RegEx 可用于检查某些模式是否存在于不同的数据类型中。要首先在 python 中使用 RegEx，我们应该导入名为re的 RegEx 模块。

该重模块

导入模块后，我们可以使用它来检测或查找模式。

进口 重新

re模块中的方法

为了找到一个模式，我们使用不同的re字符集集，允许在字符串中搜索匹配项。

re.match()：仅在字符串第一行的开头搜索，如果找到则返回匹配的对象，否则返回 None。re.search：如果字符串中的任何地方都有匹配对象，包括多行字符串，则返回一个匹配对象。re.findall：返回包含所有匹配项的列表re.split：获取一个字符串，在匹配点处将其拆分，返回一个列表re.sub：替换字符串中的一个或多个匹配项

比赛

# 语法重新。匹配（子串，串，再。我）＃子是一个字符串或图案，字符串是我们要寻找的图案文字，如re.I是忽略大小写

进口 重新txt = '我喜欢教 python 和 javaScript' # 它返回一个具有跨度的对象，并且匹配match = re。match ( '我爱教' , txt , re . I )print ( match ) # <re.Match object; span=(0, 15), match='I love to Teaching'> # 我们可以使用 span span = match将匹配的开始和结束位置作为元组获取。span ()print ( span )# (0, 15) # 让我们从 span 中找到开始和停止位置start , end = span print ( start , end ) # 0, 15 substring = txt [ start : end ]print ( substring ) # 我喜欢教书

从上面的示例中可以看出，我们正在寻找的模式（或我们正在寻找的子字符串）是I love to Teaching。仅当文本以模式开头时，match 函数才返回一个对象。

进口 重新txt = '我喜欢教 python 和 javaScript' match = re。match ( '我喜欢教' , txt , re . I )print ( match ) # None字符串不与I like to Teaching串在一起，因此没有匹配，匹配方法返回 None。

搜索

# 语法re . match ( substring , string , re . I )# substring 是一个模式，string 是我们要查找的模式的文本，re.I 是 case ignore flag

进口 重新txt = '''Python 是人类有史以来最美丽的语言。我推荐 Python 作为第一门编程语言'''# 它返回一个具有 span 和 match match = re的对象。search ( 'first' , txt , re . I )print ( match ) # <re.Match object; span=(100, 105), match='first'> # 我们可以使用 span span = match将匹配的开始和结束位置作为元组获取。span ()print ( span )# (100, 105) # 让我们从 span start , end = span print找到开始和停止位置( start , end ) # 100 105 substring = txt [ start : end ]print ( substring ) # first

如您所见，搜索比匹配好得多，因为它可以在整个文本中查找模式。搜索返回具有找到的第一个匹配项的匹配对象，否则返回None。一个更好的re函数是findall。此函数检查整个字符串中的模式并将所有匹配项作为列表返回。

使用findall搜索所有匹配项

findall()将所有匹配项作为列表返回

txt = '''Python 是人类有史以来最美丽的语言。我推荐 Python 作为第一门编程语言'''# 它返回一个列表matches = re . findall ( 'language' , txt , re . I )print ( matches ) # ['language', 'language']

如您所见，在字符串中找到了两次language一词。让我们多练习一些。现在我们将在字符串中查找 Python 和 python 单词：

txt = '''Python 是人类有史以来最美丽的语言。我推荐 Python 作为第一门编程语言'''# 它返回列表匹配 = re . findall ( 'python' , txt , re . I )print ( matches ) # ['Python', 'python']

由于我们使用re.I，因此包括小写和大写字母。如果我们没有 re.I 标志，那么我们将不得不以不同的方式编写我们的模式。让我们来看看：

txt = '''Python 是人类有史以来最美丽的语言。我推荐 Python 作为第一门编程语言'''匹配 = 重新。findall ( 'Python|python' , txt )打印(匹配) # ['Python', 'python']#匹配 = re . findall ( '[Pp]ython' , txt )打印(匹配) # ['Python', 'python']

替换子串

txt = '''Python 是人类有史以来最美丽的语言。我推荐 Python 作为第一门编程语言'''match_replaced = re。sub ( 'Python|python' , 'JavaScript' , txt , re . I )print ( match_replaced ) # JavaScript 是人类有史以来最美丽的语言。# 或match_replaced = re . sub ( '[Pp]ython' , 'JavaScript' , txt , re . I )打印( match_replaced ) # JavaScript 是人类有史以来最美丽的语言。

让我们再添加一个例子。除非我们删除 % 符号，否则以下字符串真的很难阅读。用空字符串替换 % 将清除文本。

txt = '''%I a%m te%%a%%che%r% a%n%d %% I l%o%ve te%ach%ing。T%he%re i%sn%o%th%ing as r%ewarding a%se%duc%at%i%ng a%n%de%m%p%ow%er%ing p%e%o%请。我找到 te%a%ching m%ore i%n%t%er%%es%ting t%h%an 任何其他 %jobs。D%o%es 这%sm%ot%iv%a%te %y%o%u 到b%eat%e%a%cher？'''匹配 = 重新。sub ( '%' , '' , txt )打印（匹配）

我是老师，我喜欢教书。

没有什么比教育和赋予人们权力更有价值的了。

我发现教学比任何其他工作都有趣。这会激励你成为一名教师吗？

使用 RegEx Split 拆分文本

txt = '''我是老师，我喜欢教学。没有什么比教育和赋予人们权力更有价值的了。我发现教学比任何其他工作都有趣。这会激励你成为一名教师吗？''' print ( re . split ( ' \n ' , txt )) # splitting using \n - end of line symbol

[ '我是老师，我喜欢教学。' , '没有什么比教育和赋予人们权力更有意义的了。' , '我发现教学比任何其他工作都有趣。' , '这会激励你成为一名教师吗？' ]

编写正则表达式模式

要声明一个字符串变量，我们使用单引号或双引号。声明 RegEx 变量r’’。下面的模式只用小写字母标识苹果，为了使它不区分大小写，我们应该重写我们的模式，或者我们应该添加一个标志。

进口 重新regex_pattern = r'apple' txt = '苹果和香蕉是水果。一句陈词滥调说，医生的一天一个苹果已经被一天一个香蕉所取代，医生远离我。'匹配 = re。findall ( regex_pattern , txt )打印(匹配) # ['apple']# 为了不区分大小写添加标志 ' matches = re . findall ( regex_pattern , txt , re . I )print ( matches ) # ['Apple', 'apple'] # 或者我们可以使用一组字符方法regex_pattern = r'[Aa]pple' # 这意味着第一个字母可以是苹果或苹果匹配 = 重。findall ( regex_pattern , txt )print ( matches ) # ['Apple', 'apple']

[]：一组字符

[ac] 表示 a 或 b 或 c

[az] 表示从 a 到 z 的任何字母

[AZ] 表示从 A 到 Z 的任何字符

[0-3] 表示 0 或 1 或 2 或 3

[0-9] 表示 0 到 9 之间的任意数字

[A-Za-z0-9] 任何单个字符，即 a 到 z、A 到 Z 或 0 到 9

\：用于转义特殊字符

\d 表示：匹配字符串包含数字的地方（0-9 的数字）

\D 表示：匹配不包含数字的字符串

. : 除换行符以外的任何字符(\n)

^：以

r’^substring’ eg r’^love’, 一个以单词 love 开头的句子

r’[^abc] 表示不是 a，不是 b，不是 c。

$：以

r’substring′例如r′love' 例如 r'love′例如r′love’，以单词 love 结尾的句子

*：零次或多次

r’[a]*’ 表示一个可选的或者它可以出现多次。

+：一次或多次

r’[a]+’ 表示至少一次（或多次）

?: 零次或一次

r’[a]?’ 表示零次或一次

{3}：正好 3 个字符

{3,}：至少 3 个字符

{3,8}：3 到 8 个字符

|: 要么

r’apple|banana’ 表示苹果或香蕉

()：捕获和分组

让我们用例子来阐明上面的元字符

方括号

让我们使用方括号来包含小写和大写

regex_pattern = r'[Aa]pple' # 这个方括号表示 A 或 a txt = '苹果和香蕉是水果。一句陈词滥调说，医生的一天一个苹果已经被一天一个香蕉所取代，让医生远离我。匹配 = 重新。findall ( regex_pattern , txt )print ( matches ) # ['Apple', 'apple']

如果我们要寻找香蕉，我们写的模式如下：

regex_pattern = r'[Aa]pple|[Bb]anana' # 这个方括号表示 A 或 a txt = '苹果和香蕉是水果。一句陈词滥调说，医生的一天一个苹果已经被一天一个香蕉所取代，让医生远离我。匹配 = 重新。findall ( regex_pattern , txt )print ( matches ) # ['Apple', 'banana', 'apple', 'banana']

使用方括号和或运算符，我们设法提取Apple、apple、Banana 和banana。

正则表达式中的转义字符（\）

regex_pattern = r'\d' # d 是一个特殊字符，表示digits txt = '此正则表达式示例于12月6日制作并于7月8日修订' matches = re。findall ( regex_pattern , txt )print ( matches ) # ['6', '2', '0', '1', '9', '8', '2', '0', '2', '1 ']，这不是我们想要的

一次或多次(+)

regex_pattern = r'\d+' # d 是一个特殊字符，表示数字，+ 表示一次或多次txt = '此正则表达式示例于 年 12 月 6 日制作， 年 7 月 8 日修订' matches = re . findall ( regex_pattern , txt )print ( matches ) # ['6', '', '8', ''] - 现在更好了！

时期（。）

regex_pattern = r'[a].' # 这个方括号表示 a 和 。表示除换行符txt = '''Apple 和香蕉是水果'''匹配 = re之外的任何字符。findall ( regex_pattern , txt )print ( matches ) # ['an', 'an', 'an', 'a', 'ar']regex_pattern = r'[a].+' # . 任何字符，+ 任何字符一次或多次匹配 = re。findall ( regex_pattern , txt )print ( matches ) # ['and 香蕉是水果']

零次或多次(*)

零次或多次。该模式可能不会出现，也可能会出现多次。

regex_pattern = r'[a].*' # . 任何字符，* 任何字符零次或多次txt = '''Apple 和香蕉是水果'''匹配 = re。findall ( regex_pattern , txt )print ( matches ) # ['and 香蕉是水果']

零次或一次（？）

零次或一次。该模式可能不会出现，也可能出现一次。

txt = '''我不确定是否有约定如何写电子邮件这个词。有些人把它写成电子邮件，其他人可能把它写成电子邮件或电子邮件。''' regex_pattern = r'[Ee]-?mail' # ? 在这里意味着 '-' 是可选的matches = re。findall ( regex_pattern , txt )print ( matches ) # ['e-mail', 'email', 'Email', 'E-mail']

正则表达式中的量词

我们可以使用大括号指定我们在文本中查找的子字符串的长度。让我们想象一下，我们对长度为 4 个字符的子字符串感兴趣：

txt = '此正则表达式示例于 年 12 月 6 日制作并于 年 7 月 8 日修订' regex_pattern = r'\d{4}' # 正好四次匹配 = re . findall ( regex_pattern , txt )打印(匹配) # ['', '']TXT = '这个正则表达式示例被做了12月6，并修改了有关7月8' regex_pattern = R '\ d {1,4}' ＃1至4匹配 = 重。findall ( regex_pattern , txt )print ( matches ) # ['6', '', '8', '']

购物车 ^

以。。开始

txt = '此正则表达式示例于 年 12 月 6 日制作并于 年 7 月 8 日修订' regex_pattern = r'^This' # ^ 表示以matches = re开头。findall ( regex_pattern , txt )打印(匹配) # ['This']

否定

txt = '此正则表达式示例制作于12月6日，修改于7月8日' regex_pattern = r'[^A-Za-z ]+' # ^ in set 字符表示否定，不是A到Z，不是a 到 z，没有空格匹配 = re。findall ( regex_pattern , txt )print ( matches ) # ['6,', '', '8', '']

第 19 天 - 文件处理

到目前为止，我们已经看到了不同的 Python 数据类型。我们通常以不同的文件格式存储我们的数据。除了处理文件之外，我们还将在本节中看到不同的文件格式（.txt、.json、.xml、.csv、.tsv、.excel）。首先，让我们熟悉处理具有常见文件格式（.txt）的文件。

文件处理是编程的重要组成部分，它允许我们创建、读取、更新和删除文件。在 Python 中，我们使用open()内置函数来处理数据。

# 语法open ( 'filename' , mode ) # mode(r, a, w, x, t,b) 可以是读、写、更新

“r” - 读取 - 默认值。打开一个文件进行读取，如果文件不存在则返回错误“a” - Append - 打开一个文件进行追加，如果文件不存在则创建该文件“w” - 写入 - 打开一个文件进行写入，如果文件不存在则创建该文件“x” - Create - 创建指定的文件，如果文件存在则返回错误“t” - 文本 - 默认值。文本模式“b” - 二进制 - 二进制模式（例如图像）

打开文件进行阅读

打开的默认模式是读取，因此我们不必指定 ‘r’ 或 ‘rt’。我在文件目录中创建并保存了一个名为 reading_file_example.txt 的文件。让我们看看它是如何完成的：

f = open ( './files/reading_file_example.txt' )print ( f ) # <_io.TextIOWrapper name='./files/reading_file_example.txt' mode='r' encoding='UTF-8'>

正如你在上面的例子中看到的，我打印了打开的文件，它提供了一些关于它的信息。打开的文件有不同的读取方法：read()、readline、readlines。必须使用close()方法关闭打开的文件。

read()：将整个文本作为字符串读取。如果我们想限制我们想要读取的字符数，我们可以通过将 int

值传递给read(number)方法来限制它。

f = 打开( './files/reading_file_example.txt' )txt = f。读取()打印(类型( txt ))打印( txt )f。关闭()

#输出<类' str ' >这是一个显示如何打开文件和读取的示例。这是正文的第二行。

我们不打印所有文本，而是打印文本文件的前 10 个字符。

f = 打开( './files/reading_file_example.txt' )txt = f。读取（10）打印（类型（txt））打印（txt）f。关闭()

# output < class ' str ' >这是一个

readline() : 只读取第一行

f = 打开( './files/reading_file_example.txt' )line = f。readline ()打印（类型（行））打印（行）f。关闭()

# output < class ' str ' >这是一个显示如何打开文件和读取的示例。

readlines()：逐行读取所有文本并返回行列表

f = 打开( './files/reading_file_example.txt' )行 = f。readlines ()打印（类型（行））打印（行）f。关闭()

# output < class ' list ' > [ '这是一个显示如何打开文件和读取的示例。\n ' , '这是文本的第二行。' ]

另一种将所有行作为列表获取的方法是使用splitlines()：

f = 打开( './files/reading_file_example.txt' )行 = f。读（）。splitlines ()打印（类型（行））打印（行）f。关闭()

# output < class ' list ' > [ '这是一个显示如何打开文件和读取的示例。' , '这是正文的第二行。' ]

打开文件后，我们应该关闭它。很容易忘记关闭它们。有一种使用with打开文件的新方法- 自行关闭文件。让我们用with方法重写前面的例子：

使用 open ( './files/reading_file_example.txt' )作为 f：lines = f。读（）。splitlines ()打印（类型（行））打印（行）

# output < class ' list ' > [ '这是一个显示如何打开文件和读取的示例。' , '这是正文的第二行。' ]

打开文件进行写入和更新

要写入现有文件，我们必须向open()函数添加一个模式作为参数：

“a” - 追加 - 将追加到文件的末尾，如果文件没有，它会创建一个新文件。“w” - 写入 - 将覆盖任何现有内容，如果它创建的文件不存在。

让我们将一些文本附加到我们一直在阅读的文件中：

使用 open ( './files/reading_file_example.txt' , 'a' )作为 f :f。write ( '此文本必须附加在最后' )

如果文件不存在，下面的方法会创建一个新文件：

使用 open ( './files/writing_file_example.txt' , 'w' )作为 f :f。write ( '此文本将写入新创建的文件' )

删除文件

我们在上一节中已经看到，如何使用os模块创建和删除目录。现在再次，如果我们想删除一个文件，我们使用os模块。

导入 操作系统os。删除（'./files/example.txt'）

如果文件不存在，remove 方法将引发错误，因此最好使用这样的条件：

导入 os如果 os。路径。存在( './files/example.txt' ):os。remove ( './files/example.txt' )else :print ( '文件不存在' )

文件类型

带有 txt 扩展名的文件

带有txt扩展名的文件是一种非常常见的数据形式，我们在上一节中已经介绍过。让我们转到 JSON 文件

带有 json 扩展名的文件

JSON 代表 JavaScript 对象表示法。实际上，它是一个字符串化的 JavaScript 对象或 Python 字典。

例子：

# 字典person_dct = {"name" : "Asabeneh" ,"country" : "Finland" ,"city" : "Helsinki" ,"skills" :[ "JavaScrip" , "React" , "Python" ]}# JSON: 一个字符串形式的字典person_json = "{'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'skills': ['JavaScrip', 'React', ' Python']}”# 我们使用三个引号并使其多行以使其更具可读性person_json = '''{ "name":"Asabeneh", "country":"Finland", "city":"Helsinki", "skills":[ "JavaScrip", "React","Python"] }'''

将 JSON 更改为字典

要将 JSON 更改为字典，首先我们导入 json 模块，然后使用load方法。

import json # JSON person_json = '''{ "name": "Asabeneh", "country": "Finland", "city": "Helsinki", "skills": ["JavaScrip", "React", "Python" ] }''' # 让我们将 JSON 更改为字典person_dct = json . 加载（person_json）打印（类型（person_dct））打印（person_dct）打印（person_dct [ 'name' ]）

# output < class ' dict ' > {' name ' : ' Asabeneh ' , ' country ' : ' Finland ' , ' city ' : ' Helsinki ' , ' skills ' :[ ' JavaScrip ' , ' React ' , ' Python ' ] }阿萨贝内

将字典更改为 JSON

要将字典更改为 JSON，我们使用json 模块中的dumps方法。

import json # python 字典person = {"name" : "Asabeneh" ,"country" : "Finland" ,"city" : "Helsinki" ,"skills" : [ "JavaScrip" , "React" , "Python" ]}# 让我们把它转换成 json person_json = json . dumps ( person , indent = 4 ) # indent 可以是 2, 4, 8. 美化json print ( type ( person_json ))print ( person_json )

# output #打印时没有引号，但实际上是字符串# JSON 没有类型，它是字符串类型。<类' str ' >{“名称”： “ Asabeneh ”，“国家”： “芬兰”，“城市”： “赫尔辛基”，“技能”：[“ JavaScrip ”，“ React ”，“ Python ”]}

保存为 JSON 文件

我们也可以将数据保存为 json 文件。让我们使用以下步骤将其保存为 json 文件。写一个json文件，我们使用json.dump()方法，它可以带字典、输出文件、ensure_ascii和缩进。

import json # python 字典person = {"name" : "Asabeneh" ,"country" : "Finland" ,"city" : "Helsinki" ,"skills" : [ "JavaScrip" , "React" , "Python" ]}使用 open ( './files/json_example.json' , 'w' , encoding = 'utf-8' )作为 f :json。转储（人，f，ensure_ascii = False，缩进= 4）

在上面的代码中，我们使用了编码和缩进。缩进使 json 文件易于阅读。

带有 csv 扩展名的文件

CSV 代表逗号分隔值。CSV 是一种简单的文件格式，用于存储表格数据，例如电子表格或数据库。CSV 是数据科学中非常常见的数据格式。

例子：

"name","country","city","skills""Asabeneh","Finland","Helsinki","JavaScript"

例子：

使用open ( './files/csv_example.csv' )导入csv作为f :csv_reader = csv。读取器（˚F，分隔符= '' ）＃瓦特使用，读者方法来读取CSV LINE_COUNT = 0为行中csv_reader：如果LINE_COUNT == 0：打印（f'Column名称是：{“” 。加入（行）} ' )line_count += 1 else :print (f' \t {row [ 0 ] }是一位老师。他住在{row [ 1 ] } , {row [ 2 ] } .' )line_count += 1 print ( f '行数： { line_count } ' )

#输出：列名是：姓名、国家、城市、技能Asabeneh 是一名教师。他住在芬兰赫尔辛基。行数：2

带有 xlsx 扩展名的文件

要读取 excel 文件，我们需要安装xlrd包。在我们介绍了使用 pip 安装软件包之后，我们将介绍这一点。

导入 xlrd excel_book = xlrd。open_workbook（”样品。XLS）打印（excel_book。nsheets）打印（excel_book。sheet_names）

带有 xml 扩展名的文件

XML 是另一种看起来像 HTML 的结构化数据格式。在 XML 中，标签不是预定义的。第一行是一个 XML 声明。person 标签是 XML 的根。该人具有性别属性。 示例：XML

<? xml版本= " 1.0 " ?><人 性别= “女性” >< name >Asabeneh</ name ><国家>芬兰</国家>< city >赫尔辛基</ city ><技能><技能>JavaScrip</技能><技能>反应</技能><技能>Python</技能></技能></人>

有关如何读取 XML 文件

导入 xml。etree。ElementTree 作为 ET树 = ET。解析( './files/xml_example.xml' )root = tree。getroot（）打印（'根标签：'，根。标签）的打印（'属性：'，根。ATTRIB）为 孩子 在 根：打印（'字段：'，孩子。标签)

#输出根标签：人属性：{'性别'：'男性' }字段：名称领域：国家领域：城市领域：技能

第 20 天 - Python 包管理器(PIP)

什么是PIP？

PIP 代表首选安装程序。我们使用pip来安装不同的 Python 包。包是一个 Python 模块，可以包含一个或多个模块或其他包。我们可以安装到应用程序的一个或多个模块是一个包。在编程中，我们不必编写每个实用程序，而是安装包并将它们导入到我们的应用程序中。

安装PIP

如果您没有安装 pip，让我们现在安装它。转到您的终端或命令提示符并复制并粘贴以下内容：

asabeneh@Asabeneh: ~ $ pip install pip

通过写入检查是否安装了 pip

pip --version

asabeneh @ Asabeneh：〜 $ PIP - -版本点子 21.1。3 来自 / usr / local / lib / python3。7 /站点-包/ pip（python 3.9 .6）

如您所见，我使用的是 pip 版本 21.1.3，如果您看到某个数字低于或高于该数字，则表示您已安装 pip。

让我们检查一下 Python 社区中出于不同目的使用的一些包。只是为了让您知道有许多软件包可用于不同的应用程序。

使用 pip 安装包

让我们尝试安装numpy，称为 numeric python。它是机器学习和数据科学社区中最受欢迎的软件包之一。

NumPy 是使用 Python 进行科学计算的基础包。其中包括：

一个强大的 N 维数组对象复杂的（广播）功能用于集成 C/C++ 和 Fortran 代码的工具有用的线性代数、傅立叶变换和随机数功能

asabeneh@Asabeneh: ~ $ pip install numpy

让我们开始使用 numpy。打开你的python交互式shell，编写python然后导入numpy，如下所示：

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 导入 numpy >> > numpy。版本。版本' 1.20。1 '>> > lst = [ 1 , 2 , 3 ,4 , 5 ]>> > np_arr = numpy。数组( lst )>> > np_arr数组([ 1 , 2 , 3 , 4 , 5 ])>> > len ( np_arr )5 >> > np_arr * 2数组([ 2 , 4 , 6 , 8 , 10 ])>> > np_arr + 2数组([ 3 , 4 , 5 , 6 , 7 ])>> >

Pandas 是一个开源的、BSD 许可的库，为 Python 编程语言提供高性能、易于使用的数据结构和数据分析工具。让我们安装numpy的大哥pandas：

asabeneh@Asabeneh: ~ $ pip install pandas

asabeneh @ Asabeneh：~ $ python Python 3.9。6（默认， 年6月 28 日 ，15：26：21）[锵 11.0 0.0（铛- 1100.0。33.8）在 达尔文式 的“帮助”，“版权”，“信用” 或 “许可” 的 更多 信息。>> > 导入 熊猫

本节不是关于 numpy 或 pandas，在这里我们试图学习如何安装包以及如何导入它们。如果需要，我们将在其他部分讨论不同的包。

让我们导入一个网页浏览器模块，它可以帮助我们打开任何网站。我们不需要安装这个模块，它已经在 Python 3 中默认安装了。例如，如果你想随时打开任意数量的网站，或者你想安排一些事情，可以使用这个webbrowser模块。

import webbrowser # 网页浏览器模块打开网站# url 列表：python url_lists = ['' ,'/in/asabeneh/' ,'/Asabeneh' ,'/Asabeneh' ,]＃打开在不同的选项卡网站上面的列表中的 网址 在 url_lists：网页浏览器。open_new_tab ( url )

卸载软件包

如果您不想保留已安装的软件包，可以使用以下命令删除它们。

pip 卸载包名

包裹清单

查看我们机器上已安装的软件包。我们可以使用 pip 后跟列表。

点子列表

显示包

显示有关包的信息

pip 显示包名

asabeneh@Asabeneh: ~ $ pip show pandas名称：熊猫版本：1.2.3总结：强大的数据结构，用于数据分析、时间序列和统计主页：作者：无作者邮箱：无许可证：BSD位置：/usr/local/lib/python3.7/site-packages需要：python-dateutil、pytz、numpy必填项：

如果我们想要更多细节，只需添加 --verbose

asabeneh@Asabeneh: ~ $ pip show --verbose pandas名称：熊猫版本：1.2.3总结：强大的数据结构，用于数据分析、时间序列和统计主页：作者：无作者邮箱：无许可证：BSD位置：/usr/local/lib/python3.7/site-packages需要：numpy、pytz、python-dateutil必填项：元数据版本：2.1安装程序：pip分类器：开发状态 :: 5 - 量产/稳定环境 :: 控制台操作系统 :: 独立于操作系统目标受众 :: 科学/研究编程语言 :: Python编程语言 :: Python :: 3编程语言 :: Python :: 3.5编程语言 :: Python :: 3.6编程语言 :: Python :: 3.7编程语言 :: Python :: 3.8编程语言 :: Cython主题 :: 科学/工程入口点：[pandas_plotting_backends]matplotlib = pandas:plotting._matplotlib

画中画冻结

生成已安装的 Python 包及其版本，输出适合在需求文件中使用。requirements.txt 文件是一个文件，它应该包含 Python 项目中所有已安装的 Python 包。

asabeneh@Asabeneh: ~ $ pip freeze文档工具==0.11Jinja2==2.7.2标记安全==0.19Pygments==1.6狮身人面像==1.2.2

pip freeze 为我们提供了使用、安装的软件包及其版本。我们将它与 requirements.txt 文件一起用于部署。

从 URL 读取

到目前为止，您已经熟悉如何读取或写入位于本地机器上的文件。有时，我们想使用 url 或 API 从网站读取。API 代表应用程序接口。它是一种主要作为 json 数据在服务器之间交换结构化数据的方法。要打开网络连接，我们需要一个名为requests的包- 它允许打开网络连接并实现 CRUD（创建、读取、更新和删除）操作。在本节中，我们将只介绍读取矿石获取 CRUD 的一部分。

让我们安装请求：

asabeneh @ Asabeneh : ~ $ pip install requests

我们将在requests模块中看到get、status_code、headers、text和json方法：

get()：打开网络并从 url 获取数据 - 它返回一个响应对象status_code : 获取数据后，我们可以检查操作的状态（成功、错误等）headers : 检查标题类型text : 从获取的响应对象中提取文本json :提取json数据让我们从这个网站读取一个txt文件，/TR/PNG/iso_8859-1.txt。

import requests # 导入请求模块url = '/TR/PNG/iso_8859-1.txt' # 来自网站的文本响应 = 请求。get ( url ) # 打开网络并获取数据print ( response )print ( response . status_code ) # status code, success:200 print ( response . headers )# headers 信息print ( response . text ) # 给出来自的所有文本这一页

<响应 [200] >200{“日期”：“格林威治标准时间 年 12 月 8 日 18:00:31 ”，“最后修改时间”：“格林威治标准时间 年 11 月 7 日星期五 05:51:11 ”，“ etag ”：“ 17e9-3cb15080808087 -gzip" ' , '接受范围' : '字节' , '缓存控制' : ' max-age=31536000 ' , '过期' : ' 年 12 月 7 日星期一 18:00:31 GMT包括子域；预载'， '内容安全策略'： '升级不安全请求' }

让我们从 API 中读取。API 代表应用程序接口。它是一种在服务器之间交换结构数据的手段，主要是 json 数据。API

示例：https : //restcountries.eu/rest/v2/all。让我们使用requests模块阅读这个 API 。

导入 请求url = 'https://restcountries.eu/rest/v2/all' # 国家 API响应 = 请求。get ( url ) # 打开网络并获取数据print ( response ) # response 对象print ( response . status_code ) # status code, success:200 countries = response . json ()打印(国家[: 1 ]) # 我们只对第一个国家进行切片，去掉切片可以看到所有国家

<响应 [200] >200[{' alpha2Code '：' AF '，' alpha3Code '：' AFG '，' altSpellings '：[ ' AF '，'阿富汗' ]，'区域'：652230.0，'边界'：[ ' IRN '，' PAK ' , ' TKM ' , ' UZB ', 'TJK '，' CHN ' ]，' callingCodes '：[ ' 93 ' ]，'资本'：'喀布尔'，' cioc '：' AFG '，'货币'：[{'代码'：' AFN '，'姓名' : '阿富汗阿富汗尼' , '符号'：' ؋ ' }]，'区域居民称谓词'：'阿富汗'，'标志'：' https://restcountries.eu/data/afg.svg '，'基尼'：27.8，'语言'：[{' iso639_1 '：“ ps ”，“ iso639_2 ”：“脓液”，“名称”：'普什图语' ' nativeName '：' پښتو “ }，{' iso639_1 '：' uz '，' iso639_2 '：' uzb '，' name '：' Uzbek '，' nativeName '：' Oʻzbek ' }，{' iso639_1 '：' TK '，' iso639_2 '：'三轮'，'名称'：'土库曼'，' nativeName '：'土库曼' }]，'经纬度'：[33.0，65.0]，'名称'：'阿富汗' ,'本地名称'：' افغانستان '，' numericCode '： ' 004 '，'人口'：27657145，'地区'： '亚洲'，' regionalBlocs '：[{'首字母缩略词'： ' SAARC名称'南亚区域协会'，'南亚区域协会'：合作' ,'otherAcronyms “：[]，' otherNames '：[]}]，' subregion '：'南亚'，'时区'：[ ' UTC+04:30 ' ]，' topLevelDomain '：[ '. af ' ]，' translations '：{' br '：' Afeganistão '，' de '：'阿富汗'，' ES '：'阿富汗'，' FA '：' افغانستان '，' FR '：'阿富汗'，'小时'：'阿富汗'，'它'：'阿富汗'，' JA '：'アフガニスタン'，' nl '：'阿富汗'，' pt '：' Afeganistão ' }}]

我们使用响应对象中的json()方法，如果我们正在获取 JSON 数据。对于 txt、html、xml 等文件格式，我们可以使用text。

创建包

我们根据一些标准将大量文件组织在不同文件夹和子文件夹中，以便我们可以轻松查找和管理它们。如您所知，一个模块可以包含多个对象，例如类、函数等。一个包可以包含一个或多个相关模块。一个包实际上是一个包含一个或多个模块文件的文件夹。让我们使用以下步骤创建一个名为 mypackage 的包：

在 30DaysOfPython 文件夹中创建一个名为 mypacakge 的新文件夹在 mypackage 文件夹中创建一个空的init .py 文件。使用以下代码创建模块 algorithm.py 和 greet.py：

# mypackage/arithmetics.py #arithmetics.py def add_numbers ( * args ):total = 0 for num in args :total += num return totaldef 减法( a , b ):返回( a - b )def multiple ( a , b ):返回 a * bdef 除法( a , b ):返回 a / bdef 余数( a , b ):返回 a % bdef power ( a , b ):返回 a ** b

# mypackage/greet.py # greet.py def greet_person ( firstname , lastname ):return f' {firstname } {lastname }，欢迎来到 30DaysOfPython Challenge！

包的文件夹结构应如下所示：

─ 我的包裹├── __init__.py├──算术.py└── 问候.py

现在让我们打开 python 交互式 shell 并尝试我们创建的包：

asabeneh@Asabeneh: ~ /Desktop/30DaysOfPython$ pythonPython 3.9.6（默认， 年 6 月 28 日，15:26:21）[Clang 11.0.0 (clang-1100.0.33.8)] 在达尔文输入“ help ”、“ copyright ”、“ credits ”或“ license ” 以获取更多信息。>>> from mypackage 导入算法>>>算术.add_numbers(1, 2, 3, 5)11>>>算术.减法(5, 3)2>>>算术.multiple(5, 3)15>>>算术.除法(5, 3)1.6666666666666667>>>算术.remainder(5, 3)2>>> 算术.power(5, 3)125>>> from mypackage 导入问候>>> greet.greet_person( ' Asabeneh ' , ' Yetayeh ' )' Asabeneh Yetayeh，欢迎参加 30DaysOfPython 挑战赛！' >>>

如您所见，我们的软件包运行良好。包文件夹包含一个名为init .py的特殊文件- 它存储包的内容。如果我们将init .py 放在包文件夹中，python start 会将其识别为包。在初始化指定从模块的资源导入到其他Python文件的.py自曝。导入包时，空的init .py 文件使所有函数都可用。该INIT的.py是必不可少的文件夹以通过Python作为一个包被识别。

关于包的更多信息

数据库

SQLAlchemy 或 SQLObject - 面向对象访问多个不同的数据库系统

pip 安装 SQLAlchemy

Web开发

Django - 高级 Web 框架。

pip 安装 django

Flask - 基于 Werkzeug、Jinja 2 的 Python 微框架。（它是 BSD 许可的）

pip 安装烧瓶

HTML解析器

Beautiful Soup - 专为快速周转项目（如屏幕抓取）而设计的 HTML/XML 解析器，将接受不良标记。

pip 安装 beautifulsoup4

PyQuery - 在 Python 中实现 jQuery；显然比 BeautifulSoup 快。

XML处理

ElementTree - Element 类型是一个简单但灵活的容器对象，旨在在内存中存储分层数据结构，例如简化的 XML 信息集。–注意：Python 2.5 及更高版本在标准库中有 ElementTree

图形用户界面

PyQt - 跨平台 Qt 框架的绑定。

TkInter - 传统的 Python 用户界面工具包。

数据分析、数据科学和机器学习

Numpy：Numpy(numeric python) 被称为 Python 中最受欢迎的机器学习库之一。

Pandas：是 Python 中的数据分析、数据科学和机器学习库，提供高级数据结构和多种分析工具。

SciPy：SciPy 是一个面向应用程序开发人员和工程师的机器学习库。SciPy 库包含用于优化、线性代数、集成、图像处理和统计的模块。

Scikit-Learn：它是 NumPy 和 SciPy。它被认为是处理复杂数据的最佳库之一。

TensorFlow：是谷歌构建的机器学习库。

Keras：被认为是 Python 中最酷的机器学习库之一。它提供了一种更简单的机制来表达神经网络。Keras 还提供了一些用于编译模型、处理数据集、图形可视化等的最佳实用程序。

网络：

requests：是一个我们可以用来向服务器发送请求的包（GET、POST、DELETE、PUT）

pip 安装请求

🎉 恭喜！ 🎉你是一个非凡的人，你有非凡的潜力。

作为一个续集更新，感兴趣了解下面的学习内容，记得关注我，你们的三连是我持续输出的动力，感谢。