devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python 的私有化属性、私有化方法、Property属性、_new_方法、单例模式、错误与异常处理、动态添加属性与方法以及_slots_属性_python类的私有对象属性

作者：你好赵伟 | 2024-07-30 11:50:21

赞

踩

python类的私有对象属性

Day11新手小白学python

 第十一节  Python 的私有化属性、私有化方法、Property属性、_new_方法、单例模式、错误与异常处理、动态添加属性与方法以及_slots_属性，并进行了相应练习

目录

Day11新手小白学python

前言

一、私有化属性

二、私有化方法

三、Property属性

四、__new__方法

五、单例模式

六、错误与异常处理

七、Python动态添加属性和方法

八、__slots__属性

九、练习

总结

前言

本文介绍了Python 的私有化属性、私有化方法、Property属性、_new_方法、单例模式、错误与异常处理、动态添加属性与方法以及_slots_属性，并进行了相应练习

一、私有化属性

为了更好的保存属性安全，即不能随意修改，将属性定义为私有属性，添加一个可调用的方法去访问。

私有属性的特性：私有化属性不能在类的外部访问，可以在类里面访问，修改；子类不能继承私有化属性；两个下划线开头，声明该属性为私有。

  1. # 使用私有属性的场景
  2. # 1.把特定的一个属性隐藏起来，不想让类的外部进行直接调用
  3. # 2.我想保护这个属性，不想让属性的值随意的改变
  4. # 3.保护这个属性，不想让派生类【子类】去继承
  5. class Person:
  6.     __hobby='跳舞'  # 类属性
  7.     def __init__(self):
  8.         self.__name="李四"    # 加两个下划线，将此属性私有化 私有化之后不能在外部直接访问了 当然在类的内部是可以访问的
  9.         self.age=30
  10.         pass
  11.     def __str__(self):
  12.         '''
  13.         私有化的属性在内部可以使用 self.__name
  14.         :return:
  15.         '''
  16.         return '{}的年龄是{} 爱好是{}'.format(self.__name,self.age,Person.__hobby)
  17.     def changevalue(self):
  18.         Person.__hobby='唱歌'     # 私有属性可以在内部修改
  19.         pass
  20.  
  21. class Student(Person):
  22.     def printInfo(self):
  23.         # print(self.__name)  # 在此访问父类的私有属性可以吗  不可以 会报错 因为子类不能继承私有化属性
  24.         print(self.age)     # 输出30
  25.     pass
  26.  
  27. stu=Student()
  28. # print(stu.name)   # 会报错 子类没有这个属性，有也不可以在类外部调用
  29. stu.printInfo()
  30.  
  31. stu.changevalue()   # 修改私有属性的值
  32. print(stu)      # 输出 李四的年龄是30 爱好是唱歌
  33. # print(stu.__hobby)        # 实例对象访问类属性  是私有属性在不能访问
  34. # print(Person.__hobby)     # 对于类属性和实例属性同样如此 只要定义为私有属性 则都不能在外部访问
  35.  
  36. # xl=Person()
  37. # # print(xl.name)  # 是通过类对象在外部访问私有属性  会报错
  38. # print(xl)    # 输出 李四的年龄是30
  39.  
  40. # 小结：
  41. # 1 私有化的【实例】属性不能在类的外部直接访问，但可以在类的内部直接访问
  42. # 2 子类不能继承父类的私有化属性【只能继承父类公共的属性和行为】
  43. # 3 在属性名的前面直接加'__'就可以变成私有化属性了
'
运行

在类的外面修改私有属性:可以通过定义修改属性的方法来修改，也可以利用property来修改。 

二、私有化方法

概述：私有化方法跟私有化属性概念一样，有些重要的方法，不允许外部调用，防止子类意外重写，把普通的方法设置成私有化方法。

语法：私有化方法，即在方法名前面加两个下划线。

特性：私有化方法一般是类内部调用，子类不能继承，外部不能调用。

  1. class Animal:
  2.     def __eat(self):
  3.         print('吃东西')
  4.         pass
  5.     def run(self):
  6.         self.__eat()        # 在此调用私有化的方法 可以正确执行
  7.         print('飞快的跑')
  8.         pass
  9. class Bird(Animal):
  10.     pass
  11. b1=Bird()
  12. # b1.eat()      # 私有化方法不能在类的外部使用
  13. b1.run()
'
运行

三、Property属性

在外部可以访问私有方法的办法：

 方法一：类属性,即在类中定义 值为property对象的类属性。

  1. class Person(object):
  2.     def __init__(self):
  3.         self.__age = 18 # 定义一个私有化属性，属性名字前加连个 __ 下滑线
  4.     def get_age(self): # 访问私有实例属性
  5.         return self.__age
  6.     def set_age(self,age): # 修改私有实例属性
  7.         if age < 0:
  8.             print('年龄不能小于0')
  9.         else:
  10.             self.__age = age
  11.             pass
  12.         pass
  13.     # 定义一个类属性 实现通过直接访问属性的形式去访问私有属性
  14.     age=property(get_age,set_age)   # 获取或修改age值时不用调用p1.get_age()或其他，直接调用age即可
  15.     pass
  16.  
  17. p1=Person()
  18. print(p1.age)   #获取age属性值时，会自动调用get age方法。输出 18 
  19. p1.age=-1       # 修改age属性值时，会自动调用set age方法，
  20. print(p1.age)    # 输出 年龄不能小于0
  21. # p1.get_age()
  22. # p1.set_age()
'
运行

方法二：装饰器，即在方法上使用装饰器

  1. # 实现方式2 通过装饰器的方式去声明
  2. class Person(object):
  3.     def __init__(self):
  4.         self.__age = 18 
  5.     @property       # 用装饰器修饰 添加属性标志 提供一个getter方法  获取值
  6.     def age(self): 
  7.         return self.__age
  8.     @age.setter     # 使用装饰器进行装饰，提供一个setter方法  修改值 函数名.setter
  9.     def age(self,parms):
  10.         if parms < 0:
  11.             print('年龄不能小于0')
  12.         else:
  13.             self.__age = parms
  14.             pass
  15.         pass
  16.     pass
  17. p1=Person()
  18. print(p1.age)   #获取age属性值时，会自动调用@property标志的方法。输出 18
  19. p1.age=30       # 修改age属性值时，会自动调用@age.setter标志的方法，
  20. print(p1.age)    # 输出 30
  21. # p1.get_age()
  22. # p1.set_age()
'
运行

四、__new__方法

_new_方法的作用是，创建并返回一个实例对象，如果__new__只调用了一次，就会得到一个对象。继承自object的新式类才有new这一魔法方法。

注意事项：

        __new__ 是在一个对象实例化的时候所调用的第一个方法

        __new__至少必须要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供 ，其他的参数是用来直接传递给 __init__ 方法

        __new__ 决定是否要使用该 __init__ 方法，因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 __new__ 没有返回实例对象，则 __init__ 不会被调用

        在__new__ 方法中，不能调用自己的__new__ 方法，即：return cls.__new__ (cls)，否则会报错（RecursionError: maximum recursion depth exceeded：超过最大递归深度）

  1. class Animal:
  2.     def __init__(self):
  3.         self.color='红色'
  4.         pass
  5.     # 在python中如果不重写_new_方法，默认结果如下
  6.     def __new__(cls, *args, **kwargs):
  7.         return super().__new__(cls, *args, **kwargs)
  8.         # return object.__new__(cls, *args, **kwargs)   # 以上两种方法都可以返回当前创建的类
  9.     pass
  10. tigger=Animal()     # 实例化的过程会自动调用 new 去创建实例
  11. # 在新式类中  new 才是真正的实例化方法，为类提高外壳制造出实例框架，然后调用该框架内的构造方法_init_进行丰满操作
  12. # 比如建房子  _new_方法负责开发地皮 打地基 并将原料存放在工地，而_init_负责从工地取材料建造出地皮开发图纸规定的大楼，负责细节设计、建造、最终完成
'
运行

五、单例模式

单例模式：是一种软件设计模式  目的：确保某一个类只有一个实例存在。如果希望在这个系统中 某个类只能出现一个实例的时候，那么这个单例对象就满足要求。单例就比如我们打开电脑的回收站，在系统中只能打开一个回收站，也就是说这个整个系统中只有一个实例，重复打开也是使用这个实例。简单的说就是不管创建多少次对象，类返回的对象都是最初创建的，不会再新建其他对象。

  1. # 单例模式：是一种软件设计模式  目的：确保某一个类只有一个实例存在
  2. # 如果希望在这个系统中 某个类只能出现一个实例的时候，那么这个单例对象就满足要求
  3.  
  4. # 创建一个单例对象 基于_new_方法去实现的【推荐的一种】
  5. class DataClass(object):
  6.     _instance = None  # 保存实例对象
  7.     def __new__(cls, *args, **kwargs):
  8.         # cls.instance=cls.__new__(cls)     不能使用自身的new方法 容易造成一个深度递归，应该调用父类的new方法
  9.         # 利用hasattr判断_instance是否创建
  10.         if not hasattr(cls,'_instance'):     # 如果不存在cls._instance就创建_instance类属性 只让_instance创建一次
  11.             cls._instance=super().__new__(cls, *args, **kwargs)
  12.         return cls._instance
  13.         # 利用if--else判断
  14.         # 如果类属性 _instance 的值为None,那么新建一个对象
  15.         # 如果类属性值不为None 返回 _instance 保存的对象
  16.         # if not cls._instance:
  17.         #     cls._instance = super().__new__(cls, *args, **kwargs)  # 调用父类__new__方法生成一个实例对象
  18.         #     return cls._instance
  19.         # else:
  20.         #     return cls._instance
  21.     pass
  22.  
  23. class DBoptSingle(DataClass):
  24.     pass
  25.  
  26. db1=DBoptSingle()
  27. print(id(db1))
  28. db2=DBoptSingle()
  29. print(id(db2))
  30. db3=DBoptSingle()
  31. print(id(db3))      # 3个id相都等，说明实例化三次对象，实际上都是同一个对象
'
运行

六、错误与异常处理

有时候代码写错了，执行程序的时候，执行到错误代码的时候，程序直接终止报错，这是因为Python检测到一个错误时，解释器就无法继续执行了，出现了错误的提示，这就是"异常"。

语法格式：

 try ... except 语句：将可能出错的代码放到try里面，except可以指定类型捕获异常。except里面的代码是捕获到异常时执行,将错误捕获，这样程序就不会因为一段代码包异常而导致整个程序崩溃。用一个块 可以捕获多个不同类型的异常。Exception 可以捕获所有的异常，当对出现的问题或者错误不确定的情况下，可以使用Exception

  1. # except在捕获错误异常时 是要根据具体的错误类型来捕获的
  2. # 用一个块 可以捕获多个不同类型的异常
  3. # Exception 可以捕获所有的异常 当对出现的问题或者错误不确定的情况下 可以使用Exception
  4. try:
  5.     # print(b)        # 要捕获错误逻辑的代码
  6.     # li=[1,2,45]
  7.     # print(li[10])       # 通过下标去访问列表
  8.     # a=10/0
  9.     pass
  10. except NameError as msg:
  11.     # 捕获到的错误 才会在这个执行
  12.     print(msg)
  13.     pass
  14. except IndexError as msg:
  15.     print(msg)
  16.     pass
  17. except ZeroDivisionError as msg:
  18.     print(msg)
  19.     pass
  20. # except Exception as result:     # Exception 可以捕获所有的异常
  21. #     print(result)
  22. #     在此尽量去处理捕获到的错误，如进行打印标识一下
  23. #     pass
  24. # print('初次异常处理')
  25. # print('HAHAHAHAHA')
'
运行

异常传递：如果多个函数嵌套调用，内层函数异常，异常会往外部传递，直到异常被抛出，或被处理。不需要在每个可能出错的地方去捕获，只要在合适的层次去捕获错误就可以了，这样的话就大大减少我们写try---except的麻烦

  1. def A(s):
  2.     return 10/int(s)
  3.     pass
  4. def B(s):
  5.     return A(s)*2
  6. def main():
  7.     # B(0)
  8.     try:
  9.         B('0')
  10.         pass
  11.     except Exception as msg:
  12.         print(msg)
  13.         pass
  14.     pass
  15. main()
  16. # 不需要在每个可能出错的地方去捕获，只要在合适的层次去捕获错误就可以了 这样的话 就大大减少我们写try---except的麻烦
  17. # 异常的抛出机制
  18. # 如果在运行时发生异常，解释器会查找相应的异常捕获类型
  19. # 如果在当前函数里面没有找到的话，它会将异常传递给上层的调用函数，看能否处理
  20. # 如果在最外层没有找到的话，解释器就会退出，程序down
'
运行

  try ... excep--else语句：

  1. # try--except--else
  2. try:
  3.     print('我是没有错误产生的')
  4.     pass
  5. except Exception as msg:
  6.     print('error',msg)
  7.     pass
  8. else:
  9.     print('当Try里面的代码没有出现异常的情况下 我才会执行')
  10.     pass
'
运行

 try--except--finally语句：

  1. try:
  2.     int('34')
  3.     open('aaaa.txt')
  4.     pass
  5. except Exception as msg:
  6.     print('error',msg)
  7.     pass
  8. finally:
  9.     print('释放文件的资源、数据库连接的资源等等')
  10.     print('不管有没有捕获到异常，finally都是执行的')
'
运行

自定义异常：都要直接或间接继承Error或Exception类。由开发者主动抛出自定义异常，在python中使用raise关键字

  1. class ToolongException(Exception):
  2.     def __init__(self,leng):
  3.         '''
  4.         :param leng:长度
  5.         '''
  6.         self.leng=leng
  7.         pass
  8.     def __str__(self):
  9.         return '您输入的姓名数据长度是'+str(self.leng)+'超过长度了...'
  10.     pass
  11.  
  12. def name_Test():
  13.     name=input('请输入姓名')
  14.     try:
  15.         if len(name)>=5:
  16.             raise  ToolongException(len(name))
  17.         else:
  18.             print(name)
  19.             pass
  20.     except ToolongException as result:
  21.         print(result)
  22.         pass
  23.     finally:
  24.         print('执行完毕了')
  25.         pass
  26.     pass
  27. name_Test()
'
运行

七、Python动态添加属性和方法

动态语言：运行时可以改变其结构的语言，例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。如php,JavaScript,python都是动态语言，C，C#，java是静态语言。

1、动态添加实例属性：运行中给对象添加属性

  1. class Animal(object):
  2.     def __init__(self,name,age):
  3.         self.name = name
  4.         self.age = age
  5.  # 定义了两个初始属性name和age，但是没有颜色，我想要添加颜色又不能去修改类
  6. cat = Animal('小白',5)
  7. # 动态绑定colour属性
  8. cat.colour = '白色'
  9. print(cat.colour)
'
运行

2、动态添加类属性：运行中给类添加属性

  1. class Animal(object):
  2.     def __init__(self,name,age):
  3.         self.name = name
  4.         self.age = age
  5. # 定义了两个初始属性name和age，但是没有颜色，我想要添加颜色又不能去修改类
  6. cat = Animal('小白',5)
  7. # 动态绑定colour属性
  8. Animal.foot = 4 # 添加类属性
  9. print(cat.foot )
'
运行

3、动态添加实例方法：需要使用types，首先要导入types模块，再定义好需要使用的方法，再绑定调用。使用方式：实例对象.需定义的实例方法名=types.MethodType(定义好的需绑定的实例方法名，实例对象)

4、动态添加类方法和静态方法：首先要先定义好类方法和静态方法再绑定调用。使用方式：类名.需定义类的方法名 = 定义好的需绑定的类方法 或 类名.需定义类的静态方法名 = 定义好的需绑定的静态方法

  1. import types    # 添加方法的库  动态添加实例方法需要用到types模块
  2. def dymicMethod(self):
  3.     print('{}的体重是{}，在{}读大学'.format(self.name,self.weight,Student.school)) # 类属性用类访问
  4.     pass
  5. @classmethod        # 定义一个类方法
  6. def classTest(cls):
  7.     print('这是一个类方法')
  8.     pass
  9. @staticmethod       # 定义一个静态方法
  10. def staticMethodTest():
  11.     print('这是一个静态方法')
  12.     pass
  13. class Student:
  14.     def __init__(self,name,age):
  15.         self.name=name
  16.         self.age=age
  17.         pass
  18.     def __str__(self):
  19.         return '{}今天{}岁了'.format(self.name,self.age)
  20.     pass
  21. # ---------------------------给类绑定类方法----------------------------------
  22. print('绑定类方法')
  23. Student.TestMethod=classTest        # 语法：类名.需定义类的方法名 = 定义好的需绑定的类方法
  24. Student.TestMethod()                # 调用绑定好的类方法
  25. print('---------绑定类方法结束-------------')
  26.  
  27. # ---------------------------给类绑定静态方法----------------------------------
  28. print('绑定静态方法')
  29. Student.staticMethodTest=staticMethodTest       # 语法：类名.需定义类的静态方法名 = 定义好的需绑定的静态方法
  30. Student.staticMethodTest()                      # 调用绑定好的静态方法
  31. print('---------绑定静态方法结束-------------')
  32.  
  33. # ---------------------------动态添加实例属性----------------------------------
  34. lxy=Student('刘绚',20)
  35. lxy.weight=50       # 动态添加属性 添加的是实例属性
  36.  
  37. # ---------------------------动态添加实例方法  需要使用types----------------------------------
  38. lxy.printInfo=types.MethodType(dymicMethod,lxy) # 实例对象.需定义的实例方法名=types.MethodType(定义好的需绑定的实例方法名，实例对象)
  39. lxy.TestMethod()        # 实例对象调用动态绑定好的类方法
  40. print(lxy)
  41.  
  42. print('-------另一个实例对象 张明--------')
  43. zm=Student('张明',20)
  44. zm.weight=80
  45. print(zm)       # 输出：张明今天20岁了
  46. zm.printInfo=types.MethodType(dymicMethod,zm)       # 动态绑定实例方法
  47. # ---------------------------给类对象添加属性 类属性----------------------------------
  48. print('-------给类对象添加属性--------')
  49. Student.school='华电'     # 动态添加 类属性
  50. print(zm.school)
  51.  
  52. print('-------执行动态调用实例方法--------')
  53. lxy.printInfo()     # 调用动态绑定的实例方法
  54. zm.printInfo()
'
运行

八、__slots__属性

python是动态语言，在运行的时候可以动态添加属性。如果要限制在运行的时候给类添加属性，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性。

只有在__slots__变量中的属性才能被添加，没有在__slots__变量中的属性会添加失败。可以防止其他人在调用类的时候胡乱添加属性或方法。

__slots__属性子类不会继承，只有在当前类中有效。若子类声明了_slots_，此时子类会继承父类的_slots_，也就是子类_slots_的范围是：其自身_slots_+父类的_slots_ ，在这两者中定义的变量可以被添加，其余都不行；子类和父类的_slots_最好不要有一样的，会占用内存空间

__slots__属性的作用：限制属性的随意输入；节省内存空间。

  1. # __slots__作用
  2. # 限制要添加的实例属性
  3. # 节约内存空间
  4. class Student(object):
  5.     __slots__ = ('name','age')
  6.     def __str__(self):
  7.         return '{}.....{}'.format(self.name,self.age)
  8.     pass
  9. xw=Student()
  10. xw.name='小王'
  11. xw.age=20
  12. # xw.score=96     # 不在solts申明的范围内，不允许添加该属性，会报错
  13. # print(xw.__dict__)  # 输出：{'name': '小王', 'age': 20}  所有可以用的属性都在字典里面存储 不足的地方就是占用的内存空间大
  14. # 在定义了slots变量之后，student类的实例对象已经不能随意创建不在_slots_定义的属性了
  15. # 同时可以看到实例中也不存在__dict__，都存在_slots_中了
  16. print(xw)
  17.  
  18. # 在继承关系当中的使用 _slots_
  19. # 当子类未声明_slots_时，那么是不会继承父类的_slots_，此时子类是可以随意的添加属性的
  20. # 子类声明了_slots_时，此时子类会继承父类的_slots_，也就是子类_slots_的范围是 其自身+父类的_slots_
  21. # 子类和父类的_slots_最好不要有一样的，会占用内存空间
  22. class subStudent(Student):
  23.     __slots__ = ('gender','pro')
  24.     pass
  25. ln=subStudent()
  26. ln.gender='男'
  27. ln.pro='计算机'
  28. print(ln.gender,ln.pro)
'
运行

九、练习

1、编写一段代码以完成下面的要求：定义一个Person类，类中要有初始化方法，方法中要有人的姓名，年龄两个私有属性。提供获取用户信息的函数。提供获取私有属性的方法。提供可以设置私有属性的方法。设置年龄的范围在(0-120)的方法，如果不在这个范围，不能设置成功。

  1. class Person(object):
  2.     def __init__(self,name,age):
  3.         self.__name=name
  4.         self.__age=age
  5.         pass
  6.     def get_msg_name(self):
  7.         return self.__name
  8.     def get_msg_age(self):
  9.         return self.__age
  10.     def set_msg_name(self, name):
  11.         self.__name = name
  12.         pass
  13.     def set_msg_age(self,age):
  14.         if 120<age or age<0:
  15.             print('年龄不合适')
  16.             pass
  17.         else:
  18.             self.__age=age
  19.             pass
  20.         pass
  21.     name=property(get_msg_name,set_msg_name)
  22.     age=property(get_msg_age,set_msg_age)
  23.     def __str__(self):
  24.         return '{}的年龄是{}岁'.format(self.__name,self.__age)
  25.     pass
  26.  
  27. def getData():
  28.     name=input('请输入您的姓名')
  29.     age=input('请输入您的年龄')
  30.     return name,age
  31.  
  32. name,age=getData()
  33. lxy=Person(name,age)
  34. print(lxy.name)
  35. print(lxy.age)
  36. print(lxy)
  37. lxy.name='xiaom'
  38. lxy.age=-1
  39. print(lxy)

2、请写一个单例模式

  1. class DataClass(object):
  2.     _instance=None
  3.     def __new__(cls, *args, **kwargs):
  4.         if not cls._instance:   # 如果_instance仍为空
  5.             cls._instance=super().__new__(cls, *args, **kwargs)
  6.             return cls._instance
  7.         else:
  8.             return cls._instance
  9.         pass
  10.     pass
  11. db1=DataClass()
  12. print(id(db1))
  13. db2=DataClass()
  14. print(id(db2))
'
运行

 3、创建一个类，并定义两个私有化属性，提供一个获取属性的方法和设置属性的方法。 利用property 属性给调用者提供属性方式的调用获取和设置私有属性方法的方式。

  1. class Student:
  2.     def __init__(self,name,score):
  3.         self.__name=name
  4.         self.__score=score
  5.         pass
  6.     @property        # 用装饰器修饰 添加属性标志 提供一个getter方法  获取值
  7.     def name(self):
  8.         return self.__name
  9.     @name.setter  # 使用装饰器进行装饰，提供一个setter方法  修改值 函数名.setter
  10.     def name(self,name):
  11.         self.__name=name
  12.         pass
  13.     @property
  14.     def score(self):
  15.         return self.score
  16.     @score.setter
  17.     def score(self,score):
  18.         self.__score=score
  19.         pass
  20.     def __str__(self):
  21.         return self.__name
  22.     pass
  23.     def __call__(self, *args, **kwargs):    # 将实例对象以函数的形式去调用
  24.         print('{}的分数是{}'.format(self.__name,self.__score))
  25.         pass
  26. xw=Student('小王',90)
  27. print(xw)
  28. xw()        # 输出：小王的分数是90
  29. xw.name='张三'
  30. xw.score=48
  31. xw()        # 输出：张三的分数是48
'
运行

4、 创建一个Animal类，实例化一个cat对象，请给cat对象动态绑定一个run方法，给类绑定一个类属性colour，给类绑定一个类方法打印字符串'ok'。

  1. import types
  2. class Animal:
  3.     pass
  4. def run(self):      # 绑定实例方法
  5.     print("我跑得飞快")
  6.     pass
  7. @classmethod        # 定义一个类方法
  8. def printInfo(cls):
  9.     print("ok")
  10.     pass
  11. Animal.color='橘色'    # 给类绑定一个类属性colour
  12. cat=Animal()
  13. cat.weight=20       #  动态添加实例属性
  14. print("猫的颜色是{}，重{}".format(Animal.color,cat.weight))
  15. cat.run1=types.MethodType(run,cat)      # 给cat对象动态绑定一个run方法 实例方法
  16. cat.run1()
  17.  
  18. Animal.printInfo1=printInfo  # 给类绑定一个类方法
  19. cat.printInfo1()
'
运行

总结

本文仅仅简单介绍了Python 的私有化属性、私有化方法、Property属性、_new_方法、单例模式、错误与异常处理、动态添加属性与方法以及_slots_属性，并进行了相应练习

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/903631
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号