python 全栈开发,Day29(昨日作业讲解,模块搜索路径,编译python文件,包以及包的import和from,软件开发规范)

 一、昨日作业讲解

先来回顾一下昨日的内容

1.os模块
    和操作系统交互
    工作目录 文件夹 文件 操作系统命令 路径相关的
2.模块
    最本质的区别 import会创建一个专属于模块的名字,
        所有导入模块中的都会在这个空间中
    import
    from import
    as 起别名
    * 和 __all__

 

作业讲解:
os.listdir() 返回一个列表,里面的每一个元素都是相对路径
值就是文件,或者文件夹

 

使用递归的方式实现

import os
def get_size(dir):
    sum_size = 0  # 初始大小
    for item in os.listdir(dir):  # 返回一个列表,里面的每一个元素都是相对路径
        path = os.path.join(dir,item)  # 由于item是相对路径的文件或者文件夹,需要join拼出绝对路径
        if os.path.isfile(path):  # 判断绝对路径是否为文件
            sum_size += os.path.getsize(path)  # 计算文件大小
        else:
            sum_size += get_size(path)  # 调用自身函数。加上文件夹的大小,固定为4096,空的也是那么大。
    return sum_size

ret = get_size('E:\python_script\day26')  # 传入一个目录
print(ret)

执行输出:

4950326

 

栈(先进先出)
使用栈的思想完成上面的代码:

import os
def get_size(path):
    l = [path]  # 文件夹列表
    sum_size = 0  # 初始文件大小
    while l:  # 判断列表是否为空
        path = l.pop()  # 删除列表最后一个元素,并返回给path l = ['E:\python_script\day26']
        for item in os.listdir(path):  #遍历列表,path = 'E:\python_script\day26'
            path2 = os.path.join(path, item)  # 组合绝对路径 path2 = 'E:\python_script\day26\test'
            if os.path.isfile(path2):  # 判断绝对路径是否为文件
                sum_size += os.path.getsize(path2)   # 计算文件大小。sum = 文件的大小 + 0
            else: 
                l.append(path2)  # 为文件夹时,添加到列表中。再次循环。l = ['E:\python_script\day26\test']
                
    return sum_size

print(get_size('E:\python_script\day26'))

执行输出:

4951192

 

和上面的结果有微小的差异,是因为,当前py文件,增加了几行代码。

查看文件夹属性

大小是一致的,有些windows系统,可能有微小的差异。

 

栈也可以解决深度问题,比如文件夹里面的所有文件统计

l就是一个栈

栈也可以完成递归的功能。
递归比较占用空间,每调用一次,产生一个新的空间
但是栈不会每次产生新的空间,非常节省空间
栈可以解决不确定深度问题
栈的精髓就是先进后出

 

第二题

思考:假如有两个模块a,b。
我可不可以在a模块中import b ,再在b模块中import a?

新建文件demo1.py,内容如下:

import my_module
print('demo1')

新建文件my_module.py,内容如下:

import demo1
print('my_module')

执行demo1.py,结果如下:

demo1
my_module
demo1

 

分析:

第一步执行demo1.py中的import my_module

第二步执行my_module.py中的import demo1

第三步执行demo1.py中的import my_module,发现mysql_modulel已经被导入了,那么不会再次导入!

第四步执行demo1.py中的print('demo1'),为什么呢?因为从上至下代码执行原则

第五步执行my_module.py中的print('my_module'),为什么呢?因为从上至下原则

 

引用有一个模块,是为了引用方法

修改demo1.py,增加一个函数

import my_module

def func():
    print('ret')

my_module.func2()  # 执行函数

修改my_module.py,增加一个函数

import demo1

def func2():
    print('in func2')

demo1.func1()

执行demo1.py,输出报错:

AttributeError: module 'my_module' has no attribute 'func2'

为什么呢?

看我上面写的步骤分析,执行第4步时,由于my_module.py中的func2还没有加载到内容

执行第5步时,调用my_module中的func2函数,就会直接报错,提示找不到函数


结论:
代码不会发现循环引用问题
模块中的引用不能成环

看下面一张图

b引用a,c引用b。但是a不能引用c,否则就是一个环。反反复复,无法终止。

2个模块之间引用,那么就产生高层模块和底层模块
根据依赖倒置原则,高层模块不应该依赖底层模块
否则就违反了开发原则。

 

二、模块搜索路径

导入一个模块,就会从sys.path里面的路径中寻找
程序运行时,会将当前路径加入到搜索路径中

目前是demo1.py和my_module.py在同一个文件夹中

将my_module.py文件移动到上一层目录中

import sys
print(sys.path)
import my_module # 执行报错

执行就会报错,因为sys.path提供的搜索路径中,找不到my_module.py文件

 如果手动添加一个呢?

import sys
print(sys.path)
sys.path.append('E:\python_script\day26')  # 添加搜索路径
import my_module

再次执行,就不会报错了。

能不能导入一个模块,不是靠Pycharm画红线决定的

而是sys.path决定的。

总结:

引入的模块必须满足两个条件
  1.模块名必须满足变量名的规范
  2.被导入的模块所在的位置必须在sys.path所在的搜索路径中

 

模块
  py文件是一个模块
脚本
  py文件也是一个模块

如果一个py文件被导入了 他就是一个模块
如果这个py文件被直接执行 这个被直接执行的文件就是一个脚本

模块
  没有具体的调用过程
  但是能对外提供功能

 

 比如三次登录程序

 创建文件login.py,内容如下:

def log_in():
    user = input('>>>')
    pwd = input('>>>')
    print('三次登录')

 创建文件test.py,内容如下:

import login

login.log_in()  # 执行登录

执行文件test.py,效果如下:

>>>111
>>>222
三次登录

 

现在有一个需求:

当login模块被当做脚本执行的时候,能够独立完成登陆功能
当login模块被当做模块导入的时候,需要等待调用才能完成功能

修改login.py

def log_in():
    # user = input()
    # pwd = input()
    print('三次登陆')

print(__name__) 

修改test.py

import login

login.log_in()

print(__name__)

执行test.py,输出:

login
三次登陆
__main__

说明由test.py调用login.py时,输出login,也就是模块名

 

如果login.py想直接执行log_in方法,但是不想被导入时,自动执行。可以做一个if判断

def log_in():
    # user = input()
    # pwd = input()
    print('三次登陆')

if __name__ == '__main__':
    log_in()

执行输出:三次登陆

修改test.py,只包含一行

import login

执行test.py,输出为空

 

if __name__ == '__main__': 这句话,永远不会变,它是为了区分脚本和模块

所有的print不应该出现在模块里面,而是出现在if下面的代码中

 

结论:

当一个模块被当做脚本执行的时候,__name__是一个字符串数据类型的'__main__'
当一个模块被当做模块导入的时候,__name__是一个字符串数据类型模块名

 

三、编译python文件

执行导入操作时,会自动创建目录__pycache__

查看里面的文件

那么这些文件是谁创建的呢?

python解释器创建的
当一个文件被当做模块导入的时候,
如果pyc文件不存,python解释器就会创建,存在不会再次被创建

pyc文件 编译文件

python --> 字节码 -->机器码

编译过程
从上到下 编译 成字节码 pyc
从上倒下 解释 执行代码

为什么要编译
  1.一个文件如果作为模块 一定会经常被导入
  2.每次被导入都要经历一个被编译的过程
  3.包.编译耗费时间
  4.所以模块在被第一次导入的时候被编译存在pyc文件里
  5.之后的导入可以直接呐pyc文件中的字节码,就可以直接执行了

 

主要功能:

编译文件 在模块导入的一瞬间 能够提高代码的执行速度
不能提高程序在具体执行的时候的效率

 程序第一次执行,可能会慢一点,因为有一个编译过程

 

补充:dir()函数


内建函数dir是用来查找模块中定义的名字,返回一个有序字符串列表

import my_module
dir(my_module)

如果没有参数,dir()列举出当前定义的名字

dir()不会列举出内建函数或者变量的名字,它们都被定义到了标准模块builtin中,可以列举出它们,

import builtins
dir(builtins)

  

四、包以及包的import和from

包是一种通过使用'.模块名' 来组织python模块名称空间的方式。

1. 无论是import形式还是from...import形式,凡是在导入语句中(而不是在使用时)遇到带点的,都要第一时间提高警觉:这是关于包才有的导入语法
2. 包是目录级的(文件夹级),文件夹是py文件来组成(包的本质就是一个包含__init__.py文件的目录)
3. import导入文件时,产生名称空间中的名字来源于文件,import 包,产生的名称空间的名字同样来源于文件,即包下的__init__.py,导入包本质就是在导入该文件
强调:
  1. 在python3中,即使包下没有__init__.py文件,import 包仍然不会报错,而在python2中,包下一定要有该文件,否则import 包报错
  2. 创建包的目的不是为了运行,而是被导入使用,记住,包只是模块的一种形式而已,包即模块

 

使用Pycharm创建一个包,会自动创建__init__.py文件

所谓的包,就是一个包含__init__.py文件的文件夹

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

 

模块是对外提供功能的
如果我写的模块足够强大,能提供的功能足够多
多到一个文件写不
把对外提供的功能,根据提供的内容不同,分成几个文件
把这些文件放在一个文件夹下,就形成了包
比如django框架
是所有框架中,功能最全的
功能:
1.操作数据库的模块
2.和web页面交互的模块
3.登录认证的模块
4.安全的中间件 模块,比如web攻击

django将所有的模块集合成一个包

 

 自动创建目录结构

import os
os.makedirs('glance/api')
os.makedirs('glance/cmd')
os.makedirs('glance/db')
l = []
l.append(open('glance/__init__.py','w'))
l.append(open('glance/api/__init__.py','w'))
l.append(open('glance/api/policy.py','w'))
l.append(open('glance/api/versions.py','w'))
l.append(open('glance/cmd/__init__.py','w'))
l.append(open('glance/cmd/manage.py','w'))
l.append(open('glance/db/models.py','w'))
map(lambda f:f.close() ,l)

执行代码,查看目录结构

文件内容如下:

#policy.py
def get():
    print('from policy.py')

#versions.py
def create_resource(conf):
    print('from version.py: ',conf)

#manage.py
def main():
    print('from manage.py')

#models.py
def register_models(engine):
    print('from models.py: ',engine)

手动将内容复制到对应的py文件中去

这里面的每一个文件夹,都是包
包里面的每一个py文件,都是模块

 

新建一个文件new.py

目录结构如下:

./
├── glance
│   ├── api
│   │   ├── __init__.py
│   │   ├── policy.py
│   │   └── versions.py
│   ├── cmd
│   │   ├── __init__.py
│   │   └── manage.py
│   ├── db
│   │   └── models.py
│   └── __init__.py
└── new.py 

new.py想用glance目录下的api文件夹下的policy模块

修改new.py

from glance.api import policy
policy.get()

执行输出:

from policy.py

注意事项

1.关于包相关的导入语句也分为import和from ... import ...两种,但是无论哪种,无论在什么位置,在导入时都必须遵循一个原则:凡是在导入时带点的,点的左边都必须是一个包,否则非法。可以带有一连串的点,如item.subitem.subsubitem,但都必须遵循这个原则。

2.对于导入后,在使用时就没有这种限制了,点的左边可以是包,模块,函数,类(它们都可以用点的方式调用自己的属性)。

3.对比import item 和from item import name的应用场景:
如果我们想直接使用name那必须使用后者。

 

也可以用这种写法:

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

执行输出:

from policy.py

对于点没有约束,对比2种方式,使用from方式,就比较简单了。

 

from ... import ...
需要注意的是from后import导入的模块,必须是明确的一个不能带点,否则会有语法错误,如:from a import b.c是错误语法
这样就报错了

from glance import api.policy
policy.get()

下面的方式,也是不对的

import glance
glance.api.policy.get()

症结就是导入一个包,并没有把包里面的所有内容,导入进来

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

修改glance下面的__init__.py文件

import api

手动执行__init__.py文件,没有报错

修改new.py

import glance
glance.api.policy.get()

执行new.py,提示报错

ImportError: No module named 'api'

为什么?
因为sys.path,路径中找不到api。__init__.py 执行时,在它的工作目录中可以找到api
但是new.py所在的工作目录,无法直接找到api目录,所以就报错了

 

绝对导入和相对导入

我们的最顶级包glance是写给别人用的,然后在glance包内部也会有彼此之间互相导入的需求,这时候就有绝对导入和相对导入两种方式:

绝对导入:以glance作为起始

相对导入:用.或者..的方式最为起始(只能在一个包中使用,不能用于不同目录内)

 

修改glance目录下的__init__.py文件

from glance import api

修改api目录下的__init__.py 

from glance.api import policy

再次执行new.py,输出:

from policy.py

  

为什么呢?因为首先执行了glance目录下的__init__.py文件,再执行了api目录下的__init__.py 

所以就能找到policy模块

 

所有导入,都是以glance为基础
这就是绝对路径导入

 

这个时候,新建一个文件new_pac
将glance目录剪切到new_pac

当前目录结构如下:

./
├── new_pac
│   └── glance
│       ├── api
│       │   ├── __init__.py
│       │   ├── policy.py
│       │   ├── __pycache__
│       │   │   ├── __init__.cpython-35.pyc
│       │   │   └── policy.cpython-35.pyc
│       │   └── versions.py
│       ├── cmd
│       │   ├── __init__.py
│       │   └── manage.py
│       ├── db
│       │   └── models.py
│       ├── __init__.py
│       └── __pycache__
│           └── __init__.cpython-35.pyc
└── new.py

如果new.py想调用new_pac目录下glance文件夹下面的内容呢?
修改new.py文件

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

执行报错:

ImportError: No module named 'glance'

为什么?因为glance下的所有__init__.py路径不对,都得改
修改glance目录下的__init__.py

from new_pac.glance import api

修改api目录下的__init__.py 

from new_pac.glance.api import policy

再次执行new.py,输出

from policy.py

 

但是这样太麻烦了,有缺点
一旦上级目录发生变化,那么所有的init_py,都得修改

总结:

绝对路径
  被直接执行的文件与包的关系必须是固定的,
    一旦发生改变,包内的所有关系都要重新指定
  跨包引用的问题,无法解决

 

如果policy想要执行manage呢?

修改policy.py,内容如下:

from new_pac.glance.cmd import manage
def get():
    print('from policy.py')

manage.main()

执行报错:

ImportError: No module named 'new_pac'

不能单独执行policy.py
它取决于sys.path

 

不改变new.py内容,执行new.py,输出:

from manage.py
from policy.py

结果正常。

特别需要注意的是:可以用import导入内置或者第三方模块(已经在sys.path中),但是要绝对避免使用import来导入自定义包的子模块(没有在sys.path中),应该使用from... import ...的绝对或者相对导入,且包的相对导入只能用from的形式。

 

相对导入

用.或者..的方式最为起始(只能在一个包中使用,不能用于不同目录内)

好处就是,比方是你电脑开发的。换了另外一台电脑,也依然可以正常运行,不需要修改文件路径

再次执行创建文件的脚本

import os
os.makedirs('glance/api')
os.makedirs('glance/cmd')
os.makedirs('glance/db')
l = []
l.append(open('glance/__init__.py','w'))
l.append(open('glance/api/__init__.py','w'))
l.append(open('glance/api/policy.py','w'))
l.append(open('glance/api/versions.py','w'))
l.append(open('glance/cmd/__init__.py','w'))
l.append(open('glance/cmd/manage.py','w'))
l.append(open('glance/db/models.py','w'))
map(lambda f:f.close() ,l)

再次补充文件内容

#policy.py
def get():
    print('from policy.py')

#versions.py
def create_resource(conf):
    print('from version.py: ',conf)

#manage.py
def main():
    print('from manage.py')

#models.py
def register_models(engine):
    print('from models.py: ',engine)

新建文件new2.py

目录结构如下:

./
├── glance
│   ├── api
│   │   ├── __init__.py
│   │   ├── policy.py
│   │   └── versions.py
│   ├── cmd
│   │   ├── __init__.py
│   │   └── manage.py
│   ├── db
│   │   └── models.py
│   └── __init__.py
└── new2.py 

修改glance下的__init__.py,内容如下:

from . import api

点表示当前路径

api目录的__init__.py,内容如下:

from . import policy

修改new2.py,内容如下:

import glance
glance.api.policy.get()

执行new2.py,输出:

from policy.py

 

新建目录new_pac2,将目录glance剪切到new_pac2下面

目录结构如下:

./
├── new2.py
└── new_pac2
    └── glance
        ├── api
        │   ├── __init__.py
        │   ├── policy.py
        │   └── versions.py
        ├── cmd
        │   ├── __init__.py
        │   └── manage.py
        ├── db
        │   └── models.py
        └── __init__.py

 

修改new2.py,内容如下:

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

再次执行new2.py,输出:

from policy.py

居然没有报错,666啊!

 

修改policy.py,导入versions模块

from . import versions
def get():
    print('from policy.py')

versions.create_resource('userinfo')

执行new2.py,输出:

from version.py: userinfo
from policy.py

 

手动执行policy.py,输出:

ImportError: attempted relative import with no known parent package

它不能当成脚本执行

 

结论:

在一个py文件中使用了相对路径引入一个模块
那么这个文件就不能被当成脚本运行了

 

修改policy.py,导入manage模块

from . import versions
from .. cmd import manage
def get():
    print('from policy.py')

versions.create_resource('userinfo')
manage.main()

点点表示上一级目录

执行new2.py,输出:

from version.py:  userinfo
from manage.py
from policy.py

  

new2.py 只能关联到glance包

 

from glance.api import *

在讲模块时,我们已经讨论过了从一个模块内导入所有*,此处我们研究从一个包导入所有*。
此处是想从包api中导入所有,实际上该语句只会导入包api下__init__.py文件中定义的名字,我们可以在这个文件中定义__all___:

 

修改policy.py

from . import versions
from ..cmd import manage
__all__ = ['get']
def get():
    print('from policy.py')

versions.create_resource('userinfo')
manage.main()

修改api.py,内容如下:

from . import policy
__all__ = ['policy']

修改new2.py

from new_pac2.glance.api import *

执行输出:

from version.py: userinfo
from manage.py

 

总结:

包就是py模块的集合
自带__init__.py文件
  py2 包中必须有一个__init__.py文件
  py3 不存在也可以
能不能导入一个包:要看sys.path中的路径下有没有这个包
从包中导入模块: 把包与包之间的关系写清楚,精确到模块,就一定能导入
直接导入一个包,并不会导入包下的模块,而是执行这个包下的__init__.py文件
如果对导入还有更高的要求
  可以对包中的__init__.py文件做定义
  绝对路径导入的方式
  相对路径导入的方式 使用相对路径导入的模块不能作为脚本执行

 

sys.path是所有模块的核心
是导入的关键

 

记住下面的:

#导入具体的文件
#1.使用from
from glance.api import policy
policy.get()
#
#1.使用import加别名
import glance.api.policy as policy
policy.get()

保你2年平安...

 

五、软件开发规范

比如校园管理系统,目录结构如下:

开始程序为start.py

 

为什么要设计好目录结构?
"设计项目目录结构",就和"代码编码风格"一样,属于个人风格问题。
设计一个层次清晰的目录结构,就是为了达到以下两点:
  1.可读性高: 不熟悉这个项目的代码的人,一眼就能看懂目录结构,知道程序启动脚本是哪个,测试目录在哪儿,配置文件在哪儿等等。从而非常快速的了解这个项目。

  2.可维护性高: 定义好组织规则后,维护者就能很明确地知道,新增的哪个文件和代码应该放在什么目录之下。这个好处是,随着时间的推移,代码/配置的规模增加,项目结构不会混乱,仍然能够组织良好。

 

所以,我认为,保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录,其实是一件很简单的事儿。

 

关于README的内容

这个我觉得是每个项目都应该有的一个文件,目的是能简要描述该项目的信息,让读者快速了解这个项目。

它需要说明以下几个事项:

1.软件定位,软件的基本功能。
2.运行代码的方法: 安装环境、启动命令等。
3.简要的使用说明。
4.代码目录结构说明,更详细点可以说明软件的基本原理。
5.常见问题说明。

我觉得有以上几点是比较好的一个README。在软件开发初期,由于开发过程中以上内容可能不明确或者发生变化,并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候,是需要撰写这样的一个文档的。

 

可以参考Redis源码中Readme的写法,这里面简洁但是清晰的描述了Redis功能和源码结构。

https://github.com/antirez/redis#what-is-redis

 

posted @ 2018-04-26 19:54  肖祥  阅读(828)  评论(1编辑  收藏  举报