Python学习-08-面向对象编程进阶和异常处理
一、类的进阶
1）静态方法：
跟类没有关系了。是一个单纯的函数。调用的时候，必须用类名来调用。（台湾与大陆的关系。）相当于类下面的一个函数，跟类没有关系，不能直接调用类的参数。
静态方法：只是名义上归类管理，实际上静态方法访问不了类或实例中的任何属性。
通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法，什么是静态方法呢？其实不难理解，普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法
1 class Dog(object): 2 3 def __init__(self,name): 4 5 self.name = name 6 7 @staticmethod #把eat方法变为静态方法 8 9 def eat(self): 10 11 print("%s is eating" % self.name) 12 13 d = Dog("张三") 14 15 d.eat()
上面的调用会出以下错误，说是eat需要一个self参数，但调用时却没有传递，没错，当eat变成静态方法后，再通过实例调用时就不会自动把实例本身当作一个参数传给self了。
TypeError: eat() missing 1 required positional argument: 'self'
想让上面的代码可以正常工作有两种办法
1. 调用时主动传递实例本身给eat方法，即d.eat(d)
2. 在eat方法中去掉self参数，但这也意味着，在eat中不能通过self.调用实例中的其它变量了
1 class Dog(object): 2 3 def __init__(self,name): 4 5 self.name = name 6 7 @staticmethod 8 9 def eat(): 10 11 print(" is eating") 12 13 d = Dog("张三") 14 15 d.eat()
2）类方法：只能访问类变量，不是访问实例变量。用途无。@classmethod
1 class Dog(object): 2 def __init__(self,name): 3 self.name = name 4 5 @classmethod 6 def eat(self): 7 print("%s is eating" % self.name) 8 9 10 11 d = Dog("张三") 12 d.eat()
执行报错如下，说Dog没有name属性，因为name是个实例变量，类方法是不能访问实例变量的
AttributeError: type object 'Dog' has no attribute 'name'
1 class Dog(object): 2 name = "我是类变量" 3 def __init__(self,name): 4 self.name = name 5 6 @classmethod 7 def eat(self): 8 print("%s is eating" % self.name) 9 10 d = Dog("张三") 11 d.eat() 12 13 #执行结果 14 15 我是类变量 is eating
3）属性方法：@property。把一个方法变成静态属性。就是不能传参数。（重点）
举例：一个方法变成属性，如何修改它，如何删除它
1 class Dog(object): 2 '''这个类是描述狗这个对象的''' 3 def __init__(self,name): 4 self.name = name 5 self.__food = None 6 @property #attribute属性方法，把方法变成了属性，无法调用参数 7 def eat(self): 8 print("%s is eating %s" %(self.name,self.__food)) 9 @eat.setter#修改属性方法，通过self.__food，修改属性方法 10 def eat(self,food): 11 print("set to food:",food) 12 self.__food = food 13 @eat.deleter#输出属性方法 14 def eat(self): 15 del self.__food 16 print("删完了") 17 def talk(self): 18 print("%s is talking"% self.name) 19 d = Dog("张三") 20 d.eat 21 d.eat=("包子") 22 d.eat 23 del d.eat
属性方法的应用：
既然想要静态变量，那直接定义成一个静态变量不就得了么？well, 以后你会需到很多场景是不能简单通过定义静态属性来实现的，比如，你想知道一个航班当前的状态，是到达了、延迟了、取消了、还是已经飞走了(第三方公司)，想知道这种状态你必须经历以下几步:
1. 连接航空公司API查询
2. 对查询结果进行解析
3. 返回结果给你的用户
因此这个status属性的值是一系列动作后才得到的结果，所以你每次调用时，其实它都要经过一系列的动作才返回你结果，但这些动作过程不需要用户关心，用户只需要调用这个属性就可以，明白了么？
1 class Flight(object): 2 3 def __init__(self,name): 4 5 self.flight_name = name 6 7 def checking_status(self): 8 9 print("checking flight %s status " % self.flight_name) 10 11 return 1 12 13 @property 14 15 def flight_status(self): 16 17 status = self.checking_status() 18 19 if status == 0 : 20 21 print("flight got canceled...") 22 23 elif status == 1 : 24 25 print("flight is arrived...") 26 27 elif status == 2: 28 29 print("flight has departured already...") 30 31 else: 32 33 print("cannot confirm the flight status...,please check later") 34 35 f = Flight("CA980") 36 37 f.flight_status
cool , 那现在我只能查询航班状态，既然这个flight_status已经是个属性了，那我能否给它赋值呢？试试吧
1 f = Flight("CA980") 2 f.flight_status 3 f.flight_status = 2
输出， 说不能更改这个属性，我擦。。。。，怎么办怎么办。。。
checking flight CA980 status flight is arrived... f.flight_status = 2 AttributeError: can't set attribute 当然可以改，不过需要通过@proert
y.setter装饰器再装饰一下，此时 你需要写一个新方法， 对这个flight_status进行更改。
1 class Flight(object): 2 def __init__(self,name): 3 self.flight_name = name 4 def checking_status(self): 5 print("checking flight %s status " % self.flight_name) 6 return 1 7 @property 8 def flight_status(self): 9 status = self.checking_status() 10 if status == 0 : 11 print("flight got canceled...") 12 elif status == 1 : 13 print("flight is arrived...") 14 elif status == 2: 15 print("flight has departured already...") 16 else: 17 print("cannot confirm the flight status...,please check later") 18 19 @flight_status.setter #修改 20 def flight_status(self,status): 21 status_dic = { 22 : "canceled", 23 :"arrived", 24 : "departured" 25 } 26 print("\033[31;1mHas changed the flight status to \033[0m",status_dic.get(status) ) 27 @flight_status.deleter #删除 28 def flight_status(self): 29 print("status got removed...") 30 f = Flight("CA980") 31 f.flight_status 32 f.flight_status = 2 #触发@flight_status.setter 33 del f.flight_status #触发@flight_status.deleter
注意以上代码里还写了一个@flight_status.deleter, 是允许可以将这个属性删除。
4）类的特殊成员方法：
1. __doc__ 表示类的描述信息
1 class Foo: 2 3 """ 描述类信息，这是用于看片的神奇 """ 4 5 def func(self): 6 7 pass 8 9 print Foo.__doc__#输出：类的描述信息
2. __init__ 构造方法，通过类创建对象时，自动触发执行。
3. __del__ 析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的
4. __call__ 对象后面加括号，触发执行。
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
5. __dict__ 查看类或对象中的所有成员
6.__str__ 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
1 class Dog(object): 2 '''这个类是描述狗这个对象的''' 3 def __init__(self,name): 4 self.name = name 5 def eat(self,food): 6 print("%s is eating %s" %(self.name,food)) 7 def talk(self): 8 print("%s is talking"% self.name) 9 def __call__(self, *args, **kwargs): 10 print("running call",args,kwargs) 11 def __str__(self):#打印对象的时候，输入该方法的返回值。默认是内存地址 12 return "<obj:%s>" %self.name 13 14 #print(Dog.__doc__) #打印描述信息 15 #测试__call__方法 16 d=Dog("张三") 17 #d(1,2,3,name=123) 18 #上面的可以换为： 19 #Dog("张三")() 20 #print(Dog.__dict__) #打印类里的所有属性，不包括实例属性 21 #print(d.__dict__) #打印所有实例属性，不包括类属性
7. __getitem__、__setitem__、__delitem__
用于索引操作，如字典。以上分别表示获取、设置、删除数据
1 class Foo(object): 2 3 def __getitem__(self, key): 4 5 print('__getitem__',key) 6 7 def __setitem__(self, key, value): 8 9 print('__setitem__',key,value) 10 11 def __delitem__(self, key): 12 13 print('__delitem__',key) 14 15 obj = Foo() 16 17 result = obj['k1'] # 自动触发执行 __getitem__ 18 19 obj['k2'] = 'alex' # 自动触发执行 __setitem__ 20 21 del obj['k1']
8.__new__ 、 __metaclass__ （底层框架要用）
1 class Foo(object): 2 3 def __init__(self, name): 4 5 self.name = name 6 7 f = Foo("alex") 8 9 print(type(f)) 10 11 print(type(Foo))
上述代码中，f是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。
如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。
print type(f) # 输出：<class '__main__.Foo'> 表示，obj 对象由Foo类创建
print type(Foo) # 输出：<type 'type'> 表示，Foo类对象由 type 类创建
所以，f对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。
那么，创建类就可以有两种方式：
a). 普通方式
1 class Foo(object): 2 3 def func(self): 4 5 print 'hello alex'
b). 特殊方式
1 def func(self): 2 3 print 'hello wupeiqi' 4 5 Foo = type('Foo',(object,), {'func': func}) 6 7 #type第一个参数：类名 8 9 #type第二个参数：当前类的基类 10 11 #type第三个参数：类的成员
a) 和b) 两个都是一样的，都是实现创建类的。
举例代码
1 def func(self): 2 3 print("hello %s"%self.name) 4 5 def __init__(self,name,age): 6 7 self.name = name 8 9 self.age = age 10 11 Foo = type('Foo',(object,),{'func':func,'__init__':__init__}) 12 13 f = Foo("jack",22) 14 15 f.func()
So ，记住，类是由 type 类实例化产生
那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？
答：类中有一个属性 __metaclass__，其用来表示该类由谁来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看类创建的过程。
参考代码；
1 class MyType(type): 2 3 def __init__(self, what, bases=None, dict=None): 4 5 print("--MyType init---") 6 7 super(MyType, self).__init__(what, bases, dict) 8 9 def __call__(self, *args, **kwargs): 10 11 print("--MyType call---") 12 13 obj = self.__new__(self, *args, **kwargs) 14 15 obj.data = {"name":111} 16 17 self.__init__(obj, *args, **kwargs) 18 19 class Foo(object): 20 21 __metaclass__ = MyType 22 23 def __init__(self, name): 24 25 self.name = name 26 27 print("Foo ---init__") 28 29 def __new__(cls, *args, **kwargs): 30 31 print("Foo --new--") 32 33 #print(object.__new__(cls)) 34 35 return object.__new__(cls) #继承父亲的__new__方法 36 37 # 第一阶段：解释器从上到下执行代码创建Foo类 38 39 # 第二阶段：通过Foo类创建obj对象 40 41 obj = Foo("Alex") 42 43 print(obj.name)
new是用来创建实例的。
类的生成 调用 顺序依次是 __new__ --> __init__ --> __call__
metaclass 详解文章：http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python 得票最高那个答案写的非常好
9、反射：通过字符串映射或修改程序运行时的状态、属性、方法, 有以下4个方法：
hasattr():第一个是实例化名字，第二个是字符串形式 反射 判断一个对象里是否有字符串对应的方法
getattr():如果是方法，获取并调用，根据字符串获取obj对象里的对应的方法的内存地址。
如果是动态属性，则直接返回属性的值
setattr():通过字符串设置属性。setattr(obj,’y’,’z’) 等价于x.y=z
delattr():删除属性或者方法
1 def bulk(self): 2 print("%s is yelling...." %self.name) 3 4 class Dog(object): 5 def __init__(self,name): 6 self.name = name 7 8 def eat(self,food): 9 print("%s is eating..."%self.name,food) 10 11 d = Dog("李四") 12 choice = input(">>:").strip() 13 14 if hasattr(d,choice):#第一个是实例化名字，第二个是字符串形式 反射 判断一个对象里是否有字符串对应的方法 15 16 getattr(d,choice)#如果是方法，获取并调用，根据字符串获取obj对象里的对应的方法的内存地址。 17 #如果是动态属性，则直接返回属性的值 18 Delattr(d,choice)#删除属性或者方法 19 20 else: 21 setattr(d,choice,bulk) #d.talk = bulk 通过字符串设置属性。 22 #setattr(obj,’y’,’z’) 等价于x.y=z。上面的choice是talk，d.talk=bulk 23 #d.talk(d) 24 25 func = getattr(d, choice) 26 27 func(d)
再次举例：
1 class Foo(object): 2 3 def __init__(self): 4 5 self.name = 'wupeiqi' 6 7 def func(self): 8 9 return 'func' 10 11 obj = Foo() 12 13 14 15 # #### 检查是否含有成员 #### 16 17 hasattr(obj, 'name') 18 19 hasattr(obj, 'func') 20 21 22 23 # #### 获取成员 #### 24 25 getattr(obj, 'name') 26 27 getattr(obj, 'func') 28 29 30 31 # #### 设置成员 #### 32 33 setattr(obj, 'age', 18) 34 35 setattr(obj, 'show', lambda num: num + 1) 36 37 38 39 # #### 删除成员 #### 40 41 delattr(obj, 'name') 42 43 delattr(obj, 'func')
异常处理：
通过提前预判错误，打印提示
1 data={} 2 3 try: 4 5 data['name'] 6 7 except KeyError as e: 8 9 print("没有这个Key",e)
写程序时需要考虑到try代码块中可能出现的任意异常，可以这样写：多个预判错误：
在Python执行时，当遇到第一个错误就会停止。
1 data={} 2 3 name=[] 4 5 try: 6 7 name[2] 8 9 data['name'] 10 11 except KeyError as e: 12 13 print("没有这个Key",e) 14 15 except IndexError as e: 16 17 print("列表操作错误",e)
还可以这样写：应用于无论什么错误类型，处理结果一样的情况。
1 data={} 2 3 name=[] 4 5 try: 6 7 name[2] 8 9 data['name'] 10 11 except (KeyError,IndexError) as e: 12 13 print("没有这个Key",e)
万能异常 在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即（万能错误类型）
1 data={} 2 3 name=[] 4 5 try: 6 7 name[2] 8 9 data['name'] 10 11 except Exception as e: # Exception 任意错误，一般不用不容易调试判断 12 13 print("没有这个Key",e)
windows中的未知错误？怎么做到的呢？我们用Python试一试？
1 data={} 2 3 name=[] 4 5 try: 6 7 open("a.txt") 8 9 except KeyError as e: 10 11 print("没有这个Key",e) 12 13 except IndexError as e: 14 15 print("列表操作错误",e) 16 17 except Exception as e: 18 19 print("未知错误",e)
else 和 finally 用法：
1 data={} 2 3 name=[] 4 5 try: 6 7 #open("a.txt") 8 9 a=1 10 11 except KeyError as e: 12 13 print("没有这个Key",e) 14 15 except IndexError as e: 16 17 print("列表操作错误",e) 18 19 except Exception as e: 20 21 print("未知错误",e) 22 23 else: 24 25 print("一切正常") 26 27 finally: 28 29 print("无论有没有错，都会执行")
注意：
1）Python3中的as在Python2.7中用的是‘，’。
2）一些抓不到的错误，比如说缩进、语法导致的错误。IndentationError: unexpected indent
常用的错误类型：
1 AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x 2 IOError 输入/输出异常；基本上是无法打开文件 3 ImportError 无法引入模块或包；基本上是路径问题或名称错误 4 IndentationError 语法错误（的子类） ；代码没有正确对齐 5 IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5] 6 KeyError 试图访问字典里不存在的键 7 KeyboardInterrupt Ctrl+C被按下 8 NameError 使用一个还未被赋予对象的变量 9 SyntaxError Python代码非法，代码不能编译 10 TypeError 传入对象类型与要求的不符合 11 UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它 12 ValueError 传入一个调用者不期望的值，即使值的类型是正确的
更多的错误
1 ArithmeticError 2 3 AssertionError 4 5 AttributeError 6 7 BaseException 8 9 BufferError 10 11 BytesWarning 12 13 DeprecationWarning 14 15 EnvironmentError 16 17 EOFError 18 19 Exception 20 21 FloatingPointError 22 23 FutureWarning 24 25 GeneratorExit 26 27 ImportError 28 29 ImportWarning 30 31 IndentationError 32 33 IndexError 34 35 IOError 36 37 KeyboardInterrupt 38 39 KeyError 40 41 LookupError 42 43 MemoryError 44 45 NameError 46 47 NotImplementedError 48 49 OSError 50 51 OverflowError 52 53 PendingDeprecationWarning 54 55 ReferenceError 56 57 RuntimeError 58 59 RuntimeWarning 60 61 StandardError 62 63 StopIteration 64 65 SyntaxError 66 67 SyntaxWarning 68 69 SystemError 70 71 SystemExit 72 73 TabError 74 75 TypeError 76 77 UnboundLocalError 78 79 UnicodeDecodeError 80 81 UnicodeEncodeError 82 83 UnicodeError 84 85 UnicodeTranslateError 86 87 UnicodeWarning 88 89 UserWarning 90 91 ValueError 92 93 Warning 94 95 ZeroDivisionError
主动触发异常：
1 try: 2 3 raise Exception('错误了。。。') 4 5 except Exception,e: 6 7 print e
自定义异常：注意不要覆盖已经存在的异常。
1 class AlexError(Exception): 2 3 def __init__(self, msg): 4 5 self.message = msg 6 7 try: 8 9 raise AlexError('数据库连不上') 10 11 except AlexError as e: 12 13 print(e)
参考文献：
http://www.cnblogs.com/alex3714/articles/5213184.html
http://www.cnblogs.com/wupeiqi/articles/5017742.html
