Python 类的基本定义详解

【摘要】Python是一种面向对象的语言，稍微复杂一点的程序，都应该采用类来进行设计，以使程序结构更加清晰，易于把控。本文将讨论单类的基本内容定义，以后的博文再讨论其它。

 

一. 成员的访问范围：

Python中的类，其实就是执行代码块，这一点很重要，所有位于 class 语句中的代码，都是在特殊的类命名空间中执行的，这个类命名空间可由类内所有实例成员访问。

类内成员包括类成员（用类名来访问），实例成员（用self 或 实例对象变量来访问）。

Python语言本身对成员的访问范围控制不是很严格，更是一种对程序员的提醒或约定，请不要在外部使用保护成员及私有成员。以下是实例成员的访问范围的定义约定；如果是类成员，应该都是公用的，否则，请不要把它定义为类成员。

类型	名称	python 中的定义方法	举例	可访问范围
public	公用成员	不加入任何特殊字符	member	类实例，继承类，当前类内部
protected	保护成员	加一个下划线	_member	继承类，当前类内部
private	私有成员	加二个下划线	__member	当前类内部

 

二. 类成员的定义详解：

成员名称	说明	举例
类本身	类名的命名规范为 CamelCase 每个单词都以大写字母开头，单词之间没有分隔符	class DemoClass:
构造函数	创建类实例时，将触发执行	def __init__(self):
析构函数	由系统的垃圾回收机制来自动执行，程序无法控制它何时执行，请谨慎使用	def __del__(self):
类代码	直接定义在类范围，不定义在任何方法中 触发执行：第一次实例化对象，或第一次调用类成员	class DemoClass:     print('Class 执行代码块开始执行了, 但整个过程只执行一次！')
类字段（类特性）	直接定义在类范围，不定义在任何方法内 访问方法： DemoClass.class_scope_field 任何类实例，访问的都是同一个类字段 self.class_scope_field的初始值为DemoClass.class_scope_field,  但随后的改动，将被绑定在 self 实例范围，跟类本身没有关系	class DemoClass    class_scope_field = “类作用域字段”
类方法	带装饰器 @classmethod的函数 第一个参数一定为cls 访问方式：DemoClass.class_method()，不带 cls参数 不能访问 self成员 可以通过cls, 直接访问类成员	@classmethod def class_method(cls):     print("类方法: classmethod_hello()")
静态方法	带装饰器 @staticmethod 不带任何固定参数 访问方式: DemoClass.static_method() 不能访问self成员 静态方法就是普通的函数，只不过碰巧定义在了类里，而不是模块层。因此，完全可以将其放在跟类同模块的类定义前面或后面	@staticmethod def static_method():     print('静态方法: static_hello')
成员字段（成员特性）	在成员方法中，前面加self进行定义 按PEP8规范，所有成员字段，应该定义在 def __init__(self)方法中 通过加下划线，约定访问范围 访问方式： 通过self 或 实例对象变量名来访问           self.__private_field           demo_instance.public_field	def __init__(self, class_name):     print("构造函数：__init__()")     self.public_field = "公用字段"     self._protected_field = "受保护字段"     self.__private_field = "私有字段"     self._name = class_name
成员方法	python的函数，第一个参数一定为self 通过加下划线，约定访问范围 可通过self访问所有实例成员 访问方式： 通过self 或 实例对象变量名来访问，访问时，带( ), 不需要带self参数            self.__private_method( )            demo_instance.public_method( )	def public_method(self): def _protected_method(self): def __private_method(self):
成员属性（读）	带装饰器 @property的成员方法 可在返回结果前，进行逻辑控制处理，并屏蔽内部的字段命名 访问范围，按设计初衷，成员属性一般应该是公用的 访问方式，通过 self 或 实例对象变量名来访问，访问时，不带（），跟字段一样，直接使用           self.public_property           demo_instance.public_property	@property def public_property(self):     return self._name.upper()
成员属性（写）	带装饰器 @指定属性名.setter的成员方法 方法名称跟对应的成员属性名称一致 第二个参数，为传入值参数 对传入值可以进行逻辑处理，然后赋值给类的成员字段 访问范围，跟对应的成员属性一致 访问方式，通过 self 或 实例对象变量名来访问，只支持赋值，跟字段赋值一样         self.public_property = ‘new property’ demo_instance.public_property = “new property 2”	@public_property.setter def public_property(self, value):     self._name = value.lower()

 

三. 实例代码及演示：

# coding:utf-8
# -----------------------------------------------------------------------------
# Comments  : 演示说明python类的基本成员定义及使用
# Developer : Edwin.Zhang
# Date      : 2018-8-28
# -----------------------------------------------------------------------------

def normal_method():
    print("*.调用正常函数：normal_hello()")


# 类名的命名规范为： CamelCase
class DemoClass:
    print('【演示】Class 执行代码块开始执行了, 但整个过程只执行一次！\n')

    class_scope_field = "类作用域字段"

    def __init__(self, class_name):
        print("构造函数：__init__()")
        self.public_field = "公用字段"
        self._protected_field = "受保护字段"
        self.__private_field = "私有字段"
        self._name = class_name

    def __del__(self):
        print("析构方法：__del__() for [" + self._name + "],  什么时候被调用，不确定，请谨慎使用！")

    @property
    def public_property(self):
        return self._name.upper()

    @public_property.setter
    def public_property(self, value):
        self._name = value.lower()

    def public_method(self):
        print('*.公用方法：public_hello() : ' + self.public_field + " " + self.public_property)

    def _protected_method(self):
        print('*.受保护方法：_private_hello() : ' + self.__private_field)

    def __private_method(self):
        print('*.私有方法：_private_hello() : ' + self.__private_field)

    @classmethod
    def class_method(cls):
        print("*.类方法: classmethod_hello()")
        print("*.类方法访问 " + cls.class_scope_field)

    @staticmethod
    def static_method():
        print('*.静态方法: static_hello')

    def internal_call(self):
        self.public_method()
        self._protected_method()
        self.__private_method()

        self.class_method()
        self.static_method()

        DemoClass.class_method()
        DemoClass.static_method()

        normal_method()

        self.public_property = "new setting property"
        print("*.访问公共属性 ：" + self.public_property)
        print("*.通过self, 访问：" + self.class_scope_field)
        print("*.通过类名, 访问：" + DemoClass.class_scope_field)


def demo0():
    print(DemoClass.public_property)


def demo1():
    instance = DemoClass('My Demo Class')

    print("\n【演示】类内部，调用的成员")
    instance.internal_call()

    print("\n【演示】通过对象实例，调用的方法")
    instance.public_method()
    instance.class_method()
    instance.static_method()

    print("\n【演示】通过对象实例，访问字段及属性")
    print(instance.public_field)
    print(instance.public_property)
    instance.public_property = "new class name"
    print(instance.public_property)

    print("\n【演示】通过类名，访问类字段及类方法")
    print(DemoClass.class_scope_field)
    DemoClass.class_method()
    DemoClass.static_method()


def demo2():
    print("\n\n\n【演示2】类型字段可以在多个类实例共享，若绑定到self并修改，则只作用于当前实例")
    print("Case 1 : \n*.实例初始化时： 两者一致")
    ins1 = DemoClass("Instance 01")
    print("ins1.class_scope_field = " + ins1.class_scope_field)
    print("DemoClass.class_scope_field = " + DemoClass.class_scope_field)

    print("\n*.基于（实例）修改后， 成员已经绑定self, 两者不一致")
    ins1.class_scope_field = "基于（实例）修改类作用域字段"
    print("ins1.class_scope_field = " + ins1.class_scope_field)
    print("DemoClass.class_scope_field = " + DemoClass.class_scope_field)

    print("\n*.基于类修改后：（已经发生基于（实例）修改过）：两者不一致")
    DemoClass.class_scope_field = "基于类修改类作用域字段"
    print("ins1.class_scope_field = " + ins1.class_scope_field)
    print("DemoClass.class_scope_field = " + DemoClass.class_scope_field)
    print("")

    print("\nCase 2 : \n*.创建新的实例：开始两者一致，为类成员当前值")
    ins2 = DemoClass("Instance 02")
    print("ins2.class_scope_field = " + ins2.class_scope_field)
    print("DemoClass.class_scope_field = " + DemoClass.class_scope_field)

    print("\n*.基于类修改后：（没有基于（实例）修改过），两者一致，为更新值")
    DemoClass.class_scope_field = "基于类修改类作用域字段 (新)"
    print("ins1.class_scope_field = " + ins2.class_scope_field)
    print("DemoClass.class_scope_field = " + DemoClass.class_scope_field)
    print("")

    print("\nCase 3: \n*.创建新的实例：两者一致，为类成员的更新值")
    ins3 = DemoClass("Instance 03")
    print("ins2.class_scope_field = " + ins3.class_scope_field)
    print("DemoClass.class_scope_field = " + DemoClass.class_scope_field)
    print("")


if __name__ == "__main__":
    demo0()
    demo1()
    demo2()