Python内置函数

print(abs(2)) #求出绝对值
print(all(([],1,3)))  #传1个可跌倒对象，元素中包含的全部为可迭代对象，返回True 其他返回False #如果可迭代对象是空，就返回True
print(any((' ',None,[]))) #传1个可迭代对象，元素中包含1个可迭代对象，返回True 其他返回False
print(sum([1,23])) #传入1个可迭代对象，求和。
print(bin(3)) #求出二进制
print(bool(0)) #求出布尔值
print(bytes('张根'.encode('gbk')))
print(divmod(100,3)) #取出商和余数
print(hash("ssss"))

salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
f=lambda k: salaries[k]
print(max(salaries,key=lambda k: salaries[k]))
print(sorted(salaries,key=lambda x:salaries[x],reverse=True))
#默认按字典的键比较，如果有key关键字按照 key里面定义的函数执行结果比较； 
#参数key用来指定一个函数，此函数在每次元素比较时被调用，此函数代表排序的规则，也就是你按照什么规则对你

---

的序列进行排序；
# 也可以把函数传入 max 和sorted 后面函数 将传入 sorted传入迭代器 salary ，next序列salary一个逐一比较字典的值；
print(sorted(salaries,key=lambda x:salaries[x] ))

print(sorted(salaries,key=lambda x:salaries[x]))

from functools import reduce
l=['游勤兵','方少伟','高路川']
l1=[1,2,3,4]

map函数 将旧列表的内容，映射到一个新的列表；

g=map(lambda x:x+"2",l)  #map (函数，可迭代对象) 返回一个迭代器
for i in g:
    print(i)

reduce函数 将现有的数据内容，合并整合成一个新的列表；

#需要从第三方模块中导入 from functools import reduce
print(reduce( lambda x,y:x+y ,l1 ))  #reduce(函数，可迭代对象)

filter函数 讲现有的内容，按一定的规则过滤出来到一个新的列表；

get=filter(lambda f: f <5 ,l1) #filter(函数，可迭代对象) 返回以个迭代器 for i in get: print(i)

匿名函数

什么是匿名函数？

不声明函数名称的函数为匿名函数，也就是lambda函数，使用lambda函数可以时代码简洁、节省声明函数所需的内存；

#普通函数
def cala0(n):
    return n*n

print(cala0(10))

#lambda函数（匿名函数）
cala1=lambda n1,n2:n1*n2  #cala1是函数名，n1,n2是参数,:后面的是函数逻辑
print(cala1(10,20))

Lambda和max、min、map。。联合使用

dic={"k1":10,"k2":100,"k3":30}
def func(key):
    return dic[key]

print(max(dic))         #默认排序是根据字典中的键对应的accic码进行排序
print(max(dic,key=func))#指定排序的key为1个函数的返回值
print(max(dic,key=lambda k:dic[k])) #lambada和max内置函数共用

重要的内置函数

all()和any()内置函数

print(all(['A',False])) #all()内置函数接收1个可迭代对象，如果可迭代对象中的元素全部为True，才会返回
print(any(([None,1]))) #any()内置函数也是接收1个可迭代对象，和all()相对如果可迭代对象中元素任意1个为Ture都会返回True

zip()拉链函数

l=[1,2,3]
l1=['a','b','c']
l2=("*","**",[1,2])
print(dict(zip(l,l1)))#{1: 'a', 2: 'b', 3: 'c'}

filter()内置过滤函数

filter(接收1个函数，1个可迭代的对象）作为参数；

然后可迭代对象中的每1个元素将 传入函数中做为参数执行；

函数每1次执行如果返回True就会被筛选出来；

注意结果是个迭代器

filter执行后元素个数变少，只管筛选，不改变原来的值

筛选奇数

print(list(filter(lambda x: x+1 if x%2 == 1 else(),[1,4,6,7,9,12])))

 筛选字符串

print(list(filter(lambda x:x if type(x)==str else(),[1,'hello',6,7,"word",12,"18"])))

 求可以开方的数字

from math import sqrt
print(list(filter(lambda x:x if sqrt(x)%1==0 else(),range(0,100))))

map()内置过滤函数

对可迭代对象的元素进行改变

map执行后元素个数不变，值发生改变；

print(list(map(abs,[-1,7,-40,20])))

sorted()内置函数

列表自带的sort()方法，是在原列表的基础上进行排序

#列表自带的sort()方法
l=[1,-4,6,5,-10]
l.sort(key=abs)#根据绝对值对列表l进行排序
print(l)

 sorted(可迭代对象,key=func)，生成1个新的列表，占用内存；

#sorted(可迭代对象,key=func)，生成1个新的列表
print(sorted(l,key=abs,reverse=True))

 根据列表的长度排序

l=['  ',[1,2],'hello world']

print(sorted(l,key=len))

练习

print('=====================作业一'.center(50))
print('1、用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb')
name=['alex','wupeiqi','yuanhao']
g1=map(lambda i:i+'sb',name )
for i in g1:
    print(i)

print("2、用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾")
l=[{'name':'alex'},{'name':'y'}]
g2=map(lambda i:i['name']+'sb' ,l )
for i in g2:
    print(i)


print('=====================作业二'.center(50))

shares={
    'IBM':36.6,
    'Lenovo':23.2,
    'oldboy':21.2,
    'ocean':10.2,
}
print(shares)
print('1、用filter来处理,得到股票价格大于20的股票名字')
f3=filter(lambda d:d>20 ,shares.values())
for i in f3:
    print(i)



print('=====================作业二'.center(50))
print('1、如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格')
portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]
print(portfolio)

print('1:map来得出一个包含数字的迭代器，数字指的是：购买每支股票的总价格')

g4= map(lambda f:f['shares']*f['price'], portfolio)
for i in g4:
    print(i)
l=list(map(lambda f:f['shares']*f['price'], portfolio))
print('2:基于1的结果，用reduce来计算，购买这些股票总共花了多少钱')
from functools import reduce
print(l)
print(reduce(lambda x,y:x+y,l))

print('3、：用filter过滤出，单价大于100的股票有哪些')

g5=filter(lambda i:i['price'] <100,portfolio)
for i in g5:
    print(i)

执行结果

             =====================作业一             
1、用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb
alexsb
wupeiqisb
yuanhaosb
2、用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
alexsb
ysb
             =====================作业二             
{'IBM': 36.6, 'Lenovo': 23.2, 'oldboy': 21.2, 'ocean': 10.2}
1、用filter来处理,得到股票价格大于20的股票名字
36.6
23.2
21.2
             =====================作业二             
1、如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
[{'name': 'IBM', 'shares': 100, 'price': 91.1}, {'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'FB', 'shares': 200, 'price': 21.09}, {'name': 'HPQ', 'shares': 35, 'price': 31.75}, {'name': 'YHOO', 'shares': 45, 'price': 16.35}, {'name': 'ACME', 'shares': 75, 'price': 115.65}]
1:map来得出一个包含数字的迭代器，数字指的是：购买每支股票的总价格
9110.0
27161.0
4218.0
1111.25
735.7500000000001
8673.75
2:基于1的结果，用reduce来计算，购买这些股票总共花了多少钱
[9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]
51009.75
3、：用filter过滤出，单价大于100的股票有哪些
{'name': 'IBM', 'shares': 100, 'price': 91.1}
{'name': 'FB', 'shares': 200, 'price': 21.09}
{'name': 'HPQ', 'shares': 35, 'price': 31.75}
{'name': 'YHOO', 'shares': 45, 'price': 16.35}

内置函数——filter和map

参考