第七篇、Python之模块/包

一、模块（module）的概念

1、模块定义和分类

在python中，一个.py文件就称之为一个模块（Module）。

模块的使用方式都是一样的，细分模块可以分为三类：　

　1 自定义模块：使用python编写的单个.py文件，或者把一系列的.py文件组织在一起的文件夹。（注：文件夹下有个__init__.py文件，该文件夹称之为包）

　2 第三方模块：已被编译为共享库或DLL的C或C++扩展

　3 python标准库：使用C编写并链接到python解释器的内置模块

2、模块优点

1） 从文件级别组织程序，更方便管理

2） 拿来主义，提升开发效率

我们不仅仅可以单独执行脚本文件，还可以导入到其他的模块中或者下载他人模块导入自己项目中使用，实现了功能的重复利用并且极大地提升我们的开发效率。

* 3） 模块可以避免函数名和变量名冲突

使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们自己在编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。

3、模块的导入

1） 模块导入的搜索路径

模块的查找顺序是：内存中已经加载的模块->内置模块->sys.path路径中包含的模块

1、在第一次导入某个模块时（比如spam），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用
    ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看
2、如果没有，解释器则会查找同名的内建模块
3、如果还没有找到就从sys.path给出的目录列表中依次寻找spam.py文件。

模块的查找顺序

import sys
print(sys.path)

注意事项：按照sys.path的路径顺序优先查找，所以若在当前目录下存在与要引入模块同名的文件，就会把要导入的模块屏蔽掉。 当前目录是优先于标准库目录的，需要强调的是：我们自定义的模块名不要跟python标准库的模块名重复

sys.path从以下位置初始化：
    1 执行文件所在的当前目录
    2 PTYHONPATH（包含一系列目录名，与shell变量PATH语法一样）
    3 依赖安装时默认指定的

sys.path初始化位置

在初始化后，python程序可以修改sys.path。

import sys
sys.path.append(‘/a/b/c/d‘)
sys.path.insert(0,‘/x/y/z‘)

路径排在前的目录，优先被搜索：搜索时按照sys.path中从左到右的顺序查找，位于前的优先被查找，sys.path中还可能包含.zip归档文件和.egg文件，python会把.zip归档文件当成一个目录去处理。

#首先制作归档文件：zip module.zip foo.py bar.py
import sys
sys.path.append(‘module.zip‘)
import foo,bar

#也可以使用zip中目录结构的具体位置
sys.path.append(‘module.zip/lib/python‘)

#windows下的路径不加r开头，会语法错误
sys.path.insert(0,r‘C:\Users\Administrator\PycharmProjects\a‘)

#至于.egg文件是由setuptools创建的包，这是按照第三方python库和扩展时使用的一种常见格式，.egg文件实际上只是添加了额外元数据(如版本号，依赖项等)的.zip文件。

#需要强调的一点是：只能从.zip文件中导入.py，.pyc等文件。使用C编写的共享库和扩展块无法直接从.zip文件中加载（此时setuptools等打包系统有时能提供一种规避方法），且从.zip中加载文件不会创建.pyc或者.pyo文件，因此一定要事先创建他们，来避免加载模块是性能下降。

2） 模块导入的过程

第一次导入模块会有三步流程，重复导入python会直接引用内存中已经加载好的结果，即后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句。

import sys
#test.py

#1.为源文件(导入的模块sys)创建新的名称空间，在模块中定义的函数和方法若是使用到了global时访问的就是这个名称空间。

#2.在新创建的命名空间中执行模块中包含的代码
    事实上，函数定义也是“被执行”的语句，模块级别函数定义的执行将函数名放
    入模块全局名称空间表，用globals()可以查看

#3.创建名字sys来引用该命名空间
    这个名字和变量名没什么区别，都是‘第一类的’，且使用sys.名字（sys.MName）的方式
    可以访问sys.py文件中定义的名字，sys.MName与test.py中的名字来自
    两个完全不同的地方。

每个模块都是一个独立的名称空间，定义在这个模块中的函数，把这个模块的名称空间当做全局名称空间，这样我们在编写自己的模块时，就不用担心我们定义在自己模块中全局变量会在被导入时，与使用者的全局变量冲突

print(‘from the spam.py‘)

money=1000

def read1():
    print(‘spam模块：‘,money)

def read2():
    print(‘spam模块‘)
    read1()

def change():
    global money
    money=0

spam.py

import spam #只在第一次导入时才执行spam.py内代码
import spam
import spam

#执行结果：from the spam.py

test.py

import spam
money=10
print(spam.money)

‘‘‘
执行结果：
from the spam.py
1000
‘‘‘

test1.py

import spam
def read1():
    print(‘========‘)
spam.read1()

‘‘‘
执行结果：
from the spam.py
spam模块： 1000
‘‘‘

test2.py

import spam
money=1
spam.change()
print(money)

‘‘‘
执行结果：
from the spam.py
1
‘‘‘

test3.py

3）为导入模块名起别名

为已经导入的模块起别名的方式对编写可扩展的代码很有用

import sys as sss
print(sss.path)

from sys import path as spp
print(spp)

4）模块导入方法

A、导入一个或多个模块

import module1[, module2[,... moduleN]

B、导入模块里的单个或全部对象，这个导入方法将模块中的名字直接导入到当前的名称空间中，所以在当前名称空间中，调用直接使用名字就可以了、无需加前缀，但容易与当前执行文件中的名字冲突：

from modname import name1[, name2[, ... nameN]]    #可以直接调用name1[, name2[, ... nameN]]
from modname import *    #比较不推荐，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

　　可以使用__all__来控制*（用来发布新版本），在spam.py中新增一行

__all__=[‘money‘,‘read1‘] #这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字

　　

验证一：当前位置直接使用read1和read2就好了，执行时，仍然以spam.py文件全局名称空间

#测试一：导入的函数read1，执行时仍然回到spam.py中寻找全局变量money
#test.py
from spam import read1
money=100
read1()
‘‘‘
执行结果:
from the spam.py
spam模块： 1000            #spam->read1->money 1000
‘‘‘

#测试二:导入的函数read2，执行时需要调用read1(),仍然回到spam.py中找read1()
#test.py
from spam import read2
def read1():
    print(‘==========‘)
read2()

‘‘‘
执行结果:
from the spam.py
spam模块                        #spam->read2 calling read
spam模块： 1000             #spam->read1->money 1000
‘‘‘

验证二：如果当前有重名read1或者read2，那么会有覆盖效果。

#测试三:导入的函数read1，被当前位置定义的read1覆盖掉了
#test.py
from spam import read1
def read1():
    print(‘==========‘)
read1()
‘‘‘
执行结果:
from the spam.py
==========
‘‘‘

验证三：导入的方法在执行时，始终是以源文件为准的

from spam import money,read1
money=100 #将当前位置的名字money绑定到了100
print(money) #打印当前的名字
read1() #读取spam.py中的名字money,仍然为1000

‘‘‘
from the spam.py
spam->read1->money 1000
‘‘‘

　　

5）模块循环导入问题

模块循环/嵌套导入抛出异常的根本原因是由于在python中模块被导入一次之后，就不会重新导入，只会在第一次导入时执行模块内代码

在我们的项目中应该尽量避免出现循环/嵌套导入，如果出现多个模块都需要共享的数据，可以将共享的数据集中存放到某一个地方

在程序出现了循环/嵌套导入后的异常分析、解决方法如下

#示范文件内容如下
#m1.py
print(‘正在导入m1‘)
from m2 import y

x=‘m1‘

#m2.py
print(‘正在导入m2‘)
from m1 import x

y=‘m2‘

#run.py
import m1

#测试一
执行run.py会抛出异常
正在导入m1
正在导入m2
Traceback (most recent call last):
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/aa.py", line 1, in <module>
    import m1
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
    from m2 import y
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m2.py", line 2, in <module>
    from m1 import x
ImportError: cannot import name ‘x‘

#测试一结果分析
先执行run.py--->执行import m1，开始导入m1并运行其内部代码--->打印内容"正在导入m1"
--->执行from m2 import y 开始导入m2并运行其内部代码--->打印内容“正在导入m2”--->执行from m1 import x,由于m1已经被导入过了，所以不会重新导入，所以直接去m1中拿x，然而x此时并没有存在于m1中，所以报错

#测试二:执行文件不等于导入文件，比如执行m1.py不等于导入了m1
直接执行m1.py抛出异常
正在导入m1
正在导入m2
正在导入m1
Traceback (most recent call last):
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
    from m2 import y
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m2.py", line 2, in <module>
    from m1 import x
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa练习目录/m1.py", line 2, in <module>
    from m2 import y
ImportError: cannot import name ‘y‘

#测试二分析
执行m1.py，打印“正在导入m1”，执行from m2 import y ，导入m2进而执行m2.py内部代码--->打印"正在导入m2"，执行from m1 import x，此时m1是第一次被导入，执行m1.py并不等于导入了m1，于是开始导入m1并执行其内部代码--->打印"正在导入m1"，执行from m1 import y，由于m1已经被导入过了，所以无需继续导入而直接问m2要y，然而y此时并没有存在于m2中所以报错

# 解决方法:
方法一:导入语句放到最后
#m1.py
print(‘正在导入m1‘)

x=‘m1‘

from m2 import y

#m2.py
print(‘正在导入m2‘)
y=‘m2‘

from m1 import x

方法二:导入语句放到函数中
#m1.py
print(‘正在导入m1‘)

def f1():
    from m2 import y
    print(x,y)

x = ‘m1‘

# f1()

#m2.py
print(‘正在导入m2‘)

def f2():
    from m1 import x
    print(x,y)

y = ‘m2‘

#run.py
import m1

m1.f1()

示例文件

#m1.py
f1()
print(‘正在导入m1‘)
import m2

x=‘m1‘

print(m2.y)

#m2.py
print(‘正在导入m2‘)
import m1

y=‘m2‘

#run.py
import m1

思考

* 6） 模块的重载

考虑到性能的原因，每个模块只被导入一次,放入字典sys.module中，如果你改变了模块的内容，你必须重启程序，python不支持重新加载或卸载之前导入的模块，

有的同学可能会想到直接从sys.module中删除一个模块不就可以卸载了吗，注意了，你删了sys.module中的模块对象仍然可能被其他程序的组件所引用，因而不会被清楚。

特别的对于我们引用了这个模块中的一个类，用这个类产生了很多对象，因而这些对象都有关于这个模块的引用。

如果只是你想交互测试的一个模块，使用 importlib.reload(), e.g. import importlib; importlib.reload(modulename)，这只能用于测试环境。

def func1():
    print(‘func1‘)

aa.py

import time,importlib
import aa

time.sleep(20)
# importlib.reload(aa)
aa.func1()

aa_test.py

在20秒的等待时间里，修改aa.py中func1的内容，等待test.py的结果。

打开importlib注释，重新测试

二、python文件

python文件区分两种用途:模块与脚本

1） 脚本，一个文件就是整个程序，用来被执行

2） 模块，文件中存放着一堆功能，用来被导入使用

python文件的编译：

为了提高加载模块的速度，强调强调强调：提高的是加载速度而绝非运行速度。python解释器会在__pycache__目录中下缓存每个模块编译后的版本，格式为：module.version.pyc。通常会包含python的版本号。例如，在CPython3.3版本下，spam.py模块会被缓存成__pycache__/spam.cpython-33.pyc。这种命名规范保证了编译后的结果多版本共存。

Python检查源文件的修改时间与编译的版本进行对比，如果过期就需要重新编译。这是完全自动的过程。并且编译的模块是平台独立的，所以相同的库可以在不同的架构的系统之间共享，即pyc使一种跨平台的字节码，类似于JAVA火.NET,是由python虚拟机来执行的，但是pyc的内容跟python的版本相关，不同的版本编译后的pyc文件不同，2.5编译的pyc文件不能到3.5上执行，并且pyc文件是可以反编译的，因而它的出现仅仅是用来提升模块的加载速度的，不是用来加密的。

python文件编译

#python解释器在以下两种情况下不检测缓存
#1 如果是在命令行中被直接导入模块，则按照这种方式，每次导入都会重新编译，并且不会存储编译后的结果（python3.3以前的版本应该是这样）
    python -m spam.py

#2 如果源文件不存在，那么缓存的结果也不会被使用，如果想在没有源文件的情况下来使用编译后的结果，则编译后的结果必须在源目录下
sh-3.2# ls
__pycache__ spam.py
sh-3.2# rm -rf spam.py
sh-3.2# mv __pycache__/spam.cpython-36.pyc ./spam.pyc
sh-3.2# python3 spam.pyc
spam

#提示：
1.模块名区分大小写，foo.py与FOO.py代表的是两个模块
2.你可以使用-O或者-OO转换python命令来减少编译模块的大小
    -O转换会帮你去掉assert语句
    -OO转换会帮你去掉assert语句和__doc__文档字符串
    由于一些程序可能依赖于assert语句或文档字符串，你应该在在确认需要
    的情况下使用这些选项。
3.在速度上从.pyc文件中读指令来执行不会比从.py文件中读指令执行更快，只有在模块被加载时，.pyc文件才是更快的

4.只有使用import语句是才将文件自动编译为.pyc文件，在命令行或标准输入中指定运行脚本则不会生成这类文件，因而我们可以使用compieall模块为一个目录中的所有模块创建.pyc文件

模块可以作为一个脚本（使用python -m compileall）编译Python源
python -m compileall /module_directory 递归着编译
如果使用python -O -m compileall /module_directory -l则只一层

命令行里使用compile()函数时，自动使用python -O -m compileall

详见：https://docs.python.org/3/library/compileall.html#module-compileall

三、python内置全局变量__name__

当文件被当做脚本执行时：__name__ 等于‘__main__‘

当文件被当做模块导入时：__name__等于模块名

if __name__ == ‘__main__‘:

作用：用来控制.py文件在不同的应用场景下执行不同的逻辑，

1）避免代码被import，也就是被调用时，屏蔽代码段

2）调试运行代码

#fib.py

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=‘ ‘)
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

#执行：python fib.py <arguments>
python fib.py 50 #在命令行

四、python包

1、python包的定义

包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

Packages are a way of structuring Python’s module namespace by using “dotted module names” # 包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

　　1） 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错

2）创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块。

2、python包的优点

包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来。

随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能。

而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性。

3、包的使用之import 和注意事项

1） 在import/from...import时，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。

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

而from...import后面的导入模块，必须是不能带点，否则会有语法错误。

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

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

### 使用import导入包：单独导入包名称时不会导入包中所有包含的所有子模块

import glance
glance.cmd.manage.main()   #AttributeError: module ‘glance‘ has no attribute ‘cmd‘，单独导入包名，子模块无法调用

#解决方法
from . import cmd         #glance/__init__.py，导入包本质就是在导入__init__.py文件
from . import manage      #glance/cmd/__init__.py
#or
import glance.cmd.manage glance.cmd.manage.main()

### 使用from ... import ...导入包的模块

from glance.db import models
models.register_models(‘mysql‘)

from glance.db.models import register_models
register_models(‘mysql‘)　　

### 从一个包导入所有*: 想从包api中导入所有，实际上该语句只会导入包api下__init__.py文件中定义的名字，我们可以在这个文件中定义__all___:

#glance同级目录test.py文件
from glance.api import *

#api/__init__.py文件
x=10
def func():
    print(‘from api.__init.py‘)

__all__=[‘x‘,‘func‘,‘policy‘]

#glance同级目录test.py文件中
from glance import *
get()
create_resource(‘a.conf‘)
main()
register_models(‘mysql‘)

#在glance.__init__.py中
from .api.policy import get
from .api.versions import create_resource
from .cmd.manage import main
from .db.models import  register_models

__all__=[‘get‘,‘create_resource‘,‘main‘,‘register_models‘]

from glance import * 

   

       ### 绝对导入和相对导入

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

绝对导入：以执行文件的sys.path为起始点开始导入,称之为绝对导入（以glance作为起始）

# 优点: 执行文件与被导入的模块中都可以使用
# 缺点: 所有导入都是以sys.path为起始点,导入麻烦

相对导入：参照当前所在文件的文件夹为起始开始查找,称之为相对导入。

# 符号:  "."代表当前所在文件的文件夹,".."代表上一级文件夹,"..."代表上一级的上一级文件夹
# 优点:  导入更加简单
# 缺点:  只能在导入包中的模块时才能使用（只能在一个包中使用，不能用于不同目录内）

比如：

# glance/api/version.py中想要导入glance/cmd/manage.py# 在glance/api/version.py，单独运行报错原因：只能在同一个包内进行导入，不同目录之间无法进行相对或绝对导入

# 绝对导入，单独run version.py会报错 “ModuleNotFoundError: No module named ‘glance‘”from glance.cmd import manage manage.main() 
# 相对导入，单独run version.py会报错 “ValueError: attempted relative import beyond top-level package”from ..cmd import manage manage.main()
# 测试代码：glance的同级目录test.py,from glance.api import versions

注意:

* 相对导入只能用于包内部模块之间的相互导入,导入者与被导入者都必须存在于一个包内

* 试图在顶级包之外使用相对导入是错误的,言外之意,必须在顶级包内使用相对导入,每增加一个“.”代表跳到上一级文件夹,而上一级不应该超出顶级包。

---- 报错“attempted relative import beyond top-level package”

* 导入路径必须注意，包以及包的模块都是用来被导入的，而不是被直接执行的。而环境变量都是以执行文件为准的。

#api/version.py中,单独执行没有问题。
import policy
policy.get()

#glance同级下的一个test.py，这样就报错了
from glance.api import versions  #ImportError: No module named ‘policy‘

‘‘‘
分析:
此时我们导入versions在versions.py中执行，import policy需要找从sys.path也就是从当前目录找policy.py,这必然是找不到的
‘‘‘

  ├── test.py
  └── glance                  #Top-level package
           │
           ├── __init__.py      #Initialize the glance package
           │
           ├── api                  #Subpackage for api
           │     ├── __init__.py
           │     ├── policy.py
           │     └── versions.py
           │
           ├── cmd                #Subpackage for cmd
           │     ├── __init__.py
           │     └── manage.py
           │
           └── db                  #Subpackage for db
                  ├── __init__.py
                  └── models.py

实验: https://pan.baidu.com/s/1C1Rzioen64WvvuOiQuamZQ

# import的使用
# import glance.api.policy
# glance.api.policy.get()   #from policy.py

#一次性import整个包
# import glance
# glance.cmd.manage.main()  #AttributeError: module ‘glance‘ has no attribute ‘cmd‘

#import包里的某个模块
# import glance.cmd.manage
# glance.cmd.manage.main()    #from manage.py

#使用from...import
# # from glance.db import models
# # # # glance.db.models.register_models(‘mysql‘)  #NameError: name ‘glance‘ is not defined
# # # db.models.register_models(‘mysql‘)  #NameError: name ‘db‘ is not defined
# # models.register_models(‘mysql‘)
# from glance.db.models import register_models
# register_models(‘mysql‘)     #from models.py:  mysql

# #一次性从包导入所有*
#1、from glance.api import *
# # from glance.api import *
# # func()
# # policy.get()
# # print(x)
# # versions.create_resource("10.1.1")

# #2、from glance import *
# # from glance.api.policy import *
# # get()
# # from glance.api.versions import *
# # create_resource(‘a.conf‘)
# # from glance.cmd.manage import *
# # main()
# # from glance.db.models import *
# # register_models(‘mysql‘)
# from glance import *
# get()
# create_resource(‘a.conf‘)
# main()
# register_models(‘mysql‘)

# #测试在glance/api/version.py中想要导入glance/cmd/manage.py
# from glance.api import versions

test.py

#从一个模块内导入所有*
#2-1、from glance import *
# from .models import *
# __all__=[‘register_models‘]

db/__init__.py

#从一个模块内导入所有*
#1、from glance.api import *
# from . import policy
# from . import versions
#
# x=10
#
# def func():
#     print(‘from api.__init.py‘)
#
# # __all__=[‘x‘,‘func‘,‘policy‘]
# __all__=[‘x‘,‘func‘,‘policy‘,"versions"] #2-1、from glance import *

#2-2、from glance import *
# from .policy import get
# from .versions import create_resource
# from .policy import *
# from .versions import *
#
# __all__ =[‘get‘,‘create_resource‘]

api/__init__.py

#从一个模块内导入所有*
#2、from glance import *
# from .api import *
#
# from .cmd.manage import *
#
# from .db.models import *

from .api.policy import get
from .api.versions import create_resource

from .cmd.manage import main
from .db.models import  register_models

__all__=[‘get‘,‘create_resource‘,‘main‘,‘register_models‘]

glance/__init__.py

#从一个模块内导入所有*
#2-1、from glance import *
# from .manage import *
# __all__=[‘ma‘]

cmd/__init__.py

def get():
    print(‘from policy.py‘)

policy.py

def create_resource(conf):
    print(‘from version.py: ‘,conf)

versions.py

def main():
    print(‘from manage.py‘)

manage.py

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

models.py

*4、包的分发

https://packaging.python.org/distributing/

五、软件开发规范

【参考链接】https://www.cnblogs.com/yuanchenqi/articles/5732581.html

https://www.cnblogs.com/linhaifeng/articles/6379069.html

原文地址：https://www.cnblogs.com/chenyuting/p/12612944.html

时间： 2024-10-08 16:21:10

第七篇、Python之模块/包的相关文章

Python常用模块——包&amp;跨模块代码调用

Python常用模块--包&跨模块代码调用 一.包(Package) 当你的模块文件越来越多,就需要对模块文件进行划分,比如把负责跟数据库交互的都放一个文件夹,把与页面交互相关的放一个文件夹. my_proj/ ├── apeland_web #代码目录 │ ├── __init__.py │ ├── admin.py │ ├── apps.py │ ├── models.py │ ├── tests.py │ └── views.py ├── manage.py └── my_proj #配置

第七篇 python基础之函数，递归，内置函数

阅读目录 一 数学定义的函数与python中的函数 二 为何使用函数 背景提要 三 函数和过程 四 函数参数 五 局部变量和全局变量 六 前向引用之'函数即变量' 七 嵌套函数和作用域 八 递归 九 匿名函数 十 函数式编程 十一 内置函数 十二 本节作业 一 数学定义的函数与python中的函数 初中数学函数定义:一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量,把y称为因变量,y是x的函数.自变量x的取值范围叫做

【Python之路】第七篇--Python基础之面向对象及相关

面向对象基础 基础内容介绍详见一下两篇博文: 面向对象初级篇 面向对象进阶篇 其他相关

第七篇Python基本数据类型之数字&amp;字符串

数字 整型 Python3里无论数字多长都用int表示,Python2里有int和Long表示,Long表示长整型 有关数字的常用方法,方法调用后面都必须带括号() int():将字符串转换为整型,且字符串内容只能是数字 a = "123" b = "123a" c = int(a) d = int(b) # ValueError: invalid literal for int() with base 10: '123a' print(type(c)) print

读懂掌握 Python logging 模块源码 （附带一些 example）

搜了一下自己的 Blog 一直缺乏一篇 Python logging 模块的深度使用的文章.其实这个模块非常常用,也有非常多的滥用.所以看看源码来详细记录一篇属于 logging 模块的文章. continue Reference: https://juejin.im/post/5b13fdd0f265da6e0b6ff3dd  Pycon2018 利用logging模块轻松地进行Python日志记录 原文地址:https://www.cnblogs.com/piperck/p/9634133.

七、Python模块和包

Python模块 Python模块是组织代码的基本方式 Python的脚本都是用扩展名为py的文本文件保存的,一个脚本可以单独运行,也可以导入另一个脚本中运行.当脚本被导入运行时,将其称为模块 cat test.py #!/usr/bin/python #coding:utf-8 from __future__ import division def a(x,y): print x+y def b(x,y): print x*y cat new.py #!/usr/bin/python impo

第一篇：python的模块与包

模块的简介 模块就是一组功能的集合体,我们的程序可以导入模块来复用模块里的功能.每一个 Python 脚本.py文件都可以被当成是一个模块.模块以磁盘文件的形式存在.当一个模块变得过大,并且驱动了太多功能的话,就应该考虑拆一些代码出来另外建一个模块.模块里的代码可以是一段直接执行的脚本,也可以是一堆类似库函数的代码,从而可以被别的模块导 入(import)调用.模块可以包含直接运行的代码块.类定义. 函数定义或这几者的组合. 模块分类:Python标准库模块.Python第三方模块.应用程序自定

Python开发【第七篇】： 面向对象和模块补充

内容概要 特殊成员 反射 configparser模块 hashlib模块 logging模块 异常处理 模块 包 1. 特殊成员 2. 反射 3. configparser模块 该模块适用于配置文件件的格式与windows ini文件类似,可以包含一个或多个节(section)每个节可以有多个参数(键=值). 首先, 我们先看一个xxx服务器的配置文件 [DEFAULT] ServerAliveInterval = 45 Compression = yes CompressionLevel =

Python之模块和包学习

模块简介 python是由一系列的模块组成的,每个模块就是一个py为后缀的文件,同时模块也是一个命名空间,从而避免了变量名称冲突的问题.模块我们就可以理解为lib库,如果需要使用某个模块中的函数或对象,则要导入这个模块才可以使用,除了系统默认的模块(内置函数)不需要导入外. 导入直接使用如下语法:  import 模块名称 (不要.py后缀) 这样导入成功后,就可以在另外一个模块中使用被导入模块的功能函数或对象. 举例如下,比如在F:\Pro-files\workspace\myPython目录