time/requests/hashlib/hmac/re模块

time模块

提供了三种不同类型的时间(时间戳)

import time 
 # 时间戳:时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。
print(time.time()) 


 # 格式化时间
print(time.strftime('%Y-%m-%d  %X')) # 获取当前时间，'-'为拼接符

 # 结构化时间
print(time.localtime)



 # (****)
 # 只要记住time.time()和time.sleep(1)

datetime模块

时间的加减

import datetime

now = datetime.datetime.now()   # 获取当前时间
print(now)


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))   # 减

now.replace(year=1949, month=10, day=1, hour=10, minute=1, second=0, microsecond=0) 

random模块

随机数

掌握

print(random.random())  # 0-1随机

print(random.randint(1,3))  # 1-3整数


lt= [1,2,3,4,5]
print(random.shuffle(lt))   # 打乱列表中的顺序

print(random.choice(lt)     # 随机选择一个

random.seed(1）
print(random.choice(lt))    # 只随机一次

了解

print(random.sample([1,23,4],2))    # 随机生成2个数

hashlib和hmac模块

# 叠加性
m = hashlib.md5()
# m.update(b'say')
# m.update(b'hello')
m.update(b'sathello')

print(m.hexhdigest())   # 对于不同的字符而言，永不重复

hash_pwd = '0562b36c3c5a3925dbe3c4d32a4f2ba2'


pwd_list = [
    'hash3714',
    'hash1313',
    'hash94139413',
    'hash123456',
    '123456hash',
    'h123ash',
]


for pwd in pwd_list:
    m = hashlib.md5()
    m.update(pwd.encode('utf-8'))
    res = m.hexdigest()
    if res == hash_pwd
        print(f'{pwd}')
        
 # hmac密钥
import hmac
m = hmac.new(b'make')   #密钥
m.update(b'hash123456)
print(m.hexdigest())
         
m = hmac.new(b'sssfe')  
m.update(b'hash123456)
print(m.hexdigest())


         

typing模块

与函数联用，控制函数参数的数据类型,提供了基础数据类型之外的数据类型

lt = [1,2,3,4]
print()

from typing import Iterable
def func(x:int lt:Iterable) ->list
    return [1,2,3]

requester模块

爬虫——》爬数据，模拟游览器对url发送请求，拿到数据

import requests

response = requests.get('http://duanziwang.com/')
data = response.txt
print(data)

re模块

去字符串找符合某种特点的字符串

^：以...开头

import re

s = 'abcdabc'
res = re.findall('^ab',s)       
 # ['ab','ab']

$：以...结尾

s = 'abcdabcall'
res = re.findall('all$',s)      
 # ['all']

.：任意字符*

s = 'abcdabcp'
res = re.findall('ab.',s)       
 # ['abc','abp']

\d：数字*

s = 'abcd1ab2p14'
res = re.findall('\d',s)        
 # ['1','2','1','4']

\D：非数字*

s = 'abcd1ab2p14'
res = re.findall('\w',s)        
 # ['a', 'b', 'c', 'd', '1', 'a', 'b', '2', 'p', '1', '4']

\w：非空*

s = 'abcd1ab2p14' #字母数字下划线等
res = re.findall('\w',s)        
 # ['a', 'b', 'c', 'd', '1', 'a', 'b', '2', 'p', '1', '4']

\s：空

s = 'abcd1 ab2p14'
res = re.findall('\s',s)        
 # ['']

\S：非空*

s = 'abcd1 ab2p14'
res = re.findall('\s',s)        
 # ['a', 'b', 'c', 'd', '1', 'a', 'b', '2', 'p', '1', '4']

+：前面的字符至少1个*

s = 'abcdddd abcd abc'
res = re.findall('abcd+',s)     
 # ['abcdddd', 'abcd']

？：前面的字符至0-1个*

s = 'abcdddd abcd abc'
res = re.findall('abcd?',s)     
 # ['abcd', 'abcd','abc']

*：前面的字符至0个*

s = 'abcdddd abcd abc'
res = re.findall('abcd*',s)     
 # ['abcd', '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 cbc dbc'
print(re.findall('abc|bbc',s))
 # ['dbc','bbc']

贪婪模式*

s = 'abcdefgaaaaaaaaaag'
print(re.findall('a.*g',s))
 # ['abcdefgaaaaaaaaaag'] 最大跨度 找到最后一个

非贪婪模式*

s = 'abcdefgaaaaaaaaaag'
print(re.findall('a.*?g',s))
 # ['abcdefg', 'aaaaaaaaaag'] 小跨度

函数

compile

s = 'abcd abcddd abc'
res = re.compile('abcd*',s)
phone_patter = re.comeile('\d{13}') # 先定义在拿来用

match*

s = 'abcd abcddd abc'
res = re.match('abcd*',s)
print(res.group)    # 从开头找一个找到就不继续找了，找不到就报错
 # abcd

search*

s = 'abcd abcddd abc'
res = re.match('abcd*',s)
print(res.group)    # 从从字符串中找一个，找不到就报错
 # abcd

split

s = 'abc1231d abcd12321dd a123bc'
res = re.split('\w+',s)
print(res.) # 以数字划开
 # ['abc', 'd abcd', 'dd a', 'bc']

sub(replace)

s = 'abc1231d abcd12321dd a123bc'
res = re.sub('\w+','',s)
print(res.) # 将数字替换为''
 # [abcd abcddd abc]

补充

修饰符-->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']

()分组-->只要括号里的

s = 'abc abcd abcdd'
print(re.findall('a(.)c(d)', s))

 # [('b', 'd'), ('b', 'd')]

()有名分组

s = 'abc abcd abcdd'
print(re.search('a(?P.)c(?Pd)', s).groupdict())