常用内置模块(2)
一、time模块
1、时间戳
import time
res = time.time() # 时间戳形式
print(res)
# 1569667754.9504838
2、格式化时间
import time
res = time.strftime('%Y-%m-%d %X') # 格式化时间
print(res)
# 2019-09-28 18:49:14
3、结构化时间
import time
res = time.localtime() # 结构化时间
print(res)
# time.struct_time(tm_year=2019, tm_mon=9, tm_mday=28, tm_hour=18, tm_min=49, tm_sec=14, tm_wday=5, tm_yday=271, tm_isdst=0)
4、不同格式的时间互相转换
4.1 结构化时间 —> 格式化时间
struct_time = time.localtime(3600*24*365)
print(time.strftime('%Y-%m-%d %X',struct_time))
# 2019-09-28 18:52:18
4.2 格式化时间 —> 结构化时间
format_time = time.strftime('%Y-%m-%d %X')
print(time.strptime(format_time,'%Y-%m-%d %X'))
# time.struct_time(tm_year=2019, tm_mon=9, tm_mday=28, tm_hour=18, tm_min=52, tm_sec=18, tm_wday=5, tm_yday=271, tm_isdst=-1)
4.3 结构化时间 —> 时间戳
struct_time = time.localtime(3600*24*365) # 括号中加时间是从计算机元年1970年1月1日 0:0:0 开始计算的
print(time.mktime(struct_time))
# 31536000.0
4.4 时间戳 —> 结构化时间
time_stamp = time.time()
print(time.localtime(time_stamp))
# time.struct_time(tm_year=2019, tm_mon=9, tm_mday=28, tm_hour=18, tm_min=52, tm_sec=18, tm_wday=5, tm_yday=271, tm_isdst=0)
二、datetime模块
用来进行时间的加减计算
import datetime
now = datetime.datetime.now()
print(now)
# 默认3天
print(now + datetime.timedelta(3))
# 加3周
print(now + datetime.timedelta(weeks=3))
# 加3小时
print(now + datetime.timedelta(hours=3))
# 减3小时
print(now - datetime.timedelta(hours=3))
print(now + datetime.timedelta(hours=-3))
# 替换时间
print(now.replace(year=1949, month=10, day=1, hour=10, minute=1, second=0, microsecond=0))
'''
2019-09-28 18:56:48.240483
2019-10-01 18:56:48.240483
2019-10-19 18:56:48.240483
2019-09-28 21:56:48.240483
2019-09-28 15:56:48.240483
2019-09-28 15:56:48.240483
1949-10-01 10:01:00
'''
三、random模块
随机数模块
import random
# 掌握
# 默认为0-1中的一个随机数
print(random.random())
# [1-3]中的整数
print(random.randint(1,3))
# 随机打乱
lt=[1,2,3]
random.shuffle(lt)
print(lt)
# 随机选择一个
print(random.choice(lt))
# 只随机一次 --> 梅森旋转算法
import time
random.seed(time.time()) # 以时间为基准计算，每次都不一样
# random.seed(111111111111) # 以具体的数计算，只计算一次，之后每次都一样
print(random.random())
# 了解
print(random.sample([1,'a','c',2,3,4],2))
'''
0.6264256562221452
2
[3, 2, 1]
1
0.08023345502018553
[2, 1]
'''
四、hashlib模块
对字符加密的模块
import hashlib
m = hashlib.md5()
m.update(b'hello') # 等同于m.update('hello'.encode('utf-8'))
print(m.hexdigest())
# 5d41402abc4b2a76b9719d911017c592
# Unicode-objects must be encoded before hashing
五、hmac模块
对字符加密，且可以使用密钥
import hmac
m = hmac.new(b'maerzi') # 加密钥
m.update(b'hash123456')
print(m.hexdigest()) # f82317e44545b0ab087109454814b5c4
六、typing模块
与函数联用，控制函数参数的数据类型,提供了基础数据类型之外的数据类型
from typing import Iterable # 迭代器对象
lt = [1, 2, 3, 4] # 只是可迭代对象
print(type(lt) is list) # True
print(lt == Iterable) # False
七、requests模块
模拟浏览器对URL发送请求，拿到数据，通常用于网络爬虫
import requests
response = requests.get('https://www.baidu.com')
data = response.text
八、re模块
去字符串找 符合某种特点的字符串
1、re模块的基本语法
import re # 第一步，要引入re模块
s = "这个字符串是否有匹配规则的字符"
res = re.findall("匹配规则",s)
# 第二步，调用模块函数
print(res) # 以列表形式返回匹配到的字符串
2、re模块的特殊字符
^：以...开头
s = 'abcdabc'
res = re.findall('^ab', s)
print(res)
res = re.findall('^bc', s)
print(res)
# ['ab']
# []
$: 以..结尾
s = 'abcdabc'
res = re.findall('bc$', s)
print(res)
# ['bc']
. : 任意字符
s = 'abc红abc'
res = re.findall('abc.', s)
print(res)
# ['abc红']
\d: 数字
s = 'skld2342ljk'
res = re.findall('\d', s)
print(res)
# ['2', '3', '4', '2']
\w: 非空，数字字母下划线(不包含特殊字符)
s = 'skld_23 42ljk'
res = re.findall('\w', s)
print(res)
# ['s', 'k', 'l', 'd', '_', '2', '3', '4', '2', 'l', 'j', 'k']
\s：空，空格/\t/\n
s = 'skld_23 42ljk'
res = re.findall('\s', s)
print(res)
# [' ']
\D: 非数字
s = 'skld2342ljk'
res = re.findall('\D', s)
print(res)
# ['s', 'k', 'l', 'd', 'l', 'j', 'k']
\W: 空
s = 'skld_23 42ljk'
res = re.findall('\W', s)
print(res)
# [' ']
\S：非空
s = 'skld_23 42ljk'
res = re.findall('\S', s)
print(res)
# ['s', 'k', 'l', 'd', '_', '2', '3', '4', '2', 'l', 'j', 'k']
+: 前面的一个字符至少1个
s = 'abcddddd abcd abc'
print(re.findall('abcd+', s))
# ['abcddddd', 'abcd']
？：前面的一个字符0-1个
s = 'abcddddd abcd abc'
print(re.findall('abcd?', s))
# ['abcd', 'abcd', 'abc']
*：前面的一个字符至少0个
s = 'abcdddddddddddddddddd abcd abc'
print(re.findall('abcd*', s))
# ['abcdddddddddddddddddd', 'abcd', 'abc']
[]: 中括号内的都可以
s = 'abc bbc cbc dbc'
print(re.findall('[abc]bc', s))
# ['abc', 'bbc', 'cbc']
**[^]: 中括号的都不可以**
s = 'abc bbc cbc dbc'
print(re.findall('[^abc]bc', s))
# ['dbc']
|：或
s = 'abc bbc dbc'
print(re.findall('abc|bbc', s))
# ['abc', 'bbc']
{m}:前面的字符m个
s = 'abccabc abccc'
print(re.findall('abc{2}', s))
# ['abcc', 'abcc']
{1,2}:前面的字符1或2个
s = 'abccabc abccc'
print(re.findall('abc{1,2}', s))
# ['abcc', 'abc', 'abcc']
3、贪婪模式与非贪婪模式
3.1 贪婪模式
# .（任意字符）*（0-无穷个）
s = 'abcdefgbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbg'
print(re.findall('a.*g', s)) # 第一个a到最后一个g
# 我全都要
# ['abcdefgbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbg']
3.2 非贪婪模式
# .（任意字符）*（0-无穷个）？（让他进入非贪婪模式）
s = 'abcdefgbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbg'
print(re.findall('a.*?g', s)) # 最后一个a到第一个g
# 够了
# ['abcdefg']
4、特殊构造
# a(?=\d) ：a后面是数字，但是不要数字，不消耗字符串内容
s = 'a123 aaaa a234 abc'
# a1 aa
# aa
# aa a2 ab
print(re.findall('a(?=\d)', s))
print(re.findall('a(?=\w)', s))
# ['a', 'a']
# ['a', 'a', 'a', 'a', 'a', 'a']
5、compile
s = '#@#@#@nickchen121@163.com$$$$////nick@qq.com$$#$#$[]]2287273393@162.com@$2423423lksdlfj#'
email_pattern = re.compile('\w+@\w+.com')
# phone_patter = re.compile('\d{11}')
print(re.findall(email_pattern, s))
s = 'abcd abcddd abc'
print(re.findall('abcd*', s))
# ['nickchen121@163.com', 'nick@qq.com', '2287273393@162.com']
# ['abcd', 'abcddd', 'abc']
6、match和search
# match: 从开头找一个，找得到就不找了 ；找不到报错 --》
s = 'abcd abcddd abc'
res = re.match('abcd*', s)
print(res.group())
# search： 从字符串找一个，就不找了
s = 'ab abcddd abc'
res = re.search('abcd*', s)
print(res.group())
# abcd
# abcddd
7、split
s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.split('\d+', s))
# ['ab', 'abcddd', 'abcasdfjlasjdk', 'l', 'lk', 'j', 'kl', 'kl', 'k', 'j', 'kl', 'j', 'lkj']
8、sub (相当于replace)
s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.sub('\d+', ' ', s))
# ab abcddd abcasdfjlasjdk l lk j kl kl k j kl j lkj
9、subn --> sub + 替换了多少次
s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.subn('\d+', ' ', s))
# ('ab abcddd abcasdfjlasjdk l lk j kl kl k j kl j lkj', 12)
10、补充（非常有用）
10.1 修饰符 --> re.S会让.匹配换行符（*****）
s = '''abc
abcabc*abc
'''
# .不匹配换行
print(re.findall('abc.abc', s)) # ['abc*abc']
print(re.findall('abc.abc', s, re.S)) # ['abc\nabc', 'abc*abc']
# ['abc*abc']
# ['abc\nabc', 'abc*abc']
10.2 分组 --> 只要括号里的（*****）
s = 'abc abcd abcdd'
print(re.findall('a(.)c(d)', s))
# [('b', 'd'), ('b', 'd')]
10.3 有名分组(了解)
s = 'abc abcd abcdd'
print(re.search('a(?P<name>.)c(?P<name2>d)', s).groupdict())
# {'name': 'b', 'name2': 'd'}
10.4 超高级用法
s = 'abc123abc123' # c123a
print(re.sub('c(\d+)a', ' ', s))
print(re.sub('c(?P<name1>\d+)a', ' \g<name1> ', s)) # \g<name1>这个东西不能替换掉
# ab bc123
# ab 123 bc123
