day 17

包

什么是包

包是模块的一种形式，包的本质就是一个含有.py的文件的文件夹。

为什么要有包

由于版本扩展，文件越来越大，模块设计者对模块的管理，维护变得越来越复杂，因此我们可以使用包来扩展模块的功能

如何用包

模块和包

导入模块发生的三件事：

1.创建一个包的名称空间

2.执行py文件，将执行过程中产生的名字存放于名称空间中

3.在当前执行文件中拿到一个aaa，aaa是指向包的名称空间

导入包发生的三件事：

1.创建一个包的名称空间

2.由于包是一个文件夹，无法执行包。因此执行包下的.py文件，将执行过程中产生的名字存放于包名称空间中(即包名称空间中存放的名字都是来自于.py)

3.在当前执行文件中拿到一个名字aaa,aaa是指向包的名称空间的

导入包就是在导入包下的.py，并且可以使用一下两种方式导入：

1.import ...

2.from ... import ...

__init__.py文件

包是含有__init__.py的文件；导包就是导入__init__

包一定是被当作模块文件导入， 模块文件m1,py/m2,py 的搜索路径以执行文件 包的介绍.py路径为准

import aaa

print(aaa.f1)
print(aaa.f2)

print(aaa.f3)

from aaa.m1 import f1 # 不符合包的原则
f1()

绝对导入和相对导入

绝对导入：

# aaa/.py

from aaa.m1 import func1
from aaa.m2 import func2

相对导入：

• .代表当前被导入文件所在的文件夹
• ..代表当前被导入文件所在的文件夹的上一级
• ...代表当前被导入文件所在的文件夹的上一级的上一级

包的作用

当模块内部函数过多，为了方便管理模块，把一个模块划分成多个模块，但是又不能改变导入方式，把多个模块放入一个包（文件夹）内。未来导包就是导init

time模块

提供了三种不同类型的时间(时间戳)，三种不同类型的时间可以相互转换

import time

print(time.time())  # 时间戳形式

# 格式化时间
print(time.strftime('%Y-%m-%d %X'))

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

# 格式化时间 --》 结构化时间
format_time = time.strftime('%Y-%m-%d %X')
print(time.strptime(format_time,'%Y-%m-%d %X'))

# 结构化时间 --》 格式化时间
struct_time = time.localtime(3600*24*365)
print(time.strftime('%Y-%m-%d %X',struct_time))

# 结构化时间 --》 时间戳
struct_time = time.localtime(3600*24*365)
print(time.mktime(struct_time))

# 时间戳 --》 结构化时间
time_stamp = time.time()
print(time.localtime(time_stamp))

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(hour=3))
print(now + datetime.timedelta(hour=-3))

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()
print(random.random())

# 了解
print(random.sample([1,'a','c',2,3,4],3))

hashlib模块和hmac模块

hashlib模块

对字符加密

import hashlib

# 叠加性
m = hashlib.md5()
m.update(b'say')
m.update(b'hello')
print(hexdigest())  # 对于不同的字符而言，永不重复


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

for pwd in pwd_list:
    m = hashlib.md5()
    m.update(pwd.encode('utf8'))
    res = m.hexdigest()
    if res == hash_pwd:
        print(f'获取密码成功:{pwd}')

hmac模块

对字符加密，并且加上密钥

import hmac

m = hmac.new(b'maerzi')
m.update(h'hash123456')
print(m.hexdigest())

m = hmac.new(b'sajhgakldhf')
m.update(b'hash123456')
print(m.hexdigest())

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

typing模块

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

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

from typing import Iterable, Iterator,Generator

print(lt == Iterable)   # False

def func(x:int, lt:Iterable) -》 list:
    return [1,2,3]

func(10,'123123')

requests模块

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

# url --》 一个特定的网址 --》永不重复

import requests

response = requests.get('https://ishuo.cn')
data = response.text
# print(data)

re模块

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

import re

# s = '去字符串找符合某种特点的字符串'
#
# res = re.findall(''.s)
# print(res)

元字符

s = 'abcabc'
# ^: 以...开头

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

# $: 以...结尾
s = 'abcabc'
res = re.findall('bc$',s)
print(res)                      # ['bc']

# .: 任意字符
s = 'abc红abc'
res = re,findall('abc.',s)
print(res)                      # ['abc红']

# \d: 数字
s = 'sklaf49355jk'
res = re.findall('\d',s)
print(res)                      # ['4','9','3','5','5']

# \w: 非空，数字字母下划线
s = 'afjk_76 325jk'
res = re.findall('\w',s)
print(res)                      #['a','f','j','k','_','7','6','3','2','5','j','k']

# \s: 空，空格/\t/\n
s = 'shk_93 091jk'
res = re.findall('\s',s)
print(res)                      # [' ']

# \D: 非数字
s = 'skfaw5624jk'
res = re.findall('\D',s)
print(res)                      # ['s','k','f','a','w','j''k]

# \S: 非空
s = 'skfaw5624jk'
res = re.findall('\S',s)
print(res)                      # ['s','k','f','a','w','5','6','2','4','j','k']

# +: 前面的一个字符至少一个
s = 'abcddddddd abcd abc'
print(re.findall('abcd+',s))    # ['abcddddddd','abcd']

# ?: 前面的一个字符0-1个
s = 'abcddddddd abcd abc'
print(re.findall('abcd+',s))    # ['abcd','abcd','abc']

# *: 前面的一个字符至少0个
s = 'abcdddddddddddd abcd abc'
print(re.findall('[abc]bc',s))  # ['abc','abc','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']

# {2}: 前面的字符2个
s = 'abccabc abccc'
print(re.findall('abc{2}',s))   # ['abcc','abcc']

# {1,2}: 前面的字符2个
s = 'abccabc abccc'
print(re.findall('abc{1，2}',s)) # ['abc','abc','abcc']

贪婪模式

# . (任意字符)*(0-无穷个)

s = 'abcdefgbbbbbbbbbbbbbbbbg'
print(re,findall('a.*g',s))     # ['abcdefgbbbbbbbbbbbbbbbbg']

非贪婪模式(重要)

# . (任意字符)*(0-无穷个) ？ (让它进入非贪婪模式)
s = 'abcdefgbbbbbbbbbbbbbbbbg'
print(re.findall('a.*?g',s))    # ['abcdefg']

bug

# . (任意字符)*(0-无穷个) ？ (让它进入非贪婪模式)
s = 'abcdefg'
print(re.findall('.*?', s))     # ['', '', '', '', '', '', '', '']      

了解(特殊构造)

# a(?=\d) : a后面是数字，但是不要数字，不消耗字符串内容
s = 'a123 aaaa a234 abc'

print(re.findall('a(?=\d)',s))  # ['a','a']
print(re.findall('a(?=\w)',s))  # ['a','a','a','a','a','a']

# 匹配邮箱
s = '#@#@#@[email protected]$$$$////[email protected]$$#$#$[]][email protected]@$2423423lksdlfj#' 

import re

res = re.findall('\w.*?@.*?com',s)
print(res)              # ['[email protected]', '[email protected]', '[email protected]']