本文实例讲述了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