Python学习笔记05

第七章、Python函数进阶

函数多返回值

思考

**问：**如果一个函数如些两个return(如下所示)，程序如何执行？

defreturn_num():

return 1

return 2

result = return_num()

print(result) # 1

**答：**只执行了第一个return，原因是因为return可以退出当前函数导致return下方的代码不执行

多个返回值

如果一个函数要有多个返回值，该如何书写代码？

def test_return():

return 1，2

x，y = test_return()

print(x) # 结果1

print(y) # 结果2

按照返回值的顺序，写对应顺序的多个变量接收即可

变量之间用逗号隔开

支持不同类型的数据return

def test_return():

return 1, "hello", True

x, y, z = test_return()

print(x)

print(y)

print(z)

函数多种传参方式

函数参数种类

使用方式上的不同，函数有4中常见参数使用方式：

• 位置参数
• 关键字参数
• 缺省参数
• 不定长参数

位置参数

位置参数：调用函数时根据函数定义的参数位置来传递参数

def user_info(name, age, gender):

print(f"您的姓名是：{name}, 年龄是：{age}, 性别是：{gender}")

user_info('小明', '20', '男')

注意：

传递的参数和定义的参数的顺序及个数必须一致

关键字参数

关键字参数：函数调用时通过"键=值"形式传递参数.

作用：可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求.

def user_info(name, age, gender):

print(f"您的姓名是：{name}, 年龄是：{age}, 性别是：{gender}")

关键字传参

user_info(name="小明", age=20, gender="男")

可以不按照固定顺序

user_info(age=10, gender='女', name='潇潇')

可以和位置参数混用，位置参数必须在前，且匹配参数顺序

user_info('甜甜', gender='女', age=9)

注意：

函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序\

缺省参数

缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值(注意：所有位置参数必须出现在默认参数前，包括函数定义和调用).

作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值.

def user_info(name, age, gender='男'):

print(f"您的姓名是：{name}, 年龄是：{age}, 性别是：{gender}")

user_info('小天', 13)

user_info('小美', 13, gender='女')

注意：

函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值

不定长参数

不定长参数：不定长参数也叫可变参数.用于不确定调用的时候会传递多少个参数(不传参也可以)的场景.作用：当调用函数时不确定参数个数时，可以使用不定长参数

不定长参数的类型：

1. 位置传递
2. 关键字传递

位置传递

def user_info(*args):

print(args)

('TOM',)

user_info('TOM')

('TOM'，18)

user_info('TOM', 18)

注意：

传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递

关键字传递

def user_info(**kwargs):

print(kwargs)

{'name': 'TOM', 'age': 18, 'id': 110}

user_info(name='TOM', age=18,id=110)

注意：

参数是"键=值"形式的形式的情况下，所有的"键=值"都会被kwargs接受，同时会根据"键=值"组成字典.

总结

1.掌握位置参数

• 根据参数位置来传递参数

2.掌握关键字参数

• 通过"键=值"形式传递参数，可以不限参数顺序
• 可以和位置参数混用，位置参数需在前

3.掌握缺省参数

• 不传递参数值时会使用默认的参数值
• 默认值的参数必须定义在最后

4.掌握不定长参数

• 位置不定长传递以*号标记一个形式参数，以元组的形式接受参数，形式参数一般命名为args
• 关键字不定长传递以**号标记一个形式参数，以字典的形式接受参数，形式参数一般命名为kwargs

匿名函数

函数作为参数传递

函数作为参数传递

在前面的函数学习中，我们一直使用的函数，都是接受数据作为参数传入：

• 数字
• 字符串
• 字典、列表、元组等

其实，我们学习的数本身，也可以作为参数传入另一个函数内。

如下代码：

def test_func(compute):

result = compute(1, 2)

print(f"计算结果：{result}")

def compute(x, y):

return x + y

test_func(compute) # 结果：3

函数compute，作为参数，传入了test_func函数中使用。

• test_func需要一个函数作为参数传入，这个函数需要接收2个数字进行计算，计算逻辑由这个被传入函数决定
• compute函数接收2个数字对其进行计算，compute函数作为参数，传递给了test_func函数使用
• 最终，在test_func函数内部，由传入的compute函数，完成了对数字的计算操作

所以，这是一种，计算逻辑的传递，而非数据的传递。

就像上述代码那样，不仅仅是相加，相见、相除、等任何逻辑都可以自行定义并作为函数传入。

总结

1.函数本身是可以作为参数，传入另一个函数中进行使总结 用的。

2.将函数传入的作用在于：传入计算逻辑，而非传入数据。

Lambda匿名函数

lambda匿名函数

函数的定义中

• def关键字，可以定义带有名称的函数
• lambda关键字，可以定义匿名函数(无名称)

有名称的函数，可以基于名称重复使用。

无名称的匿名函数，只可临时使用一次。

匿名函数定义语法：

lambda传入参数：函数体(一行代码)

• lambda是关键字，表示定义匿名函数
• 传入参数表示匿名函数的形式参数，如：x，y表示接收2个形式参数
• 函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码

如下图代码，我们可以：

通过def关键字，定义一个函数，并传入，如下图：

def test_func(compute):

result = compute(1, 2)

print(f"计算结果：{result}")

def compute(x, y):

return x + y

test_func(compute) # 结果：3

也可以通过lambda关键字，传入一个一次性使用的lambda匿名函数

def test_func(compute):

result = compute(1, 2)

print(f"结果是：{result}")

test_func(lambda x, y: x + y) # 结果：3

使用def和使用lambda，定义的函数功能完全一致，只是lambda关键字定义的函数是匿名的，无法二次使用

总结

1.匿名函数使用lambda关键字进行定义

2.定义语法：

lambda 传入参数：函数体(一行代码）

3.注意事项：

1. 匿名函数用于临时构建一个函数，只用一次的场景
2. 匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数

第八章、Python文件操作

文件的编码

文件编码

思考：计算机只能识别：0和1，那么我们丰富的文本文件是如何被计算机识别，并存储在硬盘中呢？

答案：使用编码技术(密码本)将内容翻译成0和1存入。

编码技术即：翻译的规则，记录了如何将内容翻译成二进制，以及如何将二进制翻译回可识别内容。

我 → 编码 → 1011

喜 → 编码 →1101

欢 → 编码 → 1111

你 → 编码 → 1001

计算机中有许多可用编码：

• UTF-8
• GBK
• Big5
• 等

不同的编码，将内容翻译成二进制也是不同的。

编码有许多，所以要使用正确的编码，才能对文件进行正确的读写操作呢。

我 → 编码A → 1011 我 → 编码B → 1011

喜 → 编码A →1011 讨 → 编码B → 1101

欢 → 编码A → 1111 厌 → 编码B → 1111

你 → 编码A → 1001 你 → 编码B → 1001

如上，如果你给喜欢的女孩发送文件，使用编码A进行编码(内容转二进制)，女孩使用编码B打开文件进行解码(二进制反转回内容)，那就自求多福吧。

查看文件编码

我们可以使用Windows系统自带的记事本，打开文件后，即可看出文件的编码是什么

UTF-8是目前全球通用的编码格式

除非有特殊需求，否则，一律以UTF-8格式进行文件编码即可。

总结

1.什么是编码？

编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。

编码有许多中，我们最常用的是UTF-8编码

2.为什么需要使用编码？

计算机只认识0和1，所以需要将内容翻译成0和1才能保存在计算机中。

同时也需要编码，将计算机保存的0和1，反向翻译回可以识别的内容。

文件的读取

什么是文件

内存中存放的数据在计算机关机后就会消失。要长久保存数据，就要使用硬盘、光盘、U盘等设备。为了便于数据的管理和检索，引入了"文件"的概念。

一篇文章、一段视频、一个可执行程序，都可以被保存为一个文件，并赋予一个文件名。操作系统以文件为单位管理磁盘中的数据。一般来说，文件可分为文本文件、视频文件、音频文件、图像文件、可执行文件等多种类别。

文件操作包含哪些内容呢？

在日常生活中，文件操作主要包括打开、关闭、读、写等操作。

文件的操作步骤

想想我们平常对文件的基本操作，大概可以分为三个步骤(简称文件操作三步走)：

1. 打开文件
2. 读写文件
3. 关闭文件

注意事项

注意：可以只打开和关闭文件，不进行任何读写

open()打开函数

在Python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下

open(name, mode, encoding)

name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。

mode：设置打开文件的模式(访问模式)：只读、写入、追加等。

encoding:编码格式(推荐使用UTF-8)

示例代码：

f = open('python.txt','r',encoding="UTF-8")

encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定

注意事项

注意：此时的f是open函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象，属性或对象.方法对其进行访问，后续面向对象课程会给大家进行详细的介绍。

mode常用的三种基础访问模式

模式 描述

r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件。

a 打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

读操作相关方法

read()方法：

文件对象.read(num)

num表示要从文件中读取的数据的长度(单位是字节)，如果没有传入num，那么就表示读取文件中所有的数据。

readlines()方法：

readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。

f = open('python.txt')

content = f.readlines()

['hello world\n','abcdefg\n', 'aaa\n', 'bbb\n','ccc']

print(content)

关闭文件

f.close()

readline()方法：一次读取一行内容

f = open('python.txt')

content = f.readline()

print(f'第一行：(content]")

content = f.readline()

print(f'第二行：(content')

关闭文件

f.close()

for循环读取文件行

for line in open("python.txt", "r"):

print(line)

每一个line临时变量，就记录了文件的一行数据

close()关闭文件对象

f = open("python.txt", "r")

f.close()

最后通过close，关闭文件对象，也就是关闭对文件的占用

如果不调用close，同时程序没有停止运行，那么这个文件将一直被Python程序占用。

with open语法

with open("python.txt", "r") as f:

f.readlines()

通过在with open的语句块中对文件进行操作

可以在操作完成后自动关闭close文件，避免遗忘掉close方法

操作汇总

操作 功能

文件对象=open(file, mode, encoding) 打开文件获得文件对象

文件对象.read(num） 读取指定长度字节不指定num读取文件全部

文件对象.readline() 读取一行

文件对象.readlines() 读取全部行，得到列表

for line in 文件对象 for循环文件行，一次循环得到一行数据

文件对象.close() 关闭文件对象

with open() as f 通过with open语法打开文件，可以自动关闭

总结

1.操作文件需要通过open函数打开文件得到文件对象

2.文件对象有如下读取方法：

• read()
• readline()
• readlines()
• for line in 文件对象

3.文件读取完成后，要使用文件对象.close()方法关闭文件对象，否则文件会被一直占用

练习

课后练习：单词计数

通过Windows的文本编辑器软件，将如下内容，复制并保存到：word.txt，文件可以存储在任意位置

itheima itcast python

itheima python itcast

beijing shanghai itheima

shenzhen guangzhou itheima

wuhan hangzhou itheima

zhengzhou bigdata itheima

通过文件读取操作，读取此文件，统计itheima单词出现的次数

参考代码：

f = open('D:/word.txt', 'r', encoding= "UTF-8")

方式1：读取全部内容,通过字符串count方法统计itheima单词数量

content = f.read()

count = content.count("itheima")

print(f"itheima在文件中出现了{count}次")

方式2：读取内容,一行一行的读取

count = 0 #使用count变量来累加itheima出现的次数

for line in f:

line = line.strip() # 去除开头和结尾的空格以及换行符

words = line.split(" ")

for word in words:

if word == "itheima":

count += 1 # 如果单词是itheima,进行数量的累加加1

print(f"itheima出现的次数是：{count}")

f.close()

文件的写入

写操作快速入门

案例演示：

1.打开文件

f = open('python.txt','w')

2.文件写入

f.write('hello world')

3.内容刷新

f.flush()

注意：

• 直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
• 当调用flush的时候，内容会真正写入文件
• 这样做是避免频繁的操作硬盘，导致效率下降(攒一堆，一次性写磁盘)

总结

1.写入文件使用open函数的"w"模式进行写入

2.写入的方法有：

• wirte()，写入内容
• flush()，刷新内容到硬盘中

3.注意事项：

• w模式，文件不存在，会创建新文件
• w模式，文件存在，会清空原有内容
• close()方法，带有flush()方法的功能

文件的追加

追加写入操作快速入门

案例演示：

1.打开文件，通过a模式打开即可

f = open('python.txt', 'a')

2.文件写入

f.write('hello world')

3.内容刷新

f.flush()

注意：

• a模式，文件不存在会创建文件
• a模式，文件存在会在最后，追加写入文件

总结

1.追加写入文件使用open函数的"a"模式进行写入

2.追加写入的方法有(和w模式一致)：

• wirte()，写入内容
• flush()，刷新内容到硬盘中

3.注意事项：

• a模式，文件不存在，会创建新文件
• a模式，文件存在，会在原有内容后面继续写入
• 可以使用"\n"来写出换行符

文件操作综合案例

需求分析

需求：有一份账单文件，记录了消费收入的具体记录，内容如下：

name, date, money, type,remarks

周杰轮,2022-01-01,100000,消费,正式

周杰轮,2022-01-02,300000,收入,正式

周杰轮,2022-01-03,100000,消费,测试

林俊节,2022-01-01,300000,收入,正式

林俊节,2022-01-02,100000,消费,测试

林俊节,2022-01-03,100000,消费,正式

林俊节,2022-01-04,100000,消费,测试

林俊节,2022-01-05,500000,收入,正式

张学油,2022-01-01,100000,消费,正式

张学油,2022-01-02,500000,收入,正式

张学油,2022-01-03,900000,收入,测试

王力鸿,2022-01-01,500000,消费,正式

王力鸿,2022-01-02,300000,消费,测试

王力鸿,2022-01-03,950000,收入,正式

刘德滑,2022-01-01,300000,消费,测试

刘德滑,2022-01-02,100000,消费,正式

刘德滑,2022-01-03,300000,消费,正式

同学们可以将内容复制并保存为bill.txt文件

我们现在要做的就是：

• 读取文件
• 将文件写出到bill.txt.bak文件作为备份
• 同时，将文件内标记为测试的数据行丢弃

实现思路：

• open和r模式打开一个文件对象，并读取文件
• open和w模式打开另一个文件对象，用于文件写出
• for循环内容，判断是否是测试不是测试就write写出，是测试就continue跳过
• 将2个文件对象均close()

参考代码：

a = open("D:/bill.txt", 'r', encoding="UTF-8")

b = open("D:/bill.txt.bak", 'w', encoding="UTF-8")

for line in a: line =

line.strip()

if line.split(",")[-1] == "测试":

continue

b.write(line)

b.write("\n")

a.close()

b.close()

第九章、Python异常、模块与包

了解异常

什么是异常

当检测到一个错误时，Python解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"，也就是 我们常说的BUG

bug单词的诞生

早期计算机采用大量继电器工作，马克二型计算机就是这样的。

1945年9月9日，下午三点，马克二型计算机无法正常工作了，技术人员试了很多办法，最后定位到第70号继电器出错。负责人哈珀观察这个出错的继电器，发现一只飞蛾躺在中间，已经被继电器打死。她小心地用摄子将蛾子夹出来，用透明胶布帖到"事件记录本"中，并注明"第一个发现虫子的实例"。自此之后，引发软件失效的缺陷，便被称为Bug。

异常演示

例如：以r方式打开一个不存在的文件。

f = open("D:/abc.txt", "r", encoding="UTF-8")

执行结果：

Traceback (most recent call last):

File "D:\python-learn\pythonProject\test.py", line 1, in

f = open("D:/abc.txt", "r", encoding="UTF-8")

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

FileNotFoundError: [Errno 2] No such file or directory: 'D:/abc.txt'

总结

1.什么是异常：

异常就是程序运行的过程中出现了错误

2.bug是什么意思：

bug就是指异常的意思，因为历史因为小虫子导致计算机失灵的案例，所以延续至今，bug就代表软件出现错误。

异常的捕获方法

为什么要捕获异常

世界上没有完美的程序，任何程序在运行的过程中，都有可能出现：异常，也就是出现bug，导致程序无法完美运行下去。

我们要做的，不是力求程序完美运行。而是在力所能及的范围内，对可能出现的bug，进行提前准备、提前处理。

这种行为我们称之为：异常处理(捕获异常)

当我们的程序遇到了BUG，那么接下来有两种情况：

1. 整个程序因为一个BUG停止运行
2. 对BUG进行提醒，整个程序继续运行

显然在之前的学习中，我们所有的程序遇到BUG就会出现①的这种情况，也就是整个程序直接奔溃.

但是在真实工作中，我们肯定不能因为一个小的BUG就让整个程序全部奔溃，也就是我们希望的是达到2的这种情况那这里我们就需要使用到捕获异常

捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。

捕获常规异常

基本语法：

try:

可能发生错误的代码

except:

如果出现异常执行的代码

快速入门

需求：尝试以"r 模式打开文件，如果文件不存在，则以w方式打开。

try:

f = open("D:/abc.txt", "r", encoding="UTF-8")

except:

print("出现异常了，因为文件不存在，我将open的模式改为w模式去打开")

f = open("D:/abc.txt", "w", encoding="UTF-8")

捕获指定异常

基本语法：

try:

print(name)

except NameError as e:

print("出现了变量未定义的异常")

print(e)

注意事项

1. 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码。

捕获多个异常

当捕获多个异常时，可以把要捕获的异常类型的名字，放到except 后，并使用元组的方式进行书写。

try:

1 / 0

print(name)

except(NameError, ZeroDivisionError) as e:

print("出现了变量未定义 或者 除以0的异常")

执行结果：

出现了变量未定义 或者 除以0的异常

异常else

else表示的是如果没有异常要执行的代码。

try:

print("Hello")

except Exception as e:

print("出现异常了")

else:

print("好高兴，没有出现异常。")

执行结果：

好高兴，没有出现异常。

异常的finally

finally表示的是无论是否异常都要执行的代码，例如关闭文件。

try:

f = open("D:/123.txt", "r", encoding="UTF-8")

except Exception as e:

print("出现异常了")

f = open("D:/123.txt", "w", encoding="UTF-8")

else:

print("好高兴，没有出现异常。")

finally:

print("我是finally，有没有异常我都要执行")

f.close()

总结

1.为什么要捕获异常？

在可能发生异常的地方，进行捕获。当异常出现的时候，提供解决方式，而不是任由其导致程序无法运行。

2.捕获异常的语法？

try:

可能要发生异常的语句

except[异常 as 别名：]

出现异常的准备手段

[else:]

未出现异常时应做的事情

[finally:]

不管出不出现异常都会做的事情

3.如何捕获所有异常？

异常的种类多种多样，如果想要不管什么类型的异常都能捕获到，可以使用：

• except:
• except Exception:
• 两种方式捕获全部的异常

异常的传递

异常的传递

异常是具有传递性的

def func1():

print("func1 开始执行")

num = 1 / 0 #肯定有异常，除以0的异常

print("func1 结束执行")

def func2():

print("func2 开始执行")

func1()

print("func2 结束执行")

def main():

try:

func2()

except Exception as e:

print(f"出现异常了，异常的信息是：{e}")

main()

当函数func01中发生异常，并且没有捕获处理这个异常的时候，异常会传递到函数func02，当func02也没有捕获处理这个异常的时候，main函数会捕获这个异常。这就是异常的传递性.

提示：

当所有函数都没有捕获异常的时候，程序就会报错

Python模块

模块的导入

什么是模块

Python 模块(Module)，是一个Python文件，以.py 结尾. 模块能定义函数，类和变量，模块里也能包含可执行的代码.

模块的作用：python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能.

大白话：模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用(导入模块去使用)

模块的导入方式

模块在使用前需要先导入 导入的语法如下：

[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]

常用的组合形式如：

• import 模块名
• from 模块名 import 类、变量、方法等
• from 模块名 import *
• import 模块名as 别名
• from 模块名import 功能名 as 别名

import模块名

基本语法：

import 模块名

import 模块名1，模块名2

模块名.功能名()

案例：导入time模块

import time # 导入Python内置的time模块（time.py这个代码文件)

print("开始")

让程序睡眠5秒(阻塞)

time.sleep(5)

print("结束")

from 模块名 import 功能名

基本语法：

from 模块名import 功能名

功能名()

案例：导入time模块中的sleep方法

导入时间模块中的sleep方法

from time import sleep

print("开始")

让程序睡眠5秒(阻塞)

sleep(5)

print("结束")

from 模块名 import *

基本语法：

from 模块名 import*

功能名()

案例：导入time模块中所有的方法

from time import * # *表示全部的意思

print("开始")

sleep(5)

print("结束")

as定义别名

基本语法：

模块定义别名

import 模块名 as 别名

功能定义别名

from 模块名 import 功能 as 别名

案例：

import time as t

print("开始")

t.sleep(5)

print("结束")

from time import sleep as sl

print("开始")

sl(5)

print("结束")

总结

1.什么是模块？

模块就是一个Python代码文件，内含类、函数、变量等，我们可以导入进行使用。

2.如何导入模块

[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]

3.注意事项：

• from可以省略，直接import即可
• as别名可以省略
• 通过"."来确定层级关系
• 模块的导入一般写在代码文件的开头位置

自定义模块

制作自定义模块

Python中已经帮我们实现了很多的模块.不过有时候我们需要一些个性化的模块，这里就可以通过自定义模块实现，也就是自己制作一个模块

**案例：**新建一个Python文件，命名为my_module1.py，并定义test函数

def test(a, b):

print(a + b)

import my_module1

my_module1.test(1, 2)

注意

每个Python文件都可以作为一个模块，模块的名字就是文件的名字也就是说自定义模块名必须要符合标识符命名规则

注意事项：

模块1代码

def test(a, b):

print(a + b)

模块2代码

def test(a, b):

print(a - b)

导入模块和调用功能代码

from my_module1 import test

from my_module2 import test

my_test函数是模块2中的函数

test(1, 3)

当导入多个模块的时候，且模有同名场能，当调用这个同名功能的时候，调用到的是后面导入的模块的功能

测试模块

在实际开发中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如，在my_module1.py文件中添加测试代码test(1,1)

def test(a, b):

print(a + b)

test(1,2)

问题：

此时，无论是当前文件，还是其他已经导入了该模块的文件，在运行的时候都会自动执行test"函数的调用

解决方案：

def test(a, b):

print(a + b)

只在当前文件中调用该函数，其他导入的文件内不符合该条件，则不执行test函数调用

if name == 'main':

test(1,2)

all

如果一个模块文件中有__all__变量，当使用from xxx import * 导入时， 只能导入这个列表中的元素

all = ['test_a']

def test_a(a, b):

print(a + b)

def test_b(a, b):

print(a - b)

总结

1.如何自定义模块并导入？

在Python代码文件中正常写代码即可，通过import、from关键字和导入Python内置模块一样导入即可使用。

2.__main__变量的功能是？

if main == "main__"表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入

3.注意事项

• 不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
• __all__变量可以控制import 的时候哪些功能可以被导入

Python包

自定义包

思考

基于Python模块，我们可以在编写代码的时候，导入许多外部代码来丰富功能。

但是，如果Python的模块太多了，就可能造成一定的混乱，那么如何管理呢？

通过Python包的功能来管理。

什么是Python包

从物理上看，包就是一个文件夹，在该文件夹下包含了一个 init.py 文件，该文件夹可用于包含多个模块文件

从逻辑上看，包的本质依然是模块

包的作用：

当我们的模块文件越来越多时，包可以帮我们管理这些模块，包的作用就是包含多个模块，但包的木质依然是精

快速入门

步骤如下：

• 新建包 my_package
• 新建包内模块：my_module1和my_module2
• 模块内代码如下:

def info_print1():

print("我是模块1的功能函数代码")

def info_print2():

print("我是模块2的功能函数代码")

注意：新建包后，包内部会自动创建__init__.py'文件，这个文件控制着包的导入行为

导入包

方式一：

import 包名.模块名

包名.模块名.目标

方式二：

from 包名 import *

模块名.目标

import my_package.my_module1

import my_package.my_module2

my_package.my_module1.info_print1()

my_package.my_module2.info_print2()

from my_package import my_module1

from my_package import my_module2

my_module1.info_print1()

my_module2.info_print2()

from my_package.my_module1 import info_print1

from my_package.my_module2 import info_print2

info_print1()

info_print2()

注意：必须在__init__.py文件中添加__all__ = [ ]，控制允许导入的模块列表

总结

1.什么是Python的包？

包就是一个文件夹，里面可以存放许多Python的模块(代码文件)，通过包，在逻辑上将一批模块归为一类，方便使用。

2.init.py文件的作用？

创建包会默认自动创建的文件，通过这个文件来表示一个文件夹是Python的包，而非普通的文件夹。

3.__all__变量的作用？

同模块中学习到的是一个作用，控制import*能够导入的内容

安装第三方包

什么是第三方包

我们知道，包可以包含一堆的Python模块，而每个模块又内含许多的功能。

所以，我们可以认为：一个包，就是一堆同类型功能的集合体。

在Python程序的生态中，有许多非常多的第三方包(非Python官方)，可以极大的帮助我们提高开发效率，如：

• 科学计算中常用的：numpy包
• 数据分析中常用的：pandas包
• 大数据计算中常用的：pyspark、apache-flink包
• 图形可视化常用的：matplotlib、pyecharts
• 人工智能常用的：tensorflow
• 等

这些第三方的包，极大的丰富了Python的生态，提高了开发效率。

但是由于是第三方，所以Python没有内置，所以我们需要安装它们才可以导入使用哦。 高级软件

安装第三方包-pip

第三方包的安装非常简单，我们只需要使用Python内置的pip程序即可。

打开我们许久未见的：命令提示符程序，在里面输入：

pip install 包名称

即可通过网络快速安装第三方包

pip的网络优化

由于pip是连接的国外的网站进行包的下载，所以有的时候会速度很慢。

我们可以通过如下命令，让其连接国内的网站进行包的安装：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称

https://pypi.tuna.tsinghua.edu.cn/simple是清华大学提供的一个网站，可供pip程序下载第三方包

总结

1.什么是第三方包?有什么作用？

第三方包就是非Python官方内置的包，可以安装它们扩展功能，提高开总结 发效率。

2.如何安装？

在命令提示符内：

• pip install 包名称
• pip install -i
• https://pypi.tuna.tsinghua.edu.cn/simple 包名称

在PyCharm中安装

Python异常、模块、包：综合案例

练习

练习案例：自定义工具包

创建一个自定义包，名称为：my_utils(我的工具)

在包内提供2个模块

1. str_util.py(字符串相关工具，内含：)

• 函数：str_reverse(s)，接受传入字符串，将字符串反转返回
• 函数：substr(s，x，y)，按照下标x和y，对字符串进行切片

2. file_util.py(文件处理相关工具，内含：)

• 函数：print_file_info(file_name)，接收传入文件的路径，打印文件的全部内容，如文件不存在则捕获异常，输出提示信息，通过finally关闭文件对象
• 函数：append to file(file_name,data)，接收文件路径以及传入数据，将数据追加写入到文件中

构建出包后尝试着用一用自己编写的工具包

参考代码：

str_util.py:

def str_reverse(s):

"""

功能是将字符串完成反转

:param s: 将被反转的字符串

:return: 反转后的字符串

""" return s[::-1]

def substr(s, x, y):

"""

功能是按照给定的下标完成给定字符串的切片

:param s: 即将被切片的字符串

:param x: 切片的开始下标

:param y: 切片的结束下标

:return: 切片完成后的字符串

""" r

eturn s[x:y]

if name == 'main':

print(str_reverse("黑马程序员"))

print(substr("黑马程序员", 1, 3))

file_util.py:

def print_file_info(file_name):

"""

功能是：将给定路径的文件内容输出到控制台中

:param file_name: 即将读取的文件路径

:return: None

"""

f = None

try:

f = open(file_name, "r", encoding="UTF-8")

content = f.read()

print("文件的全部内容如下：")

print(content)

except Exception as e:

print(f"程序出现异常了，原因是{e}")

finally:

if f: # 如果变量是None，表示False，如果有任何内容，就是True

f.close()

def append_to_file(file_name, data):

"""

功能：将指定的数据追加到指定的文件中

:param file_name: 指定的文件的路径

:param data: 指定的数据

:return: None

"""

f = open(file_name, "a", encoding="UTF-8")

f.write(data)

f.write("\n")

f.close()

if name == 'main':

print_file_info("D:/bill.txt")

append_to_file("D:/test_append.txt", "传智教育")

实际应用：

import my_utils.str_util

from my_utils import file_util

print(my_utils.str_util.str_reverse("黑马程序员"))

print(my_utils.str_util.substr("itheima", 0, 4))

file_util.append_to_file("D:/test_append.txt", "itheima")

file_util.print_file_info("D:/test_append.txt")