一、模块的使用
1. 模块使用说明
python中一个py文件就是一个模块，
可以通过import 或者 from - import在一个模块中去使用另一个模块的内容
import 模块名
---> 将模块中所有的内容都导入，并且可以在当前模块中通过“模块名.”的方式去使用所有的全局变量
(推荐，可以从代码中看出来是从哪个模块中导入的）from 模块名 import 变量1，变量2，……
--> 将模块中所有的内容都导入，但是只能使用import后面的变量from 模块名 import *
--> 将模块中所有的内容都导入，可以直接使用模块中所有的变量
代码执行到import的时候，会将import后面的模块的内容执行一遍
例：
# import test1
# # 100
# # 这是test1中的内容
# # hello test1
#
# print(test1.test_a + 1) # 101
# test1.test1_func1() # hello test1
test1.py中代码如下：
test_a = 100
print(test_a)
print('这是test1中的内容')
def test1_func1():
print('hello test1')
test1_func1()
# from test1 import test_a
# print('当前模块：', test_a)
# print('当前模块：', test_func1) # NameError: name 'test_func1' is not defined
# from test1 import test1_func1, test_a
# # 100
# # 这是test1中的内容
# # hello test1
#
# test1_func1() # hello test1
# from test1 import *
# # 100
# # 这是test1中的内容
# # hello test1
# test1_func1() # hello test1
2.重命名
import 模块吗 as 模块的新名字 （给模块重命名，使用的时候使用新的名字）
from 模块名 import 变量名1 as 新名1， 变量名2，…… （给部分变量重新命名）
# import test1 as TS
# # 100
# # 这是test1中的内容
# # hello test1
#
# TS.test1_func1() # hello test1
# from test1 import test_a as ts_a
# test_a = 50
# # 100
# # 这是test1中的内容
# # hello test1
# print(ts_a + 1) # 101 (使用test1模块的test_a变量）
# print(test_a) # 50 (当前模块的test_a变量）
3.import：
可以检查被导入的内容之前是否已经导入过，如果导入过，不会再重复导入，但是多种导入的效果可以同时生效
# 导入多次，但是只执行一次,多种导入的效果可以同时生效
# import test1
# import test1
# from test1 import test1_func1 as ts_a
# # 100
# # 这是test1中的内容
# # hello test1
#
# test1.test1_func1() # hello test1
# ts_a() # hello test1
二、选择性导入（阻止导入）
1.阻止导入的方法：
if __name__ == ‘__main__':
代码块
说明：
if __name__ == ‘__main__': --> 固定写法
代码块 --> 直接执行当前模块，代码块会被执行，如果在别的模块中被导入，代码块不会执行
test1.py中代码：
def test1_func1():
print('hello test1')
if __name__ == '__main__':
test_a = 100
print(test_a)
print('这是test1中的内容')
test1_func1()
import test1
# 没有打印
test1.test1_func1() # hello test1
# test1.test_a在阻止导入代码块中，不会导入
# print(test1.test_a) # AttributeError: module 'test1' has no attribute 'test_a'
2.阻止导入语句的原理
每一个模块都有一个 name 属性，这个属性的默认值是当前模块对应py文件的文件名，
当当前模块正在被执行（直接）的时候，系统会自动将模块的name属性变成'main'
import test1
print(__name__) # __main__
print(test1.__name__) # test1
3.什么时候使用模块
将具有相同的功能的函数和数据封装到一起
三、迭代器
1.什么是迭代器(iter)
迭代器是python中一种容器类的数据类型，属于序列。没有具体的字面量，
可以将其他的序列转换成迭代器: iter(序列)
2.迭代器的特点
只能通过next方法去一个一个地按顺序获取迭代器中的元素，取出后迭代器中就不存在这个元素了
print(iter([5, 6, 7])) #
iter1 = iter('abc')
print(iter1) #
print(next(iter1)) # a
print(next(iter1)) # b
print(next(iter1)) # c
# print(next(iter1)) # StopIteration
3.遍历迭代器
print('===============')
iter1 = iter(['abc', 1, 'name'])
for x in iter1:
print(x)
# abc
# 1
# name
next(迭代器）
迭代器.next()
iter2 = iter((1, 2, 3))
a = iter2.__next__()
print(a) # 1
print(next(iter2)) # 2
list1 = list(iter2)
print(list1) # [3]
四、生成式和生成器
1.什么是生成器
生成器就是迭代器，但是迭代器不一定是生成器
生成式就是生成器的一种特殊形式：(变量 for 变量 in 序列)
例：产生一个生成器，生成器中可以生成的数据是数字0~4（每个元素是数字）
ge1 = (x for x in range(5))
print(ge1)
print(next(ge1))
print(next(ge1))
print('=========')
for item in ge1:
print(item)
ge2 = (x*2 for x in range(5))
print('=========')
for item in ge2:
print(item)
ge2 = ([x, x*2] for x in 'abc')
print(next(ge2))
print('===========')
ge2 = (x for x in range(5) if x%2)
for item in ge2:
print(item)
2.生成器就是函数体中有yield关键字的函数
--> (函数中只要有yield，那么调用这个函数不再是执行函数体并且获取返回值，而是产生一个生成器)
通过next获取生成器的元素的时候，会去执行生成器对应的函数的函数体，执行到yield为止，并且将yield后面的值作为返回值(元素值)。
然后保存当前结束的位置，下次一获取生成器的元素的时候会接着上次结束位置往后执行，执行到yield.....
生成器可以当成序列来使用
print('============')
def func1(n):
print('你好，生成器!!')
for x in range(n+1):
print(x)
yield x
print('yeye')
ge3 = func1(3)
print(ge3)
print('=:',next(ge3)) # 0
print('=:',next(ge3)) # 1
print(next(ge3)) # 2
print(next(ge3)) # 3
# print(next(ge3))
def func2():
str1 = 'abcdef'
index = 0
while index < len(str1):
yield str1[index]
index += 1
ge4 = func2()
print(next(ge4))
#
print(next(ge4))
print(list(ge4))
def func3():
num = 0
while True:
yield num
num += 1
ge5 = func3()
print(ge5)
print('==:',next(ge5))
print('==:',next(ge5))
print('========')
for _ in range(5, 100):
print(next(ge5))
print('=======')
print(next(ge5))
练习： 生成器生成的数据的规律：奇数就返回他本身，偶数就返回它的2倍
def func2(n):
for x in range(n):
yield x, 2*x, 3*x
# yield 2*x
# yield 3*x
# if x%2:
# yield x
# else:
# yield x*2
g6 = func2(5)
print(next(g6))
print(next(g6))
print(next(g6))
五、文件的读写
使用文件可以做数据的持久化(本地化) ---> 数据库文件，txt、json，plist，二进制文件
1.文件操作 -- 读写操作
读 -> 取出文件中的数据
写 -> 将数据写到文件中
所有文件操作的过程：打开文件 --> 操作文件 --> 关闭文件
2.打开文件和关闭文件
open(file, mode='r',encoding=None)
a. file -> 文件路径(必须传参)，决定需要打开的是哪个文件
绝对路径（不推荐使用）
相对路径: ./相对路径 (相对路径是相对当前py文件对应的文件夹)
./ ---> 当前文件夹
../ --> 当前文件夹的上层文件夹
.../ --> 当前文件夹的上层文件夹的上层文件夹b. mode -> 文件打开方式（不同的操作对应不同的打开方式）
'r' --> 以只读的形式打开文件, 文本
'rb'/'br' --> 读操作，读出来的数据是二进制形式的数据
'w' --> 以写的形式打开文件
'bw'/'wb' --> 写操作，将二进制数据写入文件
'a' --> 写操作，追加c. encoding -> 文本文件的编码方式
utf-8 :几乎支持所有的语言文字
gbk : 只支持英文d. open函数的返回值，就被打开的文件对象
关闭文件: 文件对象.close()
========================文件的读操作=====================
- 打开文件
f1 = open('./test1.txt', 'r', encoding='utf-8')
- 读文件中的内容
文件对象.read() --> 从文的读写位置读到文件结束,返回读到的结果
文件对象.readline() --> 读一行
文件对象.readlines() --> 返回一个列表，列表的元素是文件中每一行的内容
content = f1.read()
print(type(content), content)
# print('==:', f1.read())
# content = f1.readlines()
# print(content)
- 关闭文件
f1.close()
** ==================文件的写操作==================**
- 打开文件
'w' -> 将字符串写入文件中， 完全覆盖文件原来的内容
'wb'/'bw' -> 将二进制写入文件中, 完全覆盖文件原来的内容
'a' -> 追加
f2 = open('./test1.txt', 'w', encoding='utf-8')
- 写入文件
f2.write(content+'hello world') # 这样写可以接着之前读取的内容写
f2.writelines(['abc\n', '123\n', 'aaaaa\n']) # 覆盖写
- 关闭文件
f2.close()