python高级day01

装饰器

什么是装饰器:
    python装饰器就是用于拓展原来函数功能的一种函数，这个函数的特殊之处在于它的返回值也是一个函数
    
 装饰器的功能要求:
    装饰器实际是软件设计模式的一种名称，他要求具备的功能是：
	在不改变原函数代码的基础上，增加新的功能

装饰器实现

1. 概念:本质也是一个函数, 用于加强原函数, 这个函数就是装饰器
    备注: 原函数功能不变的情况进行加强

2. 如何实现装饰器函数
    1. 定义一个函数
    2. 接收原函数作为参数
    3. 新增新功能
3. 装饰器的使用
    def 装饰器函数(原函数):
        pass

    @装饰器函数   # 语法糖 类方法,静态方法 装饰器的使用
    def 原函数():
        pass
    
例子:
import time


# 装饰器函数:统计一个函数运算时间
def decorator(old_func):  # 传入原函数
    # 定义一个子函数,将子函数返回
    def inner():
        # 新增功能
        # 原函数功能不变
        start = time.time()  # 开始时间
        res = old_func()  # 调用原函数
        end = time.time()  # 结束时间
        print("函数运行时间", end - start)
        # 返回结果
        return res

    # 返回原函数
    return inner()


# 原函数
@decorator
def count():  # 求和
    # 模拟运行时间长
    c = 0
    for i in range(100000000):
        c += i
    return c


# 装饰器使用
# count=decorator(count)
result = count()
print(result)
# result=count()

随机模块

random随机模块:
接口名称	          	类型	               说明
random.random()		   实数相关		用于生成一个0到1的随机浮点数: [0, 1)
random.uniform(a,b)			   	   生成[a,b]或[b,a]之间的均匀分布随机浮点数。
random.randint(a,b)	   整数相关		生成[a,b]的随机整数，要求a < b。
random.randrange(a,b)		   	   生成[a,b)的随机整数，第三个参数可以指定步长。
random.choice(seq)	   序列相关		从序列中随机选择一个元素，若序列为空，则抛出异常。
random.shuffle(seqb)		   	   打乱原序列，原序列必须可写。
random.sample(seq,k)		   	   从序列中随机选择k个元素返回，原序列不变。
random.seed(n=none)	   初始化	     初始化随机熵池。  
例子:
import random

# 初始化随机熵池
# random.seed(1)

# 随机生成0到1之间的小数
print(random.random())
# 随机生成两个数之间的小数
print(random.uniform(1, 10))
# 随机生成两个数之间的整数,前面数比后面小
print(random.randint(1, 10))
# 生成随机整数,可指定步长
print(random.randrange(1, 10))
# 从一个序列中选取一个元素随机
print(random.choice([1, 2, 3, 4, 5, 6]))
# 打乱原序列,原序列必须是可修改的
seq = [1, 2, 3, 4, 5, 6, 7, 8]
random.shuffle(seq)
print(seq)
# 从原序列中选取多个元素返回
print(random.sample([1, 2, 3, 5, 4, 5, 4], 3))

# 随机生成随机四位验证码
import string

string = string.ascii_letters + "0123456789"
code = ""
for i in range(4):
    code += random.choice(string)
print(code)                                  

datetime模块

1. 概念
    主要有两个模块非常重要, time和datetime模块

    time模块: 基于计算机底层时钟实现的模块. 计算机时间是默认使用4个字节存储, 这个时间也就是
    时间戳. 21亿秒--->2038年

    datetime高级模块: 对于time模块的二次封装和改进, 表示 0000-9999 年

2. time模块
    语法:
    import time
    time.time() : 获取当前时间戳
    time.sleep(秒) : 让程序休眠多少秒(让出cpu)
3.datetime模块
    该模块上有两个重要的类, datetime类和timedelta类
    语法:
    from datetime import datetime,timedelta

    使用:
        datetime类的使用
        datetime.now() : 创建当前时间对象
        datetime(year=2020,month=1,day=8......) : 创建指定时间对象
        datetime.strptime(): 将字符串转换会时间对象

        # 时间对象上的方法
        时间对象.year
        时间对象.month
        时间对象.day

        时间对象.strftime()  # 将时间对象进行字符串格式,用于自定义时间展示
        
        
        
例子:
import time
time.sleep(2)
print("欢迎进入")
time.sleep(2)
print("源码时代")
print(time.time())




datetime例子:
# datetime模块使用
from datetime import datetime

# 获取当前时间对象
now_time = datetime.now()
print(now_time)

# 自定义展示时间
print(now_time.strftime("%Y-%m-%d %H:%M:%S"))

# 时间字符串
date_string = "2020-01-08 15:37:15"
# 将时间字符串转换成时间对象
date_obj = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S")
print(date_obj)
print(date_obj.year)

import time

# 时间计时
while True:
    print("\r时间:", datetime.now().strftime("%H:%M:%S"),end="")
    time.sleep(1)

timedelta模块

timedelta类: 用于处理时间对象之间的差(时间计算), 时间跨度类
        创建对象的方式:
            1. 两时间对象相减
            2. 创建跨度对象
                timedelta(days=100)
例子:
# 计算距离国庆还有多少天
from datetime import datetime, timedelta

days = datetime(year=2020, month=10, day=1) - datetime.now()
print(days)
print(days.seconds)
print(days.total_seconds())

# 计算一百天后的日期
future = datetime.now() + timedelta(days=100)
print(future)

哈希散列

1. 哈希散列 是一种算法, 用于对数据进行加密, 生成固定长度小量的数据, 是原数据的唯一识别码.
    注意: 哈希散列算法是不可逆的算法

2. 用处:
    a. 密码加密
    b. 软件生成md5码进行比对安全.

3. 常见的算法
    a. md5

    b. sha (名称来自于安全散列算法2（Secure Hash Algorithm 2）)

4. 算法的使用步骤
    a. 导入算法库模块
        import hashlib
    b. 准备需要加密的数据(二进制)
        1. b"字符串"
        2. 变量名.encode("utf-8")
        3. 读取文件的时候采用rb
    c. 创建算法对象
        h=hashlib.md5(二进制数据)
        h=hashlib.sha256(二进制数据)
        h=hashlib.sha512(二进制数据)
    d. 获取加密结果
        h.hexdigest()
        
        
例子:
# a. 导入算法库模块
import hashlib
# b. 准备需要加密的数据(二进制)
# password = "1234567fasdfasdfasdfasdfasdfasdf"
# password = password.encode("utf-8")

# 检查软件的md5
fp = open("./python-3.8.1-amd64-webinstall.exe","rb")
data = fp.read()
fp.close()

# c. 创建算法对象
h = hashlib.md5(data)
# h = hashlib.sha256(password)
# h = hashlib.sha3_256(password)
# d. 获取加密结果
res = h.hexdigest()
print(res)
print(len(res))

迭代器和生成器

"""
容器: 存储多个元素的数据结构
    例如: 列表,元组,字典,集合,字符串

迭代器(for ... in ...遍历的底层实现)
    a. 使用 iter(容器) ----> 生成迭代器
    b. 使用 next(迭代器) 每次取下一个元素
    c. 取完抛出异常 StopIteration

生成器:
    概念:
        1. 生成器是特殊的迭代器(使用方式和迭代器一样)
        2. 生成器中的元素不是直接生成, 而是每次调用next()才生成
        3. 好处: 大大的节约内存资源

    定义生成语法:
        1. 方式一: 列表推导式生成器
            g = (表达式 for i in 容器 简单判断语句) # range()  generate

        2. 方式二: 函数式生成器
            a. 定义函数的时候,只要函数中出现了 yield , 这个函数就是生成器函数
            b. 调用函数:  生成器函数名() 不会立马执行函数体, 返回生成器对象
            c. 当使用 next(生成器对象) 执行函数体
            d. 当执行到 yield 数据, 返回数据到 next() 调用位置 并且 暂停 代码运行.
            e. 当下次再调用 next() 才继续运行.
"""


# 生成器函数 1-任意
def showNum():
    i = 1
    while True:
        yield i  # 返回
        i += 1


# g = showNum()  # 返回生成器对象
# print(next(g))
# print(next(g))
# print(next(g))


# 生成斐波那契数列:1 1 2 3 5 8 13 ............
def fbnq():
    a, b = 1, 1  # 初始化值
    while True:
        yield a + b
        a, b = b, a + b
# 使用
g = fbnq()
print(next(g))
print(next(g))
print(next(g))


"""
生成 1-10000000 列表
"""
# l = [i for i in range(1,1000000000)] # 直接生成数据 对内存消耗非常大
# print(l)

# 生成器实现
# g = (i for i in range(1,1000000000)) # 直接生成数据 对内存消耗非常大
# print(g)
# print(next(g))
# print(next(g))
# print(next(g))


"""
names = ["张飞","李四","关羽","曹操","刘备"]
# for ... in ...
# 通过迭代器的形式遍历列表
d = iter(names)
while True:
    try:
        print(next(d))
    except Exception as e:
        pass
# print(d)
# print(next(d))
# print(next(d))
# print(next(d))
# print(next(d))
# print(next(d))
# print(next(d))
"""