Pyhton学习笔记

def是将一个函数对象和一个变量关联起来，这样使用 变量名() 就可以调用该函数，而lambda定义函数，直接返回的函数对象。

变量的作用域：变量分为函数内的变量（本地变量），模块的变量（全局变量），built_in变量（整个Pyhton语言事先定义好的变量，如 for、list），其作用域依次由小增大。

在引用一个变量时会优先从小作用域中去找这个变量的值，若没有，则回去更大的作用域寻找。

一个函数可传入的参数如下所示，

1、x 为指定参数，参数的数量必须传入的实参保持一致，

2、x = 10 未默认参数，若不传入此实参，则使用默认的值，若传入实参，则用实参替代默认值。

3、*x 表示可传入不限定数量的实参

4、 **x 用于传入不限定数量的dict实参

def(x,x = 10，*x,**x)  

函数的闭合。

def f1(y):
    def f2(x):
        return x**y
    return f2

当执行上述函数时，返回的是函数对象f2，由于f2中有用到f1传入的参数，故系统会将f1传入的参数保存下来，执行f2对象是调用该参数，这就叫函数的闭合。

Python闭包 lexical closure 是指函数及其相关环境组成的整体。 闭包仅是在形式上像函数，闭包自身并不是函数，实际他是让别人生成一个函数对象。

函数在嵌套环境中，如果内层函数对外层函数作用域中的变量进行了引用，那么在外层函数返回后，内层函数依然可以使用其外层函数中的变量，这种变量就构成了内层函数可以使用的环境。

函数的惰性计算。 其实生成器就是运用了此原理。函数中使用yield，会返回一个生存器对象。

def getNum(n):
    i = 0
    while i <= n:
        yield i**2
        i+=1
g1 = getNum(20)
print type(g1)
for i in g1:
    print i

装饰器: （原来装饰器其实是利用了闭包的原理 ）

    1、装饰器本身是一个函数，用于装饰其它函数。

    2、功能：增强被装饰函数的功能

装饰器一般接收一个函数对象作为参数，以对其进行功能增强。

即使用@服务装饰某个方法时，该方法会被当成参数传入装饰器中，而装饰器会给该方法添加一些其他的功能，这样就达到了增强该函数的功能。

def deco(func):
    def wrapper(x):
        print "please say something >>>"
        func(x)
        print "i have say"
    return wrapper
@deco
def show(x):
    print x
show("huyansheng")

协程：yield置于右边时，表示协程。

函数的设计规范：

    耦合性：

        1、通过参数接收输入，以及通过return产生输出以保证函数的独立性。

        2、尽量减少使用全局变量进行函数间的通信。

        3、不要在函数中直接修改可变类型参数。

        4、避免直接改变定义在另一个模块中的变量。

       

    聚合性：

        1、每个函数都应该有一个单一的、统一的目标

        2、每个函数的功能都应该相对简单。

程序 = 指令 + 编号

    代码可以选择以指令为核心或以数据为核心进行编写

以指令为核心则是面向过程的编程：程序具有一些列的动作，主体思想是代码作用于数据

以数据为核心则是面向对象的编程：围绕数据及数据严格定义的接口来组织程序，用数据控制对代码的访问

类间关系

依赖：一个类的方法操作另一个类的对象

聚合：类A的对象包含类B的对象

继承：描述特殊与一般关系

面向对象的模型机制的三个原则：封装、继承、多态

封装：隐藏实现方案细节

        将代码及其处理的数据绑定在一起的一种编程机制，用于保证程序和数据不受外部干扰且不会被误用。

继承：一个对象获得另一个对象属性的过程；用于实现按层分类的概念。

        一个深度继承的子类继承了类层次中它的每个祖先的所有属性

        超类、基类、父类、

        子类、派生类

多态：允许一个接口被多个通用的的类动作使用的特性，具体使用哪个动作与应用场合有关。

        一个接口，多个方法。

        用于为一组相关的动作设计一个通用的接口，以降低复杂度。

顺便提一句关于Java中接口和抽象类的关系。都是表现了抽象的概念，不同点是接口表现一类动作的抽象，而抽象类则是一种根源的抽象。（这是我见过对接口和抽象类最好的解释）而实际表现出来的则是接口只能定义抽象方法，且不能有实现和成员变量；而抽象类中可以有成员变量，可以有抽象方法，也可以有具体实现的方法。

Python中类是一种可调用对象，callable（）；故创建类的实例的方法与Java略有不同，instance = ClassName(args...)

类在实例化时可使用__init__和__del__两个特殊的方法。注意类对象和实例对象的区别。

Python使用class关键字创建类，语法格式如下：

class ClassName(bases):

    data = value

    def method(self,...):

        self.member = value  

超类是一个或多个用于继承的父类的集合。

class语句内，任何赋值语句都会创建类属性

每个实例对象都会继承类的属性并获得自己的名称空间

在OOP中，实例就像是带有“数据”的记录，而类是处理这些记录的"程序"

通过实例调用方法相当于调用所属类的方法来处理当前实例

因此，类中的每个方法必须具有self参数，它隐含当前实例之意。

在方法内对self属性做赋值计算会产生每个实例自己的属性

Python中规定，没有实例，方法允许被调用，此即“绑定”

要区分实例属性和类属性。

__varname__():Python解释器会自动调用

__init__方法被成为构造器,如果类中没有定义__init__方法，实例创建之初仅是一个简单的名称空间

可以使用类的__dict__方法或dir()查看实例属性

c.__name__  类c的名字

c.__doc__ 类c的文档字符串

c.__bases__  类c的所有父类组成元组

c.__dict__ 类c的属性

c.__module__ 类c定义所在的模块

c.__class__ 实例c对应的类

方法的可用变量

1、实例变量：指定变量名称及实例自身进行引用，如self.变量名

2、局部变量：方法内部创建的变量，可直接使用

3、类变量（也称静态变量）：通过指定类名和变量名进行引用，如类名.变量名

4、全局变量：直接使用

#!/user/bin/env python
# encoding = "utf-8"
global_variable = 2  #全局变量，即模块内的变量
class Person():
	static_variable = "hello world"    #类变量，也成为静态变量
	class_variable = " ni hao "
	def __init__(self,instance_name):   #实例变量，实例对象时引用的变量
		self.instance_name = instance_name
	def printName():
		local_variable = 0
		for local_variable in range(5):  #局部变量，即方法内部内定义的变量
			print local_variable
			local_variable+=1

类实例化的过程。

继承描述了基类的属性如何“遗传”给派生类

1、子类可以继承基类的任何属性，包括数据属性和方法

2、一个未指定基类的类，其默认有一个名为object的基类

3、Python允许多重继承

4、创建子类时，只需要在类名后跟一个或多个父类 

class ParentClass(object):
	'parent class'
	gender = 'Male'
	def setName(self,x):
		self.name = x
class ChildClass(ParentClass):
	'child class'
	def displayInfo(self):
		print self.name,self.gender
x =  ChildClass()
x.setName('Tom')
x.displayInfo()
>>> Tom Male

Python中几乎所有属性的获取都可以使用"object.attribute"的格式，不过，此表达式会在Python中启动搜索——搜索连续的树。

class语句会产生一个类对象，对class的调用会创建实例，实例自动连结至创建了这些实例的类。

继承会现在子类中寻找变量名，然后才查找超类，因此，子类可以对超类的属性重新定义来取代继承的行为。

1、子类完全可以取代从超类继承而来的属性

2.也可以通过已覆盖的方法回调超类来扩展超类的方法

class FarClass(object):
	def setInfo(self,sex='Female'):
		self.sex = sexx
class ChiClass(FarClass):
	def setInfo(self,name):
		self.name = name
x = ChiClass()
x.setInfo('Tom')
x.name
>>> Tom

issubclass()布尔函数，判断一个类是否由另一个类派生，语法：issubclass(sub,sup)

isinstance()布尔函数，判断一个对象是否是给定类的实例，语法:isinstance(obj1,obj2_class)

hasattr() 布尔函数，判断一个对象是否有指定的属性，语法：hasattr(obj,attr)

super()  在子类中找出其父类以便于调用其属性，一般情况下仅能采用非绑定方式调用祖先类方法，

而super()可用于传入实例或类型对象，语法super(type[,obj])

运算符重载就是用各种运算符来重载方法。

运算符重载是指在方法中拦截内置的操作——当类的实例出现在内置操作中，Python会自动调用自定义的方法，并且返回自定义方法的操作结果。

运算符重载让类拦截常规的Python运算；

1、类可重载所有Python表达式运算符

2、类也可重载打印、函数调用、属性点号运算等内置运算

重载使类实例的行为更像内置对象

重载通过提供特殊名称的类方法实现。

重载运算符并非必需，并且通常也不是默认的。

除了__init__和__del__之外，Python类支持使用许多特殊方法。

这些特殊方法是Python用来扩展类的强大工具，他们可以实现：

1、模拟标准类型

2、重载操作符

特殊方法允许类通过重载标准操作符+、*，甚至包括分段下标及映射操作[]来模拟标准类型

模块：顶层文件、模块文件1、模块文件2、

模块在物理形式上表现为以.py结尾的代码文件

1、一个文件被看作一个独立的模块，一个模块也可以被看作是一个文件

2、模块的文件名就是模块的名字加上扩展名.py

3、每隔模块都有自己的名称空间。

Python中允许“导入”其他模块以实现代码重用，从而也实现了将独立的代码文件组织成更大的程序系统

1、Python中，模块也是对象

2、在一个模块的顶层定义的所有变量都在被导入时成为了被导入模块的属性

import module as module_alias

from module import name1 常用于导入指定模块的部分属性至当前名称空间

import 和from -import 是赋值语句

1、import 和 from 是可执行语句，类似于def，因此，他们可以嵌套在if测试中，出现于def中等等

2、Python执行到到这些语句时才会对其进行解析，这意味着，所有来自模块的属性仅在import语句执行后才能使用

import 语句导入指定模块时会执行三个步骤：

1、找到模块文件：在指定的路径下搜索模块文件

2、编译成字节码：文件导入时就会编译，因此，顶层文件的.pyc字节码文件在内部使用后会被丢弃，只有被导入的文件才会留下.pyc文件

3、执行模块的代码来创建所定义的对象：模块文件中的所有语句会依次执行，从头至尾，而此步骤中任何对变量名的赋值运算，都会产生所得到的模块文件的属性

注意：模块只有在第一次导入时才会执行如上步骤

1、后续的操作只不过是提取内存中已加载的模块对象

2、reload()可用于重新加载模块

Python解释器在import模块时必须先找到对应的模块文件

1、程序的主目录

2、PYTHONPATH目录（如果设置了此变量）

3、标准链接库目录

4、任何.pth文件的内容（如果存在.pth文件）

这四个组件组合成起来即是sys.path所包含的路径，而Python会选择在搜索路径中的第一个符合导入文件名的文件。

包用于将一组模块归并到一个目录中，此目录即包，目录名即为包名。

1、包是一个有层次的文件目录结构，它定义了一个由模块和子包组成的Python应用程序执行环境

2、基于包，Python在执行模块导入时可以指定模块的导入路径。 如 import dir1.dir2.mod1

包导入语句的路径内的每个目录内必须有__init__文件，__init__可包含Python代码，但通常为空，仅用于扮演包初始化的挂钩、替目录产生模块命令空间以及使用目录导入时实现from *行为的角色。

一个模块文件可以同时支持顶层执行（作为顶层文件）或被导入（作为模块文件）

每个模块都有名为__name__的内置属性，Python会自动设置该属性。

1、如果文件是以顶层程序文件执行，在启动时，__name__的值为"__main__"

2、如果被导入，则__name__为模块名

distutils模块能够帮助完成模块获程序发布。

1、“发布”是指一个文件集合，这些文件联合在一起可使用distutils构建、打包和发布模块

2、创建好的发布可用于安装，也可上传到PyPI与他人共享。

创建发布

1、将各代码文件组织到模块容器中

2、准备一个README或README.txt文件

3、而后在容器中创建setup.py文件

from distutils.core import setup
setup(
	name = "testmod",
	version = '0.0.1',
	author = 'fengmanlou',
	author_email = "huyansheng@gmail.com",
	py_module = ['test_module'],
	url = '',
	descrpition = 'A simple module',
	platforms:平台列表
	license：许可证
	py_modules:各模块名称组成的列表，这些模块可能位于包的根目录下（modname），也可能位于某子包目录中（subpkg1.modname）。
	packages: 各子包名组成的列表	
)

python setup.py sdist/bdist 

    可指定格式：

        zip：zip file

        gztar：tar.gz file

        bztar: tar.bz2 file

第三方模块的默认安装路径通常为:site-packages

    /user/local/python27/lib/python2.7/site-packages

自定义安装路径：

    --user=

    --prefix =

    --exec-prefix = 

深度定制：

    --install-purelib = /path/to/python_lib

    --install-platlib=/path/to/plat_lib

        

Python的异常是一个对象，表示错误或意外情况

在Python检测到一个错误时，将触发一个异常。

    python可以通过异常机制传导一个异常对象，发出一个异常情况出现的信号。

Python的异常可以理解为：程序出现了错误而在正常控制流以外采取的行为。

第一阶段：解释器触发异常，此时当前程序流将被打断

第二阶段：异常处理，如忽略非致命错误、减轻错误带来的影响等。

错误处理：Python的默认处理：停止程序，打印错误信息。

使用try语句处理异常并从异常中恢复

事件通知：用于发出有效状态信号

特殊情况处理：无法调整代码去处理的场景

终止行为：try/finally 语句可确保执行必需的结束处理机制

非常规控制流程：异常是一种高级跳转（goto）机制

try-except-finally

raise语句可显式触发异常，raise [SomeException [,args [,traceback]] ]

1、SomeException ： 可选，异常的名字，仅能使用字符串、类、实例

2、args : 可选，以元组的形式传递给异常的参数

3、traceback ： 可选，异常触发时新生成的一个用于异常-正常化的跟踪标记，多用于重新引发异常时。

Python自身引发的所有异常都是Exception的子类的实例 

assert 语句用于在程序中引入调试代码

assert condition[, expression]

1、如果condition条件满足，则assert不做任何操作

2、如果condition条件不满足，则assert使用expression作为参数实例化AssertionError并引发结果实例

其实断言语句就是一个简化版的自定义异常，用于测试代码的正确性，如果代码正确，条件满足则assert不做任何操作，

如果代码错误，导致condition中的条件不满足，就会导致AssertionError。

注意：如果运行Python时使用了-O优化选项，则assert将是一个空操作：编译器不为assert语句生成代码

运行Python时不使用-O选项，则__debug__内置变量为True，否则其值为False 

assert语句相当于以下代码：

if __debug__:
	if not condition:
		raise AssertionError,<expression>

doctest模块允许在字符串文档内嵌入注释以显示各种语句的期望行为，尤其是函数和方法的结果

1、此处的文档字符串看起来如同一个交互式shell会话

2、可用于测试文档是否与程序主体保持同步，或基于文档对程序本身做测试、

自动化测试框架。

创建可自测试的模块：

在模块的尾部添加如下代码即可。 

if __name__ == "__main__":
	import doctest
	doctest.testmod()

 

        

来自为知笔记(Wiz)