python第八天-类详解

目录

1、python中没有重载（重名）

2、方法的动态性

3、私有属性和私有方法（实现封装）

4、@property装饰器

5、面向对象的特征

6、继承

7、object根类

8、重写__str__属性

9、多重继承

10、多态

11、特殊属性

12、对象的浅拷贝和深拷贝

13、组合

---

1、python中没有重载（重名）

python中，方法的参数没有类型，参数的数量也可以由可变参数空值，所有python中是没有重载的。

如果出现重名的方法，只有在最后的方法是有效的。

2、方法的动态性

#类的方法可以新增也可以修改
class Person:
    def work(self):
        print('work hard')
def play(s):
    print('well played')
def work2(s):
    print('please work harder')
p=Person()
p.work()
Person.play=play
p.play()
Person.work=work2
p.work()
****结果如下****
work hard
well played
please work harder

注意，（1）在修改类的方法时，用作为一个对象来进行操作，即不需要括号(Person.play=play，而不是Person.play=play()）。（2)在要替换成类的方法时，该方法至少有一个参数，因为类里的参数默认有一个self。

3、私有属性和私有方法（实现封装）

通常约定两个下划线开头的属性是私有属性，其他的为公开的。

类内部可以访问私有属性

类外部不能直接访问私有属性（方法）

类外部可以通过_类名__私有属性（方法）名访问私有属性。

class Person:
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def __work(self):
        print('hard work')
        print('年龄{0}'.format(self.__age))
p=Person('大神',16)
print(p.name)
print(p._Person__age)
p._Person__work()
****结果如下****
大神
16
hard work
年龄16

在类内部可以随意访问私有方法和属性。在外部要调用则需要采用格式写法（_类名__私有属性（方法））

4、@property装饰器

@property可以将一个方法的调用方式改为属性调用。

class Person:
    @property
    def salary(self):
        return 10000
p=Person()
print(p.salary)
***结果如下***
10000

5、面向对象的特征

三大特征：

封装：隐藏对象的属性和实现细节，只提供必要的方法

继承：继承可以让子类具有父类的特性，提高代码的重要性

多态：多态是指同一个方法调用由于对象不同会产生不同的行为。

6、继承

父类的私有属性，继承给子类同样是私有属性。

子类继承了父类除构造方法之外的所有成员。

子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为重写。

 

7、object根类

mro()或者类的属性__mro__可以输出这个类的继承层次结构。

object类是所有类的父类。

8、重写__str__属性

文档属性

#重写__str__
class Person:
    def __init__(self,name):
        self.name=name
    def __str__(self):
        return '名字是{0}'.format(self.name)
p=Person('大神')
print(p)
****结果如下****
名字是大神

在改写__str__时，要用return，不能用其他的如print。

9、多重继承

python支持多重继承，一个子类可以有多个直接父类，这样就具备了多个父类，但是这样会被类的整体层次搞得异常复杂，尽量避免使用。

子类在多重继承时，如果父类具有相同的方法，那么按照继承的顺序即从左到右的顺序来决定谁的方法生效。

#多重继承的解析顺序
class A:
    def say(self):
        print('AAA')
class B:
    def say(self):
        print('BBB')
class C(B,A):
    pass
c=C()
c.say()
****结果如下****
BBB

10、多态

多态要注意两点：

（1）多态时方法的多态，属性没有多态

（2）多态的两个必要条件，继承和方法重写。

class Man:
    def eat(self):
        print('eat food')
class Chinese(Man):
    def eat(self):
        print('山珍海味')
class Waiguoren(Man):
    def eat(self):
        print('金坷垃')
def ManEat(s):
    if isinstance(s,Man):
        s.eat()
    else:
        print('NO')
ManEat(Chinese())
ManEat(Waiguoren())
****结果如下****
山珍海味
金坷垃

11、特殊属性

12、对象的浅拷贝和深拷贝

import copy
class A:
    def __init__(self,B,C):
        self.B=B
        self.C=C
class B:
    def show(self):
        print('bb')
class C:
    def cal(self):
        print('cc')
b=B()
c=C()
a1=A(b,c)

a2=copy.copy(a1)
a3=copy.deepcopy(a1)
print(a1,a1.B,a1.C)
print(a2,a2.B,a2.C)
print(a3,a3.B,a3.C)
***结果如下***
<__main__.A object at 0x000001AC640C0F88> <__main__.B object at 0x000001AC640C0E48> <__main__.C object at 0x000001AC640C0E88>
<__main__.A object at 0x000001AC640C0F08> <__main__.B object at 0x000001AC640C0E48> <__main__.C object at 0x000001AC640C0E88>
<__main__.A object at 0x000001AC640D7A08> <__main__.B object at 0x000001AC640D7B08> <__main__.C object at 0x000001AC641004C8>

浅拷贝的子对象是和源对象的子对象引用相同的，深拷贝是复制了自己的自己对象。

13、组合

class A :
    def say_a(self):
        print('aaa')
class B :
    def __init__(self,a):
        self.a=a
a=A()
b=B(a)
b.a.say_a()
****结果如下****
aaa