面向对象~~类的成员: 私有成员,公有成员, 实例方法, 类方法, 静态方法, 属性(property), isinstance ,issubclass, 元类(type)

一 私有成员公有成员

• 公有成员: 在任何地方都能访问

• 私有成员: 只有在类的内部才能访问

  类从加载时,只要遇到类中的私有成员,都会在私有成员前面加上_类名

二 实例方法

实例方法就是类的实例能够使用的方法

三 类方法

类方法使用装饰器 @classmethod

类方法: 一般就是通过类名去调用的方法,并且自动将类名地址传给cls,

但是如果通过对象调用也可以,但是传的地址还是类名地址.

class Student:
    count = 0
    def __init__(self,name,id):
        self.name = name
        self.id = id
        Student.stu_num()

    @classmethod
    def stu_num(cls):
        cls.count += 1
    @classmethod
    def get_num(cls):
        print(f'学生的数量是{cls.count}')

xiaohu = Student('小虎',123)
# xiaohu.get_num()
Student.get_num()

类方法作用:

1. 得到类名可以实例化对象.
2. 可以操作类的属性.

四 静态方法

静态方法使用装饰器 @staticmethod。

静态方法是不依赖于对象与类的,不会涉及到类中的属性和方法的操作。可以理解为，静态方法是个独立的、单纯的函数

保证代码的规范性,合理的划分.后续维护性高.

import time

class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())

print(TimeTest.showTime())
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print(nowTime)

五 属性 property

将动态方法 伪装 成了一个属性,虽然在代码级别上没有什么提升,但是让你看起来更合理.

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')
#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA  # 执行property
f1.AAA='aaa' # 执行AAA.setter
del f1.AAA  # 执行AAA.deleter

class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA)
    #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

六 isinstance issubclass

isinstance(a,B)：判断a是否是B类（或者B类的派生类）实例化的对象

issubclass(A,B)： 判断A类是否是B类（或者B的派生类）的派生类

七 元类type

获取该对象从属于的类

print(type('abc'))

Python原则是：一切皆对象，其实类也可以理解为'对象',而type元类又称作构建类，python中大多数内置的类（包括object）以及自己定义的类，都是由type元类创造的。

type类与object类之间的关系比较独特：object是type类的实例，而type类是object类的子类，这种关系比较神奇无法使用python的代码表述，因为定义其中一个之前另一个必须存在。