第十四讲：模块

第十四讲：模块

模块

• 模块化指将⼀个完整的程序分解成⼀个个的小模块
• 通过将模块组合，来搭建出⼀个完整的程序
• 模块化的优点：

1. 方便开发
2. 方便维护
3. 模块可以复⽤

模块的创建

1. 在Python当中⼀个py⽂件就是⼀个模块
2. 在⼀个模块中引⼊外部模块 import 模块名(模块名就是py⽂件)

#语法
import 模块名

3. 可以引⼊同⼀个模块多次，但是模块的实例只会创建⼀次
4. import 模块名 as 模块别名

#语法
import 模块名 as 别名

5. 在⼀个模块内部都有⼀个__name__。通过它我们可以获取模块的名字

#模块a中，写入print(__name__)
#在另一文件中引入该模块时，会打印模块a的模块名

6. 如果py⽂件直接运⾏时，那么__name__默认等于字符串’main’。 __name__属性值为__main__的模块是主模块。⼀个程序中只有⼀个主模块

#在模块中，写入print(__name__)
#直接运行该模块时，会打印__main__

模块的使用

• 访问模块中的变量 语法是 模块名.变量名

#语法
#在模块中定义一些变量，如变量a=1
import 模块名.a
print(模块名.a)

• 访问模块中的函数 语法是 模块名.函数名**(同上)**

#往往使用不直接使用模块中的函数
fn=模块名.函数名
#然后在该文件中使用fn

• 访问模块中的对象 语法是 模块名.对象名 (同上)

如果不想直接调用整个模块，而只使用其中的部分内容

• 我们也可以引⼊模 块中部分内容：
  语法 from 模块名 import 变量

• 如果引入多个内容，可以直接from 模块名 import 变量，函数，对象

• from 模块名 import *与import 模块名的区别：
  import 模块名，如果主程序有引入模块的同名函数或参数，只使用主程序的函数或参数；而如果是from 模块名 import *，则有前后顺序替代问题，具体示例如下。

import test_m
def test1():
    print('主模块test1..')
test1()

def test1():
    print('主模块test1..')
import test_m
test1()

from test_m import *
def test1():
    print('主模块test1..')
test1()

def test1():
    print('主模块test1..')
from test_m import *
test1()

• 如果是在（不同）文件夹中引入文件，可以使用from 文件夹 import 模块名
• 如果还不能导入的话，可以设置该文件夹为根目录
  
• 要想避免上述的替代，还有⼀种引⼊⽅式 语法 from 模块名 import 变量 as 别名，这样为引入模块内的内的函数或变量进行了重命名，可以有效避免和本程序内函数或变量重名被替代的问题
• 我们不希望引入模块内的用来测试的函数被执行，可以添加一行代码

#在引入模块内添加
if __name__ == '__main__'
	#执行命令

总结为：

1 import xxx；
2 import xxx as yyy；
3 from xxx import yyy,zzz,bbb；
4 from xxx import *；
5 from xxx import yyy as zzz

列表推导式

• 推导式 列表推导式 字典推导式 集合推导式
• 语法 [变量 for 变量 in 旧列表] 或者 [变量 for 变量 in 旧列表 if 条件判断]
  如果使用旧的方法，即使用函数的方法：

names=['jerry','amy','tony','james','anny','mcheal','abc','nba']
def fn(lst):
    new_lst = []
    for a in lst:
        if len(a) > 3:
            new_lst.append(a)
    return new_lst
print(fn(names))

使用新方法时：

r=[n.capitalize() for n in names if len(n)>3]
print(r)#.capitalize()是大写首字母函数

# 将1 - 100之间能被3整除的，组成一个新的列表
new_list=[i for i in range(1,101) if i %3==0]

生成器

• 在Python当中有一种一边循环一边计算的机制我们称之为生成器 generator
• 为什么使用生成器：因为很多时候，我们使用推导式得到的数据太多，真正运行起来会占用内存减慢运行速度，于是就想追求一边循环一边计算，需要多少生成多少，可以满足所需而不占用过多的内存
• 如何创建生成器：

1. 只需要将推导式的[]改为（）即可

# 要得到0 - 10之内分别和3相乘的列表 [0 3 6 9 12 15...]
new_lst = [x*3 for x in range(11)]
#那么改为生成器只需要将[]改为（）
g=(x*3 for x in range(11))
print(type(g)) # 结果为g的类型为generator

2. 使用函数的方法创建生成器

• 1. 定义一个函数，函数中要使用yield关键字
• 2. 调用函数，接收调用的结果 结果就是一个生成器
• 3. 借助next() next 获取元素

def fn():
    num = 0
    while True:
        num += 1
        yield num
g=fn()# g即为生成器函数
print(g.__next__())
print(next(g))

• 如何调用生成器：
  使用__next__()
  或者使用next()

g=(x*3 for x in range(11))
print(g.__next__())
print(next(g))

迭代器

• 可迭代:一般就是指可迭代对象,简单理解可以for循环的
• 可迭代对象包含哪些? 1:列表 集合 字典 字符串 元祖 2:生成器
• 如何判断一个对象是否是可迭代的?

from collections import Iterable
g = (x*3 for x in range(10))
lst = [1,2,3]
r = isinstance(g,Iterable)#判断A是否为B的实例
#一开始会报错，没有Iterable模块，按住Ctrl和Enter键，选择Import this name即可导入该模块
print(r)

• 迭代器：可以被next()函数调用并不断返回下一个值的对象，即Iterator。
• 生成器是可迭代的，也是迭代器；列表是可迭代的，但不是迭代器
• 通过**iter()**函数可以将可迭代的变成一个迭代器

lst1 = [1,2,3]
print（next(lst1)）#报错
lst1 = iter(lst1)
print(next(lst1))
print(next(lst1))