面向对象–特殊成员

1.类的特殊成员之call

day6面向对象–类的特殊成员方法,day6面向对象–成员

什么时候适用面向对象?

  • 如果多个函数须传入多个共同的参数时
  • 根据一个模板创建某些东西
  • (ssh)
 1 class SpecialMembers:
 2     #类的构造方法
 3     def __init__(self):
 4         print("构造了一个方法")
 5     
 6     def __call__(self):
 7         print("构造了一个对象")
 8 
 9 #创建一个对象,并执行类的构造方法
10 obj = SpecialMembers()
11 #执行对象的构造方法
12 obj()
13 #先执行类的构造方法,然后再执行对象的构造方法
14 SpecialMembers()()

类的特殊成员方法

类的特殊成员

  1. __doc__ #输出:类的描述信息

  2. __module__ 和 __class__
      __module__ 表示当前操作的对象在那个模块
      __class__ 表示当前操作的对象的类是什么

  3. __init__
      构造方法,通过类创建对象时,自动触发执行。

  4. __del__
      析构方法,当对象在内存中被释放时,自动触发执行。

  5. __call__
      对象后面加括号,触发执行。即: 对象() 或 类()()

    class Foo:

     def __init__(self):
         pass
    
     def __call__(self, *args, **kwargs):
         print('__call__')
    
obj = Foo()  # 执行 __init__
obj()  # 执行 __call__
  1. __dict__ 类或对象中的所有成员

  2. __str__
      如果一个类中定义了__str__方法,那么在打印 对象
    时,默认输出该方法的返回值。

  3. __getitem__ __setitem__ __delitem__
      类似字典一样索引的操作,以上分别表示获取,设置,删除。(当在类外面做了这些操作后触发这些函数,甚至可删除不存在的数据)

    class Foo(object):

     def __getitem__(self, key):
         print('__getitem__',key)
     def __setitem__(self, key, value):
         print('__setitem__',key,value)
     def __delitem__(self, key):
         print('__delitem__',key)
    

    obj = Foo()

    result = obj[“k1”] # 自动触发执行 getitem
    obj[‘k2’] = ‘wupeiqi’ # 自动触发执行 setitem
    del obj[‘k1’] # 自动触发执行 delitem

__getitem__ k1
__setitem__ k2 wupeiqi
__delitem__威尼斯人官网, k1

  1. __new__ 用来将类实例化的

    def new(cls,*args,**kwargs): #重构new方法:在实例化之前做些事情

     print("Foo --new--")
     return object.__new__(cls)     #继承父类的__new__方法(此时cls是一个对象)
    

2.类的特殊成员之getitem,setitem,delitem

    1. __doc__  表示类的描述信息

class Func(object):
    '''__doc__方法是用来打印类的描述信息'''

    def tell(self):
        pass

    def enroll(self):
        pass

print(Func.__doc__)    # 输出:类的描述信息
运行结果如下:
__doc__方法是用来打印类的描述信息

    __doc__是用来打印类的描述信息。就是类的注释。

    2.__module__和__class__

    __module__表示当前操作的对象在那个模块

    __class__ 表示当前操作的对象的类是什么

 

反射(用户交互)

hasattr(obj,name_str)
判断一个对象obj中是否有对应的name_str字符串方法,返回布尔值
getattr(obj,name_str) 根据字符串去获取obj对象里的对应方法的内存地址
setattr(d,name_str,[new])
给对象的属性\方法重新定义,若不存在,先创建再赋值。

class Dog(object):
    def __init__(self,name):
        self.name = name
    def eat(self,food):
        print("%s is eating %s" %(self.name,food))

def bulk(name):
    print("%s is yelling ..." %name)

d = Dog("xiaohei")
choice = input(">>: ").strip()
if hasattr(d,choice):
    func = getattr(d,choice)
    func("xiaoqiang")
else:
    # setattr(d,choice,"black")     #--1--  设置变量
    # v = getattr(d,choice)
    # print(v)
    setattr(d,choice,bulk)       #--2--  设置方法
    bulk(d.name)
 1 class SpecialMembers:
 2     #当执行obj['value']的时候就会自动执行__getitem__方法,并且把对象括号内的值当做__getitem__的值
 3     def __getitem__(self,item):
 4         print(item)
 5     def __setitem__(self,key,value):
 6         print(key,value)
 7     def __delitem__(self,key):
 8         print(key)
 9 
10 #创建一个对象
11 obj = SpecialMembers()
12 #自动执行__getitem__方法
13 obj['value']
14 #自动执行__setitem__方法
15 obj['k1'] = 'values'
16 #自动执行__delitem__方法
17 del obj['key']

    3. __init__ 构造方法,通过类创建对象时,自动触发执行。

    4.__del__

 

    析构方法,当对象在内存中被释放时,自动触发执行。

   
注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的

     5. __call__ 对象后面加括号,触发执行。

    注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于
__call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()

class Func(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def enroll(self):
        print("%s in enrolling in the school" %self.name)

    # def __call__(self):
    #     print("实例化加夸好还可以执行,窝草")


f = Func("alex",18,"Female")

f.enroll()
f()
运行结果如下:
alex in enrolling in the school
Traceback (most recent call last):
  File "/home/zhuzhu/第七天/class的方法.py", line 17, in <module>
    f()
TypeError: 'Func' object is not callable

 

   
上面代码中,f是一个实例,我们知道,实例化的变量是不能够加上括号执行的。提示错误:TypeError:
‘Func’ object is not
callable
,说不能够callable,现在我们加上__call__()方法,如下:

class Func(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def enroll(self):
        print("%s in enrolling in the school" %self.name)

    def __call__(self):
        print("实例化加夸好还可以执行,窝草")


f = Func("alex",18,"Female")

f.enroll()
f()
运行结果如下:
alex in enrolling in the school
实例化加夸好还可以执行,窝草

 

   
从上面代码可以看出,本来实例加上括号不能执行的,现在可以执行了,就因为__call__()方法,可以看出,__call__()方法,对实例就行了构造,让其能够执行__call__()的方法。

    6. __dict__ 查看类或对象中的所有成员

class Province:
    country = 'China'

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

    def func(self, *args, **kwargs):
        print('func')


# 获取类的成员,即:静态字段、方法、
print(Province.__dict__)
# 输出:{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province('HeBei', 10000)
print(obj1.__dict__)
# 获取 对象obj1 的成员
# 输出:{'count': 10000, 'name': 'HeBei'}

obj2 = Province('HeNan', 3888)
print(obj2.__dict__)
# 获取 对象obj1 的成员
# 输出:{'count': 3888, 'name': 'HeNan'}

    7.__str__ 如果一个类中定义了__str__方法,那么在打印 对象
时,默认输出该方法的返回值。

class Foo:
    def __str__(self):
        return 'alex li'


obj = Foo()
print(obj)
# 输出:alex li

 

    8.__getitem__、__setitem__、__delitem__

    用于索引操作,如字典。以上分别表示获取、设置、删除数据

class Foo(object):
    def __getitem__(self, key):
        print('__getitem__', key)

    def __setitem__(self, key, value):
        print('__setitem__', key, value)

    def __delitem__(self, key):
        print('__delitem__', key)


obj = Foo()

result = obj['k1']  # 自动触发执行 __getitem__
obj['k2'] = 'alex'  # 自动触发执行 __setitem__
del obj['k1']    

 

    9. __new__ \ __metaclass__

class Foo(object):
    def __init__(self, name):
        self.name = name

f = Foo("alex")

 

   上述代码中,f 是通过 Foo 类实例化的对象,其实,不仅 f
是一个对象,Foo类本身也是一个对象,因为在Python中一切事物都是对象

   
如果按照一切事物都是对象的理论:obj对象是通过执行Foo类的构造方法创建,那么Foo类对象应该也是通过执行某个类的
构造方法 创建。

    <class ‘__main__.Foo’>   
# 输出:<class '__main__.Foo'>     表示,obj 对象由Foo类创建
  <class ‘type’>     
# 输出:<type 'type'>              表示,Foo类对象由 type 类创建

    所以,f对象是Foo类的一个实例Foo类对象是 type
类的一个实例
,即:Foo类对象 是通过type类的构造方法创建。   

   

类的特殊成员方法 1. __doc__ 表示类的描述信息 class Func( object ):
”’ __doc__方法是用来打…

3.类的特殊成员之dict

获取类或对象中的所有成员

 1 class SpecialMembers:
 2     """
 3     类的注释
 4     """
 5     def __init__(self,name,age):
 6         self.name = 'abc'
 7         self.age = 18
 8 #获取类中的成员
 9 print(SpecialMembers.__dict__)
10 #创建一个对象
11 obj = SpecialMembers()
12 #获取对象中的成员
13 print(obj.__dict__)#以字典的形式输出

4.类的特殊成员之iter

 1 class SpecialMembers:
 2     def __iter__(self):
 3         yield 1
 4         yield 2
 5         yield 3
 6 #创建一个对象
 7 obj = SpecialMembers()
 8 #如果执行for循环对象时,会自动执行对象的__iter__方法,此时的__iter__就是一个生成器
 9 for i in obj:
10     print(i)

5.类的特殊成员之add

 1 class SpecialMembers:
 2     def __init__(self,a1,a2):
 3         self.a1 = a1
 4         self.a2 = a2
 5     def __add__(self,other):
 6         return self.a1 + other.a2
 7 
 8 obj1 = SpecialMembers(1,2)
 9 obj2 = SpecialMembers(3,4)
10 print(obj1 + obj2)#5

6.真正的构造方法

 1 class Foo:
 2     def __init__(self,a1,a2):#初始化方法
 3         """
 4         为空对象进行数据初始化
 5         """
 6         self.a1 = a1
 7         self.s2 = a2
 8 
 9     def __new__(cls,*args,**kwargs):
10         """
11         创建一个空对象
12         """
13         return object.__new__(cls)#python内部创建一个当前类的对象
14 
15 obj = Foo(1,2)
16 print(obj)

 

相关文章