Python：模块（一）

• 模块介绍

    把常用的一些功能单独放置到一个文件中，方便其他文件来调用，这样的一个文件可以称为一个模块。

模块分为三种：

1. 自定义模块
2. 内置标准模块（又称标准库）
3. 开源模块

导入模块：

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename 
from module.xx.xx import *　　　　　　

 

自定义模块：

自己定义一个模块命名demo。py：

在test.py中引入模块：

然后运行test.py，就会输出和demo.py同样的结果。

注：

只有在同一个文件夹中才能成功导入，如果想在所有文件夹中导入，需要获取模块路径再添加到库里面

import sys
print sys.path

#打印结果：D:myProgramPython35python.exe E:/Python-study/mdtest/demo.py

sys.path.append("E:/Python-study/mdtest/demo.py")
print(sys.path)
#打印结果：['E:\Python-study\mdtest', 'E:\Python-study', 'D:\myProgram\Python35\python35.zip', 'D:\myProgram\Python35\DLLs', 'D:\myProgram\Python35\lib', 'D:\myProgram\Python35', 'D:\myProgram\Python35\lib\site-packages', 'E:/Python-study/mdtest/demo.py']

此时已经将自定义模块添加到库当中，这样就可以在其他文件夹中成功导入：

from mdtest import demo

若要删除：

sys.path.remove("E:/Python-study/mdtest/demo.py")
print(sys.path)

或者直接将demo直接复制到自己的Python中：Python35Libsite-packages

site-packages：存放所有第三方安装的模块

内置标准模块：

• time模块

#导入time模块
import time

    .time（）：返回当前时间戳（时间戳指1970年1月1日之后的秒）

print(time.time())
#打印结果：1463641304.0342803

    .ctime（）：当前系统时间

print(time.ctime())
#打印结果：Thu May 19 15:08:30 2016


#当前时间减去一天的时间（一天=86400）
print(time.ctime(time.time()-86400))
#打印结果：Thu May 18 15:08:30 2016

    .gmtime（）：将当前时间戳转换成struct_time格式

print(time.gmtime())
#打印结果：time.struct_time(tm_year=2016, tm_mon=5, tm_mday=19, tm_hour=7, tm_min=12, tm_sec=36, tm_wday=3, tm_yday=140, tm_isdst=0
   

    .localtime（）：将当地时间转换成struct_time格式

print(time.localtime())
#打印结果：time.struct_time(tm_year=2016, tm_mon=5, tm_mday=19, tm_hour=15, tm_min=14, tm_sec=0, tm_wday=3, tm_yday=140, tm_isdst=0)

    .mktime（）：将struct_time格式转成当地时间戳格式

print(time.mktime(time.localtime()))
#打印结果：1463642192.0

    .sleep（）：延迟

print("计时5秒")
time.sleep(5)#延迟
print("计时结束")
#延时效果无法展示，只能自己动手操作

    .strftime（）：将struct_time格式转换成指定的字符串格式

print(time.strftime('%Y-%m-%d %H:%M:%S'))
#打印结果：2016-05-19 15:21:38


#将时间戳转换成指定的字符串格式
print(time.strftime('%Y-%m-%d %H:%M:%S',time.gmtime()))
#打印结果：2016-05-19 07:22:58


#将当地时间以struct_time格式转换成指定的字符串格式
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))
#打印结果：2016-05-19 15:23:13

    .strptime（）：将字符串格式转换成struct_time格式

print(time.strptime("2016-05-17","%Y-%m-%d")
#打印结果：time.struct_time(tm_year=2016, tm_mon=5, tm_mday=17, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=138, tm_isdst=-1) time.struct_time(tm_year=2016, tm_mon=5, tm_mday=19, tm_hour=7, tm_min=32, tm_sec=30, tm_wday=3, tm_yday=140, tm_isdst=0)

• datetime模块

datetime的分类：

datetime.date : 表示日期的类（year,month,day）

datetime.time : 表示时间的类（hour,minute,second,microsecond）

datetime.datetime : 表示日期时间

datetime.timedelta：表示时间间隔

#导入datetime模块
import datetime

   

    .date.today（）：当天时间，格式：2016-05-19

print(datetime.date.today())
#打印结果：2016-05-19

    .date.formtimestamp（）：将当前系统时间（时间戳）以日期格式呈现

print(datetime.date.fromtimestamp(time.time()))
#打印结果：2016-05-19

    .datetime.now（）：当前日期时间

ret_time = datetime.datetime.now()
print(ret_time) #输出字符串形式的当前时间
print(ret_time.timetuple()) #返回struct_time格式
print(ret_time.replace(2014,10,1))#替换日期
#打印结果：
2016-05-19 16:22:23.804101
time.struct_time(tm_year=2016, tm_mon=5, tm_mday=19, tm_hour=16, tm_min=22, tm_sec=23, tm_wday=3, tm_yday=140, tm_isdst=-1)
2014-10-01 16:22:23.804101

    .datetime.strptime（）：将字符串转换成日期时间格式

str_to_date = datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
print(str_to_date)
#打印结果：2006-11-21 16:30:00

   

    .datetime.timedelta（）：取时间长度

#在当前时间基础上增加10天
new_date = datetime.datetime.now() + datetime.timedelta(days=10)
print(new_date)
#打印结果：2016-05-29 16:31:00.617860

#减去10天：datetime.timedelta(days=-10)
#减去10小时：datetime.timedelta(hours=-10)
#减去10秒：datetime.timedelta(seconds=-10)

• sys模块

用于提供对Python解释器相关的操作：

sys.argv           #命令行参数List，第一个元素是程序本身路径
sys.exit(n)        #退出程序，正常退出时exit(0)
sys.version        #获取Python解释程序的版本信息
sys.maxint         #最大的Int值
sys.path           #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       #返回操作系统平台名称
sys.stdin          #输入相关
sys.stdout         #输出相关
sys.stderror       #错误相关

常用函数：

返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值：sys.path()

import sys
import time
for i in range(31):
    sys.stdout.write("
")
    sys.stdout.write("%s%% | %s" % (int(i/30*100),int(i/30*100)*'*'))
    sys.stdout.flush()
    time.sleep(0.1)

• os模块

用于提供系统级别的操作：

import os

os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd
os.curdir                   返回当前目录: ('.')
os.pardir                   获取当前目录的父目录字符串名：('..')
os.makedirs('dir1/dir2')    可生成多层递归目录
os.removedirs('dirname1')   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')         生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                 删除一个文件
os.rename("oldname","new")  重命名文件/目录
os.stat('path/filename')    获取文件/目录信息
os.sep                      操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep                  当前平台使用的行终止符，win下为"	
",Linux下为"
"
os.pathsep                  用于分割文件路径的字符串
os.name                     字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")   运行shell命令，直接显示
os.environ                  获取系统环境变量
os.path.abspath(path)       返回path规范化的绝对路径
os.path.split(path)         将path分割成目录和文件名二元组返回
os.path.dirname(path)       返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)      返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)        如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)         如果path是绝对路径，返回True
os.path.isfile(path)        如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)         如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间

常用函数：

获取文件/目录信息：os.stat('path/filename')

import os
r = os.stat("E:\Python-study")
print(r)
#打印结果：os.stat_result(st_mode=16895, st_ino=1688849860274247, st_dev=1816702834, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1464095097, st_mtime=1464095097, st_ctime=1464094748)

r = os.stat("E:\Python-study")
print(r.st_size)
#打印结果：0

返回path的目录。其实就是os.path.split(path)的第一个元素：os.path.dirname(path)

如果path存在，返回True；如果path不存在，返回False：os.path.exists(path)

将多个路径组合后返回，第一个绝对路径之前的参数将被忽略：os.path.join(path1[,path2[,...]])

• hashlib模块

用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

import hashlib
 
# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
print(hash.digest())
 
 
######## sha1 ########
 
hash = hashlib.sha1()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha256 ########
 
hash = hashlib.sha256()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
 
# ######## sha384 ########
 
hash = hashlib.sha384()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())
 
# ######## sha512 ########
 
hash = hashlib.sha512()
hash.update(bytes('admin', encoding='utf-8'))
print(hash.hexdigest())

以上加密算法虽然已经很厉害，但还是存在缺陷，通过撞库可以反解。所以，有需要对加密算法中添加自定义key再进行加密。

import hashlib
hash = hashlib.md5(bytes("jiami",encoding="utf-8"))
hash.update(bytes("3.1415926",encoding="utf-8"))
print(hash.hexdigest())

练习：

def md5(arg):
    ooo = hashlib.md5(bytes("jiami",encoding="utf-8"))
    ooo.update(bytes(arg,encoding="utf-8"))
    return ooo.hexdigest()
def login(user,pwd):
    with open("db","r",encoding="utf-8") as f:
        for line in f:
            u,p = line.strip().split("|")
            if u == user and p == md5(pwd):
                return True
def refister(user,pwd):
    with open("db","a",encoding="utf-8") as f:
        temp = user + "|" + md5(pwd)
        f.write(temp)

i = input("1,登录；2，注册")
if i == "2":
    user = input("用户名:")
    pwd = input("密码:")
    refister(user,pwd)
elif i== "1":
    user = input("用户名:")
    pwd = input("密码:")
    r = login(user,pwd)
    if r:
        print("登录成功")
    else:
        print("登录失败")

•  序列化

Python中用于序列化的两个模块

• json　　跨平台或跨语言的数据交互
• pickle　　仅限Python之间的数据交互

• pickle模块

pickle模块提供了四个功能：dumps、dump、loads、load

pickle.dumps（obj）: 把任意对象序列化成一个str，然后把这个str写入文件

pickle.loads（string）: 反序列化出对象

pickle.dump（obj,file）：直接把对象序列化后写入文件

pickle.load（file）：从文件中反序列化出对象

购物练习：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pickle
accounts = {
    1000: {
        'name':'USERA',
        'email': 'lijie3721@126.com',
        'passwd': 'abc123',
        'balance': 15000,
        'phone': 13651054608,
        'bank_acc':{
            'ICBC':14324234,
            'CBC' : 235234,
            'ABC' : 35235423
        }
    },
    1001: {
        'name': 'USERB',
        'email': 'caixin@126.com',
        'passwd': 'abc145323',
        'balance': -15000,
        'phone': 1345635345,
        'bank_acc': {
            'ICBC': 4334343,
        }
    },
}
#把字典类型写入到文件中
f = open('accounts.db','wb')
f.write(pickle.dumps(accounts))
f.close()

#2，反序列出对象并修改其内容，并将修改内容重新写入文件
file_name = "accounts.db"
f = open(file_name,'rb')
account_dic = pickle.loads(f.read())
f.close()

account_dic[1000]['balance'] -= 500
f = open(file_name,'wb')
f.write(pickle.dumps(account_dic))
f.close()


#3,反序列化对象并查看其内容

f = open('accounts.db','rb')
acountdb = pickle.loads(f.read())
print(acountdb)

dic = {
    'k1': [1,2],
    'k2': [3,4]
}
#1.将对象写入文件
f = open('test','wb')
pickle.dump(dic,f)
f.close()
#2.将文件中内容反序列化，并读出
f = open('test','rb')
dic2 = pickle.load(f)
print(dic2)
f.close()

•  json模块

json模块提供了四个功能：dumps、dump、loads、load

json.dumps（obj）: 将数据通过特殊的形式转换为所有程序语言都认识的字符串

json.loads（string）: 反序列化出对象

json.dump（obj,file）：将数据通过特殊形式转换为所有成语语言都认识的字符串，写入文件

json.load（file）：从文件中反序列化出对象

import json

s = '{"k1":1,"k2":2}'
result = json.loads(s)
print(result,type(result))
#打印结果：{'k2': 2, 'k1': 1} <class 'dict'>

li = "[1,2,3,4]"
result = json.loads(li)
print(result,type(result))
#打印结果：[1, 2, 3, 4] <class 'list'>

s = ["alex","eric","rain"]
result = json.dumps(s)
print(result,type(result))
#打印结果：["alex", "eric", "rain"] <class 'str'>