Python类中的①私有变量/方法、②静态方法和③类方法

最新推荐文章于 2024-04-27 19:14:16 发布
最新推荐文章于 2024-04-27 19:14:16 发布
阅读量1k 收藏 5
点赞数 1
分类专栏： Python 面试题（Interview Questions） 文章标签： python
搬的时候标注一下来源，谢谢。
本文链接：https://blog.csdn.net/weixin_44878336/article/details/124667428
版权

0. 引言

在Python的类中，默认的定义为公开变量/方法，当然也可以定义私有变量和私有方法，与其他语言不同的是，Python中使用__进行声明而非关键字进行声明。

1. 私有属性和私有方法

1.1 定义

  • 私有属性是指在 Python 的面向对象开发过程中，对象的某些属性只想在对象的内部被使用，但不想在外部被访问到这些属性。即，私有属性是对象不愿意公开的属性。
  • 私有方法是指在 Python 的面向对象开发过程中，对象的某些方法或者称为函数只想在对象的内部被使用，但不想在外部被访问到这些方法或函数。即：私有方法是对象不愿意公开的方法或函数。

1.2 语法

二者均使用开头__(两个下划线)进行定义：

  • 定义私有属性：self.__属性名 = xxx
  • 定义私有方法：def __方法名(参数)

例子：

class Demo:
    def __init__(self, param_1, param_2):
        self.param_1 = param_1  # 定义公有属性
        self.__param_2 = param_2  # 定义私有属性
    
    # 定义私有方法
    def __secret_function(self):
        print(f"[公有属性] self.param_1: {self.param_1}")
        print(f"[私有属性] self.__param_2: {self.__param_2}")

1.3 调用分析

1.3.1 私有属性

在__init__的对象初始化方法中，以两个下划线开头定义的__param_1属性就是私有属性。现在在对象的外部来调用一下__param_1属性，看是否能正常访问该私有属性。

class Demo:
    def __init__(self, param_1, param_2):
        self.param_1 = param_1  # 定义公有属性
        self.__param_2 = param_2  # 定义私有属性
    
    # 定义私有方法
    def __secret_function(self):
        print(f"[公有属性] self.param_1: {self.param_1}")
        print(f"[私有属性] self.__param_2: {self.__param_2}")
        
        
ins_obj = Demo(param_1="公有属性", param_2="私有属性")
print(ins_obj.param_1)
print(ins_obj.__param_2)


"""
    公有属性
    ---------------------------------------------------------------------------
    AttributeError                            Traceback (most recent call last)
    Input In [20], in <cell line: 14>()
         12 ins_obj = Demo(param_1="公有属性", param_2="私有属性")
         13 print(ins_obj.param_1)
    ---> 14 print(ins_obj.__param_2)

    AttributeError: 'Demo' object has no attribute '__param_2'
"""

从上图运行结果可以看出，第14行，即在对象外部访问对象的私有属性 __param_2 时，提示 AttributeError 错误，Demo对象 ins_obj 没有__param_2属性。

为了证明ins_obj 类对象确实是有 self.__param_2 这个实例属性的，只是因为在对象外部不能访问私有属性。我把 self.__param_2 修改为self.param_2，结果如下：

class Demo:
    def __init__(self, param_1, param_2):
        self.param_1 = param_1  # 定义公有属性
#         self.__param_2 = param_2  # 定义私有属性
        self.param_2 = param_2  # 将私有属性改为公有属性
    
    # 定义私有方法
    def __secret_function(self):
        print(f"[公有属性] self.param_1: {self.param_1}")
        print(f"[私有属性] self.__param_2: {self.param_2}")
        
        
ins_obj = Demo(param_1="公有属性", param_2="私有方法 -> 公有属性")
print(ins_obj.param_1)
print(ins_obj.param_2)


"""
    公有属性
    私有方法 -> 公有属性
"""

可以从运行结果看出，这种公有属性在外部的调用是正常的，没有提示 AttributeError 错误。

1.3.2 私有方法

在__secret_function(self) 实例方法中，以两个下划线开头定义的__secret_function(self) 方法就是私有方法。和上面测试流程一样，先在对象的外部来调用私有方法__secret_function(self) ，看是否能正常调用该私有方法。

class Demo:
    def __init__(self, param_1, param_2):
        self.param_1 = param_1  # 定义公有属性
        self.__param_2 = param_2  # 定义私有属性
    
    # 定义私有方法
    def __secret_function(self):
        print(f"[公有属性] self.param_1: {self.param_1}")
        print(f"[私有属性] self.__param_2: {self.__param_2}")
        
        
ins_obj = Demo(param_1="公有属性", param_2="私有属性")
print(ins_obj.param_1)
try:
    print(ins_obj.__param_2)
except Exception as e:
    print(f"在调用私有属性时发生错误: {e}")
    
# 调用私有方法
ins_obj.__secret_function()


"""
    公有属性
    在调用私有属性时发生错误: 'Demo' object has no attribute '__param_2'
    ---------------------------------------------------------------------------
    AttributeError                            Traceback (most recent call last)
    Input In [22], in <cell line: 20>()
         17     print(f"在调用私有属性时发生错误: {e}")
         19 # 调用私有方法
    ---> 20 ins_obj.__secret_function()

    AttributeError: 'Demo' object has no attribute '__secret_function'
"""

从上图运行结果可以看出，第20行，即在对象外部访问对象的私有方法__secret_function(self) 时，提示 AttributeError 错误，Demo 对象 ins_obj 没有 __secret_function(self) 方法。

为了证明 Demo 类对象是有 __secret_function(self) 这个实例方法的，只是因为在对象外部不能访问私有方法。把__secret_function(self) 方法修改为：secret_function(self) ，其他代码不变，看如下的运行结果。

class Demo:
    def __init__(self, param_1, param_2):
        self.param_1 = param_1  # 定义公有属性
        self.__param_2 = param_2  # 定义私有属性
    
    # 定义私有方法
    def secret_function(self):  # 将私有方法改为公有方法
        print(f"[公有属性——类内部调用] self.param_1: {self.param_1}")
        print(f"[私有属性——类内部调用] self.__param_2: {self.__param_2}")
        
        
ins_obj = Demo(param_1="公有属性", param_2="私有属性")
print(f"[类外部调用] ins_obj.param_1: {ins_obj.param_1}")
try:
    print(f"[类外部调用] ins_obj.__param_2: {ins_obj.__param_2}")
except Exception as e:
    print(f"在调用私有属性时发生错误: {e}")
    
# 调用公有方法
ins_obj.secret_function()


"""
    [类外部调用] ins_obj.param_1: 公有属性
    在调用私有属性时发生错误: 'Demo' object has no attribute '__param_2'
    [公有属性——类内部调用] self.param_1: 公有属性
    [私有属性——类内部调用] self.__param_2: 私有属性
"""

可以从运行结果看出，这种非私有方法在外部的调用是正常的，没有提示 AttributeError 错误。

1.3.3 类内部调用私有属性/方法

在对象内部私有方法与私有属性是可以被调用的，证明如下：

class Demo:
    def __init__(self, param_1, param_2):
        self.param_1 = param_1  # 定义公有属性
        self.__param_2 = param_2  # 定义私有属性
    
    # 定义私有方法
    def __secret_function(self):  # 私有方法
        print(f"[公有属性——类内部调用] self.param_1: {self.param_1}")
        print(f"[私有属性——类内部调用] self.__param_2: {self.__param_2}")
    
    # 定义公有方法并在公有方法中调用私有方法和私有属性
    def public_function(self):  # 公有方法
        # 分别调用公有属性和私有属性
        print(f"[public_function内部调用] self.param_1: {self.param_1}")
        print(f"[public_function内部调用] self.__param_2: {self.__param_2}")
        
        # 调用私有方法
        self.__secret_function()
        
        
ins_obj = Demo(param_1="公有属性", param_2="私有属性")
print(f"[类外部调用] ins_obj.param_1: {ins_obj.param_1}")
try:
    print(f"[类外部调用] ins_obj.__param_2: {ins_obj.__param_2}")
except Exception as e:
    print(f"在调用私有属性时发生错误: {e}")

# 调用类的私有方法
try:
    ins_obj.__secret_function()
except Exception as e:
    print(f"在调用私有方法时发生错误: {e}")
    
# 调用公有方法
ins_obj.public_function()


"""
    [类外部调用] ins_obj.param_1: 公有属性
    在调用私有属性时发生错误: 'Demo' object has no attribute '__param_2'
    在调用私有方法时发生错误: 'Demo' object has no attribute '__secret_function'
    [public_function内部调用] self.param_1: 公有属性
    [public_function内部调用] self.__param_2: 私有属性
    [公有属性——类内部调用] self.param_1: 公有属性
    [私有属性——类内部调用] self.__param_2: 私有属性
"""

上述代码中，public_function公有方法调用了私有属性self.__param_2和私有方法__secret_function(self)。说明在对象外部可以通过调用对象的公有方法去访问私有属性和私有方法（前提是得在类的内部定义好相关的代码）。

在类的内部，私有属性和私有方法是可以随意被调用的，一旦到了类的外部，那就不能调用了！

1.3.4 子类 内部/外部 调用私有属性/方法

class Demo:
    def __init__(self, param_1, param_2):
        self.param_1 = param_1  # 定义公有属性
        self.__param_2 = param_2  # 定义私有属性
    
    # 定义私有方法
    def __secret_function(self):  # 私有方法
        print(f"[公有属性——类内部调用] self.param_1: {self.param_1}")
        print(f"[私有属性——类内部调用] self.__param_2: {self.__param_2}")
    
    # 定义公有方法并在公有方法中调用私有方法和私有属性
    def public_function(self):  # 公有方法
        # 分别调用公有属性和私有属性
        print(f"[public_function内部调用] self.param_1: {self.param_1}")
        print(f"[public_function内部调用] self.__param_2: {self.__param_2}")
        
        # 调用私有方法
        self.__secret_function()
        
class Demo_child(Demo):
    # 继承Demo的一切
    # 定义公有方法访问父类的私有属性和方法
    def public_child(self):
        # 分别调用公有属性和私有属性
        print(f"[public_child内部调用] self.param_1: {self.param_1}")
        print(f"[public_child内部调用] self.__param_2: {self.__param_2}")
        
        # 调用私有方法
        self.__secret_function()
        
        
child_obj = Demo_child(param_1="Re-公有属性", param_2="Re-私有属性")
print(f"[成功] [类外部调用-子类调用父类公有属性] child_obj.param_1: {child_obj.param_1}")
try:
    print(f"[成功] [类外部调用-子类调用父类私有属性] child_obj.__param_2: {child_obj.__param_2}")
except Exception as e:
    print(f"[失败] 子类调用父类私有属性时发生错误: {e}")

# 子类调用父类的私有方法
try:
    print("......................[开始] 子类调用父类的私有方法......................")
    child_obj.__secret_function()
    print("[成功] 子类调用父类的私有方法")
except Exception as e:
    print(f"[失败] 子类调用父类的私有方法时发生错误: {e}")
    
# 子类调用父类的公有方法
try:
    print("......................[开始] 子类调用父类的公有方法......................")
    child_obj.public_function()
    print("[成功] 子类调用父类的公有方法")
except Exception as e:
    print(f"[失败]子类调用父类的公有方法时发生错误: {e}")

# 子类调用自己的公有方法
try:
    print("......................[开始] 子类调用自己的公有方法......................")
    child_obj.public_child()
    print("[成功] 子类调用自己的公有方法")
except Exception as e:
    print(f"[失败] 子类调用自己的公有方法时发生错误: {e}")
    

"""
    [成功] [类外部调用-子类调用父类公有属性] child_obj.param_1: Re-公有属性
    [失败] 子类调用父类私有属性时发生错误: 'Demo_child' object has no attribute '__param_2'
    ......................[开始] 子类调用父类的私有方法......................
    [失败] 子类调用父类的私有方法时发生错误: 'Demo_child' object has no attribute '__secret_function'
    ......................[开始] 子类调用父类的公有方法......................
    [public_function内部调用] self.param_1: Re-公有属性
    [public_function内部调用] self.__param_2: Re-私有属性
    [公有属性——类内部调用] self.param_1: Re-公有属性
    [私有属性——类内部调用] self.__param_2: Re-私有属性
    [成功] 子类调用父类的公有方法
    ......................[开始] 子类调用自己的公有方法......................
    [public_child内部调用] self.param_1: Re-公有属性
    [失败] 子类调用自己的公有方法时发生错误: 'Demo_child' object has no attribute '_Demo_child__param_2'
"""

可以看到，子类可以调用：

  1. 父类的公有属性
  2. 父类的公有方法（无论该公有方法是否调用父类的私有方法/属性）
  3. 子类的公有方法（里面不能直接调用父类的私有方法！）

子类不能直接调用父类的私有方法和私有属性，但可以通过调用父类的公有方法间接访问父类的私有方法（即该父类的公有方法调用了父类的私有方法）。

1.4 Python 伪·私有属性和私有方法

在 Python 中，并没有真正意义上的私有，之所以上面的例子中我们无法访问在外部访问私有方法和私有属性，是因为 Python 内部在给属性、方法命名时，对名称做了一些特殊处理，使得外界无法访问到对应的属性和方法。

以私有属性和私有方法为例，Python内部处理方式为：

  1. 属性: __param_1,经过处理后的属性名为:_Demo__param_1 ，即_类名__属性名
  2. 方法: __secret_function,经过处理后的方法名为:_Demo__secret_function，即_类名__方法名

知道了 Python 内部对于私有属性和私有方法的处理，现在使用这种处理后的命名方式来在对象外部访问私有属性和私有方法，看是否能访问正常。

class Demo:
    def __init__(self, param_1, param_2):
        self.param_1 = param_1  # 定义公有属性
        self.__param_2 = param_2  # 定义私有属性
    
    # 定义私有方法
    def __secret_function(self):  # 私有方法
        print(f"[公有属性——类内部调用] self.param_1: {self.param_1}")
        print(f"[私有属性——类内部调用] self.__param_2: {self.__param_2}")
    
    # 定义公有方法并在公有方法中调用私有方法和私有属性
    def public_function(self):  # 公有方法
        # 分别调用公有属性和私有属性
        print(f"[public_function内部调用] self.param_1: {self.param_1}")
        print(f"[public_function内部调用] self.__param_2: {self.__param_2}")
        
        # 调用私有方法
        self.__secret_function()
        

ins_obj = Demo(param_1="公有属性", param_2="私有属性")
print(f"[成功] [类外部调用公有属性] ins_obj.param_1: {ins_obj.param_1}")

try:
    print(f"[成功] [类外部调用私有属性] ins_obj.__param_2: {ins_obj._Demo__param_2}")
except Exception as e:
    print(f"[失败] 类外部调用私有属性时发生错误: {e}")

# 调用私有方法
try:
    ins_obj._Demo__secret_function()
    print("[成功] 类外部调用私有方法")
except Exception as e:
    print(f"[失败] 类外部调用私有方法时发生错误: {e}")
    
    
"""
    [成功] [类外部调用公有属性] ins_obj.param_1: 公有属性
    [成功] [类外部调用私有属性] ins_obj.__param_2: 私有属性
    [公有属性——类内部调用] self.param_1: 公有属性
    [私有属性——类内部调用] self.__param_2: 私有属性
    [成功] 类外部调用私有方法
"""

控制台没有抛任何的异常，之前的提示 AttributeError 错误也没有了。

这个例子证明了 Python 是没有真正意义上的私有的，当知道了其内部处理方式后，依然可以使用实例对象._类名__属性名(方法名)的方法来在对象外部访问到对象内部定义的私有属性和私有方法。

但这种方式在日常工作中是不推荐使用的，既然在对象内部定义属性和方法时，就声明了其为私有的，调用方就需要遵守其规则。

2. 实例方法、静态方法和类方法

2.1 实例方法/对象方法

实例方法或者叫对象方法，指的是我们在类中定义的普通方法。只有实例化对象之后才可以使用的方法，该方法的第一个形参接收的一定是对象本身self。

说白了实例化方法就是我们最常用的方法，例子如下：

class Demo:
    # 定义一个实例方法（对象方法）
    def ins_func(self):  # 对于实例方法，self不能省略
        print("这是一个[实例方法]")
        

# [实例化方法] 方法1：实例化对象 -> 变量接收 -> 变量.调用实例方法
ins_obj = Demo()
ins_obj.ins_func()

# [实例化方法] 方法2：实例化对象.调用实例方法（没有实例化对象的接收变量）
Demo().ins_func()  # Demo的()就说明实例化对象了！


"""
    这是一个[实例方法]
    这是一个[实例方法]
"""

2.2 静态方法

  1. 格式：在方法上面添加 @staticmethod
  2. 参数：静态方法可以有参数也可以无参数
  3. 应用场景：一般用于和类对象以及实例对象无关的代码
  4. 使用方式： 类名.类方法名(或者对象名.类方法名)

例子：

class Demo:
    # 定义一个实例方法（对象方法）
    def ins_func(self):  # 对于实例方法，self不能省略
        print("这是一个[实例方法]")
        
    # 定义一个静态方法
    @staticmethod
    def static_method():  # 参数可有可无
        print("这是一个[静态方法]")
        

# [实例化方法] 方法1：实例化对象 -> 变量接收 -> 变量.调用实例方法
ins_obj = Demo()
ins_obj.ins_func()

# [实例化方法] 方法2：实例化对象.调用实例方法（没有实例化对象的接收变量）
Demo().ins_func()  # Demo的()就说明实例化对象了！



# [静态方法] 不用实例化对象，直接调用静态方法
Demo.static_method()
# Demo().static_method()  # 也不报错，但一般不这么用（因为会实例化对象）


"""
    这是一个[实例方法]
    这是一个[实例方法]
    这是一个[静态方法]
"""

2.3 类方法

类方法无需实例化，可以通过类直接调用的方法，但是方法的第一个参数接收的一定是类本身cls。

  1. 在方法上面添加@classmethod
  2. 方法的参数为 cls 也可以是其他名称，但是一般默认为cls
  3. cls 指向 类对象
  4. 应用场景：当一个方法中只涉及到静态属性的时候可以使用类方法(类方法用来修改类属性)
  5. 使用方法（两种均可）：
    1. 对象名.类方法名
    2. 类名.类方法名

例子：

class Demo:
    # 0. 定义一个类属性
    __private_attr = 1
    
    
    # 1. 定义一个实例方法（对象方法）
    def ins_func(self, param_ins):  # 对于实例方法，self不能省略
        self.param_ins = param_ins
        print(f"这是一个[实例方法]: {self.param_ins}")
        
    # 2. 定义一个静态方法
    @staticmethod
    def static_method(param_static):  # 参数可有可无
        print(f"这是一个[静态方法]: {param_static}")
        
    # 3. 定义一个类方法
    @classmethod
    def class_method(cls, param_cls):
        print(f"这是一个[类方法]： {param_cls}")
        print(f"[修改前]类属性为: {cls.__private_attr}")
        cls.__private_attr = param_cls
        print(f"[修改后]类属性为: {cls.__private_attr}\n")
        
        try:        
            print(f"[修改前]类属性self.param_ins为: {cls.param_ins}")
            cls.param_ins = param_cls
            print(f"[修改后]类属性self.param_ins为: {cls.param_ins}")
        except Exception as e:
            print("类方法只能修改类属性，不能修改实例方法的类属性！")
        
        

# [实例化方法] 方法1：实例化对象 -> 变量接收 -> 变量.调用实例方法
ins_obj = Demo()
ins_obj.ins_func(param_ins = "实例方法ins_func传入的参数")

# [实例化方法] 方法2：实例化对象.调用实例方法（没有实例化对象的接收变量）
Demo().ins_func(param_ins = "实例方法ins_func传入的参数")  # Demo的()就说明实例化对象了！



# [静态方法] 不用实例化对象，直接调用静态方法
Demo.static_method(param_static="静态方法static_method传入的参数")
# Demo().static_method(param_static="静态方法static_method传入的参数")  # 也不报错，但一般不这么用（因为会实例化对象）


# [类方法] 方法1：对象名.类方法名
ins_obj.class_method(100)

# [类方法] 方法2：类名.类方法名
Demo.class_method(100)


"""
    这是一个[实例方法]: 实例方法ins_func传入的参数
    这是一个[实例方法]: 实例方法ins_func传入的参数
    这是一个[静态方法]: 静态方法static_method传入的参数
    这是一个[类方法]： 100
    [修改前]类属性为: 1
    [修改后]类属性为: 100

    类方法只能修改类属性，不能修改实例方法的类属性！
    这是一个[类方法]： 100
    [修改前]类属性为: 100
    [修改后]类属性为: 100

    类方法只能修改类属性，不能修改实例方法的类属性！
"""

参考

  1. https://www.jb51.net/article/239280.htm
  2. https://blog.csdn.net/weixin_39898248/article/details/109935893
Le0v1n
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python3基础之面向对象的类变量，类方法，静态方法
qq_36242554的博客
12-21 510
类变量 1.定义：在类中，方法外定义变量 class 类名： 变量名 = 表达式 2.调用： 类名.变量名 不建议通过对象访问类变量 3.说明 存储在类中 只有一份，被所有对象共享 4.作用：描述所有对象的共有数据 class ICBC: """ 工商银行 """ # 表示总行的钱 total_money = 1000000 def __init__(self, name, money): self.name
Python类的实例方法、静态方法和类方法
Always On The Way
05-05 329
Python类语法中支持三种方法：实例方法，静态方法，类方法。 class Foo(object): """类三种方法语法形式""" def instance_method(self): print("是类{}的实例方法，只能被实例对象调用".format(Foo)) @staticmethod def static_method(): ...
Python 私有变量
qq_49873907的博客
04-17 4165
定义私有变量可以在变量名前加上两个 "_"，来表示（这里说的私有变量并不是真正的私有，而是尽量避免从外部进行访问）class C: #定义类Cdef __init__(self,x): #定义带参构造函数self.__x = x #定义私有变量def set_x(self,x): #定义set_x方法，设置私用变量的值def get_x(self): #定义get_x方法，获取私有变量的值c = C(22)c.__x #从外部访问私有变量会报错'''c.__x'''
Python私有属性与私有方法
m0_59485658的博客
03-17 4670
1、 场景定义 私有属性 是指在 Python 的面向对象开发过程中，对象的某些属性只想在对象的内部被使用，但不想在外部被访问到这些属性。 即：私有属性是对象不愿意公开的属性。 私有方法 是指在 Python 的面向对象开发过程中，对象的某些方法或者称为函数只想在对象的内部被使用，但不想在外部被访问到这些方法或函数。 即：私有方法是对象不愿意公开的方法或函数。 2、 语法定义 在 Python 中定义私有属性和私有方法的语法如下： class Staff: def __ini..
Python零基础入门篇 - 35 - 私有函数、私有变量及封装(1)
最新发布
m0_63174618的博客
04-27 986
return f’{self.name} 最喜欢吃水果是 ‘榴莲’ 和 ‘番石榴’’return f’{self.name} 最喜欢的健身方式是 ‘跑步’ 和 ‘游泳’’
类的属性（公有属性，受保护属性，私有属性，只读属性propery）
weixin_62848630的博客
04-18 937
class Animal: x = 10 def test(self): print(Animal.x) print(self.x) #self是类本身，等于Animal pass class Dog(Animal): def test2(self): print(Dog.x) print(self.x) pass print(Animal.
Python 私有变量和私有方法介绍
cnds123的专栏
06-12 1511
Python 私有变量和私有方法介绍
Python中私有方法定义
HJ_blog
08-29 1589
python中私有方法定义
python类私有变量
alex1801
06-15 1009
1、类list 1.1、__len__ __len__()方法我们也知道是为了能让class作用于len()函数。 1.2、__getitem__ Fib实例虽然能作用于for循环，看起来和list有点像，但是，把它当成list来使用还是不行，比如，取第5个元素： >>> Fib()[5] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError:
Python 面向对象静态方法、类方法、属性方法知识点小结
09-17
在类的定义中，有三种特殊的方法类型：静态方法、类方法和属性方法，它们在不同场景下各有其独特的用途。 1. 静态方法（Static Method） 静态方法是通过`@staticmethod`装饰器定义的，它们与类和实例都没有直接的...
Python语言基础：类的变量方法.pptx
05-05
Python是一种高级编程语言，以其...了解类的变量和方法，包括构造方法`__init__`、私有成员、静态方法和类方法，对于掌握Python面向对象编程至关重要。理解并熟练运用这些概念，将有助于编写更加高效和易于维护的代码。
Python编程之属性和方法实例详解
09-22
在Python编程中，属性和方法是面向对象编程的基础概念，它们是类（class）的核心组成部分。下面我们将深入探讨这两个概念。 一、属性 属性是用来描述对象状态的数据成员。在Python中，属性分为两种：公有属性...
python面向对象_详谈类的继承与方法的重载
12-24
上面就是先定义了一个类A，然后由定义了一个类B，B继承了类A，这样B就有了A的非私有属性和方法。 class Washer: company='ZBL' def __init__(self,water=10,scour=2): self._water=water #不想让用户直接访问...
面向对象（类方法+静态方法+属性方法私有化、异常处理）
02-06
私有化（Private）在面向对象编程中是一种封装策略，用于限制对类内部属性和方法的直接访问。在Python中，我们通过在变量或方法名前加上两个下划线`__`来实现私有化。尽管Python并没有严格的私有化，但这种命名约定...
私有属性和私有方法
liupc的学习笔记
11-03 3907
一、定义 什么是私有属性和私有方法呢？有时候某些属性和方法 只希望在对象内部被使用，不希望外部使用。 私有属性：对象不希望公开的属性。 私有方法：对象不希望公开的方法。 二、使用 在定义属性或方法的时候，在属性名或方法名前增加两个下划线，就定义为了私有属性或方法。 私有属性，外部不能访问。【例1】 在对象的方法内部是可以访问私有属性的。外部可以访问函数。【例2】 外部不能访问私...
Python学习之-私有变量、方法
Summer的博客
04-08 971
在Python中，不像一些其他编程语言如Java或C++，并没有严格意义上的“私有”函数。不过，Python有一种约定俗成的做法来指示一个函数是私有的，这意味着它不应该被外部访问。在Python中，如果你想定义一个私有函数，你可以在函数名称前加上两个下划线__。这会触发一个名字改编（name mangling）的过程，使得这个函数在外部不容易被直接访问。这种机制的目的是为了“伪私有”，实际上是提供了一种弱保护措施来避免子类意外覆盖基类的方法。
类的私有方法 | python
weixin_48888528的博客
04-06 1133
考虑一个类中需要进行某些较为复杂的操作，如果直接将这些操作暴露给外部，可能会导致外部代码直接修改内部状态，进而破坏类的一些内部逻辑。私有方法的存在可以把复杂的逻辑封装在类的内部，对于外部代码来说，只需要关注类对外公开的接口，而不需要关心内部实现细节。私有方法是指在类中定义的方法，它只能在类的内部被访问和调用，而不能在类实例化之后被外部代码访问和调用。在面向对象编程中，私有方法主要用于封装类的实现细节，避免外部代码直接访问和修改内部状态，从而保证类的封装性和安全性。
python中类的封装--详解类中的私有变量、私有方法和静态属性
敲代码的设计师
03-14 518
当程序完成的时候，有些数据和代码我们就不希望别人调用或者查看的时候，可以对程序进行封装，在python中主要就是进行变量或者方法的私有化。 我们可以在变量或者方法前面加上__，两个下划线来进行私有化，使其变成私有变量或者私有方法，这样在外部就不可以直接调用了，类中私有化的内容由3个，分别是 1）私有化变量 2）私有化方法 3）静态变量 1.先说下私有化变量，比如下面的代码 class Person...
python基础面向对象(三)
抓一只橙煦⚪
09-15 176
私有属性 面向对象三大特性(核心)：封装、继承、多态 封装的意义： 将属性和方法放到一起做为一个整体，然后通过实例化对象来处理； 隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了； 对类的属性和方法增加 访问权限控制。 私有权限：在属性名和方法名 前面 加上两个下划线 __ 类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问； 类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问； 私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。 私有
Python编程：私有属性、方法与特殊方法解析
总结，Python中的面向对象编程提供了丰富的特性，如私有属性和方法的封装，可调用对象的实现，以及静态方法和实例属性、类属性的使用，这些都极大地增强了代码的灵活性和可维护性。理解并熟练运用这些概念是提升...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值