成员修饰、特殊成员

一、类成员修饰符:

  • __ 修饰符:
    • 公有:均可访问
    • 私有:
      • 只能内部访问(指通过类自身中的方法去访问)
      • 继承也是如此,只能通过自身类中方法访问,不能通过子类中方法访问
  • example:
    • 私有字段:
class Class1:

__var2 = ‘静态私有‘

def __init__(self,  age):

self.__age = age

def function1(self):

print(‘动态私有‘, self.__age)

print(‘静态私有‘,Class1.__var2)

# 调用执行

obj = Class1()

obj.function1()   //从类自身方法中,获取任何字段都行

obj.__age           //报错,不能获取私有动态字段

Class1.__var2      //报错,不能获取私有静态字段

    • 私有方法:
class Class1:

def __function1(self):

print(‘私有 动态方法‘)

@staticmethod

def __static_func():

print(‘私有 静态方法‘)

@classmethod

def __class_func(cls):

print(‘私有 类方法‘)

def show(self):

self.__function1()

Class1.__static_func()

Class1.__class_func()

# 调用执行

obj = Class1()

obj.show()                 //从自身方法中,调用任何方法都行

obj.__function1()       //报错

Class.__static_func()   //报错

Class.__class_func()    //报错

  • 图解总结:

  • 特例:
    • 不到万不得已,别这样用,忘记他

class Foo:

def __init__(self,name):

slef.__name = name

def function1(self):

print(self.__name)

obj = Foo()

obj.__name //此时不能通过外部访问,报错

print(_Foo__name) //可以访问


二、类中的特殊成员:

    • def __del__():
      • 析构方法, 即垃圾清理这个对象前会执行的方法(一个对象长时间没有人调用时候,就由垃圾回收机制自动销毁)
    • __call__(self, *args, **kwargs):
      • obj = Class1()  会执行__init__(self,*args, **kwargs) 方法
        • obj() 会执行__call__ 方法,注意是“对象”后面加括号
        • class()() 先执行__init__后执行__call__
    • __str__()
      • 若一个对象定义了__str__方法,那么在print(obj_name)时,会自动执行该方法,并输出返回值

class Foo:

def __init__(self,name, age):

slef.name = name

self.age = age

def __str__(self):

return ‘{}-{}‘.format(self.name,self.age)

obj1 = Foo(‘qiao‘,18)

print(obj1)

print(ret)          //若class中没有定义str方法,则输出该对象内存地址,若定义str,则输出str方法的返回值

ret = str(obj1)  //str也会调用该对象的__str__方法,不过不会直接输出,只会拿到返回值

    • __dict__ 一个字段,存储了类或对象中所有成员;__dict__默认已经存在
      • obj1.__dict__ 会将对象中所有字段拿出来,放在字典中
      • class.__dict__ 会讲类中所有成员拿出来,放在字典中
    • __add__()
      • 当2个对象执行“相加”操作时,会执行该方法
      • 加减乘除等操作相同,都有对应的方法

class Class1:

def __init__(self,name):

self.name = name

def __add__(self,other):

print(‘my nam:{}, her age:{}‘.format(self.name,other.age))

class Class2:

def __init(self,age):

self.age = age

obj1 = Class1(‘qiaogy‘)

obj2 = Class2(18)

obj1+obj2    //会执行obj1的__add__方法,obj2为other

时间: 2024-09-28 19:59:37

成员修饰、特殊成员的相关文章

python学习笔记-Day8 上(pickle补充、字段、面向对象成员、成员修饰符、特殊方法)

pickle 序列化补充 # pickle load # 现在有两个python程序,调用关系如下 # s1.py class foo: …. Obj = foo(x,y) Pickle.dump(obj, open(‘db’,’wb’)) S2.py # s2.py from s1 import foo pickle.load(db) # s2.py 反序列化加载包含对象,一定要先导入对象对应的类,否则Pickle load将会报错 类多继承关系 有共同父类的继承关系如下 如图,如果我们有两个

学习C#修饰符:类修饰符和成员修饰符

C#修饰符之类修饰符:public.internal. partial.abstract.sealed.static C#修饰符之成员修饰符:public.protected.private.internal.sealed.abstract.virtual.override.readonly.const Public:最开放,所有的本程序集以及其他的程序集里面的对象都能够访问 Protected:比较开放,自身成员以及子类成员可访问 Private:只有自身成员才能够访问 Internal:本程

Python类成员及类成员修饰符

13.面向对象:多态.继承.封装成员:字段:普通字段.静态字段方法:普通方法.静态方法.类方法特性:property,将方法伪造为字段,可以直接使用类.方法名调用,不用加() 成员修饰符:公有和私有,私有的字段和方法可以通过对象中的其他普通方法间接进行调用私有字段:__field, 以__双下划线开头的字段,私有字段只能在自己的对象中才能使用,继承后也无法使用私有方法:__function, 以__双下划线开头的方法,私有字段只能在自己的对象中才能使用,继

文成小盆友python-num8 面向对象中的成员,成员修饰符,特殊成员,异常处理,设计模式之单例模式

本节主要内容: 1.面向对象中的成员 2.成员修饰符 3.特殊成员 4.异常处理 5.设计模式之单例模式 一.面向对象中的成员(类的成员) 类的成员总共可以分为3大类,每类中有不同的分支. 1.总述,基本分类 如下图所示: 类成员包括字段,方法,和属性 2.字段 如上图字段分为普通字段和静态字段,两者的使用有区别,但是最大的区别在于两者在内存中的保存位置有区别. 普通字段属于对象而静态字段属于类,在使用过程中谁的字段就由谁来调用. 静态字段和普通字段的定义如下: 在调用时分各自调用 #####类

Python面向对象成员修饰符

成员修饰符就是设置类的成员有些是公开的有些是私有的,公开的是在外部通过对象或者类可以调用,但是私有的只能通过类的内部才可以调用. 静态字段修饰 #!/usr/bin/env python # _*_coding:utf-8 _*_ class Foo:    # 公有的静态字段    ClassMembers = "公开的"    # 私有的静态字段    __ClassMembers = "私有的" # 执行公有的静态字段 print(Foo.ClassMembe

修饰 C++ 成员函数的两种关键字总结

修饰 C++ 成员函数的两种关键字总结 常量成员函数 (const 关键字) const 修饰成员函数表示这个成员函数不能修改类的成员变量,因此这种成员函数称为常量成员函数.这样,编译器可以对这个函数进行深度的优化.另外,一个类的常量型示例只能调用常量型成员函数.比如下面这个例子. class Test { public: Test(); int getValue() const; int value(); private: int intValue; }; Test::Test(): intV

Python_day8_面向对象(多态、成员修饰符、类中特殊方法、对象边缘知识)、异常处理之篇

一.面向对象之多态 1.多态:简而言子就是多种形态或多种类型 python中不支持多态也用不到多态,多态的概念是应用与java/C#中指定传参的数据类型, java多态传参:必须是传参数的数据类型或传参的子类类型 面向对象总结: 面向对象是一种编程方式,此编程方式的实现是基于类和对象的使用 类:是一个模板,模板中包含了多个函数共使用,即类中可包含多个函数(类中的函数即叫做方法) 一般疑问: 1)什么样的代码才是面向对象? 简单来说,如果程序中的所有功能否是由 “类”和“对象”实现,那么就是面向对

面向对象之成员修饰符

一.成员修饰符 1.方法名带下划线例  __name() 即属性私有化,就表明该函数不可以通过对象或者类调用(简称外部调用),只能通过类的内部其他方法间接的调用. 2.类中的静态字段.普通字段.静态方法.普通方法.类方法,都适用. 3.儿子孙子继承者也不能访问. class Foo: __xo = "xo" def __init__(self,name,age): __dog = "cat" self.n = name self.a = age def f1(sel

Java反射机制可以动态修改实例中final修饰的成员变量吗?

问题:Java反射机制可以动态修改实例中final修饰的成员变量吗? 回答是分两种情况的. 1. 当final修饰的成员变量在定义的时候就初始化了值,那么java反射机制就已经不能动态修改它的值了. 2. 当final修饰的成员变量在定义的时候并没有初始化值的话,那么就还能通过java反射机制来动态修改它的值. 实验: 1. 当final修饰的成员变量在定义的时候就初始化了值 1 public Class Person { 2 private final String name = "damon