精华内容
下载资源
问答
  • Python访问私有成员变量

    千次阅读 2018-07-03 10:14:49
    首先,Python 正常访问公有成员变量的方式为: class PrivateTest: name = "private" if __name__ == "__main__": pt = PrivateTest() print(pt.name) 输出结果为: private Python ...

    首先,Python 正常访问公有成员变量的方式为:

    class PrivateTest:
        name = "private"
    
    
    if __name__ == "__main__":
        pt = PrivateTest()
        print(pt.name)
    

    输出结果为:

    private
    

    Python 中将成员和方法私有化的方式是在成员名或者方法名前面加两个下划线,如下:

    class PrivateTest:
        __name = "private"
    
    
    if __name__ == "__main__":
        pt = PrivateTest()
        print(pt.__name)
    

    运行报错:

     print(pt.__name)
    AttributeError: 'PrivateTest' object has no attribute '__name'
    

    换个方式:

    class PrivateTest:
        __name = "private"
    
    
    if __name__ == "__main__":
        pt = PrivateTest()
        print(pt.name)
    

    运行依然报错:

     print(pt.name)
    AttributeError: 'PrivateTest' object has no attribute 'name'
    

    Python 中访问私有成员变量的正确方式为:实例类.类名_变量名

    class PrivateTest:
        __name = "private"
    
    
    if __name__ == "__main__":
        pt = PrivateTest()
        print(pt._PrivateTest__name)
    

    输出结果:

    private
    
    展开全文
  • 私有成员只允许类函数内部使用,类外部不能访问。 如果需要强制使用,使用方法是"对象名._类名__xxx" class One: def __init__(self,a=1111,b=2222): # 构造方法 """构造函数""" self.__a = a...

    什么是私有成员?

    • 从形式上看,如果成员名有两个下划线(__)开头则表示私有成员。
    • 私有成员只允许类函数内部使用,类外部不能访问。
    • 如果需要强制使用,使用方法是"对象名._类名__xxx"
    class One:
        def __init__(self,a=1111,b=2222):       # 构造方法
            """构造函数"""
            self.__a = a                        # 私有成员
            self._b = b                         # 公有成员    
    
        def SetValue(self,a,b):                 # 成员方法
            self.__a = a                        # 私有成员方法
            self._b = b                         # 公有成员方法
    
        def show(self):                         # 成员方法
            print(self.__a)
            print(self._b)
    
    
    # 实例化对象
    one = One()
    
    # 在类外部可以直接访问非私有成员
    print(one._b)
    
    # 在类外部强制访问对象的私有数据
    print(one._One__a)
    
    
    

    运行结果

    2222
    1111
    
    展开全文
  • 私有成员 作用: 向类外提供必要的功能,不必要的隐藏(隐藏实现的细节),用户就无法从外面访问这个成员了 做法: 命名使用双下划线开头(名称被修改为_类名__成员名) #定义一个Wife类 class Wife: def __init__(self,...
    私有成员

    作用: 当你在封装时,只需要向类外提供必要的功能,需要把外界不必要的隐藏掉(实现的细节)
    语法: 命名使用双下划线开头(通过obj.__dict__查看,名称被修改为_类名__成员名)

    class Wife:
    	'''演示对私有成员进行只读'''
    	 def __init__(self,name):
    	 	self.name = name
    	 	self.__age = 25
    	 
    	 #对私有成员进行读操作的方法
    	 @property
    	 def age(self):
    	 	return self.__age
    
    w01 = Wife01('小乔')	
    w01.age = 18	#对他进行写操作会报错(因为被@property拦截了,显示can`t set attribute)	
    
    class Wife:
    	'''演示实现对私有成员进行读写'''
    	def __init__(self,name,age):
    		self.name = name
    		self.age = age
    	
    	#对age进行读操作的方法
    	@property
    	def age(self):
    		return self.__age
    	
    	#对age进行写操作的方法
    	@age.setter
    	def age(self,value):
    		if 25<=value<=30:
    			self.__age = value
    		else:
    			raise ValueError(’我不要')
    		
    		
    w01 = Wife('甄宓',250)
    print(w01.age)
    print(w01.__dict__)	#查看该类的所有属性,包括私有变量
    print(w01.__wife__age)	#访问私有变量(私有变量是障眼法,其实还是可以通过这种方式访问)
    
    展开全文
  • 文章目录1、私有成员变量(类中数据的封装)(1)私有成员变量概念(2)私有成员变量特点(3)私有成员变量体验属性不被私有化情况:属性被私有化情况:2、属性私有化工作原理3、定义成员变量的标识符规范4、私有...

    1、私有成员变量(类中数据的封装)

    (1)私有成员变量概念

    在Python面向对象中,把类的某些属性,如果在使用的过程中,不希望被外界直接访问,就可以将该属性设置为私有的,即只有当前类持有,然后暴露给外界一个访问的函数,来实现间接的访问对象属性,这就是类中数据的封装。

    如果类中的属性不想被外界直接访问,则可以在属性的前面添加两个下划线__,此时称该属性为私有属性,即私有成员变量。

    封装的本质:就是属性的私有化。

    (2)私有成员变量特点

    只能在类的内部被直接访问,在外界不能直接访问。

    (3)私有成员变量体验

    属性不被私有化情况:
    # 1.属性不私有化的时候
    class Student():
        def __init__(self, name, age):
            self.name = name
            self.age = age
    
        def tellMe(self):
            print(f"大家好,我是{self.name},年龄{self.age}")
    
    
    # 创建对象
    stu = Student("孙悟空", 18)
    
    # 通过对象.成员函数,调用函数并访问对象中的成员变量
    stu.tellMe()
    
    # 通过对象.属性,直接访问对象中的属性
    print(f"大家好,我是{stu.name},年龄{stu.age}")
    
    # 通过对象直接访问对象的属性,并给属性赋值
    stu.name = "齐天大圣"
    print(stu.name)  # 齐天大圣
    
    """
    输出结果:
    大家好,我是孙悟空,年龄18
    大家好,我是孙悟空,年龄18
    齐天大圣
    
    
    可以看到都可以访问到。
    """
    
    属性被私有化情况:
    # 2.属性私有化的时候
    class Student():
        def __init__(self, name, age):
            self.name = name
            # 私有化age属性
            self.__age = age
    
        def tellMe(self):
            print(f"大家好,我是{self.name},年龄{self.__age}")
    
    # 创建对象
    stu = Student("孙悟空", 18)
    
    # 通过对象.成员函数,调用函数并访问对象中的成员变量
    # 可以访问当对象中的私有成员变量
    # 输出:大家好,我是孙悟空,年龄18
    stu.tellMe()
    
    # 通过对象.属性,直接访问对象中的属性
    # 报错:
    # AttributeError: 'Student' object has no attribute '__age'
    # print(f"大家好,我是{stu.name},年龄{stu.__age}")
    
    # 直接通过对象.属性,修改成员变量属性值
    # 可以
    stu.name = "齐天大圣"
    print(stu.name)  # 齐天大圣
    # 结果:大家好,我是齐天大圣,年龄18
    stu.tellMe()
    
    # 直接通过对象.属性,修改私有成员变量属性值
    # 输出了结果
    stu.__age = 30
    print(stu.__age)  # 30
    # 结果:大家好,我是齐天大圣,年龄18
    # 但是通过调用对象中的方法,查看对象的私有属性
    # 结果并没有变化,还是18
    stu.tellMe()
    
    """
    但是我们通过__dict__属性查看stu对象的所有成员:
    {'name': '齐天大圣', '_Student__age': 18, '__age': 30}
    可以看到我们并没有修改原有的属性'_Student__age': 18,
    而是给stu对象新添加了一个属性 '__age': 30。
    所以说我们并没有对私有成员变量age重新赋值成功。
    只有 '_Student__age': 18为什么指的是私有变量的age,
    我们下面的私有成员原理就会讲解。
    """
    print(stu.__dict__)
    
    

    双下划线开头的属性,是对象的隐藏属性,隐藏属性只能在类的内部访问,无法通过对象访问

    2、属性私有化工作原理

    class Student():
        def __init__(self, name, age):
            self.name = name
            # 私有化成员属性
            self.__age = age
    
        def tellMe(self):
            print(f"大家好,我是{self.name},年龄{self.__age}")
    
    
    """
    其实隐藏(私有化)属性只不过是Python自动为属性改了一个名字
    实际上是将名字修改为了,_类名__属性名 
    比如 __age -> _Student__name,
    也就是在原有的变量名前边加上了 _类名。
    """
    
    # 创建对象
    stu = Student("孙悟空", 18)
    # 结果:大家好,我是孙悟空,年龄18
    stu.tellMe()
    
    # 直接通过对象.属性,修改对象的私有成员变量
    # 通过下面的打印结果可以看到,修改成功了
    stu._Student__age = 30
    # 结果:大家好,我是孙悟空,年龄30
    stu.tellMe()
    

    总结:

    Python中,并没有 真正意义私有,实际是对成员变量的名称做了一些特殊处理,使得外界无法访问到。

    所以定义为双下划线__开头的属性,实际上依然可以在外部访问。

    但平时我们不建议这么访问私有属性。

    3、定义成员变量的标识符规范

    • xxx:普通变量。

    • _xxx:使用_开头的属性为受保护的变量,没有特殊需要不要修改。

    • __xxx:使用双_开头的属性私有变量,在外界不能直接被访问。

    • __xxx__:系统的内置变量。

    • xx_:单后置下划线,用于避免与Python关键词的冲突。

    示例:

    class Student():
        def __init__(self, name, age, gender):
            # 在变量的前面添加一个下划线,属于特殊变量,则认为该变量受保护的
            self._name = name
    
            # 在变量的前添加双下划线。表示定义私有变量。
            # 特点:对象不能直接使用
            self.__age = age
    
            # 在变量的前后各添加两个下划线,属于特殊变量,一般认为这种变量都是系统的内置变量或者内置函数
            # 特点:在类的外面也可以直接访问,但不建议使用
            self.__gender__ = gender
    
    
    stu = Student("唐僧", 66, "男")
    print(stu._name)  # 唐僧
    print(stu.__gender__)  # 男
    
    

    4、私有成员变量的获取和设置方式

    方式:

    如何获取(修改)对象中的私有属性?

    需要提供一个getter和setter方法使外部可以访问到属性。

    • getter()方法用来获取对象中的指定属性

      getter()方法的规范命名为get_属性名

    • setter()方法用来设置对象的指定属性(set_属性名)

      setter()方法的规范命名为set_属性名

    格式:

    getter()方法:会有一个返回值

        def get_xxx(self):
            return self.属性名
    

    setter()方法:没有返回值,但是方法多一个参数

    def set_xxx(self, 形参名称):
                self.属性名 = 形参名称的值
    

    示例:

    class Student():
        def __init__(self, name, age):
            # 普通变量
            self.name = name
            # 私有变量
            self.__age = age
    
        def tellMe(self):
            print(f"大家好,我是{self.name},年龄{self.__age}")
    
        def get_name(self):
            """
                get_name()用来获取对象的name属性
            """
            return self.name
    
        def set_name(self, name):
            """
                set_name()用来设置对象的name属性
            """
            self.name = name
    
        def get_age(self):
            return self.__age
    
        def set_age(self, age):
            if age > 0:
                self.__age = age
    
    
    # 创建对象
    stu = Student("孙悟空", 18)
    # 输出结果:大家好,我是孙悟空,年龄18
    stu.tellMe()
    
    # 修改属性值
    stu.set_name("齐天大圣")
    stu.set_age(30)
    
    # 打印属性值
    # 结果都是:大家好,我是齐天大圣,年龄30
    stu.tellMe()
    print(f"大家好,我是{stu.get_name()},年龄{stu.get_age()}")
    
    """
    私有属性只能在类内部使用,对象不能直接使用,但是我们可以通过在类内部定义公有方法对私有属性进行调用或修改,然后对象在调用这个公有方法使用
    """
    

    总结:

    • 不管是普通方法和私有方法都可以使用getter()方法和setter()方法来获取或设置属性值,我们日常开发中也经常是这么编程的。

    • 使用封装,确实增加了类的定义的复杂程度,但是它也确保了数据的安全性

    • 增加了getter()方法和setter()方法,很好的控制的属性是否是只读的,

      如果希望属性是只读的,则可以直接去掉setter()方法,

      如果希望属性不能被外部访问,则可以直接去掉getter()方法。

    • 使用setter()方法设置属性,可以增加数据的验证,确保数据的值是正确的,如

          def set_age(self, age):
              if age > 0:
                  self.__age = age
      
    • 同理使用getter()方法获取属性时,或者使用setter()方法设置属性时,可以在读取属性和修改属性的同时,对数据做一些其他的处理。

    展开全文
  • Python对于类的成员没有严格的访问控制限制,这与其他面向对象的编程语言是有所区别的。 关于私有方法其实和私有属性差不多,有如下要点: 1、通常我们约定,两个下划线开头的方法是私有方法。 2、类内部可以访问...
  • Python 类的私有成员

    2019-05-05 22:20:35
    大家都知道,一个类的私有成员只能在其所在的类里能够访问,而在外部是不行的。比如 C++ 或者 Java 的 private 关键字就是用来声明类的私有成员的,如果一个属性或者方法被 private 声明,那么这个成员就只能在类...
  • python并没有对私有成员提供严格的访问保护机制。 在定义类的成员时,如果成员名以两个下划线“__”或更多下划线开头而不以两个或更多下划线结束则表示是私有成员私有成员在类的外部不能直接访问,需要通过...
  • Python的类并不使用关键字区分是私有成员和共有成员,但是为啥私有成员变量外面还是访问不到呢?粗糙的隐藏普通的python类class TT: def __init__(self,name): self.name=name self.privateMem=1t=TT('hah') ...
  • 类的创建,成员变量,构造函数和析构函数,普通成员函数,访问私有成员变量。 print("Test Class") class Video(object): # 4、私有成员变量 两个下划线开头定义的变量就是私有成员变量 __name = "private name" ...
  • python对于类的成员没有严格的访问控制限制,这与其他面向对象语言有区别,关于私有属性和私有方法,有如下要点: 1.通常我们约定,两个下划线开头的属性是私有的(private),其他为公共的(public)。 2.类...
  • 私有成员变量: __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。 保护成员变量: _foo:以单下划线开头的表示的是 protected 类型的变量,即保护类型只能允许其本身与子类进行...
  • 这句话是重点,即使是私有成员,在类外部通过obj._className__attrName 也可以访问的到。 况且,Python对这些以两个_,开头的成员名称进行了改变,变为_className__attrName. 而这也解释了下边这个奇怪的现象。 ...
  • 默认情况下,Python中的成员函数和成员变量都是公开的(public),在python中没有类似public,private等关键词来修饰成员函数和成员变量。在python中定义私有变量只需要在变量名或函数名前加上 ”__“两个下划线,那么这...
  • python对于类的成员没有严格的访问控制限制,这与其他面对对象语言有区别。 方法本质上也是属性,只不过是可以通过()执行而已。 关于私有属性和私有方法,要点: 1、通常约定,两个下划线开头的属性是私有的属性,...
  • python对类的成员没有严格的访问控制限制,这与其他面向对象语言有区别。关于私有属性和私有方法,有如下要点: 1.通常我们约定,两个下划线开头的属性是私有的(private)。其他的为公共的(public)。 2.类内部可以...
  • python中的protected和private python中用 _var ;变量名前一个下划线来定义,此变量...变量名前两个下划线来定义,此变量为私有private,只允许类本身访问,连子类都不可以访问。 class perent_class(objec...
  • python中,类内方法外的变量叫属性,类内方法内的变量叫字段...方法、属性的访问于上述方式相似,即:私有成员只能在类内部使用 以上这篇老生常谈python的私有公有属性(必看篇)就是小编分享给大家的全部内容了,希望能
  • 为了控制对类的成员访问权限,类的成员分:公有、保护 、私有三种类型。 一、公有成员 任何时候都可以访问成员即为公有成员,在定义类的公有成员时没有什么特殊的要求。 二、保护成员 名称以一条下划线“_”开头...
  • 注意,不能直接访问私有属性,但可以通过方法中访问。 举个栗子: class A: __name='class A' def dd(self): print('私有属性') sg=A() sg.dd() print(sg.__name) 运行结果: Traceback (most recent call last...
  • @什么是类的私有成员 成员就是指类的属性和方法; 私有,即不能再类的外界进行访问; 目的是为了保障安全,如涉及隐私的属性、核心方法实现等; @案例,需求如下 创建Person类,添加存款信息 保护存款信息,将...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • Python不像C++、Java、C#等有明确的公共、私有或受保护的关键字来定义成员函数或属性,它使用约定的单下划线“_"和"__"双下划线作为函数或属性的前缀来标识。使用单下划线还是双下划线,是有很大的区别的。 1. 单...
  • python对于类的成员没有严格的访问控制限制,这与其他面向对象的语言有区别。关于私有属性和私有方法,有如下要点: 1)通常我们约定,两个下划线开头的属性是私有的,其他是公共的; 2)类内部可以访问私有属性...
  • Python 私有

    2019-09-21 07:45:58
    python中的私有变量和私有方法仍然是可以访问的;访问方法如下:私有变量:实例._类名__变量名 私有方法:实例._类名__方法名() Python并没有真正的私有化支持,但可用下划线得到伪私有。 尽量避免定义以下划线开头的...
  • Python学习 7.6 成员可见性:公开...私有成员(private):在类的外部无法对它赋值或读取。 在Python中,对于一个变量或者方法,名字前面没有双下划线“__”则认为是公开的;如果前面加上双下划线则认为是私有的。一个
  • 1.私有成员 2.@property 3.访问对象信息 1.私有成员 在某些情况下,我们希望限制用户访问对象的属性或方法,也就是希望它是私有的,对外隐蔽。 那么,如何在类中定义私有属性或私有方法呢:在属性名或方法名前...
  • 私有成员

    2018-08-21 13:55:00
    1.双下划线开头 ...4.子类也不能直接访问父类中的私有成员,只能间接访问 class Base: def __init__(self): self.__name = 'python' self.name = 'P' def BaseShow(self): retur...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 525
精华内容 210
关键字:

python访问私有成员

python 订阅