1.面向对象高级语法部分
1.1 静态方法
通过 @staticmethod 装饰器即可把其装饰的方法变为一个静态方法，什么是静态方法呢？其实不难理解，普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，但 静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法
class Dog(object): def __init__(self,name): self.name = name @staticmethod # 把eat方法变为静态方法 def eat(self): print("%s is eating" % self.name)d = Dog("ChenRonghua")d.eat() # 报错d.eat(d) # 调用时主动传递实例本身给eat方法才能正常工作 上面的调用会出以下错误，说是eat需要一个self参数，但调用时却没有传递，没错，当eat变成静态方法后，再通过实例调用时就不会自动把实例本身当作一个参数传给self了。
Traceback (most recent call last): File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/静态方法.py", line 17, in d.eat()TypeError: eat() missing 1 required positional argument: 'self' 想让上面的代码可以正常工作有两种办法：
- 调用时主动传递实例本身给eat方法，即d.eat(d)
- 在eat方法中去掉self参数，但这也意味着，在eat中不能通过self.调用实例中的其它变量了，代码示例如下：
class Dog(object): def __init__(self,name): self.name = name @staticmethod def eat(): print(" is eating")d = Dog("ChenRonghua")d.eat() 1.2 类方法
类方法通过 @classmethod 装饰器实现，类方法和普通方法的区别是：类方法只能访问类变量，不能访问实例变量
class Dog(object): def __init__(self,name): self.name = name @classmethod def eat(self): print("%s is eating" % self.name) d = Dog("ChenRonghua")d.eat() 执行报错如下，说Dog没有name属性，因为name是个实例变量，类方法是不能访问实例变量的：
Traceback (most recent call last): File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/类方法.py", line 16, ind.eat() File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/类方法.py", line 11, in eat print("%s is eating" % self.name)AttributeError: type object 'Dog' has no attribute 'name'
此时可以定义一个类变量，也叫name,看下执行效果：
class Dog(object): name = "我是类变量" def __init__(self,name): self.name = name @classmethod def eat(self): print("%s is eating" % self.name)d = Dog("ChenRonghua")d.eat()#执行结果：我是类变量 is eating 1.3 属性方法
属性方法的作用就是通过 @property 把一个方法变成一个静态属性
class Dog(object): def __init__(self,name): self.name = name @property def eat(self): print("%s is eating" % self.name)d2 = Dog("Jack")d2.eat() 调用会出以下错误， 说NoneType is not callable, 因为==eat此时已经变成一个静态属性了， 不是方法了， 想调用已经不需要加()号了，直接d.eat就可以==了
Traceback (most recent call last): ChenRonghua is eating File "/Users/jieli/PycharmProjects/python基础/自动化day7面向对象高级/属性方法.py", line 16, ind.eat()TypeError: 'NoneType' object is not callable
去掉()调用才能正常调用：
d = Dog("Jack")d.eat输出:Jack is eating 场景应用：
把一个方法变成静态属性有什么卵用呢？既然想要静态变量，那直接定义成一个静态变量不就得了么？well, 以后你会需到很多场景是不能简单通过 定义 静态属性来实现的， 比如 ：你想知道一个航班当前的状态，是到达了、延迟了、取消了、还是已经飞走了， 想知道这种状态你必须经历以下几步:
- 连接航空公司API查询
- 对查询结果进行解析
- 返回结果给你的用户
因此这个status属性的值是一系列动作后才得到的结果，所以你每次调用时，其实它都要经过一系列的动作才返回你结果，但这些动作过程不需要用户关心， 用户只需要调用这个属性就可以。
class Flight(object): def __init__(self,name): self.flight_name = name def checking_status(self): print("checking flight %s status " % self.flight_name) return 1 @property def flight_status(self): status = self.checking_status() if status == 0 : print("flight got canceled...") elif status == 1 : print("flight is arrived...") elif status == 2: print("flight has departured already...") else: print("cannot confirm the flight status...,please check later") @flight_status.setter # 修改flight_status属性需要通过@proerty.setter装饰器再装饰一下，此时需要写一个方法， 对这个flight_status进行更改。 def flight_status(self,status): status_dic = { 0 : "canceled", 1 :"arrived", 2 : "departured" } print("\033[31;1mHas changed the flight status to \033[0m",status_dic.get(status) ) @flight_status.deleter # 删除 def flight_status(self): print("status got removed...")f = Flight("CA980")f.flight_statusf.flight_status = 0 #触发@flight_status.setterdel f.flight_status #触发@flight_status.deleter 注意以上代码里还写了一个 @flight_status.deleter , 是允许可以将这个属性删除
2. 类的特殊成员方法
class A(object): """ 这是一个测试的类。 """ passa = A()#1. __doc__ 表示类的描述信息print(A.__doc__)#2. __module__ 表示当前操作的对象在那个模块print(A.__module__) #>>: __main__print(a.__module__) #>>: __main__#3. __class__ 表示当前操作的对象的类是什么print(a.__class__) #>>:#4. __init__ 构造方法，通过类创建对象时，自动触发执行#5. __del__ 析构方法，当对象在内存中被释放时，自动触发执行。#6. __call__ 实例对象后面加括号直接执行# 构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
- __dict__ 查看类或对象中的所有成员
class Province: country = 'China' def __init__(self, name, count): self.name = name self.count = count def func(self, *args, **kwargs): print 'func'# 获取类的成员，即：静态字段、方法、print Province.__dict__# 输出：{'country': 'China', '__module__': '__main__', 'func': , '__init__': , '__doc__': None}obj1 = Province('HeBei',10000)print obj1.__dict__# 获取 对象obj1 的成员# 输出：{'count': 10000, 'name': 'HeBei'} - __str__ 如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值。
class Foo: def __str__(self): return 'This is string'obj = Foo()print obj# 输出：This is string
9.__getitem__、__setitem、__delitem
用于索引操作，如字典。以上分别表示获取、设置、删除数据
class Foo(object): def __getitem__(self, key): print('__getitem__',key) def __setitem__(self, key, value): print('__setitem__',key,value) def __delitem__(self, key): print('__delitem__',key)obj = Foo()result = obj['k1'] # 自动触发执行 __getitem__obj['k2'] = 'Tesla' # 自动触发执行 __setitem__del obj['k1'] # 自动触发执行 __delitem__ - __new__ __metaclass__
class Foo(object): def __init__(self,name): self.name = namef = Foo("alex") 上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。
如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的构造方法创建。
print type(f) # 输出：# 表示，obj 对象由Foo类创建print type(Foo) # 输出： # 表示，Foo类对象由 type 类创建
所以，f对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。
那么，创建类就可以有两种方式：
a). 普通方式
class Foo(object): def func(self): print 'hello world'
b). 特殊方式
def func(self): print 'hello wupeiqi'Foo = type('Foo',(object,), {'func': func})#type第一个参数：类名#type第二个参数：当前类的基类#type第三个参数：类的成员 加上构造方法后：
def func(self): print("hello %s"%self.name)def __init__(self,name,age): self.name = name self.age = ageFoo = type('Foo',(object,),{'func':func,'__init__':__init__})f = Foo("jack",22)f.func() 所以，类是由type类实例化产生的
那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？
答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。
#_*_coding:utf-8_*_class MyType(type): def __init__(self, what, bases=None, dict=None): print("--MyType init---") super(MyType, self).__init__(what, bases, dict) def __call__(self, *args, **kwargs): print("--MyType call---") obj = self.__new__(self, *args, **kwargs) self.__init__(obj, *args, **kwargs)class Foo(object): __metaclass__ = MyType def __init__(self, name): self.name = name print("Foo ---init__") def __new__(cls, *args, **kwargs): print("Foo --new--") return object.__new__(cls)# 第一阶段：解释器从上到下执行代码创建Foo类# 第二阶段：通过Foo类创建obj对象obj = Foo("Jack") 3. 反射
通过字符串映射或修改程序运行时的状态、属性、方法。
python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。
"""贯穿开发周期内都会用到的：hasattr,setattr,getattr,delattr的介绍传说中的反射，通过名字的字符串获取相应对象的内存地址"""import sysclass WebServer(object): def __init__(self, host, post): self.host = host self.post = post def start(self): print("Server is starting...") def stop(self): print("Server is stopping...") def restart(self): self.stop() self.start()# 定义一个类外面的方法def test_run(res): print("{} {} is running...".format(res.host, res.post))if __name__ == "__main__": server = WebServer("localhost", 33) # 判断实例中是否有命令行参数同名的方法名 if hasattr(server, sys.argv[1]): func = getattr(server, sys.argv[1]) # 获取对应类方法的内存地址 # 执行上面获取的方法，可带参数。 func() # setattr # 把一个类外面的方法绑定到一个类对象中 setattr(server, "run", test_run) server.run(server) # delattr # 删除类方法 delattr(WebServer, "stop") print("=======" * 10) server.restart() 4. 异常处理
4.1 异常基础
在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，而是现实一个提示的页面。
try: # 主代码块 passexcept KeyError as e: # 异常时，执行该块 passelse: # 主代码块执行完，执行该块 passfinally: # 无论异常与否，最终执行该块 pass
4.2 异常种类
Python中的异常种类非常多，每个异常专门用于处理某一项异常。
AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性xIOError 输入/输出异常；基本上是无法打开文件ImportError 无法引入模块或包；基本上是路径问题或名称错误IndentationError 语法错误（的子类） ；代码没有正确对齐IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]KeyError 试图访问字典里不存在的键KeyboardInterrupt Ctrl+C被按下NameError 使用一个还未被赋予对象的变量SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）TypeError 传入对象类型与要求的不符合UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它ValueError 传入一个调用者不期望的值，即使值的类型是正确的# 更多……ArithmeticErrorAssertionErrorAttributeErrorBaseExceptionBufferErrorBytesWarningDeprecationWarningEnvironmentErrorEOFErrorExceptionFloatingPointErrorFutureWarningGeneratorExitImportErrorImportWarningIndentationErrorIndexErrorIOErrorKeyboardInterruptKeyErrorLookupErrorMemoryErrorNameErrorNotImplementedErrorOSErrorOverflowErrorPendingDeprecationWarningReferenceErrorRuntimeErrorRuntimeWarningStandardErrorStopIterationSyntaxErrorSyntaxWarningSystemErrorSystemExitTabErrorTypeErrorUnboundLocalErrorUnicodeDecodeErrorUnicodeEncodeErrorUnicodeErrorUnicodeTranslateErrorUnicodeWarningUserWarningValueErrorWarningZeroDivisionError
4.2 实例
IndexError
dic = ["pig", 'dog']try: dic[10]except IndexError as e: print (e)
KeyError
dic = {'k1':'v1'}try: dic['k20']except KeyError as e: print (e) ValueError
s1 = 'hello'try: int(s1)except ValueError as e: print (e)
对于上述实例，异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。
# 未捕获到异常，程序直接报错s1 = 'hello'try: int(s1)except IndexError as e: print (e)
所以，写程序时需要考虑到try代码块中可能出现的任意异常，可以这样写：
s1 = 'hello'try: int(s1)except IndexError as e: print (e)except KeyError as e: print (e)except ValueError as e: print (e)
在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即：
s1 = 'hello'try: int(s1)except Exception as e: print (e)
接下来你可能要问了，既然有这个万能异常，其他异常是不是就可以忽略了！
答：当然不是，对于特殊处理或提醒的异常需要先定义，最后定义Exception来确保程序正常运行。
s1 = 'hello'try: int(s1)except KeyError as e: print '键错误'except IndexError as e: print '索引错误'except Exception as e: print ('错误') 4.3 主动触发异常
try: raise Exception('错误了')except Exception as e: print (e) 4.4 自定义异常
class WupeiqiException(Exception): def __init__(self, msg): self.message = msg def __str__(self): return self.messagetry: raise WupeiqiException('我的异常')except WupeiqiException as e: print (e) 4.5 断言
# assert 条件assert 1 == 1print("True")assert 1 == 2print("False") 5.动态导入模块
我们想动态导入 lib 目录的 aa.py如下：
class C(object): def __init__(self,name="David"): self.name = name
官方建议是这样导入：
import importlibaa = importlib.import_module("lib.aa")print(aa.C().name) 还有一种方法也可以导入：
lib = __import__("lib.aa")print(lib.aa.C().name)