Python中的类（面向对象）（二）

类的成员：

1.字段：普通字段、静态字段

2.方法：普通方法、静态方法、类方法

 

class example:
    school = '李四小学'    # 这是一个静态字段
    def __init__(self,name):
        self.name = name 这是一个普通字段

    # add()这是一个普通方法
    def add(self):
        print('123456')

    # 只要在方法上加 @staticmethod ，那它就是一个静态方法，不需要加self
    @staticmethod
    def foo():
        print('我是静态方法')

    # 在方法上面加 @classmethod，那他就是一个类
    @classmethod
    def clsm(cls):
        print('我是类方法')

ret = example('张三')    # 创建对象

# 通过对象调用普通字段
print(ret.name)   # 输出：张三

# 通过类调用静态字段
print(example.school)    # 输出：李四小学

# 通过对象调用方法
ret.add()    # 输出：123456

# 通过类直接调用方法
example.add(ret)    # 输出：123456

# 通过类直接调用静态方法
example.foo()   # 输出：我是静态方法

# 通过类直接调用类方法
example.clsm()  # 输出：我是类方法

        方法要加括号才可以进行访问，然而字段不加括号就可以访问，普通字段保存在对象中，静态字段保存在类中。

        如果出现大量需要重复的对象，为了防止其占内存，可以写为静态字段或者方法，用类来调用，调用时括号中需要给传对象。也可以通过对象去直接调用。

        只要是静态方法，self就可以不加，就可以通过类去直接调用它，不需要再往里加对象了。如果需要传参数，就在后面加个括号，然后往里写参数就可以了。

        类方法的括号中必须要有一个参数，并且默认要写cls（表示当前类），它在执行的时候，python会自动在它里面传入类名example。 

---

 类的属性

class example:
    @property
    def foo(self):
        print('123123')
        return 111

    # 通过方法名加setter来修改这个属性
    @foo.setter
    def foo(self,val):
        print(val)

obj = example()
n = obj.foo    # 输出：123123
print(n)    # 输出：111

obj.foo = 789789   # 输出：789789

         上面代码中，foo是一个方法，但是调用它是，却又像在调用字段，这种既想字段，又像方法的东西，叫做类的属性。

        可以通过 方法名.setter 来修改这个属性。

---

额外内容

class example:

    def foo_1(self):
        print('123')

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

    def foo_3(self):
        print('del')
    
    add = property(fget=foo_1,fset=foo_2,fdel=foo_3)

obj = example()

obj.add   # 输出：123
obj.add=45679   # 输出：45679
del obj.add    # 输出：del

        property()这个函数有三个参数，给它赋值了一个对象add，当去直接调用add时，会去执行第一个参数中的内容，也就是拿值。当给add赋值的时候，会执行第二个参数的方法。当删除add时，会取执行第三个参数的方法。详情去看参数名及源码。

---

成员修饰符

1.公有成员：普通字段、静态字段、方法、类方法，这些可以直接调用的，就是公有成员。

2.私有成员：在公有成员的前面加上两个下划线，就变成了私有成员

class example:
    school = '张三中学'   # 公有成员

    def __init__(self,name):
        self.name = name  # 公有成员
        self.__age = 18   # 私有成员

    def __aaa(self):    # 私有成员
        print('我是私有方法')

    def show(self):   # 这个方法是用来调用私有成员的
        b = print(self.__age)
        c = self.__aaa()
        return b,c

obj = example('李四')   # 创建对象
print(obj.name)     # 调用共有成员  输出：李四

# print(obj.__age)       # 调用私有成员  输出：AttributeError: 'example' object has no attribute '__age'
# obj.__aaa()     # 调用私有方法  输出：AttributeError: 'example' object has no attribute '__aaa'

obj.show()  # 执行show方法  输出：18
#                               我是私有方法

        从上面代码可以看出，我们可以通过对象，直接去调用公有成员，但是通过对象直接去调用私有成员的时候会报错，如果在写程序时，有不想让人渠道的东西，就可以使用私有成员，让外部无法调用。

        如果想去调用私有成员，可以通过间接方法去调用，上述代码中写了一个show()方法，就可以通过它去拿到私有成员。

        私有成员只会存在于类的内部，如果出了类，就没法获取到了。例如在子承父类时，子类是无法获取父类中的私有成员的，如果想要获取，只能在父类中创建方法去取私有成员。

---

类的特殊成员

        只要是双下划线开头并且双下划线结尾的，都是特殊方法

class example:

    def __init__(self):
        print('我是初始化函数')

    def __call__(self):
        print('我是call方法')

    def __int__(self):
        return 123

    def __str__(self):
        return '张三'

    def __getitem__(self, item):
        return item+50


obj = example()     # 创建对象  输出：我是初始化函数

obj()    # 等价于example()()  ,用来调用__call__方法  输出：我是call方法

print(int(obj))    # 用来调用int方法   # 输出：123

print(str(obj))    # 用来调用str方法   # 输出：张三

print(obj[20])     # 用来调用getitem方法   # 输出：70

1.当执行 类名() 时，__init__ 方法会自动执行

2.当执行 类名()() 时，__call__ 方法会自动执行

3.当执行 int(obj) 时，会自动执行 __init__ 方法，当执行 str(obj) 时，会自动执行 __str__ 方法

4.当给对象加一个中括号，会自动执行 __getitem__ 方法