xyZGHio

樱花同载酒，终似少年游

0%

Python面向对象之类的定义

发表于 阅读数： 评论数：
本文字数： 4.3k 阅读时长 ≈ 9 分钟

这里介绍Python的面向对象——如何定义类

abstract.png

定义类

这里定义一个Dog类，示例如下

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
44
45
class Dog:
    """
    狗
    """
    # 类变量
    remark = "备注：警犬"

    # 构造方法: 通过特殊方法名 __init__ 进行定义,用于创建实例。其会在对象实例化时自动调用
    # Python中，一个类只能有一个构造方法。如果期望实现多个构造方法，可通过为形参添加默认值的方式实现
    def __init__(self, name, age, type="拉布拉多"):
        # 实例变量通过self与实例进行关联
        self.name = name
        self.age = age
        self.sex = "male"
        # 以双下划线__开头的变量为私有变量
        self.__type = type

    # 对于实例方法而言，其第一个形参必须为实例对象本身，该形参名习惯上使用self
    # 当我们通过实例对象调用实例方法时，不需要为self参数提供实参，Python会自动传入 
    def say(self):
        print(self.name, "正在狗叫: 汪汪汪")
        self.__bye()
        
    def info(self):
        print("I'm", self.name, "Age is", self.age, "Sex: ", self.sex, "Type: ", self.__type)

    def update_sex(self, sex):
        self.sex = sex

    # 以双下划线__开头的方法为私有方法 
    def __bye(self):
        print("Bye ~~~~")
   
    # 添加 @classmethod装饰器 表示其为类方法, 可通过类/实例进行调用
    # 对于类方法而言，其第一个形参必须为类本身，该形参名习惯上使用cls
    # 当我们通过实例对象 或 类调用类方法时，都不需要为cls参数提供实参，Python均会自动传入类本身
    @classmethod
    def get_remark_info(cls):
        print("我是类方法, remark:", cls.remark, ", cls:", cls) 

    # 添加 @staticmethod装饰器 表示其为静态方法, 可通过类/实例进行调用
    # 本质上就是一个普通函数，只是将其放置在类中了。通常是一些工具方法
    @staticmethod
    def get_remark(msg):
        print("我是静态方法, remark:", Dog.remark, ", msg:",msg)

构造方法/实例方法

构造方法：Python中，一个类只能有一个构造方法，用于创建实例。如果期望实现多个构造方法，可通过为形参添加默认值的方式实现。具体地，通过特殊方法名 __init__ 进行定义构造方法。其会在对象实例化时自动调用

实例方法：其第一个形参必须为实例对象本身，该形参名习惯上使用self。我们通过实例对象调用实例方法时，不需要为self参数提供实参，Python会自动传入

1
2
3
4
5
6
7
8
9
10
11
12
title = "调用实例方法"
print(f"------------ {title} -------------------")

# 创建对象
my_dog = Dog("Luca", 3)
his_dog = Dog("Tony", 17, "藏獒")

# 调用对象的实例方法
my_dog.say()
my_dog.info()
his_dog.say()
his_dog.info()

figure 1.png

实例变量

对于实例变量，在类内部（即类的定义中）通过self . 变量名访问；在类外部可通过实例名 . 变量名访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
title = "访问/修改 实例变量"
print(f"------------ {title} -------------------")

# 创建对象
my_dog = Dog("Luca", 3)
his_dog = Dog("Tony", 17, "藏獒")

# 访问对象的实例变量
print("My Dog is", my_dog.name)
print("My Dog age is", my_dog.age)
print("My Dog sex is", my_dog.sex)

# 修改对象的实例变量
# 通过对象直接修改
his_dog.name = "Tonnnnnnnnnny"
# 通过对象的实例方法修改
his_dog.update_sex("female")
print("His Dog is", his_dog.name)
print("His Dog age is", his_dog.age)
print("His Dog sex is", his_dog.sex)

figure 2.png

类变量

对于类变量，在类内部（即类的定义中）通过类名 . 变量名访问；在类外部可通过类名 . 变量名访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
title = "访问/修改 类变量"
print(f"------------ {title} -------------------")

# 创建对象
my_dog = Dog("Luca", 3)
his_dog = Dog("Tony", 17, "藏獒")

# 访问/修改 类变量
print(f"Dog.remark: {Dog.remark}")

Dog.remark = "备注：宠物犬"
print(f"Dog.remark: {Dog.remark}")

Dog.remark = "备注：中华田园犬"
print(f"Dog.remark: {Dog.remark}")

figure 3.png

私有变量/私有方法

Python中，以双下划线__开头的变量为私有变量，以双下划线__开头的方法为私有方法。在类外部不可以访问私有变量/私有方法。但事实上可以通过特殊手段进行访问

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
title = "私有变量/私有方法"
print(f"------------ {title} -------------------")

# 创建对象
my_dog = Dog("Luca", 3)
his_dog = Dog("Tony", 17, "藏獒")

# 类的外部不可以 访问私有变量
try:
    print("my dog type:", my_dog.__type)
except Exception as e:
    print("访问私有变量， 发生异常：", e)

# 类的外部无法 修改私有变量
my_dog.__type = "中华田园犬"
my_dog.info()

# 事实上，类外部可以通过 _类名__私有变量名  访问私有变量
print("his dog type: ", his_dog._Dog__type)
his_dog._Dog__type = "金毛"
his_dog.info()

print("------------------------------------------------------------------")

# 类的外部不可以 调用私有方法
try:
    my_dog.__bye()
except Exception as e:
    print("调用私有方法， 发生异常：", e)

# 事实上，类外部可以通过 _类名__私有方法名  调用私有方法
his_dog._Dog__bye()

figure 4.png

类方法

定义类的类方法时，需要添加 @classmethod装饰器 表示其为类方法。对于类方法而言，其第一个形参必须为类本身，该形参名习惯上使用cls。可通过类/实例来调用类方法，调用时，不需要为cls参数提供实参，Python均会自动传入类本身

1
2
3
4
5
6
7
8
9
title = "调用类方法"
print(f"------------ {title} -------------------")

# 类方法: 可通过类进行调用
Dog.get_remark_info()

# 类方法: 可通过实例进行调用
dog2 = Dog("Tom", 3)
dog2.get_remark_info()

figure 5.png

静态方法

定义类的静态方法时，需要添加 @staticmethod装饰器 表示其为静态方法, 可通过类/实例进行调用。本质上就是一个普通函数，只是将其放置在类中了。通常是一些工具方法

1
2
3
4
5
6
7
8
9
title = "调用静态方法"
print(f"------------ {title} -------------------")

# 静态方法: 可通过类进行调用
Dog.get_remark("嘻嘻")

# 静态方法: 可通过实例进行调用
dog1 = Dog("Caily", 22)
dog1.get_remark("嘿嘿")

figure 6.png

参考文献

  1. Python编程·第3版：从入门到实践 Eric Matthes著
  2. Python基础教程·第3版 Magnus Lie Hetland著
  3. 流畅的Python·第1版 Luciano Ramalho著
推荐文章
请我喝杯咖啡捏～
  • 本文作者： Aaron Zhu
  • 本文链接： https://xyzghio.xyz/ClassOfPy/
  • 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-ND 许可协议。转载请注明出处！

欢迎关注我的微信公众号：青灯抽丝