第十章：类和对象(38-40课时)

向西而笑

           38课时：继承
继承的写法和使用方法只要在子类名加上括号和父类的名字就表示继承了父类（class子类名(父类名）:）。被继承的类称作基类、父类、超类，继承的类称作子类。子类继承了父类所有的属性和方法。
例子：

1. >>> class Parent:
   
2.         def hello(self):
   
3.                 print('正在调用父类的方法...')
   
4. 
   
5. 
   
6. >>> class Child(Parent):
   
7.         pass
   
8. >>> p = Parent()
   
9. >>> p.hello()
   
10. 正在调用父类的方法...
    
11. >>> c = Child()
    
12. >>> c.hello()
    
13. 正在调用父类的方法...

复制代码

如果在子类定义中和父类重名的属性或方法，则会自动覆盖对应的属性和方法，但是父类的不变。例如：

1. >>> class Child(Parent):
   
2.         def hello(self):
   
3.                 print('正在调用子类的方法...')
   
4. >>> c = Child()
   
5. >>> c.hello()
   
6. 正在调用子类的方法...
   
7. >>> p.hello()
   
8. 正在调用父类的方法..

复制代码

子类和父类中成员重名问题
如果子类的方法和父类的重名了，一般是覆盖掉父类的方法。但我希望既能继承父类的方法也能保留子类的方法，python中有两个解决方法：调用未绑定的父类方法和使用super方法，前者弊端大不推荐，super()方法非常的强大，就用这个方法。
举例：

1. >>> class A:
   
2.         def __init__(self):
   
3.                 print('进入A...')
   
4.                 print('离开A...')
   
5. >>> class B(A):
   
6.         def __init__(self):
   
7.                 print('进入B...')
   
8.                 super().__init__()
   
9.                 print('离开B...')
   
10. >>> b = B()
    
11. 进入B...
    
12. 进入A...
    
13. 离开A...
    
14. 离开B...

复制代码

多重继承
在python中可以一个子类可以继承多个父类。写法是：class 子类（父类1，父类2...）。多重继承容易产生问题，要慎重使用

1. >>> class A:
   
2.         def __init__(self):
   
3.                 print('进入A...')
   
4.                 print('离开A...')
   
5. >>> class B(A):
   
6.         def __init__(self):
   
7.                 print('进入B...')
   
8.                 super().__init__()
   
9.                 print('离开B...')
   
10. >>> class C(A):
    
11.         def __init__(self):
    
12.                 print('进入C...')
    
13.                 super().__init__()
    
14.                 print('离开C...')
    
15. >>> class D(B,C):
    
16.         def __int__(self):
    
17.                 print('进入D...')
    
18.                 super().__init__()
    
19.                 print('离开D...')
    
20. >>> d = D()
    
21. 进入B...
    
22. 进入C...
    
23. 进入A...
    
24. 离开A...
    
25. 离开C...
    
26. 离开B...

复制代码

          39课时：拾遗
类的组合
类之间的继承属于纵向关系，除了纵向关系还有横向关系，即类组合。但类之间有派生关系用继承更好，但我只想要在类中加入其他类的功能就用组合。通过类的实例化来调用类。例如：

1. >>> class Turtle:
   
2.         def __init__(self,x):
   
3.                 self.x = x
   
4. >>> class Fish:
   
5.         def __init__(self,y):
   
6.                 self.y = y
   
7. >>> class Pool:
   
8.         def __init__(self,x,y):
   
9.                 self.turtle = Turtle(x)
   
10.                 self.fish = Fish(y)
    
11.         def printnum(self):
    
12.                 print('池塘内的乌龟有%d只，小鱼有%d条！'%(self.turtle.x,self.fish.y))
    
13. >>> pool = Pool(10,100)
    
14. >>> pool.printnum()
    
15. 池塘内的乌龟有10只，小鱼有100条！

复制代码

属性和方法重名问题
如果属性和方法重名了，那么属性会覆盖掉方法。。
例子：

1. >>> class Example:
   
2.         def fun(self):
   
3.                 print('我成功显示了')
   
4. >>> case = Example()
   
5. >>> case.fun()
   
6. 我成功显示了
   
7. >>> case.fun = '我变成属性了'
   
8. >>> case.fun()
   
9. Traceback (most recent call last):
   
10.   File "<pyshell#14>", line 1, in <module>
    
11.     case.fun()
    
12. TypeError: 'str' object is not callable
    
13. >>> case.fun
    
14. '我变成属性了'

复制代码

解决方法：1、不要试图在类里面定义出所有想到的属性和方法应该利用继承和组合机制来扩展。  2、用不同的词性命名属性名用名词，方法名用动词。例如定义一个矩形类，定义长的属性用’len’，定义求面积的方法用’getArea’这样的词

类定义、类对象、类实例化对象
定义完一个类后，类就成为了类对象，通过类实例化后的对象就成为了类实例化对象。类定义的属性和方法是静态的，类实例化后的属性和方法是动态的。
例子：

1. >>> class X:
   
2.         count = 0      #开始定义count属性等于0
   
3. 
   
4. >>> a = X()
   
5. >>> b =X()
   
6. >>> a.count
   
7. 0
   
8. >>> b.count
   
9. 0
   
10. 
    
11. >>> a.count += 10  #这里改变实例化对象a的count属性
    
12. >>> a.count   
    
13. 10
    
14. >>> X.count     #结果显示X类的count属性并没有收到影响
    
15. 0
    
16. >>> b.count     #实例化对象b也没收到影响
    
17. 0
    
18. 
    
19. >>> X.count += 100  #这里改变X类的count属性
    
20. >>> X.count
    
21. 100
    
22. >>> b.count      #b的count属性跟着改变了
    
23. 100
    
24. >>> a.count      #然而a的count属性却还是10
    
25. 10

复制代码

如果类属性和方法改变，实例化对象会跟着改变

        40课时：一些相关的BIF
这节课讲的是有关类的一些BIF
issubclass(clas,classinfo):如果第一个参数class是第二个参数classinfo的子类则返回True。注意：1、一个类被认为是自身的子类。2、clasinfo可以是有类对象组成的元组，只要class是其中任何一个候选类的子类就返回True。

1. >>> class X:
   
2.         pass
   
3. >>> class A(X):
   
4.         pass
   
5. >>> issubclass(A,A)  #自己是自己的子类
   
6. True
   
7. >>> issubclass(A,X)
   
8. True
   
9. >>> issubclass(X,object)  #object是所有类的基类
   
10. True

复制代码

isinstance(object,classinfo):用于检查一个对象是否属于某种类，是返回True，不是返回False。这个是之前学了的函数，也可以用于检查一个对象是不是某个类的实例对象，class是一个类实例对象classinfo同样可以是由类组成的元组。

1. >>> class X:
   
2.         pass
   
3. >>> a = X()
   
4. >>> class Z:
   
5.         pass
   
6. >>> isinstance(a,X)
   
7. True
   
8. >>> isinstance(a,Z)
   
9. False

复制代码

hasattr(object,name):测试一个对象是否有指定的属性。name必须是字符串的形式。举例：

1. >>> class X:
   
2.         def __init__(self,a=0):
   
3.                 self.a = a
   
4. >>> x = X()
   
5. >>> hasattr(x,'a')
   
6. True

复制代码

getattr(object,name[,default]):返回对象指定属性的值，name也是要求是字符串的形式。如果设置了默认值default，指定属性不存在时返回default,否则抛出异常。

1. >>> class X:
   
2.         a = 10
   
3. >>> x = X()
   
4. >>> getattr(x,'a')
   
5. 10
   
6. >>> getattr(x,'b')
   
7. Traceback (most recent call last):
   
8.   File "<pyshell#20>", line 1, in <module>
   
9.     getattr(x,'b')
   
10. AttributeError: 'X' object has no attribute 'b'
    
11. >>> getattr(x,'b','这个属性不存在！')
    
12. '这个属性不存在！'
    

复制代码

setattr(object,name,value):为对象指定属性设置值，name要求是字符串形式，如果指定属性不存在则新建一个属性。

1. >>> class Z:
   
2.         x = 1
   
3. >>> z = Z()
   
4. >>> setattr(z,'x',2)
   
5. >>> getattr(z,'x')
   
6. 2
   
7. >>> setattr(z,'y',10)
   
8. >>> getattr(z,'y')
   
9. 10

复制代码

delattr(object,name):与setattr()作用相反，删除对象的指定属性，如果指定属性不存在则抛出attribute异常。

property(fget=None,fset=None,fdel=None,doc=None):用property()函数使得在访问属性值调用第一个参数，设置属性调用第二个参数，删除属性调用第三个参数，三个参数都是方法。举例：

1. >>> class Case:
   
2.         def __init__(self,size):
   
3.                 self.size = size
   
4.         def getSize(self):
   
5.                 return self.size
   
6.         def setSize(self,value):
   
7.                 self.size = value
   
8.         def delSize(self):
   
9.                 del self.size
   
10.         z = property(getSize,setSize,delSize)
    
11. >>> c =Case(10)
    
12. >>> c.z
    
13. 10
    
14. >>> c.__dict__
    
15. {'size': 10}
    
16. >>> c.z = 100
    
17. >>> c.z
    
18. 100
    
19. >>> del c.z
    
20. >>> c.z
    
21. Traceback (most recent call last):
    
22.   File "<pyshell#36>", line 1, in <module>
    
23.     c.z
    
24.   File "<pyshell#28>", line 5, in getSize
    
25.     return self.size
    
26. AttributeError: 'Case' object has no attribute 'size'
    
27. >>> c.__dict__
    
28. {}

复制代码

这个property()到底有什么用呢？用上例来说明的话，如果对size属性修改比如重命名或者设置成私有变量，那么实例化对象调用这个属性就会出错，要想正确调用就要相应地修改代码，太麻烦了；如果运用了proper，不管在类定义里如何改变size，实例对象还是只要调用z就可以了。以上就是我的浅薄理解，如有不对，请多赐教，谢谢。