day21_编写规范与包的使用

from ... import ...导入也发生了三件事
1、产一个模块的名称空间
2、运行foo.py将运行过程中产生的名字都丢到模块的名称空间去
3、在当前名称空间拿到一个名字，该名字与模块名称空间中的某一个内存地址
from foo import x # x=模块foo中值0的内存地址
from foo import get
from foo import change

print(x)
print(get)
print(change)
x=333333333
print(x)
get()
change()
get()

print(x)
from foo import x # x=新地址
print(x)

from...impot...导入模块在使用时不用加前缀
优点：代码更精简
缺点：容易与当前名称空间混淆
from foo import x # x=模块foo中值1的内存地址
x=1111

一行导入多个名字(不推荐)
from foo import x,get,change

*：导入模块中的所有名字
name='egon'
from foo import *
print(name)

from socket import *

了解：_ _ all _ _

_ _ all _ _=['x','get','change'] # 控制*代表的名字

from foo import *
print(x)
print(get)
print(change)

起别名
from foo import get as g
print(g)

解决循环导入问题的两种方式

1.把变量提到最上面

2.在函数内进行导入

def f1():
    from m1 import y
    print(y)

3.模块查找优先级

无论是import还是from...import在导入模块时都涉及到查找问题
优先级：
1、内存（内置模块）
2、硬盘：按照sys.path中存放的文件的顺序依次查找要导入的模块

import sys
值为一个列表，存放了一系列的对文件夹
其中第一个文件夹是当前执行文件所在的文件夹
print(sys.path)

import foo # 内存中已经有foo了
foo.say()

import time
time.sleep(10)

import foo
foo.say()

了解：sys.modules查看已经加载到内存中的模块
import sys
import foo # foo=模块的内存地址
del foo

def func():
import foo # foo=模块的内存地址

func()

print('foo' in sys.modules)

print(sys.modules)

import sys

找foo.py就把foo.py的文件夹添加到环境变量中

sys.path.append(r'/Users/linhaifeng/PycharmProjects/s14/day21/aa')

import foo

foo.say()

模块编写规范

"The module is used to..." #模块的文档描述

import sys #导入模块

x=1 #定义全局变量,如果非必须,则最好使用局部变量,这样可以提高代码的易维护性,并且可以节省内存提高性能

class Foo: #定义类,并写好类的注释
    'Class Foo is used to...'
    pass

def test(): #定义函数,并写好函数的注释
    'Function test is used to…'
    pass

if __name__ == '__main__': #主程序
    test() #在被当做脚本执行时,执行此处的代码

4.包介绍

'''
1、包就是一个包含有__init__.py文件的文件夹

2、为何要有包
包的本质是模块的模块的一种形式，包是用来被当做模块导入
'''

1、产生一个名称空间

2、运行包下的__init__.py文件，将运行过程中产生的名字都丢到1的名称空间中

3、在当前执行文件的名称空间中拿到一个名字mmm，mmm指向1的名称空间

import mmm

print(mmm.x)

print(mmm.y)

mmm.say()

模块的使用者：egon老湿

环境变量是以执行文件为准备的，所有的被导入的模块或者说后续的其他文件引用的sys.path都是参照执行文件的sys.path

import sys

sys.path.append('/aaaaaaaaaaaaaaaaaaaaaaaaaa')
# print(sys.path)

sys.path.append(r'/Users/linhaifeng/PycharmProjects/s14/day21/aa')

import foo # foo下__init__.py

foo.f1()
foo.f2()
foo.f3()

from foo import f1,f2,f3,f4

f1()
f2()
f3()
f4()

import foo
foo.f4()

强调：
1.关于包相关的导入语句也分为import和from ... import ...
两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：
凡是在导入时带点的，点的左边都必须是一个包，否则非法。
可以带有一连串的点，如import 顶级包.子包.子模块,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。
例如：
from a.b.c.d.e.f import xxx
import a.b.c.d.e.f
其中a、b、c、d、e 都必须是包

2、包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

3、import导入文件时，产生名称空间中的名字来源于文件，
import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

绝对导入，以包的文件夹作为起始来进行导入
import sys
print('==========>这是在被导入的__init__.py中查看到的sys.path')
print(sys.path)

from foo.m1 import f1
from foo.m2 import f2
from foo.m3 import f3

from foo.bbb.m4 import f4 # foo内有了一个f4
import foo.bbb.m4.f4 # 语法错误，点的左侧必须是一个包

相对导入:仅限于包内使用，不能跨出包（包内模块之间的导入，推荐使用相对导入）
. :代表当前文件夹
.. :代表上一层文件夹

from .m1 import f1
from .m2 import f2
from .m3 import f3
from .bbb.m4 import f4

强调：相对导入不能跨出包，所以相对导入仅限于包内模板彼此之间闹着玩，而绝对导入是没有任何限制的，所以绝对导入是一种通用的导入方式