包 ，模块（time、datetime、random、hashlib、typing、requests、re）

目录

• 1. 包
• 2. time模块
  • 1. 优先掌握
  • 2. 了解
• 3. datetime模块
  • 1. 优先掌握
• 4. random模块
  • 1. 优先掌握
  • 2. 了解
• 5. hashlib模块和hmac模块
• 6. typing模块
• 7. requests模块
• 8. re模块
  • 1. re模块的正则表达式的元字符和语法
  • 2. 贪婪模式和非贪婪模式
  • 3. 匹配邮箱实例
  • 4. re模块中的常用功能函数
  • 5. 修饰符 re.S
  • 6. 补充
• 9. uuid 模块

1|01. 包

• 什么是包

  包就是模块

• 包有什么用

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

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

  3. 未来导包就是导__init__

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

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

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

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

  相对导入：

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

  绝对导入：

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

  2|02. time模块

• time模块的作用

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

• 三种类型的时间

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

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

2|11. 优先掌握

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

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

2|22. 了解

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|03. datetime模块

• datetime模块的作用

  可以实现时间的加减

3|11. 优先掌握

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|04. random模块

• random模块的作用

  产生随机数

4|11. 优先掌握

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())

4|22. 了解

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

5|05. 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|06. typing模块

• typing模块的作用

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

• 实例

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

7|07. requests模块

• request是模块的作用

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

• 实例

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

8|08. re模块

• re模块的作用

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

• 正则表达式 ： Pattern

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

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

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

8|11. 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个到无穷个
  
  

8|22. 贪婪模式和非贪婪模式

# 贪婪模式

# .（一个任意字符）*（0-无穷个）

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

# 非贪婪模式（*******）

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

8|33. 匹配邮箱实例

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

8|44. 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))

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

8|66. 补充

## 分组 --> 只要括号里的（*****）
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|09. uuid 模块

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

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

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

__EOF__

本文作者：BigSun丶
本文链接：https://www.cnblogs.com/Mcoming/p/11604846.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！