面向对象基础

1面向对象不是所有情况都适用

2面向对象编程

a定义类

class 类名:

def 方法1(self,参数)

b根据类创建对象

使用对象执行类中方法

3 self，形式参数，python内部传递

obj=abc()

obj.abc()===>self:obj

4 类+括号 =》自动执行类中的__init__方法，在__init__方法中执行具体封装的操作__init__有一个特殊的名字:构造方法。

__del__解释器销毁对象时候自动调用，析构方法。

封装：

使用场景：当同一类型的方法具有相同的参数，直接封装到对象即可

把类当做模板，创建多个对象，对象内封装的数据不一样

5派生类可以继承基类中所有的功能

6派生类和基类同时存在，优先找派生类

7多继承的时查找方法，先自己然后左面优先class aaa(a,b),先找自己，然后a，然后b

继承：

多继承

8多态

多种形态

python本身支持多态

扩展：

重载，函数名相同，参数个数不同.(python不支持)

重写，派生类中重新实现基类的方法(还有点关系)

先来简单的类

class test:

    def abc(self,num):
        print(num)

    def abc2(self):
        print("abc2")

obj=test()
obj.abc(10)

对象和类的区别：

根据上面图来用代码进一步理解：

class test:

    def abc(self):
        print(self)

obj1=test()
print(obj1)
obj1.abc()


obj2=test()
print(obj2)
obj2.abc()


结果：

<index.test instance at 0x0000000002CB5408>
<index.test instance at 0x0000000002CB5408>

<index.test instance at 0x0000000002C5C6C8>
<index.test instance at 0x0000000002C5C6C8>

这里可以看出self是什么东西了吧就是创建实例的obj，在执行类中的方法就是obj地址.xxx

封装

先来个简单的封装

 1 class test:
 2 
 3     def abc(self):
 4         print(self.pk) #打印pk变量
 5 
 6 obj1=test()
 7 obj1.pk=123  #在对象中封装数据，但是这个不是非主流的封装方式。只是实验
 8 print(obj1.pk)
 9 
10 obj2=test()
11 obj2.pk="abc"  
12 obj2.abc()     #执行abc方法，这个方法和obj1执行方式不一样.但是意思都是一样的。这样就是封装将某个变量封装在对象中以后有需要就拿就可以了
13 
14 结果：
15 123
16 abc

__init__()构造方法：一般这样封装

 1 class test:
 2     def __init__(self,pk):
 3         self.pk=pk
 4     def abc(self):
 5         print(self.pk)
 6 
 7 obj1=test(11) #初始化实例的时候必须先执行__init__方法
 8 print(obj1.pk)
 9 
10 obj2=test("abc")
11 obj2.abc()

构造方法

执行父类的构造方法

 1 #-*- coding:utf-8 -*-
 2 class base(object):
 3     def __init__(self):
 4         print("base")
 5         self.age=19
 6 
 7 class s1(base):
 8     def __init__(self):
 9         print("s1")
10         self.name="zhangsan"
11         #执行父类构造方法1.super方法就是找父类的方法，s1就是告诉super找s1的父类，self就是zhhangsan的实例。找到父类__init__方法并执行,super
12         #会自动给我们传递参数给__init__()函数，这里不用奇怪
13         super(s1,self).__init__()
14         #第二种方法知道就好，不推荐使用.主要在于如果是多继承super会按照object类的方式查找。而这个需要自己写。主要多继承需要写很多
15         #base.__init__(self)
16 
17 
18 zhangsan=s1()
19 print(zhangsan.name)
20 print(zhangsan.age)

View Code

继承

 1 class base:
 2     def chi(self):
 3         print("chi")
 4 
 5     def he(self):
 6         print("he")
 7 
 8 class Cat(base):
 9     def __init__(self,name):
10           self.name=name
11     def jiao(self):
12         print("miao  ")
13 
14 class Dog(base):
15     def __init__(self,name):
16           self.name=name
17     def jiao(self):
18         print("wang  ")
19 
20 h1=Dog("zs")
21 h1.chi()
22 h1.jiao()
23 
24 
25 结果：
26 chi
27 wang  
28 chi
29 miao

继承

 1 class base:
 2     def chi(self):
 3         print("chi")
 4 
 5     def he(self):
 6         print("he")
 7 
 8 class base1:
 9     def chi(self):
10         print("base1 chi")
11 
12     def he(self):
13         print("base1 he")
14 
15 class Cat(base):
16     def __init__(self,name):
17           self.name=name
18     def jiao(self):
19         print("miao  ")
20 
21 #多继承在查找方法的时候左面优先，base先找然后在找base1
22 class Dog(base,base1):
23     def __init__(self,name):
24           self.name=name
25     def jiao(self):
26         print("wang  ")
27 
28 h1=Dog("zs")
29 h1.chi()
30 h1.jiao()
31 
32 h1=Cat("zs")
33 h1.chi()
34 h1.jiao()
35 
36 
37 结果：
38 chi
39 wang  
40 chi
41 miao

多继承

第一种查找

第二种查找

PY3中顺序D-->B--->E-->C--->A

py2中有二种,带object跟py3一样,不带D-->B--->A -->E-->C

 1 #python2中如果不加object查找方式就是左面全部找完在找右面。
 2 #加上的话d--->b--->e--->c--->a  最后找共同的父类
 3 #在python3中就只有第二种方式，py2中尽量都是使用带object的
 4 class A(object):   
 5     def f1(self):
 6         print("A")
 7 
 8 class B(A):
 9     def f1(self):
10         print("B")
11 
12 class C(A):
13     def f1(self):
14         print("C")
15 
16 class D(B):
17     def f1(self):
18         print("D")
19 class E(A):
20     def f1(self):
21         print("E")
22 class F(D,E):
23     pass
24 F1=F()
25 F1.f1()

多类查找

扩展：

 1 class A(object):
 2     def aa(self):
 3         print("A")
 4 
 5 class B(A):
 6     def f1(self):
 7         print("B")
 8         self.aa()
 9 
10 class C():
11     def aa(self):
12         print("C")
13 
14 
15 class F(C,B):
16     pass
17 
18 F1=F()
19 F1.f1()
20 
21 #这里只要记住不管方法中的方法再去调什么方法都的开之前
22 这个方法是谁执行的。这里是F1那么不管如何调用都是以F1为准
23 结果：
24 B
25 C

实现上图方法