Oort.

0%

【Python笔记】类与对象

发表于
本文字数： 6.3k 阅读时长 ≈ 6 分钟
Python学习笔记

1、类得定义与实例化

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
""" 类的定义与实例化 """
from ast import Mult
from tool import topic


class MyClass:
    """ 自定义类 """
    x = 10

    def __init__(self) -> None:
        self.y = 0
        pass

    def func(abcd) -> str:
        return f"x={abcd.x}, y={abcd.y}"

    @staticmethod
    def static_method(str):
        # print(f"In MyClass.static_method, x={x}")
        print(f"In MyClass.static_method, str='{str}'")
        pass

    @classmethod
    def class_method(cls):
        print(f"In MyClass.static_method, x={cls.x}")
        pass


@topic("Demo-1")
def demo_1():
    """ 类的类型 """
    print(MyClass)
    print(type(MyClass))
    pass


@topic("Demo-2")
def demo_2():
    """ 类成员变量与方法的调用 """
    obj = MyClass()
    print(MyClass.x)
    # print(MyClass.func())
    MyClass.static_method("Class Call")
    MyClass.class_method()

    print(f"x={obj.x}")
    print(obj.func())
    obj.static_method("Object Call")
    obj.class_method()


    # 新增成员变量
    obj.z = 100
    print(f"obj.z={obj.z}")
    MyClass.v = 1000
    print(f"obj.v={obj.v}")
    print(f"MyClass.v={MyClass.v}")
    pass


@topic("Demo-3")
def demo_3():
    """ 删除成员变量与函数 """
    obj = MyClass()
    del MyClass.x
    del obj.y
    # print(obj.x)
    # print(obj.y)
    del MyClass.func
    # del obj.func
    # print(obj.func())
    pass


if __name__ == "__main__":
    demo_1()
    demo_2()
    demo_3()
    pass

2、类的内置函数与重载

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
""" 类的内置函数与重载 """


class MyClass:
    """ 自定义类 """

    def __init__(self) -> None:
        self.x = 0
        self.y = 0
        pass


class AnotherClass:
    """ 另一个自定义类 """

    def __init__(self) -> None:
        self.val = 0
        pass

    def __str__(self) -> str:
        return f"val={self.val}"

    def __eq__(self, __o: object) -> bool:
        return self.val == __o.val

    def __ne__(self, __o: object) -> bool:
        return self.val != __o.val

    def __le__(self, __o: object) -> bool:
        return self.val <= __o.val

    def __ge__(self, __o: object) -> bool:
        return self.val >= __o.val

    def __lt__(self, __o: object) -> bool:
        return self.val < __o.val

    def __gt__(self, __o: object) -> bool:
        return self.val > __o.val


def demo_1():
    """ 类的内置变量与函数 """
    obj = MyClass()
    other_obj = MyClass()
    print(dir(obj))

    # 内置变量
    print(obj.__dict__)
    print(obj.__doc__)

    # 内置函数
    # obj.__init__()
    # obj.__str__()
    # obj.__eq__(other_obj)
    # obj.__ne__(other_obj)
    # obj.__le__(other_obj)
    # obj.__ge__(other_obj)
    # obj.__lt__(other_obj)
    # obj.__gt__(other_obj)
    pass


def demo_2():
    """ 类的函数重载 """
    obj1 = AnotherClass()
    obj2 = AnotherClass()

    print(obj1)

    obj1.val = 1
    obj2.val = 1
    print(obj1 == obj2)
    print(obj1 != obj2)
    print(obj1 >= obj2)
    print(obj1 <= obj2)
    print(obj1 > obj2)
    print(obj1 < obj2)
    pass


if __name__ == "__main__":
    demo_1()
    demo_2()
    pass

3、继承

3.1、单继承

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
46
47
48
49
50
51
52
53
""" 继承 """


class A:
    y = 100

    def __init__(self) -> None:
        self.x = 10
        pass

    def func_A(self):
        print("func_A in Class A.")
        return


class B(A):
    pass


class C(A):

    # def __init__(self) -> None:
    #     super().__init__()

    def func_A(self):
        print("func_A in Class C.")


def demo_1():
    a = A()
    b = B()
    c = C()

    a.func_A()
    b.func_A()
    c.func_A()
    pass


def demo_2():
    a = A()
    b = B()
    c = C()

    print(c.x)
    print(c.y)
    pass


if __name__ == "__main__":
    demo_1()
    demo_2()
    pass

3.2、多继承

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
""" 多继承 """


class A:
    z = 10

    def __init__(self) -> None:
        self.x = 0

        pass

    def func_A(self):
        print("func_A in Class A.")
        return


class B:
    z = 100

    def __init__(self) -> None:
        self.y = 0
        pass

    def func_A(self):
        print("func_A in Class B.")
        return


class C(A, B):

    # def __init__(self) -> None:
    #     super().__init__()

    def func_C(self):
        print(f"x={self.x}")
        # print(f"y={self.y}")
        print(f"z={self.z}")
        pass

    def func_CC(self):
        # print(f"super.x={super().x}")
        # print(f"super.y={super().y}")
        print(f"super.z={super().z}")
        pass


def demo_1():
    c = C()

    c.func_A()
    c.func_C()
    c.func_CC()
    pass


class D(A, B):

    def __init__(self) -> None:
        B.__init__(self)

    def func_D(self):
        # print(f"x={self.x}")
        print(f"y={self.y}")
        print(f"z={self.z}")
        pass

    def func_DD(self):
        # print(f"super.x={super().x}")
        # print(f"super.y={super().y}")
        print(f"super.z={super().z}")
        pass

    def func_DDD(self):
        print(f"A.z={A.z}")
        print(f"B.z={B.z}")
        pass


def demo_2():
    d = D()
    d.func_D()
    d.func_DD()
    d.func_DDD()
    pass


if __name__ == "__main__":
    demo_1()
    demo_2()
    pass

多继承

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
class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

class E:
    pass

class F(E, D):
    pass

class G(F, D):
    pass

class H:
    pass

class Foo(H, G):
    pass

4、元类

类与元类

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
""" 元类 
MyClass = MetaClass()
my_object = MyClass() 
"""


class A:
    a = 10

    def func_A():
        print("In Class A.")


class B:
    b = 100

    def func_B():
        print("In Class B.")


class C(A, B):
    c = 1000

    def func_C(self):
        print("In Class C.")

    @staticmethod
    def static_method(str):
        print(f"In C.static_method, str='{str}'.")
        pass

    @classmethod
    def class_method(cls):
        print(f"In C.class_method, c={cls.c}.")
        pass


def func_C(self):
    print("In global function func_C.")
    pass


@staticmethod
def static_method(str):
    print(f"In global function static_method, str='{str}'.")
    pass


@classmethod
def class_method(cls):
    print(f"In global function class_method, c={cls.c}.")
    pass


def demo_1():
    c = C()
    c.func_C()
    c.static_method("Hello.")
    c.class_method()
    pass


def demo_2():
    C = type(
        "C", (A, B), {
            "c": 1000,
            "func_C": func_C,
            "static_method": static_method,
            "class_method": class_method
        })

    c = C()
    c.func_C()
    c.static_method("Hello.")
    c.class_method()
    pass


if __name__ == "__main__":
    demo_1()
    demo_2()
    pass
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
""" 自定义元类 """


def my_meta_class(class_name, class_parents, class_attr):
    """ 自定义元类
    将类中非"__"开头的属性改为大写
    """
    new_attr = {}
    for name, value in class_attr.items():
        if not name.startswith("__"):
            new_attr[name.upper()] = value
        pass
    return type(class_name, class_parents, new_attr)


class A(object, metaclass=my_meta_class):
    a = 1

    def func_A(self):
        pass

    pass


def demo_1():
    a = A()
    print(type(A))
    print(A.__dict__)
    pass


class MyMetaClass(type):

    def __new__(cls, class_name, class_parents, class_attr):
        new_attr = {}
        for name, value in class_attr.items():
            if not name.startswith("__"):
                new_attr[name.upper()] = value
            pass
        return type(class_name, class_parents, new_attr)


class B(metaclass=MyMetaClass):
    b = 1

    def func_B(self):
        pass

    pass


def demo_2():
    a = B()
    print(type(B))
    print(B.__dict__)
    pass


if __name__ == "__main__":
    demo_1()
    demo_2()
    pass