day12-包和模块

1.什么是模块

“”"
一个py文件就是一个模块
“”"

2. 模块之间的数据交流

我们可以在任意一个模块中使用另外一个模块中所有的全局变量(普通变量\函数\类)
如果想要在一个模块中使用另外一个模块的内容，必须先导入模块

3.模块的分类：

“”"

1. 系统模块 - 系统已经定义好的模块，程序员可以直接导入使用
2. 第三方库模块(其他程序员或者机构定义的模块) - 需要先下载放到工程中以后再导入使用
3. 自定义模块(在工程中创建的模块) - 程序员直接导入使用
   “”"

4.导入模块

“”"
1)导入方式
import 模块名 - 导入指定模块，导入后可以使用这个模块中所有的全局变量, 使用方式: 模块名.变量
from 模块名 import 变量1,变量2,变量3,… - 导入指定模块，导入后可以使用这个模块中指定的变量，使用方式: 直接用
from 模块名 import * - 导入指定模块，导入后可以使用模块中所有的变量

2)重命名
import 模块名 as 新模块名 - 导入模块的时候对模块进行重命名，重命名后通过新模块名来使用模块
from 模块 import 变量1 as 新变量1, … - 导入模块的时候对指定的变量进行重命名
“”"

1. ==import=
   import test
   import random
   print(test.a)
   print(test.x)
   test.func1()

print(random.randint(10, 30))

2. =form - import=
   from test import x, func1
   from random import randint
   print(x)
   func1()
   print(randint(10, 30))

3. =form - import *=
   from test import *
   print(a)
   print(x)
   func1()

======= 对模块重命名 =========
import test as TS
test = 10
print(test)

print(TS.x, TS.a)
TS.func1()

from test import a as t_a, x, func1
a = ‘hello’
print(a, t_a)

import random
import time
import math

1.导入模块的原理

“”"
当代码指定到import 或者 from-import 导入模块的时候，系统会自动进入指定模块，执行这个模块中所有的代码。

阻止模块中内容的导入：
如果一个模块中的部分代码不希望在被导入的时候执行，就将这个代码写在 if name == ‘main’ 中。
（每个模块都有一个__name__属性，这个属性保存的是模块名，默认值都是文件名。当我们直接执行某个模块的时候，这个模块
的__name__的值会自动变成__main__, 其他没有被执行的__name__的值都是自己的文件名）
“”"
import test1
from test1 import scores
import test2

def func1():
print(‘显示主页面’)

def func2():
print(‘登录’)

def func3():
print(‘注册’)

def main():
# 实现当前模块的功能（功能的实现全靠函数和类）
func1()
func3()
func2()
pass

if name == ‘main’:
main()

1.什么是包

“”"
包就是包含__init__.py文件的文件夹
“”"

2.怎么使用包中的模块里面的内容

“”"
import 包.模块
from 包 import 模块
from 包.模块 import 变量1, 变量2, …
“”"

=======1. import 包.模块 =========
import file.fileManager
file.fileManager.read_file()

import file.fileManager as FM
FM.read_file()
FM.write_file()

=2. from 包 import 模块=
from file import fileManager
fileManager.read_file()
fileManager.write_file()
=========3. from 包.模块 import ==========
from file.fileManager import f_name, read_file
print(f_name)
read_file()

3.导入包的原理

“”"
导入包的时候，会执行执行包中的__init__.py文件中所有的代码
“”"
import file
import file.fileManager
from file import fileManager

import file

print(file.a)
file.file_message()
file.read_file()

from file.fileManager import read_file
read_file()

from file import read_file
read_file()

from file import fileManager

4.重复导入

“”"
import在导入模块或者包的时候会自动检查对应模块或者包之前是否已经导入过了，如果已经导入不会再重复导入
“”"
include aa.h

1.标准库和第三方库
“”"
标准库 - python自己提供模块或者包, 用的时候可以直接导入
第三方库 - 由别人提供的模块或者包，需要先安装或者下载后才可以导入
“”"

常用标准库

“”"
os模块 - 提供文件或者文件夹操作的相关功能(例如: 创建文件/文件夹、删除文件/文件夹、…)
sys模块 - 提供系统相关的操作
time模块 - 时间相关操作
datetime模块 - 时间相关的操作
json模块 - json操作
re模块 - 正则表达式相关操作
hashlib - 加密模块
…

turtle模块 - 画图
“”"

import time

1.time() - 获取当前时间, 返回的是时间戳

2. sleep(时间) - 让程序睡眠指定时间(秒)

3. localtime() - 获取当前的本地时间

4. localtime(时间戳) - 将时间戳对应的时间转换成struct_time（转换我们认识的时间值）

t1 = time.time()
time.sleep(1)
t2 = time.time()
print(t2 - t1)
print(t1, type(t1))

补充：时间戳
时间戳就是当前时间到格林威治时间的1970年1月1日0时0分0秒的时间差, 单位是秒
t1 = 1596615744.128383 + 20000 # 4个字节

‘2020/8/5/16:31:50’ # 17个字节
print(time.localtime(t1))

from datetime import datetime
print(datetime.now())

import hashlib

1.hashlib模块的使用

“”"
hashlib是python3.x中提供的一个标准库，专门用来对数据进行hash加密的，常用的加密算法是: md5、shaxxx

hash算法:
hash算法又叫摘要算法或者离散算法
“”"

2.hash(md5)加密的特点

“”"
a. 同样的内容使用相同的算法加密之后的结果是一样的
b. 加密之后的结果不可逆
c. 不管原数据的大小或者长度是多少，使用同一种加密算法得到的密文(摘要)的长度是一样的
“”"

3.生成摘要(对数据加密)

1) 根据算法创建hash对象

hashlib.算法名()

hash = hashlib.md5()

2).使用hash对象对指定的数据加密

hash对象.update(数据) - 对指定的数据加密(这儿的数据必须是二进制数据,类型是bytes)

pw = ‘123456’
hash.update(bytes(pw, encoding=‘utf-8’))
hash.update(pw.encode())

3).获取摘要(获取加密后的密文)

di = hash.hexdigest()
print(di)

4.hash加密的应用2：生成数据摘要，确保原数据的完整性

with open(‘test.txt’, ‘rb’) as f:
content = f.read()

hash2 = hashlib.md5()
hash2.update(content)
hash2.update(‘2020-5-8 5:49:0’.encode())
print(hash2.hexdigest())

print(’======================================’)
补充：二进制和字符串之间的相互转换
“”"

1. 字符串 -> 二进制
   bytes(字符串, encoding=‘utf-8’)
   字符串.encode()

2. 二进制 -> 字符串
   str(二进制, encoding=‘utf-8’)
   二进制.decode(encoding=‘utf-8’)
   “”"
   b = ‘acb’.encode()
   print(type(b))
   str_b = str(b, encoding=‘utf-8’)
   print(str_b, type(str_b))
   str_b2 = b.decode(encoding=‘utf-8’)
   print(str_b2, type(str_b2))

from re import fullmatch

fullmatch(正则表达式, 字符串) - 判断正则表达式和字符串是否完全匹配，如果不能匹配返回None

1. 什么是正则表达式

“”"
正则表达式是一种处理字符串的工具
“”"

2.正则的语法（通用）

print(’=====第一种符号: 匹配符号=’)

1) 普通字符

“”"
除了在正则中有特殊功能和特殊意义以外的字符就是普通字符。
普通字符在正则表达式中表示这个字符本身
“”"
re_str = r’abc’
print(fullmatch(re_str, ‘abc’))

2) . - 匹配一个任意字符

re_str = r’.bc’ # 匹配一个长度是3的字符串，后两个字符是bc, 第一个字符是任意字符
print(fullmatch(re_str, ‘你bc’))
print(fullmatch(re_str, ‘bc’)) # None
print(fullmatch(re_str, ‘abb’)) # None

re_str = r’x.x’
print(fullmatch(re_str, ‘x=x’))

3) \w - 匹配任意一个数字、字母或者下划线(在ASCII码表中)

re_str = r’\w123’
print(fullmatch(re_str, ‘9123’))
print(fullmatch(re_str, ‘A123’))
print(fullmatch(re_str, ‘_123’))
print(fullmatch(re_str, ‘+123’)) # None
print(fullmatch(re_str, ‘胡123’)) # 注意：\w可以匹配任意非ASCII码中的字符

4) \d - 匹配任意一个数字字符

re_str = r’\d\dabc’
print(fullmatch(re_str, ‘23abc’))
print(fullmatch(re_str, ‘00abc’))
print(fullmatch(re_str, ‘2Habc’)) # None

5) \s - 匹配任意一个空白字符

常见的空白字符：’ ‘、’\n’、’\t’
re_str = r’\d\d\s\d’
print(fullmatch(re_str, ‘12 3’))
print(fullmatch(re_str, ‘89\t3’))
print(fullmatch(re_str, ‘90\n4’))
print(fullmatch(re_str, ‘12 3’)) # None

6. \大写字母(\W, \S, \D)
   \大写字母 的功能和 \小写字母 的功能相反
   \S - 匹配任意一个非空白字符
   \D - 匹配任意一个非数字字符

7) [字符集] - 匹配字符集中的任意一个字符

“”"
注意: a.一个[]只能匹配一个字符 b.[字符1-字符2]中两个字符之间的-表示范围：字符1到字符2， 并且要求字符1的编码值必须小于字符2
[abc] - 匹配a或者b或者c
[a-z] - 匹配任意一个小写字母
[A-Z] - 匹配任意一个大写字母
[a-zA-Z] - 匹配任意一个字母
[0-9] - 匹配任意一个数字
[2-9] - 匹配2到9的任意一个数字字符
[\u4e00-\u9fa5] - 匹配任意一个中文字符
“”"
re_str = r’[xam]123’
print(fullmatch(re_str, ‘a123’))
print(fullmatch(re_str, ‘x123’))
print(fullmatch(re_str, ‘m123’))
print(fullmatch(re_str, ‘b123’)) # None

re_str = r’[3-7]abc’
print(fullmatch(re_str, ‘3abc’))
print(fullmatch(re_str, ‘7abc’))
print(fullmatch(re_str, ‘6abc’))
print(fullmatch(re_str, ‘2abc’)) # None

re_str = r’[0-9a-zA-Z_]abc’ # abc前面是任意数字、字母或者下划线
print(fullmatch(re_str, ‘4abc’))
print(fullmatch(re_str, ‘Kabc’))
print(fullmatch(re_str, ‘_abc’))

re_str = r’[\dxy]abc’ # abc前面是任意数字或者x或者y
print(fullmatch(re_str, ‘8abc’))
print(fullmatch(re_str, ‘xabc’))
print(fullmatch(re_str, ‘yabc’))

8) [^字符集] - 匹配任意一个不在字符集中的字符

“”"
[^abc] - 匹配一个不是a、b、c的任意一个字符
[^a-z] - 匹配一个不是小写字母的任意一个字符
“”"
re_str = r’[^xy]abc’
print(fullmatch(re_str, ‘xabc’)) # None
print(fullmatch(re_str, ‘yabc’)) # None
print(fullmatch(re_str, ‘9abc’))
print(fullmatch(re_str, ‘Kabc’))
print(fullmatch(re_str, ‘=abc’))

注意：

a. []中的^{只有放在最前面的时候才有特殊意义，在其他位置的时候表示字符}本身

b. []中的-只有在两个字符之间的时候才有特殊意义，否则也是表示字符-本身

re_str = r’[x^y]abc’
print(fullmatch(re_str, ‘xabc’))
print(fullmatch(re_str, ‘yabc’))
print(fullmatch(re_str, ‘^abc’))

re_str = r’[09-]abc’
print(fullmatch(re_str, ‘0abc’))
print(fullmatch(re_str, ‘9abc’))
print(fullmatch(re_str, ‘-abc’))
print(fullmatch(re_str, ‘8abc’)) # None

print(’======2. 匹配次数=’)

1) * - 匹配0次或多次

“”"
a* - a匹配0次或者多次
\d* - 任意数字出现0次或多次
[abc]* - [abc]匹配0次或者多次
“”"
re_str = r’a*123’
print(fullmatch(re_str, ‘123’))
print(fullmatch(re_str, ‘a123’))
print(fullmatch(re_str, ‘aaaaa123’))

re_str = r’\d*abc’
print(fullmatch(re_str, ‘abc’))
print(fullmatch(re_str, ‘4abc’))
print(fullmatch(re_str, ‘478abc’))

2) + - 匹配1次或多次

re_str = r’\d+abc’
print(fullmatch(re_str, ‘abc’)) # None
print(fullmatch(re_str, ‘2abc’))
print(fullmatch(re_str, ‘7238abc’))

3) ? - 匹配0次或一次

re_str = r’m?123’
print(fullmatch(re_str, ‘123’))
print(fullmatch(re_str, ‘m123’))
print(fullmatch(re_str, ‘mm123’)) # None

4) {}

“”"
{N} - 匹配N次
{M,N} - 匹配M到N次
{M,} - 匹配至少M次
{,N} - 最多N次
“”"
print(fullmatch(r’\d{3}abc’, ‘890abc’))

print(fullmatch(r’x{3,5}abc’, ‘xxxabc’))
print(fullmatch(r’x{3,5}abc’, ‘xxxxabc’))
print(fullmatch(r’x{3,5}abc’, ‘xxxxxabc’))

print(fullmatch(r’x{3,}abc’, ‘xxxxxxxxxabc’))
print(fullmatch(r’x{3,}abc’, ‘xxabc’)) # None

print(fullmatch(r’x{,3}abc’, ‘abc’))
print(fullmatch(r’x{,3}abc’, ‘xxabc’))
print(fullmatch(r’x{,3}abc’, ‘xxxabc’))
print(fullmatch(r’x{,3}abc’, ‘xxxxabc’)) # None

“”"