模块
使用模块import 模块名。有的仅仅导入了某个模块的一个类或者函数，使用from 模块名 import 函数或类名实现。为了避免模块名冲突。Python引入了按文件夹来组织模块的方法，称为包（Package）。
则在a文件夹下的b.py模块名就是a.b。a文件夹下必须有一个文件__ini__.py。哪怕是文件内容是空。否则a就成了普通文件夹。
标准模块文件模板：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
'a test module' #不论什么模块的第一个字符串都被视为模块的文档凝视
__author__ = 'Your Name'
...
def f():
...
if __name__ == '__main__': #从其它地方导入模块，if不会通过。因此能够用来在命令行下进行測试
f()- 模块中的非公开函数前缀
_。如def _private_1(): - 能够被直接引用的特殊变量一般用
__argname__这样的前后各两个下划线的形式来表示。自定义的公开函数或变量一般就用普通的形式def f，不用这样的下划线形式。 - 须要注意的是。Python并没有一种方法能够全然限制訪问private函数或变量。因此这个得靠自觉了
第三方模块能够使用pip安装pip install numpy。它会从python的官方站点自己主动下载和安装。
也能够自己下载下来之后安装。
面向对象编程
类语法
class Student(object):
passobject是默认父类名称。实例的创建使用tom = Student()。作为动态语言，Python支持*给tom绑定类外的新属性tom.name = 'Tom'。
假设有须要在创建实例时绑定的属性。一般写在类中的__ini__函数中：
def __ini__(self, arg1, arg2):
self.__arg1 = ...
self.arg2 = ...__ini__的第一个參数永远是self，会自己主动传入。
有了这样的__ini__。创建实例时就须要传入arg1和arg2參数。__arg1的两个前下划线表明这是一个私有属性，不能被外部訪问。
鸭子类型：仅仅要看起来像鸭子。跑起来像鸭子，那就能够看做鸭子
Python的动态性也体如今继承的上。假设有个函数中调用了某类的方法，仅仅要传入的对象也有这种方法，都能够运行，而和这个对象是不是该类或该类子类的实例无关。
获取对象信息
获取对象的信息能够使用type()，同一时候假设
import types。还能够使用type(对象) == types.type模块中的常量函数类型来推断一个对象是否是某种详细函数类型。isinstance(对象，类)的推断方法则假设该对象是參数中类的父类也返回True。能用type推断的基本类型都能够使用isinstance，第二个參数也能够是个list。仅仅要满足是元素之中的一个就返回True。dir()能够将一个对象的全部属性和方法都返回
当不知道对象细节时，能够使用
hasattr(obj, 'arg')得到obj是否有arg属性或方法；getattr(obj, 'arg')返回属性或方法；setattr(obj, 'arg', value)设置属性或方法（没有则直接添加）
面向对象高级编程
使用__slots__
由于Python是动态语言。因此能够任意为类、实例绑定属性或者方法。绑定方法要用到from types import MethodType，s.f = MethodType(f, s)将方法f绑定到类或实例s上。同一时候要注意f的第一个參数要是self才干绑定。
假设想要限制实例的属性，就须要在定义类的时候定义一个特殊变量__slots__ = ('name1','name2')来限定给实例绑定的属性名仅仅能是name1或者name2。
辨析：
from types import MethodType
class Student(object):
__slots__ = ('name', 'sex', 'set_name', 'set_grade')
#同意绑定的在下文中称为内方法和内属性。
反之称为外方法和外属性#
#内方法中绑定内属性
def set_name(self, name):
self.name = name
#内方法中绑定外属性#
def set_grade(self, grade):
self.grade = grade
#外方法中绑定外属性#
def set_score(self, score):
self.score = score
#外方法中绑定内属性#
def set_sex(self, sex):
self.sex = sex
tom = Student()
jane = Student()（1）给实例绑定属性：
tom.name = 'Tom' #正确。name是内属性
jane.grade = 98 #错误，grade是外属性。不能绑定
print(jane.name) #错误，未定义实例jane的name
#第三句可见实例绑定的属性仅仅算各个实例自己的（2）给类绑定属性：
Student.name = 'name' #内属性能够绑定
Student.grade = 0 #外属性也能够绑定，可见__slots__仅仅作用于实例
tom.name = 'Tom' #错误。可见通过这样的方法绑定的属性到实例中为仅仅读
print(jane.name) #输出为name
（3）给实例绑定方法：
tom.set_name = MethodType(set_name, tom) #内方法，当中绑定内属性
tom.set_grade = MethodType(set_name, tom) #内方法。当中绑定外属性。调用方法时会报错
tom.set_score = MethodType(set_score, tom) #外方法。不可绑定
tom.set_sex = MethodType(set_name, tom) #外方法，不可绑定
（4）给类绑定方法
#绑定内方法
Student.set_name = MethodType(set_name, Student)
tom.name = 'Tom'
print(jane.name) #报错，可见在调用方法绑定内属性之前。“实例.属性 =”事实上回到了第一种辨析的情况
tom.set_name('Tom')
jane.set_name('Jane') #调用内方法，才将内属性绑定到了类
tom.name = 'Tom' #报错。可见上一句绑定的属性和（3）中同样。仅仅读。
仅仅能通过类方法改动
print(jane.name)
print(tom.name) #输出也是Jane，可见通过类方法改动的属性是类属性，各实例的相应属性都是最后一次调用类方法之后的属性值
#绑定内方法，当中绑定外属性
Student.set_grade = MethodType(set_grade, Student)
tom.set_grade(4) #调用方法绑定了外属性
tom.grade = 4 #类属性仅仅读。不可直接改动
print(tom.grade) #实例拥有了外属性，只是是类属性，仅仅读，仅仅能通过类方法改动剩下的两种情况不再赘述，由于__slots__不限制类，因此不论什么方法和属性都能够被绑定。仅仅只是通过调用方法绑定的属性是仅仅读的，仅仅能通过调用方法改动，不能在实例中直接使用.赋值改动通过以上辨析，总结例如以下：
__slots__仅仅限制实例的方法或属性绑定，不限制类。对类绑定的方法和属性都能够在实例中调用，但类属性在实例中是仅仅读的，它的值为最后一次调用方法或通过
类.属性=赋值的结果，不能在实例中用实例.属性=改动。
使用@property
当须要改动属性时。为了能够检查參数，一般调用方法来设置属性值。
但这样的话就略显麻烦。
这时候@property装饰器就起作用了。
@property
def name(self):
return self._name
@name.setter #假设不用下面的部分，则name就变成了仅仅读属性
def name(self,value):
...类型检查等
self._name = value注意属性_name一定要有下划线来区分属性和方法，否则名字同样变成了方法。上面的代码就成了递归。会报现递归次数溢出错误
多重继承
假设继承的多个父类都有同样的方法，则以第一个为准，后面几个父类的该方法不会起作用。
定制类
诸如__slots__这样的两端都有两个下划线的变量或者函数是有特殊用途的，因此能够通过定义这类对象来对类进行定制
__str__(self)：当运行print(类）时，程序会打印出属性和内存地址，假设想要打印出特定的内容。则能够定义一个__str__方法，输出特定的内容。
假设不用print而是直接调用类名输出信息。则须要定义__repr__()方法。简单的一种定义方法就是__repr__ = __str__高速定义。
__iter__(self)：假设想要迭代一个类则须要定义__iter__方法返回self。然后再定义一个__next__(self)方法运行迭代中要做的事情
__getitem__(self, n)：把类变成像list那样能够按下标取元素操作。
在__getitem__下返回元素值。假设要实现切片等功能。还要再对这个函数进行进一步的细化，比方推断传入的參数是否是slice等一系列兴许操作。
同样地，将类变为像dict那样，使用__setitem__。使用__delitem__删除元素。
以上的这些方法将类变成list或dict的“鸭子”，使类能够像list或dict那样操作。
__getattr__(self, attr)：返回动态属性或方法。
这个函数下边对attr进行推断。从而绑定规定的属性或者方法。绑定属性返回属性值。绑定方法则返回lambda函数。
假设没有不论什么限制，显然不论什么属性或方法都能够绑定。这时候假设返回自身，则就实现了链式调用。利用这一点构造一个针对不同API的SDK。下面的代码就实现了一个GitHub的API的URL输出：
class Chain(object):
def __init__(self, path =''):
self._path = path
def __getattr__(self, path):
return Chain('%s/%s' %(self._path, path))
def __call__(self,name):
return Chain('%s/:%s' %(self._path, name))
def __str__(self):
return 'GET ' + self._path
print(Chain().users('hermanncain').repos)
#输出为GET /users/:hermanncain/repos
__call__(self)：调用实例自身。
即调用s()时运行__call__(self)。也能够使用__call__(self, *args, **kw)来传递參数，则调用s(*args, *kw)时运行当中的内容。这样模糊了类和实例的界限。
枚举类
from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
'Oct', 'Nov', 'Dec'))
for name, member in Month.__member__.items():
print(name, '=>', member, ',', member.value)value为枚举成员相应的int值，默认从1開始
还有一种从Enum派生的自定义枚举类。语法就和C++中的枚举类型有些像了：
from enum import Enum, unique
@unique
class Weekday(Enum):
Sun = 0
Mon = 1
...@unique装饰器用于检查反复值。
对枚举类的成员有下面几种引用方法：
print(Weekday.Sun)
print(Weekday['Sun'])
print(Weekday(1))
#以上的输出都是Weekday.Sun
print(Weekday.Sun.value)
#输出0元类*
使用type()创建类
动态语言的函数和类的定义是在运行时动态创建的。
写一个a.py的模块。在模块里定义class A，然后在主程序中from a import A，加载模块时运行模块全部语句，结果就是动态创建出一个A的class。type(A)返回值是type，type(A的实例)的返回值则是class '__main__'.A。
可是type()也能够用于动态创建类。实际上Python解释器遇到class定义时，也是使用type()动态地将该类创建出来的：
def f(self, ...):
...
A = type('A', (object,), dict(af = f)这样就动态创建了一个A类。父类是object（注意多重继承父类放在tuple里。假设仅仅有一个父类则tuple仅仅有一个元素，逗号不可少）。而且有一个名为af的方法。
metaclass元类*
类相当于元类的实例。metaclass是Python面向对象里最难理解，也是最难使用的魔术代码。一般用不到
*这部分内容先略过，等到用到的时候依据实例来整理