登录
Python中的类和对象
未完待续
1.定义类
python3中的根类，有且只有一个：object（小写）
⚠️大写的Object不存在于python内置中，是自己定义的，为防止混淆不建议使用
__bases__是python中一个内置的变量，代表基类
# 隐式继承，python3自动处理class Cat: pass# 显式继承class Dog(object): passif __name__ == '__main__': print( Cat.__bases__ ) # (<class 'object'>,) print( Dog.__bases__ ) # (<class 'object'>,)2.类的成员
2.1 构造方法
- python初始化类的对象，使用
__init__()这个特殊方法作为类的构造方法，创建对象时会被自动调用。 - python构造方法不支持重载，不能弄多个
__init__()，否则最后一个覆盖前面的。
构造方法就是一种实例方法，实例方法第一个参数必须是
self代表当前对象
class Cat: def __init__(self): print('init') print(self) print(self.__class__)if __name__ == '__main__': cat = Cat() print(cat)init<__main__.Cat object at 0x000001982BE1D400><class '__main__.Cat'><__main__.Cat object at 0x000001982BE1D400>2.2 类和实例的属性
- 实例属性在构造器
__init__中声明，__init__()中通过self.定义实例属性 - 定义在类以内，
__init__()以外的属性是类属性，类似Java中的static - 实例属性和类属性不同名时，实例属性通过
对象.访问，类属性可以通过类.访问或对象.访问 - 实例属性和类属性同名是合法但是不推荐的，这种情况下，实例和类会各自有一份，
对象.访问到的是实例属性，类属性只能通过类.访问
⚠️
__init__()外面的同名属性前面没有static且和self.后面的属性名重名时，self.极易被Java程序员误判为是在为外面的属性初始化或赋值，这种Java的思路，在python中是错误的
例：
__init__()里面的重名name，age是实例属性，通过对象.访问__init__()外面的重名name，age是类属性，通过类.访问country属性不重名，可通过对象.访问，也可以通过类.访问
class Stu: name = 'simaple_name' age = 0 country = 'China' def __init__(self, age, name): print('init') self.age = age self.name = name def speak(self): print(self.age, self.name)if __name__ == '__main__': stu1 = Stu(18, '元宝') stu2 = Stu(20, '大黄') stu1.speak() stu2.speak() print('---------------') print(Stu.name) print(Stu.age) print('-------------') print(stu1.country) print(stu2.country) print(Stu.country)initinit18 元宝20 大黄---------------simaple_name0-------------ChinaChinaChina有时候，一个类存在属性过多，逐一用参数赋值会很复杂，例如：
def __str__(self)同样是一个内置函数，类似Java中的toString()，打印对象时转换为字符串- 双下划线
__开头的属性，属于私有属性，类外不可直接访问
class Stu: def __init__(self, name, age, no, score): self.name = name self.age = age self.no = no self.__score = score def __str__(self): return f'{self.name}, {self.age}, {self.no}, {self.__score}'if __name__ == '__main__': stu1 = Stu('liming', 16, 10001, 100) print(stu1) print(stu1.name) print(stu1.age) print(stu1.no) #print(stu1.__score) ❌错误 AttributeError: 'Stu' object has no attribute '__score'liming, 16, 10001, 100liming1610001python是一门灵活的语言！解决这个问题，可以动态的给某个对象设置属性，例如为stu2动态指定一个属性no
self.__dict__可以代表对象所有属性
class Stu: def __init__(self, name, age, score): self.name = name self.age = age self.__score = score def __str__(self): return f'{self.__dict__}'if __name__ == '__main__': stu1 = Stu('liming', 16, 100) print(stu1) stu2 = Stu('liming', 16, 100) stu2.no = '10002' print(stu2){'name': 'liming', 'age': 16, '_Stu__score': 100}{'name': 'liming', 'age': 16, '_Stu__score': 100, 'no': '10002'}上面的写法不推荐，可以采用定义好再去赋值的写法
class Stu: def __init__(self): self.name = None self.age = None self.no = None def __str__(self): return f'{self.__dict__}'if __name__ == '__main__': stu1 = Stu() print(stu1) stu2 = Stu() stu2.age = 12 stu2.no = '123' stu2.name = 'sxh' print(stu2){'name': None, 'age': None, 'no': None}{'name': 'sxh', 'age': 12, 'no': '123'}还可以通过可变参数
class Stu: def __init__(self, **kwargs): self.name = kwargs.get('name', None) self.age = kwargs.get('age', None) self.no = kwargs.get('no', None) def __str__(self): return f'{self.__dict__}'if __name__ == '__main__': stu1 = Stu(name='lzj', age=19, no='10002') print(stu1) stu2 = Stu(name='xiaohong', age=19 ) print(stu2){'name': 'lzj', 'age': 19, 'no': '10002'}{'name': 'xiaohong', 'age': 19, 'no': None}2.3 成员访问限制
在python中，属性可以进行访问权限控制，和Java类似，如果要访问受保护的属性，就定义方法，这是类封装性的体现
- 受保护的属性
_单个下划线开头，仅仅起到提醒作用，但是不阻止访问，例如_age - 私有属性
__双下划线开头，类外不可访问，否则程序运行出错，例如__age - 公开访问属性 没有下划线的，无限制
- 魔法属性 是python内置的，有特殊的含义，不可自行定义，例如
__dict__
⚠️
__双下划线不可访问的底层实现，实际上是将该变量替换成了_类名__私有变量名，通过将某个私有变量名修改为_类名__私有变量名的形式，可以突破访问控制，这种访问方式极不推荐
例：
class Stu: def __init__(self, **kwargs): self.name = kwargs.get('name', None) self.__age = kwargs.get('age', None) self._no = kwargs.get('no', None) def __str__(self): return f'{self.__dict__}' def getAge(self): return self.__ageif __name__ == '__main__': stu1 = Stu(name='lzj', age=19, no='10002') print(stu1) print(stu1.name) print(stu1.getAge()) print(stu1._no) #不建议的 print(stu1._Stu__age) #不建议的 #print(stu1.__age) #运行出错{'name': 'lzj', '_Stu__age': 19, '_no': '10002'}lzj1910002192.4 静态方法
上面例子里面出现在类中，参数以self开头的方法，都是实例方法，在python中，还存在静态方法和类方法
在python中，有一种方法，只是出现在类中，但是不依赖于实例和类的普通方法，叫做静态方法，采用@staticmethod装饰器装饰，通常都是作为一种工具方法，除非传入否则不能访问类和实例的成员，可以使用实例名或类名调用，但是参数列表中不能出现self或cls
例：def sum(a, b)就是静态方法
class Stu: def __init__(self): name = None def call(self): self.sum(1, 2) self.__class__.sum(3, 4) Stu.sum(5, 6) @staticmethod def sum(a, b): return a + bif __name__ == '__main__': stu1 = Stu() stu1.call() stu1.sum(7, 8) Stu.sum(9, 10)2.5 类方法
类方法类似Java中的static方法，python的类方法声明时第一个形参永远是cls代表类本身（不是实例），同时除__new__()以外，所有类方法都要采用@classmethod函数装饰器修饰。
python的类方法既能通过类也能通过实例调用，但是为防混淆不建议用实例调用。
主要用于操作类属性或实现工厂模式。
可直接访问类属性，类方法和静态方法，不能直接操作实例属性或实例方法。
例：
class Stu: school = 'bupt' def __init__(self): name = None def call(self): pass @classmethod def classfunc1(cls): print(cls.__name__) print(cls.school) cls.sum(1, 2) cls.classfunc2() @classmethod def classfunc2(cls): print('classfunc2') @staticmethod def sum(a, b): return a + bif __name__ == '__main__': Stu.classfunc1() s1 = Stu() s1.classfunc2() s1.__class__.classfunc2()Stubuptclassfunc2classfunc2classfunc23.对象初始化
python对象初始化o = Obj()，会经历以下几个过程：
1.调用该Obj类的__new__(cls,...)方法，在内存中开辟空间，创建一个空的实例对象
2.__new__(cls,...)执行完成，必须返回一个当前Obj类的实例对象，就是后续的self
3.python自动把返回的对象，传给__init__(self,...)的第一个参数self
4.调用__init__(self,...)给这个空对象绑定属性，初始化数据
5.返回初始化完成的实例对象给变量o
其中：
__new__(cls,...)是类方法，但是无需显式添加@classmethod装饰器__new__(cls,...)必须有返回值，返回当前类对象时执行__init__(self,...)，返回None则跳过__init__(self,...)__new__(cls,...)的时机一定早于__init__(self,...)，先创建再初始化- 永远不要出现多个生效的
__init__(self,...)
