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'