内置函数的使用

内置函数的使用

返回首页

　　abs：求绝对值

print(abs(-1))   #求绝对值
print(abs(0))

　　all：传入可迭代对象，用布尔值去判断是否是可迭代。当参数都可迭代时，返回True。

print(all(' '))   #all里面要传入一个可迭代对象，all会将可迭代对象变成迭代器。然后布尔一下迭代出的值。当所有的值都为True时，才会返回True。
print(all((1,' ',2,None)))
print(all(i for i in range(1,10)))

　　any：和all对应，any只要有一个True，就会返回True。

print(any([])) #any和all对应，只是它只有一个结果是True就返回True
print(any([None,0,'',{},1]))

　　sum：求和

res=sum(i for i in range(3))
print(res)

　　bin：将整数返回一个二进制数。

print(bin(3))

　　bool：布尔值

print(bool(0))
print(bool(None))
print(bool(''))

　　bytes：把字符串转换成字节

print(bytes('hello',encoding='utf-8'))

　　callable：判断可不可以被调用

def test():
    pass
print(callable(test))
print(callable(sum))

　　chr：ASCII码对应的转换关系

print(chr(67))
print(chr(65))
print(ord('A'))

　　complex：设置实部和虚部

x=complex(1-2j)
print(x.real)
print(x.imag)

x=1-2j
print(x.real)  #显示实部
print(x.imag)  #显示虚部

　　int：整型

num=1 #num=int(1)
print(type(num)) #查看num的类型
print(isinstance(num,int)) #判断num是否为int类型
print(num is 1) #is 是身份运算，根据id去判断身份

　　str：字符串

x='asdfa' #x=str('asdfa')
print(str(1))
print(str({'a':1}))

　　list：列表

x=[]
x=list(i for i in range(10))
print(x)

　　dict：字典

d={'a':1}
d=dict(x=1,y=2,z=3)
print(d)

　　set：集合

s={1,2,3,4,4}
print(s)
s.add(5)
print(s)

　　frozenset：不可变集合

f=frozenset({1,2,3,4})
print(type(f))

　　dir：查看对象下的方法

l=[]
print(dir(l))

　　help：帮助

print(help(sum))

　　divmod：取整除值和取余

print(divmod(100,33))  #返回两个值，一个是整除值，一个是取余，可用来做前端分页

　　enumerate：是一个迭代器，取出的值，既包含元素，也包含元组。

for i in enumerate(['a','b','c','d']):
    print(i)

for i in enumerate({'x':1,'y':2}):
    print(i)

 　　hash：哈希值，相同数据的哈希值一致。

s='hello'
print(hash(s))
s='h'
print(hash(s))

　　hex：十进制转十六进制

print(hex(10))
print(hex(11))

　　id：查看身份的，唯一身份的。

print(id('asdf'))
a=1
b=2
print(id(a))
print(id(b))
print(a is b)
x='a'
y='a'
print(id(x))
print(id(y))
print(x is y)

　　max和min：求最大值和最小值

print(max(1,2,3,4,10,3))
print(min(1,2,3,4,10,3))

salaries={
    'george':300000,
    'wang':100000000,
    'jack':100000,
    'jumes':250000
}

def get_value(k):
    return salaries[k]

print(max(salaries,key=get_value))  #取薪资最高的人

　　lambda：匿名函数

salaries={
    'george':300000,
    'wang':100000000,
    'jack':100000,
    'jumes':250000
}

def get_value(k):
    return salaries[k]

print(max(salaries,key=get_value))  #取薪资最高的人

#匿名函数
lambda k:salaries[k]
f=lambda k:salaries[k]  #匿名函数也可以赋值一个名字，但是这便违反了匿名的初衷
print(f)
print(f('george'))

print(max(salaries))
print(max(salaries,key=get_value))
print(max(salaries,key=lambda k:salaries[k]))
print(min(salaries,key=lambda k:salaries[k]))

　　zip：拉链，zip会形成一个迭代器。

salaries={
    'george':300000,
    'wang':100000000,
    'jack':100000,
    'jumes':250000
}

l1=[1,2,3,4]
s='hel'
for i in zip(l1,s):
    print(i)  #将l1的值和s的值，交叉组成新的列表，按位交替，当l1的4没有对应的时候，s不会在没有值的情况下补位其他值。也既是i之打印到l1的3.

print(salaries.keys(),salaries.values())
z=zip(salaries.values(),salaries.keys())
print(z)
for i in z:  #这里的z就是一个zip对象。
    print(i)

　　sorted：排序，按升序排列。

l=[3,4,1,0,9,10]
print(sorted(l)) #返回值是列表，默认是升序
print(sorted(l,reverse=True)) #降序排列，reverse反转，就变成了降序。

s='hello abc'
print(sorted(s))

salaries={
    'george':3000,
    'wang':100000000,
    'jack':10000,
    'jumes':250
}
print(sorted(salaries)) #默认是按照字典salaries的key去排序的
print(sorted(salaries,key=lambda x:salaries[x])) #按薪资排序
print(sorted(salaries,key=lambda x:salaries[x]),reverse=True)

------------ END -----------