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

时间：2019-10-06 00:42:29 阅读：69 评论：0 收藏：0 [点我收藏+]

标签：func 自带 default michael student 装饰器检验应该遇到

---恢复内容开始---

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.1str

定义好__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...‘)

---恢复内容结束---

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

标签：func 自带 default michael student 装饰器检验应该遇到

原文地址：https://www.cnblogs.com/kkkhycz/p/11626172.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

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

1、面向对象

1.1类和实例

1.1.1 类

1.1.2 实例

1.1.3 __init__方法

1.2 访问限制

1.3 继承和多态

1.4 获取对象信息

1.4.1使用type()

1.4.2 使用isinstance()

1.4.3 使用dir()

2、面向对象高级编程

2.1 使用__slots__

2.2 使用@property

2.3.1 多重继承

2.3.2 MixIn

2.4 定制类

2.4.1__str__

2.4.2 __iter__

2.4.3 __getitem__

2.4.4 __getattr__

2.4.5 __call__

3、错误、调试和测试

3.1 错误处理

3.1.1try

3.1.2 记录错误

3.1.3 抛出错误

3.2 调试

3.2.1 print()

3.2.2 断言

3.2.3 logging

3.3 单元测试

1.1.3 init方法

2.1 使用slots

2.4.1str

2.4.2 iter

2.4.3 getitem

2.4.4 getattr

2.4.5 call