Python学习日记（八）—— 模块一（sys、os、hashlib、random、time、RE）一、sys二、OS三、hashlib四、random五、time模块六、RE模块

模块，用一砣代码实现了某个功能的代码集合。 

类似于函数式编程和面向过程编程，函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。

如：os 是系统相关的模块；file是文件操作相关的模块

模块分为三种：

• 自定义模块
• 第三方模块
• 内置模块

使用模块

导入模块

Python之所以应用越来越广泛，在一定程度上也依赖于其为程序员提供了大量的模块以供使用，如果想要使用模块，则需要导入。导入模块有一下几种方法：

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

导入模块其实就是告诉Python解释器去解释那个py文件

• 导入一个py文件，解释器解释该py文件
• 导入一个包，解释器解释该包下的 __init__.py 文件 【py2.7】

那么问题来了，导入模块时是根据那个路径作为基准来进行的呢？即：sys.path

import sys
for i in sys.path:
print(i)
结果：
C:UsersSullivanPycharmProjectsq1day11
#pycharm自己添加的
C:UsersSullivanPycharmProjectsq1
#pycharm自己添加的
C:python36python36.zip
C:python36DLLs
C:python36lib
C:python36
C:python36libsite-packages

如果sys.path路径列表没有你想要的路径，可以通过 sys.path.append('路径') 添加。

import sys
sys.path.append("D:")
#把D盘当做路径

模块

内置模块是Python自带的功能，在使用内置模块相应的功能时，需要【先导入】再【使用】

一、sys

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

#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
错误相关

#argv
print(sys.argv)
结果:
C:UsersSullivanPycharmProjectsq1day10>python module-sys.py
['module-sys.py']
C:UsersSullivanPycharmProjectsq1day10>python module-sys.py 1 2
['module-sys.py', '1', '2']
#platform
print(sys.platform)
结果:
win32
#exit是可以打印东西的
#sys.exit("Goodbye!")
#往屏幕上打东西,和print不一样
sys.stdout.write("hello")
#不会自动换行,所以能在一行里显示
print("hello")
#会自动换行
sys.stdout.write("hello")
结果:
hellohello
#可以看到sys.stdout.write没有输出换行符,所以print输出的hello紧跟在后面
hello
#因为print输出hello后加了换行符,所以hello显示在了下一行

实例：带百分比的进度条

import sys,time
for i in range(31):
sys.stdout.write('r')
#每一次都会清空本行
sys.stdout.write("%s%% | %s" % (int(i/30*100) , int(i/30*100)*'*'))
sys.stdout.flush()
#强制刷新到屏幕
time.sleep(0.3)

二、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下为"rn",Linux下为"n"
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所指向的文件或者目录的最后修改时间

#stat
print(os.stat('joel'))
info = os.stat('joel')
#产看文件大小
print(info.st_size)
print(info.st_atime)
#最后一次访问的时间,显示的是时间戳
print(info.st_mtime)
#修改文件的时间
#system -- 输出shell命令,就不用调用控制台输入了
#print(os.system("dir"))
#路径拼接，很重要记得用
os.path.join([a,b])

三、hashlib

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

import hashlib
hash = hashlib.md5()
hash.update(bytes('123',encoding='utf-8'))
print(hash.hexdigest())
结果：
202cb962ac59075b964b07152d234b70

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密，俗称加盐。　　

import hashlib
hash = hashlib.md5(bytes('joel-love-ellie',encoding='utf-8'))
hash.update(bytes('123',encoding='utf-8'))
print(hash.hexdigest())
结果：
178172ac856c2dae457bdb731229d01c　

其它的加密算法

import hashlib
######## 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())

四、random

import random
print(random.random())
　
生成一个随机数 0-1之间的小数
print(random.randint(1, 2))
　　　
左边什么时候都包括,包括右边的值（2）
print(random.randrange(1, 10))
　　　
不包括右边的值（10）
print(random.choice('hello',))
从提供的字符串中随机取一个
print(random.choice(['ciri','ellie']))
随机取列表中的一个值

随机验证码

#方法一：
import random
def captcha_code():
code = ''
for i in range(6):
add = random.choice([random.randrange(10),chr(random.randrange(65,91))])
　　　　 #从随机的数字和字母中随机选一个
code = code + str(add)
print(code)
captcha_code()
#方法二：
import random
checkcode = ''
for i in range(4):
current = random.randrange(0,4)　　　　#当随机数和i的值相同时输出字母，不同时输出数字
if current != i:
temp = chr(random.randint(65,90))
else:
temp = random.randint(0,9)
checkcode += str(temp)
print checkcode

五、time模块

时间相关的操作，时间有三种表示方式：

• 时间戳               1970年1月1日之后的秒，即：time.time()
• 格式化的字符串    2014-11-11 11:11，    即：time.strftime('%Y-%m-%d')
• 结构化时间          元组包含了：年、日、星期等... time.struct_time    即：time.localtime()

print time.time()
print time.mktime(time.localtime())
print time.gmtime()
#可加时间戳参数
print time.localtime() #可加时间戳参数
print time.strptime('2014-11-11', '%Y-%m-%d')
print time.strftime('%Y-%m-%d') #默认当前时间
print time.strftime('%Y-%m-%d',time.localtime()) #默认当前时间
print time.asctime()
print time.asctime(time.localtime())
print time.ctime(time.time())
import datetime
'''
datetime.date：表示日期的类。常用的属性有year, month, day
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime：表示日期时间
datetime.timedelta：表示时间间隔，即两个时间点之间的长度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")
'''
import datetime
print datetime.datetime.now()
print datetime.datetime.now() - datetime.timedelta(days=5)　

%Y
Year with century as a decimal number.
%m
Month as a decimal number [01,12].
%d
Day of the month as a decimal number [01,31].
%H
Hour (24-hour clock) as a decimal number [00,23].
%M
Minute as a decimal number [00,59].
%S
Second as a decimal number [00,61].
%z
Time zone offset from UTC.
%a
Locale's abbreviated weekday name.
%A
Locale's full weekday name.
%b
Locale's abbreviated month name.
%B
Locale's full month name.
%c
Locale's appropriate date and time representation.
%I
Hour (12-hour clock) as a decimal number [01,12].
%p
Locale's equivalent of either AM or PM.

 

六、RE模块

什么是正则表达式（Regular Expression，简称RE）？

正则表达式 -- 本身就是一门语言(所以它也有自己的语法)，比较短小，在Python中，通过RE模块调用。

1、基础知识

元字符：   .   ^    $    *    +    ?    {}    []    |    ()    

	" . " -- 通配符,一个"."只能匹配一个字符
" ^ " -- 尖角符,开头匹配,控制开头(在字符集里还有个特殊的意义)
" $ " -- dollar符,末尾匹配,控制结尾
" * " -- 重复0到多次
" + " -- 重复1到多次
" ? " -- 重复0到1次
"{} " -- 想重复几次重复几次
"[] " -- 字符集,会取消元字符的特殊功能
" | " -- 管道符,或
"() " -- 做分组用的
"  " -- 反斜杠后面跟元字符,去除特殊功能
　　　　 　反斜杠后面跟普通字符实现特殊功能(只是一部分,并不是所有的)
　　　　　 引用序号对应的字组所匹配的字符串

反斜杠  "    "后面加普通字符实现的特殊功能

***大写的字母都表示 非 的意思***
d -- 匹配任何十进制数:它相当于类[0-9]
D -- 匹配任何非数字字符:它相当于类[^0-9]
s -- 匹配任何空白字符:它相当于类[ tnrfv]　　#有空格，最前面是个空格
S -- 匹配任何非空白字符:它相当于类[^ tnrfv] #有空格，尖角号后面是个空格
w -- 匹配任何字母数字字符:它相当于类[a-zA-Z0-9_]
W -- 匹配任何非字母数字字符:它相当于类[^a-zA-Z0-9_]
b -- 匹配一个单词边界（特殊边界）,也就是指单词和空格间的位置

2、re模块的内置功能

match　

# match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
match(pattern, string, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# falgs
： 匹配模式
X
VERBOSE
Ignore whitespace and comments for nicer looking RE's.
I
IGNORECASE
Perform case-insensitive matching.忽略大小写
M
MULTILINE
"^" matches the beginning of lines (after a newline)
as well as the string.
"$" matches the end of lines (before a newline) as well
as the end of the string.
S
DOTALL
"." matches any character at all, including the newline.
A
ASCII
For string patterns, make w, W, b, B, d, D
match the corresponding ASCII character categories
(rather than the whole Unicode categories, which is the
default).
For bytes patterns, this flag is the only available
behaviour and needn't be specified.
L
LOCALE
Make w, W, b, B, dependent on the current locale.
U
UNICODE
For compatibility only. Ignored for string patterns (it
is the default), and forbidden for bytes patterns.

为何要有分组？提取匹配成功的内容的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）

origin = "ciri prime deborah ellie joel"
# 无分组
r = re.match("cw+", origin)
print(r.group())
# 获取匹配到的所有结果
print(r.groups())
# 获取模型中匹配到的分组结果
print(r.groupdict())
# 获取模型中匹配到的分组结果
结果：
ciri
()
{}
# 有分组
r = re.match("(c)(w+)", origin)
print(r.group())
# 获取匹配到的所有结果
print(r.groups())
# 获取模型中匹配到的分组结果
print(r.groupdict())
# 获取模型中匹配到的分组中所有执行了key的组
结果：
ciri
#不管对于分组还是不分组,group没有区别,因为都是拿所有的内容
('c', 'iri')
#有几个括号放进几个到元组中
{}
r = re.match("(?P<n1>c)(w+)" , origin)
#?P<n1>给组起一个名
print(r.groupdict())
结果：
{'n1': 'c'}
　　

search

# search,浏览整个字符串去匹配第一个，未匹配成功返回None
# search(pattern, string, flags=0)

有分组&无分组　　

origin = "ciri prime deborah ellie joel"
# 无分组
r = re.search("cw+", origin)
print(r.group())
# 获取匹配到的所有结果
print(r.groups())
# 获取模型中匹配到的分组结果
print(r.groupdict())
# 获取模型中匹配到的分组结果
结果：
ciri
()
{}
# 有分组
r = re.search("(c)(w+)", origin)
print(r.group())
# 获取匹配到的所有结果
print(r.groups())
# 获取模型中匹配到的分组结果
print(r.groupdict())
# 获取模型中匹配到的分组中所有执行了key的组
结果：
ciri
('c', 'iri')
{}
r = re.search("(?P<n1>c)(w+)" , origin)
#?P<n1>给组起一个名
print(r.groupdict())
结果：
{'n1': 'c'} 

findall

# findall，获取非重复的匹配列表
#如果有一个组则以列表形式返回，且每一个匹配均是字符串
#如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖
# 空的匹配也会包含在结果中
#findall(pattern, string, flags=0)

有分组&无分组

origin = "ciri cirila prime deborah ellie joel"
#无分组
r = re.findall("cw+" , origin)
print(r)
结果：
['ciri', 'cirila']
#有分组
r = re.findall("(cw+)" , origin)
#和上面是相同的,和不加括号一样
print(r)
r = re.findall("c(w+)" , origin)
#这样findall里面就只有组里的东西
print(r)
r = re.findall("(c)(w+)" , origin)
print(r)
结果：
['ciri', 'cirila']
['iri', 'irila']
[('c', 'iri'), ('c', 'irila')]
#findall就是把groups里面所有的东西都放到列表中去

findal补充：

　　findall其实就是一个一个的search,然后把groups里的结果组合起来,以列表的形式

n = re.findall("d+wd+","a2b3c4d5")
print(n)
结果：
['2b3', '4d5']
#从输出结果可以看出,findall在匹配过程中找到了就从下一个开始继续匹配
n = re.findall('','ciri')
print(n)
结果：
['', '', '', '', '']
#多一个,因为末尾会有一个空值来进行匹配
n = re.findall('(w)(w)(w)(w)','ciri')
print(n)
结果：
[('c', 'i', 'r', 'i')]
n = re.findall('(w){4}','ciri')
print(n)
结果：
['i']
#匹配时还是会全部匹配，但是提取内容时,有4个分组,它不知道拿哪一个,默认就拿最后一个
#匹配是一回事,但分组(去匹配到的东西中取)就是有几个括号分几次组
n = re.findall('(w)*','ciri')
print(n)
结果：
['i', '']
#最后面还有一个什么都不是的,就由*为0时来匹配

sub

# sub，替换匹配成功的指定位置字符串
sub(pattern, repl, string, count=0, flags=0)
# pattern： 正则模型
# repl
： 要替换的字符串或可执行对象
# string ： 要匹配的字符串
# count
： 指定匹配个数
# flags
： 匹配模式

无分组

origin = "ciri ciri ciri prime deborah ellie joel"
r = re.sub("cw+" ,"666" , origin , 2)
print(r)
结果：
666 666 ciri prime deborah ellie joel　

split

# split，根据正则匹配分割字符串
split(pattern, string, maxsplit=0, flags=0)
# pattern： 正则模型
# string ： 要匹配的字符串
# maxsplit：指定分割个数
# flags
： 匹配模式

有分组&无分组

origin = "sulli ciri prime deborah ellie joel"
#无分组
r = re.split("ciri"
, origin , 1)
print(r)
结果：
['sulli ', ' prime deborah ellie joel']
#有分组
r = re.split("(ciri)"
, origin , 1)#会保留分组内的东西
print(r)
r = re.split("c(iri)"
, origin , 1)
print(r)
r = re.split("(ci(ri))"
, origin , 1)#有几个()输出几个
print(r)
结果：
['sulli ', 'ciri', ' prime deborah ellie joel']
['sulli ', 'iri', ' prime deborah ellie joel']
['sulli ', 'ciri', 'ri', ' prime deborah ellie joel']

IP：
^(25[0-5]|2[0-4]d|[0-1]?d?d)(.(25[0-5]|2[0-4]d|[0-1]?d?d)){3}$
手机号：
^1[3|4|5|8][0-9]d{8}$
邮箱：
[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(.[a-zA-Z0-9_-]+)+

未完待续。。。