一、模块

相信使用过Python编写代码的同学，会经常在文件头看到这样的import …，是的，这就是导入模块的语句，而每一个后缀名为.py的文件都是一个模块。

import jieba
import os　

1. 什么是模块？

  逻辑上来说模块是一组功能的组合；实质上一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

import加载的模块分为四个通用类别：

a. 使用python编写的代码（.py文件）；
b. 已被编译为共享库或DLL的C或C++扩展；
c. 包好一组模块的包
d. 使用C编写并链接到python解释器的内置模块；

如何使用模块？
　　想要使用模块，必须先要将模块加载进来，可以通过关键字 import 或 from进行加载；需要注意的是模块和当前文件在不同的命名空间中。

2. 模块的构成

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

二、模块的导入

1、导入整个模块

  比如我们有一个myModule的文件夹，里面有一个first.py文件，文件中的内容如下

a = 1
def myfun(s):
    print(s + 1)

  在myModule的文件夹下打开终端/cmd，输入python进入命令行交互模式
写完模块导入的语句之后，接着就可以调用该模块下的函数了。调用方式为

>>> import first
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> first.a
1
>>> first.myfun(2)
3

2、导入特定的函数/变量

  所以说first.py文件就是一个模块，可以用import导入，里面变量和方法都要用first.前缀来引用，如果想不使用这个前缀或是我们只是想要使用模块中的某个函数，就可以只导入该变量或函数。导入方式为：from module_name import function_name。
  如果导入的是变量，就可以直接输入变量名来获得变量的值；如果直接导入的是函数，可以直接使用function_name() 的方式调用函数，无需在函数名前面加上模块名。

# 导入变量
>>> from first import a
>>> a
1
# 导入函数
>>> from first import myfun
>>> myfun(3)
4
# 一次导入多个变量
>>> from first import a,myfun
>>> a
1
>>> myfun(5)
6
# 导入模块中全部变量
>>> from first import *
>>> a
1
>>> myfun(5)
6
>>>

3、使用as给模块指定别名

  可以在后面使用as给函数指定别名。句式如：import module_name as new_name，

>>> import first as f
>>> f.a
1
>>> f.myfun(6)
7

在上述导入函数的基础上，可以在后面用as语句给导入的函数指定别名。句式如：from module_name import function_name as new_function。

>>> from first import myfun as add
>>> add(8)
9

三、包、库

模块(module) 其实就是py文件，里面定义了一些函数、类、变量等。
包(package) 是多个模块的聚合体形成的文件夹，里面可以是多个py文件，也可以嵌套文件夹。
库是参考其他编程语言的说法，是指完成一定功能的代码集合，在python中的形式就是模块和包。

一个包的架构：

sound/                          Top-level package
      __init__.py               Initialize the sound package
      formats/                  Subpackage for file format conversions
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  Subpackage for sound effects
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  Subpackage for filters
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

Python 只把含 __init__.py 文件的目录当成包。这样可以防止以 string 等通用名称命名的目录，无意中屏蔽出现在后方模块搜索路径中的有效模块。 最简情况下，__init__.py 只是一个空文件，但该文件也可以执行包的初始化代码，或设置 __all__ 变量，详见下文。

四、包的导入

导入包的本质：导入一个包就是执行包下的__init__.py文件

只要一个文件夹下面有个__init__.py 文件，那么这个文件夹就可以看做是一个包。

包导入的过程和模块的基本一致，只是导入包的时候会执行此包目录下的 init.py 而不是模块里面的语句了。另外，如果只是单纯的导入包，而包的 init.py 中又没有明确的其他初始化操作，那么此包下面的模块是不会自动导入的。

另外需要注意两点

1. __ init__ .py文件编写时，如果要在__init__.py中导入其他模块中的变量，即使__ init__.py文件和abcd.py文件在同一个文件夹下，也不能from abcd import b，要从abcd文件从哪里来开始写，即从包的名称开始，from folder.abcd import b。
2. folder文件夹里的嵌套文件夹内不需要新建__init__.py文件即可像模块一样调用，但是一般还是要新建这个文件，可以方便地导入常用变量。
3. init.py文件其实是一个特殊的文件，它相当于名为folder模块，即如果使用import folder则可以调用在__init__.py文件文件中定义的变量。

五、__ all __

使用 from sound.effects import * 时会发生什么？理想情况下，该语句在文件系统查找并导入包的所有子模块。这项操作花费的时间较长，并且导入子模块可能会产生不必要的副作用，这种副作用只有在显式导入子模块时才会发生。

唯一的解决方案是提供包的显式索引。import 语句使用如下惯例：如果包的 __init__.py 代码定义了列表 __all__，运行 from package import * 时，它就是用于导入的模块名列表。发布包的新版本时，包的作者应更新此列表。如果包的作者认为没有必要在包中执行导入 * 操作，也可以不提供此列表。例如，sound/effects/__init__.py 文件包含以下代码：

__all__ = ["echo", "surround", "reverse"]

这将意味着将 from sound.effects import * 导入 sound.effects 包的三个命名的子模块。

如果没有定义 __all__，from sound.effects import * 语句 不会 把包 sound.effects 中所有子模块都导入到当前命名空间；该语句只确保导入包 sound.effects （可能还会运行 __init__.py 中的初始化代码），然后，再导入包中定义的名称。这些名称包括 __init__.py 中定义的任何名称（以及显式加载的子模块），还包括之前 import 语句显式加载的包里的子模块。

变量__all__的好处：只会导出all中的子模块，可以有效地避免命名空间的污染，并加速模块的导入

一、模块公开接口的一种约定
__all__可以在模块级别暴露接口，形式如下：
__all__ = [“foo”, “bar”]
Python 没有原生的可见性控制，其可见性的维护是靠一套需要大家自觉遵守的”约定“，比如，下划线开头的变量对外部不可见。
__all__ 是针对模块公开接口的一种约定，以提供了”白名单“的形式暴露接口。如果定义了__all__，其他文件中使用from xxx import *导入该文件时，只会导入 __all__ 列出的成员，可以其他成员都被排除在外。
如，test1.py,test2.py,test3.py三个文件：
test1.py
#__all__ = [‘func’]
def func():
pass

test2.py
import test1

__all__ = [‘func2’, ‘test1’]
def func2():
pass

def func22():
pass

test3.py
from test2 import *

func2() #能正常引用
test1.func() #能正常引用
func22() #不能正常引用

二、控制 from xxx import * 的行为
python不提倡用 from xxx import * 这种写法。如果一个模块 xxx 没有定义 __all__，执行 from spam import * 时会将 xxx 中所有非下划线开头的成员（包括该模块import的其他模块成员）都会导入当前命名空间，这样就可能弄脏当前的命名空间。显式声明了 __all__，import * 就只会导入 __all__ 列出的成员，如果 __all__ 定义有误，还会明确地抛出异常，方便检查错误。

三、为 lint 等代码检查工具提供辅助
编写库时，经常会在 __init__.py 中暴露整个包的 API，而这些 API 的实现可能是在包的其他模块中。如果仅仅这样写：from xxx import a, b，一些代码检查工具，如 pyflakes 会报错，认为变量 a和 b import 了但没被使用。一个可行的方法是把这个警告压掉：from xxx import a, b # noqa （No Q/A，即无质量保证），但更好的方法是显式定义 __all__，这样代码检查工具就会理解，从而不再报 unused variables 的警告。

四、定义 all 需要注意的地方

• __all__ 的形式都是 list类型。如果写成其他类型， pyflakes 等 lint 工具可能无法识别。
• 不能动态生成 __all__，如使用列表解析式。__all__ 的作用是定义公开接口，需要以字面量的形式显式写出来。
• 即使定义了 __all__， 也不应该在非临时代码中使用 from xxx import * 语法，或用编程工具模拟 Ruby 的自动 import。Python 不像 Ruby，没有 Module 这类成员，模块就是命名空间隔离的执行者。如果打破了这一层，引入诸多动态因素，生产环境中跑的代码就可能充满不确定性，调试也会变得困难。
• 按照 PEP8 建议的风格，__all__ 应该写在所有 import 语句下面，函数、常量等成员定义的上面。
• 如果一个模块需要暴露的接口改动频繁，__all__ 可以这样定义：

__all__ = [
“foo”,
“bar”,
“egg”,
]
这样修改一个暴露的接口只修改一行，方便版本控制的时候看 diff。最后多出的逗号在 Python 中是允许的，符合 PEP8 风格。

由上面的输出结果，我们可以知道import *只会导入__all__中指定的变量，无论是否以下划线开头。这样限制可以防止import *命令导入太多变量污染命名空间，过滤掉一些中间变量如b

五、模块导入的绝对引用与相对引用

python中的import分为绝对引用和相对引用两种。它们之间的差异在于，引用模块时，定位被引用模块位置 的方式不同。

绝对引用是通过.的连接，指定出最高级文件（夹），到目标文件的绝对路径。我们上面的所有用法都属于绝对引用。

而相对引用是指定待引用模块与当前文件的相对位置，.表示上一级文件

• 绝对引用：from folder.abcd import myclass
• 相对引用：from .abcd import myclass

在实际使用中，无论是绝对导入还是相对导入都要注意，如何导入与被调用位置有关。

@符号是装饰器（修饰符）的语法糖，在定义函数的时候使用，避免再一次赋值操作

装饰器(Decorators)是 Python 的一个重要部分。简单地说：他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短，也更Pythonic（Python范儿）。大多数初学者不知道在哪儿使用它们，所以我将要分享下，哪些区域里装饰器可以让你的代码更简洁。 首先，让我们讨论下如何写你自己的装饰器。

‘@’符号用作函数修饰符是python2.4新增加的功能，修饰符必须出现在函数定义前一行，不允许和函数定义在同一行。也就是说＠A def f(): 是非法的。只可以在模块或类定义层内对函数进行修饰，不允许修饰一个类。一个修饰符就是一个函数，它将被修饰的函数做为参数，并返回修饰后的同名函数或其它可调用的东西。

实例（1）：

def spamrun(fn):
   def sayspam(*args):
       print("spam,spam,spam")
   return sayspam

@spamrun
def useful(a,b):
   print (a**2+b**2)

执行： useful(3,4)

返回：spam,spam,spam

def addspam(fn):
   def new(*args):
       print "spam,spam,spam"
       return fn(*args)
   return new

@addspam
def useful(a,b):
   print a**2+b**2

执行： useful(4,3)

结果：

spam,spam,spam

25

@torch.no_grad()

@torch.no_grad()
def eval():
	...

@torch.no_grad()后面的函数的数据不需要计算梯度，也不会进行反向传播

Python装饰器：

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

先来看一个简单例子：

def foo():
    print('i am foo')

现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：

def foo():
    print('i am foo')
    logging.info("foo is running")

bar()、bar2()也有类似的需求，怎么做？再写一个logging在bar函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门处理日志 ，日志处理完之后再执行真正的业务代码

def use_logging(func):
    logging.warn("%s is running" % func.__name__)
    func()

def bar():
    print('i am bar')

use_logging(bar)

逻辑上不难理解， 但是这样的话，我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢？当然有，答案就是装饰器。

简单装饰器

def use_logging(func):

    def wrapper(*args, **kwargs):
        logging.warn("%s is running" % func.__name__)
        return func(*args, **kwargs)
    return wrapper

def bar():
    print('i am bar')

bar = use_logging(bar)
bar()

函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。

@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作

方法一：不用语法糖@符号​​​​​​​

# 装饰器不传入参数时
f = decorator(函数名)

# 装饰器传入参数时
f = (decorator(参数))(函数名)


方法二：采用语法糖@符号​​​​​​​

# 已定义的装饰器
@decorator 
def f():  
    pass

# 执行被装饰过的函数 
f()

def use_logging(func):

    def wrapper(*args, **kwargs):
        logging.warn("%s is running" % func.__name__)
        return func(*args)
    return wrapper

@use_logging
def foo():
    print("i am foo")

@use_logging
def bar():
    print("i am bar")

bar()

如上所示，这样我们就可以省去bar = use_logging(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。

装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。

带参数的装饰器

装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@use_logging，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。

def use_logging(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == "warn":
                logging.warn("%s is running" % func.__name__)
            return func(*args)
        return wrapper

    return decorator

@use_logging(level="warn")
def foo(name='foo'):
    print("i am %s" % name)

foo()

上面的use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level=”warn”)调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。

类装饰器

再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

__call__方法 : 在生成一个类的实例时，自动自行一次call方法

当执行Foo时候生成一个实例，就会自动调用__call__方法

class Foo(object):
    def __init__(self, func):
    self._func = func

def __call__(self):
    print ('class decorator runing')
    self._func()
    print ('class decorator ending')

@Foo
def bar():
    print ('bar')

bar()

functools.wraps

使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：

装饰器

def logged(func):
    def with_logging(*args, **kwargs):
        print func.__name__ + " was called"
        return func(*args, **kwargs)
    return with_logging

函数

@logged
def f(x):
   """does some math"""
   return x + x * x

该函数完成等价于：

def f(x):
    """does some math"""
    return x + x * x
f = logged(f)

不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。

print f.__name__    # prints 'with_logging'
print f.__doc__     # prints None

这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。

from functools import wraps
def logged(func):
    @wraps(func)
    def with_logging(*args, **kwargs):
        print func.__name__ + " was called"
        return func(*args, **kwargs)
    return with_logging

@logged
def f(x):
    """does some math"""
    return x + x * x

print f.__name__  # prints 'f'
print f.__doc__   # prints 'does some math'

内置装饰器

@staticmathod、@classmethod、@property

@property

把类内方法当成属性来使用，必须要有返回值，相当于getter；

假如没有定义 @func.setter 修饰方法的话，就是只读属性

class Car:

    def __init__(self, name, price):
        self._name = name
        self._price = price    
     
    @property
    def car_name(self):
        return self._name
        
     # car_name可以读写的属性   
     @car_name.setter
     def car_name(self, value):
         self._name = value
         
     # car_price是只读属性 
     @property
     def car_price(self):
         return str(self._price) + '万'
         
benz = Car('benz', 30)

print(benz.car_name)   # benz
benz.car_name = "baojun"
print(benz.car_name)   # baojun
print(benz.car_price)  # 30万

@staticmethod

静态方法，不需要表示自身对象的self和自身类的cls参数，就跟使用函数一样。

静态方法的使用场景：

如果在方法中不需要访问任何实例方法和属性，纯粹地通过传入参数并返回数据的功能性方法，那么它就适合用静态方法来定义，它节省了实例化对象的开销成本，往往这种方法放在类外面的模块层作为一个函数存在也是没问题的，而放在类中，仅为这个类服务。

@classmethod

类方法，不需要self参数，但第一个参数需要是表示自身类的cls参数。

类方法的使用场景有：

作为工厂方法创建实例对象，例如内置模块 datetime.date 类中就有大量使用类方法作为工厂方法，以此来创建date对象。如果希望在方法里面调用静态类，那么把方法定义成类方法是合适的，因为要是定义成静态方法，那么你就要显示地引用类A，这对继承来说可不是一件好事情。

例子

class Demo(object):

    text = "三种方法的比较"
    
    def instance_method(self):
        print("调用实例方法")

    @classmethod
    def class_method(cls):
        print("调用类方法")
        print("在类方法中 访问类属性 text: {}".format(cls.text))
        print("在类方法中 调用实例方法 instance_method: {}".format(cls().instance_method()))

    @staticmethod
    def static_method():
        print("调用静态方法")
        print("在静态方法中 访问类属性 text: {}".format(Demo.text))
        print("在静态方法中 调用实例方法 instance_method: {}".format(Demo().instance_method()))

if __name__ == "__main__":
    # 实例化对象
    d = Demo()
    
    # 对象可以访问 实例方法、类方法、静态方法
    # 通过对象访问text属性
    print(d.text)
    
    # 通过对象调用实例方法
    d.instance_method()
    
    # 通过对象调用类方法
    d.class_method()
    
    # 通过对象调用静态方法
    d.static_method()
    
    # 类可以访问类方法、静态方法
    # 通过类访问text属性
    print(Demo.text)
    
    # 通过类调用类方法
    Demo.class_method()
    
    # 通过类调用静态方法
    Demo.static_method()

@staticmethod 和 @classmethod 的 区别 和 使用场景：

在上述例子中，我们可以看出，

区别

在定义静态类方法和类方法时，@staticmethod 装饰的静态方法里面，想要访问类属性或调用实例方法，必须需要把类名写上；

而@classmethod装饰的类方法里面，会传一个cls参数，代表本类，这样就能够避免手写类名的硬编码。

在调用静态方法和类方法时，实际上写法都差不多，一般都是通过 类名.静态方法() 或 类名.类方法()。也可以用实例对象调用类方法和静态方法。 对象可以访问 实例方法、类方法、静态方法 ， 类可以访问类方法、静态方法

也可以用实例化对象去调用静态方法和类方法，但为了和实例方法区分，最好还是用类去调用静态方法和类方法。

使用场景

所以，在定义类的时候，

假如不需要用到与类相关的属性或方法时，就用静态方法@staticmethod；

假如需要用到与类相关的属性或方法，然后又想表明这个方法是整个类通用的，而不是对象特异的，就可以使用类方法@classmethod。

装饰器的顺序

@a
@b
@c
def f ():

等效于

f = a(b(c(f)))