004-python面向对象,错误,调试和测试
---恢复内容开始--- 1、面向对象面向对象编程——Object Oriented Programming,简称OOP,是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。 1.1类和实例1.1.1 类定义类是通过class关键字,class后面紧接着是类名,即Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下来的,通常,如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类 class Student(object): pass 1.1.2 实例定义好了Student类,就可以根据Student类创建出Student的实例,创建实例是通过类名+()实现的 >>> bart = Student() >>> bart <__main__.Student object at 0x10a67a590> >>> Student <class ‘__main__.Student‘> 1.1.3 __init__方法 定义一个特殊的__init__方法,在创建实例的时候,就把name,score等属性绑上去 class Student(object): def __init__(self,name,score): self.name = name self.score = score
有了__init__方法,在创建实例的时候,就不能传入空的参数了,必须传入与__init__方法匹配的参数,但self不需要传,Python解释器自己会把实例变量传进去 >>> bart = Student(‘Bart Simpson‘,59) >>> bart.name ‘Bart Simpson‘ >>> bart.score 59 1.2 访问限制如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,在Python中,实例的变量名如果以__开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问 class Student(object): def __init__(self,score): self.__name = name self.__score = score def print_score(self): print(‘%s: %s‘ % (self.__name,self.__score)) 如果外部代码要获取name和score,可以给Student类增加get_name和get_score这样的方法 class Student(object): ... def get_name(self): return self.__name def get_score(self): return self.__score 如果要允许外部代码修改score,可以再给Student类增加set_score方法 class Student(object): ... def set_score(self,score): self.__score = score 1.3 继承和多态 在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Base class、Super class) class Animal(object): def run(self): print(‘Animal is running...‘) 当我们需要编写Dog和Cat类时,就可以直接从Animal类继承 class Dog(Animal): pass class Cat(Animal): pass 对于Dog来说,Animal就是它的父类,对于Animal来说,Dog就是它的子类。Cat和Dog类似 class Animal(object): def run(self): print(‘Animal is running...‘) class Dog(Animal): pass >>> dog = Dog() 也可以对子类增加一些方法,比如Dog类 class Dog(Animal): def run(self): print(‘Dog is running...‘) def eat(self): print(‘Eating meat...‘) 继承的第二个好处需要我们对代码做一点改进。无论是Dog还是Cat,它们run()的时候,显示的都是Animal is running...,符合逻辑的做法是分别显示Dog is running...和Cat is running...,因此,对Dog和Cat类改进如下 class Dog(Animal): def run(self): print(‘Dog is running...‘) class Cat(Animal): def run(self): print(‘Cat is running...‘) 当子类和父类都存在相同的run()方法时,我们说,子类的run()覆盖了父类的run(),在代码运行的时候,总是会调用子类的run()。这样,我们就获得了继承的另一个好处:多态 def run_twice(animal): animal.run() animal.run() class Tortoise(Animal): def run(self): print(‘Tortoise is running slowly...‘)
>>> run_twice(Tortoise()) Tortoise is running slowly... Tortoise is running slowly...
多态的好处就是,当我们需要传入Dog、Cat、Tortoise……时,我们只需要接收Animal类型就可以了,因为Dog、Cat、Tortoise……都是Animal类型,然后,按照Animal类型进行操作即可。由于Animal类型有run()方法,因此,传入的任意类型,只要是Animal类或者子类,就会自动调用实际类型的run()方法,这就是多态的意思: 1.4 获取对象信息1.4.1使用type()我们来判断对象类型,使用type()函数,基本类型都可以用type()判断 >>> type(123) <class ‘int‘> >>> type(‘str‘) <class ‘str‘> >>> type(None) <type(None) ‘NoneType‘> 如果一个变量指向函数或者类,也可以用type()判断 >>> type(abs) <class ‘builtin_function_or_method‘> >>> type(a) <class ‘__main__.Animal‘> type()函数返回对应的Class类型 >>> import types >>> def fn(): ... pass ... >>> type(fn)==types.FunctionType True >>> type(abs)==types.BuiltinFunctionType True >>> type(lambda x: x)==types.LambdaType True >>> type((x for x in range(10)))==types.GeneratorType True 1.4.2 使用isinstance()先创建3种类型的对象 >>> a = Animal() >>> d = Dog() >>> h = Husky() h虽然自身是Husky类型,但由于Husky是从Dog继承下来的,所以,h也还是Dog类型。换句话说,isinstance()判断的是一个对象是否是该类型本身,或者位于该类型的父继承链上 >>> isinstance(h,Husky) True >>> isinstance(h,Dog) True >>> isinstance(h,Animal) True 能用type()判断的基本类型也可以用isinstance()判断 >>> isinstance(‘a‘,str) True >>> isinstance(123,int) True >>> isinstance(b‘a‘,bytes) True 可以判断一个变量是否是某些类型中的一种,比如下面的代码就可以判断是否是list或者tuple >>> isinstance([1,2,3],(list,tuple)) True >>> isinstance((1,3),tuple)) True 1.4.3 使用dir() 如果要获得一个对象的所有属性和方法,可以使用dir()函数,它返回一个包含字符串的list >>> dir(‘ABC‘) [‘__add__‘,‘__class__‘,...,‘__subclasshook__‘,‘capitalize‘,‘casefold‘,‘zfill‘] 类似__xxx__的属性和方法在Python中都是有特殊用途的,比如__len__方法返回长度,下面的代码是等价的 >>> len(‘ABC‘) 3 >>> ‘ABC‘.__len__() 3 我们自己写的类,如果也想用len(myObj)的话,就自己写一个__len__()方法 >>> class MyDog(object): ... def __len__(self): ... return 100 ... >>> dog = MyDog() >>> len(dog) 100 仅仅把属性和方法列出来是不够的,配合getattr()、setattr()以及hasattr(),我们可以直接操作一个对象的状态 >>> class MyObject(object): ... def __init__(self): ... self.x = 9 ... def power(self): ... return self.x * self.x ... >>> obj = MyObject() >>> hasattr(obj,‘x‘) # 有属性‘x‘吗? True >>> obj.x 9 >>> hasattr(obj,‘y‘) # 有属性‘y‘吗? False >>> setattr(obj,‘y‘,19) # 设置一个属性‘y‘ >>> hasattr(obj,‘y‘) # 有属性‘y‘吗? True >>> getattr(obj,‘y‘) # 获取属性‘y‘ 19 >>> obj.y # 获取属性‘y‘ 19 如果试图获取不存在的属性,会抛出AttributeError的错误,可以传入一个default参数,如果属性不存在,就返回默认值 >>> getattr(obj,‘z‘) # 获取属性‘z‘ Traceback (most recent call last): File "<stdin>",line 1,in <module> AttributeError: ‘MyObject‘ object has no attribute ‘z‘ >>> getattr(obj,‘z‘,404) # 获取属性‘z‘,如果不存在,返回默认值404 404 也可以获得对象的方法 >>> hasattr(obj,‘power‘) # 有属性‘power‘吗? True >>> getattr(obj,‘power‘) # 获取属性‘power‘ <bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>> >>> fn = getattr(obj,‘power‘) # 获取属性‘power‘并赋值到变量fn >>> fn # fn指向obj.power <bound method MyObject.power of <__main__.MyObject object at 0x10077a6a0>> >>> fn() # 调用fn()与调用obj.power()是一样的 81 实例属性和类属性 >>> class Student(object): ... name = ‘Student‘ ... >>> s = Student() # 创建实例s >>> print(s.name) # 打印name属性,因为实例并没有name属性,所以会继续查找class的name属性 Student >>> print(Student.name) # 打印类的name属性 Student >>> s.name = ‘Michael‘ # 给实例绑定name属性 >>> print(s.name) # 由于实例属性优先级比类属性高,因此,它会屏蔽掉类的name属性 Michael >>> print(Student.name) # 但是类属性并未消失,用Student.name仍然可以访问 Student >>> del s.name # 如果删除实例的name属性 >>> print(s.name) # 再次调用s.name,由于实例的name属性没有找到,类的name属性就显示出来了 Student 从上面的例子可以看出,在编写程序的时候,千万不要对实例属性和类属性使用相同的名字,因为相同名称的实例属性将屏蔽掉类属性,但是当你删除实例属性后,再使用相同的名称,访问到的将是类属性 2、面向对象高级编程2.1 使用__slots__如果我们想要限制实例的属性,比如,只允许对Student实例添加name和age属性,Python允许在定义class的时候,定义一个特殊的__slots__变量,来限制该class实例能添加的属性 class Student(object): __slots__ = (‘name‘,‘age‘) # 用tuple定义允许绑定的属性名称 >>> s = Student() # 创建新的实例 >>> s.name = ‘Michael‘ # 绑定属性‘name‘ >>> s.age = 25 # 绑定属性‘age‘ >>> s.score = 99 # 绑定属性‘score‘ Traceback (most recent call last): File "<stdin>",in <module> AttributeError: ‘Student‘ object has no attribute ‘score‘ 使用__slots__要注意,__slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的 >>> class GraduateStudent(Student): ... pass ... >>> g = GraduateStudent() >>> g.score = 9999 除非在子类中也定义__slots__,这样,子类实例允许定义的属性就是自身的__slots__加上父类的__slots__ 2.2 使用@propertyPython内置的@property装饰器就是负责把一个方法变成属性调用的 class Student(object): @property def score(self): return self._score @score.setter def score(self,value): if not isinstance(value,int): raise ValueError(‘score must be an integer!‘) if value < 0 or value > 100: raise ValueError(‘score must between 0 ~ 100!‘) self._score = value
可以定义只读属性,只定义getter方法,不定义setter方法就是一个只读属性 class Student(object): @property def birth(self): return self._birth @birth.setter def birth(self,value): self._birth = value @property def age(self): return 2015 - self._birth
上面的birth是可读写属性,而age就是一个只读属性,因为age可以根据birth和当前时间计算出来 2.3.1 多重继承 假设我们要实现以下4种动物: class Animal(object): pass # 大类: class Mammal(Animal): pass class Bird(Animal): pass # 各种动物: class Dog(Mammal): pass class Bat(Mammal): pass class Parrot(Bird): pass class Ostrich(Bird): pass
我们要给动物再加上Runnable和Flyable的功能,只需要先定义好Runnable和Flyable的类 class Runnable(object): def run(self): print(‘Running...‘) class Flyable(object): def fly(self): print(‘Flying...‘)
对于需要Runnable功能的动物,就多继承一个Runnable,例如Dog class Dog(Mammal,Runnable): pass
对于需要Flyable功能的动物,就多继承一个Flyable,例如Bat: class Bat(Mammal,Flyable): pass
2.3.2 MixIn 在设计类的继承关系时,通常,主线都是单一继承下来的,例如,Ostrich继承自Bird。但是,如果需要“混入”额外的功能,通过多重继承就可以实现,比如,让Ostrich除了继承自Bird外,再同时继承Runnable。这种设计通常称之为MixIn class Dog(Mammal,RunnableMixIn,CarnivorousMixIn): pass
MixIn的目的就是给一个类增加多个功能,这样,在设计类的时候,我们优先考虑通过多重继承来组合多个MixIn的功能,而不是设计多层次的复杂的继承关系 2.4 定制类2.4.1__str__定义好__str__()方法,返回一个好看的字符串 >>> class Student(object): ... def __init__(self,name): ... self.name = name ... def __str__(self): ... return ‘Student object (name: %s)‘ % self.name ... >>> print(Student(‘Michael‘)) Student object (name: Michael) 2.4.2 __iter__如果一个类想被用于for ... in循环,类似list或tuple那样,就必须实现一个__iter__()方法,该方法返回一个迭代对象,然后,Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值,直到遇到StopIteration错误时退出循环 我们以斐波那契数列为例,写一个Fib类,可以作用于for循环 class Fib(object): def __init__(self): self.a,self.b = 0,1 # 初始化两个计数器a,b def __iter__(self): return self # 实例本身就是迭代对象,故返回自己 def __next__(self): self.a,self.b = self.b,self.a + self.b # 计算下一个值 if self.a > 100000: # 退出循环的条件 raise StopIteration() return self.a # 返回下一个值 ? 现在,试试把Fib实例作用于for循环: >>> for n in Fib(): ... print(n) ... 1 1 2 3 5 ... 46368 75025 2.4.3 __getitem__Fib实例虽然能作用于for循环,看起来和list有点像,但是,把它当成list来使用还是不行,要表现得像list那样按照下标取出元素,需要实现__getitem__()方法 class Fib(object): def __getitem__(self,n): a,b = 1,1 for x in range(n): a,b = b,a + b return a 现在,就可以按下标访问数列的任意一项了 >>> f = Fib() >>> f[0] 1 >>> f[1] 1 >>> f[2] 2 >>> f[3] 3 >>> f[10] 89 >>> f[100] 573147844013817084101 2.4.4 __getattr__Python还有另一个机制,那就是写一个__getattr__()方法,动态返回一个属性,当调用不存在的属性时,比如score,Python解释器会试图调用__getattr__(self,‘score‘)来尝试获得属性,这样,我们就有机会返回score的值 class Student(object): def __init__(self): self.name = ‘Michael‘ def __getattr__(self,attr): if attr==‘score‘: return 99 >>> s = Student() >>> s.name ‘Michael‘ >>> s.score 99
2.4.5 __call__在Python中,任何类,只需要定义一个__call__()方法,就可以直接对实例进行调用 class Student(object): def __init__(self,name): self.name = name def __call__(self): print(‘My name is %s.‘ % self.name) ? 调用方式如下: >>> s = Student(‘Michael‘) >>> s() # self参数不要传入 My name is Michael. 3、错误、调试和测试3.1 错误处理3.1.1trytry...except...finally...的错误处理机制 try: print(‘try...‘) r = 10 / int(‘a‘) print(‘result:‘,r) except ValueError as e: print(‘ValueError:‘,e) except ZeroDivisionError as e: print(‘ZeroDivisionError:‘,e) finally: print(‘finally...‘) print(‘END‘) 错误应该有很多种类,如果发生了不同类型的错误,可以有多个except来捕获不同类型的错误 try: print(‘try...‘) r = 10 / int(‘2‘) print(‘result:‘,e) else: print(‘no error!‘) finally: print(‘finally...‘) print(‘END‘) 使用try...except捕获错误,可以跨越多层调用,比如函数main()调用foo(),foo()调用bar(),结果bar()出错了,这时,只要main()捕获到了,就可以处理: def foo(s): return 10 / int(s) def bar(s): return foo(s) * 2 def main(): try: bar(‘0‘) except Exception as e: print(‘Error:‘,e) finally: print(‘finally...‘) 3.1.2 记录错误Python内置的logging模块可以非常容易地记录错误信息,同样是出错,但程序打印完错误信息后会继续执行,并正常退出 import logging def foo(s): return 10 / int(s) def bar(s): return foo(s) * 2 def main(): try: bar(‘0‘) except Exception as e: logging.exception(e) main() print(‘END‘) ? 同样是出错,但程序打印完错误信息后会继续执行,并正常退出 ERROR:root:division by zero Traceback (most recent call last): File "err_logging.py",line 13,in main bar(‘0‘) File "err_logging.py",line 9,in bar return foo(s) * 2 File "err_logging.py",line 6,in foo return 10 / int(s) ZeroDivisionError: division by zero END 通过配置,logging还可以把错误记录到日志文件里,方便事后排查 3.1.3 抛出错误如果要抛出错误,首先根据需要,可以定义一个错误的class,选择好继承关系,然后,用raise语句抛出一个错误的实例 class FooError(ValueError): pass def foo(s): n = int(s) if n==0: raise FooError(‘invalid value: %s‘ % s) return 10 / n foo(‘0‘) ? 执行,可以最后跟踪到我们自己定义的错误: Traceback (most recent call last): File "err_throw.py",line 11,in <module> foo(‘0‘) File "err_throw.py",line 8,in foo raise FooError(‘invalid value: %s‘ % s) __main__.FooError: invalid value: 0 3.2 调试3.2.1 print()用print()把可能有问题的变量打印出来看看 def foo(s): n = int(s) print(‘>>> n = %d‘ % n) return 10 / n def main(): foo(‘0‘) main() 用print()最大的坏处是将来还得删掉它,想想程序里到处都是print(),运行结果也会包含很多垃圾信息 3.2.2 断言凡是用print()来辅助查看的地方,都可以用断言(assert)来替代 def foo(s): n = int(s) assert n != 0,‘n is zero!‘ return 10 / n def main(): foo(‘0‘) 如果断言失败,assert语句本身就会抛出AssertionError Traceback (most recent call last): ... AssertionError: n is zero! Python解释器时可以用-O(断言的开关“-O”是英文大写字母O)参数来关闭assert,关闭后,可以把所有的assert语句当成pass来看 $ python -O err.py
Traceback (most recent call last):
...
ZeroDivisionError: division by zero
3.2.3? logging把print()替换为logging,和assert比,logging不会抛出错误,而且可以输出到文件 import logging s = ‘0‘ n = int(s) logging.info(‘n = %d‘ % n) print(10 / n) INFO:root:n = 0 Traceback (most recent call last): File "err.py",in <module> print(10 / n) ZeroDivisionError: division by zero 3.3 单元测试 单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作 import unittest from mydict import Dict class TestDict(unittest.TestCase): def test_init(self): d = Dict(a=1,b=‘test‘) self.assertEqual(d.a,1) self.assertEqual(d.b,‘test‘) self.assertTrue(isinstance(d,dict)) def test_key(self): d = Dict() d[‘key‘] = ‘value‘ self.assertEqual(d.key,‘value‘) def test_attr(self): d = Dict() d.key = ‘value‘ self.assertTrue(‘key‘ in d) self.assertEqual(d[‘key‘],‘value‘) def test_keyerror(self): d = Dict() with self.assertRaises(KeyError): value = d[‘empty‘] def test_attrerror(self): d = Dict() with self.assertRaises(AttributeError): value = d.empty 一旦编写好单元测试,我们就可以运行单元测试。最简单的运行方式是在mydict_test.py的最后加上两行代码: if __name__ == ‘__main__‘: unittest.main() 以test开头的方法就是测试方法,不以test开头的方法不被认为是测试方法,测试的时候不会被执行 class TestDict(unittest.TestCase): def setUp(self): print(‘setUp...‘) def tearDown(self): print(‘tearDown...‘) ---恢复内容结束--- (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |