Python笔记【八】

本文为博主原创，未经许可严禁转载。
本文链接：https://blog.csdn.net/zyooooxie/article/details/108095932

Python笔记的博客很久很久很久没有分享过了，一是没有时间，二是懒。
最近需求不算太多，我也就继续学习、分享一篇啊。

个人博客：https://blog.csdn.net/zyooooxie

作用域

https://docs.python.org/zh-cn/3.9/tutorial/classes.html#python-scopes-and-namespaces

"""
@blog: https://blog.csdn.net/zyooooxie
"""def test_1():"""作用域:return:"""# 一个作用域是 一个命名空间可直接访问的Python程序的文本区域。# 【作用域是针对变量而言，指申明的变量 在程序里的可应用范围，或者称为 变量的生效范围。】# 虽然作用域是静态地确定的，但它们会被动态地使用。# python解释器动态执行过程中，对遇到的变量进行解释时，是按照一条固定的作用域链 查找解释的，又称为LEGB法则。# • Local(最内部函数)局部作用域# • Enclosing（嵌套函数的外层函数）嵌套作用域# • Global（模块全局）全局作用域# • Built-in（内置）内置作用域# 我的理解：# • 嵌套函数的 内层函数的 作用范围；# • 嵌套函数的 外层函数的 作用范围；# • 全局作用域是文件级别的，或者说是模块级别的，每个py文件中处于顶层的变量 都是全局作用域范围内的变量；# • 内置作用域是预先定义好的，在__builtins__模块中。这些名称主要是一些关键字，例如open、range、quit等；# --------------# 上面4个作用域的范围排序是按照从内到外，从小到大排序的。# 内层范围可以引用外层范围的变量，外层范围不包括内层范围的变量。# 在局部作用域中，可以看到局部作用域、嵌套作用域、全局作用域、内建作用域中 所有定义的变量。pass# TODO 强烈建议：使用IDE的debug功能
# TODO 强烈建议：多打断点 + 在Watches面板 观察x 、open 、 yx = 11                  # Globaldef f():# 如果一个名称被声明为全局变量，则所有引用和赋值将直接指向包含该模块的全局名称的中间作用域。# 要重新绑定在最内层作用域以外找到的变量，可以使用nonlocal语句声明为非本地变量。如果没有被声明为非本地变量，这些变量将是只读的（尝试写入这样的变量只会在最内层作用域中创建一个新的局# 部变量，而同名的外部变量保持不变）。open = 90               # Enclosingy = 8# 如果函数内部重新赋值了一个和全局变量名称相同的变量，则这个变量是本地变量x = 33print("f1:", x, 'x的值')          # 33print("f1:", open, 'open的值')   # 90print("f1:", y, 'y的值')          # 8def g():open = 40                   # Localprint("g:", open, 'open的值')print("g:", y, 'y的值')       # Enclosingprint("g:", x, 'x的值')print('g() 执行结束')g()print("f2:", x)         # 33print("f2:", open)      # 90print("f2:", y)         # 8out()def out():# 如果在函数内部引用了一个和全局变量同名的变量，且没有重新赋值，那么此变量 引用的是全局变量。print('out:', x, 'x的值')             # Globaly = 1111print('out:', y, 'y的值')open = 0.1111print('out:', open, 'open的值')print('out() 执行结束')if __name__ == '__main__':passprint("main: f()执行前", x, 'x的值')    # 11f()print("main: f()执行后", x, 'x的值')    # 11print('main', open)         # <built-in function open>

global()、locals()

https://docs.python.org/zh-cn/3.9/library/functions.html#globals

https://docs.python.org/zh-cn/3.9/library/functions.html#locals

"""
@blog: https://blog.csdn.net/zyooooxie
"""# locals() 实际上没有返回局部名字空间，它返回的是一个拷贝。所以对它进行修改，修改的是拷贝，而对实际的局部名字空间中的变量值并无影响。
# globals() 返回的是实际的全局名字空间，对 globals 所返回的字典的 任何的改动都会直接影响到全局变量的取值。name = 'zyooooxie'
web = 'csdn'print('在模块层级上，locals() 和 globals() 是同一个字典。')
# print(locals(), '1-locals')
# print(globals(), '1-globals')def test_globals():a = globals()       # 这永远是当前模块的字典（在一个函数或方法内部时，这是指定义该函数或方法的模块，而不是调用该函数或方法的模块）print(a)# 2种方式 修改全局变量a['name'] = 'new_zyooooxie'print(globals())                # 修改成功global webweb = 'new_csdn'print(globals())def test_locals():# locals函数以字典的形式返回当前所在作用域的全部变量，# 如果你在一个模块里执行locals函数，那么它返回的与globals函数返回值相同；# 如果你在一个函数中执行locals函数，就只能返回这个函数所形成的局部作用域里的变量。print(locals())a = 1print(locals(), 'a')b = 2print(locals(), 'b')locals()['a'] = 11111               # 注意：更改 不会影响解释器使用的局部变量或自由变量的值。print(locals(), '直接修改a，实际locals()没变')def test_locals2(int1: int, str1: str, list1: list, **kwargs) -> str:"""locals() 的一些用法:param int1: :param str1: :param list1: :param kwargs: :return: """print(locals(), '函数内部的变量')res = '第一，其中传入的实参值有 {}, {}'.format(int1, kwargs)print(res)res = '第二，其中传入的实参值有 {list1}, {kwargs}'.format(**locals())print(res)res = '第三，其中传入的实参值有 {kwargs}, 有 {0}, 有 {list1}, 有 {1}'.format(locals()['kwargs'], str1, **locals())print(res, '特别留意！！！')print('有 {kwargs}'.format(**locals()))print('有 {1}'.format(locals()['kwargs'], str1))res = f'第四，其中传入的实参值 有{kwargs}, 有{str1}'print(res)return resif __name__ == '__main__':pass# test_globals()# test_locals()test_locals2(1, 'zyooooxie2', [3, 4.00], csdn55=('qq', '153132336'), zy6666='77777.77', xie8888='99999.99')

global语句、nonlocal语句

https://docs.python.org/zh-cn/3.9/reference/simple_stmts.html#the-global-statement

https://docs.python.org/zh-cn/3.9/reference/simple_stmts.html#the-nonlocal-statement

"""
@blog: https://blog.csdn.net/zyooooxie
"""def test_2():"""global、nonlocal语句:return:"""# 注意：在内部函数中不能先访问外部函数变量，之后再定义一个同名的局部变量，这样会报错。# 函数内部只要是赋值操作 就表示声明为本地变量# --------------# 在一个模块内定义的函数的全局作用域就是该模块的命名空间，无论该函数从什么地方或以什么别名被调用。# 如果不存在生效的global或nonlocal语句，则对名称的赋值总是会进入最内层作用域。# def内部声明(赋值)的变量默认是本地变量，要想让其变成全局变量，需要使用global。# def内部如果没有声明某变量，则引用的这个变量是全局变量。# --------------# global 语句可被用来表明特定变量生存于 全局作用域 并且应当在其中被重新绑定；# nonlocal 语句表明特定变量生存于 外层作用域 并且应当在其中被重新绑定。# --------------# global:如果一个命名被声明为global，那么对于这个命名的所有的引用与赋值都会作用于模块的全局命名。# 【可以在函数内声明全局变量，然后实现对全局变量的修改。】# global可以声明一个或多个变量为全局变量，多个变量使用逗号隔开，也可以声明事先不存在的变量为全局变量。# 不能global中直接赋值。# 在 global 语句中列出的名称 不得在同一代码块内 该global语句之前的位置中使用【若使用的话，就将它声明为本地变量了】# 在global语句声明后，某些变量变为全局变量，实际是 未赋值。【必须先声明 后使用】# TODO 如果允许，应尽量不要将函数内部的变量修饰为全局变量# --------------# 在嵌套函数中，如果你想要在内层函数中使用 外层函数中的变量，是只可读 不可修改。# 在内层函数 尝试修改外层函数的变量，直接赋值时 会在内层函数 重新创建一个新的局部变量，而外层函数的变量依然存在。# nonlocal:它是用来重新绑定中间层次作用域中的变量。【在嵌套函数中，在内层函数声明nonlocal，可以实现修改外层函数的局部变量值。】# nonlocal 语句会使得所列出的名称 指向之前在最近的包含作用域中绑定的 除全局变量以外 的变量。# 【nonlocal默认将内层函数中的变量修饰为上一层函数的作用域范围，如果上一层函数中不存在该变量，则修饰为上上层、上上上层直到顶层函数，但不能修饰为全局作用域范围。】# nonlocal语句 修饰多个变量的时候，需要逗号隔开。passvar = "123"def scope_test():# print('1', globals())print('1', locals())def do():print('do()内部 var:', var, ';', 'var2:', var2)print('do()', locals(), '未重新赋值时，引用得是 外层函数中的变量')def do_2():# print(var)              # UnboundLocalError: local variable 'var' referenced before assignmentvar = "do_2新赋值的var"# print('2', globals())print('2', locals(), '只一个新定义的局部变量')def do_nonlocal():# print(var)              # SyntaxError: name 'var' is used prior to nonlocal declarationnonlocal var            # 没有在函数do_nonlocal()的域中创建一个变量，而是去引用到了外层的 【下面 var = "test-var"】nonlocal var2           # 去引用 外层的【下面 var2 = 'test-var2'】var = 'new-var'var2 = 'new-var2'new_var222222 = '用完就销毁'# nonlocal new_var222222    # SyntaxError: name 'new_var222222' is assigned to before nonlocal declaration# nonlocal false_var      # SyntaxError: no binding for nonlocal 'false_var' foundnonlocal var02, var01, var03var03 = 'do_nonlocal()中nonlocal语句声明var02, var01, var03后，只赋值var03'print(var01, var02, var03)print('请留意：var01 var02 没有新赋值，变量值就不会变；nonlocal没有报错')print('3', globals(), '请观察实际全局变量的var')print('3', locals(), '请观察实际局部变量的 var和var2')def do_global():# global 先声明 后使用！# var = 1     # 若是不注释此行，下一行的 global var 会报错：SyntaxError: name 'var' is assigned to before global declarationglobal varglobal new_var, new_var2var = "do_global()新赋值的var"new_var = '新建全局new_var'# 实际 new_var2 没有赋值print('do_global()中global语句声明var、new_var、new_var2，没有赋值给new_var2')# print(new_var, var, new_var2)           # NameError: name 'new_var2' is not definedprint(new_var, var)# print('请留意：var没有新赋值时，变量值就不会变；global没有报错。')# print('请留意：var新赋值后，变量值就变；')new_var2222222222 = '用完就销毁-新建'print('4', globals(), '留意new_var、var')print('4', locals())var = "test-var"print('scope_test函数中var:', var)var2 = 'test-var2'var01 = 'TEST-01'var02 = 'TEST-02'var03 = 'TEST-03'print(var2, var01, var02, var03, '留意')# print('5', globals())print('5', locals(), locals()['var'])do()print("do()执行后：", var, var2)do_2()print("do_2()执行后：", var, var2)               # 局部赋值（这是默认状态）不会改变 scope_test 对 var 的绑定。do_nonlocal()print("After nonlocal assignment：", var, var2, 'var、var2的值已经改变')print('8', globals())print('8', locals(), '实际局部var、var2、var03 已经改变')do_global()print('6', globals(), '实际全局var、new_var')print('6', locals())print("After global assignment 全局var 已改:", globals()['var'])print("After global assignment 全局new_var 新增:", globals().get('new_var'))# nonlocal 赋值会改变scope_test 对 var、var2 的绑定，# 而global 赋值会改变模块层级的绑定。if __name__ == '__main__':passprint("最初var:", var)print('0', globals())       # globals()['new_var'] 报keyErrorprint('0', locals())scope_test()print("最后var:", var)print('7', globals(), globals().get('new_var'))print('7', locals())# print('在模块层级上，locals() 和 globals() 是同一个字典。')

私有变量

https://docs.python.org/zh-cn/3.9/tutorial/classes.html#private-variables

"""
@blog: https://blog.csdn.net/zyooooxie
"""def test_1():"""类的封装、私有属性、私有方法:return:"""# 在Class内部，可以有属性和方法，而外部代码可以通过直接调用实例变量的方法来操作数据，还可以自由地修改一个实例的 属性；# 一些属性不想被 外部访问、不想被外部操作，可以把属性的名称前加上两个下划线__。# 在python里，如果属性和方法前面 是双下划线，那么这个属性和方法就变成了私有的属性。# 以双下划线开头的方法，类的实例对象 无法使用，双下划线开头的属性 也同样无法访问；# 通过这种方法，就可以将 不希望外部访问的属性和方法 隐藏起来。# 类中的私有属性，以及私有方法只能在类的内部使用，不能被实例对象以及类对象在类外边直接调用。# --------------# 私有变量的本质# 类定义的时候，如果声明一个实例变量的时候，使用双下划线，Python解释器会将其改名，转换名称为"_类名__变量名"的名称，所以用原来的名字访问不到了。# 名称改写：任何形式为__spam 的标识符（至少带有两个前缀下划线，至多一个后缀下划线）的文本将被替换为_classname__spam，其中classname 为去除了前缀下划线的当前类名称。# 这种改写不考虑标识符的句法位置，只要它出现在类定义内部就会进行。# 那要如何访问 双下划线的私有属性呢？# 既然我们知道了私有变量的新名称，就可以直接从外部访问到，并修改它。# 因此 尽管是私有属性，我们依旧是可以对其进行更改,但建议大家不要去修改。# --------------# 在变量名前使用一个下划线，称为保护变量。# 可以看出，这个_addr属性根本就没有改变名称，和普通的属性一样，解释器不做任何特殊处理。# 这只是开发者共同的约定，看见这种变量，就如同私有变量，不要直接使用。# --------------# 私有方法的本质# 单下划线的方法只是开发者之间的约定，解释器不做任何改变。# 双下划线的方法，是私有方法，解释器会改名，改名策略和私有变量相同， 即"_类名__方法名" 。# 在Python中使用 _单下划线 或者 __ 双下划线 来标识一个成员被保护或者被私有化隐藏起来。# 但是，不管使用什么样的访问控制，都不能真正的阻止用户修改类的成员。 Python中没有绝对的安全的保护成员或者私有成员。# 因此，前导的下划线只是一种警告或者提醒，请遵守这个约定。除非真有必要，不要修改或者使用保护成员或者私有成员，更不要修改它们。# --------------# 1.在python中实现的封装操作，不是通过权限限制，而是通过改名(name mangling 改名策略)实现的，名字变了找不到而已。# 2.可以使用 __dict__ 可以查看属性(包括私有属性)的值，在类的内部使用私有属性，python内部会自动进行转换成 _类名__属性名。# 在类的外部不能给对象添加 私有属性，因为不能转换成_类名__属性名类型。# 3.可以通过 对象名._类名__方法名 访问到（但禁止这么干）。# 可以使用 _类名__私有属性名来获取值。但是一般情况下不要使用，了解即可。pass

"""
@blog: https://blog.csdn.net/zyooooxie
"""class Animal(object):def __init__(self, age, name):# 类的私有属性，只能在类的内部进行访问，不能在类的外部直接访问到。self.__a_age = ageself.__a_name = nameself._a_addr = 'sz'self._a_hobby = '吃人'def __func_run(self):print('{}在{}跑步'.format(self.__a_name, self._a_addr))def _func_eat(self):print('{}岁啊 就喜欢{}'.format(self.__a_age, self._a_hobby))def run(self):self.__func_run()def eat(self):self._func_eat()# 在python中，一般定义函数名‘get_xx’来获取私有属性，定义‘set_xx’来修改私有属性。def set_age(self, age):if isinstance(age, int) is False:raise Exception('类型有误')self.__a_age = agedef get_age(self):return self.__a_agedef get_hobby(self):return self._a_hobby

"""
@blog: https://blog.csdn.net/zyooooxie
"""if __name__ == '__main__':passa = Animal(1, '刚1岁的小猫')print(a.__dict__)a.age = 100.12# age属性 若是暴露出来了，别人在使用时就可能会犯这样的错误，# 属性隐藏起来，并非不让外部使用，而是在使用时 要受到控制。print(a.__dict__)print(a.age, '刚设置的age')print(a.get_age(), '查看实际的_Animal__a_age')# a.set_age(100.12)       # Exception: 类型有误a.set_age(90)print(a.get_age(), '新设置后的_Animal__a_age')print(Animal.__dict__)

"""
@blog: https://blog.csdn.net/zyooooxie
"""if __name__ == '__main__':passprint(Animal.__dict__)# ani = Animal(33, '33岁的小猫')# print(dir(ani))         # 返回 所有属性的列表 list of strings# print(ani.__dict__)     # 一个字典，键为属性名，值为属性值；an object’s (writable) attributes## # dir()用来寻找一个对象的所有属性，包括__dict__中的属性，__dict__是dir()的子集## print()an = Animal(5, '5岁的小猫')print(an.__dict__)          # {'_Animal__a_age': 5, '_Animal__a_name': '5岁的小猫', '_a_addr': 'sz', '_a_hobby': '吃人'}print(an._Animal__a_age)              # 不要直接使用print(an._Animal__a_name)             # 不要直接使用an._Animal__a_age = 100.01          # 绕过，直接设置了an._Animal__a_name = '新的name'print(an._Animal__a_age)print(an._Animal__a_name)print(an.__dict__, '直接设置后')setattr(an, '_Animal__a_age', 9.99)setattr(an, '_Animal__a_name', '新的name在在在')print(an.__dict__, 'setattr()重新赋值1')print()print(an._a_addr)                 # 不要直接使用print(an._a_hobby)                # 不要直接使用setattr(an, '_a_addr', '换个地方')setattr(an, '_a_hobby', '换个喜好')print(an.__dict__, 'setattr()重新赋值2')print(an._a_addr)print(an._a_hobby)an._a_addr = 'zai换个地方'an._a_hobby = 'zai换个喜好'print(an.__dict__, '直接赋值2')an._addr = '新新新添加个保护_addr'          # 新增print(an._addr)print(an.__dict__)an.__a_name = '新新新添加个私有__a_name'        # 新增print(an.__a_name)# 表面上看，外部代码“成功”地设置了 __a_name，但实际上这个 __a_name 和class内部的 __a_name 不是一个变量！# 内部的__a_name 已经被Python解释器自动改成了 _Animal__a_name，而外部代码给an新增了一个 __a_name。print(an.__dict__, an.__dict__['_Animal__a_name'], an.__dict__['__a_name'])# print(an.__age)                     # AttributeError: 'Animal' object has no attribute '__age'# print(an.__like)                    # AttributeError: 'Animal' object has no attribute '__like'print()# an.__func_run()                          # AttributeError: 'Animal' object has no attribute '__func_run'# print(an.__a_age)                           # AttributeError: 'Animal' object has no attribute '__a_age'# __func_run()方法是以双下划线开头的；这样的方法，类的对象无法使用，双下划线开头的属性也同样无法访问，# 通过这种方法，就可以将不希望外部访问的属性和方法隐藏起来。an._func_eat()                                      # 不要直接使用an._Animal__func_run()                              # 不要直接使用an.eat()an.run()print(an.get_hobby())print(an.get_age())

@property

https://docs.python.org/zh-cn/3.9/library/functions.html#property

"""
@blog: https://blog.csdn.net/zyooooxie
"""def test_0():"""属性装饰器 -- 把 get/set 方法“装饰”成属性调用。:return:"""# 我们自定义get_age和set_age方法操作属性，的确可以实现私有变量的管理。那有没有简单的方式呢？# @property可以把一个实例方法 变成 其同名属性，以支持.号访问，它亦可标记设置限制，加以规范。# Decorators make defining new properties or modifying existing ones easy:## class C(object):#     @property#     def x(self):#         "I am the 'x' property."#         return self._x#     @x.setter#     def x(self, value):#         self._x = value#     @x.deleter#     def x(self):#         del self._x# 使用property装饰器的时候这三个方法同名。# property装饰器必须在前，setter，deleter装饰器在后。# property装饰器：后面跟的函数名是以后的属性名。它就是getter。这个必须有，有了它至少是只读属性。# setter装饰器：与属性名同名，且接收2个参数，第一个self，第二个是将要赋值的值。有了它，属性可写。# deleter装饰器：可以控制是否删除属性，很少用。pass

私有实例属性使用property装饰器

"""
@blog: https://blog.csdn.net/zyooooxie
"""class Person2(object):"""property装饰器 可以用调用属性的形式来调用方法 [这个方法就变成了一个属性] ，后面不需要加()。把实例的某些属性保护起来，不让外部直接访问；外部使用getter读取属性和setter方法设置属性。"""def __init__(self, name, age=18):self.p_name = nameself.__p_age = ageself.__p_birthday = '0101'@property               # 把一个getter方法变成属性，只需要加上@property就可以了def age(self):"""Person2-这是 __doc__ """return self.__p_age# 以上 @property 装饰器会将 age() 方法转化为一个具有相同名称的只读属性的 "getter"，# 并将 age 的文档字符串设置为 "Person2-这是 __doc__ "# 特征属性对象具有 getter, setter 以及 deleter 方法，它们可用作装饰器来创建该特征属性的副本，并将相应的访问函数设为所装饰的函数。# 用户进行属性调用的时候，直接调用 age 即可，而不用知道属性名 __p_age，因此用户无法更改属性，从而保护了类的属性。@age.setter             # 负责把一个setter方法变成属性赋值def age(self, new_age):if not isinstance(new_age, int):raise ValueError('age must be an integer!')if new_age < 0 or new_age > 100:print('不能设置成功，但不报错')returnself.__p_age = new_age@age.deleterdef age(self):del self.__p_age@property       # 还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性【这个属性可以让用户使用，但没办法随意修改】def birthday(self):return self.__p_birthday# 要特别注意：属性的方法名 不要和 属性 重名！

"""
@blog: https://blog.csdn.net/zyooooxie
"""if __name__ == '__main__':passprint(Person2.__dict__)                 # 'age': <property object>p1 = Person2('zy1111', 1111)print(p1.age, '这是age')print(p1.__dict__)# p1.age = 10.7            # ValueError: age must be an integer!# print(p1.age)p1.age = 999                 # 不符合，故而 设置不成功print(p1.age, '那')print(p1.__dict__)p1.age = 28                 # 符合，设置成功print(p1.age, '符合，设置成功后的新值')print(p1.__dict__)p1._Person2__p_age = 111222.333          # 绕过了print(p1.age, '绕过去了')print(p1.__dict__)del p1.ageprint(p1.__dict__, '实际删除的是 _Person2__p_age ')print()print(p1.birthday)# p1.birthday = '0202'         # AttributeError: can't set attribute# del p1.birthday              # AttributeError: can't delete attributep1._Person2__p_birthday = ['0202', '0303']       # 绕过了print(p1.__dict__)print(Person2.__dict__)         # 'age': property object，未变

"""
@blog: https://blog.csdn.net/zyooooxie
"""if __name__ == '__main__':passprint(Person2.__dict__)             # 'age': <property object>print(Person2.age, Person2.age.__doc__)print()p2 = Person2('zy2222', 22)print(p2.__dict__)print(dir(p2))print(p2.age, '看清楚')print()# 千万不要随意修改类属性 (尤其是 值为 property object 的)Person2.age = '2sss'                # 修改类属性 'age': property object 变为 'age': '2sss'print(Person2.__dict__)p = Person2('zy', 11)print(p.__dict__)print(dir(p))# 实例是没有这个age属性(实例是有_Person2__p_age)，用了 类属性ageprint(p.age, '看清楚')print(p.p_name, p.age, p._Person2__p_age)print(p.__dict__)p.age = '8888zy'            # 给了实例属性print(p.p_name, p.age, p._Person2__p_age)print(p.__dict__, p.__dict__['_Person2__p_age'], p.__dict__['age'])del Person2.ageprint(Person2.__dict__)# 和 birthday 做个对比       'birthday': <property object># p.birthday = '0808'             # 实际报错 AttributeError: can't set attributedel p.birthday                      # AttributeError: can't delete attribute

私有类属性使用property装饰器

"""
@blog: https://blog.csdn.net/zyooooxie
"""import random
import string
from xxx_use.import_external_coupon import ImportExternalCoupon
from user_log import Logclass ImportExternalCouponNew(object):__EXCEL_PATH = r'D:\project_python\excel_folder'def __init__(self, start_num: str, middle_num: str, end_num: str, num: int = 100, beginning_letter: str = None,mixture_repeat_number: int = None):"""num是Excel生成的数量；beginning_letter是 是否添加字母；mixture_repeat_number是 混合生成Excel时 重复的条数；:param start_num::param middle_num::param end_num::param num::param beginning_letter::param mixture_repeat_number:"""Log.info('每次生成 {} 条'.format(num))Log.info('start_num = {}'.format(start_num))Log.info('middle_num = {}'.format(middle_num))Log.info('end_num = {}'.format(end_num))self.__start_num = start_numself.__middle_num = middle_numself.__end_num = end_numself.__beginning_letter = beginning_letterself.__mixture_repeat_number = mixture_repeat_numberself.__num = num@propertydef EXCEL_PATH(self):return self.__EXCEL_PATH@EXCEL_PATH.setterdef EXCEL_PATH(self, new_path):if isinstance(new_path, int):raise Exception('搞错了。。。{}'.format(new_path))self.__EXCEL_PATH = new_path@propertydef num(self):return self.__num@num.setterdef num(self, new_num):if isinstance(new_num, int) and new_num > 0:self.__num = new_numelse:Log.info('传参有误，{}'.format(new_num))raise

"""
@blog: https://blog.csdn.net/zyooooxie
"""if __name__ == '__main__':print(ImportExternalCouponNew.__dict__)iecn = ImportExternalCouponNew('123', '456', '789', 200)print(iecn.__dict__)print(dir(iecn))print(iecn.EXCEL_PATH)# iecn.EXCEL_PATH = 123456            # Exception: 搞错了。。。123456print()iecn.EXCEL_PATH = r'D:\project_python\zy'print(iecn.EXCEL_PATH, '新赋值')# 上面对iecn.EXCEL_PATH 重新赋值后，# 特别看下：实例对象的 _ImportExternalCouponNew__EXCEL_PATH 的值 和 类对象的 _ImportExternalCouponNew__EXCEL_PATH 的值 是不同的！print(iecn.__dict__)                            # '_ImportExternalCouponNew__EXCEL_PATH': 'D:\\project_python\\zy'print(ImportExternalCouponNew.__dict__)         # '_ImportExternalCouponNew__EXCEL_PATH': 'D:\\project_python\\excel_folder'# 'EXCEL_PATH': property object  未改变

一个错误的示例如下：


"""
@blog: https://blog.csdn.net/zyooooxie
"""if __name__ == '__main__':pass# ImportExternalCouponNew._ImportExternalCouponNew__EXCEL_PATH = r'D:\project_python\202112'        # 修改成功；未修改 EXCEL_PATH:property object# print(ImportExternalCouponNew.__dict__)# ---------------------------print(ImportExternalCouponNew.__dict__)# 'EXCEL_PATH': <property object > ，使用property# 'num': <property object >ImportExternalCouponNew.EXCEL_PATH = r'D:\project_python\202201'          # 修改了原本的 property object；但是 _ImportExternalCouponNew__EXCEL_PATH的值是 没变print(ImportExternalCouponNew.__dict__)print()en = mn = sn = random.randint(100000, 999999)iecn = ImportExternalCouponNew(str(sn), str(mn), str(en), num=100)print(iecn.__dict__)print(iecn.EXCEL_PATH)iecn.EXCEL_PATH = r'D:\project_python\zy'         # 实例对象.EXCEL_PATH是 覆盖 类对象的.EXCEL_PATH# iecn.num = 500.22                                 # 传参有误，500.22 实际报错：RuntimeError: No active exception to reraiseprint(iecn.EXCEL_PATH, iecn.num, '刚刚新赋值')iecn.EXCEL_PATH = 123456                        # 没有报错！！！print(iecn.EXCEL_PATH)print()print(iecn.__dict__)                                # 留意 EXCEL_PATHprint(ImportExternalCouponNew.__dict__)             # 留意 EXCEL_PATH

本文链接：https://blog.csdn.net/zyooooxie/article/details/108095932

交流技术欢迎+QQ 153132336 zy
个人博客 https://blog.csdn.net/zyooooxie