析构函数>>>私有属性>>>私有方法（alex—

本站消息

站长简介/公众号

出租广告位,需要合作请联系站长

3434erer

1048

文章

832127

访问

+关注

分类

暂无分类

日期归档

2023-06(2)

析构函数>>>私有属性>>>私有方法（alex——again）

发布于2019-08-06 17:30 阅读(588) 评论(0) 点赞(0) 收藏(3)

析构函数

在实例释放，销毁（运行结束）的时候自动执行的，通常用于做一些收尾工作，比如：关闭一些数据库连接，关闭打开的临时文件。

__del__的作用是在程序退出或实例释放或销毁的时候，执行。

class Role:  # (类名)
    n = 123  # 类变量
    name = "我是类name"  # 类变量

    def __init__(self, name, role, weapon, life_value=100, money=15000):
        # 构造函数
        # 在实例化时做一些类的初始化工作
        self.name = name  # 叫实例变量（也叫静态属性），赋给了实例。作用域就是实例本身
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
        # 以上代码是属性

    def __del__(self):  # 不需要给它传参数
        print("%s 彻底死了。。。"%self.name)

    def shot(self):  # 类的方法，就是功能的意思。（也叫动态属性，动态属性就是方法。静态属性就是变量）
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")

    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)
    # 以上代码是功能


r1 = Role('Alex', 'police', 'AK47')
r1.buy_gun("ak47")
r1.got_shot()

r2 = Role("jack", "terrorist", "B22")
r2.got_shot()

# 结果：
# # just bought ak47
# # ah...,I got shot...
# # ah...,I got shot...
# # Alex 彻底死了。。。
# # jack 彻底死了。。。
#可以看出：del的作用是在程序退出或实例释放或销毁的时候，执行。
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
34
35
36
37
38
39
40
41
42

再看
如果不是要等到结束的时候就执行

class Role:  # (类名)
    n = 123  # 类变量
    name = "我是类name"  # 类变量

    def __init__(self, name, role, weapon, life_value=100, money=15000):
        # 构造函数
        # 在实例化时做一些类的初始化工作
        self.name = name  # 叫实例变量（也叫静态属性），赋给了实例。作用域就是实例本身
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
        # 以上代码是属性

    def __del__(self):  # 不需要给它传参数
        print("%s 彻底死了。。。" % self.name)

    def shot(self):  # 类的方法，就是功能的意思。（也叫动态属性，动态属性就是方法。静态属性就是变量）
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")

    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)
    # 以上代码是功能


r1 = Role('Alex', 'police', 'AK47')
r1.buy_gun("ak47")
r1.got_shot()

del r1  # 不要等到结束就得死

r2 = Role("jack", "terrorist", "B22")
r2.got_shot()

# 结果：
# just bought ak47
# ah...,I got shot...
# Alex 彻底死了。。。
# ah...,I got shot...
# jack 彻底死了。。。
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
34
35
36
37
38
39
40
41
42
43

私有方法，私有属性

属性：静态属性（变量），动态属性（方法），一般我们说属性就是变量，方法就是方法
私有：就是外面访问不了，只能自己访问

私有属性：在前面加两个__,实例是访问不了的。

class Role:  # (类名)
    n = 123  # 类变量
    name = "我是类name"  # 类变量

    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value  # 加两个下划线就变成私有属性了
        self.money = money
        # 以上代码是属性

    def __del__(self):  # 不需要给它传参数
        pass  # print("%s 彻底死了。。。" % self.name)

    def shot(self):  # 类的方法，就是功能的意思。（也叫动态属性，动态属性就是方法。静态属性就是变量）
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")

    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)
    # 以上代码是功能


r1 = Role('Alex', 'police', 'AK47')
r1.buy_gun("ak47")
r1.got_shot()
print(r1.)  #现在就无法调用私有属性了
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

再看：
如何查看私有属性，在内部定义一个方法，把私有属性读出来

class Role:  # (类名)
    n = 123  # 类变量
    name = "我是类name"  # 类变量

    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value  # 加两个下划线就变成私有属性了
        self.money = money
        # 以上代码是属性

    def __del__(self):  # 不需要给它传参数
        pass  # print("%s 彻底死了。。。" % self.name)

    def show_status(self):
        print("name:%s weapon:%s life_val:%s" % (self.name,
                                                 self.weapon,
                                                 self.__life_value))  # 在内部是可以调用的，可以定义一个函数把它读出来

    def shot(self):  # 类的方法，就是功能的意思。（也叫动态属性，动态属性就是方法。静态属性就是变量）
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")

    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)
    # 以上代码是功能


r1 = Role('Alex', 'police', 'AK47')
r1.buy_gun("ak47")
r1.got_shot()
print(r1.show_status())  # 现在就可以查看私有属性了

结果：
just bought ak47
ah...,I got shot...
name:Alex weapon:AK47 life_val:100    #现在就可以读了
None
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
34
35
36
37
38
39
40
41

再看
私有属性外面访问不了，里面可以改

class Role:  # (类名)
    n = 123  # 类变量
    name = "我是类name"  # 类变量

    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value  # 加两个下划线就变成私有属性了
        self.money = money
        # 以上代码是属性

    def __del__(self):  # 不需要给它传参数
        pass  # print("%s 彻底死了。。。" % self.name)

    def show_status(self):
        print("name:%s weapon:%s life_val:%s" % (self.name,
                                                 self.weapon,
                                                 self.__life_value))  # 在内部是可以调用的，可以定义一个函数把它读出来

    def shot(self):  # 类的方法，就是功能的意思。（也叫动态属性，动态属性就是方法。静态属性就是变量）
        print("shooting...")

    def got_shot(self):
        self.__life_value -= 50
        print("ah...,I got shot...")

    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)
    # 以上代码是功能


r1 = Role('Alex', 'police', 'AK47')
r1.buy_gun("ak47")
r1.got_shot()
print(r1.show_status())  # 现在就可以查看私有属性了


#结果
# just bought ak47
# ah...,I got shot...
# name:Alex weapon:AK47 life_val:50
# None
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
34
35
36
37
38
39
40
41
42
43

私有方法也是一样的，也是加__,和私有属性是一样的

    n = 123  # 类变量
    name = "我是类name"  # 类变量

    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value  # 加两个下划线就变成私有属性了
        self.money = money
        # 以上代码是属性

    def __del__(self):  # 不需要给它传参数
        pass  # print("%s 彻底死了。。。" % self.name)

    def show_status(self):
        print("name:%s weapon:%s life_val:%s" % (self.name,
                                                 self.weapon,
                                                 self.__life_value))  # 在内部是可以调用的，可以定义一个函数把它读出来

    def __shot(self):  # 前面加__,实例就访问不了了
        print("shooting...")

    def got_shot(self):
        self.__life_value -= 50
        print("ah...,I got shot...")

    def buy_gun(self, gun_name):
        print("just bought %s" % gun_name)
    # 以上代码是功能


r1 = Role('Alex', 'police', 'AK47')
r1.buy_gun("ak47")
r1.__shot()     #就访问不了了
print(r1.show_status())  # 现在就可以查看私有属性了
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
34
35