包 ,模块(time、datetime、random、hashlib、typing、requests、re)

1. 包

  • 什么是包

    包就是模块

  • 包有什么用

    1. 当模块内的函数过多时,为了方便管理函数,把多个函数划分成多个模块,但同时不同改变原来的导入方式,把多个模块放入一个包(文件夹)内。

    2. 通过包,可以不改变用户的导入方式(就和装饰器不改变被装饰函数的调用方式同理),提高用户体验

    3. 未来导包就是导__init__

  • 在包的用法中主要注意的有两点

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

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

  • 相对导入和绝对导入(只能在包中内部使用)

    相对导入:

    • .表示(同一文件夹下的)当前文件的目录
    • ..表示当前文件的父目录
    • ...表示当前文件的爷爷目录

    绝对导入:

    • 就是不用点表示目录,直接写名字

    2. time模块

  • time模块的作用

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

  • 三种类型的时间

    • 格式化时间
    • 结构化时间
    • 时间戳

    他们是以结构化时间为中间介质,格式化时间和结构化时间可以互相转化;时间戳可以和结构化时间互相转化

1. 优先掌握

import time
time.time() # 时间戳 (从计算机元年开始到现在的时间,以秒计算显示)

time.sleep(1)  # 让程序运行到这一步暂停1秒

2. 了解

import time

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

# 格式化时间
print(time.strftime('%Y-%m-%d %H:%M:%S'))

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


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


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


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

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

# 把格式化时间转换成时间戳
def str_to_timestamp(str_time=None, format='%Y-%m-%d %H:%M:%S'):
    if str_time:
        time_tuple = time.strptime(str_time, format)  # 把格式化好的时间转换成元祖
        result = time.mktime(time_tuple)  # 把时间元祖转换成时间戳
        return int(result)
    return int(time.time())


print(str_to_timestamp('2019-04-27 07:01:46'))
print(str_to_timestamp()) # 1556349904

# 把时间戳转换成格式化

def timestamp_to_str(timestamp=None, format='%Y-%m-%d %H:%M:%S'):
    if timestamp:
        time_tuple = time.localtime(timestamp)  # 把时间戳转换成时间元祖
        result = time.strftime(format, time_tuple)  # 把时间元祖转换成格式化好的时间
        return result
    else:
        return time.strptime(format)

print(timestamp_to_str(1556348505)) # 2019-04-27 15:01:45

3. datetime模块

  • datetime模块的作用

    可以实现时间的加减

1. 优先掌握

import datetime
# 获取当前时间
now = datetime.datetime.now()
print(now) # 2019-09-28 19:56:44.330734

# 加3天,默认单位天 # 2019-10-01 19:56:44.330734
print(now + datetime.timedelta(3)) 


# 加3周 #2019-10-19 19:56:44.330734
print(now + datetime.timedelta(weeks=3))

# 加3小时 2019-09-28 22:56:44.330734
print(now + datetime.timedelta(hours=3))

# 减3小时 # 2019-09-28 16:56:44.330734
print(now - datetime.timedelta(hours=3))
print(now + datetime.timedelta(hours=-3))

# 1949-10-01 10:01:00
print(now.replace(year=1949, month=10, day=1, hour=10, minute=1, second=0, microsecond=0))

# 两个时间的差值
import datetime
d1 = datetime.datetime.strptime('2012-03-05 17:41:20', '%Y-%m-%d %H:%M:%S')
d2 = datetime.datetime.strptime('2012-03-02 17:41:10', '%Y-%m-%d %H:%M:%S')
delta = d1 - d2
print (22222,delta.days)  # 相差的天数(只是日期相减,不含后面的时间点)
print (333,delta.seconds)  # 相差的天数(只是时间点相减,不含前面的日期)
print (5555,delta.total_seconds())  # 相差的总时间,以秒为单位

# 字符串、时间类型之间的转换
# 字符串转时间:
new_time = datetime.datetime.strptime(str_time,'%Y-%m-%d %H:%M:%S')

# 时间转字符串
str_now_time = datetime.datetime.strftime(now_time,'%Y-%m-%d %H:%M:%S')


4. random模块

  • random模块的作用

    产生随机数

1. 优先掌握

import random


# 掌握

# 随机生成一个0~1之间的小数点后是16位的小数 如: `0.4033592505614103`
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)
seed() 方法是改变随机数生成器的种子,也就是说,当使用seed()方法后,后面的产生的随机数就是一样的了。
seed()括号内的数不同,产生的随机数种子也不同
就是说 例如:
random.seed(1) 后面再产生的随机数都为 2
random.seed(2)后面再产生的随机数都为 3
print(random.random())

2. 了解

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

5. hashlib模块和hmac模块

  • hashlib模块的作用

    对字符加密,最后产生一个32位的字符串。如:62416b4bd5d83b0908bbd3523fea81cc 类型:<class 'str'>

  • hmac模块的作用

    对字符加密,并且加上密钥,相当于用了两层加密。

  • hashlib模块的实例

import hashlib

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

# 981fe96ed23ad8b9554cfeea38cd334a

# 手机号/生日/性别/qq账号/以前的密码/   --》 挖矿(算法)

# 1 2 3 5 71113 111111111111111 - 1111111111111111111111 111111111111111111111111111111111111111111111111111

hash_pwd = '0562b36c3c5a3925dbe3c4d32a4f2ba2'

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}')
  • hamc模块的实例

    import hmac
    
    m = hmac.new(b'maerzi')
    m.update(b'hash123456')  # f82317e44545b0ab087109454814b5c4
    print(m.hexdigest())
    
    m = hmac.new(b'sdfjhjk2394879ul%$$Y#($&')
    m.update(b'hash123456')  # 2a70fd0f13cb49357f40d326a4e071a2
    print(m.hexdigest())
    
    pwd_list = [
        'hash3714',
        'hash1313',
        'hash94139413',
        'hash123456',
        '123456hash',
        'h123ash',
    ]
    

6. typing模块

  • typing模块的作用

    与函数联用,控制函数参数的数据类型,提供了基础数据类型之外的数据类型(如 Iterable, Iterator, Generator

  • 实例

    def func(x: int, lt: Iterable) -> list:
        return [1, 2, 3]
    
    func(10, '123123')
    

7. requests模块

  • request是模块的作用

    爬数据的模块,模拟浏览器对url发送请求,获取数据

  • 实例

    # url ——> 一个特定的网址 -》 永不重复
    import requests
    
    response = requests.get('https://ishuo.cn')
    data = response.text
    print(data)
    

8. re模块

  • re模块的作用

    从大的字符串中挑选出 具有某种形状特点的字符串

  • 正则表达式 : Pattern

  • 正则表达式本身是一种小型的、高度专业化的编程语言,它并不是Python的一部分。

  • 正则表达式模式被编译成一系列的字节码,然后由用C编写的匹配引擎执行

  •  以下必须得记住
    
    # .*?
    # 贪婪和非贪婪
    # findall
    # re.S
    # match和search的区别
    # 分组
    # 有名分组:给分组加名字
    

1. re模块的正则表达式的元字符和语法

  • re模块匹配后返回的结果都是列表

    s = 'abcdabc'
    #    abc
    #        abc
    #     bc  bc
    
    # ^:以...开头
    res = re.findall('^ab', s)
    print(res)
    res = re.findall('^bc', s)
    print(res)
    # $: 以..结尾
    s = 'abcdabc'
    res = re.findall('bc$', s)
    print(res)
    
    # .: 任意字符
    s = 'abc红abc'
    res = re.findall('abc.', s)
    print(res)
    
    # \d: 数字
    s = 'skld2342ljk'
    res = re.findall('\d', s)
    print(res)
    
    # \w: 非空,数字字母下划线
    s = 'skld_23 42ljk'
    res = re.findall('\w', s)
    print(res)
    
    # \s:空,空格/\t/\n
    s = 'skld_23 42ljk'
    res = re.findall('\s', s)
    print(res)
    
    # \D: 非数字
    s = 'skld2342ljk'
    res = re.findall('\D', s)
    print(res)
    
    # \W: 空
    s = 'skld_23 42ljk'
    res = re.findall('\W', s)
    print(res)
    
    # \S:非空
    s = 'skld_23 42ljk'
    res = re.findall('\S', s)
    print(res)
    
    # +: 前面的一个字符至少1个
    s = 'abcddddd abcd abc'
    print(re.findall('abcd+', s))
    
    # ?:前面的一个字符0-1个
    s = 'abcddddd abcd abc'
    print(re.findall('abcd?', s))
    
    # *:前面的一个字符至少0个
    s = 'abcdddddddddddddddddd abcd abc'
    print(re.findall('abcd*', s))
    
    # []: 中括号内的都可以
    s = 'abc bbc cbc dbc'
    print(re.findall('[abc]bc', s))
    
    # [^]: 中括号的都不可以
    s = 'abc bbc cbc dbc'
    print(re.findall('[^abc]bc', s))
    
    # |:或
    s = 'abc bbc dbc'
    print(re.findall('abc|bbc', s))
    
    # {2}:前面的一个字符的个数是2个
    
    s = 'abccabc abccc'
    print(re.findall('abc{2}', s))
    
    # {1,3}:前面的一个字符的个数是1个到3个
    
    s = 'abccabc abcccabcccdf'
    print(re.findall('abc{1,3}', s)) # ['abcc', 'abc', 'abcc','abccc']
    
    # {1,}:前面的一个字符的个数是1个到无穷个
    
    

2. 贪婪模式和非贪婪模式

# 贪婪模式

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

s = 'abcdefgbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbg'
print(re.findall('a.*g', s)) # ['abcdefgbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbg'] 就是 a~g 找一个最长的

# 非贪婪模式(*******)

# .(任意字符)*(0-无穷个)?(让他进入非贪婪模式)
s = 'abcdefgbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbg'  ['abcdefg']  就是a~g找一个最短的
print(re.findall('a.*?g', s))

3. 匹配邮箱实例

s = '#@#@#@nickchen121@163.com$$$$////nick@qq.com$$#$#$[]]2287273393@162.com@$2423423lksdlfj#'
# \w(字母/数字/下划线)+(0-无穷个)@ \w(字母/数字/下划线)+(0-无穷个).com
print(re.findall('\w+@\w+\.com', s)) # \. 是使 点 成为一个普通的字符

4. re模块中的常用功能函数

## compile 用来创建Pattern对象
s = 'abcd abcddd abc'
# res = re.compile('abcd*')
email_pattern = re.compile('\w+@\w+.com')
phone_patter = re.compile('\d{13}')
print(re.findall(email_pattern, s))

print(re.findall('abcd*', s))

# ## match:  从开头找一个,找得到就不找了 ;找不到报错 --》
# s = 'ab abcddd abc'
# res = re.match('abcd*', s)
# print(res.group())

## search: 从字符串找一个,就不找了
s = 'ab abcddd abc'
res = re.search('abcd*', s)
print(res.group())

## split
s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.split('\d+', s))

## sub == replace
s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.sub('\d+', ' ', s))

## subn --> 替换了多少次
s = 'ab23423abcddd234234abcasdfjlasjdk234l23lk4j2kl34kl25k3j2kl3j5lkj'
print(re.subn('\d+', ' ', s))

5. 修饰符 re.S

  • 就是flags参数

    ## 修饰符 --> re.S会让.可以匹配换行符\n
    
    # .不匹配换行
    print(re.findall('abc.abc', s))  # ['abc*abc']
    # 匹配换行
    print(re.findall('abc.abc', s, re.S))  # ['abc\nabc', 'abc*abc']
    

6. 补充

## 分组 --> 只要括号里的(*****)
s = 'abc abcd abcdd'
print(re.findall('a(.)c(d)', s))

## 有名分组(了解)
s = 'abc abcd abcdd'
print(re.search('a(?P<name>.)c(?P<name2>d)', s).groupdict())

# 超高级用法
s = 'abc123abc123'  # c123a
print(re.sub('c(\d+)a', ' ', s))
print(re.sub('c(?P<name1>\d+)a', ' \g<name1> ', s))  # \g<name1>这个东西不能替换掉

9. uuid 模块

  • 用来生成一个全世界唯一的长度为36的uuid对象,可以强制转换成字符串类型。去掉 - 则为32位全球唯一字符串

import uuid
print(uuid.uuid4())
print(len(str(uuid.uuid4())))

# 194feb44-98b9-48cd-bcd5-eaeafc46843c
# 36

posted @ 2019-09-28 21:01  BigSun丶  阅读(276)  评论(0编辑  收藏  举报