python进阶之内置函数和语法糖触发魔法方法

前言

前面已经总结了关键字、运算符与魔法方法的对应关系，下面总结python内置函数对应的魔法方法。

魔法方法

数学计算

abs(args):返回绝对值，调用__abs__;
round(args):返回四舍五入的值，调用__round__;
math.floor():向下取整，调用__floor__;
math.ceil():向上取整，调用__ceil__;
math.trunc()：求一个值距离0最近的整数，调用__trunc__;
divmod(a,b):返回商和余，调用__divmod__;
pow(a,b):返回幂，调用__pow__;
sum():返回和，调用__sum__;
float():转换小数，调用__float__;
int():转换整数，调用__int__;
str():转换字符串，调用__str__;
sys.getsizeof():对象占内存的大小，调用__sizeof__;
bin(*args, **kwargs):调用参数的__bin__方法，返回整数的二进制表示形式，只支持一个参数，只支持int类型
hash():调用__hash__方法，获取一个对象的散列值，相等的两个数哈希值相等，反过来不一定成立
hex(*args, **kwargs)：调用__hex__方法，求整数的十六进制表示形式，只支持Int类型
oct(*args, **kwargs)：调用__oct__方法，求整数的八进制表示形式，只支持Int类型

访问控制

__getattr__(self, name):getattr方法触发，仅对对象未定义的属性有效，即如果视图获取一个没有的属性时会调用该方法，前提是该对象未定义__getattribute__(self, name)方法；
__getattribute__(self, name)：getattr方法触发，如果对象定义了该方法，一定触发，__getattr__方法将不会被调用；它也可以被self.name语法糖触发；
__setattr__(self, name, value)：setattr方法触发,设置一个对象的属性；也可以被self.name = ‘‘语法糖触发。
__delattr__(self, name)：delattr方法触发,删除一个对象的属性，或由del self.name 形式触发；

容器类型

在Python中实现自定义容器类型需要用到一些协议。不可变容器类型有如下协议：

  1. 不可变容器，需要定义 _len_ 和 _getitem_ ;
  2. 可变容器,需要定义 _len_ 、_getitem_、_setitem_、_delitem_ ;
  3. 容器可迭代，需要定义 _iter_ ；
  4. 迭代器，必须遵守迭代器协议，需要定义 _iter_ 和 _next_ 方法。
  • 索引语法糖与魔法方法
__len__(self):返回容器的长度；
__getitem__(self, key):使用self[key]形式语法糖获取元素会触发；
__setitem__(self, key):使用self[key] = ‘xxx‘形式复制会触发；
__delitem__(self, key):使用del self[key]语法糖触发
__reversed__(self):reversed(self)触发，反转容器；
__missing__(self, key)：字典结构使用self[key]形式获取元素，如果元素不存在触发；
  • 分片语法糖与魔法方法

切片在底层的原理，py2和py3有很大的不同，py2中使用_getslice_、_setslice_、__delslice__三个魔法方法控制，py3中将索引和切片统一由_getitem_、_setitem_、__delitem__控制。

# py2中
ls = [1,2,3,4]
print(ls[1:3]) # py2中该语法糖调用__getslice__方法，py3中废弃
del ls[1:3] # py2中该语法糖调用__delslice__方法，py3中废弃
ls[1:3] = [1,2,2] # py2中该语法糖调用__setslice__方法，py3中废弃
# py3中
class Person(object):
    def __getitem__(self, item):
        print(item)
        return ‘getitem‘

    def __setitem__(self, key, value):
        print(key, value)
        return ‘setitem‘

    def __delitem__(self, key):
        print(key)
        return ‘delitem‘

if __name__ == "__main__":
    person = Person()
    print(person[0]) # person[0] ==> person.__getitem__(0)
    print(person[0:2]) # person[0:2] ==> person.__getitem__(slice(0,2,None))
    person[0:2] = ‘test‘ # ==> person.__setitem__(slice(0,2,None), ‘test‘)
    del person[0:2] # ==> person.__delitem__(slice(0,2,None))

# 结果
0
getitem
slice(0, 2, None)
getitem
slice(0, 2, None) test
slice(0, 2, None)

python在处理索引语法糖的时候，将索引当做参数传入相关getitem、setitem、delitem的魔法方法；在处理切片语法糖的时候先调用slice方法得到slice实例对象，将其作为参数调用相关的魔法方法。

拷贝

__copy__(self):如果对象定义了该方法，copy.copy()就会调用该方法返回拷贝对象；
__deepcopy__(self, x):如果对象定义了该方法，copy.deepcopy()就会调用该方法返回拷贝对象；

序列化

序列化我们可以简单理解成对任何数据的一种描述方法，如果多种平台遵循了相同的序列化协议，数据之间的传递就会变得方便。python默认的序列化模块为pickle。

  • 序列化的简单例子
class Person(object):
    def __init__(self):
        self.name = ‘cai‘

if __name__ == "__main__":
    import pickle
    person = Person()
    with open(‘./person.txt‘, ‘wb‘) as f:
        # 序列化后存储
        pickle.dump(person,f)

    with open(‘./person.txt‘, ‘rb‘) as f:
        # 反序列化
        per = pickle.load(f)
        print(per.name)

# 我们可以把一个类保存起来，后续读取它直接使用。
  • 相关的魔法方法
__getinitargs__(self):该魔法方法在py3中似乎被废弃，原本的功能是在序列化时获取实例化参数，应该返回一个元组；
__getnewargs__(self)：对新式类，通过这个方法改变类在反pickle时传递给__new__ 的参数；应该返回一个参数元组。
__getstate__(self):定义对象被序列化时的状态，而不使用对象的 __dict__ 属性，必须返回一个字典，他会去替代 __dict__ 属性，在序列化时被调用；
__setstate__(self,state)：当一个对象被反pickle时，如果定义了 __setstate__ ，对象的状态会传递给这个魔法方法，而不是直接应用到对象的 __dict__ 属性， state参数是序列化前的__dict__属性。
class Person(object):
    def __init__(self,name):
        print(‘init‘)
        self.name = name

    def __getinitargs__(self):
        print(‘initargs‘)
        return ‘zhao‘,

    def __getnewargs__(self):
        print(‘newargs‘)
        return ‘wang‘,

    def __getstate__(self):
        print(‘getstate‘)
        return {‘name‘:‘xiao‘}

    def __setstate__(self, state):
        print(‘setstate‘)
        print(state)
        self.__dict__ = state

if __name__ == "__main__":
    import pickle
    person = Person(‘cai‘)
    with open(‘./person.txt‘, ‘wb‘) as f:
        # 序列化后存储
        pickle.dump(person,f)

    with open(‘./person.txt‘, ‘rb‘) as f:
        # 反序列化
        per = pickle.load(f)
        print(per.name)

# 结果
__new__
init
newargs
getstate
__new__
setstate
{‘name‘: ‘xiao‘}
xiao

说明：

  1. pickle序列化对象之前，先执行__getnewargs__或__new__方法的参数；
  2. 然后执行__getstate__方法，返回的值替代对象的__dict__属性值；
  3. 反序列化时调用new方法，以getnewargs返回的值作为参数创建实例；
  4. 最后调用__setstate__方法，将getstate方法的返回值作为state参数；
  5. 所以由于反序列化时不会调用init方法初始化，getinitargs和getnewargs方法的作用都变得不大；

其他

__instancecheck__(self, instance):instance触发,判断对象的类型
__subclasscheck__(self, subclass):issubclass触发，判断一个对象是另一个对象的子类；
__call__:callable触发，判断一个对象是否可调用；
__dir__(self):dir()触发，获取对象的所有属性、方法的名字组成的列表；
  • __str__和__repr__

调用str触发_str_，调用repr()触发_repr_,但是print()也可以触发__str__和__repr__，如果对象定义了_str_，则print()一般触发_str_，否则触发_repr_；但列表以及字典等容器总是会使用_repr_ 方法.

__str__和__repr__的区别

  1. 一般来说，_str_ 的返回结果在于强可读性，而 _repr_ 的返回结果在于准确性;
  2. 默认情况下，在需要却找不到 __str__方法的时候，会自动调用 _repr_ 方法。

总结

熟悉了python语法糖、内置函数与魔法方法之间的关系后，显然对于如何写好一个优雅易用的类有很大的帮助。

参考

原文地址：https://www.cnblogs.com/cwp-bg/p/9856309.html

时间： 2024-11-13 18:55:57

python进阶之内置函数和语法糖触发魔法方法的相关文章

python基础之内置函数与匿名函数

python基础之内置函数与匿名函数 内置函数68个如下图 重点的关注的内置函数len,sorted,enumerate,all,any,zip,filter,map,reversed,slice len(o):参数为O,返回数据类型的长度sorted():      sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list iterable:是可迭代类型; cmp:用于比较的函数,比较什么由key决定; ke

python进阶之内置方法

python进阶之内置方法 字符串类型的内置方法 常用操作与方法: 按索引取值 str[index] 切片 ste[start:stop:step] 长度 len(str) 成员运算in和not in str1 in str2; str1 not in str2 移除空白 str.strip() 切分 str.split() 循环 for i in str : 需要掌握的: 左/右去除空白 lstrip/rstrip 截掉 string 左/右边的空格 大/小写 upper/lower 转换 s

Python基础之内置函数和递归

本文和大家分享的主要是python中内置函数和递归相关内容,一起来看看吧,希望对大家学习python有所帮助. 一.内置函数 下面简单介绍几个: 1.abs() 求绝对值 2.all() 如果 iterable 的所有元素都为真(或者如果可迭代为空),则返回  True 3.any() 如果 iterable 的任何元素为真,则返回  True .如果iterable为空,则返回  False 4.callable() 如果  object 参数出现可调,则返回  True ,否则返回  Fal

Python基础之内置函数（二）

先上一张图,python中内置函数: python官方解释在这:点我点我 继续聊内置函数: callable(object):检查对象是否可被调用,或是否可执行,结果为bool值 def f1(): pass f2 = 123 print(callable(f1)) print(callable(f2)) out: True False char(): ord(): 这两个一起讲,都是对应ASCii表的,char(obect)将十进制数字转化为ascii中对应的字母,ord(object)将字母

python基础之内置函数补充、匿名函数、递归函数

内置函数补充 python divmod()函数:把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b) 语法: 1 divmod(a, b) #a.b为数字,a为除数,b为被除数 示例: 1 >>> divmod(7, 2) 2 (3, 1) #3为商,1为余数 3 >>> divmod(7, 2.5) 4 (2.0, 2.0) 应用:web前端页数计算 1 total_count=73 2 per_count=23 3 res=div

python进阶 内置函数

内置函数: 一.map 对序列的每一个元素进行操作,最终获得操作后的新序列. 实例: #!/usr/bin/env  python# --*--coding:utf-8 --*--li = [11, 22, 33]news = map(lambda a: a + 2, li)print newsli = [22, 33, 44]l1 = [11, 22, 33]news = map(lambda a, b: a - b, li, l1)print newsli = [11, 22, 33]new

Python基础之内置函数

一.内置函数表(Python 3.x) 1.数学运算类: 2.集合类操作: 3.逻辑判断: 4.反射: 5.IO操作: 二.内置函数使用实例: 1.abs() 取绝对值 print(abs(3)) print(abs(-3)) #取-3的绝对值 --------输出结果-------- 3 3 2.all() 括号里的内容都为True时,结果才为True,反之为False print(all("")) #可迭代对象是空的,也返回True print(all((1,2,"a&q

Python基础之内置函数一

内置函数比较多,今天只记录下一部分吧. abs() 求绝对值 >>> abs(-10.1) 10.1 >>> all() 全部为真才是真,参数是可迭代的 >>> all([12,3,4,5,None]) False any() 任意为真,就为真 >>> any([12,3,4,5,None]) True bool() 布尔值 >>> bool(1) True >>> bool(0) False &g

Python初识之内置函数二

数据结构相关 列表和元组:list().tuple().reversed().slice() l=[1, 2, 3, 4, 5] l.reverse() # 列表顺序反转 l2 = reversed(l) # 得到一个反序的迭代器 print(l) print(l2) reversed() l=[1, 2, 3, 4, 5] sli = slice(0, 3, 1) # slice切片函数 print(l[sli]) slice() 字符串相关:str().fotmat().bytes().by