模块的使用

李ma

已于 2024-05-12 13:57:49 修改

阅读量677

点赞数 25

文章标签： python

于 2024-05-11 16:54:37 首次发布

本文链接：https://blog.csdn.net/2301_80332388/article/details/138679551

版权

1.导入模块的三种方式

方式一：import 模块名
- ```
import commors.str_util
```
方式二：from 模块名 import 功能名
- ```
from commors.str_util import str_reverse
```
方式三：from 模块名 import
- ```
from commors.str_util import 
```

2.导入包三种方式

import 包名[.模块名 [as 别名]]
- import my_package.module1
  # 必须通过包名.模块名的方式访问模块中的成员
  my_package.module1.hello()
- 别名方式：
  import my_package.module1 as module1
  # 别名方式可直接通过别名访问模块中的成员
  module1.hello()
- 如果使用 as 给包名.模块名起一个别名的话，就使用直接使用这个别名作为前缀使用该模块中的方法可使用这个别名作为前缀使用该模块中的方法。
from 包名 import 模块名 [as 别名]
- # 导入my_package包下的module1模块
  from my_package import module1
  module1.hello()
- 使用此语法格式导入包中模块后，在使用其成员时不需要带包名前缀，但需要带模块名前缀。
from 包名.模块名 import 成员名 [as 别名]
- # 导入my_package包下的module1模块中的hello成员
  from my_package.module1 import hello
  hello()
- 在使用此种语法格式加载指定包的指定模块时，可以使用 * 代替成员名，表示加载该模块下的所有成员。例如：
- from my_package.module1 import *
- 只有以“from 模块名 import *”形式导入的模块，当该模块设有 `__all__` 变量时，只能导入该变量指定的成员，未指定的成员是无法导入的。

3.异常

程序运行时常会碰到一些错误，例如除数为 0、年龄为负数、数组下标越界等，这些错误如果不能发现并加以处理，很可能会导致程序崩溃。和 C++、Java 这些编程语言一样，Python 也提供了处理异常的机制，可以让我们捕获并处理这些错误，让程序继续沿着一条不会出错的路径执行
捕获指定异常类型
nums = []
nums[0]
try:
print(nums[0])
except IndexError:
print("异常了")
捕获多个指定异常

通过多 except 代码块，捕获不同类型的异常。
try:
print(1/0)
except IndexError:
print("下标越界")
except ZeroDivisionError:
print("除数不能为0")
except Exception:
print("未知错误")
同时，每个 except 块都可以同时处理多种异常。
try:
print(1/0)
except (IndexError,ZeroDivisionError):
print("下标越界或除数不能为0")
except Exception:
print("未知错误")
捕获所有异常

所有异常的父类都是Exception，通过Exception即可捕获所有异常信息。
try:
print(10+"")
except Exception:
print("报错了")
异常的捕获信息

针对未知异常信息，可以通过`Exception as 变量名`方式捕获特定的异常信息。
try:
print(10+"")
except Exception as ex:
print(f"{ex}")
异常的else

在原本的`try except`结构的基础上，Python异常处理机制还提供了一个 else 块，也就是原有 try except 语句的基础上再添加一个 else 块，即`try except else`结构。

使用 else 包裹的代码，只有当 try 块没有捕获到任何异常时，才会得到执行；反之，如果 try 块捕获到异常，即便调用对应的 except 处理完异常，else 块中的代码也不会得到执行。
try:
print(str(10)+"10")
except Exception:
print("报错了")
else:
print("没有出现异常情况")
异常的finally

> 在整个异常处理机制中，finally 语句的功能是：无论 try 块是否发生异常，最终都要进入 finally 语句，并执行其中的代码块。

         try:
          print(str(10)+"10")
        except Exception:
          print("报错了")
        else:
          print("执行else中的代码")
        finally:
          print("执行finally中的代码")

自定义异常
创建自定义异常类：

class MyException(Exception):
def __init__(self, msg: str):
self.msg = msg

def __str__(self):
return self.msg
模拟自定义异常引发场景：
try:
a: int = 2
if a < 5:
raise MyException("a的值不能小于5")
except Exception as ex:
print(ex)

4. 文件

open() 函数用于创建或打开指定文件，该函数的常用语法格式如下：

```python
file = open(file_name [, mode='r' [ , buffering=-1 [ , encoding = None ]]])
```

此格式中，用 [] 括起来的部分为可选参数，即可以使用也可以省略。其中，各个参数所代表的含义如下：

- file：表示要创建的文件对象。
- file_name：要创建或打开文件的文件名称，该名称要用引号（单引号或双引号都可以）括起来。需要注意的是，如果要打开的文件和当前执行的代码文件位于同一目录，则直接写文件名即可；否则，此参数需要指定打开文件所在的完整路径。
- mode：可选参数，用于指定文件的打开模式。如果不写，则默认以只读（r）模式打开文件。
- buffering：可选参数，用于指定对文件做读写操作时，是否使用缓冲区（本节后续会详细介绍）。
- encoding：手动设定打开文件时所使用的编码格式，不同平台的 ecoding 参数值也不同，以 Windows 为例，其默认为 cp936（实际上就是 GBK 编码）。
open() 函数支持的文件打开模式：

<table border="1">
   <tr style="font-weight:bold;">
       <td>模式</td>
       <td>说明</td>
<td>注意实现</td>
   <tr>
   <tr>
       <td>r</td>
<td>只读模式打开文件，读文件内容的指针会放在文件的开头。</td>
<td rowspan="4">操作的文件必须存在。</td>
</tr>
<tr>
       <td>rb</td>
<td>以二进制格式、采用只读模式打开文件，读文件内容的指针位于文件的开头，一般用于非文本文件，如图片文件、音频文件等。</td>
</tr>
<tr>
       <td>r+</td>
<td>打开文件后，既可以从头读取文件内容，也可以从开头向文件中写入新的内容，写入的新内容会覆盖文件中等长度的原有内容。</td>
</tr>
<tr>
       <td>rb+</td>
<td>以二进制格式、采用读写模式打开文件，读写文件的指针会放在文件的开头，通常针对非文本文件（如音频文件）。</td>
</tr>
<tr>
   <td>w</td>
<td>以只写模式打开文件，若该文件存在，打开时会清空文件中原有的内容。</td>
<td rowspan="4">若文件存在，会清空其原有内容（覆盖文件）；反之，则创建新文件。</td>
</tr>
<tr>
   <td>wb</td>
<td>以二进制格式、只写模式打开文件，一般用于非文本文件（如音频文件）</td>
</tr>
<tr>
   <td>w+</td>
<td>打开文件后，会对原有内容进行清空，并对该文件有读写权限。</td>
</tr>
<tr>
   <td>wb+</td>
<td>以二进制格式、读写模式打开文件，一般用于非文本文件</td>
</tr>
<tr>
   <td>a</td>
<td>以追加模式打开一个文件，对文件只有写入权限，如果文件已经存在，文件指针将放在文件的末尾（即新写入内容会位于已有内容之后）；反之，则会创建新文件。</td>
<td rowspan="4"></td>
</tr>
<tr>
   <td>ab</td>
<td>以二进制格式打开文件，并采用追加模式，对文件只有写权限。如果该文件已存在，文件指针位于文件末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。</td>
</tr>
<tr>
   <td>a+</td>
<td>以读写模式打开文件；如果文件存在，文件指针放在文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。</td>
</tr>
<tr>
   <td>ab+</td>
<td>以二进制模式打开文件，并采用追加模式，对文件具有读写权限，如果文件存在，则文件指针位于文件的末尾（新写入文件会位于已有内容之后）；反之，则创建新文件。</td>
</tr>
</table>
文件读

read() 逐个字节或者字符读取文件中的内容
readline() 逐行读取文件中的内容
readlines() 一次性读取文件中多行内容
try:
# 1.读取整个文件，并返回列表
print(f.readlines())
# 2.读取一行
print(f.readline())
# 3.逐个字节或者字符读取文件中的内容
print(f.read(8))
except Exception as ex:
print(ex)
finally:
# 关闭文件
f.close()
文件写

write() 可以向文件中写入指定内容。注意：在使用 write() 向文件中写入数据，需保证使用 open() 函数是以 r+、w、w+、a 或 a+ 的模式打开文件，否则执行 write() 函数会抛出 `io.UnsupportedOperation` 错误。
writelines()可以实现将字符串列表写入文件中。注意：使用 writelines() 函数向文件中写入多行数据时，不会自动给各行添加换行符。

> 注意，写入函数只有 write() 和 writelines() 函数，而没有名为 writeline 的函数。
f = open("a.txt", "r+", encoding="utf-8")
# 不换行
f.write("hello world")
f.write("hello world")
f.write("hello world")
# 换行
f.write("hello world\n")
f.write("hello world\n")
f.write("hello world\n")
# 追加，这个需要打开模式为a
f.write("ni hao python")
with as**

使用 with as 操作已经打开的文件对象（本身就是上下文管理器），无论期间是否抛出异常，都能保证 with as 语句执行完毕后自动关闭已经打开的文件。

with as 语句的基本语法格式为：
with 表达式 [as target]：
代码块

5.高阶函数

filter()函数

`filter(func,lst)`函数（又称之为过滤函数）用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象，可将其转换成list。
nums = [1, 2, 3, 4, 5, 6, 7]
# 1.filter 过滤函数
f = filter(lambda a: a > 5, nums)
map()函数

`map(func,lst)`函数（又称之为遍历函数）将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表（Python2）或者迭代器对象（Python3）。
nums = [1, 2, 3, 4, 5, 6, 7]
# 2.map 遍历函数
m = map(lambda a: a * 2, nums)
reduce()函数

`reduce(func,lst)`函数（又称之为规约函数），其中func必须有两个参数，每次func计算的结果继续和序列的下一个元素做累计计算处理。

通过reduce()函数计算总和：
nums = [1, 2, 3, 4, 5, 6, 7]
r = reduce(lambda a, b: a + b, nums)
print(r)
通过reduce()函数计算列表中的奇数：
nums = [1, 2, 3, 4, 5, 6, 7]

def func_sj(a, b):
if b % 2 == 1:
a.append(b)
return a

r1 = reduce(func_sj, nums, [])
print(r1)