Python面向对象（三）

​
​

活动地址：CSDN21天学习挑战赛

十三、私有属性

在实际工作中，我们有时候需要限制实例随意修改属性，这时候就要用到私有属性。定义私有属性很简单，只要在定义属性名字的前面使用两条下划线作为开头。

class Factory:
    '''这是一个工厂类'''
    def __init__(self,name,money):
        self.name=name
        self.__money=money
        print('公司名字叫：{}'.format(self.name))
        print('公司有{} 资产。'.format(__money))
 
    def jianyan(self):
        print('这是工厂里面负责检验的。')
 
 
factory1=Factory('X超级工厂',99999999)
factory1.jianyan()
 
#输出：
'''
公司名字叫：X超级工厂
Traceback (most recent call last):
  File "G:\Python Project Center\面向对象学习.py", line 15, in 
    factory1=Factory('X超级工厂',99999999)
  File "G:\Python Project Center\面向对象学习.py", line 7, in __init__
    print('公司有{} 资产。'.format(__money))
NameError: name '_Factory__money' is not defined
'''
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

十四、私有方法

私有方法和私有属性一样，私有方法只能在类内部被调用，实例不能直接调用。

class Factory:
 
    def __inf(self):
        print('超级工厂')
    def zuzhuang(self):
        print('这里负责组装')
 
factory1=Factory()
factory1.zuzhuang()
factory1.__inf()
#输出
'''
Traceback (most recent call last):
  File "G:\Python Project Center\面向对象学习.py", line 10, in 
    factory1.__inf()
AttributeError: 'Factory' object has no attribute '__inf'
这里负责组装
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

十五、继承

继承，是一种对类进行分层划分的概念，继承的基本思想是在一个类的基础上制定出一个新的类，这个新的类不仅可以继承原来类的属性和方法，还可以增加新的属性和方法。原来的类被称为父类，新的类被称为子类。

继承：实现代码的重用 相同的代码不需要重复的编写。

继承的语法：

class 类名（父类名）:
    pass
1
2

子类继承父类，可以直接享受父类封装好的方法，不需要再次开发

class Factory:
    def jianyan(self):
        print('这是工厂里面负责检验的。')
 
    def zuzhuang(self):
        print('这是工厂里面负责组装的。')
 
    def baozhuang(self):
        print('这是工厂里面负责包装的。')
 
    def chuhuo(self):
        print('这是工厂里面负责出货的。')
 
 
class QiCheFactory(Factory):
    def jinrong(self):
        print('这里提供金融服务！')
 
x_car=QiCheFactory()
x_car.chuhuo()
x_car.jinrong()
 
#输出：
'''
这是工厂里面负责出货的。
这里提供金融服务！
'''
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

继承的时候需要注意：

1、在继承中，如果子类定义了__init__方法，则父类的__init__方法不会被自动调用，需要在子类的__init__方法中专门调用。

class Factory:
    def __init__(self,name):
        self.name=name
 
    def jianyan(self):
        print('这是{},里面负责检验的。'.format(self.name))
 
class QiCheFactory(Factory):
    def __init__(self):
        print('超级工厂！')
 
    def jinrong(self):
        print('这里提供金融服务！')
 
x_car=QiCheFactory()
x_car.jianyan()
#输出：
'''
Traceback (most recent call last):
  File "G:\Python Project Center\面向对象学习.py", line 16, in 
    x_car.jianyan()
  File "G:\Python Project Center\面向对象学习.py", line 6, in jianyan
    print('这是{},里面负责检验的。'.format(self.name))
AttributeError: 'QiCheFactory' object has no attribute 'name'
超级工厂！
'''
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

我们可以使用super函数调用__init__方法。

class Factory:
    def __init__(self,name):
        self.name=name
 
    def jianyan(self):
        print('这是{},里面负责检验的。'.format(self.name))
 
class QiCheFactory(Factory):
    def __init__(self):
        super(QiCheFactory,self).__init__('超级工厂')
 
 
    def jinrong(self):
        print('这里提供金融服务！')
 
x_car=QiCheFactory()
x_car.jianyan()
#输出：
'''
这是超级工厂,里面负责检验的。
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2、子类不能继承父类中的私有方法，也不能调用父类的私有方法。

class Factory:
    def __init__(self,name):
        self.name=name
 
    def jianyan(self):
        print('这是{},里面负责检验的。'.format(self.name))
 
    def __jianyan(self):
        print('这是{}，里面负责检验重要物料。'.format('特殊车间'))
 
class QiCheFactory(Factory):
    def __init__(self):
        pass
 
    def jinrong(self):
        print('这里提供金融服务！')
 
x_car=QiCheFactory()
x_car.jianyan()
x_car.__jianyan()
#输出：
'''
Traceback (most recent call last):
  File "G:\Python Project Center\面向对象学习.py", line 21, in 
    x_car.__jianyan()
AttributeError: 'QiCheFactory' object has no attribute '__jianyan'. Did you mean: 'jianyan'?
这是超级工厂,里面负责检验的。
'''
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

十六、多态

不同的子类对象调用相同的父类方法，产生不同的执行结果：

• 多态可以增加代码的灵活度
• 以继承和重写父类方法为前提
• 是调用方法的技巧，不会影响到类的内部设计

class Factory:
    def shengchan(self):
        print('我们负责生产高铁。')
 
class QiCheFactory(Factory):
    def shengchan(self):
        print('我们负责生产汽车。')
 
class LunTaiFactory(Factory):
    def shengchan(self):
        print('我们负责生产轮胎。')
 
qiche=QiCheFactory()
qiche.shengchan()
 
luntai=LunTaiFactory()
luntai.shengchan()
 
#输出：
'''
我们负责生产汽车。
我们负责生产轮胎。
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

分析：

    当子类和父类存在相同的方法时，子类的方法会覆盖父类的方法，这样代码在运行时总是会调用子类的方法，这就是多态。

    多态的意思就是多种形态。多态意味着即使不知道变量所引用的对象时什么类型，也能对对象进行操作。多态会根据类的不同而表现出不同的行为。
1
2
3

判断一个实例是不是某个对象，可以使用isinstance函数。举例如下：

class Factory:
    def shengchan(self):
        print('我们负责生产高铁。')
 
class QiCheFactory(Factory):
    def shengchan(self):
        print('我们负责生产汽车。')
 
class LunTaiFactory(Factory):
    def shengchan(self):
        print('我们负责生产轮胎。')
 
qiche=QiCheFactory()
luntai=LunTaiFactory()
 
print(isinstance(qiche,QiCheFactory))
print(isinstance(qiche,Factory))
print(isinstance(luntai,LunTaiFactory))
print(isinstance(luntai,Factory))
#输出：
'''
True
True
True
True
'''
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

十七、类变量

类变量不需要实例化就能直接使用，相当于绑定在类上，而不是绑定在实例上。

class Factory:
    name='X工厂'
 
print(Factory.name)
 
#输出
'''
X工厂
'''
1
2
3
4
5
6
7
8
9

但是类变量在实例中也是可以被调用的。值得注意的是，实例不能修改类变量。

class Factory:
    name='X工厂'
 
print(Factory.name)
 
qiche=Factory()
luntai=Factory()
 
print(qiche.name)
print(luntai.name)
 
Factory.name='超级工厂'
 
print(qiche.name)
print(luntai.name)
 
#输出
'''
X工厂
X工厂
X工厂
超级工厂
超级工厂
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

十八、静态方法

静态方法和类变量有点类似，静态方法在定义类时就已经被分配定义好了。静态方法并不绑定类也不绑定实例，想当于给方法添加了一个前缀。定义静态方法将引入一个新的概念——装饰器。

定义静态方法的语法就是在定义函数的上面一行（不能有空行）添加一句"@staticmethod"。静态方法不再有第一个默认参数 self。所以静态方法本身也不能调用成员变量和成员方法。静态方法不需要实例化之后使用，和类变量一样直接使用即可，其他的和一般函数没有任何区别。

class Factory:
    name='X工厂'
 
    @staticmethod
    def inf():
        print('本公司是世界五百强！')
 
Factory.inf()
#输出
'''
本公司是世界五百强！
'''
1
2
3
4
5
6
7
8
9
10
11
12

十九、类方法

类方法，顾名思义就是该方法绑定在定义的类上面，而不是绑定在实例上。

定义类方法和静态方法有点类似，是在定义类方法的前一行（不能有空行）添加一句装饰器"@classmethod"。和静态方法不同的是，类方法和成员方法一样都有一个初始的参数，但是这个参数不同于成员方法。成员方法的第一个参数指向的是实例，而类方法指向的则是定义的类本身，所以类方法可以读取和修改类变量。

class Factory:
    name='X工厂'
 
    @classmethod
    def inf(cls):
        print(cls.name,'世界五百强。')
 
Factory.inf()
#输出
'''
X工厂 世界五百强。
'''
1
2
3
4
5
6
7
8
9
10
11
12