14.12.1类的特殊成员1

类的特殊成员1

__call__方法

#__call__方法
class Foo:
    def __init__(self):
        print("init")
    def __call__(self,*args,**kwargs):
        print("call")

obj=Foo()
obj()
# init
# call

Foo()()
# init
# call

#对象()只执行__call__方法,非常特殊
#__init__也是,创建对象就执行__init__方法
#\__int\__方法
s="123"
s=str("123") #等价

i=int(s)
print(i,type(i))  #自己转化成int类型
# 123 <class ‘int‘>

__int__方法

class foo1:

    def __init__(self):
        pass

    def __int__(self):
        return 1234

    def __str__(self): #用于打印,很重要,非常常见
        return "haha"

obj2=foo1()

print(obj2,type(obj2))

#int 加上对象,执行对象的__int__方法,并将返回值赋给int对象
r=int(obj2)

print(r)

# <__main__.foo1 object at 0x000000FFA667AA90> <class ‘__main__.foo1‘>
# 1234

__str__方法

#__str__方法
class foo2:

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self): #用于打印,很重要,非常常见
        return "%s-%s"%(self.name,self.age)

obj3=foo2("jiaxin",10)

print(obj3,type(obj3))
# jiaxin-10 <class ‘__main__.foo2‘>

原文地址:http://blog.51cto.com/10777193/2102964

时间: 2024-10-13 13:59:54

14.12.1类的特殊成员1的相关文章

14.12.4类的特殊成员4

类的特殊成员 metaclass # 在Python中,一切事物都是对象. **** # class foo: # pass # obj=foo() # obj是foo的对象 # foo类是type的对象 # 只要写类,默认都继承object类 #类都是type类的对象 class myType(type): def __init__(self,*args,**kwargs): print("mytype") pass def __call__(self, *args, **kwarg

14.12.2类的特殊成员2

类的特殊成员 __add__方法 #两个对象相加时,会自动执行第一个对象的__add__方法,并且将第二个对象当做参数传递进入 class foo: def __init__(self,name,age): self.name=name self.age=age def __add__(self, other): #return 123 #return self.age+other.age return foo("oo",20) # def __del__(self): # print

14.12.3类的特殊成员3

类的特殊成员 __iter__方法 class foo: def __init__(self,name,age): self.name=name self.age=age def __iter__(self): return iter([1,2,3,4]) li=foo("jiaxin",8) # 如果类中有__iter__方法,对象就是可迭代对象 # 对象.__iter__()的返回值:迭代器 # for 循环:迭代器,next # for 循环,可迭代对象,先获取对象的__iter

12、类成员访问修饰符public/private/producted/readonly

1.private 类的私有成员 private 类的私有成员,只能在内部访问,在外部访问不到,无法被继承,我们可以将不需要被外部修改的定义为私有的 私有成员,只能在内部访问,在外部访问不到 private 可以在类的内部访问私有成员,不能再外部访问,但是在外部可以访问这个getType,从而访问到type,方法也是默认public公开的 私有成员无法被继承  2.protected受保护的 和private类似,也是私有成员,只能在内部访问,外部无法访问,但是可以被继承 可以被继承,但是只能在

java类中各成员初始化的顺序

了解java中类各个成员的初始化顺序是非常重要的,这样你可以对类有全局的认识.不说太多,直接看下面的例子 class Father { static{ System. out.println("父类静态代码块初始化" ); } { System. out.println("父类代码块初始化" ); } private static String s=print(); public static String print() { System. out.println

基类的protected成员

2014-07-27 星期日 18:10:56 重温下c++ primer,随意记录. 1.基类protected成员 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 6

C++ primer plus读书笔记——第12章 类和动态内存分配

第12章 类和动态内存分配 1. 静态数据成员在类声明中声明,在包含类方法的文件中初始化.初始化时使用作用域运算符来指出静态成员所属的类.但如果静态成员是整形或枚举型const,则可以在类声明中初始化. P426-P427类静态成员的声明和初始化 //strnbad.h class StringBad { private: static int num_strings; … }; //strnbad.cpp int StringBad::num_strings = 0; 不能在类声明中初始化静态

类的特殊成员

1.__doc__ 表示类的描述信息 class Food(object): "定义一个食物类" pass print(Food.__doc__) #输出 定义一个食物类 2.__module__ 和 __class__ __module__ 表示当前操作对象在哪个模块 __class__    表示当前操作对象的类是什么 class A(object): def __init__(self, name): self.name = name from local.obj import

C# - 阻止派生类重写虚成员

1 using System; 2 3 namespace 类_阻止派生类重写虚成员 4 { 5 // 声明一个抽象类Animal(用abstract关键字声明抽象类) 6 public abstract class Animal 7 { 8 // 基类的抽象方法Voice(); 功能在派生类实现 9 public abstract void Voice(); 10 } 11 12 // 派生类(子类)继承自Animal 13 // 14 public class Horse : Animal