Python面向对象编程（Object Oriented Programming，OOP）之结构、成员和属性

叁歲伎倆 2022-05-18 01:04 142阅读 0赞

## 面向对象结构 ##

面向对象类中的数据大致分为两块区块：

class Demo:
        name = '张三'  # 第一部分：静态字段（静态变量）
        age = 18  # 第一部分：静态字段（静态变量）
        address = '北京'  # 第一部分：静态字段（静态变量）
    
        def __init__(self):  # 第二部分：动态字段（方法）部分
            pass
    
        def func(self):  # 第二部分：动态字段（方法）部分
            pass

> **结论：分为静态字段（变量）和动态字段（方法）两部分**

每个部分还可以分为多个小部分：

class Demo:
        idNum = '111111111'  # 静态变量
        __address = '北京'  # 私有静态变量
    
        def __init__(self, name, age, height):  # 构造方法，也属于普通方法
            self.name = name
            self.__age = age
            self.__height = height
    
        def func1(self):  # 普通方法
            pass
    
        def __func2(self):  # 私有方法
            pass
    
        @classmethod
        def class_func(cls):  # 类方法，至少含有一个cls参数
            print("类方法")
    
        @staticmethod  # 静态方法，无默认参数
        def static_func():
            print("静态方法")
    
        @property  # 属性
        def property_func(self):
            return "属性"

类有这么多的成员，那么我们先从那些地方研究呢？ 可以从私有与公有部分，方法的详细分类两个方向去研究。

## 私有与公有 ##

对于每一个类的成员而言都有两种形式：

>  *  公有成员，在任何地方都能访问。
>  *  私有成员，只有在类的内部才能方法。

私有和公有成员访问权限不同：

**静态字段（静态变量）**

>  *  公有静态字段：类可以访问；内部类可以访问；派生类（子类）可以访问。
>  *  私有静态字段：仅内部类可以访问。

class DemoA:
        name1 = '公有字段'
        __name2 = '私有字段'
    
        def func1(self):  # 内部类访问
            print((DemoA.name1))  # 可以访问
            print(DemoA.__name2)  # 可以访问
    
    
    class DemoB(DemoA):
        def show1(self):  # 派生类访问
            print(DemoA.name1)  # 可以访问
            # print(DemoA.__name2) # 不可以访问
    
    
    c1 = DemoA()
    c1.func1()
    c2 = DemoB()
    c2.show1()

结果：

> 公有字段  
> 私有字段  
> 公有字段
> 
> Process finished with exit code 0

**普通字段（对象属性）**

>  *  公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问。
>  *  私有普通字段：仅类内部可以访问。

class DemoA:
        def __init__(self):
            self.foo1 = '公有字段'
            self.__foo2 = '私有字段'
    
        def func1(self):  # 内部类访问
            print(self.foo1)  # 可以访问
            print(self.__foo2)  # 可以访问
    
    
    class DemoB(DemoA):
        def show1(self):  # 派生类访问
            print(self.foo1)  # 可以访问
            # print(self.__foo2) # 不可以访问，报错
    
    
    c1 = DemoA()
    c1.func1()
    
    c2 = DemoB()
    c2.show1()

结果：

> 公有字段  
> 私有字段  
> 公有字段
> 
> Process finished with exit code 0

**方法：**

>  *  公有方法:对象可以访问；类内部可以访问；派生类中可以访问。
>  *  私有方法:仅类内部可以访问。

class DemoA:
        def __init__(self):
            pass
    
        def add1(self):
            print("超类公有方法")
    
        def __add2(self):
            print("超类私有方法")
    
        def add3(self):
            self.__add2()  # 本类调用自己的私有方法
    
    
    class DemoB(DemoA):
        def show1(self):
            print("派生类公有方法")
    
        def __show2(self):
            print("派生类私有方法")
    
        # def show3A_add2(self):
        #     self.__add2  # 派生类不能引用超类私有方法，报错
    
        def show4B_show2(self):
            self.__show2()  # 派生类可以引用自身的私有方法，属于自己调用
    
    
    c1 = DemoA()
    c1.add1()  # 调用自身公有方法
    # c1.add2()  # 外部无法调用私有方法，报错
    c1.add3()  # 外部间接调用类中私有方法
    
    c2 = DemoB()
    c2.add1()  # 派生类调用超类公有方法
    # c2.add2()  # 派生类无法调用超类私有方法，报错
    c2.add3()  # 派生类调用自身公有方法
    c2.show1()  # 派生类调用自身公有方法
    # c2.show2()  # 派生类在外部无法调用自身私有方法，报错
    # c2.show3A_add2()  # 派生类不能引用超类私有方法，报错
    c2.show4B_show2()  # 派生类间接调用父类私有方法

结果：

> 超类公有方法  
> 超类私有方法  
> 超类公有方法  
> 超类私有方法  
> 派生类公有方法  
> 派生类私有方法
> 
> Process finished with exit code 0

> 总结：
> 
> **对于这些私有成员来说，他们只能在类的内部使用,不能再类的外部以及派生类中使用。**

## 成员 ##

**字段**

字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同。

> **普通字段属于对象，静态字段属于类。**

class Demo:
        country = '中国'  # 静态字段
    
        def __init__(self, name):
            self.name = name  # 普通字段
    
    
    obj = Demo('北京')
    
    # 直接访问普通字段
    print(obj.name)
    print(obj.country)
    
    # 直接访问静态字段
    print(Demo.country)

结果：

> 北京  
> 中国  
> 中国
> 
> Process finished with exit code 0

> 结论：
> 
> **普通字段需要通过对象来访问，也可以使用使用对象来访问。**
> 
> **静态字段通过类访问，类不能直接访问普通字段。**

**注意：静态字段在内存中只保存一份，普通字段在每个对象中都要保存一份。**

**方法**

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

*  普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self。
 *  类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls。
 *  静态方法：由**类**调用，无默认参数。

class Foo:
    
        def __init__(self, name):
            self.name = name
    
        def ord_func(self):
            """ 定义普通方法，至少有一个self参数 """
            print('普通方法')
    
        @classmethod
        def class_func(cls):
            """ 定义类方法，至少有一个cls参数，cls表示这个类 """
            print('类方法')
    
        @staticmethod
        def static_func():
            """ 定义静态方法 ，无默认参数"""
            print('静态方法')
    
    
    # 调用普通方法
    f = Foo(1)  # 随便写一个实参，无实际意义
    f.ord_func()
    
    # 调用类方法
    Foo.class_func()
    
    # 调用静态方法
    Foo.static_func()

结果：

> 普通方法  
> 类方法  
> 静态方法
> 
> Process finished with exit code 0

这些方法的差异：

相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。

不同点：方法调用者不同、调用方法时自动传入的参数不同。

**属性（property）**

具有访问它时会执行一段功能（函数）然后返回值的特性。

例：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解） 成人的BMI数值：

*  过轻：低于18.5
 *  正常：18.5-23.9
 *  过重：24-27
 *  肥胖：28-32
 *  非常肥胖, 高于32

体质指数（BMI）=体重（kg）÷身高^2（m），例：70kg÷（1.75×1.75）=22.86。

class People:
        def __init__(self, name, weight, height):
            self.name = name
            self.weight = weight
            self.height = height
    
        @property
        def bmi(self):
            return self.weight / (self.height ** 2)
    
    
    p1 = People('张三', 70, 1.75)
    print(p1.bmi)

结果：

> 22.857142857142858
> 
> Process finished with exit code 0

ps：这是本人的BIM值，唉~又胖了啊。

使用属性的好处：

将一个类的函数定义成特性以后，对象再去使用的时候obj.name，根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则。

由于新式类（Python3中全是新式类）中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除。

class people:  # 定义一个人的类
        def __init__(self, name, sex):
            self.name = name
            self.sex = sex  # p1.sex = "male",遇到property，优先用property
    
        @property  # 查看sex的值
        def sex(self):
            return self.__sex  # 返回正真存值的地方
    
        @sex.setter  # 修改sex的值
        def sex(self, value):
            if not isinstance(value, str):  # 在设定值之前进行类型检查
                raise TypeError("性别必须是字符串类型")  # 不是str类型时，主动抛出异常
            self.__sex = value  # 类型正确的时候，直接修改__sex的值，这是值正真存放的地方
            # 这里sex前加"__",对sex变形，隐藏。
    
        @sex.deleter  # 删除sex
        def sex(self):
            del self.__sex
    
    
    p1 = people("张三", "男")  # 实例化对象p1
    print(p1.sex)  # 查看p1的sex，此时要注意self.sex的优先级
    p1.sex = "女"  # 修改sex的值
    print(p1.sex)  # 查看修改后p1的sex
    print(p1.__dict__)  # 查看p1的名称空间，此时里面有sex
    del p1.sex  # 删除p1的sex
    print(p1.__dict__)  # 查看p1的名称空间，此时发现里面已经没有sex了

结果：

> 男  
> 女  
> \{'name': '张三', '\_people\_\_sex': '女'\}  
> \{'name': '张三'\}
> 
> Process finished with exit code 0

--------------------