变幻莫测的python(四)---python3中的内置函数

1.整个内置函数图片

2.内置函数的大概介绍

abs(x) #返回一个数的绝对值，参数可以是整型或者浮点型，如果是一个复数类型，则返回其实数的绝对值
all(iterable)   #在一个可迭代的数据类型中，每一项的元素都不为空，则返回真，反之，返回假
any(iterable)   #在一个可迭代的数据类型中，任一元素不为空，返回真，反之，返回假
ascii(object)   #类似于repr(),返回一个可打印的字符串
bin(x)  #返回一个整数类型的二进制字符串，当x不为整型的时候，x必须实现__index__()方法来返回一个整型数值
bool(x) #将一个值转换成一个boolean类型的值
bytearray([source[,encoding[,errors]]]) #返回一个字节数组
bytes([source[,encoding[,errors]]]) #返回一个字节类型的对象
callable(object)    #检查一个对象是否可调用，如果一个实例的类实现了__call__()方法，则它是可以调用的
chr(i) #返回一个整数类型的字符串表达字母，和ord()正好相反
classmethod(function)   #返回一个类方法
compile(source,filename,mode,flags=0,dont_inherit,optimize=1)   #编译一个源，返回一个代码对象，该代码对象可以用来作为exec()或者eval()的参数
complex([real[,imag]])  #返回一个复数对象，类似于int(),str()等
delattr(object,name)    #删除一个对象的属性，相当于del object.name
dict()  #返回一个字典类型的对象
dir([object])   #返回一个列表对象，包含了object的所有属性，如果没有参数，则包含当前作用域的所用属性，如果该对象有一个__dir__()方法，则返回__dir__()的返回值，__dir__()的返回值必须是一个包含属性的列表对象
divmod(a,b) #返回一个包含商和余数的元组
enumerate(iterable,start=0) #返回一个可迭代的对象
eval(expression,global=None,locals=None)    #执行一段代码，expression必须是字符串
exec(object[,globals[,locals]]) #也是执行一段代码
filter(function,iterable)   #迭代一个可迭代的对象，每一个元素作为function的参数，真则保留下来，假则丢去，返回一个filter对象，可以用list()或者dict()等调用
float(x)    #返回一个浮点型的对象
format(value[,format_spec]) #格式化一个值，当参数是一个自定义对象的时候，该对象需要实现__format__()方法
frozenset([iterable])   #返回一个frozeset对象，即集合对象
getattr(object,name[,default])  #获得对象的name属性，当该属性不存在的时候可以使用一个默认值作为返回值
globals()   #返回一个包含当前各种信息的字典
hasattr(object,name)    #检查对象是否包含name属性，也与getattr()有所关联
hash(object)    #返回一个hash对象，如果有的话
help()         #帮助查询，输入对应的名称
hex(x)  #返回一个十六进制的值,与__index__()相关
input()  #输入  读取键盘的输入回车键结束
int(x[,base=10])    #返回相对应的进制的值
isinstance(object,classname)    #判断是否是一个类型的实例
issubclass(class,baseclass) #判断一个类是否是一个类型的子类型
iter(object[,sentinel]) #返回一个可迭代的对象
len(s)   #返回一个长度值，与object中的__len__()有关
locals()    #返回一个包含信息的字典
map(function,iterable)  #与filter()相似
max()   #返回列表中最大数值，如果是字符则对应ascii码大小
memoryview(object)  #返回一个memory view对象
min()     #返回列表中最小数值，如果是字符则对应ascii码大小
next(iterable[,default])    #下一个产生的生成值,与__next__()有关
oct(x)  #返回一个八进制的值，与__index__()相关
open() #返回一个打开文件的指针
ord(c)  #返回一个给定字符的整型值
pow(x,y[,z])  #指数计算
print()       #打印输出
property()  #这个函数要深入啊
range()     #快速生成序列对象
repr()  #返回一个计算机可识别的字符形式
reversed()  #倒序序列，如果是对象，则需要实现__reversed__()
round(flt, ndig=0) 接受一个浮点数 flt 并对其四舍五入，保存 ndig位小数。
set([iterable])  #返回一个集合
setattr(object,name,value)  #为一个对象的name属性设置一个value
slice(start,stop[,step])    #分割一个可分割的对象，返回其中的一部分
sorted(iterable[,key][,reverse]) #排序
staticmethod(function)  #返回一个静态的方法
str()   #转换为字符串
sum()   #求和
super() #当需要实现父类的构造方法时，可以被调用
tuple()  #返回一个元组
type()  #返回一个对象的类型，返回值是一个类型实例
vars([object])  #返回object中所有属性的信息的字典
zip(*iterable)  #并行遍历返回列表，如果不匹配，返回最小列表
__import__(name,globals=None,locals=None,fromlist=(),level=0)

3.内置函数详解实例

#返回一个数的绝对值。参数可以是一个整数或者一个浮点数。如果参数是一个复数，那么将返回它的模
>>> abs(1.0236)
1.0236
>>> abs(1)
1
>>> abs(1+2.4j)
2.5999999999999996
>>> abs(-1.0236)
1.0236
>>> abs(-1)
1
>>> abs(-1-2.4j)
2.5999999999999996
#在一个可迭代的数据类型中，每一项的元素都不为空，则返回真，反之，返回假  
>>> a=(1,'a',None)
>>> all(a)
False
#在一个可迭代的数据类型中，任一元素不为空，返回真，反之，返回假  
>>> a=(None,'a',None)
>>> any(a)
True
#类似于python2中的repr(),返回一个可打印的字符串
>>> ascii('a')
"'a'"
>>> a=(None,'a',None)
>>> ascii(a)
"(None, 'a', None)"
>>> ascii(1)
'1'
#返回一个整数类型的二进制字符串，当x不为整型的时候，x必须实现__index__()方法来返回一个整型数值  
>>> bin(556)
'0b1000101100'
#coding:utf
class Sen:
    def __init__(self,num):
        self.num=num
    def __index__(self):
        return int(self.num)

s=Sen(10.1)

#将一个值转换成一个boolean类型的值
print(bin(s))
>>> bool(1)
True
>>> bool(0)
False
>>> bool(None)
False
>>> bool('c' and 1)
True
#返回一个字节数组 根据大小
>>> bytearray(10)
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
>>> bytearray('senssic','utf8')
bytearray(b'senssic')
>>> a=(1,33,)
>>> bytearray(a)
bytearray(b'\x01!')
>>> for x in bytearray('senssic','utf8'):#使用str.encode()转换的结果
	print(x)


	
115
101
110
115
115
105
99
#返回一个数组对象
>>> a=bytes(10)
>>> type(a)
<class 'bytes'>
#返回一个包含商和余数的元组 
divmod(10,2)
(5, 0)
#返回一个长度值，与object中的__len__()有关
#coding:utf
class Sen:
    def __init__(self,num):
        self.num=num
    def __index__(self):
        return int(self.num)
    def __len__(self):
        return len(self.num)


a=Sen('senssic')
print(len(a))
>>> len('senssic')
7
>>> a=(1,'2',100)
>>> len(a)
3 
#指数计算，如果三个参数则前两则结果与第三个参数相求余
>>> pow(2,3)
8
>>> pow(2,99)
633825300114114700748351602688
>>> pow(2,3,4)
0
#接受一个浮点数 flt 并对其四舍五入，保存 ndig位小数。  
>>> round(10.2355486963,3)
10.236

#检查一个对象是否可调用，如果一个实例的类实现了__call__()方法，则它是可以调用的
>>> callable(dir)
True
>>> callable(a)
False
>>> callable(1)
False
#coding:utf
class Sen:
    def __init__(self,num):
        self.num=num
    def __call__(self, *args, **kwargs):
        print(args)


a=Sen('senssic')


print(callable(a))
#判断是否是一个类型的实例
#coding:utf
class Sen:
    def __init__(self,num):
        self.num=num
    def __call__(self, *args, **kwargs):
        print(args)


a=Sen('senssic')


print(isinstance(a,Sen))
#true
#快速生成序列
>>> a=range(1,11,1)
>>> for x in a:
	print(x)
1
2
3
4
5
6
7
8
9
10
#返回一个对象的类型，返回值是一个类型实例
>>> type(1)
<class 'int'>
>>> type('c')
<class 'str'>
>>> type((1,'c'))
<class 'tuple'>
>>> type([1,'d'])
<class 'list'>
#转为int并返回相对应的进制的值
>>> int(10)
10
>>> int(10.3)
10
>>> int('1234656')
1234656
>>> int('0b1100100',0)
100
#转换为float
>>> float(10)
10.0
>>> float('123.2')
123.2
#返回一个复数对象
>>>complex(20.4j+6)
(6+20.4j)
#字符串处理，字符串首字符大写
>>> a='abc'
>>> a.capitalize()
'Abc'
>>> 'bvc'.capitalize()
'Bvc'
#字符串处理，字符串替代
>>> a='a.b.c.d'
>>> a.replace('.','-')
'a-b-c-d'
#字符串处理，拆分字符串
>>> a='a-b-c-d'
>>> a.split('-')
['a', 'b', 'c', 'd']
#序列处理，过滤序列
>>> b=filter(lambda x:x>3,(1,2,3,4,5,6))
>>> for x in b:
	print(x)


	
4
5
6
#序列处理，合并序列，zip以最小序列为准
>>> a=(1,2,3)
>>> b=(4,5,6,7)
>>> c=(8,9,10,11,12)
>>> d=zip(a,b,c)
>>> for x in d:
	print(x)


	
(1, 4, 8)
(2, 5, 9)
(3, 6, 10)
#序列处理，处理序列返回处理序列列表
>>> a=map(lambda x:x+100,(1,2,3))
>>> for x in a:
	print(x)


	
101
102
103
>>> b=map(lambda x,y:x*y,(1,2,3),(4,5,6,7))
>>> for x in b:
	print(x)	
4
10
18
>>> c=map(lambda x,y:x*y,(1,2,3,None),(4,5,6,7))
>>> for x in c:
	print(x)
4
10
18
Traceback (most recent call last):
  File "<pyshell#241>", line 1, in <module>
    for x in c:
  File "<pyshell#235>", line 1, in <lambda>
    c=map(lambda x,y:x*y,(1,2,3,None),(4,5,6,7))
TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'