Python——模块

💦 模块

定义重复利用的代码的文件被称为模块。模块中定义的代码可以被导入到另一个模块或者主模块中。

其中，模块就是一个包含了python定义和声明的“ .py ”文件。例如我们定义一个“ fib.py ”的文件，内容如下：

def fib1(n):
    a = 2
    b = 2
    while b < n:
        print(b)
        b *= 2

def fib2(n):
    result = []
    a = 2
    b = 2
    while b < n:
        result.append(b)
        b *= 3
    return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

☁️ 使用模块

模块也是对象，所以调用模块中的内容和调用对象中的内容的方法是一样的。首先，我们需要在同级目录下再另建一个文件test.py，如下图👇：

然后我们再进入到test.py文件中去调用fib.py模块，例如👇：

import fib
fib.fib1(20)
print(fib.fib2(20))
#2
#4
#8
#16
#[2,6,18]
1
2
3
4
5
6
7
8

☁️ __name__变量

模块的模块名可通过全局变量“__name__”来获得。例如（此时我们还是在test.py中执行）👇：

import fib
print(fib.__name__)
print(__name__)
#fib
#__main__
1
2
3
4
5

可以看到，fib的“__name__”打印出来的是fib，但是第二个print也就是打印本文件的“__name__”却是“__main__”。

在python中，“__name__”是当前模块名，如果当前模块被直接运行，那么此时它的模块名就是“__main__”。（就像我们在test.py模块中直接运行它）。所以，我们在定义模块时，可以通过看当前的“__name__”变量的值是否为“__main__”来判断当前文件是被直接运行还是作为模块被导入。例如（在test中）👇：

if __name__ == "__main__":
    print("直接运行")
else:
    print("作为模块被导入")
#直接运行
1
2
3
4
5

import fib
if fib.__name__ == "__main__":
    print("直接运行")
else:
    print("作为模块被导入")
#作为模块被导入
1
2
3
4
5
6

☁️ dir函数

$dir$函数可以列出对象的模块标识符，标识符有函数、类和变量。当为$dir$函数提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，则返回当前模块中定义的名称列表。例如👇：

import fib
print(dir(fib))
print(dir())
#['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'fib1', 'fib2']
#['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'fib']
1
2
3
4
5

从执行结果可以看到一些内置变量，也可以看到在fib中定义的两个函数fib1和fib2。

💦 包

代码、模块、包它们三者的关系是：“包”包含模块且至少包含一个“__init__.py”文件，模块包含代码。

简单来说，包就是文件夹，且该文件夹下必须有“__inti__.py”文件，该文件的内容可以为空。__init__.py用于标识当前文件夹是一个包。

包可以在python中新建，如下图👇：

现在我们要来使用包，创建包后，需在它的目录下另外创建3个文件，一定要包含__init__.py，如下图👇：
fun1.py中的代码为：

def print1():
	print("fun1")
1
2

fun2.py中的代码为：

def print2():
	print("fun2")
1
2

__inti__.py中的代码为：

if __name__ == "__main__":
	print("作为主程序运行")
else:
	print("package 初始化")
1
2
3
4

然后我们需要在与Package1同级目录下创建一个文件来调用这个包，如下图👇：

这里创建的是一个work.py来调用包。work.py中的代码为：

from Package1.fun1 import print1
from Package1.fun2 import print2

print1()
print2()
#package 初始化
#fun1
#fun2
1
2
3
4
5
6
7
8

💦 标准库

Python官方提供了不少包和模块，我们称之为标准库。下面介绍一些常用的标准库中的模块。

☁️ sys

$sys$模块的功能很多，这里介绍一些比较实用的功能。$sys$模块提供了许多函数和变量来处理python运行时环境的不同部分。

1. 识别操作系统(sys.platform)

import sys
print(sys.platform)
#win32
1
2
3

2. 处理命令行参数(sys.argv)
   $sys.argv$变量可以获取命令行的参数。$argv$是一个list类型的变量，它会返回在命令行中用户输入的参数。
   详情可以点击下面链接，来源：CSDN博主——流动的风与雪。
   http://t.csdn.cn/s20Y8

3. 退出程序(sys.exit)
   执行到主程序末尾，解释器会自动退出，如果需要中途退出程序，可以调用$sys.exit$函数，它带有一个可选的整数参数返回给调用它的程序，表示你可以在主程序中捕获对$sys.exit$的调用。（参数0表示正常退出，其它为异常）。例如👇：

import sys
if len(sys.argv) <= 1:
    print("缺少参数")
    sys.exit(1)
for arg in sys.argv:
    print(arg)
1
2
3
4
5
6

如果是直接执行该文件，则执行结果如下：

#缺少参数
1

4. 获取模块搜索路径(sys.path)
   例如：

import sys

for path in sys.path:
    print(path)
1
2
3
4

执行结果如下：

❗️：不同的环境下执行结果可能不一样。

由于$sys.path$是列表类型的变量，所以我们可以像修改变量一样修改$sys.path$变量来增加python解释器查找模块的路径。例如👇：

import sys

sys.path.append("c:\\")
for path in sys.path:
    print(sys)
1
2
3
4
5

此时调用“import”来导入模块时，python解释器会去“c:\”目录中查找模块。

5. 查找已导入的模块
   “sys.modules”是一个全局字典，该字典在python启动后就加载到内存中。每当程序员导入新的模块时，“sys.modules”就会自动记录该模块。当第二次导入该模块时，python会直接到字典中查找，从而加快程序运行的速度。“sys.modules”拥有字典所拥有的一切方法。例如👇：

import sys

print(sys.modules.keys())
print(sys.modules.values())
print(sys.modules["os"])
1
2
3
4
5

输出如下：

后面还有很多…

☁️ os

python中的os模块封装了操作系统的文件和目录操作。下面介绍一些常见的方法。

1. 获取当前文件所在目录

import os
print(__file__)
#D:/pycharm/pythonProject1/test.py
print(os.path.dirname(__file__))
#D:/pycharm/pythonProject1
1
2
3
4
5

__file__是python的内置变量，os.path.dirname(__file__)表示的是文件当前所在文件夹的位置。

2. 获取当前路径以及切换当前路径

import os
print(os.getcwd())
#D:\pycharm\pythonProject1
os.chdir("c:\\")
print(os.getcwd())
#c:\
1
2
3
4
5
6

os.getcwd()可以获取当前执行程序的路径，os.chdir()可以切换当前的路径。

3. 重命名文件

import os
os.rename("test.py","test1.py")
1
2

上面代码将我们原来名为“test.py”的文件改为“test1.py”。

4. 查看指定的路径是否存在

import os
a = os.path.exists("D:\\pycharm\\pythonProject1\\test1.py")
print(a)
#True
1
2
3
4

存在返回$True$，否则返回$False$。

5. 判断给出的路径是否为一个文件

import os
a = os.path.isfile("D:\\pycharm\\pythonProject1\\test.py")
print(a)
#False
1
2
3
4

这里因为我们前面更改了名字，所以返回$False$。

6. 判断所给出的路径是否为一个目录

import os
a = os.path.isdir("D:\\pycharm\\pythonProject1\\test.py")
print(a)
#False
b = os.path.isdir("D:\\pycharm\\pythonProject1")
print(b)
#True
1
2
3
4
5
6
7

7. 创建单层目录

import os
os.mkdir("d:\\test1111111")
1
2

位置就能找到我们创建的目录了。但是os.mkdir函数只能创建一层目录，在有父目录的情况下创建子目录，如果父目录不存在则不能创建并输出错误。

8. 创建多层目录

import os
os.makedirs("d:\\test2\\test3")
1
2

——————————————————————————————

这时我们点进test2就会发现里面还有一个目录test3。

☁️ math

下面简单介绍几个math库中的函数。

1. 两个常量

import math
print(math.pi)
#3.141592653589793
print(math.e)
#2.718281828459045
1
2
3
4
5

2. 指数运算

import math
print(math.pow(2,3))
#8.0
1
2
3

3. 对数计算

import math
print(math.log(math.e))
#1.0
print(math.log(100,10))
#2.0
1
2
3
4
5

该函数默认底数为e，可以实用第二个参数来改变对数的底数。

4. 三角函数计算

import math
print(math.sin(math.pi/2))
#1.0
print(math.cos(0))
#1.0
1
2
3
4
5

☁️ random

1. 0~1之间的随机浮点数

import random
print(random.random())
#0.9822369992491721
#0.5783076696174532
#...
1
2
3
4
5

2. 指定范围内的浮点数

import random
print(random.uniform(1,10))
#5.49485532264801
#9.106030260288195
#...
1
2
3
4
5

3. 指定范围内的整数

import random
print(random.randint(1,10))
#1
#5
#...
1
2
3
4
5

4. 从给定的序列中随机获得一个元素

import random
a = ["hello",1,2,"你好"]
print(random.choice(a))
#hello
#2
#...
1
2
3
4
5
6

5. 将一个列表中的元素打乱

import random
a = list(range(1,10))
print(random.shuffle(a)) #注意，该函数没有返回值
#None
1
2
3
4

import random
a = [1,2,3,4]
random.shuffle((a))
print(a)
#[2,3,1,4]
1
2
3
4
5

❗️：这个函数会修改原来的序列，所以原来的序列必须是可修改的，因此元组等类型不能作为该函数的参数。