Python 类的介绍

如何创建类：

class 类名:
     pass

eg:

class Bar:                                        # 定义一个类

    def foo(self, arg):                           # self 永远是调用方法的对象，即中间人
        print(self, self.name, self.age, arg)

obj = Bar()                                       # 使用 Bar 类,创建一个对象 obj
print(obj)
obj.name = 'klvchen'
obj.age = 28
obj.foo(666)

运行结果:
<__main__.Bar object at 0x000001AB792D23C8>
<__main__.Bar object at 0x000001AB792D23C8> klvchen 28 666

创建方法

构造方法: __init__(self, arg)
                 obj = 类(参数)

普通方法：obj = 类(参数)
                  obj.普通方法名()

调用类中的方法

class Foo:
    def bar(self):
        print('bar')

obj = Foo()          # 方法一，常用
obj.bar()

obj = Foo()          # 方法二
Foo.bar(obj)

运行结果：
bar
bar

类中的字段

在类中分为普通字段和静态字段：
普通字段：保存在对象中，执行只能通过对象访问
静态字段：保存在类中，执行可以通过对象访问，也可以通过类访问
eg:

class Province:

    country = 'China'                  # 静态字段

    def __init__(self, name):
        self.name = name               # 普通字段


print(Province.country)

运行结果:
China

类中的三种方法：

1.普通方法：保存在类中，由对象来调用，self 是对象
2.静态方法：保存在类中，由类直接调用
3.类方法 ： 保存在类中，由类直接调用， cls 是当前类
应用场景：
如果对象需要保持一些值，执行某功能时，需要使用对象中的值，选择 普通方法
不需要任何对象中的值选择 静态方法
注:类在内存中只保存一份，可节省系统的内存
eg:

class Foo:
    def bar(self):
        print('bar')

    @staticmethod                     # 静态方法
    def sta():
        print('static method')

    @staticmethod                     # 静态方法，带参数
    def sta2(n):
        print(n)

Foo.sta()
Foo.sta2(666)

运行结果:
static method
666

class Foo:


    @classmethod
    def classmod(cls):             # 类方法, cls 是当前类 Foo
        print(cls)
        print('classmethod')

Foo.classmod()

运行结果:
<class '__main__.Foo'>
classmethod

面向对象三大特性之一: 封装

eg:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        print('%s %d' %(self.name, self.age))


klvchen = Person('陈', 28)             # 生成对象时会自动执行 __init__() 方法
klvchen.show()

运行结果:
陈 28

面向对象三大特性之二: 继承

将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

class Father:
         pass

class Son(Father):
         pass

eg:

class F:
    def f1(self):
        print('F.f1')

    def f2(self):
        print('F.f2')

class S(F):
    def s1(self):
        print('S.s1')

    def f2(self):
        super(S, self).f2()      # 执行父类的 f2 方法
        F.f2(self)               # 执行父类的 f2 方法

obj = S()
obj.f1()
obj.s1()
obj.f2()

运行结果:
F.f1
S.s1
F.f2
F.f2

Python 支持多继承，规则如下：

1.左侧优先
2.一条道做到最后
3.同一根时，根最后执行

eg:

class F1:
    def f(self):
        print('F1.f')


class F2:
    def f(self):
        print('F2.f')


class S(F1, F2):
    pass

obj = S()
obj.f()

运行结果:
F1.f

面向对象三大特性之三: 多态

python 原生就支持多态

添加 @property 后，访问属性时可以制造出和访问字段完全相同的假象

class Foo:
    def bar(self):
        print('bar')

    @property
    def per(self):
        print('123')
        return 1

    @per.setter
    def per(self, val):
        print(val)

    @per.deleter
    def per(self):
        print(888)

obj = Foo()
r = obj.per
#print(r)

obj.per = 666
del obj.per

运行结果:
123

class Foo:

    def f1(self):
        return 123

    def f2(self, val):
        print(val)

    def f3(self):
        print('del')

    per = property(fget=f1, fset=f2, fdel=f3)

obj = Foo()
ret = obj.per
print(ret)
obj.per = 6666
del obj.per

运行结果:
123
6666
del

对象后面加 () 直接调用__call__方法

class Foo:
    def __init__(self):
        print('init')

    def __call__(self, *args, **kwargs):
        print('call')

obj = Foo()
obj()

运行结果:
init
call

__dict__获取对象所有的成员，以字典返回

class Foo:

    def __init__(self, name, age):
        self.name = name
        self.age = age

obj = Foo('klvchen', 28)
d = obj.__dict__
print(d)

运行结果:
{'name': 'klvchen', 'age': 28}