14-模块

14-模块

• 1、模块
  • 模块化指将一个完整的程序分解成一个个的小模块
  • 通过将模块组合，来搭建出一个完整的程序
  • 模块化的优点
    • 方便开发
    • 方便维护
    • 模块可以复用
• 2、模块的创建
  • 在Python当中一个py文件就是一个模块
  • 在一个模块中引入外部模块 import 模块名(模块名就是py文件)
  • 可以引入同一个模块多次，但是模块的实例只会创建一次
  • import 模块名 as 模块别名
  • 在一个模块内部都有一个__name__。通过它我们可以获取模块的名字
  • 如果py文件直接运行时，那么__name__默认等于字符串’main’。__name__属性值为__main__的模块是主模块。一个程序中只有一个主模块
• 3、模块的使用
  • 访问模块中的变量 语法是 模块名.变量名
  • 访问模块中的函数 语法是 模块名.函数名
  • 访问模块中的对象 语法是 模块名.对象名
  • 我们也可以引入模块中部分内容 语法 from 模块名 import 变量，变量…
  • 还有一种引入方式 语法 from 模块名 import 变量 as 别名

创建一个mo.py文件

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/18 0018 18:08
# @Author  : Oliver
# 在python当中一个py文件就是一个模块

# 在一个模块中引入外部模块
# 1.import 模块名
# import test_m
# print(test_m)

# 2.import 模块名 as 模块别名
# import test_m as test
# print(test)# <module 'test_m' from 'C:\\demo\\test_m.py'>

# 用过__name__可以获取模块的名字
import test_m
# print(__name__)

 # 使用测试模块的变量
 # 语法是：模块名.变量名
# print(test_m.b,test_m.a)

# 语法：模块名.函数名
# test_m.test1()
# test_m.test2()

# 语法：模块名.对象名
# p=test_m.Person()
# print(p.name)

# 我们引入模块中的部分内容
# 语法 from 模块名 import 变量
# from test_m import Person
# p1=Person()
# print(p1.name)
#
# from test_m import test1
# test1()

# 为了方面可以引入多个模块
# 3.语法 from 模块名 import 变量，变量，变量....
# from test_m import Person,test1,test2
# from test_m import *

# 4.语法： from 模块名 import 变量 as 别名
def test1():
    print('主模块的test....')
# 重名了，怎么调用都是有一方会损失的，但是取别名就会避免这样的影响
from test_m import test1 as new_test
test1()
new_test()

# 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

创建一个test_m.py文件

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/18 0018 18:11
# @Author  : Oliver

# print('这是我的第一个模块')
# print(__name__)
a=1
b=2

def test1():
    print('test1....')
def test2():
    print('test2...')
class Person():
    def __init__(self):
        self.name='葫芦娃'

# 通过这样的形式来避免这个模块的测试代码出现在调用该模块的主程序中，而仅仅在该模块内显示
if __name__=='__main__':
    p=Person()
    test1()
    test2()
    print(p.name)

• 4、推导式

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/18 0018 19:15
# @Author  : Oliver

# 推导式
# 列表推导式  字典推导式  集合推导式
# 语法 [变量 for 变量 in 旧列表]或者[变量 for变量 in 旧列表 if 条件判断]
names=['aaa','bbb','cccww','ddd','eeerr']
# 需求：过滤掉长度小于等于3的人名
'''
def fn(lst):
    new_lst=[]
    for name in names:
        if len(lst)>3:
            new_lst.append(name)
    return new_lst
'''

r=[name.capitalize() for name in names if len(name)>3]
print(r)

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

• 5、生成器

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/18 0018 19:29
# @Author  : Oliver

# a=[x for x in range(10000000000)]
# 在python当中有一种一遍 循环一遍计算的机智我们称之为生成器
# 获取元素的方式1  通过调用__next__来获取元素
# 获取元素的方式2 通过next（）
# 生成器的实现
# 1.通过列表推导式来得到生成器
# 得到0-10之内分别和3相乘的列表[0 3 6 9 12 ....]
# new_lst=[x*3 for x in range(10)]
# g=(x*3 for x in range(10))# 格式是列表推导式的语法格式[]-->()
# print(type(g))# 得到生成器对象
# print(g.__next__())
# print(g.__next__())
# print(next(g))
# print(next(g))

# 第二种方式 通过函数来得到生成器
'''
1.定义一个函数，函数中要是用yield关键字
2.调用函数，接受调用的结果 结果就是一个生成器函数
3.借助next（）或者__next__获取元素
'''
# 只要在函数中yield关键字，那么这个函数就是一个生成器函数
def  fn():
    num=0
    while True:
        num+=1
        # print(num)
        yield num

g=fn()#g是生成器函数
print(g.__next__())
print(next(g))

• 6、迭代器

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/18 0018 21:46
# @Author  : Oliver

# 迭代 获取元素的一次过程
# 可迭代、一般就是指可迭代对象 简单的理解是可以for循环的
# 可迭代对象包含什么？
# 1.列表  集合 字典 字符串 元组
# 2.生成器
# # 如何判断一个对象是否是可迭代的？
# from collections import Iterable
#
# lst=[1,2,3]
# r=isinstance(lst,Iterable)
# print(r)

# 迭代器  可以被next函数调用并不断返回下一个值的对象称为迭代器 Iterator
# lst=[1,2,3]
# print(next(lst))#报错，可迭代对象不一定是迭代器


# 生成器是可迭代的，也是迭代器
# 列表是可迭代的，但是不是迭代器
# 通过iter（）函数可以将可迭代对象转成迭代器
lst1=[1,2,3]
lst1=iter(lst1)
print(next(lst1))