您的位置:首页 > 脚本大全 > > 正文

python内置函数一览表(Python面向对象程序设计构造函数和析构函数用法分析)

更多 时间:2021-10-18 11:31:54 类别:脚本大全 浏览量:557

python内置函数一览表

Python面向对象程序设计构造函数和析构函数用法分析

本文实例讲述了python面向对象程序设计构造函数和析构函数用法。分享给大家供大家参考,具体如下:

构造函数和析构函数

1、构造方法的使用

很多类都倾向于将对象创建为有初始化状态.因此类可以定义一个名为init()的特殊方法(构造方法)来实例化一个对象。

构造方法也叫做构造器,是指当实例化一个对象(创建一个对象)的时候,第一个被自动调用的方法。

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

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • class person():
  •   #构造方法
  •   def __init__(self):
  •     print("构造函数被执行了")
  •   #创建对象的过程中构造函数被自动调用
  • p1 = person()
  • 输出:

    构造函数被执行了

    结论:创建对象的过程中调用了构造函数。

    当未手动添加构造函数时,系统会默认提供一个无参的构造函数。

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

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

  • ?
  • 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 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__:返回的是当前类的类名

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 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的关键字

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 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 删除对象的时候,系统会自动调用析构函数

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

    演示:

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 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()
  • 输出:

    析构函数被调用了
    析构函数被调用了

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • class animal(object):
  •   def __del__(self):
  •     print('animal父类的析构函数被调用了')
  • class cat(animal):
  •   pass
  • cat = cat()
  • 输出:

    animal父类的析构函数被调用了

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 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析构函数被调用了

    希望本文所述对大家python程序设计有所帮助。

    原文链接:https://blog.csdn.net/lm_is_dc/article/details/80166544

    您可能感兴趣