内置函数的使用

内置函数的使用

返回首页

　　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))  #取薪资最高的人，拿value比较，返回value对应的key

　　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)

 　　map：采集一些数据，放在列表中，然后对每个数据进行处理，提取有用的结果。

　　　　　 map函数结合lambda使用，将原始列表的数据进行处理，生成一个新的列表。

l=[1,2,3,7,5]
x=[i**2 for i in l]
print(x)

m=map(lambda item:item**2,l)
print(m)

for i in m:
    print(i)

print(list(m))

name_l=['george','wang','tom','jim']
m=map(lambda name:name+'Good',name_l)
print(list(m))

　　reduce：合并，导入 from functools import reduce 

　　　　       通过合并操作，可以得到一个最终的结果。

from functools import reduce #合并
l=list(range(100))
print(l)
print(reduce(lambda x,y:x+y,l,100))  #求100的和

i=iter(l)
100 next(i) --->100,0----->x,y-x+y-->100
100 next(i)---->100,1----->x,y--x+y-->101
101 next(i)----->101,2

  　　filter：过滤

name_l=[
    {'name':'george','age':18},
    {'name':'Fire','age':1000},
    {'name':'wang','age':9000},
    {'name':'tom','age':10000},
]

f=filter(lambda d:d['age'] > 100,name_l)
print(f)
for i in f:
    print(i)

　　oct：进制，十进制转八进制

print(oct(10))

　　pow：只有两个参数，取平方。三个值，是前两个值的平方对第三个值，取余数。

print(pow(3,2,2))

　　reversed：反转

print(list(reversed([1,5,3,9])))　

　　round：小数点大于5进一。

print(round(10.3))
print(round(10.5))
print(round(10.6))
print(round(10.9))

　　slice：切片

l=[1,2,3,4,5,6,7,9]
print(l[2:5:2])
print(l[2:4])
s1=slice(2,5)
s2=slice(2,5,2)  #位置参数是开始，结束，步长
print(l[s1])
print(l[s2])

　　vars：

print(vars() is locals()) #vars 和 locals一样，打印局部空间名字
print(vars())
print(locals())

 

 

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