day12 - 生成器和模块

1.什么是生成器

生成器就是迭代器中的一种; 生成器作为容器它保存的不是数据，而是产生数据的算法

2.怎么创建生成器

调用带有yield关键字的函数，就可以得到一个生成器
注意: 函数中只要有yield不管遇不遇得到，调用这个函数都不会执行函数体，并且得到的是一个生成器对象

def func1():
    print('=====')
    print('+++++')
    return 100
    if False:
        yield


re = func1()   # 这儿的re就是生成器
print(re)   #

3.生成器怎么产生数据(怎么确定生成器中的元素)

一个生成器能够产生多少个数据和哪些数据，看执行完生成器关联的函数的函数体会遇到几次yield;
遇到几次yield生成器就可以产生多个数据；每次遇到yield，yield后面的数据就是对应的元素

def func2():
    # print('=====')
    yield 10
    # print('++++')
    yield 100
    yield 1000


gen1 = func2()  # 如果把生成器比作一只下蛋的母鸡，声明一个gen1把func2保存起来的过程就相当于把这只母鸡圈养起来。而如果不执行这步操作直接使用func2的话就相当于每次操作都是一只全新的母鸡
for x in gen1:
    print('x:', x)

# print(next(gen1))     # StopIteration

4. 生成器产生数据的规律

生成器怎么获取元素:
获取第一个元素的时候从函数的第一条语句开始执行，执行到第一个yield为止，并且将yield后面的值作为当前获取到的元素；获取下一个元素的时候接着上次结束的往后执行，直到遇到下一个yield为止,并且将yield后面的值作为当前获取到的元素；以此类推...
如果从执行位置开始到函数结束没有遇到yield就会报StopIteration的错误

def func2():
    print('==========')
    yield 1
    print('++++++++++')
    yield 10
    print('**********')
    yield 100
    print('!!!!!!!!!!!')


gen2 = func2()
print(gen2)    # 
print(next(gen2))
print('=====获取第一个值结束====')
print(next(gen2))
print('=====获取第二个值结束====')
print(next(gen2))
print('=====获取第四个值结束====')
# print(next(gen2))    # StopIteration


def func3(n):
    for _ in range(n):
        yield 100


gen3 = func3(4)
next(gen3)
for x in gen3:
    print('x:', x)


def func4(n):
    for x in range(1, n+1):
        yield x*x


gen4 = func4(4)
print(next(gen4))
print(next(gen4))     # 4
for m in gen4:
    print('m:', m)

print(next(func4(4)))   # 1
print(next(func4(4)))   # 1


# 练习:写一个生成器，能够产生一班所有学生的学号，班级人数自己定; 前缀自己定
# 234 -> py001, py023, py122
# 59  -> h501, h534
def create_study_id(pre: str, count: int):
    length = len(str(count))
    for num in range(1, count+1):
        yield pre+str(num).zfill(length)


nums = create_study_id('python', 30)
print(next(nums))
for num in nums:
    print(num)

1.什么是生成式

生成式就是生成器；只是写法上更简洁，只有一行代码

1)语法一:

生成器 = (表达式 for 变量 in 序列) 

相当于普通生成器:
def 函数名():
    for 变量 in 序列:
        yield 表达式
生成器 = 函数名()

2)语法二:

生成器 = (表达式 for 变量 in 序列 if 条件语句)

def 函数名():
    for 变量 in 序列:
        if 条件语句:
           yield 表达式 
生成器 = 函数名()

3)语法三

生成器 = (表达式 for 变量1 in 序列1 for 变量2 in 序列2)

def 函数名():
    for 变量1 in 序列1:
        for 变量2 in 序列2:
           yield 表达式  
生成器 = 函数名()

2.列表生成式

将上面生成式语法中所有的()变成[],结果就会由原来的生成器，变成列表

生成器 = (表达式 for 变量 in 序列) 
[表达式 for 变量 in 序列]  == list(生成器)

# 写一个生成器：产生数字1~10
# 方法一:
def create_num():
    for num in range(1, 11):
        yield num


gen1 = create_num()

# 方法二:
gen2 = (num for num in range(1, 11))
print(gen2)   #  at 0x10e3c0468>
# print(next(gen2))
# print(next(gen2))

print([num for num in range(1, 11)], list(gen2))


gen3 = ('str%s' % x for x in range(5))
print(next(gen3))

def func2():
    for x in range(5):
        yield 'str%s' % x


gen4 = (x for x in range(0, 10) if x % 2)
# gen4中的元素:  1,3,5,7,9
for num in gen4:
    print('num:', num)

导入模块的代码应该放在文件的开头

import random
import math

1.什么是模块

python中一个py文件就是一个模块

2.怎么使用其他模块中的内容(导入模块)

如果想要在一个模块中使用另一个模块中的内容，需要在当前模块中去导入另外的模块

1)怎么导入模块

a. import 模块名 - 导入后可以使用被导入的模块中所有的全局变量(普通全局变量,全局函数,类)；
以'模块名.变量名'的方式去使用模块中的内容

b. from 模块名 import 变量名1, 变量名2, ...
导入后可以使用import后面指定的全局变量;
使用的时候直接用变量名

c. from 模块名 import *
导入模块中所有的全局变量；
使用的时候直接用变量名

d. 对模块进行重命名
import 模块名 as 新模块名 - 重命名后在当前模块中通过新名字来使用导入的模块

e.对模块中的变量进行重命名
from 模块名 import 变量名1 as 新变量名1, 变量名2 as 新变量名2, ...

# =================1.import 模块名================
# import test1
#
# print(test1.a)
# print(test1.x)
# test1.func1()

# =================2.from - import ================
# from test1 import func1, a
# func1()
# print(a)


# =================3.from - import * ================
# from test1 import *
# func1()
# print(a)
# print(x)

# =================3.对模块进行重命名 ================
# import studentManagerSystem as SMS
# import test1 as new_test1
#
# SMS.func2()
# print(new_test1.a)
# test1 = 1200
# print(test1, new_test1.x)


# =================4.对模块中的变量进行重命名 ================
from test1 import func1 as test1_func1, a as test1_a, x
a = 'hello'
print(a, test1_a)


# func1()
def func1():
    print('当前模块中的func1')


func1()
test1_func1()
print(x)

1.导入模块的原理

不管是通过import直接导入模块，还是通过from-import去导入模块的变量。当代码执行到导入模块的语句的时候，系统会自动进入被导入的模块中，执行这个模块中所有的代码；执行完后再回到当前模块接着往后执行

2.阻止导入

如果将模块中的代码写入if name == 'main'这个if语句中，那么这个if语句代码在被导入的时候不会执行。直接运行当前模块的时候会执行

阻止的原理:
在创建模块的时候，系统会自动给这个模块添加属性: name, 用来保存当前模块的名字;
name属性的值默认是当前文件的文件名; 当直接运行当前模块的时候，这个模块的name属性值会变成'main', 运算完成后又变回文件名。

print('06的模块名:', __name__)

# print('========================')
# import test1
import test2

import pygame
pygame.display
pygame.font

1.什么是包

包含init.py文件的文件夹；包是用来管理模块


# ==============1. 导入指定包中指定模块: 使用模块的时候 - 包.模块==============
# import game.display
# print(game.display.bg)   # 背景
# game.display.create_window(100, 200)   # 创建窗口:100x200

# ==============2. 导入指定包中指定模块,对'包.模块'进行重命名==============
# import game.display as display
# print(display.bg)  # 背景
# display.create_window(10, 8)    # 创建窗口:10x8

# ==============3. 导入指定包中指定模块: 使用模块的时候 - 模块==============
# from game import display, font
# print(display.bg)
# display.create_window(1, 2)

# ==============4.直接导入包中指定模块中的指定的变量=======================
# from game.display import create_window, bg
# print(bg)
# create_window(3, 4)

# import game
# print(game.display.bg)
# print(game.bg)

from game import bg, func1
print(bg)
func1()

import hashlib

1.什么是hashlib

hashlib是python提供的用来通过哈希算法进行加密(产生摘要)的一个库
哈希又叫离散算法，主要包含md5、sha两类算法

2.哈希算法加密特点

1）加密后的摘要(密文)是不可逆的
2）相同的数据通过同一种算法产生的摘要是一样的
3）不同长度的数据通过同一种算法产生摘要的长度是一样的

3.怎么产生数据的摘要

1）创建hashlib的对象: hashlib.算法名()
2）添加需要产生摘要的数据: 哈希对象.update(数据)
注意: 数据必须是二进制数据
3）生成摘要(密文): 哈希对象.hexdigest()

# 1.创建哈希对象
hash = hashlib.md5()

# 2.添加数据
# pw = '123456'+'张三'
# hash.update(pw.encode())
hash.update('123456'.encode())
hash.update('张三'.encode())

# 3.生成摘要(密文)
result = hash.hexdigest()
print(result)   # e10adc3949ba59abbe56e057f20f883e



print('====================补充: 字符串和二进制的相互转换==============')
# python中的bytes就是二进制对应的数据类型
# 1.字符串转二进制
"""
1) bytes(字符串, encoding='utf-8')
2) 字符串.encode()  
"""
# 二进制转字符串
"""
1)str(二进制, encoding='utf-8')
2)二进制.decode(encoding='utf-8')
"""