004python面向对象，错误，调试和测试 - 润新知

004python面向对象，错误，调试和测试
---恢复内容开始---

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等属性绑上去
注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身
```
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, name, 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）
编写了一个名为Animal的class，有一个run()方法可以直接打印
```
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.run()
Animal is running...
```
也可以对子类增加一些方法，比如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()。这样，我们就获得了继承的另一个好处：多态
1.要理解多态的好处，我们再编写一个函数，这个函数接受一个Animal类型的变量
2.再定义一个Tortoise类型，也从Animal派生
3.当我们调用run_twice()时，传入Tortoise的实例
```
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()方法，这就是多态的意思：
对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：
对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

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类型
如果要判断一个对象是否是函数,可以使用types模块中定义的常量
```
>>> 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, 2, 3), (list, tuple))
True
```
1.4.3 使用dir()

如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list
比如，获得一个str对象的所有属性和方法：
```
>>> 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>", line 1, 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 使用@property

Python内置的@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种动物：
Dog - 狗狗；
Bat - 蝙蝠；
Parrot - 鹦鹉；
Ostrich - 鸵鸟。
1.按照哺乳动物和鸟类归类
2.按照“能跑”和“能飞”来归类
如果要把上面的两种分类都包含进来，我们就得设计更多的层次：
哺乳类：能跑的哺乳类，能飞的哺乳类；
鸟类：能跑的鸟类，能飞的鸟类
正确的做法是采用多重继承。首先，主要的类层次仍按照哺乳类和鸟类设计
```
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
为了更好地看出继承关系，我们把Runnable和Flyable改为RunnableMixIn和FlyableMixIn。类似的，你还可以定义出肉食动物CarnivorousMixIn和植食动物HerbivoresMixIn，让某个动物同时拥有好几个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.1try

try...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:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', 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", line 8, in <module>
    print(10 / n)
ZeroDivisionError: division by zero
```
3.3 单元测试

单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作
为了编写单元测试，我们需要引入Python自带的unittest模块，编写mydict_test.py如下
```
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开头的方法不被认为是测试方法，测试的时候不会被执行
可以在单元测试中编写两个特殊的setUp()和tearDown()方法。这两个方法会分别在每调用一个测试方法的前后分别被执行
```
class TestDict(unittest.TestCase):

    def setUp(self):
        print('setUp...')

    def tearDown(self):
        print('tearDown...')
```
---恢复内容结束---
相关阅读:
OLEDB SqlHelper
.net中数据库事务机制
 C#中的@符号
 C#实现WEB服务器
 Snake.Net
C#在客戶端和服務端操作Excel文件
 数据库连接字符串大全
 获取cpu序列号,硬盘ID,网卡MAC地址
 Asp.net动态生成html页面(、
document 文挡对象详解
原文地址：https://www.cnblogs.com/kkkhycz/p/11626172.html

Copyright © 2020-2023 润新知