09-Python模块

导入模块

• 通过import导入模块

import time         #导入模块time
time.sleep(50)      #睡眠50s

• 导入模块并重命名

import time as t   #导入模块time重命名为t
t.sleep(50)        #睡眠50s

• 导入模块中部分内容

from time import sleep,time  #只导入sleep和time函数
sleep(50)          #睡眠50s

• 导入模块所有内容

from time import *     #导入所有函数
time.sleep(50)         #睡眠50s

---

自定义模块

1. 创建模块myModule

1. 编辑模块myModule

def show():
    print("我是自定义模块myModule")

1. 导入模块myModule

import myModule
myModule.show()     #输出：我是自定义模块myModule

---

包

• 包中含有多个模块，我们使用包来管理多个自定义模块
• 包中需要有一个空文件__init__.py，Python就会将这个目录解析为包。

1. 创建包和模块

1. 编辑模块myModule

def show():
    print("我是自定义模块myModule")

1. 导入模块myModule

from myPackage import myModule      #从myPackage包中导入模块myModule

---

__name__属性

模块实际上就是一个普通的python文件，只不过从其他文件开始运行而已

模块myModule：

def show():
    print("我是自定义模块myModule")
print(123)

主程序:

import myModule     #输出：123

解释：

• 因为导入了模块myModule，所以会运行此模块，所以会输出123

如果不想运行模块中的部分代码，可以使用__name__属性

模块myModule.py：

def show():
    print("我是自定义模块myModule")
if __name__ == '__main__':
    print("我是主程序")

主程序main.py：

import myModule

结果：

• 运行main.py时 =======> 无任何输出
• 运行myModule.py时 ===> 输出：我是主程序

---

time模块

导入模块：

time.sleep(50)        #睡眠50s

常用函数：

t = time.time()       #返回当前的时间戳(自1970年1月1日8:00到现在的秒数)
t = time.ctime()      #返回系统定义好的时间格式
t = time.gmtime()     #返回时间对象(UTC时间)，tm_wday的0表示周一
t = time.localtime()  #返回时间对象(当地时间)，tm_wday的0表示周一
t = time.mktime(<struct_time>)   #通过时间对象返回时间戳
s = time.strftime(“%Y-%m-%d  %H:%M:%S”,<struct_time>)  #根据时间对象返回自定义格式(str类型)
t = time.strptime(“2018-10-08 21:55:01”,“%Y-%m-%d  %H:%M:%S”) #根据自定义格式转化为时间对象
							      #参数2用于解析时间的格式

时间类

• 时间对象是类time.struct_time创建的对象

import time
t = time.localtime()  #返回时间对象(当地时间)

时间对象t的数据成员：

tm_year=2020	#年
tm_mon=6        #月
tm_mday=5       #日
tm_hour=11      #时
tm_min=0        #分
tm_sec=0        #秒
tm_wday=4       #星期
tm_yday=157     #一年中第几天

自定义时间格式

import time
t = time.localtime()  #返回时间对象(当地时间)
s = time.strftime("%Y-%m-%d  %H:%M:%S",t)
print(s)    #输出：2020-06-05  11:07:56

解释：

• strftime函数将时间对象转化为自定义格式的时间(str格式)
• %Y等为占位符

常用占位符：

%Y	#年(4位数)
%y	#年(2位数)
%m	#月
%d	#日
%H	#时
%M	#分
%S	#秒

---

datetime模块

datetime也是一个比较常用的时间模块，与time模块类似

import datetime
print(datetime.datetime.now()) #返回系统定义的格式化时间

---

getpass模块

此模块用于登录，如输入密码时可以将密码隐藏。

import getpass
passwd=getpass.getpass("请输入密码:")   #在终端上运行才可以隐藏输入密码
print(passwd)

注意： 需要打开终端运行此代码！才会又正确的现象。

---

math模块

导入模块：

import math

常用函数：

math.sqrt(4)    #求平方根
math.log(1,2)   #求以 2 为底的 1 的对数
math.log10(1)   #求以 10 为底 1 的对数
math.sin(10)
math.cos(10)
math.tan(10)
math.pi         #3.141592653589793
math.e          #自然对数的底

---

cmath模块

导入cmath模块：

import cmath

• cmath与math类似，但cmath的计算结果为复数。
• 若希望得到的结果不是复数，可用abs()求模。

示例：

import cmath
num = cmath.sqrt(4)    #求平方根
print( num )      #输出：(2+0j)
print( abs(num) ) #输出：2.0

---

random模块

导入random模块：

import random

常用函数：

random.random()           #返回(0到1)的随机小数
random.randint(1,6)       #返回[0,6]的随机整数
random.randrange(1,6)     #返回[0,6)的随机整数
random.choice("hello")    #返回随机一个字母，参数可以是一个列表
random.sample("hello",2)  #随机返回两个元素，参数可以是一个列表

---

hashlib模块

通过hashlib可以通过不同的算法产生字符串的散列值

导入hashlib模块：

import hashlib

示例：

import hashlib
m=hashlib.md5()        #使用md5进行加密，加密算法可以换(如sha256等)
m.update('hello'.encode('utf8'))   #产生字符串'hello'的散列值
print(m.hexdigest())   #输出散列值
m.update('88888'.encode('utf-8'))  #此时的散列值与之前的有关("hello88888")

解释：

• 上例用的是md5算法，可根据情况选择合适的算法。

---

sys模块

这个模块与Python解释器相关

导入sys模块：

import sys

常用函数：

sys.argv       #返回参数列表，第一个元素为脚本文件名
sys.exit(0)    #退出程序，0为正常退出
sys.version    #返回解释器的版本信息
sys.maxint     #返回最大整数值(Python2)
sys.maxsize    #返回最大整数值(Python3)
sys.platform   #返回操作系统平台名称，win为win32，linux返回linux

---

os模块

这个模块与操作系统交互

导入os模块：

import os

执行命令-system函数：

import os
os.system("ls -l") #运行命令,最后返回0则执行成功

执行命令-popen函数：

import os
ret=os.popen("dir")   #返回一个管道对象
print(ret.read())     #得到命令的输出结果
ret.close()           #使用完关闭

常用函数

import os
os.getcwd()             # 返回当前工作目录
os.chdir("E:\MyFiles")  # 转移工作目录
os.curdir               # 返回.
os.pardir               # 返回..
os.mkdir("Myfiles")     # 创建一个文件夹
os.makedirs('abc\\def') # 连续创建多层目录
os.remove("1.txt")      # 删除一个文件
os.rmdir("Myfiles")     # 删除一个文件夹
os.removedirs('1\\2\\3')  # 连续删除多层空目录(非空则不删)
os.listdir("Myfiles")   # 返回一个列表，包含目录中所有文件个子目录
os.rename(src, dst)     # 将src重命名为dst
os.stat("相册.zip")     # 返回一个包含文件信息的元组
os.sep      # 返回路径分隔符，win为\,linux为/
os.linesep  # 返回行分隔符，win为\r\n,linux为\n
os.pathsep  # 返回路径分隔符，win为;,linux为:
os.name     # 返回当前平台，win为nt,linux为posix
os.environ  # 返回一个包含系统环境变量的字典

os.path.abspath(path)   #返回绝对路径
os.path.split(path)     #将路径拆成目录和文件名的二元组返回
os.path.dirname(path)   #返回path的目录,机械化地返回(若path为相对路径，则返回"")
os.path.basename(path)  #返回路径最后的文件夹名或文件名(机械化地返回)
os.path.exists(path)    #判断path是否存在
os.path.isabs(path)     #判断path是否为绝对路径
os.path.isfile(path)    #判断path是否为一个存在的文件
os.path.isdir(path)     #判断path是否为一个存在的文件夹
os.path.getatime(path)  #返回path最后存取时间
os.path.getmtime(path)  #返回path最后修改时间

---

re模块-正则表达式

re模块利用正则表达式来匹配字符串

正则表达式

.		#匹配除换行外任一字符
+		#匹配1到多个字符
*		#匹配0到多个字符
?		#匹配0或1个字符
^		#只在开头匹配("^hello")
$		#只在结尾匹配("hello$")
|		#或(比如com|cn匹配com或者cn)

{}
	{5}     #匹配5次
	{1,3}	#匹配1到3次

[]
	[c,d]		#匹配c或d
	[a-zA-Z]	#匹配所有字母
	[^0-9]		#匹配所有非数字

()
	((as)+)		#分组

\d	#匹配所有数字
\D	#匹配所有非数字
\s	#匹配所有空白字符
\S	#匹配所有非空白字符
\w	#匹配所有数字和字母
\W	#匹配所有非数字和字母字符
\\\\	#匹配\

注意：

• 匹配反斜杠本身时，需要经过两次转义。
• \\\\向解释器转义得\\，再向re转义得到\
• 在字符串前加r则取消转义。

示例：

文本：hello world		想匹配出world		可以用正则表达式：w..l
文本：abcaaa			想匹配出a和aaa		可以用正则表达式：a+
文本：r"a\b"			想匹配出'a\b'		可以用正则表达式："a\\\\b"
文本：aabc1111abc222aaabc	想匹配出'abc'、'aabc' ...	可以用正则表达式：a+bc

使用re模块

导入re模块:

import re

findall():

ret=re.findall("w..l","hello world")    #返回一个列表(包含所有匹配项)

search()：

ret=re.search("hello","hello,world")    #搜索第一个满足项，返回一个对象
ret.group()       #返回匹配项

split():

ret = re.split("a","1a2a3a")          #用符号'a'分割字符串(返回一个列表)
ret = re.split("[2,a]","1a2a3a")      #先用符号'2'分割,再用符号'a'分割

match()：

ret=re.match("hello","hello,world")    #只在开头搜索，并且搜索第一个满足项，返回一个对象
ret.group()       #返回匹配项

sub()：

ret=re.sub("4+","5","4444abc44abc")    #把4+换成5(结果为'5abc5abc')
给匹配项命名：
ret=re.search("(?P<year>\d{4})-(?P<month>\d{2})","sf1998-12-16")    #给匹配项命名
print(ret.group())       #输出全部匹配项(1998-12)
print(ret.group('year'))   #输出year(1998)

解释：

• ?P表示对此匹配项命名
• 每一个匹配项用小括号( )包裹
• 其中，(?P\d{4})表示正则为\d{4}，名字为year

compile()：

ret1=re.compile("4+")
ret2=ret1.findall("hello44，abc444")
print(ret2)     #得到 ['44', '444']

解释：

• 先定义好正则表达式，再进行匹配。
• 此正则表达式可以多次使用。

---

最后

本文所总结的模块都是常用的，还存在许许多多其他的函数供我们调用，具体可以查看文档。
模块是Python强大的部分之一，需要好好学习。