python进阶之——内置函数与魔法方法

内置函数

python的内置函数built-in function是指在标准库standard library中的内置函数。这些函数不属于任何类或模块，可以直接调用。

标准库中其他模块内的静态方法等不属于内置函数。 用户自定义扩充的函数也不属于内置。但在其他语言、其他环境下，内置函数的具体含义不同。 内置函数在概念上并没有唯一专指，是合成词，最好理解为“被内置了的一些函数”

详见文档，此处仅作部分本人了解的相关方法说明。

https://docs.python.org/3/library/functions.html?highlight=built#ascii

		Built-in Functions
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

ascii(s)  # 只在Python3中支持,用于在不支持Unicode的平台查看Unicode字符串，就像repr()那样,创建对象的可打印形式,但在结果中只是用ascii字符,非ascii字符都转换为合适的转义序列。
print(ascii('hello你好'))  # 'hello\u4f60\u597d'

repr(obj)  # 将其它类型数据转换为字符串,支持大部分内置数据类型
print(repr(123))    # 123
print(repr('hello 你好'))   # 'hello 你好'

enumerate(i,start=0)  # 根据给定对象,返回枚举类型对象,是iterator类型

filter(function, iterable)  # 过滤序列中的值
# filter函数将序列iterable中的每一个元素传入函数function中,如果返回值为真,则添加到结果集中;否则,过滤掉
# 如果function为None,则将iterable中值为True的元素添加到结果集中

 

bytes(value=b'', encoding=None, errors='strict')  # 返回字节类型,字符范围[0,255]
print(bytes("hello 你好","utf-8"))  # b'hello e4\xbd\xa0\xe5\xa5\xbd'


bin(x)  # 返回一个字符串,其中包含整数x的二进制形式 0b1010
print(bin(0),bin(1),bin(10))  # 0b0 0b1 0b1010
oct(x)  # 将10进制数x转换为8进制数
print(oct(255)) # 0o377
hex(x)  # 将一个int类型的数字转换为16进制
print(hex(255),hex(0)) # 0xff 0x0

 

getattr(object, name[, default])  # 返回object的name属性值,name必须是str类型
# 如果不存在name属性,设置了default返回default值,否则,抛出异常AttributeError
class A(object):
  attr_01='value_01'
print(getattr(A,'attr_01'))
print(getattr(A,'attr_02','value_02'))
# print(getattr(A,'attr_03')) # AttributeError: type object 'A' has no attribute 'attr_03'

hasattr(object, name)  # 判断object是否拥有属性name,返回True或False
print(hasattr(A,'attr_01')) # True
print(hasattr(A,'attr_02')) # False

setattr(object, name, value)  # 给object设置属性name,值为value
setattr(A,'attr_02','value_02')
print(hasattr(A,'attr_02')) # True

 

format(value, [format_spec])
# 格式化显示value的值,类型为str
# 如果format_spec为空,则等效于str(value)
print(format(123)) # 123
print(format(True)) # True
print(format({'a':1,'b':2}))  # {'a':1,'b':2}
print(format(123,'b')) # 格式化为2进制 1111011
print(format(123,'o')) # 格式化为8进制 173
print(format(123,'d')) # 格式化为10进制 123
print(format(123,'x')) # 格式化为16进制,使用小写字母显示 7b
print(format(123,'X')) # 格式化为16进制,使用大写在木显示 7B
print(format(123456789.123456789,'e'))   # 科学计数法,默认保留6位小数 1.234568e+08
print(format(123456789.123456789,'0.2e'))  # 科学计数法,保留2位小数 1.23e+08
print(format(123456789.123456789,'E'))   # 科学计数法,1.234568E+08
print(format(123456789.123456789,'0.2E'))  # 科学计数法,1.23E+08
print(format(123456789.123456789,'f'))   # 小数点计数法,默认保留6位小数,123456789.123457
print(format(123456789.123456789,'0.2f'))  # 小数点计数法,保留2位小数,123456789.12
print(format(1.0e+1000,'F'),format(-1.0e+1000,'F')) # 小数点计数法,无穷大转换为字母 INF,-INF

 

isinstance(object, classinfo)  # 判断object是否是classinfo的一个实例
class A():pass
print(isinstance(1,int))  # True
print(isinstance(A(),A))  # True

issubclass(class, classinfo)  # 判断class是否是classinfo的一个子类
class A():pass
class B(A):pass
print(issubclass(B,A)) # True

 

map(function, iterable, ...)  # 在序列中映射函数：map函数会对一个序列对象中的每一个元素应用被传入的函数，并返回一个包含所有函数调用结果的映射集合
# res=map(lambda x:x,[1,2,3])
res=map(lambda x,y:x+y,[1,2,3],[4,5,6])
print(type(res))

reversed(seq)  # 翻转序列seq,返回Iterator
i=reversed(['a','b','c'])
print(i)
print(next(i),next(i),next(i),next(i,'没有了'))

round(number[, ndigits])  # 四舍五入
# ndigits为保留小数点位数,默认为0
print(round(16),round(16.18),round(8.88),round(-8.88))     # 16 16 9 -9
print(round(16,1),round(16.18,1),round(8.88,1),round(-8.88,1)) # 16 16.2 8.9 -8.9

class slice(start, stop[, step])  # 返回一个切片slice对象,表示步距,可用于切片操作,实际上对可迭代对象的切片操作就是调用了slice方法
print(slice(5))   # slice(None, 5, None)
print(slice(1,5))  # slice(1, 5, None)
print(slice(1,5,2)) # slice(1, 5, 2)
seq='abcdefghj'
print(seq[slice(5)])  # abcde
print(seq[slice(1,5,2)])# bd

sorted(iterable, *, key=None, reverse=False)  # 对可迭代对象进行排序
# key为函数,依次作用于每个元素，reverse为是否倒序排序
print(sorted('872Aadbc',key=None,reverse=True))# ['d', 'c', 'b', 'a', 'A', '8', '7', '2']
print(sorted('872Aadbc',key=lambda x :str.lower(x),reverse=True))# ['d', 'c', 'b', 'A', 'a', '8', '7', '2']

 

#1、语法
# eval(str,[,globasl[,locals]])
# exec(str,[,globasl[,locals]])

#2、区别
#eg：
s='1+2+3'
print(eval(s)) #eval用来执行表达式，并返回表达式执行的结果
print(exec(s)) #exec用来执行语句，不会返回任何值
'''
None
'''

#eg：
print(eval('1+2+x',{'x':3},{'x':30})) #返回33
print(exec('1+2+x',{'x':3},{'x':30})) #返回None

# print(eval('for i in range(10):print(i)')) #语法错误，eval不能执行表达式
print(exec('for i in range(10):print(i)'))

魔法方法

__str__：

将可迭代对象和float(类型) 中每个元素都转换成字符串

定义一个老师类，定制打印对象的格式为‘<name:C_D age:18 sex:male>’
class Teacher(object):
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __str__(self):
        return "<name:%s age:%s sex:%s>"%(self.name, self.age, self.sex)
t=Teacher("a",12,"male")
print(t)  # <name:a age:12 sex:male>

注意：对象被print时自动触发，打印对象__str__方法下返回的字符串

 

__repr__：

将其它类型数据转换为字符串,支持大部分内置数据类型

class Test(object):
    def __init__(self, word):
        self.world = word

    def __str__(self):
        return 'hello world %s str.' % self.world

    def __repr__(self):
        return 'hello world %s repr.' % self.world

t = Test('123')
print(str(t),repr(t))  # hello world 123 str. hello world 123 repr.

__str__相当于是str()方法 而__repr__相当于repr()方法。str是针对于让人更好理解的字符串格式化，而repr是让机器更好理解的字符串格式化。

 

在不使用print直接输出对象的时候，通常调用的就是repr方法，这个时候改写repr方法可以让他方便的输出我们想要知道的内容，而不是一个默认内容。

__hash__：

hash()方法的装饰器版本

__dir__：

 dir()的装饰器版本。查看当前环境下有哪些方法和属性可以进行调用。使用dir(object)语法，可以获得一个对象拥有的方法和属性。同理，在类中定义了__dir__()，就可以指定哪些方法和属性能够被dir()方法所查看查找到。

__getattr__：

访问一个并不存在的属性的时候就会调用，而如果这个属性存在则不会调用该方法。在找不到属性的情况下，正常的继承object的对象都会抛出AtrributeError的错误。

__getattribute__：

拦截所有的属性

__setattr__：

设置参数的时候会调用到，相当于设置参数前的一个钩子。每个设置属性的方法都绕不开这个魔法方法，在进行world参数赋值的时候，就会调用__setattr__方法，只有拥有这个魔法方法的对象才可以设置属性。使用该方法的时候要特别注意到不要被循环调用，因为任何赋值方法都会走这个魔法方法，如果在改写__setattr__方法里面使用了类似的赋值，又会循环调用回__setattr__方法。

__delattr__：

在删除属性的时候调用

__del__ 析构方法：

完成对象内部资源整理