Python基础_面向对象

OOP

"""
    面向对象编程(Object Oriented Programming),OOP是一种程序设计思想.
    它把对象作为程序的基本单元,一个对象包含数据和操作数据的函数,
    相同属性和操作方法的对象被抽象为类.
    类Class
    对象Object
    实例Instance
    方法Method
"""
1
2
3
4
5
6
7
8
9

对象

“”"

什么是对象:
    生活中的一杯水.一个人

什么是面向对象:
    物品的特征是类,物品就是对象
    
属性和方法:
    对象具有的静态特征,对象有什么,类中定义的函数
    对象具有的各种动态行为,对象做什么

类去实例化对象
1
2
3
4
5
6
7
8
9
10
11

封装

"""
    将类中的某些信息,隐藏到类内部,不允许外部访问
    只能通过该类提供的方法实现对隐藏信息的访问和操作
    隐藏对象的信息,同时预留访问的接口
"""
1
2
3
4
5

继承

"""
    使用已经存在的类定义为基础建立新类
    新类可以增加新的数据和功能,也可以使用父类的功能
    新类继承父类所有的开放特征
    新类成为子类
    父类(基类,超类)
    子类(派生类)
"""
1
2
3
4
5
6
7
8

多继承

"""
'OBJECT'
在 Python中，如果父类和子类都重新定义了构造方法 init( )，在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造方法，必须在子类中显示调用。 
Python的类可以继承多个类，Java 和 C# 中则只能继承一个类 
Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先 
当类是经典类时，多继承情况下，会按照深度优先方式查找，当类是新式类时，多继承情况下，会按照广度优先方式查找
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话
如果当前类或者父类继承了 object 类，那么该类便是新式类，否则便是经典类。
参考:https://blog.csdn.net/qq_35240555/article/details/123011852
"""

1
2
3
4
5
6
7
8
9
10
11

多继承详解

"""
继承，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。
例如：
猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能。
然而，吃、喝、拉、撒是猫和狗都具有的功能，如果使用 继承 的思想，如下实现：
动物：吃、喝、拉、撒
猫：喵喵叫（猫继承动物的功能）
狗：汪汪叫（狗继承动物的功能）
下图显示了子类继承父类 的代码格式，就是在 class 子类名称后面的括号中写入父类的名称
"""
1
2
3
4
5
6
7
8
9
10
11
12
13

"""
那么问题又来了

是否可以继承多个类？
Python 的类可以继承多个类，Java 和 C# 中则只能继承一个类

如果继承的多个类每个类中都定了相同的函数，那么哪一个会被使用呢？
Python 的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先.

当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了 object 类，那么该类便是新式类，否则便是经典类。
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 经典类多继承
class D:

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#新式类多继承
class D(object):

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

多态

"""
多态性是指在不考虑实例类型的情况下使用实例，不论对象千变万化，使用者都可以通过一个统一的接口去调用。这么做的好处是增加了程序的灵活性和可扩展性。
比如 Python 的序列类型有多种形态：字符串，列表，元组，但我们可以在不考虑三者类型的前提下使用同样的方法去计算序列的长度，这就是多态性的一种体现

# str,list,tuple都是序列类型
s = str('hello')
l = list([1, 2, 3])
t = tuple((4, 5, 6))

我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()

len(s)
len(l)
len(t)
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

方法重写

' 子类对父类已有的方法，重新给出自己的实现版本，这个过程叫做方法重写'
    
#!/usr/bin/python3
 
class Parent:        # 定义父类
    def myMethod(self):
      print (' 调用父类方法')
 
class Child(Parent): # 定义子类
    def myMethod(self):
      print (' 调用子类方法')
 
c = Child()          # 子类实例
 c.myMethod()         # 子类调用重写方法
 super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

私有方法

'在类里面使用两个下换线的函数'
1

私有属性

 ' 在类里面使用两个下换线 __secretCount__ =0'
1

类的内置方法

"""
__doc__
    输出类的描述信息
__module__
    当前操作的对象在哪个模块
__str__
    格式化输出 % s 输出该方法的值
__repr__
    格式化输出 % r 输出该方法的值，并且 % s 在没有 ****str**** 方法时也是输出该方法的值
_del__
    del 执行该方法
        
"""
1
2
3
4
5
6
7
8
9
10
11
12
13