Python的面向对象、继承、多态和对象的消失与重生

面向对象的语言

众所周知，Python简单和面向对象的优点，所以也备受青睐。
首先是最简答的对象的创建实例

class Dog:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def sit(self):
        print(self.name.title() + " is now sitting.")

    def roll(self):
        print(self.name.title() + " rolled over!")
1
2
3
4
5
6
7
8
9
10

init是构造函数
创建类
self 传递给方法的是实例对象的本身
经过测试代码和结果如下

dog = Dog("小黑",3)
dog.sit()
dog.roll()
print("\n")
1
2
3
4

继承

# 方法的继承
class A:
    def __init__(self,x):
        self.x = x

    def hello(self):
        print("你好，我是A")

class B(A):
    def __init__(self,x):
        self.x = x

    def hello(self):    # 重写父类方法
        print("你好，我是B")

b = B(3)
b.hello()
print(b.x)
print(isinstance(b,A))      # 判断一个对象是否属于某个类
print(issubclass(B,A))
print("\n")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

直接将父类对象写在将要继承类的参数里即可

多重继承
从前往后开始继承，当前面内容没有的时候，才开始继承后面的
但要注意的是，A和B之间不能有继承关系，否则会报错
且是按顺序继承A与B之间的方法变量等，当A没有了才会取B中继续继承
如果AB同时有相同的内容，那么继承的将是A的内容，因为按顺序继承

# class C(A,B):
#     pass
#
# c = C()
1
2
3
4

类使用的小tips

组合

class Turtle:
    def say(self):
        print("不积硅步无以至千里！")
class Cat:
    def say(self):
        print("喵喵喵~")
class Dog:
    def say(self):
        print("哎呦，牛逼啊")

class Garden:
    t = Turtle()
    c = Cat()
    d = Dog()
    def say(self):
        self.t.say()
        self.c.say()
        self.d.say()

g = Garden()
g.say()
print("\n")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

通过创建最小类对象来模拟字典
亦或者可以通过传统字典来保存

class K:
    pass
k = K()
k.x = 250
k.y = "小甲鱼"
k.z = [1,2,3]
print(k.x,k.y,k.z)
print("\n")
1
2
3
4
5
6
7
8

使用super继承父类的同时进行初始化

class Car():
    pass
class ElectircCar(Car):
    def __init__(self,p):
        super.__init__()
        self.p = p
1
2
3
4
5
6

多态

class Shape():
    def __init__(self,name):
        self.name = name
    def area(self):
        pass

class Square(Shape):
    def __init__(self,length):
        super().__init__("正方形")
        self.length = length
    def area(self):
        return self.length * self.length

class Circle(Shape):
    def __init__(self,radius):
        super().__init__("圆形")
        self.radius = radius
    def area(self):
        return 3.14 * self.radius * self.radius

class Triangle(Shape):
    def __init__(self,base,height):
        super().__init__("三角形")
        self.base = base
        self.height = height
    def area(self):
        return self.base * self.height / 2

s = Square(5)
c = Circle(6)
t = Triangle(3,4)
print(s.name,s.area())
print("\n")
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
33

类内的私有变量

私有变量需要通过特定方法来进行修改，增加的数据安全性和保密性
私有变量，在定义变量名之前加上两段下划线即可,且使用get和set进行变量值的设置

class Private():
    def __init__(self,x):
        self.__x = x
    def set_x(self,x):
        self.__x = x
    def get_x(self):
        return self.__x
1
2
3
4
5
6
7

对象的消失与重生

对象的消失与del

class DelTest():
    def __init__(self):
        print("I am coming!")
    def __del__(self):
        print("I am done")
d = DelTest()
del d
print()
1
2
3
4
5
6
7
8

对象的重生，利用global

class D():
    def __init__(self,name):
        self.name = name
    def __del__(self):
        global x
        x = self
d = D("Lebron")
print(d)
print(d.name)
del d
print(x)
print()
1
2
3
4
5
6
7
8
9
10
11
12

由于最好不要过多地使用全局变量，容易出错
采用闭包的方式来使对象重生

class E():
    def __init__(self,name,func):
        self.name = name
        self.func = func
    def __del__(self):
        self.func(self)
def outter():
    x = 0
    def inner(y = None):
        nonlocal x
        if y:
            x = y
        else:
            return x
    return inner
f = outter()
e = E("小甲鱼",f)
print(e)
del e
g = f()
print(g)
print()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

而关于闭包的知识，读者可以参见我的另一篇文章Python中的函数、闭包、装饰器、lambda表达式、生成器和递归

一些冷门小知识

使用dict来查询对象的所有属性
使用slots会限制类中变量的创建的个数和和空间，但也能大大提高效率
继承自父类的__slots__属性是不会在子类中生效的，不会再限制子类变量的添加，
但原有的__slots__会继承给子类

使用__new__方法，在实例对象之前(即super)进行拦截
在函数中传入的str是不能改变大小写的，但是使用new进行拦截就可以做到
注意python的拦截方法
这里感觉很冷门，就是记录一下以便以后谈起能够更知道