目录
9.7结构化时间 --> %a %b %d %H:%M:%S %Y时间串
9.8时间戳 --> %a %b %d %H:%M:%S %Y时间串
1.模块的概念
1.1模块的概念介绍
一个包含python代码的文件就是一个模块。
使用模块的作用：
1.现在程序开发文件比较大，都放在一个文件中维护不方便，拆分成多个文件方便维护与管理
2.模块可以增加代码的重用率
1.2创建模块
模块本身就是一个文件，所有py代码都可以在文件中直接书写。不过我们开发共用模块时，最好在模块中书写以下内容。
| 变量 | 模块中的属性值 |
|---|---|
| 函数 | 单独的功能 |
| 类 | 相似功能的组合 |
| 模块测试代码 | 临时使用，被导入时不会执行 |
注意：
- .模块名称遵循标识符。
- .模块只有第一次被导入的时候执行，多次导入不会执行。
#model.py 一个简单的打招呼模块
def say_hello():
print('hello')
import model #导入模块，不加py后缀名
model.say_hello() # 调用模块中的功能，使用模块名.方法名()
2.模块导入的原理
2.1原理的介绍
1. 模块导入会将要导入的文件执行一遍
2. 导入模块的名称就是我们定义的脚本或包的名称
3. 我们导入模块的过程总结就是：在指定的范围内搜索指定名称的python脚本或者包，将其运行,获取其中的方法
3.模块的导入方式
1 、import 模块名
2 、import 模块名 as 别名
3 、import 模块名1 ，模块名2 ，... 一行导入多个模块。
4 、from ... import ...
5 、from ... import ... as 别名
6 、from ... import 功能1 ，功能2 ，...
7 、from ... import * 导入所有
3.1import模块名
作用：直接导入模块
import model #导入模块
model.say() #调用模块中的方法
3.2import 模块 as 别名
如果模块的名称太长，我们可以这个模块起一个别名。
# import 模块 as 别名
import model as mk #为模块model取别名mk
mk.say() #用别名mk调用model中的方法
3.3一行导入多个模块
import model1,model2,model3 #一行调用多个模块，之间用','隔开
#分别调用不同模块中的say()方法
model1.say()
model2.say()
model3.say()
3.4from ... import ...局部导入方式
当使用模块中的部分功能的时候，就可以使用局部导入方式。
from 模块 import 某个函数或者类。
作用：直接导入模块中的某个函数或者某个类或变量
from model import say
def say():
print('呵呵')
注意：如果当前文件中的变量或者函数名称和模块中的名称重复，会使用就近原则。
from model import say
def say():
print('呵呵')
say() # 就近原则，调用的是自己的方法,输出-->呵呵
3.5from ... import ... as 别名
当导入的模块和当前模块中的名称相同的时候可以起别名进行区分。
from model import say as say1
def say():
print('哈喽')
say1() # 调用model模块中say1方法
say() # 调用自己的say方法
3.6支持导入多行
import model1
import model2
import model3
model1.say()
model2.say()
model3.say()
3.7from 模块 import *
from my_module import *
把my_module中所有的不是以下划线(_)开头的名字都导入到当前位置，大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差。
作用：直接导入模块中的所有方法和类和变量
school = '北大'
from model import * # 可能会覆盖掉你定义的变量
say()
print(school) # 在model模块中有变量school，就会覆盖自己的school变量
注意：如果my_module.py中的名字前加_,即_money，则from my_module import *,则_money不能被导入
school = '大同大学'
print(school)
a = '2'
_age = 13 # 变量age前有下划线
def say():
print('hello')
下面导入model模板时，无法导入age变量
from model import * # model存在__all__属性，只能导入all中的变量
s = school
n = name # 报错name没有被定义
__all__属性：
__all__ = [变量1，变量2 ...] 规定导入模块的功能。
__all__=['money','read1']
#这样在另外一个文件中用from my_module import *就这能导入列表中规定的两个名字
model.py
def say():
print('hello')
school = '大同大学'
_age = 13
a = '2'
__all__ = ['school','a','_age']
from model import * # model存在__all__属性，只能导入all中的变量
s = school
say() # 无法调用
l = _age #放入all属性中,又可调用
4.模块搜索路径
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
1、当前目录
2、如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
由sys模块的sys.path方法来规定
因为sys.path返回的数据类型是列表
1、列表可以修改、我们导入的范围也可以通过修改sys.path这个列表获得暂时的修改。例如通过 sys.path.append()添加目录，导入额外目录的模块。
2、列表是有序的，当搜索的过程当中，在第一个路径下搜索到了，就停止搜索。而且sys.path第一个路 径是脚本的当前路径，所以禁止大家讲自己的脚本命名成模块的名称。
因此需要注意的是：自己模块命名的时候不能和系统的模块名称相同。
import random #自己的random模块
n = random.randint(0,3) # 报错,自己的模板中没有randint方法
print(n)
5.pyc临时文件
为了提高加载模块的速度，python解释器会在__pycache__目录中下缓存每个模块编译后的版本，之后，再次被导入时，实际上导入的是这个.pyc的临时文件。
6.把模块当做脚本运行
我们可以通过模块的全局变量__name__来查看模块名：
当做脚本运行：
__name__ 的值 等于'__main__'
当做模块导入：
__name__的值等于模块名
作用：用来控制.py文件在不同的应用场景下执行不同的逻辑
if __name__ == '__main__':
pass
def sum(x,y):
print(x+y)
if __name__ == '__main__': #当作模块，调用时不执行，在此可当作测试使用
sum(2,5)
7.random模块
产生随机数
一、随机小数
1.random()
- 产生大于0且小于1之间的小数
import random
ret = random.random() # 0-1之间的随机小数,不能加参数 [0,1)
print(ret)
输出结果:
2.uniform(a,b)
- 产生指定范围内的随机小数
import random
ret = random.uniform(1, 4) # 返回(start,end)的小数 [x, y)
print(ret)
输出结果 ：
二、随机整数
1.randint(a,b)
-产生a,b范围内的整数，包含开头和结尾
import random
ret = random.randint(1, 99) # 返回[start,end]的整数
print(ret)
输出结果：
2.randrange(start,stop,[step])
- 产生start,stop范围内的整数，包含开头不包含结尾。
- step 指定产生随机数的步长。
import random
ret = random.randrange(1, 9, 2) # 返回(start,end,step)的整数 含头不含尾
print(ret)
输出结果：
三、随机选择一个数据
1.random.choice(lst)
- 随机返回序列中的一个数据
import random
lst = [1,2,3]
ret = random.choice(lst) #从序列中随机取出一个元素
print(ret)
输出结果：
四、打乱
1.shuffle()
- 打乱列表顺序
import random
lst = [1, 2, 3]
random.shuffle(lst) # 处理，没有返回值
print(lst)
输出结果：
练习：
随机生成验证码
源码：
def code():
l = []
for i in range(4): # 循环，控制验证码的长度
n = random.randint(0, 9) #随机生成0-9的整数
s = chr(random.randint(65, 90)) #随机生成字母A-Z
a = [n, s] # 将随机生成的字母和数字放到一个列表中
ret = random.choice(a) #每次随机选择字母或数字
l.append(ret) # 选出后添加到空列表中
for i in l: # 循环打印输出
print(i, end='')
code() # 调用方法
运行结果：
8.sys模块
1.sys.version返回解释器的版本号
import sys
print(sys.version) # python解释器版本信息
# 输出：
# 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)]
2.sys.path 返回模块的搜索路径
import sys
print(sys.path) # 返回模块搜索路径
''' 输出：
['D:\\pycharm工作空间\\day11', 'D:\\pycharm工作空间', 'D:\\pycharm工作空间\\day11', 'D:\\pycharm工作空间\\venv\\Scripts\\python36.zip',
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\DLLs', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36\\lib',
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36', 'D:\\pycharm工作空间\\venv', 'D:\\pycharm工作空间\\venv\\lib\\site-packages',
'D:\\pycharm工作空间\\venv\\lib\\site-packages\\setuptools-39.1.0-py3.6.egg', 'D:\\pycharm工作空间\\venv\\lib\\site-packages\\pip-10.0.1-py3.6.egg',
'C:\\Program Files\\JetBrains\\PyCharm 2018.3.2\\helpers\\pycharm_matplotlib_backend']
'''
3.sys.argv 接受命令行下的参数
import sys
ret = sys.argv # 可接收命令行下的参数
file = ret[0]
user_name = ret[1]
pwd = ret[2]
print(ret)
if user_name =='zxb' and pwd =='555':
print('登录成功')
else:
print('用户名或密码错误')
在命令行下执行：
9.time模块
在Python中，通常有这三种方式来表示时间：
时间戳、时间元组(struct_time)、格式化的时间字符串。
- 时间戳(timestamp) ：
时间戳表示的是从1970年1月1日00:00:00开始到现在的秒值。返回的是float类型。
(2)格式化的时间字符串(Format String)： ‘1999-12-06’
(3)时间元组(struct_time) ：
struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一周的第几日，一年中第几天，夏令时。
小结：
时间戳是计算机能够识别的时间；
时间字符串是人能够看懂的时间；
时间元组则是用来操作时间的。
时间元组属性：
| 序号 | 字段 属性 | 值 |
|---|---|---|
| 1 | 年 tm_year (4位数) | 2008 |
| 2 | 月 tm_mon | 1 到 12 |
| 3 | 日 tm_mday | 1到31 |
| 4 | 小时 tm_hour | 0到23 |
| 5 | 分钟 tm_min | 0到59 |
| 6 | 秒 tm_sec | 0到61 (60或61 是闰秒) |
| 7 | 一周的第几日 tm_wday | 0到6 (0是周一) |
| 8 | 一年的第几日tm_yday | 1到366 (儒略历) |
| 9 | 夏令时 tm_isdst | -1, 0, 1, -1是决定是否为夏令时的旗帜 |
格式化的时间字符串(Format String)表示方式： ‘1999-1-06’
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
9.1time.sleep()
睡眠功能，让程序等待多少s后再执行。
import time
print('程序开始了..')
time.sleep(3) # 睡3秒
print('程序结束了..')
'''
输出结果:
程序开始了..
（中间停顿了3s）
程序结束了..
'''
9.2时间戳
time.time()
时间戳表示的是从1970年1月1日00:00:00开始到现在的秒值。返回的是float类型。
import time
ret = time.time()
print(ret) # 1546946173.998187
9.3时间元组
time.localtime()
import time
ret = time.localtime()
print(ret)
'''time.struct_time(tm_year=2019, tm_mon=1, tm_mday=8, tm_hour=16, tm_min=48, tm_sec=19,
tm_wday=1, tm_yday=8, tm_isdst=0)
一周第几天（0为周一） 一年第几天 夏令时
'''
9.4时间字符串格式化
time.strftime('%Y-%m-%d %H:%M:%S')
import time
ret = time.strftime('%Y-%m-%d %H:%M:%S')
print(ret) # 2019-01-08 19:17:28
ret = time.strftime('%Y-%m-%d %X')
print(ret) # 2019-01-08 19:17:28
9.5 时间戳和时间元组之间的转换
（1） 时间戳转换为时间元组
time.gmtime() 返回的是UTC时间与北京时间少8小时。
UTC 协调世界时，又称世界统一时间，世界标准时间，国际协调时间，简称UTC。
ret = time.gmtime() # 把当前的时间戳转换为时间元组
print(ret) # 返回的是UTC时间与北京时间少8小时。
# time.struct_time(tm_year=2019, tm_mon=1, tm_mday=9, tm_hour=1, tm_min=26, tm_sec=18, tm_wday=2, tm_yday=9, tm_isdst=0)
Time.localtime()
ret = time.localtime(888888888) # 传递时间戳，将指定时间戳转化为时间元组
print(ret) # time.struct_time(tm_year=1998, tm_mon=3, tm_mday=3, tm_hour=9, tm_min=34, tm_sec=48, tm_wday=1, tm_yday=62, tm_isdst=0)
( 2)时间元组转换为时间戳
Time.mktime()
ret = time.localtime() # 当前时间元组
ts = time.mktime(ret) # 传递元组，转换为时间戳
print(ts) # 1546997715.0
9.6时间元组和格式化字符串之间的转换
时间元组转换为字符串
time.strftime("格式定义","结构化时间") 结构化时间参数若不传，则显示当前时间
ret = time.localtime(900000000) # 指定时间戳，转换为时间元组
ts = time.strftime('%Y-%m-%d %X',ret) # 将时间元组转换为字符串格式化
print(ts) # 1998-07-10 00:00:00
字符串转换为时间元组
time.strptime(时间字符串,字符串对应格式)
ret = time.strptime('2019-01-09','%Y-%m-%d') # 字符串转换为时间元组
print(ret) # time.struct_time(tm_year=2019, tm_mon=1, tm_mday=9, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=9, tm_isdst=-1)
9.7结构化时间 --> %a %b %d %H:%M:%S %Y时间串
time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
ret = time.asctime() # 美国时间
print(ret) # Wed Jan 9 09:48:51 2019
9.8时间戳 --> %a %b %d %H:%M:%S %Y时间串
time.ctime(时间戳) 如果不传参数，直接返回当前时间的格式化串
print(time.ctime()) # Wed Jan 9 18:04:01 2019
print(time.ctime(90000000)) # Wed Nov 8 00:00:00 1972
练习题:计算从出生到现在过了多少秒
import time
ret = time.time() # 时间戳表示的是从1970年1月1日00:00:00开始到现在的秒值
ret2 = time.strptime('1996-05-17','%Y-%m-%d')
ts = time.mktime(ret2)
print('我出生到现在活了',ret - ts,'秒' ) # 我出生到现在活了 714765906.9782751 秒
