目录

• 包
  • 包的特征
  • 相对导入与绝对导入
    • 绝对导入
    • 相对导入
    • 两种导入都只能在包的内部使用
  • 包的作用
• time模块和datetime模块
• random模块
• hashlib模块和hmac模块
• typing模块
  • 与函数联用,控制函数参数的数据类型,提供基础之外的数据类型
• requests模块re模块
  • requests 模块
  • 正则表达式
  • 贪婪模式非贪婪模式
  • 特殊构造(仅了解)
  • re模块中常用函数
  • 补充
  • 总结

包

包的特征

1.包是含有__init__的文件夹,导包就是导入__init__

2.包一定是被当作模块文件导入,模块文件的搜索路径以执行文件路径为基准

相对导入与绝对导入

绝对导入

以包的根目录为基准

相对导入

以当前被导入的模块所在的目录为基准

.表示当前文件夹下的文件

..表示父文件夹下的文件

...表示爷爷文件夹下的文件

两种导入都只能在包的内部使用

包的作用

在扩展模块功能的时候,把多个模块文件放入一个包(文件夹)内,但不改变模块的导入方式,类似于函数的装饰器

time模块和datetime模块

import time

#time模块:与时间相关
    #1.time.time()---返回当前时间戳,从1970年1月1日00:00:00开始计算
    
    #2.格式化时间
print(time.strftime('%Y-%m-%d %H:%M:%S'))
print(time.strftime('%Y-%m-%d %X'))
print(time.strftime('%x %X'))
    
    #3.结构化时间
print(time.localtime()) #列出时间的九个元素,年/月/日/时/分/秒/一周中第几天(周日始)/一年中第几天/是否夏令时


import datetime

#datetime模块:时间加减

now = datetime.datetime.now()
print(now)  #秒精确到小数点后六位

#时间加减
print(now + datetime.timedelta(3))  #加三天
print(now + datetime.timedelta(weeks = 3))  #加三周
print(now + datetime.timedelta(hours = 3))  #加三小时

#时间替换
print(now.replace(1949,10,1,10,1,10,0)) 

random模块

import random
#random模块:随机数

# random.seed(10)

#常用
print(random.random())  #随机(0-1)之间浮点数

print(random.randint(1,3))  #随机[1-3]之间整数

print(random.randrange(5))  #随机[0,5)的整数

lt = [1,2,3]
random.shuffle(lt)  #将列表随机洗牌
print(lt)

print(random.choice(lt))    #从可迭代对象中随机选择一个

#随机数种子,控制只随机一次
# random.seed(10)
print(random.random())

random.seed(time.time())    #梅森旋转算法
print(random.random())

print(random.sample(lt,2))  #抽样

hashlib模块和hmac模块

#hashlib模块
import hashlib
m = hashlib.md5()
m.update(b's')
m.update(b'b')
print(m.hexdigest())  #26148d621ef74844918af182d63976b6

m = hashlib.md5()
m.update(b'sb')
print(m.hexdigest())    #26148d621ef74844918af182d63976b6
#可叠加性:多次update不同内容与直接一次update总内容结果一致

#破解hashlib加密
    #1.列出用户常用密码表
    #2.通过遍历得到常用密码对应哈希结果
    #3.比对拦截包的哈希值得到正确密码
pwd_list = ['abc','123','456','sb']
hash_pwd = '26148d621ef74844918af182d63976b6'
for pwd in pwd_list:
    m = hashlib.md5()
    m.update(pwd.encode('utf8'))
    res = m.hexdigest ()
    if res == hash_pwd:
        print('密码为:',pwd)

#hmac模块:秘钥(salt)
import hmac
m = hmac.new(b'maerzi')
m.update(b'caiqilong')
print(m.hexdigest())    #95e4cf14b46c797c40da2b090a67b5b9

m = hmac.new(b'mababa')
m.update(b'caiqilong')
print(m.hexdigest())    #7aab304fa2a10b67d4f480ae4c9e07a2
#相同的密码,密钥不同的到的hmac结果不同

typing模块

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

from typing import Iterable, Iterator
def f(x: Iterator, y: Iterable) -> list:
    pass

requests模块re模块

requests 模块

#requests模块:爬虫-->爬数据,模拟浏览器对url发送请求,拿到数据
#url:同一资源定位符,永不重复
import requests
response = requests.get('https://www.cnblogs.com/nickchen121/')
data = response.text
# print(data)

#正则re:从大的字符串中挑选出具有某种形状特点的字符串,结果以列表方式存储
import re
res_title = re.findall('<a class="postTitle2" .*?>(.*?)</a>',data,re.S)
# print(res_title)
res_digest = re.findall('<div class="c_b_p_desc">(.*?)<a href="https://.*?" class="c_b_p_desc_readmore">',data,re.S)
# print(res_digest)
l = len(res_digest)
for i in range(l):
    print(res_title[i].strip()+'\n'+res_digest[i].strip()+'\n'+'*'*175)

正则表达式

#正则表达式
import re
    #1. "^..." 表示以...字符开头, "^" 自己本身不占字符位置
s = '''abcabc1  
23'''
res = re.findall('^abc',s)
print(res)
res = re.findall('abc',s)
print(res)
res = re.findall('\^abc',s) # "\" 表示转义字符使 "\" 后的字符转义
print(res)

    #2. "...$" 表示以..字符结尾, "$" 自己本身不占字符位置
res = re.findall('bc$',s)
print(res)
res = re.findall('bc',s)
print(res)

    #3. "." 表示匹配一个字符,该字符除了"\n"外均可
res = re.findall('a.c.',s)
print(res)

    #4. "\w" 表示匹配一个单词字符,该字符属于字母数字下划线 "[A-Z,a-z,0-9,'_']"
res = re.findall('\w',s)
print(res)

    #5. "\W" 表示匹配一个单词字符,该字符不属于字母数字下划线 "[A-Z,a-z,0-9,'_']"
res = re.findall('1\W\W\W2',s)
print(res)

    #6. "\d" 表示表示匹配一个数字字符
res = re.findall('\d\d',s)
print(res)

    #7. "\D" 表示匹配一个非数字字符
res = re.findall('\D',s)
print(res)

    #8. "\s" 等价于 "\W"
res = re.findall('\s',s)
print(res)

    #9. "\S" 等价于 "\w"
res = re.findall('\S',s)
print(res)

    #10. "+" 表示匹配 "+" 前面一个字符 "[1,+∞)" 次,从 "+∞" 到 "1" , "+" 自己本身不占字符位置
res = re.findall('abcd+','abcddddd abcd abc')
print(res)

    #11. "?" 表示匹配 "?" 前面一个字符 "[0,1]" 次,从 "1" 到 "0" , "?" 自己本身不占字符位置
res = re.findall('abcd?','abcddddd abcd abc')
print(res)

    #12. "*" 表示匹配 "*" 前面一个字符 "[0,+∞)" 次,从 "+∞" 到 "0" , "*" 自己本身不占字符位置
res = re.findall('abcd*','abcddddd abcd abc')
print(res)

    #13. "[]" 表示匹配 "[]" 中的字符串中的某一个字符, "[]" 自己本身占一个字符位置
res = re.findall('[abc]b','abcbbccbcdbc')
print(res)

    #14. "[^]" 表示 "[^]" 中的字符串中的任意一个字符都不能匹配, "[^]" 自己本身占一个字符位置
res = re.findall('[^abc]bc','abcbbccbc bc')
print(res)

    #15. "|" 表示匹配 "|" 左边的字符串或者匹配 "|" 右边的字符串
res = re.findall('bbc|abc','abcbbcdbc')
print(res)

    #16. "{m,n}" 表示匹配 "{m,n}" 前面一个字符 "[m,n]" 次, "{m,n}" 自己本身不占字符位置, "{}" 内只有一个数表示匹配前一个字符确定的次数
res = re.findall('abc{1,2}','abccabcabccc')
print(res)

贪婪模式非贪婪模式

import re
#贪婪模式(最大跨度): ".*" , 其中 ".":任意字符 , "*":"[0,+∞)"个
s = 'bacdefgaaaaaaaaaaaag'
print(re.findall('a.*g',s))

#非贪婪模式(最小跨度): ".*?" , 其中 ".":任意字符, "*":"[0,+∞)"个, "?":进入非贪婪模式
print(re.findall('a.*?g',s))

特殊构造(仅了解)

#特殊构造(仅了解)
# "a(?=\d)" 表示 "a" 后面是数字但不要数字,不消耗 "\d" 内容
s = 'a123 aaaa a234 abc'
print(re.findall('a(?=\d)',s))
print(re.findall('a(?=\w)',s))

#匹配邮箱练习
s = '#@#@#@nickchen121@163.com$$$$////nick@qq.cn$$#$#$[]]2287273393@162.com@$2423@423lksdlf@j#'
res = re.findall('\w+@\w+\.\w+',s)  # "\w" :字母/数字/下划线
print(res)

re模块中常用函数

import re
# re模块中常用的函数( "findall" 之外)
#1. re.compile
s = 'abcd abcddd abc'
res = re.compile('abcd*')
print(res)
print(re.findall(res,s))
    #实际用途
email_pattern = re.compile('\w+@\w+\.\w+')
phione_pattern = re.compile('\d{13}')

# 接下来两个面试非常重要
    #2. re.match---匹配到一个之后就不再匹配,必须以以该字符串开头
s = 'abcd abcddd abc'
res = re.match('abcd*',s)
print(res)
print(res.group())

    #3. re.search---匹配到一个之后就不再匹配,可以不以该字符串开头
res = re.search('abcd*',s)
print(res)
print(res.group())

#4. re.split---以写的正则表达式划分
s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.split('\d+',s))

#5. re.sub == replace 将写的正则表达式替换成指定字符
s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.sub('\d+','',s))

#6. re.subn 比 re.sub 多输出替换次数
s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.subn('\d+','',s))

补充

import re
#7.补充
#修饰符
    # re.S---非常有用
s = '''abc
abcabc*abc
'''
print(re.findall('abc.abc',s))  # "." 不匹配换行符
print(re.findall('abc.abc',s,re.S))  # "re.s" 让 "." 能匹配换行符

#9. 分组(非常重要):"()"---提取括号内的内容,多个括号提取内容时一个符合的结果用一个元组存储
s = 'abc abcd amcdd'
print(re.findall('a(.)c(d)',s))

    #有名分组(了解即可)---一般与 "re.search" 联用,给 "()" 提取的内容加上名字,以字典形式输出
s = 'abc abcd amcdd'
print(re.search('a(?P<name1>.)c(?P<name2>d)',s).groupdict())

    #有名分组与 "re.sub" 联用, 匹配的字符串中 "()" 提取的有名内容保留,其他去除
s = 'abc123abc123'
print(re.sub('c\d+a',' ',s))
print(re.sub('c(?P<name>\d+)a',' \g<name> ',s))

总结

#重点需记忆内容
    # 贪婪和非贪婪: ".*" / ".*?"
    # re.findall
    # re.S
    # "re.match" 和 "re.search" 区别
    # 分组: "()" ---有名分组: 给分组加名字