模块

1. 模块介绍

模块是一个包含所有人为定义函数和变量的文件，其后缀名是.py。

• 容器 -> 数据的封装
• 函数 -> 语句的封装
• 类 -> 方法和属性的封装
• 模块 -> 程序文件

创建一个 hello.py 文件

# hello.py
def hi():
    print('Hi everyone, I love lsgogroup!')

命名空间因为对象的不同，也有所区别，可以分为如下几种：

• 内置命名空间（Built-in Namespaces）：Python 运行起来，它们就存在了。内置函数的命名空间都属于内置命名空间。
• 全局命名空间（Module：Global Namespaces）：每个模块创建它自己所拥有的全局命名空间，不同模块的全局命名空间彼此独立。
• 本地命名空间（Function & Class：Local Namespaces）：模块中有函数或者类，每个函数或者类所定义的命名空间就是本地命名空间。

程序在查询上述三种命名空间的时候，就按照从里到外的顺序，即：Local Namespaces–> Global Namesspaces–> Built-in Namesspaces。

import hello

hello.hi()  # Hi everyone, I love lsgogroup!
hi()  # NameError: name 'hi' is not defined

导入模块

创建一个模块 TemperatureConversion.py

# TemperatureConversion.py
def c2f(cel):
    fah = cel * 1.8 + 32
    return fah


def f2c(fah):
    cel = (fah - 32) / 1.8
    return cel

• 第一种：import模块名

import TemperatureConversion

print('32摄氏度 = %.2f华氏度' % TemperatureConversion.c2f(32))
print('99华氏度 = %.2f摄氏度' % TemperatureConversion.f2c(99))

# 32摄氏度 = 89.60华氏度
# 99华氏度 = 37.22摄氏度

• 第二种：from模块名 import函数名

from TemperatureConversion import c2f, f2c

print('32摄氏度 = %.2f华氏度' % c2f(32))
print('99华氏度 = %.2f摄氏度' % f2c(99))

# 32摄氏度 = 89.60华氏度
# 99华氏度 = 37.22摄氏度

• 第三种：import模块名 as新名字

import TemperatureConversion as tc

print('32摄氏度 = %.2f华氏度' % tc.c2f(32))
print('99华氏度 = %.2f摄氏度' % tc.f2c(99))

# 32摄氏度 = 89.60华氏度
# 99华氏度 = 37.22摄氏度

if __name__ == '__main__'

假设我们有一个 const.py文件，内容如下：

PI = 3.14


def main():
    print("PI:", PI)


main()

# PI: 3.14

现在，我们写一个用于计算圆面积的 area.py文件，area.py文件需要用到 const.py文件中的PI变量。从 const.py中，我们把 PI变量导入 area.py：

from const import PI


def calc_round_area(radius):
    return PI * (radius ** 2)


def main():
    print("round area: ", calc_round_area(2))


main()

'''
PI: 3.14
round area:  12.56
'''

我们看到 const.py中的main函数也被运行了，实际上我们不希望它被运行，因为const.py提供的 main 函数只是为了测试常量定义。这时if __name__ == '__main__'派上了用场，我们把const.py改一下，添加if __name__ == "__main__"：

PI = 3.14

def main():
    print("PI:", PI)

if __name__ == "__main__":
    main()

运行 const.py，输出如下：

PI: 3.14

运行 area.py，输出如下：

round area:  12.56

__name__：是内置变量，可用于表示当前模块的名字。

import const

print(__name__)
# __main__

print(const.__name__)
# const

由此我们可知：如果一个 .py 文件（模块）被直接运行时，其__name__值为__main__，即模块名为__main__。

所以，if __name__ == '__main__'的意思是：当 .py文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；当 .py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。

搜索路径:

import sys

print(sys.path)

# ['C:\\ProgramData\\Anaconda3\\DLLs', 'C:\\ProgramData\\Anaconda3\\lib', 'C:\\ProgramData\\Anaconda3', 'C:\\ProgramData\\Anaconda3\\lib\\site-packages',...]

包：
包是一种管理Python模块命名空间的形式，采用"点模块名称"。

创建包分为三个步骤：

• 创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字。
• 在文件夹中创建一个 __init__.py的模块文件，内容可以为空。
• 将相关的模块放入文件夹中。

在导入一个包的时候，Python会根据 sys.path中的目录来寻找这个包中包含的子目录。

目录只有包含一个叫做__init__.py的文件才会被认作是一个包，最简单的情况，放一个空的 __init__.py就可以了。

import sound.effects.echo
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

还有一种导入子模块的方法是：

from sound.effects import echo
echo.echofilter(input, output, delay=0.7, atten=4)

还有一种变化就是直接导入一个函数或者变量：

from sound.effects.echo import echofilter
echofilter(input, output, delay=0.7, atten=4)

2. datatime模块

datetime是 Python中处理日期的标准模块，它提供了 4种对日期和时间进行处理的类：datetime、date、time和 timedelta。

datetime类

• datetime.now(tz=None)获取当前的日期时间，输出顺序为：年、月、日、时、分、秒、微秒。
• datetime.timestamp()获取以 1970年1月1日为起点记录的秒数。
• datetime.fromtimestamp(tz=None)使用 unixtimestamp创建一个 datetime。

如何创建一个 datetime对象？

import datetime

dt = datetime.datetime(year=2020, month=6, day=25, hour=11, minute=23, second=59)
print(dt)  # 2020-06-25 11:23:59
print(dt.timestamp())  # 1593055439.0

dt = datetime.datetime.fromtimestamp(1593055439.0)
print(dt)  # 2020-06-25 11:23:59
print(type(dt)) # <class 'datetime.datetime'>

dt = datetime.datetime.now()
print(dt)  # 2020-06-25 11:11:03.877853
print(type(dt))  # <class 'datetime.datetime'>

• datetime.strftime(fmt)格式化 datetime对象。

import datetime

dt = datetime.datetime(year=2020, month=6, day=25, hour=11, minute=51, second=49)
s = dt.strftime("'%Y/%m/%d %H:%M:%S")
print(s)  # '2020/06/25 11:51:49

s = dt.strftime('%d %B, %Y, %A')
print(s)  # 25 June, 2020, Thursday

在处理含有字符串日期的数据集或表格时，我们需要一种自动解析字符串的方法，无论它是什么格式的，都可以将其转化为 datetime对象。这时，就要使用到dateutil中的parser模块。

from dateutil import parser

s = '2020-06-25'
dt = parser.parse(s)
print(dt)  # 2020-06-25 00:00:00
print(type(dt))  # <class 'datetime.datetime'>

s = 'March 31, 2010, 10:51pm'
dt = parser.parse(s)
print(dt)  # 2010-03-31 22:51:00
print(type(dt))  # <class 'datetime.datetime'>

data类

• date.today()获取当前日期信息。

import datetime

d = datetime.date(2020, 6, 25)
print(d)  # 2020-06-25
print(type(d))  # <class 'datetime.date'>

d = datetime.date.today()
print(d)  # 2020-06-25
print(type(d))  # <class 'datetime.date'>

time类

import datetime

t = datetime.time(12, 9, 23, 12980)
print(t)  # 12:09:23.012980
print(type(t))  # <class 'datetime.time'>

timedelta类

timedelta表示具体时间实例中的一段时间。把它们简单想象成两个日期或时间之间的间隔。

import datetime

td = datetime.timedelta(days=30)
print(td)  # 30 days, 0:00:00
print(type(td))  # <class 'datetime.timedelta'>
print(datetime.date.today())  # 2020-07-01
print(datetime.date.today() + td)  # 2020-07-31

dt1 = datetime.datetime(2020, 1, 31, 10, 10, 0)
dt2 = datetime.datetime(2019, 1, 31, 10, 10, 0)
td = dt1 - dt2
print(td)  # 365 days, 0:00:00
print(type(td))  # <class 'datetime.timedelta'>

td1 = datetime.timedelta(days=30)  # 30 days
td2 = datetime.timedelta(weeks=1)  # 1 week
td = td1 - td2
print(td)  # 23 days, 0:00:00
print(type(td))  # <class 'datetime.timedelta'>

如果将两个 datetime对象相减，就会得到表示该时间间隔的 timedelta对象。

同样地，将两个时间间隔相减，可以得到另一个 timedelta对象。

参考: 模块，datatime模块