python基础（十六）time模块、sys模块以及自定义模块

一、时间模块

import time
help(time)

执行结果：
Help on built-in module time:

NAME
    time - This module provides various functions to manipulate time values.

DESCRIPTION
.........             #此处省略好多字符

1.计算机公元纪年和现实的公元纪年区别：
现实的公元纪年是从0000年1月1日0时开始
对于unix/linux系统，计算机元年从1970年1月1日0时开始

2.UTC时间：通用坐标时间
按照经纬度，我们通常用的时间，比如中国处于东八区。看到的是英国时间
3.DST阳光节约时间，又称夏令时

二、时间元组
由9个整型的元素组成，自前向后
四位的年（如：1993）
月（1-12）
日（1-31）
时（0-23）
分（0-59）
秒（0-59）
星期（0-6，周一为0）
元旦开始日（1-366）：距离元旦过了多少天
夏令时修正时间（-1，0 or 1）

计算机中没有时钟，是用整数计时，每过一秒整数+1，最后通过算法反推回去
且起始时间为1970：1：1：0：0：0 -------> count = 0
过程：
每经过一秒，count+1
但是这一秒不会直接加到时间，而是通过 / %等算法对这个数字进行推算得到时间
count才是计算机中真正的计时方法，并没有时钟
只不过展示出来为1970：1：1：0：0：0 这样的形式

一些time模块相关的函数：
time.time():返回计算机元年至当前时间的秒数(从1970年1.1开始至今的秒数)
time.sleep(secs):让程序按照给定秒数的浮点数睡眠一段时间
time.gmtime([secs]):将给秒数转换为用UTC表达的时间元组
time.asctime([tuple])：将时间元组转换为日期时间字符串
time.mktime(tuple):将本地日期时间元组转换为新纪元秒数时间（UTC标准）
time.localtime([secs]):将UTC秒数时间转换为日期元组（以本地时间为准）

注：[]中内容可以省略，即可以不传参
示例：

>>> from time import *
>>> 
>>> time()
1554183530.3350112
>>> time()
1554183535.4846675
>>> gmtime(1554183535.4846675)
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=2, tm_hour=5, tm_min=38, tm_sec=55, tm_wday=1, tm_yday=92, tm_isdst=0)
>>> 
>>> T = gmtime(1554183535.4846675)
>>> T
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=2, tm_hour=5, tm_min=38, tm_sec=55, tm_wday=1, tm_yday=92, tm_isdst=0)
>>> asctime(T)
'Tue Apr  2 05:38:55 2019'
>>> mktime(T)
1554154735.0
>>> localtime(1554154735.0)
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=2, tm_hour=5, tm_min=38, tm_sec=55, tm_wday=1, tm_yday=92, tm_isdst=0)
>>> 

>>> gmtime(0)    #参数为0自然是从1970年开始了...
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

>>> gmtime()      #无参返回是当前时间
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=2, tm_hour=5, tm_min=52, tm_sec=55, tm_wday=1, tm_yday=92, tm_isdst=0)
>>> 

练习1：写一个程序以电子时钟的格式显示 HH:MM:SS

from time import *
def showtime():
    while True:
        t = localtime()
        s = "%02d:%02d:%02d"   %  (t[3],t[4],t[5])
        sleep(1)                  #每睡眠一秒打印一次
        print(s)
showtime()
执行结果：
14:12:49
14:12:50
14:12:51
14:12:52
14:12:53
14:12:54
.....

三、系统模块 sys：
与系统相关的一些信息（运行时系统相关的信息和函数）
常见的一些变量：
sys.path:模块搜索路径path[0]是当前脚本程序的路径名，否则为空字符串
sys.module:已加载模块的字典
sys.version:版本信息字符串
sys.version_info:版本信息的命名元组
sys.platform:操作系统平台名称信息
sys.argv:命令行参数argv[0]代表是当前脚本程序路径名
sys.copyright:获得 python版本相关的信息
sys.builtin_module_names:或者python内建模块的名称（字符串元组）

标准输入输出：
sys.stdin:标准输入文件对象，多用于input()
sys.stdout:标准输出文件对象，多用于print()
sys.stderr:标准错误输出文件对象，用于错误输出

sys模块的方法：
sys.exit([arg]):退出程序,正常退出可以sys.exit(0)
sys.getrecursionlimit():得到递归的深度的限制（栈的深度）
sys.setrecursionlimit(n):得到和修改递归嵌套层次限制（栈的深度）

import sys

def fun():
    print("进入函数")
    sys.exit()           #exit（）直接退出整个程序  区别return 是退出函数
    print("退出函数")
fun()
print("程序结束")
执行结果：
进入函数

import sys

#得到栈的深度
print(sys.getrecursionlimit())
#修改栈的深度
sys.setrecursionlimit(1001)
print(sys.getrecursionlimit())
执行结果：
1000
1001

四、自定义模块
1.我们在一个.py文件中实现fac和sum_fac函数，并且该模块名为mymod

2.我们可以在其他模块引入并且直接调用，这里我们在function2中引入使用

#mymod.py中定义：

def fac(n):
    print("正在计算",n,"的阶乘")

def sum_fac(m):
    print("正在计算",m,"的阶乘的和")
    
    
#function2.py中引入调用：
import mymod

mymod.fac(10)
mymod .sum_fac(100)

执行结果：
正在计算 10 的阶乘
正在计算 100 的阶乘的和

前提是被导入模块mymod和myfunction2在同一工程目录下

**python中寻找模块的规则：**路径索引顺序
1.索引程序的运行时的路径（当前路径)
2.搜索sys.path里提供的路径
3.搜索内置模块

模块化编程的优点：
有利于多人合作开发
使代码更加易于维护
提高代码的复用率
模块化编程有助于解决函数名和变量名冲突，变量属于各自的模块作用域下，不冲突

注：模块内的变量作用域为模块内全局

模块的加载过程：
1.在模块导入时，模块的所有语句都会执行
2.如果一个模块已经导入，则再次导入时不会重新执行模块内的语句

示例1.验证第一条

#这是自定义写的一个模块,mymod
def fn(x):
    print("我是mymod模块中的fn函数，我被执行")

def fx(m):
    print("我是mymod模块中的fx函数，我也被执行")

print("mymod中的打印语句执行")
x = 100
print("mymod中的x值为",x)

#我在另外一个模块中调用导入了这个模块，只调用一个函数，看是否执行其他语句
from mymod import *
fn(100)

执行结果：
mymod中的打印语句执行
mymod中的x值为 100
我是mymod模块中的fn函数，我被执行

#从执行结果来看，先是执行模块内的所有语句之后，然后再调用模块内的相应函数

示例2：验证如果我只导入mymod中的一个函数，会不会执行其他语句呢

#在这里我将会导入mymod模块中的一个函数，并且调用这个函数
from mymod import fn
fn(100)

执行结果：
mymod中的打印语句执行
mymod中的x值为 100
我是mymod模块中的fn函数，我被执行

#根据执行结果我们可以知道，即使我们只导入其中的一部分还是会执行整个模块，所以模块导入的时候是以.py这个文件为单位的

示例3.验证重复导入一个模块俩次 是否会将模块重复执行

from mymod import *
from mymod import *

fn(100)
执行结果：
mymod中的打印语句执行
mymod中的x值为 100
我是mymod模块中的fn函数，我被执行

#根据执行结果，多次导入同一个模块，模块内的语句不会重复执行

示例三：当我导入一个模块，但是导入后，原模块被修改了，我能不能把更新后的导入进来？

可以！
#需要导入一个新的模块，叫做imp
import   imp 
imp.reload(mymod)  #该函数会将更改后的mymod模块重新导入，卸载掉旧的模块，重新加载新的