python之路-双下方法

双下方法

定义:

双下方法是特殊方法,他是解释器提供的,由双下线加方法名加双下划线 __方法名__具有特殊意义的方法

双下方法主要是Python源码程序员使用的,元编程

我们在开发中尽量不要使用双下方法,但是深入研究双下方法,更有益于我们阅读源码

1.__len__ 计算长度

s = ‘nihaoashuaige‘
print(len(s))
#len作为内置函数,部分数据类型调用它的时候就会返回其长度,那是什么让这个函数起了这样的作用呢
#看一下字符串的str类的内容里有__len__方法,所以调用len内置函数,其实就是触发了__len__方法
class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __len__(self):
        print(‘调用len方法‘)
        return len(self.__dict__)
obj = A(‘红‘,‘24‘)
print(len(obj))
打印结果:
调用len方法
2

触发机制:

调用len,就立即触发了__len__方法,并执行里面的内容

2.__hash__

#我们之前说过,可hash的就是不可变的数据类型,那么这个是如何进行判断的呢
print(hash(‘nihao‘)) #返回一串数字
print(hash(123)) #返回一串数字
print(hash([1,2,3])) #报错
打印结果:
-3334696613266170804
123

3.__str__

class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self): #打印的时候返回的结果值
        return self.name
obj = A(‘nihao‘,18)
print(obj)
打印结果:
nihao

4.__repr__

repr内置函数,原形毕露,调用repr,则触发__repr__方法,返回其原始值

class A:
    def __repr__(self):
        return ‘nihao‘
obj = A()
print(repr(obj))
打印结果:
nihao

5.__call__ 对象后面加(),触发执行

class A:
    def __init__(self):
        print(111)
    def __call__(self, *args, **kwargs):
        print(666)
obj = A()
obj()  ##对象+()触发__call__方法
打印结果:
111
666

6.__eq__

class A:
    def __init__(self):
        self.a = 1
        self.b = 2
    def __eq__(self, other):
        print(666)
        return ‘比较‘
a = A()
b = A()
print(a == b)
#同一个类的两个实例进行比较,就会触发类中的__eq__方法
打印结果:
666
比较

7.__del__

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

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

8.__new__ 类名+()触发__new__方法 构造方法

class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __new__(cls, *args, **kwargs):
        print(666)
        return object.__new__(cls)
obj = A(‘xiaohong‘,‘19‘) ##构造一个对象是先触发__new__方法

单例模式(一个类只能实例化一个对象)

class A:
    __instance = None
    def __new__(cls,*args,**kwargs):
        if not cls.__instance:
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance
ret = A()
print(ret)
ret = A()
print(ret)
ret = A()
print(ret)
打印结果:
<__main__.A object at 0x00000263D5202B00>
<__main__.A object at 0x00000263D5202B00>
<__main__.A object at 0x00000263D5202B00>

9.__item__相关

当你对对象进行类似于字典的操作的时候,就会触发相应的方法

class A:
    def __init__(self,name):
            self.name = name

    def __getitem__(self, item):
        return self.__dict__[item]

    def __setitem__(self, key, value):
        self.__dict__[key] = value

    def __delitem__(self, key):
        print(‘删除的时候执行我‘)
ret = A(‘nihao‘)
print(ret[‘name‘]) #执行getitem
ret[‘name‘] = ‘xiaohong‘ #执行setitem
print(ret.__dict__)
del ret[‘name‘] #执行delitem
打印结果:
nihao
{‘name‘: ‘xiaohong‘}
删除的时候执行我

10.上下文管理器相关(__enter__ 和 __exit__)

class A:
    def __init__(self,text):
        self.text = text
    def __enter__(self): #开启上下文管理器时执行此方法
        self.text = self.text + ‘来了‘
        return self
    def __exit__(self, exc_type, exc_val, exc_tb): #执行完上下文管理器时执行此方法
        self.text = self.text + ‘走了‘
        return self
obj = A(‘baobao‘)
with obj as f:
    print(f.text)
print(f.text)
打印结果:
baobao来了
baobao来了走了

原文地址:https://www.cnblogs.com/Ailsa-a/p/10519885.html

时间: 2024-11-09 00:56:51

python之路-双下方法的相关文章

Python面向对象反射,双下方法

一. 反射 反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问.检测和修改它本身状态或行为的一种能力(自省).这一概念的提出很快引发了计算机科学领域关于应用反射性的研究.它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩. python面向对象中的反射:通过字符串的形式操作对象相关的属性.python中的一切事物都是对象(都可以使用反射) 四个可以实现自省的函数 下列方法适用于类和对象(一切皆对象,类本身也是一个对象) 对实例化对象的示例 class Foo

Python面向对象之反射,双下方法

一. 反射 反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问.检测和修改它本身状态或行为的一种能力(自省).这一概念的提出很快引发了计算机科学领域关于应用反射性的研究.它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩. python面向对象中的反射:通过字符串的形式操作对象相关的属性.python中的一切事物都是对象(都可以使用反射) 四个可以实现自省的函数 下列方法适用于类和对象(一切皆对象,类本身也是一个对象) class Foo:    f = '

Python(88)_双下划线方法

1.双下划线方法 #-*-coding:utf-8-*- import os import time ''' 迭代器 ''' print(dir([])) # 告诉我列表拥有的所有方法 print(dir({})) print(dir('')) ''' 求共有方法,集合求交集 ''' ret = set(dir([]))&set(dir({}))&set(dir(''))&set(dir(range(10))) print(ret) # __iter__ print([1].__a

面向对象中的双下方法

1.__str__与__repr__方法 class Animal: def __init__(self,name,age): self.name = name self.age = age def f(self): print("这是父类的方法") class Persion(Animal): country = "chinese" def __init__(self,name,age,sex): Animal.__init__(self,name,age) se

面向对象的反射和双下方法(魔术方法)

反射: 通过字符串操作对象相关属性. 1 class Text: 2 def __init__(self,name,age): 3 self.name = name 4 self.age = age 5 def func(self): 6 print(123) 7 def func1(self): 8 return self 9 10 text = Text("小明",18) 11 print(hasattr(text,"func")) # 查看对象是否具有属性或方

面向对象之: 反射和双下方法

目录 一, 反射 二, 函数VS方法 三, 双下方法 一, 反射 反射:程序可以访问,检测和修改它本身状态或行为的一种能力(自省) python面向对象中的反射:通过字符串的形式操作对象相关的属性 python中的一切事物都是对象(都可以使用反射) 四个可以实现自省的函数,下列方法适用于类和对象(一切对象,类本身也是对象) # 对实例化对象的示例 class Foo: f = '类的静态变量' def __init__(self, name, age): self.name = name sel

面向对象:反射和双下方法

面向对象:反射和双下方法 1.元类type type:获取对象从属于的类 class A: pass obj = A() print(type(A)) print(type('abc')) print(type([1,2,3])) python中一切皆对象,类在某种意义上也是一个对象,python中自己定义的类,以及大部分内置类都是由type元类(构建类)实例化得来的 type 与 object 的关系 object类是type类的一个实例,object类是type的父类. print(type

面向对象之 元类 , 反射 , 双下方法

1.元类 type type元类,又称为构建类,python中一切皆对象,类也可以理解为对象,python中自己定义的类,以及大部分内置类,都是由type元类实例化得来的 元类type class A: pass obj = A() print(type('abc')) #<class 'str'> print(type([1,2,3])) #<class 'list'> print(type((22,33))) #<class 'tuple'> print(type(

反射 双下方法

一 : 元类 type Type 获取对象从属的类 class A: pass print(type('abc')) # <class 'str'> print(type([1,2,3])) # <class 'list'> print(type((22,33))) # <class 'tuple'> python 中一切皆对象,类在某种意义上也是一个对象,python 中自己定义的类,以及大部分内置类,都是由 type元类实例化得来的 type 与 object 的关