函数 -- 1.模块导入 2.ATM架构 # 14

"""
1.什么是模块?
  模块:就是一系列代码的集合体

2.模块的三种来源:
    1.内置的(Python解释器自带)
    2.第三方的(别人写的)
    3.自定义的(你自己写)

4.模块的四种表现形式:
    1.使用Python编写的py文件(即:一个py文件也可以表示一个模块)
    2.已被编译为共享库或者DLL(动态链接库)的C或者C++扩展(了解)
    3.把一系列模块组织到一起的文件夹,(文件夹下有一个py文件,该文件称为包
    4.使用C编写并连接到Python的内置模块

4.为什么要使用模块?---优点
    主要目的:节省使用空间,提高开发效率
    1.使用别人写的,Python内置或者第三方已提供,属于典型拿来主义,极大地提高了开发的效率
    2.在做项目时,文件通常都是比较大的,,不可能只有一个py文件,当多个运行都需要调用时,无须再重写,直接调用,极大提高开发效率,并且逻辑清晰,简单明了

5.如何使用模块:
    ps: 需要区分哪个是执行文件,哪个被导入文件,方便之后运行
    1.import导入模块  -- 2.import导入模块
        ### 注:导模块时,执行文件进行了哪些操作?
                右键运行run.py 文件,创建了一个run 的名称空间(目的:储存导入模块的结果)
                    1.首先,导入模块md.py  # (第一次运行md,导入结果,第二次,无反应)
                        1.执行md.py文件
                        2.运行md.py文件将产生的名字与值存储到md.py的名称空间中
                        3.在(run.py)执行文件中产生一个指向名称空间的名字(md)
                    2.多次导入,不会再执行,会沿用之前导入的结果
实例说明:
1.import导入模块---文件夹
run.py.运行文件

import md
### 注:导模块时,执行文件进行了哪些操作?
"""
右键运行run.py文件首先会创建一个run.py的名称空间
    首次导入模块(md1.py)(******)
        1.执行md.py文件
        2.运行md.py文件中的代码将产生的名字与值存放到md.py名称空间中
        3.在执行文件中产生一个指向名称空间的名字(md)


    多次导入不会再执行模块文件,会沿用第一次导入的成果(******)
"""
money = 9999


def read1():
    print('from run read1')

# 知识点1
# 访问模块中的名字指向的值
# print(md.money)  # 使用import导入模块 访问模块名称空间中的名字统一句势:模块名.名字


# md.read1()
# md.read2()
# print(md.change)

md.change()
print(money)
print(md.money)


# 知识点2
"""
1.只要你能拿到函数名 无论在哪都可以通过函数加括号来调用这个函数(会回到函数定义阶段 依次执行代码)
2.函数在定义阶段 名字查找就已经固定死了 不会因为调用位置的变化而改变



# 知识点3
使用import导入模块 访问模块名称空间中的名字统一句势:模块名.名字
    1.指名道姓的访问模块中的名字 永远不会与执行文件中的名字冲突
    2.你如果想访问模块中名字 必须用模块名.名字的方式
"""

# 知识点4
"""
只要当几个模块有相同部分或者属于用一个模块,可以使用上面的方法
当几个模块没有联系的情况下 应该分多次导入
import os
import time
import md
ps:通常导入模块的句式会写在文件的开头
"""
# 知识点5
"""
当模块名字比较复杂的情况下 可以给该模块名取别名
"""

md.py

print('from the md1.py')
money = 1000
def read1():
  print('md',money)
def read2():
  print('md模块')
  read1()
def change():
  global money
  money = 0

testttttttttt.py ---起别名,语法错误

"""
异常有两大类
    1.语法结构错误:需要你当场修改 异常捕获没法完成
    2.逻辑错误:异常捕获可以处理
"""

d = (i for i in range(3))
while True:
    try:
        print(d.__next__())
        print(name)
        sdfsdfj
    except Exception:
        print('1111111')
        break
name = "jason"
"""
异常有两大类
    1.语法结构错误:需要你当场修改 异常捕获没法完成
    2.逻辑错误:异常捕获可以处理
"""

    2.from...import...导入模块  -- 3.from...import...导入模块
        ### 注:导模块时,执行文件进行了哪些操作?
                    右键运行run.py 文件,创建了一个run 的名称空间(目的:储存导入模块的结果)
                        1.首先,导入模块md1.py  # (第一次运行md1,导入结果,第二次,无反应)
                            1.执行md1.py文件
                            2.运行md1.py文件将产生的名字与值存储到md.py的名称空间中
                            3.在(run.py)执行文件中产生一个指向名称空间中某个值的名字(from md1 import money,money的名字)
                        2.多次导入,不会再执行,会沿用之前导入的结果
实例说明 :
2.from...import...  导入模块  ---文件夹
run1.py

# money = '我是执行文件中的money'
# from md1 import money,read1,read2,change
# from md1 import money  # 多次导入不会执行 会沿用第一次导入的成果
# money = '我是执行文件中的money'

"""
会先创建run1.py的名称空间
    首次导入md1.py模块
        1.运行md1.py
        2.将产生的名字存放到md1.py名称空间中
        3.直接拿到指向模块md1.py名称空间中某个值的名字
        
 # 知识点1       
利用from...import...句式
    缺点:
        1.访问模块中的名字不需要加模块名前缀
        2.在访问模块中的名字可能会与当前执行文件中的名字冲突
"""
# def read1():
#     print('run1.py')
# read1()

# 知识点2
# 补充
from md1 import *  # 一次性将md1模块中的名字全部加载过来 不推荐使用 并且你根本不知道到底有哪些名字可以用
print(money)
print(read1)
print(read2)
print(change)

"""
__all__可以指定当所在py文件被当做模块导入的时候
可以限制导入者能够拿到的名字个数
格式:__all__ = ['money','read1','read2']
"""

md1.py

# print('from the md1.py')


money = 1000
def read1():
  print('md',money)
def read2():
  print('md模块')
  read1()
def change():
  global money
  money = 0
__all__ = ['money','read1','read2']

6.常见导入问题--循环导入以及解决思路
例:循环导入现象
m1.py

print('正在导入m1')
from m2 import y
x = 'm1'

m2.py

print('正在导入m2')
from m1 import x
x = 'm2'

run.py

import m1  

# 造成循环导入

打印结果
    正在导入m1
    正在导入m2

如果出现循环导入问题 那么一定是你的程序设计的不合理
循环导入问题应该在程序设计阶段就应该避免

解决循环导入问题的方式
    1.方式1
        将循环导入的句式写在文件最下方()
    
    2.方式2
        函数内导入模块
"""

7.__name__方法  知识点  即.py文件的不同类型  1.执行文件  2.作为模块

# 结论1 当文件被当做执行文件执行的时候__name__打印的结果是__main__
# 结论2 当文件被当做模块导入的时候__name__打印的结果是模块名(没有后缀)

def index1():
    print('index1')

def index2():
    print('index2')

# 实例1
# print(__name__)  # 值  __main__
# 结论1 当文件被当做执行文件执行的时候__name__打印的结果是__main__
# 结论2 当文件被当做模块导入的时候__name__打印的结果是模块名(没有后缀)
# 实例2
if __name__ == '__main__':
    index1()
    index2()



# if __name__ == '__main__':  # 快捷写法 main直接tab键即可
#     index1()
#     index2()

8.模块的查找顺序

"""
模块的查找顺序
    1.先从内存中找(无,去内置中找)
    2.内置中找(无,去环境变量中找)
    3.sys.path中找(环境变量):
        一定要分清楚谁是执行文件谁是被导入文件(******)
import sys
print(sys.path)
# 值 ['E:\Python\项目\购物车面条版\day14  调包侠\6. 模块的查找顺序', 'E:\Python\项目\购物车面条版', 'E:\Python36\python36.zip', 'E:\Python36\DLLs', 'E:\Python36\lib', 'E:\Python36', 'C:\Users\DELL\AppData\Roaming\Python\Python36\site-packages', 'E:\Python36\lib\site-packages', 'E:\Program Files\JetBrains\PyCharm 2018.1.4\helpers\pycharm_matplotlib_backend']
  第一路径

['E:\Python\项目\购物车面条版\day14  调包侠\6. 模块的查找顺序',

        是一个大列表,里面放了一对文件路径,第一个路径永远是执行文件所在的文件夹

# 注意py文件名不应该与模块名(内置的,第三方)冲突

9.模块的绝对导入,相对导入

"""
绝对导入必须依据执行文件所在的文件夹路径为准
    1.绝对导入无论在执行文件中还是被导入文件都适用
    

相对导入
    .代表的当前路径
    ..代表的上一级路径
    ...代表的是上上一级路径

    注意相对导入不能再执行文件中使用
    相对导入只能在被导入的模块中使用,使用相对导入 就不需要考虑
    执行文件到底是谁 只需要知道模块与模块之间路径关系
"""

10.ATM架构车框架
   1.ATM  -  8.ATM
   2.软件开发目录规范:  ---9.软件开发目录规范

"""
软件开发目录规范:
ATM+购物车
ATM
1.项目的启动文件
    1.在bin文件夹下
    2.在项目根目录下

2.项目的配置文件
    1.放在conf下setting文件下
    IP = '127.0.0.1'
    PORT = 8080
    DATABASE = 'Mysql'
3.核心逻辑:
    1.core下src
4.公共方法:
    lib下common
5.log --日志文件
6.interface接口处理层
7.db 数据处理层
"""
# start.py
import sys,os

# 添加环境变量
sys.path.append(os.path.dirname(os.path.dirname(__file__)))

# 导模块
from core import src

if __name__ == "__main__":
    src.run()

"""