面向对象一

面向对象:

 

1. 什么是对象:
   1. 对象是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件
   2. 在python一切皆对象
2. 面向对象:
   1. 面向对象：对函数进行分类和封装
   2. 一切面向对象干的事,都可以用函数式编程实现.
3. 类和对象:
   1. 类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
   2. 对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

In [60]: print(Person) <class '__main__.Person'> In [61]: print(tom) <__main__.Person object at 0x0456B410>	In [66]: print(type(tom)) <class '__main__.Person'>

函数式的应用场景 --> 各个函数之间是独立且无共用的数据

面向对象编程,函数之间有共享的数据

1. 三大特征:
   1. 封装
      1. 将内容封装到某处,
      2. 从某处调用被封装的内容

In [67]: tom.age=10

In [69]: tom.age

Out[69]: 10

1. self关键字

self就是对象本身

对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

1. class Person:  
2.     def __init__(self, name,age):  
3.         self.name = name  
4.         self.age=age  
5.     def show(self):  
6.         print(self.name,self.age)  
7.     
8.     
9. tom = Person("tom",10)  
10. tom.show()  
11. #tom 10  

 

1. 继承

1)，面向对象中的继承和现实生活中的继承相同

1. class Animal:  
2.     def run(self):  
3.         print("可以跑")  
4.     def walk(self):  
5.         print("可以走")  
6.     
7. class Person(Animal):  
8.     def __init__(self, name,age):  
9.         self.name = name  
10.         self.age=age  
11.     
12.     def walk(self):  
13.         super().walk()  
14.         print("可以直立行走")  
15.     
16.     def show(self):  
17.         print(self.name,self.age)  
18.     
19.     
20. tom = Person("tom",10)  
21. tom.run()  
22. tom.walk()  
23. # 可以跑  
24. # 可以走  
25. # 可以直立行走  

2) 多继承

1. class Animal:  
2.     def run(self):  
3.         print("可以跑")  
4.     def walk(self):  
5.         print("可以走")  
6. class Foo:  
7.     def work(self):  
8.         print("工作")  
9.     
10. class Person(Animal,Foo):  
11.     def __init__(self, name,age):  
12.         self.name = name  
13.         self.age=age  
14.     
15.     def walk(self):  
16.         super().walk()  
17.         print("可以直立行走")  
18.     
19.     def show(self):  
20.         print(self.name,self.age)  
21.     
22.     
23. tom = Person("tom",10)  
24. tom.run()  
25. tom.walk()  
26. tom.work()  

注意:新式类和经典类是有区别的:查找方法的顺序是不同的:

Python 2.x中默认都是经典类，只有显式继承了object才是新式类

Python 3.x中默认都是新式类，不必显式的继承object

1. class A():  
2.     def __init__(self):  
3.         pass  
4.     def save(self):  
5.         print "This is from A"  
6. class B(A):  
7.     def __init__(self):  
8.         pass  
9. class C(A):  
10.     def __init__(self):  
11.         pass  
12.     def save(self):  
13.         print  "This is from C"  
14. class D(B,C):  
15.     def __init__(self):  
16.         pass  
17. fun =  D()  
18. fun.save()  
19.     
20. 经典类的答案： This is from A  
21. 新式类的答案： This is from C  
22.     
23. 作者：刘康  
24. 链接：https://www.zhihu.com/question/22475395/answer/133787573  
25. 来源：知乎  
26. 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。  

大概就是这样的过程:

        

其中黑色箭头是继承链条,红色是新式类的寻找链条

 

1. 多态:

   (⊙o⊙)…python天生就是多态的

 

推荐博文: http://www.cnblogs.com/wupeiqi/p/4493506.html

 

 

 

1. 多态