Python中面向对象编程的一些高级方法_python 面向对象编程中高级的操作

一、声明类中的私有变量 （__ 前双下划线）

    定义类中的私有变量，只要将变量名前加双下划线即可__，如果一个变量名以__开头，它就是一个私有变量（private），只能在类内部访问，不能外部访问（比如__age）。

    但是开头结尾都有双下划线__的变量是特殊变量，特殊变量是可以直接访问的，不是private变量，所以不要定义这种变量（比如__age__）

    !!!但但是，其实双下划线的变量是可以访问的，需要使用 单下划线+类名+双下划线的变量名 访问（比如Student类中的__age变量，可以使用 instance._Student__age 来访问的），但是既然设置成了私有变量，那就是不想让访问，一定要这么做是没有什么特别的好处的。

二、实例属性与类属性

    定义在类中的 init 函数中的变量（比如self.age）是属于实例的，即每一个实例都有自己的 self.age。而定义在类中，init 函数外部（前）的变量则是属于类自己的变量，比如这样定义的变量：

class Student(object):
    age= '12'
1
2

    属于类的属性是不会因实例而异的，所有实例都拥有同样的类属性。

三、限制给实例添加的属性

    动态语言中，可以给对象（object）动态添加属性，比如一个student实例，可以临时添加 student.age的属性，或者给Student类动态添加属性 Student.age，使用 slots 可以限制给一个类的实力添加的属性：

class Student():
    __slots__ = ('age', 'sex')
1
2

    这样一来Student的实例就只能动态添加age和sex两个属性，添加其他的会报错：

student = Student()

student.age= "12"
student.sex= "Man"

student.score = 100  # Raise AttributeError: 'Student' object has no attribute 'score'
1
2
3
4
5
6

四、使用@property将方法“变为”属性

    类中，通常为了不暴露一些变量，或者对一些变量的做限制，会猜用定义一个私有变量（比如score），然后使用两个方法：一个get方法来获取变量值（比如get_score）和一个set方法来修改变量的值（比如set_score）来完成。使用时需要调用两个方法。

    使用装饰器 @property 可以更简单的做到这一点，它可以将一个方法“变成”属性：

只使用 @property 定义只读属性：

class Student():
    @property
    def age(self):
        return "12"


student = Student()
print(student.age)

1
2
3
4
5
6
7
8
9

五、使用 @property 和配套产生的 @NAME.setter 来定义可读属性：

class Student():

    @property
    def age(self):
        return self.__age

    @name.setter
    def sex(self, name):
        self.__sex = sex


student = Student()
student.age= "12"

print(student.age)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

六、多重继承

    Python支持多重继承，即一个子类可以继承自多个父类，只要在子类的括号中传入多个要继承的父类即可：

class Student():
    pass

class Teacher():
    pass

class Someone(Student,Teacher):
    pass
1
2
3
4
5
6
7
8

“”"

@property装饰器来创建只读属性

1、不可被继承或子类访问
2、只能被类实例访问且其方法必须有返回值 return.
3、会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改，使方法可以像属性一样访问
1
2
3

@classmethod

1、可以访问public,
2、可以被继承，可以通过类名直接访问。
3、不可以访问单下划线开头的函数
4、不可以访问双下划线开头的函数
5、可以被单下划线的子类函数访问
6、不可以被双下划线的子类函数访问
1
2
3
4
5
6

@staticmethod

1、可以被继承,不用带self或cls.
2、可以被public访问
3、不能访问单下划线开头的函数
4、不能访问双下划线开头的函数
5、可以被单下划线的子类函数访问
6、不可以被双下划线的子类函数访问
1
2
3
4
5
6

public类型

在python中数据和方法默认都是pubic类型的，此时方法和变量名都没有下划线。
1、 xx 没有以下划线开头的变量或者方法是public类型。
2、public类型可以被子类、类内以及类外被访问。
1
2
3

protected类型

> 1、 _xx 以单下划线开头的表示的是protected类型的变量。即保护类型只能允许其本身与子类进行访问。如： 当使用“from M import”时，不会将以一个下划线开头的对象引入 。
1

private类型

> 1、 __xx 双下划线的表示的是私有类型的变量。只能允许这个类本身进行访问了，连子类也不可以用于命名一个类属性（类变量），调用时名字被改变（在类FooBar内部，__boo变成_FooBar__boo,如self._FooBar__boo）
1

特列方法

> 1、 __xx__定义的是特列方法。用户控制的命名空间内的变量或是属性，如init , __import__或是file 。只有当文档有说明时使用，不要自己定义这类变量。 （就是说这些是python内部定义的变量名）
1

Python内置类属性

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
1
2
3
4

！！！需要特殊说明的是 ，在python中没有像其他类似语言的public,private等关键字修饰。同时若方法或者变量是private类型时，其方法或者变量实际上是被转换了，
转换规则是 在变量的前端插入类名,再类名前添加一个下划线"_“,形成”_ClassName__变量名".如果我们使用转换后的变量或者方法，我们仍然可以进行访问，即python没有严格意义上的private类型。

class ClassDef(object):
    _name = 'protected类型的变量'
    __info = '私有类型的变量'
    def __init__(self):
        # public
        self.name = "class_def"

        # private
        self.__age = 29

        # protected
        self._sex = "man"

    def fun1(self):
        print("call public function")

    def __fun2(self):
        print("call private function")

    def _fun3(self):
        print("call protected function")


if __name__ == "__main__":
    # 实例化类对象
    class_def = ClassDef()
    # 调用方法
    # ok
    class_def.fun1()
    class_def._ClassDef__fun2()
    class_def._fun3()
    # 访问数据
    print(class_def._ClassDef__age)
    print(class_def._sex)
    print(class_def.name)

```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
33
34
35
36
37