闭包函数

　　闭包函数就是在内部函数当中有对外部函数名字的引用

  1. ###代码示例1###
  2. def f1():
  3.     x =1
  4.     def f2():
  5.         print(x)
  6.     return f2
  7.  
  8. f=f1()
  9. f()
  10. ###运行结果###
  11. C:\Python34\python.exe E:/Python16/day4/闭包函数.py
  12. 1
  13. Process finished with exit code 0
  14.  
  15. ###代码示例2###
  16. from urllib.request import urlopen  #第三方爬虫模块
  17.  
  18. def page(url):
  19.     def get():
  20.         return urlopen(url).read()  #爬　　　
  21.         #return urlopen(url).read().decode()   #解码（人类可读形式）
  22.  
  23.     return get
  24.  
  25. baidu=page('http://www.baidu.com')
  26. python=page('http://www.python.org')
  27. print(baidu())
  28.  
  29. ###运行结果###
  30. C:\Python34\python.exe E:/Python16/day4/闭包函数.py
  31. b'<!DOCTYPE html>\n<!--STATUS OK-->\n\r\n\r\n\r\n\r\n\r\n\91ff #4791ff}\n.s_ipt_tip{color:#aaa;position:absolute;z-index....（略）
  1.  

模块及模块导入

什么是模块？

　　  一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

为何要使用模块？

　　如果你退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。 随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用

模块的使用import

　　示例文件：spam.py，文件名spam.py,模块名spam

  1. print('from the spam.py')
  2.  
  3. money=1000
  4.  
  5. def read1():
  6.     print('spam->read1->money',1000)
  7.  
  8. def read2():
  9.     print('spam->read2 calling read')
  10.     read1()
  11.  
  12. def change():
  13.     global money
  14.     money=0

　　模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行（import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载大内存中的模块对象增加了一次引用，不会重新执行模块内的语句），如下 ：

  1. """
  2. 第一次导入模块做了3件事：
  3. 1. 创建新的作用域
  4. 2. 在该作用域执行顶级代码
  5. 3. 得到一个模块名，绑定到该模块的代码
  6.  
  7. """
  8.  
  9. import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',当然其他的顶级代码也都被执行了,只不过没有显示效果.
  10. import spam
  11. import spam
  12. import spam
  13.  
  14. '''
  15. 执行结果：
  16. from the spam.py
  17. '''
  1. #测试一:money与spam.money不冲突
  2. import spam
  3. money=10
  4. print(spam.money)
  5.  
  6. '''
  7. 执行结果：
  8. from the spam.py
  9. 1000
  10. '''
  11.  
  12. #测试二：read1与spam.read1不冲突
  13. #test.py
  14. import spam
  15. def read1():
  16.     print('========')
  17. spam.read1()
  18.  
  19. '''
  20. 执行结果:
  21. from the spam.py
  22. spam->read1->money 1000
  23. '''
  24.  
  25. #测试三：执行spam.change()操作的全局变量money仍然是spam中的
  26. #test.py
  27. import spam
  28. money=1
  29. spam.change()
  30. print(money)
  31.  
  32. '''
  33. 执行结果：
  34. from the spam.py
  35. 1
  36. '''

为模块起别名

  1. ###命名模块###
  2. print('from module spam')
  3.  
  4. money = 100
  5. def read1():
  6.     print(money)
  7.  
  8. ###模块导入测试###
  9. import spam as sp   #为spam起一个别名sp
  10.  
  11. moeny=100000
  12. sp.read1()
  13.  
  14. ###运行结果###
  15. C:\Python34\python.exe E:/Python16/day4/模块导入.py
  16. from module spam
  17. 100
  18.  
  19. Process finished with exit code 0

导入多个模块

  1. #方式一
  2. import os,sys,json
  3.  
  4. #方式二
  5. import os
  6. import sys
  7. import json
  8.  
  9. 以上两种写法不一样，但是运行效果一样
  10.  
  11. 　　为已经导入的模块起别名的方式对编写可扩展的代码很有用，假设有两个模块xmlreader.py和csvreader.py，它们都定义了函数read_data(filename):用来从文件中读取一些数据，但采用不同的输入格式。可以编写代码来选择性地挑选读取模块，例如
  12.  
  13. if file_format == 'xml':
  14.      import xmlreader as reader
  15. elif file_format == 'csv':
  16. 　　import csvreader as reader
  17. data=reader.read_date(filename)

from...import...

　　对比import spam，会将源文件的名称空间'spam'带到当前名称空间中，使用时必须是spam.名字的方式;而from 语句相当于import，也会创建新的名称空间，但是将spam中的名字直接导入到当前的名称空间中，在当前名称空间中，直接使用名字就可以了。

  1. from spam import read1,read2

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

  1. #测试一：导入的函数read1，执行时仍然回到spam.py中寻找全局变量money
  2. #test.py
  3. from spam import read1
  4. money=1000
  5. read1()
  6. '''
  7. 执行结果:
  8. from the spam.py
  9. spam->read1->money 1000
  10. '''
  11.  
  12. #测试二:导入的函数read2，执行时需要调用read1(),仍然回到spam.py中找read1()
  13. #test.py
  14. from spam import read2
  15. def read1():
  16.     print('==========')
  17. read2()
  18.  
  19. '''
  20. 执行结果:
  21. from the spam.py
  22. spam->read2 calling read
  23. spam->read1->money 1000
  24. '''

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

  1. #测试三:导入的函数read1，被当前位置定义的read1覆盖掉了
  2. #test.py
  3. from spam import read1
  4. def read1():
  5.     print('==========')
  6. read1()
  7. '''
  8. 执行结果:
  9. from the spam.py
  10. ==========
  11. '''

　　需要特别强调的一点是：python中的变量赋值不是一种存储操作，而只是一种绑定关系，如下：

  1. from spam import money,read1
  2. money=100 #将当前位置的名字money绑定到了100
  3. print(money) #打印当前的名字
  4. read1() #读取spam.py中的名字money,仍然为1000
  5.  
  6. '''
  7. from the spam.py
  8. 100
  9. spam->read1->money 1000
  10. '''

　　支持as别名和多行导入

  1. #别名
  2. from spam import read1 as read
  3.  
  4. #多行导入
  5. from spam import (read1,
  6.                    read2,
  7.                    money)

from spam import *   （下划线开头的无法开头）

　　 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置，大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道你导入什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

  1. from spam import * #将模块spam中所有的名字都导入到当前名称空间
  2. print(money)
  3. print(read1)
  4. print(read2)
  5. print(change)
  6.  
  7. '''
  8. 执行结果:
  9. from the spam.py
  10. 1000
  11. <function read1 at 0x1012e8158>
  12. <function read2 at 0x1012e81e0>
  13. <function change at 0x1012e8268>
  14. '''

__all__来控制*

  1. 可以使用__all__来控制*（用来发布新版本）
  2.  
  3. 在spam.py中新增一行
  4.  
  5. __all__=['money','read1'] #这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字

把模块当脚本来执行

　　我们可以通过模块的全局变量__name__来查看模块名：
　　当做脚本运行：
　　　　__name__ 等于'__main__'

　　当做模块导入：
　　　　__name__=

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

　　if __name__ == '__main__':

  1. ###fib.py代码###
  2.  
  3. def fib(n):    # write Fibonacci series up to n
  4.     a, b = 0, 1
  5.     while b < n:
  6.         print(b, end=' ')
  7.         a, b = b, a+b
  8.     print()
  9.  
  10. def fib2(n):   # return Fibonacci series up to n
  11.     result = []
  12.     a, b = 0, 1
  13.     while b < n:
  14.         result.append(b)
  15.         a, b = b, a+b
  16.     return result
  17.  
  18. if __name__ == "__main__":
  19.     import sys
  20.     fib(int(sys.argv[1]))
  21.  
  22. ###执行###
  23. #python fib.py
  24. python fib.py 50 #在命令行

模块搜索路径　　

　　当模块spam被导入时，解释器首先查找同名的内建模块，如果不存在，就从一个由变量sys.path给出的目录列表中依次寻找spam.py文件。

　　在初始化后，python程序可以修改sys.path,路径放到前面的优先于标准库被加载。

  1. >>> import sys
  2. >>> sys.path.append('a/b/c/d')
  3. >>> sys.path.insert(0,'/x/y/z')    #排在前的目录，优先被搜索

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

  1. ##首先制作归档文件：zip module.zip foo.py bar.py
  2.  
  3. import sys
  4. sys.path.append('module.zip')
  5. import foo,bar
  6.  
  7. ##也可以使用zip中目录结构的具体位置
  8. sys.path.append('module.zip/lib/python')

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

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

#######非当前同级目录导入实例#######

编译Python文件

　　Python检查源文件的修改时间与编译的版本进行对比，如果过期就需要重新编译。这是完全自动的过程。并且编译的模块是平台独立的，所以相同的库可以在不同的架构的系统之间共享，即pyc使一种跨平台的字节码；不同的版本编译后的pyc文件不同，2.5编译的pyc文件不能到3.5上执行，并且pyc文件是可以反编译的，因而它的出现仅仅是用来提升模块的加载速度的。（在cmd通过dir可以看见__pycache__文件）

　　提示：　　

　　1.模块名区分大小写，foo.py与FOO.py代表的是两个模块

　　2.你可以使用-O或者-OO转换python命令来减少编译模块的大小

  1.  -O转换会帮你去掉assert语句
  2.  -OO转换会帮你去掉assert语句和__doc__文档字符串
  3.  由于一些程序可能依赖于assert语句或文档字符串，你应该在在确认需要的情况下使用这些选项。

　　3.在速度上从.pyc文件中读指令来执行不会比从.py文件中读指令执行更快，只有在模块被加载时，.pyc文件才是更快的

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

  1. 模块可以作为一个脚本（使用python -m compileall）编译Python源
  2.  
  3. python -m compileall /module_directory 递归着编译
  4. 如果使用python -O -m compileall /module_directory -l则只一层
  5.  
  6. 命令行里使用compile()函数时，自动使用python -O -m compileall
  7.  
  8. 详见：https://docs.python.org/3/library/compileall.html#module-compileall

标准模块

　　python提供了一个标准模块库，一些模块被内置到解释器中，这些提供了不属于语言核心部分的操作的访问，但它们是内置的，无论是为了效率还是提供对操作系统原语的访问。这些模块集合是依赖于底层平台的配置项，如winreg模块只能用于windows系统。特别需要注意的是，sys模块内建在每一个python解释器

  1. import os,sys
  2. possible_topdir = os.path.normpath(os.path.join(
  3.     os.path.abspath(__file__),
  4.     os.pardir, #上一级
  5.     os.pardir,
  6.     os.pardir
  7. ))
  8. sys.path.insert(0,possible_topdir)

dir函数

　　内建函数dir是用来查找模块中定义的名字，返回一个有序字符串列表（用来查看对象的所有属性）
import spam
dir(spam)

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

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

包

  1. 包是一种通过使用‘.模块名’来组织python模块名称空间的方式。
  2.  
  3.     1）无论是import形式还是from...import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法
  4.  
  5.     2）包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）
  6.  
  7.     3）import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件
  8.  
  9. 包的本质就是一个包含__init__.py文件的目录。

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

  1. glance/                   #Top-level package
  2.  
  3. ├── __init__.py      #Initialize the glance package
  4.  
  5. ├── api                  #Subpackage for api
  6.  
  7. │   ├── __init__.py
  8.  
  9. │   ├── policy.py
  10.  
  11. │   └── versions.py
  12.  
  13. ├── cmd                #Subpackage for cmd
  14.  
  15. │   ├── __init__.py
  16.  
  17. │   └── manage.py
  18.  
  19. └── db                  #Subpackage for db
  20.  
  21.     ├── __init__.py
  22.  
  23.     └── models.py
  1. #文件内容
  2.  
  3. #policy.py
  4. def get():
  5.     print('from policy.py')
  6.  
  7. #versions.py
  8. def create_resource(conf):
  9.     print('from version.py: ',conf)
  10.  
  11. #manage.py
  12. def main():
  13.     print('from manage.py')
  14.  
  15. #models.py
  16. def register_models(engine):
  17.     print('from models.py: ',engine)

包的注意事项：

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

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

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

包导入之import

  1. 我们在与包glance同级别的文件中测试
  2. import glance.db.models
  3. glance.db.models.register_models('mysql')

包导入之from...import

  1. 需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法
  2.  
  3. 我们在与包glance同级别的文件中测试
  4. from glance.db import models
  5. models.register_models('db2')
  6.  
  7. from glance.db.models import register_models
  8. register_models('sqlserver')

__init__.py文件

  1. 不管是哪种方式，只要是第一次导入包或者是包的任何其他部分，都会依次执行包下的__init__.py文件(我们可以在每个包的文件内都打印一行内容来验证一下)，这个文件可以为空，但是也可以存放一些初始化包的代码。
  2.  
  3. 此处分别在glance和db目录下的__init__添加
  4. print('=================glance package')
  5. from .db import models
  6.  
  7. print('=================db package')
  8. from . import models
  9. 则会有先关打印输出

##相关添加

##相关输出

from glance.api import *

  1. 在讲模块时，我们已经讨论过了从一个模块内导入所有*，此处我们研究从一个包导入所有*。
  2.  
  3. 此处是想从包api中导入所有，实际上该语句只会导入包api下__init__.py文件中定义的名字，我们可以在这个文件中定义__all___:
  4.  
  5. x = 10
  6.  
  7. def func():
  8.     print('from api.__init.py')
  9.  
  10. __all__=['x','func','policy']
  11.  
  12. 此时我们在于glance同级的文件中执行from glance.api import *就导入__all__中的内容（versions仍然不能导入）

绝对导入和相关导入

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

　　绝对导入：以glance作为起始

　　相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）

　　例如：我们在glance/api/version.py中想要导入glance/cmd/manage.py

  1. 在glance/api/version.py
  2.  
  3. #绝对导入
  4. from glance.cmd import manage
  5. manage.main()
  6.  
  7. #相对导入
  8. from ..cmd import manage
  9. manage.main()
  10.  
  11. 测试结果：注意一定要在于glance同级的文件中测试【from glance.api import versions 】

单独导入包

  1. 单独导入包名称时不会导入包中所有包含的所有子模块，如
  2.  
  3. #在与glance同级的test.py中
  4. import glance
  5. glance.cmd.manage.main()
  6.  
  7. '''
  8. 执行结果：
  9. AttributeError: module 'glance' has no attribute 'cmd'
  10.  
  11. ''' 
  12.  
  13. 解决方法：
  14.  
  15. #glance/__init__.py
  16. from . import cmd
  17.  
  18. #glance/cmd/__init__.py
  19. from . import manage
  20.  
  21. 执行：
  22.  
  23. #在于glance同级的test.py中
  24. import glance
  25. glance.cmd.manage.main()
  26.  
  27. 【此时__all__不能解决，__all__是用于控制from...import *】

Python之旅Day4 闭包函数 模块及模块倒入的更多相关文章

  1. 第六篇：python基础_6 内置函数与常用模块（一）

    本篇内容 内置函数 匿名函数 re模块 time模块 random模块 os模块 sys模块 json与pickle模块 shelve模块 一. 内置函数 1.定义 内置函数又被称为工厂函数. 2.常 ...

  2. Python 空间名称与闭包函数

    空间名称与闭包函数 名称空间 名称空间 namespaces:存放名字的地方,是对栈区的划分 名称空间在栈区中分为三种,详细的划分不同的空间,不同空间可以存放相同名字的名字 内置名称空间 存放的名字: ...

  3. python全栈开发_day15_函数回调和模块

    一:函数回调 def a(fn=None): print("run1") if fn: fn() print("run 2") def b(): print(& ...

  4. python基础语法7 闭包函数与装饰器

    闭包函数: 1.闭包函数必须在函数内部定义 2.闭包函数可以引用外层函数的名字 闭包函数是 函数嵌套.函数对象.名称空间与作用域 结合体. # 直接传参 def func(x): print(x) f ...

  5. 小白的Python之路 day4 不同目录间进行模块调用(绝对路径和相对路径)

    一.常用模块调用函数功能解释 1.__file__ 功能:返回自身文件的相对路径 你从pycharm的执行结果可以看出,在pycharm执行atm.py文件时,是从绝对路径下去执行的,而你从cmd下去 ...

  6. Python基础（闭包函数、装饰器、模块和包）

    闭包函数 格式: def 函数名1(): def 函数名2(): 变量 = 值 return 变量 return 函数名2 func = 函数名1() key = func()

  7. python函数和常用模块（二）,Day4

    内置函数2 装饰器 字符串格式化 生成器 迭代器 递归 模块 序列化相关 time模块 datetime模块 内置函数2 callable() # 是否可以被执行,是否可以被调用 chr() # as ...

  8. 【Python 函数对象 命名空间与作用域 闭包函数 装饰器 迭代器 内置函数】

    一.函数对象 函数(Function)作为程序语言中不可或缺的一部分,但函数作为第一类对象(First-Class Object)却是 Python 函数的一大特性. 那到底什么是第一类对象(Firs ...

  9. Python入门之函数的嵌套/名称空间/作用域/函数对象/闭包函数

    本篇目录: 一.函数嵌套 二.函数名称空间与作用域 三.函数对象 四.闭包函数 ============================================================ ...

随机推荐

  1. Java多线程01(Thread类、线程创建、线程池)

    Java多线程(Thread类.线程创建.线程池) 第一章 多线程 1.1 多线程介绍 1.1.1 基本概念 进程:进程指正在运行的程序.确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于 ...

  2. blender基础操作

    旋转:鼠标中键 左右移动:鼠标中键+左shift 放大缩小:鼠标滚轮滚动 blender旋转以锁定物件作为中心点旋转 blender选取物件用鼠标右键, 选中物件之后,利用数字键盘中的点(Del) 来 ...

  3. zyupload四种不同的PHP上传demo

    PHP结合zyupload多功能图片上传实例,支持拖拽和裁剪.可以自定义高度和宽度,类型,远程上传地址等. zyupload上传基本配置 1 $("#zyupload").zyUp ...

  4. 转载：如何优雅的实现INotifyPropertyChanged接口

    转载来源:http://www.cnblogs.com/TianFang/p/6240933.html 如何优雅的实现INotifyPropertyChanged接口 INotifyPropertyC ...

  5. bootstrap table dataView展开行详情，p元素自动换行

    // bootstrap table 行详情展开,p元素自动换行1 .tableClass .detail-view p{ white-space: normal; }

  6. vue如何使用rules对表单字段进行校验

    基于element-ui 1.在代码中,添加属性::rule <el-form :model="form" :rules="rules" ref=&quo ...

  7. Failed to create agent because it is not close enough to the NavMesh

    主要原因是:两个相同对象navmesh点太近造成. 解决方案:通过NavMesh.SamplePosition 获得可以行走点 ;i<;i++) { , mRadius); , 3.14f); ...

  8. Git命令参考手册

    git init # 初始化本地git仓库(创建新仓库) git config --global user.name "xxx" # 配置用户名 git config --glob ...

  9. AST的作用

    ·代码版本兼容:例如babel ·代码混淆和压缩:将语义变量变无意义 ·开发工具:webpack.vue-cli ·编译:编译器.IDE

  10. Navicat Premium 出现2059错误解决办法

    1,登陆后可查询默认加密规则,键入 use mysql; select user,plugin from user where user ='root'; 解决办法: 1,更新用户密码:ALTER U ...