34.Python模块

1.面向过程编程

面向过程的编程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，
使用的时候依次调用，先这样再这样，最后再这样···恩 ···明白了吗？

"""
面向对象 编程 那不就是1先这样， 再这样， 最后在这样···
1.获取用户名和密码
2.组织成固定的格式
3.文件操作写入文件
"""


# 获取信息
def get_info():
    while True:
        username = input('输入用户名称>>>:').strip()
        password = input('输入用户密码>>>:').strip()
        # 输入不能为空
        if len(username) == 0 or len(password) == 0:
            print('账户或密码不能为空！')
            return
        while True:
            print('选择身份信息'.center(15, '-'))
            print("""
                '1': 'admin',
                '2': 'LV1',
                '3': 'LV2'""")
            identity = {
    
    
                '1': 'admin',
                '2': 'LV1',
                '3': 'LV2'}
            in_idf = input('请选择>>>:')
            if in_idf not in identity:
                print('输入的信息不存在！')
                break
            return username, password, identity[in_idf]


# 组织成固定的格式
def deal_data():
    data = '%s|%s|%s\n' % (get_info())
    return data


# 文件写入
def sava_data():
    with open(r'data.txt', mode='a', encoding='utf8') as f1:
        f1.write(deal_data())
        print('注册成功')

sava_data()
"""
将函数的返回值作为参数传递！
"""

2.模块

2.1简介

ps:
Python 语言最早源于Linux运维，也会称为胶水语言与调包侠。

模块：具有一定功能的代码代码结合体。
目的：使用模块能提高开发效率。

2.2模块来源

1.内置的(Python) 解释器自带的模块，可以直接导入使用。
2.第三方(别人写的)网络上发布，需要先下载后使用。
3.自定义(自己写的)命名不要去内置冲突，遵守Python命名规范。

2.3表现形式

1.使用Python编写的代码（python文件）
2.已经被编译为共享库或DLL的C或C++拓展
3.打包的一组模块包(文件夹)
	包其实就是对个py文件(模块)的集合。
	包里面通常会含有__init__.py文件
4.使用C语言编写并链接到Python解释器的内在模块

3.import导入模块

3.1格式

import 模块名   导入Python文件模块（文件后缀不要加）

文件名称：
导入文件 --> 导入 --> 模块文件

3.2导入阶段

# one.py
import two  # hello word!

# two.py
print('hello word!')

首次导入模块：（多次导入相同的模块只会执行一个。）
1.运行导入文件，先在该文件产生全局名称空间。 --> one.py
2.运行two文件，产生全局名称空间，之后将产生的名字全部存档于two.py名称空间
3.在导入文件名称空间产生一个two的名字并指向two.py的全局名称空间。

3.3特点

import 语句导入模块特点
指定获取模块中的名称,不会与导入文件的名称冲突。

# one.py
import two

name = 'qq' 
print(two.name)  # kid

# two.py
name = 'kid'

4.from语句

4.1格式

from 模块 import 名称  指定导入模块中的某个名称
在使用名称的时候直接使用。

4.2导入阶段

# one.py
from two import name


print(name)  # kid

# two.py
name = 'kid'

首次导入模块：
1.先产生执行文件的全局名称空间
2.执行模块文件，产生模块的全局名称空间，将模块中执行之后产生的名字全部存档于模块名称空间中。
3.执行文件中的名称 绑定 模块名称空间的值

4.3缺点

如果执行文件中重名，会冲突，使用的就是执行文件的名称空间。

# one.py
from two import name

name = 'qq'
print(name)  # qq

# two.py

name = 'kid'

5.拓展使用

5.1起别名

起过别名之后之前的名称就失效了。

为模块名 起别名 ,
import two as t            之后在模块中t就代表了two,two则失效

为模块中的名称起别名
from two import name as n  之后在模块中n就代表了name,name则失效

# one.py
import two as t

print(t.name)  # kid

# one.py
from two import name as n

print(n)  # kid

# two.py
name = 'kid'

5.2连续导入

导入多个模块
import os, sys

只有当多个模块功能相似或同一个系列才使用一行导入多个模块，否则推荐分行导入。

导入模块中的多个名称
from time import time, sleep

# 导入多个模块
import os, time

print(os.path)  # <module 'ntpath' from 'D:\\Python\\Python36\\lib\\ntpath.py'>
print(time.time())  # 1637655267.413634

# 导入模块中的多个名称
from time import time, sleep

print(time())  # 1637655131.1373956
sleep(1)
print(time())  # 1637655132.1504955

5.3通用导入

*号 将模块中所有的名字全部导入
from 模块 import *

from time import *

print(time())  # 1637655659.8956995
sleep(1)
print(time())  # 1637655660.905185

自定义模块可以使用__all__指定限制 * 的导入。

from two import *

func1()
func2()
func3()  

"""
from func1
from func2
···
NameError: name 'func3' is not defined
"""

# two.py
def func1():
    print('from func1')


def func2():
    print('from func2')


def func3():
    print('from func3')


__all__ = ['func1', 'func2']  # * 能获取的名字

6.py文件判断

6.1判断

判断py文件是 模块文件  还是  执行文件。
__name__ 在当前文件执行会返回 '__main__'
被导入时执行会返回模块名称

# one.py
from two import *


print(__name__)  # __main__

# two.py
print(__name__)  # two

6.2常用

1.在调试自定义模块的时候可以限制不想执行的代码。
2.在启动文件是使用。（快捷：main + tab）
	if __name__ == '__main__':
		···

# one.py
from two import *

print(__name__)  # __main__

# two.py
if __name__ == '__main__':  # 'two' == '__main__'
    print(__name__)  # 不会执行

7.循环导入

7.1出错

如果自己设计的程序中出现循环导入的问题，那么设计就不合理。

# one.py
print('from one')  # 1  # 5
from two import y  # 2  第二次运行直接要y指定的值，值没有报错···

x = 0

# two.py
print('from two')  # 3
from one import x  # 4

y = 0

7.2改错

方案：
1.调换顺序， 将彼此导入的句式放在代码之后
2.函数形式， 将导入的句式放进函数体代码 等待所有的名称产生之后在调用。

# one.py
print('from one')  
x = 0              
from two import y  

# two.py
print('from two')

y = 0
from one import x

# one.py
print('from one')
x = 0
def one():
    from two import y
one()

# two.py
print('from two')

y = 0
def two():
    from one import x
two()

8.模块导入顺序

8.1顺序

1.先去内存中查找
2.在去内置模块中查找
3.最后去sys.path系统路径中查找（自定义模块）
如果都没有则会报错。

自定义模块的时候不要与内置的模块重名，
内置的模块 比 自定义模块的查找优先级高。

8.2内存查找

# 内存的查找优先级
import time
import two  # 第一次导入

two.func()  # 第一次打印 from func
time.sleep(10)  # 睡10秒，找到b.py将源文件给删了

import two  # 第二次导入 依然可以，内存中b模块并未被垃圾回收

two.func()  # 第二次打印 from func

8.2内置查找

# one.py
import time

# time.py
print('from time!')  # 不会执行

8.3自定义查找

sys.path  查看返回模块的搜索路径 是一个列表套字符串。
列表的第一个元素为当前文件所有的目录。

将自定义的文件加载到sys.path的路径中。

pycharm会自己将当前项目所在的路径添加到sys.path的路径中。

import sys
print(sys.path)  # ['F:\\backups\\notes\\Project\\xxx',···]

1.同路径

通路径下可以通过 from 与 import直接导入，

2.跨路径

通过from 模块名 import 模块名
文件夹也是模块

# two.py 在当前文件下创建 func 将 two拖到func中
print('from func/two')

def func1():
    print('from func/two --> func1')

# one.py
from func import two  # from func/two

# one.py  
from func.two import func1

func1()  # from func/two --> func1

将two.py 的路径添加到sys.path中  
# 只将文件所有的目录添加进来即可。

import sys

sys.path.append(r'D:\13600\Desktop')

import two

two.func1()

"""
from func/two
from func/two --> func1
"""

9.导入

9.1导入情况

在程序中涉及多个文件之间导入模块的情况：
1.绝对导入
   始终按照执行文件所在的sys.path查找模块
2.相对导入
   .句点符号 .表示当前路径 .. 上级路径 ... 上上级路径
   .. 与 ...不能返回到项目目录中，查找的最顶层是项目目录的一个子文件。
   （只能在模块中使用，执行文件中不能使用）
   ValueError: Attempted relative import in non-package

9.2绝对导入

sys.path.append(r'路径')

9.3相对导入

目录结构
test
|--top
|	/--cneter
|			/--down.py
|	/--p2.py
|
|--p1.py

1 .的使用

# p1.py
from top import p2
print('from p1.py')

# p2.py
from . import down
print('from p2.py')

# down.py
print('from down.py')

2 …的使用

# p1.py

from top.center import down

# down.py
from .. import p2

print('from down.py')

# p2.py
print('from p2.py')

10.路径添加

在使用交互式环境的时候，将项目路径添加到sys.path中。
否则 from 模块 import xxx 会找不到模块

import os
import sys
os.path.dirname(__file__)  # 当前路径
BASE_PATH = os.path.dirname(os.path.dirname(__file__))  # 上一层路径
sys.path.append(BASE_PATH )

11.软件开发规范

目录规范
bin/   ---> start.py
   存放启动文件，当启动文件很少或则只有一个的时候可以直接写在项目目录下。

core/ ---> src.py
   项目核心代码


conf/  ---> settings.py
   存放配置文件,一般情况下存放全大写的变量名。
   
lib/  ---> common.py
   公用功能模块

db/ ---> userinfo.py
   数据文件
   
log/ ---> log.txt
   日志文件

readme.txt 
   项目信息

requirements.txt
   项目所需的第三方模块及版本号