day 21 模块 和 包

模块：已经写号的一组功能的集合

模块名，是按变量的命名规则命名的

模块的导入：

　　import  模块名

　　　　调用模块时  模块名.变量

　　模块导入的过程发生了什么？

　　　　一、找到这个模块

　　　　二、判断这个模块是否被导入过了

　　　　三、如果没有被导入　　　

　　　　　　1. 创建一个属于这个模块的命名空间

　　　　　　2. 让模块的名字执行这个空间

　　　　　　3. 执行这个模块中的代码

模块规则：

　　1. 不能重复导入

　　2. 模块和当前文件在不同命名空间

给模块起别名　　:起了别名之后使用这个模块就都使用别名引用变量了

　　import  my_moudle as m:

　　作用：　　

　　　　一、减少名字的代码量

　　　　二、当你要导入的两个模块都起相同的作用时，起一个别名代替

导入多个模块：

　　建议一个一个导入

导入顺序：  内置模块、第三方模块、自定义模块

by luffycity.com

什么是模块 ? 已经写好的一组功能的集合
别人写好的函数 变量 方法 放在一个文件里 (这个文件可以被我们直接使用)这个文件就是个模块
py dll文件 zip文件

如何自己写一个模块
创建一个py文件,给它起一个 符合变量名命名规则的名字,这个名字就是模块名

import my_module   # pycharm认为你的模块导入不进来
在导入模块的过程中发生了什么?
导入一个模块就是执行一个模块

怎么使用my_module模块中的名字
print(my_module.name)
print(my_module.read1)
my_module.read1()

import的命名空间,模块和当前文件在不同的命名空间中
name = 'egon'
def read1():
    print('main read1')

print(name)
print(my_module.name)

模块是否可以被重复导入
import my_module
import my_module
怎么判断这个模块已经被导入过了???
import sys
print(sys.modules)

模块导入的过程中发生了什么?
    找到这个模块
    判断这个模块是否被导入过了
    如果没有被导入过
        创建一个属于这个模块的命名空间
        让模块的名字 指向 这个空间
        执行这个模块中的代码

name = 'egon'
def read1():
    print('main read1')


print(name)
print(my_module.name)
my_module.read2()

给模块起别名,起了别名之后,使用这个模块就都使用别名引用变量了
import my_module as m
m.read1()

json pickle
dumps loads
def func(dic,t = 'json'):
    if t == 'json':
        import json
        return json.dumps(dic)
    elif t == 'pickle':
        import pickle
        return pickle.dumps(dic)

def func(dic, t='json'):
    if t == 'json':
        import json as aaa
    elif t == 'pickle':
        import pickle as aaa
    return aaa.dumps(dic)

导入多个模块
import os,time
import os as o,time as t
规范建议 模块应该一个一个的导入 : 自定义模块,第三方模块,内置模块
内置模块
扩展(第三方)模块
自定义模块

import os

import django

import my_module

from import

　　　　from  my_module import name

　　执行过程中仍然要执行这个被导入的文件

# from import导入的过程中发生了什么事儿?

　　1.找到要被导入的模块
　　2.判断这个模块是否被导入过
　　3.如果这个模块没被导入过
 　　   创建一个属于这个模块的命名空间
  　　  执行这个文件
  　　  找到你要导入的变量
   　　 给你要导入的变量创建一个引用,指向要导入的变量

# by luffycity.com

# 如何使用 from import
# 需要从一个文件中使用哪个名字,就把这个名字导入进来
# from my_module import name

# from import的过程中仍然执行了这个被导入的文件

# from my_module import read1
# import谁就只能用谁
# read1()
# from my_module import read2
# read2()

# 当前文件命名空间和模块的命名空间的问题
# from my_module import read1
# def read1():
#     print('in my read1')
# read1()
#
# from my_module import read2
# read2()

# from import导入的过程中发生了什么事儿?
# 1.找到要被导入的模块
# 2.判断这个模块是否被导入过
# 3.如果这个模块没被导入过
#     创建一个属于这个模块的命名空间
#     执行这个文件
#     找到你要导入的变量
#     给你要导入的变量创建一个引用,指向要导入的变量
# from my_module import read1
# def read1():
#     print('in my read1')
# read1()
#
# from my_module import read2
# read2()

# 导入多个名字?
# from my_module import read1,read2
# read1()
# read2()

# 给导入的名字起别名
# from my_module import read1 as r1,read2 as r2
# def read1():
#     print('in my read1')
# r1()
# r2()
# read1()

# from my_module import * 在导入的过程中 内存的引用变化
# from my_module import *
# name = 'egon'
# print(name)   # egon
# read1()
# read2()       # alex

# * 和 __all__ __all__能够约束*导入的变量的内容
# from my_module import *
# print(name)
# read1()
# read2()

# from my_module import read1
# read1()

把模块当成脚本使用

 　　当这个文件被当作脚本执行的时候 __name__ =="__main__"

　　当这个文件被当作模块导入的时候 __name__ ==''模块的名字'

模块的搜索路径：

import sys
import calculate
print(sys.path)
path = r'D:sylars15day215模块的循环引用'
sys.path.append(path)

模块引用中的情况：

　　1. 模块之间不允许循环引用

　　2. 已经被导入的模块发生了修改，是不会被感知的

　　　　要想被修改的模块被正在运行中的程序感知到，需要重启这个程序

　　3. 把模块当成脚本来使用

包：

　　文件夹中有一个__init__.py文件、是几个模块的集合

　　导入一个包，相当于执行了这个包下面的__init__.py文件

绝对导入：

　　优点：执行一个py脚本的时候，这个脚本以及和这个脚本同级的模块中只能用绝对导入

　　缺点：所有的导入都要从一个根目录下往后解释文件夹之间的关系；如果当前导入包的文件和被导入的包的位置关系发生了变化，那么所有的init文件都要做相应的调整

相对导入：

　　优点：1.不需要去反复的修改路径，只要一个包中的所有文件夹和文件的相对位置不发生变化

　　　　    2.不需要去关心当前这个包和被执行的文件之间的层级关系

　　缺点：1、含有相对导入的py文件不能被直接执行

　　　　    2、必须放在包中被导入的调用才能正常的使用

# by luffycity.com

# 包 : 文件夹中有一个__init__.py文件
# 包 : 是几个模块的集合

# 从包中导入模块
# import
# import glance.api.policy
# glance.api.policy.get()

# import glance.api.policy as policy
# policy.get()

# from import
# from glance.api import policy
# policy.get()

# from glance.api.policy import get
# get()


# 直接导入包 ,需要通过设计init文件,来完成导入包之后的操作
# 导入一个包
    # 不意味着这个包下面的所有内容都是可以被使用的
    # 导入一个包到底发生什么了?
        # 相当于执行了这个包下面的__init__.py文件

# 绝对导入 :
# 在执行一个py脚本的时候,这个脚本以及和这个脚本同级的模块中只能用绝对导入
# 缺点
# 所有的导入都要从一个根目录下往后解释文件夹之间的关系
# 如果当前导入包的文件和被导入的包的位置关系发生了变化,那么所有的init文件
# 都要做相应的调整


# import glance
# -glance.__init__.py
    # import api
# sys.path = ['D:sylars15day21']
# glance.api.policy.get()

# from bbbbb import glance


# 相对导入 :
# 不需要去反复的修改路径
    # 只要一个包中的所有文件夹和文件的相对位置不发生改变
# 也不需要去关心当前这个包和被执行的文件之间的层级关系
# 缺点
# 含有相对导入的py文件不能被直接执行
# 必须放在包中被导入的调用才能正常的使用

# import glance
# glance.api.policy.get()

# from bbbbb import glance2
# glance2.api.policy.get()

# from . import bbbbb   # 含有相对导入的文件不能被直接执行

# from bbbbb import demo1

# 如果只是从包中导入模块的话,那么我们不需要做任何多余的操作
# 直接导入就行了
# import urllib   # urllib是一个包,单纯的导入一个包啥也不会发生,包中的request.py也不能用
# urllib.request

# from urllib import request
# print(request)

# 如果我们希望导入包的时候,能够顺便把模块也导入进来
# 需要设计init文件
# 绝对目录的导入相对目录的导入各有千秋