python构造函数和析构函数

构造函数和析构函数

关注公众号“轻松学编程”了解更多。

1、构造方法的使用

很多类都倾向于将对象创建为有初始化状态.因此类可以定义一个名为__init__()的特殊方法(构造方法)来实例化一个对象。
构造方法也叫做构造器,是指当实例化一个对象(创建一个对象)的时候,第一个被自动调用的方法。

演示1:构造方法被调用的契机

class Person():
    #构造方法
    def __init__(self):
        print("构造函数被执行了")
    
    #创建对象的过程中构造函数被自动调用
p1 = Person()
输出：
构造函数被执行了

结论:创建对象的过程中调用了构造函数。
当未手动添加构造函数时,系统会默认提供一个无参的构造函数。

演示2:构造函数和普通函数之间的区别

说明:构造函数本质上还是一个函数,函数可以有参数,也可以无参,所以同样的道理,构造函数也是如。

class Person():  
    #一般情况下,构造方法的参数和成员变量有关,并且在设置的过程中与成员变量同名
    def __init__(self, name, age, height, weight):
        #print(nname, age, height, weight)
        #因为构造方法是创建对象的过程中被调用的
        #所以构造方法的作用一般是用来定义成员变量并且给成员变量赋值
        #定义属性并给属性赋值
        #通过self来进行区分是成员变量还是形参
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight
    
    def run(self):
        print("run")
    def eat(self, food):
        print("eat "+ food)     
        
'''
构造函数: __init__()  在使用类创建对象的时候自动调用
注意: 如果不显式的写出构造函数,默认会自动添加一个空的构造函数,函数体中什么都不实现
'''
per = Person("hanmeimei", 20, 170, 55)
print(per.name, per.age)
per.run()

per2 = Person("lili", 21, 175, 70)
print(per2.name, per2.age)
输出：
hanmeimei 20
run
lilei 21

2、self的使用

注意:self代表类的实例[对象],而非类本身。

类的方法与普通的函数只有一个特殊的区别—>他们必须有一个额外的第一个参数名称,按照惯例它的名字是self。
self.__class__:返回的是当前类的类名

class Test():
    def prt(self):
        print(self)
        print(self.__class__)
        
t = Test()
t.prt() 
输出：
<__main__.Test object at 0x0000017D47D81B00>
<class '__main__.Test'>

演示2:self不是python的关键字

class Person():
    def run(self):
        print("run")
        print(self.__class__)
        p = self.__class__("tt", 30, 10, 30)

    def eat(self,food):
        print("eat" + food)

    def say(self):
        print("hello, my name is %s, I am %d year old" % (self.name, self.age))

    def play(a):
        print("play", a.name)

    def __init__(self, name, age, height, weight):
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight


# self代表此时正在创建对象,self.属性表示当前对象的属性
per1 = Person("tom", 20, 160, 80)
per1.say()

per2 = Person("henmeimei", 21, 160, 80)
per2.say()

per1.say()
per1.run()
输出：
hello, my name is tom, I am 20 year old
hello, my name is henmeimei, I am 21 year old
hello, my name is tom, I am 20 year old
run
<class '__main__.Person'>

3、析构函数的使用

析构函数调用的契机【对象被销毁的时候】：
1、程序执行结束，会自动调用析构函数
2、使用del 删除对象的时候，系统会自动调用析构函数

注意：如果没写析构函数，当符合析构函数调用的契机时，系统会自动调用父类的析构函数。

演示:

class Person():
    def run(self):
        print("run")
    
    def eat(self, food):
        print("eat "+food)
    
    def __init__(self, name, age, height, weight):
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight
        
     def __del__(self):
        print("析构函数被调用了")

per = Person("hanmeimei", 20, 170, 55)
#释放对象
del per
#注意:对象释放后就不能再进行访问了

#在函数里定义的对象,会在函数结束时自动释放,这样可以用来减少内存空间的浪费
#其实就是作用域的问题
def func():
    per2 = Person("aa", 1, 1, 1)
    
func()   
输出：
析构函数被调用了
析构函数被调用了

class Animal(object):

    def __del__(self):
        print('Animal父类的析构函数被调用了')

class Cat(Animal):
    pass

cat = Cat()
输出：
Animal父类的析构函数被调用了

class A():
    def __init__(self):
        print("父类A构造函数被调用了")
    def __del__(self):
        print("父类A析构函数被调用了")

class B(A):
    def __init__(self):
        print("子类B构造函数被调用了")
        A.__init__(self)
    def __del__(self):
        print("子类B析构函数被调用了")

class C(A):
    pass

def main():
    b = B()
    del b
    print("*********************")
    c = C()

if __name__ == '__main__':
    main()
输出：
子类B构造函数被调用了
父类A构造函数被调用了
子类B析构函数被调用了
*********************
父类A构造函数被调用了
父类A析构函数被调用了