python模块_Python常用模块

andom模块

datetime模块
time模块
os模块
sys模块
hashilib模块
序列化-json模块
序列化-pickle模块
正则表达式
re模块

paramiko

logging模块
模块和包

模块其实就是我们把一些公用的功能代码写入在一个py文件中. 在其他模块中可以随意的使用该文件中的代码. 那么导入一个模块的语法

1. import 模块

2. from 模块 import 功能

本节我们主要是学习和了解一些python的内置模块的使用

1. random

python中专门用来产生随机数的一个模块

import 

2. datetime

在后期我们处理时间的时候会经常使用datetime来处理.

from datetime import datetime

# # 当前系统时间
# d = datetime.now()
# print(d)
#
# # 格林尼治时间, 和我们相差8小时
# d1 = datetime.utcnow()
# print(d1)
#
# # 用指定的时间创建datetime
# d2 = datetime(2015, 6, 5, 12, 11, 8, 3553)
# print(d2)


# 时间格式化
# d = datetime.now()
# s = d.strftime("%Y-%m-%d %H:%M:%S")
# print(s)

# 字符串转化成时间
str_date = input("请输入一个时间(格式 yyyy-mm-dd HH:MM:SS):")
d = datetime.strptime(str_date, "%Y-%m-%d %H:%M:%S")
print(d)
print(type(d))

# 计算时间差
d1 = datetime(2019, 1, 2, 11, 0, 0)
d2 = datetime(2019, 1, 1, 12, 3, 0)
diff = d2 - d1
print(diff.seconds)  # 单纯从时分秒来计算
print(diff.total_seconds())  # 包括年月日计算

3. time模块

我们一般会使用time模块让程序休息n秒. 或者计算简单的时间差

import time

print(1)
time.sleep(3)  # 让程序睡3秒
print(2)


# 简单的计算时间差
a = time.time()  # 当前系统时间, 从1970年1月1日0点0分0秒开始到现在经过了多少秒
time.sleep(2)
b = time.time()  # 当前系统时间, 从1970年1月1日0点0分0秒开始到现在经过了多少秒

print(b - a)

日期格式化的标准:

%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 当前时区的名称
%% %号本身

4. os模块

os模块主要封装了关于操作系统文件系统的相关操作. 比如. 创建文件夹, 删除文件夹等

所有和操作系统相关的内容都在os模块
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录

os.system("bash command")  运行shell命令，直接显示
os.popen("bash command").read()  运行shell命令，获取执行结果
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

# os.path
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.path.getsize(path) 返回path的大小

# 特殊属性:
os.sep    输出操作系统特定的路径分隔符，win下为"",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"rn",Linux下为"n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

用os.walk遍历文件夹

import os

for root, dirs, fils in os.walk("."):
    for dir in dirs:
        print(os.path.join(root, dir))
    for f in fils:
        print(os.path.join(root, f))

用递归遍历文件夹

def func(path):
    lst = os.listdir(path)
    for f_name in lst:
        new_path = os.path.join(path, f_name)
        if os.path.isdir(new_path):
            func(new_path)
        else:
            print(new_path)

func("./")

5. sys模块

所有和python解释器相关的都在sys模块.

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

6. hashlib模块

MD5是一种不可逆的加密算法. 它是可靠的. 并且安全的. 在python中我们不需要手写这一套算法. 只需要引入一个叫hashlib的模块就能搞定MD5的加密工作

import hashlib
obj = hashlib.md5()
obj.update("jolin".encode("utf-8"))  # 加密的必须是字节
miwen = obj.hexdigest()
print(miwen)    # 13308dd423cebfea676b4f4aa5dc9d77

那这样的密文安全么? 其实是不安全的. 当我们用这样的密文去找一个所谓的MD5解密工具. 是有可能解密成功的.

这就尴尬了. MD5不是不可逆么? 注意. 这里有一个叫撞库的问题. 就是. 由于MD5的原始算法已经存在很久了. 那就有一些人用一些简单的排列组合来计算MD5. 然后当出现相同的MD5密文的时候就很容易反推出原来的数据是什么. 所以并不是MD5可逆, 而是有些别有用心的人把MD5的常见数据已经算完并保留起来了.

那如何应对呢? 加盐就行了. 在使用MD5的时候. 给函数的参数传递一个byte即可.

import hashlib

obj = hashlib.md5(b"fjlksajflkjasfsalwer123dfskjf")    # 加盐
obj.update("jolin".encode("utf-8"))  # 加密的必须是字节
miwen = obj.hexdigest()
print(miwen)    # 8a6564795f20e0e446049b0fba6222de

此时你再去任何网站去试. 累死他也解不开密.

那MD5如何应用呢?

import hashlib

def my_md5(s):
    obj = hashlib.md5(b"fjlksajflkjasfsalwer123dfskjf")
    obj.update(s.encode("utf-8"))  # 加密的必须是字节
    miwen = obj.hexdigest()
    return miwen

# alex: 8a6564795f20e0e446049b0fba6222de
username = input("请输入用户名:")
password = input("请输入密码:")
# 数据存储的时候.
# username: my_md5(password)
# 假设现在的用户名和密码分别是
# admin: 8a6564795f20e0e446049b0fba6222de  ==> admin:jolin

# 用户登录
if username == "admin" and my_md5(password) == "8a6564795f20e0e446049b0fba6222de":
    print("成功")
else:
    print("失败")

所以. 以后存密码就不要存明文了. 要存密文. 安全, 并且. 这里加的盐不能改来改去的. 否则, 整套密码就都乱了.

7. pickle模块

pickle用起来很简单. 说白了. 就是把我们的python对象写入到文件中的一种解决方案. 但是写入到文件的是bytes. 所以这东西不是给人看的. 是给机器看的.

把python对象转化成字节的过程被称为序列化

import pickle

lst = ["周润发", "李嘉诚"]

# 把一个对象(数据)转化成字节
bs = pickle.dumps(lst)  
print(bs)
# 把一个数据转化成字节, 写入到文件
pickle.dump(lst, open("lst.dat", mode="wb"))  

我们还可以从文件中读取二进制字节, 转化回我们原来的数据, 该过程被称为反序列化

# 把一个文件中的二进制字节转化回我们的数据
lst = pickle.load(open("lst.dat", mode="rb"))  
print(lst)

bs = b'x80x03]qx00(Xtx00x00x00xe5x91xa8xe6xb6xa6xe5x8fx91qx01Xtx00x00x00xe6x9dx8exe5x98x89xe8xafx9aqx02e.'
lst = pickle.loads(bs)  # 把一个文件中的二进制字节转化回我们的数据
print(lst)

8. json模块

终于到json了. json是我们前后端交互的枢纽. 相当于编程界的普通话. 大家沟通都用json. 为什么这样呢? 因为json的语法格式可以完美的表示出一个对象. 那什么是json: json全称javascript object notation. 翻译过来叫js对象简谱. 很复杂是吧? 来上一段我们认识的代码:

wf = {
    "name":"汪峰",
    "age":18,
    "hobby":"上头条",
    "wife":{
        "name":'子怡',
        "age":19,
        "hobby":["唱歌", "跳舞", "演戏"]
    }
}

这个不是字典么? 对的. 在python里这玩意叫字典. 但是在javascript里这东西叫json. 一模一样的. 我们发现用这样的数据结构可以完美的表示出任何对象. 并且可以完整的把对象表示出来. 只要代码格式比较好. 那可读性也是很强的. 所以大家公认用这样一种数据结构作为数据交互的格式. 那在这个鬼东西之前是什么呢? XML.....来看一段代码

    汪峰
    18
    上头条
    
        子怡
        18
        
            唱歌
            跳舞
            演戏
        
    

古人(老程序员)都是用这样的数据进行传输的. 先不管这个东西好不好看. 这玩意想要解析.. 那简直了. 想死的心都有. 所以老版本的xml在维护和处理上是非常复杂和繁琐的. 多说一嘴, 就是因为这个鬼东西太难解析. 以前的项目几乎没有用ajax的.

OK. 那json既然这么牛B好用. 怎么用呢? 注意. 这里又出来一个新问题. 我们的程序是在python里写的. 但是前端是在JS那边来解析json的. 所以. 我们需要把我们程序产生的字典转化成json格式的json串(字符串). 然后网络传输. 那边接收到了之后. 它爱怎么处理是它的事情. 那, 如何把字典转化成我们的json格式的字符串呢?很简单, 上代码.

import json
dic = {"a": "女王", "b": "萝莉", "c": "小清新"}
s = json.dumps(dic) # 把字典转化成json字符串
print(s)  # {"a": "u5973u738b", "b": "u841du8389", "c": "u5c0fu6e05u65b0"}

结果很不友好啊. 那如何处理中文呢? 在dumps的时候给出另一个参数ensure_ascii=False就可以了

import json
dic = {"a": "女王", "b": "萝莉", "c": "小清新"}
s = json.dumps(dic, ensure_ascii=False) # 把字典转化成json字符串
print(s)  # {"a": "女王", "b": "萝莉", "c": "小清新"}

搞定了. 接下来. 前端给你传递信息了. 你要把前端传递过来的json字符串转化成字典.

import json

s = '{"a": "女王", "b": "萝莉", "c": "小清新"}'
dic = json.loads(s)
print(type(dic), dic)

json也可以像pickle一样把序列化的结果写入到文件中.

dic = {"a": "女王", "b": "萝莉", "c": "小清新"}
f = open("test.json", mode="w", encoding="utf-8")
json.dump(dic, f, ensure_ascii=False) # 把对象打散成json写入到文件中
f.close()

同样也可以从文件中读取一个json

f = open("test.json", mode="r", encoding="utf-8")
dic = json.load(f)
f.close()
print(dic)

9. 正则表达式

首先, 我们在网页上进行注册或者登陆的时候经常能看到一些格式上的错误提示. 比如: 你在注册百度账号的时候https://passport.baidu.com/v2/?reg®Type=1&tpl=wk 输入用户名随意的输入系统会提示你. 你的账号过长或者不允许使用中文等等操作. 那这种操作如果使用我们现有的知识点是可以完成的. 但是完成的效果并不好. 写起来也不容易. 尤其是对邮箱的匹配. 电话号码的匹配. 那正则表达式就是专门来处理类似问题的一种表达式. 英文全称:Regular Expression. 简称 regex或者re. 但你要知道我们在使用python的re模块之前. 我们首先要对正则有一定的了解和认识. 就像我们使用time模块之前. 我们已经对时间有了一定的认识.

正则表达式是对字符串操作的一种逻辑公式. 我们一般使用正则表达式对字符串进行匹配和过滤. 使用正则的优缺点:

优点: 灵活, 功能性强, 逻辑性强.

缺点: 上手难. 一旦上手, 会爱上这个东西

工具: 各大文本编辑器一般都有正则匹配功能. 我们也可以去http://tool.chinaz.com/regex/进行在线测试.

正则表达式由普通字符和元字符组成. 普通字符包含大小写字母, 数字. 在匹配普通字符的时候我们直接写就可以了. 比如"abc" 匹配的就是"abc". 我们如果用python也可以实现相同的效果. 所以普通字符没什么好说的. 重点在元字符上.

元字符: 元字符才是正则表达式的灵魂. 元字符中的内容太多了, 在这里我们只介绍一些常用的.

1. 字符组

字符组很简单用[]括起来. 在[]中出现的内容会被匹配. 例如:[abc] 匹配a或b或c

如果字符组中的内容过多还可以使用- , 例如: [a-z] 匹配a到z之间的所有字母 [0-9]匹配所有阿拉伯数字

思考: [a-zA-Z0-9]匹配的是什么?

2. 简单元字符

基本的元字符. 这个东西网上一搜一大堆. 但是常用的就那么几个:

.     匹配除换行符以外的任意字符
w    匹配字母或数字或下划线
s    匹配任意的空白符
d    匹配数字
n    匹配一个换行符
t    匹配一个制表符
b    匹配一个单词的结尾
^     匹配字符串的开始
$     匹配字符串的结尾
W    匹配非字母或数字或下划线
D    匹配非数字
S    匹配非空白符
a|b   匹配字符a或字符b
()    匹配括号内的表达式，也表示一个组
[...]    匹配字符组中的字符
[^...]    匹配除了字符组中字符的所有字符

3. 量词

我们到目前匹配的所有内容都是单一文字符号. 那如何一次性匹配很多个字符呢, 我们要用到量词

*    重复零次或更多次
+    重复一次或更多次
?    重复零次或一次
{n}    重复n次
{n,}    重复n次或更多次
{n,m}    重复n到m次

4. 惰性匹配和贪婪匹配

在量词中的?,*, +,{} 都属于贪婪匹配. 就是尽可能多的匹配到结果.

str: 麻花藤昨天让英雄联盟关服了
reg: 麻花藤.* 

此时匹配的是整句话

在使用.*后面如果加了? 则是尽可能的少匹配. 表示惰性匹配

str: 麻花藤昨天让英雄联盟关服了
reg: 麻花藤.*?

此时匹配的是 麻花藤

str: 
胡辣汤
reg: <.*>
结果: 
胡辣汤


str: 
胡辣汤
reg: <.*?>
结果: 
    

    

str: 
胡辣汤
reg: <(div|/div*)?>
结果:
    

    

.*?x的特殊含义 找到下一个x为止.

str: abcdefgxhijklmn
reg: .*?x
结果:abcdefgx

5. 分组

在正则中使用()进行分组. 比如. 我们要匹配一个相对复杂的身份证号. 身份证号分成两种. 老的身份证号有15位. 新的身份证号有18位. 并且新的身份证号结尾有可能是x.

^[1-9]d{13,16}[0-9x]$
^[1-9]d{14}(d{2}[0-9x])?$
^([1-9]d{16}[0-9x]|[1-9]d{14})$

6. 转义

在正则表达式中, 有很多有特殊意义的是元字符, 比如n和s等,如果要在正则中匹配正常的"n"而不是"换行符"就需要对""进行转义, 变成''.在python中, 无论是正则表达式, 还是待匹配的内容, 都是以字符串的形式出现的, 在字符串中也有特殊的含义, 本身还需要转义. 所以如果匹配一次"n", 字符串中要写成'n', 那么正则里就要写成"n",这样就太麻烦了. 这个时候我们就用到了r' '这个概念, 此时的正则是r'n'就可以了. 记住, 在python中写正则的时候前面带着r

10. re模块

re模块是python提供的一套关于处理正则表达式的模块. 核心功能有四个:

1. findall 查找所有. 返回list

lst = re.findall("m", "mai le fo len, mai ni mei!")
print(lst)     # ['m', 'm', 'm']

lst = re.findall(r"d+", "5点之前. 你要给我5000万")
print(lst)     # ['5', '5000']

2. search 会进行匹配. 但是如果匹配到了第一个结果. 就会返回这个结果. 如果匹配不上search返回的则是None

ret = re.search(r'd', '5点之前. 你要给我5000万').group()
print(ret) # 5

3. match 只能从字符串的开头进行匹配

ret = re.match('a', 'abc').group()  
print(ret)     # a

4. finditer 和findall差不多. 只不过这时返回的是迭代器

it = re.finditer("m", "mai le fo len, mai ni mei!")

for el in it:
    print(el.group()) # 依然需要分组

5. 其他操作

ret = re.split('[ab]', 'qwerafjbcd')  # 先按'a'分割得到'qwer'和'fjbcd',在对'qwer'和'fjbcd'分别按'b'分割
print(ret)  # ['qwer', 'fj', 'cd']

ret = re.sub(r"d+", "_sb_", "jolin250tory250tony250kevin38") # 把字符串中的数字换成__sb__
print(ret)    # jolin_sb_tory_sb_tony_sb_kevin_sb_

ret = re.subn(r"d+", "_sb_", "jolin250tory250tony250kevin38") # 将数字替换成'__sb__'，返回元组(替换的结果,替换了多少次)
print(ret)    # ('jolin_sb_tory_sb_tony_sb_kevin_sb_', 4)

obj = re.compile(r'd{3}')  # 将正则表达式编译成为一个 正则表达式对象, 规则要匹配的是3个数字
ret = obj.search('abc123eeee') # 正则表达式对象调用search, 参数为待匹配的字符串
print(ret.group())  # 结果: 123

爬虫重点:

obj = re.compile(r'(?Pd+)(?Pe+)')  # 从正则表达式匹配的内容每个组起名字
ret = obj.search('abc123eeee') # 搜索
print(ret.group())  # 结果: 123eeee
print(ret.group("id"))  # 结果: 123 # 获取id组的内容
print(ret.group("name")) # 结果: eeee # 获取name组的内容

正则在爬虫中的使用(简单案例):

import re
from urllib.request import urlopen
import ssl
# 干掉数字签名证书
ssl._create_default_https_context = ssl._create_unverified_context

def getPage(url):
    response = urlopen(url)
    return response.read().decode('utf-8')

def parsePage(s):
    ret = re.findall(
        '
.*?
.*?(?Pd+).*?(?P