打开APP
userphoto
未登录

开通VIP，畅享免费电子书等14项超值服

开通VIP

首页

好书

留言交流

下载APP

联系客服
Python进阶知识
userphoto
nxhujiee  >《◆python》

2023.04.24 宁夏

关注

二、面向对象编程

oop三大特征：继承、多态、封装

1、概念

面向过程：一开始学习的，按照解决问题的步骤编程【根据业务逻辑从上到下编程】

函数式：将某功能代码封装到函数中，下次使用直接调用，无需重复编写

面向对象编程：将数据与函数绑在一起封装，这样能够更快速的开发程序，减少重复代码的重写过程 oop（object oriented programming），是一种解决软件复用的设计和编程方法，这种方法将软件系统中相近相似的操作逻辑和操作应用数据、状态，以类的形式描述出来，以对象实例的形式在软件系统中复用，以达到提高软件开发效率的作用

面向过程适合做小项目，面向对象适合做大项目

2、类和对象

2.1 概念

类：一个模板，模板里包含多个函数，函数中实现一些功能（汽车图纸、车类）

是一组具有相同或相似属性和行为的多个对象的组合

对象：类的实例化，可以执行类中的函数（宝马）

2.2 定义类和创建对象

定义类：类结构=类名（首字母大写）+属性+方法行为

实例方法：在类内部，用def可以定义实例方法，与一般函数不同的是实例方法必须包含参数，默认第一个参数是self（名字标识可以是其他名字，但这个位置必须被占用）

  1. # class 类名：
  2. #     属性
  3. #     方法
  4. class Person:#类名：首字母大写
  5.     #属性
  6.     name='小明'#类属性
  7.     age=20
  8.     #方法（行为） 实例方法
  9.     def eat(parms):
  10.         parms.name='小红'#实例属性
  11.         print('eating')
  12.         pass
  13.     def run(self):
  14.         print('running')
  15.         pass
  16.     pass

创建对象：

格式：对象名=类名（）

  1. #创建对象[类的实例化]
  2. xm=Person()
  3. #调用函数
  4. xm.eat()
  5. print('{}的年龄是：{}岁'.format(xm.name,xm.age))

属性：

  • 类属性：类对象所拥有的属性（定义在类内部，实例方法外）
  • 实例属性：实例对象拥有的属性，只能通过实例对象访问（实例方法内定义的【通过类似于self.变量名】变量）
  1. class Student:
  2.     name='李明'#类属性
  3.     def __init__(self,age):
  4.         self.age=age#实例属性
  5.         pass
  6.     pass
  8. lm=Student(18)
  9. print(Student.name)
  10. print(lm.name)#类属性可以被类对象和实例对象访问
  11. print(lm.age)#实例属性只能通过实例对象访问
  12. print('不能通过类对象访问实例属性')
  13. print(Student.age)
  15. # 李明
  16. # 李明
  17. # 18
  18. # 不能通过类对象访问实例属性
  19. # Traceback (most recent call last):
  20. #   File "E:\资源下载\workspace\shixun\pythonProject2\2.17多态.py", line 47, in <module>
  21. #     print(Student.age)
  22. # AttributeError: type object 'Student' has no attribute 'age'

类属性和实例属性的访问原理：

2.3  __init__(self):

Python自带的内置函数

是一个初始化方法，用来定义实例属性和初始化数据，在创建对象时自动调用

  1. class Person:
  2.     def __init__(self):
  3.         self.name='小倩'
  4.         self.age=20
  5.     def run(self):
  6.         print('running')
  7.         pass
  8.     pass
  10. xq=Person()#创建新对象时，__init__自动调用
  11. print(xq.name)
  12. #小倩

传递参数（后面实例方法都可以直接使用该参数）

  1. class Person:
  2.     def __init__(self,name,age):
  3.         self.name=name
  4.         self.age=age
  5.     def eat(self,food):
  6.         print(self.name+'喜欢吃'+food)
  8. xm=Person('小明',21)
  9. xm.eat('苹果')

2.4 self的理解

self和对象指向同一内存地址，self是对象的引用，可以理解为对象自己

  1. class Person:
  2.     def eat(self):
  3.         print('self=%s',id(self))
  4.         pass
  5.     pass
  7. xm=Person()
  8. xm.eat()
  9. print('xm=%s',id(xm))
  10. #self=%s 1760559500112
  11. #xm=%s 1760559500112
  • self只有在类中定义实例方法时才有意义，在调用时不必传入相应参数，而是由解释权自动指向
  • self的名称可以更改，只是约定俗成的定义成了self
  • self指的是类实例对象本身

self传参：

  1. class Person:
  2.     def __init__(self,pro):
  3.         self.pro=pro
  4.     def eat(self,name,food,pro):
  5.         print('%s喜欢吃%s，修的专业是%s,%s'%(name,food,self.pro,pro))
  6.         pass
  7.     pass
  9. xm=Person('通信工程')
  10. xm.eat('小明','榴莲','hhh')
  11. # 小明喜欢吃榴莲，修的专业是通信工程,hhh

3、魔术方法

定义：Python中的一些内置好的特定方法，方法名为“__xxx__”，前后有两个下划线

  • 在进行特定操作时，魔术方法会自动调用

常见的魔术方法：

3.1__str__()

定义了__str__方法，在打印对象时，会执行__str__方法（__str__只能return一个字符串）

  1. class Animal:
  2.     def __init__(self,name,colour):
  3.         self.name=name
  4.         self.colour=colour
  5.     def __str__(self):
  6.         return '我的名字是%s，我的颜色是%s'%(self.name,self.colour)
  8. dog=Animal('旺财','白色')
  9. print(dog)
  10. #我的名字是旺财，我的颜色是白色
  11. #改变打印对象的内容
  13. class Animal:
  14.     def __init__(self,name,colour):
  15.         self.name=name
  16.         self.colour=colour
  18. dog=Animal('旺财','白色')
  19. print(dog)
  20. # <__main__.Animal object at 0x000001E49FEF6FD0>
  21. #直接输出对象的地址

3.2 __new__()

调用对象实例的方法，每调用一次生成一个新对象，cls是class的缩写

  1. class Animal(object):
  2.     def __init__(self,name,colour):
  3.         self.name=name
  4.         self.colour=colour
  5.         print('__init__函数执行')
  6.     def __str__(self):
  7.         return '我的名字是%s，我的颜色是%s'%(self.name,self.colour)
  8.     def __new__(cls, *args, **kwargs):
  9.         print('__new__函数执行')
  10.         # return object.__new__(cls)#这里真正创建对象实例
  12. dog=Animal('旺财','白色')
  13. print(dog)
  14. #__new__函数执行
  15. #None
  16. #解释：还没有生成对象实例
  1. class Animal(object):
  2.     def __init__(self,name,colour):
  3.         self.name=name
  4.         self.colour=colour
  5.         print('__init__函数执行')
  6.     def __str__(self):
  7.         return '我的名字是%s，我的颜色是%s'%(self.name,self.colour)
  8.     def __new__(cls, *args, **kwargs):
  9.         print('__new__函数执行')
  10.         return object.__new__(cls)#这里真正创建对象实例
  11. #        return super().__new__(cls)#若没有父类object,用super()创建对象实例
  13. dog=Animal('旺财','白色')
  14. print(dog)
  15. # __new__函数执行
  16. # __init__函数执行
  17. # 我的名字是旺财，我的颜色是白色
  19. #先执行__new__()，创建对象实例后执行__init__
  20. #__new__()创建实例框架，__init__丰满

__new__方法在__init__方法前执行

__new__方法不能调用自己的__new__方法，即：return cls.__new__(cls)

  • 否则会报错：RecursionError:maximum recursion depth exceeded超过最大递归深度

__new__和__init__的区别

  • __new__：类的实例化方法，必须返回该实例，不然对象创建不成功
  • __init__：做对象的初始化工作，也可以认为是实例的构造方法，接受该实例self并对其构造
  • __new__至少一个参数是cls，代表要实例化的类，该参数在实例化时由Python解释器自动提供
  • __new__要早于__init__函数执行

课后问答

4、析构方法

当一个对象被删除或销毁时，Python解释器默认调用__del__()方法，这个方法也称析构方法，也是一种魔术方法

  • 用于对象的释放，对象一旦被释放，不能再使用

程序执行结束自动调用__del__()

  1. class Animal:
  2.     def __init__(self,name):
  3.         self.name=name
  4.         print('__init__执行')
  5.     def __del__(self):
  6.         print('__del__执行')
  7.     pass
  9. cat=Animal('cat')
  10. print('程序等待中。。。')
  12. # __init__执行
  13. # 程序等待中。。。
  14. # __del__执行

对象被删除时，也会自动调用__del__方法

  1. class Animal:
  2.     def __init__(self,name):
  3.         self.name=name
  4.         print('__init__执行')
  5.     def __del__(self):
  6.         print('__del__执行')
  7.     pass
  9. cat=Animal('cat')
  10. del cat#手动去清理对象
  11. print('*'*20)
  13. # __init__执行
  14. # __del__执行
  15. # ********************

5、类的继承*

Python面向对象的三大特征：封装、继承、多态

封装：把内容封装到某个地方，便于后面的使用【其实就是使用初始化构造方法将内容封装到对象中，然后通过对象直接或者self来获取封装的内容】

继承：即子可以继承父的内容（属性和行为）

  • 将多个类共有的方法提取到【父类】中，然后通过继承，极大提高了效率，减少代码的重复编写

5.1 单继承

  1. class Animal:
  2.     def eat(self):
  3.         print('eating')
  5. class Cat(Animal):
  6.     pass
  9. cat1=Cat()
  10. cat1.eat()
  11. #eating

5.2 多继承

子类继承多个父类，用逗号分隔  class C(A,B)

问题是：当多个父类中存在相同方法时，应该调用哪一个呢？

  1. class E:
  2.     def eat(self):
  3.         print('E.eat')
  4. class D:
  5.     def eat(self):
  6.         print('D.eat')
  7. class C(E):
  8.     # def eat(self):
  9.     #     print('C.eat')
  10.         pass
  11. class B(D):
  12.     pass
  13. class A(B,C):
  14.     pass
  16. a1=A()
  17. a1.eat()#查找顺序，A中没有，找B，B中没有，找C
  18. print(A.__mro__)
  19. # D.eat
  20. # (<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class 'object'>)

__mro__方法：查询执行顺序

继承的传递性：爸爸继承了爷爷，儿子继承爸爸，也继承了爷爷

5.3 重写和调用父类方法

子类中有个跟父类方法名称一样的方法，相当于重写父类方法（方法覆盖）

重写父类方法后，子类调用父类方法时，调用的是子类的方法

  1. class Father:
  2.     def eat(self):
  3.         print('爸爸')
  4.     pass
  6. class Son(Father):
  7.     def eat(self):
  8.         print('儿子')
  9.     pass
  10. son=Son()
  11. son.eat()
  12. print(Son.__mro__)
  13. # 儿子
  14. # (<class '__main__.Son'>, <class '__main__.Father'>, <class 'object'>)

调用父类方法

  1. class Dog:
  2.     def __init__(self,name,color):
  3.         self.name=name
  4.         self.color=color
  5.     def bark(self):
  6.         print('汪汪汪。。')
  8. class Keji(Dog):
  9.     def __init__(self,name,color,age):#重写父类方法
  10.         # Dog.__init__(self,name,color)#调用父类方法1--手动调用
  11.         super().__init__(name,color)#调用父类方法2--自动调用：super()自动查找父类方，进而调用方法
  12.         self.age=age
  13.     def dark(self):
  14.         print('啊啊啊。。')
  15.         super().bark()#调用父类方法
  16.         print('啊啊啊。。')
  17.     def msg(self):
  18.         print('名字：%s，颜色：%s，年龄：%s'%(self.name,self.color,self.age))
  20. keji=Keji('柯基','黄白',2)
  21. keji.dark()
  22. keji.msg()
  23. # 啊啊啊。。
  24. # 汪汪汪。。
  25. # 啊啊啊。。
  26. # 名字：柯基，颜色：黄白，年龄：2

super()：假如继承了多个父类，则会按顺序查找

  1. class Animal:
  2.     def bark(self):
  3.         print('动物叫。。')
  5. class Keji(Animal,Dog):
  6.     def __init__(self,name,color,age):#重写父类方法
  7.         # Dog.__init__(self,name,color)#调用父类方法1
  8.         super().__init__(name,color)#调用父类方法2：super()自动查找父类方，进而调用方法
  9.         self.age=age
  10.     def dark(self):
  11.         print('啊啊啊。。')
  12.         super().bark()#调用父类方法
  13.         print('啊啊啊。。')
  14.     def msg(self):
  15.         print('名字：%s，颜色：%s，年龄：%s'%(self.name,self.color,self.age))
  17. keji=Keji('柯基','黄白',2)
  18. keji.dark()
  19. keji.msg()
  20. # 啊啊啊。。
  21. # 动物叫。。
  22. # 啊啊啊。。
  23. # 名字：柯基，颜色：黄白，年龄：2

6、多态

定义：就是多种状态（形态），就是同一种行为，对于不同子类【对象】有不同的行为表现

想实现多态必须满足的两个条件：

  1. 继承：多态必须发生在父态和子态之间
  2. 重写：子类重写父类方法

作用：增加程序的灵活性和扩展性

鸭子类型：在程序设计中，鸭子类型是动态类型的一种风格。“鸭子测试”可以表述为：“当一个鸟走起来像鸭子，叫起来像鸭子，那么这只鸟可以称为鸭子”

  1. class Animal:
  2.     def say(self):
  3.         print("动物叫")
  4.     pass
  6. class Dog(Animal):
  7.     def say(self):
  8.         print('汪汪汪')
  9.     pass
  10. class Cat(Animal):
  11.     def say(self):
  12.         print('喵喵喵')
  13.     pass
  15. # dog=Dog()
  16. # dog.say()
  17. # cat=Cat()
  18. # cat.say()
  20. def common(obj):
  21.     obj.say()
  22. i=[Dog(),Cat()]
  23. for item in i:
  24.     common(item)
  25. # 汪汪汪
  26. # 喵喵喵

7、类方法和静态方法

类方法：类对象所拥有的方法，用装饰器@classmate标识，类方法的第一个参数必须是类对象，一般以cls作为第一个参数。

可以通过类对象、实例对象调用

  1. class Student:
  2.     name='李华'#类属性
  4.     @classmethod
  5.     def get_name(cls):
  6.         return cls.name#访问类属性
  8.     @classmethod
  9.     def change_name(cls,new_name):
  10.         cls.name=new_name#在类方法中修改类属性的值
  13. print(Student.get_name())#类对象引用
  14. lh=Student()
  15. print(lh.get_name())#实例对象引用
  16. # 李华
  17. # 李华
  18. Student.change_name("小花")
  19. print(Student.get_name())#类对象引用
  20. xh=Student()
  21. print(xh.get_name())#实例对象引用
  22. # 小花
  23. # 小花

静态方法：类对象所拥有的方法，需要用@staticmethod来表示静态方法

  1. class Student:
  2.     name='李华'#类属性
  3.     @staticmethod
  4.     def getdate():
  5.         return  Student.name
  7. print(Student.getdate())#类对象引用
  8. lh=Student()
  9. print(lh.getdate())#实例对象引用
  10. # 李华
  11. # 李华

静态方法一般不会通过实例对象访问

为什么使用静态方法？

静态方法主要用来存放逻辑性代码，在静态方法中，不会涉及到类中方法和属性的操作，数据资源能得到有效利用

  1. #引入第三方时间模块
  2. import time
  3. class Timetest:
  4.     @staticmethod
  5.     def showtime():
  6.         return time.strftime("%H:%M:%S",time.localtime())
  7.     pass
  9. print(Timetest.showtime())
  10. # 15:46:56
  • 类方法的第一个参数是类对象cls，进而去引用类对象的属性和方法
  • 实例方法的第一个参数必须是self，通过self去引用类属性或实例属性，若存在相同名称实例属性和类属性，实例属性优先级最高
  • 静态方法不需要定义额外参数，需要引用属性时，可通过类对象或实例对象去引用

8、私有化属性和方法--保护和控制数据

8.1私有化属性

保护属性安全，不得随意修改，将属性定义成私有化属性，添加可调用的方法去访问

使用私有化属性的场景：

  1. 把特定属性隐藏，不想让类的外部直接调用（不能在外部直接访问，在类的内部可以随意访问）
  2. 保护这个属性，不想让该属性的值随意改变（内部可以修改）
  3. 保护属性，不想让派生类【子类】去继承（子类不能继承父类的私有属性）

语法：两个下划线开头，声明属性为私有属性，不能在类的外部被使用或直接访问

  1. class Person:
  2.     def __init__(self):
  3.         self.name='李四'
  4.         self.__age=18#属性私有化（外部不能访问，内部可以访问）
  5.         pass
  6.     def __str__(self):
  7.         return('{}的年龄是{}'.format(self.name,self.__age))
  9. x1=Person()
  10. print(x1)
  11. print(x1.name)
  12. print(x1.__age)#通过类对象在外部访问（私有化后，不能在外部直接访问）
  14. # Traceback (most recent call last):
  15. #   File "E:\资源下载\workspace\shixun\pythonProject2\2.17多态.py", line 125, in <module>
  16. #     print(x1.__age)#通过类对象在外部访问（私有化后，不能在外部直接访问）
  17. # AttributeError: 'Person' object has no attribute '__age'
  18. # 李四的年龄是18
  19. # 李四

 8.2 私有化方法

语法：方法名前加两个下划线

  • 私有化的方法不能被【子类】继承
  • 外部不能直接调用，内部可以调用

__xxx：方法私有化

__xxx__：魔术方法，Python自有，开发者不要创建

xxx_：避免属性名与Python关键字冲突

9、property属性函数

让调用者能直接以访问属性的方式，而且又能控制的方式

实现方法1-- 类属性

  1. class Animal(object):
  2.     def __init__(self):
  3.         self.__age=18#私有化属性
  4.     def dog(self):#访问私有属性
  5.         return self.__age
  6.     def chance(self,age):#修改私有实例属性
  7.         if age<0:
  8.             print('年龄不能小于0')
  9.             pass
  10.         else:
  11.             self.__age=age
  12.     #定义一个类属性，实现直接访问属性的形式去访问私有的属性
  13.     age=property(dog,chance)
  15. a1=Animal()
  16. print(a1.age)#访问私有属性
  17. #18
  18. a1.age=2#修改私有属性
  19. print(a1.age)
  20. #2

实现方法2：装饰器*

即在方法上使用装饰器

  1. class Animal(object):
  2.     def __init__(self):
  3.         self.__age=18#私有化属性
  5.     @property#通过装饰器修饰添加属性标志，提供一个getter方法
  6.     def dog(self):#访问私有属性
  7.         return self.__age
  9.     @dog.setter#提供一个setter方法
  10.     def chance(self,parms):#修改私有实例属性
  11.         if parms<0:
  12.             print('年龄不能小于0')
  13.             pass
  14.         else:
  15.             self.__age=parms
  16.             pass
  19. a1=Animal()
  20. print(a1.dog)#访问私有属性
  21. #18
  22. a1.chance=2#修改私有属性
  23. print(a1.dog)
  24. #2

10、__new__方法（参考3.2）和单例模式

单例模式：一种常用的软件设计模式

目的：确保某个类中只有一个实例存在

实现步骤：利用类属性保存初次创建的实例对象，第二次实例化对象的时候判断类属性是否保存实例对象，如果有就返回类属性保存的，如果没有就调用父类__new__方法创建新的实例对象

  1. class Student(object):
  2.     __instance=None
  3.     def __init__(self,name,age):
  4.         self.name=name
  5.         self.age=age
  6.         pass
  7.     def __new__(cls, *args, **kwargs):
  8.         if not cls.__instance:
  9.             cls.__instance=super(Student,cls).__new__(cls)#没有保存实例，就保存
  10.             return cls.__instance
  11.         else:
  12.             return  cls.__instance
  13.         pass
  14.     pass
  16. xm=Student('LH',19)
  17. print(id(xm))
  18. xh=Student('XH',20)
  19. print(id(xh))
  21. # 2390515351312
  22. # 2390515351312
  23. #id相同，说明实例化两次对象，都是同一对象

 11、异常处理

语法格式：

  1. try:
  2.     可能出现错误的代码块
  3. except：
  4.     出错后执行的代码块
  5. else：
  6.     没有错误执行的代码块
  7. finally：
  8.     不管有没有出错都要执行的代码块
  1. try:
  2.     x=x/2
  3.     print(x)
  4. except NameError as msg:
  5.     print(msg)
  7. #name 'x' is not defined

 Python内置异常类型：

Exception:万能类型、可以捕获所有异常

自定义异常

  • 要直接或间接继承Error或Exception
  • 用raise关键字抛出异常
  1. class Toolong(Exception):
  2.     def __init__(self,leng):
  3.         self.leng=leng
  4.         pass
  5.     def __str__(self):
  6.         return '你的长度为%s,过长了。。'%self.leng
  7.     pass
  10. def name_test():
  11.     name=input('请输入你的名字：')
  12.     try:
  13.         if len(name)>4:
  14.             raise Toolong(len(name))
  15.         else:
  16.             print(name)
  17.             pass
  18.         pass
  19.     except Toolong as msg:
  20.         print(msg)
  21.     finally:
  22.         print('执行完毕')
  24. name_test()
  25. # 请输入你的名字：chenq
  26. # 你的长度为5,过长了。。
  27. # 执行完毕

12、动态添加属性和方法

动态语言能在运行时改变其结构；Python、php、JavaScript是动态语言，c、c#、Java是静态语言

所有，Python在程序运行过程中添加属性和方法

12.1 动态添加属性

  1. #动态添加属性
  2. class Animal:
  3.     def __init__(self,name,age):
  4.         self.name=name
  5.         self.age=age
  6.     def say(self):
  7.         print('%s 年龄：%s'%(self.name,self.age))
  8.     pass
  10. cat=Animal('小猫',2)
  11. cat.say()
  13. cat.color='花色'#给对象动态添加属性
  14. print(cat.color)
  15. Animal.color='白色'#给类动态添加属性
  16. print(Animal.color)
  18. #小猫 年龄：2
  19. #花色
  20. #白色

12.2动态添加方法（需要用到types模块）

语法：

  1. import types#引入代码块
  2. def 方法名(self):
  3.     xxx
  4.     pass
  6. class 类名：
  7.     xxx
  8. pass
  10. 实例名=类名()
  11. 实例名.引入方法的新名字=types.MethodType(方法名,实例名）#动态添加方法
  12. 实例名.引入方法的新名字()#调用新方法
  1. import types#引入types模块
  2. def run(self):
  3.     print("%s 岁的%s在跑。。"%(self.age,self.name))
  5. class Animal:
  6.     def __init__(self,name,age):
  7.         self.name=name
  8.         self.age=age
  9.     pass
  11. cat=Animal('小猫',2)
  12. cat.run=types.MethodType(run,cat)#动态添加方法
  13. cat.run()#调用方法
  14. #2 岁的小猫在跑。。

12.3 动态绑定类方法和静态方法

语法：类名.新名字=类方法名

  1. @classmethod
  2. def classTest(cls):
  3.     print('这是个类方法')
  4.     pass
  5. @staticmethod
  6. def staticTest():
  7.     print("这是个静态方法")
  8.     pass
  10. class Animal():
  11.     pass
  12. #动态给类添加类方法、静态方法
  13. Animal.classnewname=classTest
  14. Animal.staticnewname=staticTest
  15. #调用类方法，静态方法
  16. Animal.classnewname()
  17. Animal.staticnewname()

13、__slots__属性

作用：限制可以添加的实例属性

  1. class Animal(object):
  2.     __slots__ = ('name','age','weight')#限制添加的属性
  3.     def __str__(self):
  4.         return '%s 。。。%s'%(self.name,self.age)
  5.     pass
  6. xh=Animal()
  7. xh.name='小花'
  8. xh.age=20
  9. xh.weight=45
  10. # xh.height  被限制，运行会报错
  11. print(xh)#小花 。。。20

__dict__:所有可用的属性都存储在这，占用内存高；使用__slots__后，实例中不再有__dict__

  1. class Animal(object):
  2.     # __slots__ = ('name','age','weight')#限制添加的属性
  3.     def __str__(self):
  4.         return '%s 。。。%s'%(self.name,self.age)
  5.     pass
  6. xh=Animal()
  7. xh.name='小花'
  8. xh.age=20
  9. xh.weight=45
  10. # xh.height  被限制，运行会报错
  11. print(xh)#小花 。。。20
  12. print(xh.__dict__)#没有设置__slots__时，所有可用的属性存储在这
  13. # 小花 。。。20
  14. # {'name': '小花', 'age': 20, 'weight': 45}

slots的作用：限制实例的属性；节约内存空间

子类继承父类时，若不声明slots，不继承父类的slots；声明slots后，子类限制属性=父类+自身

  1. class Animal(object):
  2.     __slots__ = ('name','age','weight')#限制添加的属性
  3.     def __str__(self):
  4.         return '%s 。。。%s'%(self.name,self.age)
  5.     pass
  7. class Dog(Animal):
  8.     __slots__ = ('color')#未声明时，不继承父类__slots__，声明后，限制属性=父类+自身
  9.     pass
  10. dog=Dog()
  11. dog.color='白色'
  12. print(dog.color)
  13. # 白色
文章已被收录至官方知识档案
本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。
打开APP，阅读全文并永久保存 查看更多类似文章
猜你喜欢
类似文章
【热】打开小程序，算一算2024你的财运
python使用什么关键字定义类
Python3 面向对象 | 菜鸟教程
Python 面向对象
Python中的面向对象编程详解(上)
python中类的全面分析
python中类及其实例详解
更多类似文章 >>
生活服务
热点新闻
留言交流
回顶部
联系我们
分享 收藏 导长图 关注 下载文章
绑定账号成功
后续可登录账号畅享VIP特权！
如果VIP功能使用有故障，
可点击这里联系客服！

联系客服