11.1 生成式

迭代器：是一个容器，类型为iter；可以同时存取多个数据，取的时候只能一个一个取，并且取过的数据在容器中就不存在了。

生成器：就是迭代器，数据是通过调用函数获取yield后面的值产生的。数据只会在获取的时候产生。
调用一个带yield关键字的函数，就是创建一个生成器。调用时不会执行，只有当获取生成器中数据时才会执行函数。

• 1.什么是生成式

格式1： 结果是一个生成器（迭代器）
（值1（表达式） for 变量 in 序列）
展开：

def func():
     for 变量 in 序列：
          yield 值1（表达式）

注意：表达式结果就是每次循环生成器产生的数据
这儿的for循环可以控制生成器产生的个数和值

#1.格式1
gen1 = (10 for x in range(10))     # 一个生成器，装有10个元素，每个元素都是10

gen2 = (10*x for x in range(10))     # 一个生成器，装有10个元素，0，10，20.。。

格式2：
(表达式 for 变量 in 序列 if 条件语句)
展开：

def func():
        for 变量 in 序列：
                if 条件语句：
                        yeild 表达式

#2.格式2
gen3 = (x for x in range(10) if x % 2)   # 元素为1，3，5，7，9

re = list(x for x in range(10) if x % 2 == 0) # 列表，元素为0，2，4，6，8

# 交换字典的键值对：dict1 = {'a': 1, 'b':2}
dict1 = {'a': 1, 'b':2}

dict2 = dict((dict1[key], key) for key in dict1)
dict3 = dict((value, key) for key, value in dict1.items())
print(dict2)   # 交换后{1: 'a', 2: 'b'}

11.2 模块使用

• 1.什么是模块
  python中一个py文件就是一个模块

• 2.怎麽关联多个模块

方法1：
import 模块名 - 将指定的模块导入到当前模块中（模块名就是py文件的文件名）

说明：
a.执行import的时候，实质会进入到指定的模块对应的py文件中，去执行里面的代码
b.import导入模块时会检查当前模块是否已经导入过，如果已经导入过则不会再导入（执行）
c.通过import去导入一个模块后，可以通过 模块名.全局变量 去使用被导入的模块中的内容

import test1           # text1 我是模块1;当导入时会执行test1，要加__name__=来判断

a = test1.test1_a
print(a)               # 100；调用test1中的全局变量
test1.test1_func1()    # 我是模块1;调用test1中的全局函数

方法2：
from 模块名 import 变量名/函数名 - 导入指定变量和函数

说明：
a.执行到导入模块语句时，还是会执行指定模块中的所有语句
b.通过from-import导入时，还是会查重
c.使用时只能使用import后面的变量或函数，用时不用在前面加模块名
d.import后面可以使用逗号将多个变量/函数隔开。也可以使用*将模块中所有的全局变量一起导入。

# from test2 import *                      # 将模块2中所有的全局变量一起导入。
from test2 import test2_a, test2_func1      # test2
                                            # 我是模块2
a = test2_a
print(a)                                    # 100
test2_func1()                               # 我是模块2

from random import randint
randint(10, 30)

函数 - 对功能进行封装 - 获取当前时间对应的代码封装到函数中
模块 - 对多个功能和多个数据进行封装；对函数和变量封装 - 将所有和时间相关的函数或变量放到一个py文件中 例：math模块装得都是和数学相关的函数和变量
包 - 对多个模块进行封装 - 将所有和时间相关的py文件放到一个文件夹中
什么是包：含有_init_.py文件的文件夹

• 3.重命名

import 模块名 as 新的模块名
from 模块名 import 变量名 as 新的变量名

import test1 as test1_1
from test import test1

a = test1_1.test1_a   # 100
b = test1.test1_a     # 2000
print(a, b)

• 4.包的导入

import 包名 - 会直接执行包中的_init_.py文件中的代码
import 包名.模块名 - 导入指定包中指定的模块，使用方式：包名.模块名.变量名
from 包名 import 模块名 - 使用方式：模块名.变量名
from 包名.模块名 import 变量名 - 使用方式：变量名

11.3 选择性导入

在模块中将不需要其他模块导入和执行的代码写到if _name_ == '_main_':语句中，就可防止被直接使用。

if  __name__ == '__main__':
    # 不想导入或执行的代码或变量
    # 声明在这的变量也不会被其它模块使用
    a = 100
    print('')

原理：

每个py文件（模块）都有一个属性_name_,默认值为模块名；只有当直接使用模块文件时_name_值才为_main_。可以用print（_name_）来证明。

11.4 文件操作

• 1.数据本地化

将数据以文件形式，存储到本地磁盘中。（程序中变量保存的数据都是存在内存中的，当程序运行结束之后内存中的数据会销毁。）

常见的数据本地化方式：二进制文件（包含音频、视频、压缩包等），普通文本文件，json和xml文件，数据库文件等。

• 2.文件操作（读、写）

文件操作的固定步骤：
打开文件（新建文件） - 文件操作（读、写） - 关闭文件

• 3.打开文件

open(file, mode='r',... ,encoding=None) - 返回的是被打开的文件对象（文件句柄）
文件对象（文件句柄）需要调用相关方法才能操作文件

说明：
file - 字符串；需要打开的文件的路径（可以是绝对路径，也可以是相对路径）

绝对路径：完整的路径（一般不使用）。
例：open('F:\桌面\汇总\cj.txt') 缺点是不能跟着项目走
相对路径：（相对当前py文件对应的目录）
aaa.txt 或者 ./aaa.txt 注：如果文件不带扩展名则不用加扩展名
./ -- 当前目录（可以省略）
../ -- 当前目录的上层目录（不可省）
.../ --当前目录的上上层目录（不可省）

mode - 打开方式；打开文件后不同的操作，对应的打开方式不一样

‘r’ - 默认值，以读的方式打开文件，只读，读出来的是字符串
‘w’- 以写的方式打开文件
‘rb、br’-以读的方式打开，读出来的是2进制，可用于读音频、视频文件等。
‘wb、bw’-以写的方式打开，写的是2进制，写进2进制文件中。
‘a’ - 以写的方式打开，追加
‘+’ - 以读写方式打开

encoding - 文本文件编码方式，一般赋值为‘utf-8’

utf-8 - 能对中文编码，显示
gbk - 不支持中文编码，能存，不能显示

# re = open('F:\桌面\汇总\cj.txt')   # 局限性在于不能跟着项目走
# print(re.read())    # 读取全部
# re.close()          # 打开后需要关闭，重置下标位置
# print('='*88)
# re = open('F:\桌面\汇总\cj.txt')  # 关闭后需要再次打开
# print(re.read())    # 读取全部
# re.close()

re1 = open('aaa')
re3 = open('aaa.txt')     # open('./aaa.txt')省略

# 以读的形式打开一个文本文件，保存到变量re2中。对re2进行操作
# ，就是对被打开的文件进行操作。
# re2 = open('files/cj', 'r', encoding='utf-8')    # open('./files/cj')省略

• 4.文件的读操作

文件句柄（文件对象）.read() - 从文件读写位置开始获取到文件结尾（默认就是获取文件中所有的内容）

文件句柄（文件对象）.readline() - 读一行内容**

# content = re2.read()
# print(content)

# content = re2.readline()       # 第一行
# print(content)
# content = re2.readline()       # 第二行
# print(content)

# 将文件中内容读完，要求一行一行的读


# 法1
def content():
    while 1:
        yield re2.readline()


re2 = open('files/cj', 'r', encoding='utf-8')
print(content().__next__())         # 第一行
print(content().__next__())         # 第二行
print(next(content()))              # 第三行

# 法2
content = (re2.readline() for _ in range(10))   # 只能for循环
print(content.__next__())           # 第四行
print(content.__next__())           # 第五行
print(next(content))                # 第六行

• 5.文件写操作

文件对象.write(字符串) - 将字符串中的内容写入到文件中（会完全覆盖原文件内容）

‘w’ - 完全覆盖，常用
‘a’ - 在原文件后添加

f = open('aaa.txt', 'w', encoding='utf-8')
f.write('第一次写！')         # 第一次写！
f.write('第二次写！')         # 第一次写！第二次写！
f.close()

f = open('aaa.txt', 'w', encoding='utf-8')
f.write('第三次写！')         # 第三次写！

• 6.关闭文件

文件句柄（文件对象）.close() - 关闭指定的文件

f.close()

11.5 二进制文件读取

open方法的另外一种写法：

with open(文件路径，读写方式，encoding=编码方式) as 文件对象：
    文件操作

功能：
打开文件，将文件存在文件对象中。当文件操作完成会自动关闭，所以经常用此写法。

with open('files/cj', encoding='utf-8') as f:
    print(f.read())
print(f.closed)        # True,已关闭

普通的文本文件也可以以二进制形式读和写。

• 2.二进制文件的读

只要将读写方式设置为‘rb/br’就可以了。读出来的就是二进制数据。
注意：
二进制操作不能设置编码方式

with open('files/cj', 'rb') as f:     # 不能设置编码方式
    content = f.read()
    print(content, type(content))       # bytes,二进制类

with open('files/小狐狸.png', 'rb') as f:  # 打开图片
    content = f.read()
    print(content)

with open('小狐狸new.jpg', 'wb') as f:  
# 在当前目录写入图片，要先获取到图片2进制数据
    f.write(content)

# 图片下载
import requests   # 需下载

response = requests.get('图片网络地址')
with open('下载.jpg', 'wb') as f:
     f.write(response.content())

• 3.文件不存在

当以读方式打开一个不存在的文件，会报错。
当以写的方式打开一个不存在的文件，不会报错，会在当前目录下创建它。

11.6 文件操作的运用

# 写一个程序统计当前程序执行的次数。第一次运行控制台打印1，第二次打印2.。
with open('记数本.txt', 'r', encoding='utf-8') as f:
    count = int(f.read())               # 存的是字符串
    print('第%d次进入程序。' % count)
print('运行程序！')
count += 1
with open('记数本.txt', 'w', encoding='utf-8') as f:
    f.write(str(count))                 # 写的是字符串

指导思想：

• 1.使用数据的时候去本地文件中取数据
• 2.数据修改后，将新的数据更新到本地文件中