---恢复内容开始---
1、面向对象
面向对象编程——Object Oriented Programming,简称OOP,是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。
数据封装、继承和多态是面向对象的三大特点
1.1类和实例
1.1.1 类
定义类是通过class关键字,class后面紧接着是类名,即Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下来的,通常,如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类
classStudent(object):pass
1.1.2 实例
定义好了Student类,就可以根据Student类创建出Student的实例,创建实例是通过类名+()实现的
>>> bart =Student()>>>bart<__main__.student object at>
>>>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.score59
1.2 访问限制
如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,在Python中,实例的变量名如果以__开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问
classStudent(object):def __init__(self, name, score):
self.__name =name
self.__score =scoredefprint_score(self):print('%s: %s' % (self.__name, self.__score))
如果外部代码要获取name和score,可以给Student类增加get_name和get_score这样的方法
classStudent(object):
...defget_name(self):return self.__name
defget_score(self):return self.__score
如果要允许外部代码修改score,可以再给Student类增加set_score方法
classStudent(object):
...defset_score(self, score):
self.__score = score
1.3 继承和多态
在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Base class、Super class)
编写了一个名为Animal的class,有一个run()方法可以直接打印
classAnimal(object):defrun(self):print('Animal is running...')
当我们需要编写Dog和Cat类时,就可以直接从Animal类继承
classDog(Animal):pass
classCat(Animal):pass
对于Dog来说,Animal就是它的父类,对于Animal来说,Dog就是它的子类。Cat和Dog类似
继承最大的好处是子类获得了父类的全部功能
classAnimal(object):defrun(self):print('Animal is running...')
classDog(Animal):pass>>> dog = Dog()
>>> dog.run()
Animal is running...
也可以对子类增加一些方法,比如Dog类
classDog(Animal):defrun(self):print('Dog is running...')defeat(self):print('Eating meat...')
继承的第二个好处需要我们对代码做一点改进。无论是Dog还是Cat,它们run()的时候,显示的都是Animal is running...,符合逻辑的做法是分别显示Dog is running...和Cat is running...,因此,对Dog和Cat类改进如下
classDog(Animal):defrun(self):print('Dog is running...')classCat(Animal):defrun(self):print('Cat is running...')
当子类和父类都存在相同的run()方法时,我们说,子类的run()覆盖了父类的run(),在代码运行的时候,总是会调用子类的run()。这样,我们就获得了继承的另一个好处:多态
1.要理解多态的好处,我们再编写一个函数,这个函数接受一个Animal类型的变量
2.再定义一个Tortoise类型,也从Animal派生
3.当我们调用run_twice()时,传入Tortoise的实例
defrun_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)
>>> type('str')
>>>type(None)
如果一个变量指向函数或者类,也可以用type()判断
>>>type(abs)
>>>type(a)
type()函数返回对应的Class类型
如果要判断一个对象是否是函数,可以使用types模块中定义的常量
>>> importtypes>>> deffn():
...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__()方法
>>> classMyDog(object):
...def __len__(self):
...return 100...>>> dog =MyDog()>>>len(dog)100
仅仅把属性和方法列出来是不够的,配合getattr()、setattr()以及hasattr(),我们可以直接操作一个对象的状态
>>> classMyObject(object):
...def __init__(self):
... self.x= 9...defpower(self):
...return self.x *self.x
...>>> obj =MyObject()>>> hasattr(obj, 'x') #有属性'x'吗?
True>>>obj.x9
>>> 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"", line 1, in AttributeError:'MyObject' object has no attribute 'z'
>>> getattr(obj, 'z', 404) #获取属性'z',如果不存在,返回默认值404
404
也可以获得对象的方法
>>> hasattr(obj, 'power') #有属性'power'吗?
True>>> getattr(obj, 'power') #获取属性'power'
>
>>> fn = getattr(obj, 'power') #获取属性'power'并赋值到变量fn
>>> fn #fn指向obj.power
>
>>> fn() #调用fn()与调用obj.power()是一样的
81
实例属性和类属性
当我们定义了一个类属性后,这个属性虽然归类所有,但类的所有实例都可以访问到
>>> classStudent(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实例能添加的属性
classStudent(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"", line 1, in AttributeError:'Student' object has no attribute 'score'
使用__slots__要注意,__slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的
>>> classGraduateStudent(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__()方法,返回一个好看的字符串
>>> classStudent(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循环
classFib(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: #退出循环的条件
raiseStopIteration()return self.a #返回下一个值
现在,试试把Fib实例作用于for循环:
>>> for n inFib():
...print(n)
...1
1
2
3
5...46368
75025
2.4.3 __getitem__
Fib实例虽然能作用于for循环,看起来和list有点像,但是,把它当成list来使用还是不行,要表现得像list那样按照下标取出元素,需要实现__getitem__()方法
classFib(object):def __getitem__(self, n):
a, b= 1, 1
for x inrange(n):
a, b= b, a +breturn 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的值
classStudent(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__()方法,就可以直接对实例进行调用
classStudent(object):def __init__(self, name):
self.name=namedef __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)exceptValueError as e:print('ValueError:', e)exceptZeroDivisionError as e:print('ZeroDivisionError:', e)finally:print('finally...')print('END')
错误应该有很多种类,如果发生了不同类型的错误,可以有多个except来捕获不同类型的错误
try:print('try...')
r= 10 / int('2')print('result:', r)exceptValueError as e:print('ValueError:', e)exceptZeroDivisionError as e:print('ZeroDivisionError:', e)else:print('no error!')finally:print('finally...')print('END')
使用try...except捕获错误,可以跨越多层调用,比如函数main()调用foo(),foo()调用bar(),结果bar()出错了,这时,只要main()捕获到了,就可以处理:
deffoo(s):return 10 /int(s)defbar(s):return foo(s) * 2
defmain():try:
bar('0')exceptException as e:print('Error:', e)finally:print('finally...')
3.1.2 记录错误
Python内置的logging模块可以非常容易地记录错误信息,同样是出错,但程序打印完错误信息后会继续执行,并正常退出
importloggingdeffoo(s):return 10 /int(s)defbar(s):return foo(s) * 2
defmain():try:
bar('0')exceptException as e:
logging.exception(e)
main()print('END')
同样是出错,但程序打印完错误信息后会继续执行,并正常退出
ERROR:root:division by zero
Traceback (most recent call last):
File"err_logging.py", line 13, inmain
bar('0')
File"err_logging.py", line 9, inbarreturn foo(s) * 2File"err_logging.py", line 6, infooreturn 10 /int(s)
ZeroDivisionError: division by zero
END
通过配置,logging还可以把错误记录到日志文件里,方便事后排查
3.1.3 抛出错误
如果要抛出错误,首先根据需要,可以定义一个错误的class,选择好继承关系,然后,用raise语句抛出一个错误的实例
classFooError(ValueError):pass
deffoo(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 foo('0')
File"err_throw.py", line 8, infooraise FooError('invalid value: %s' %s)__main__.FooError: invalid value: 0
3.2 调试
3.2.1 print()
用print()把可能有问题的变量打印出来看看
deffoo(s):
n=int(s)print('>>> n = %d' %n)return 10 /ndefmain():
foo('0')
main()
用print()最大的坏处是将来还得删掉它,想想程序里到处都是print(),运行结果也会包含很多垃圾信息
3.2.2 断言
凡是用print()来辅助查看的地方,都可以用断言(assert)来替代
deffoo(s):
n=int(s)assert n != 0, 'n is zero!'
return 10 /ndefmain():
foo('0')
如果断言失败,assert语句本身就会抛出AssertionError
Traceback (most recent call last):
...
AssertionError: nis 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不会抛出错误,而且可以输出到文件
importlogging
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
print(10 /n)
ZeroDivisionError: division by zero
3.3 单元测试
单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作
为了编写单元测试,我们需要引入Python自带的unittest模块,编写mydict_test.py如下
importunittestfrom mydict importDictclassTestDict(unittest.TestCase):deftest_init(self):
d= Dict(a=1, b='test')
self.assertEqual(d.a,1)
self.assertEqual(d.b,'test')
self.assertTrue(isinstance(d, dict))deftest_key(self):
d=Dict()
d['key'] = 'value'self.assertEqual(d.key,'value')deftest_attr(self):
d=Dict()
d.key= 'value'self.assertTrue('key' ind)
self.assertEqual(d['key'], 'value')deftest_keyerror(self):
d=Dict()
with self.assertRaises(KeyError):
value= d['empty']deftest_attrerror(self):
d=Dict()
with self.assertRaises(AttributeError):
value= d.empty
一旦编写好单元测试,我们就可以运行单元测试。最简单的运行方式是在mydict_test.py的最后加上两行代码:
if __name__ == '__main__':
unittest.main()
以test开头的方法就是测试方法,不以test开头的方法不被认为是测试方法,测试的时候不会被执行
可以在单元测试中编写两个特殊的setUp()和tearDown()方法。这两个方法会分别在每调用一个测试方法的前后分别被执行
classTestDict(unittest.TestCase):defsetUp(self):print('setUp...')deftearDown(self):print('tearDown...')
---恢复内容结束---