Python内置函数

一、内置函数

官方文档：点击 

# 匿名函数
f=lambda a,b:a+b
print(f(2,3))        　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　# 5

# abs() 取绝对值
print(abs(-111))       　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 # 111

# all() 循环可迭代对象的每个元素，都为真则返回True，否则返回假
# 0，None ，"",[],(),{} 是假的
print(all([11,22]))   　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　# True

# any 有一个为真，全部都为真
print(any([0,0,None]))     　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#False

# ascii 在对象类中找 __repr__，获取返回值
class D():
    def __repr__(self):
        return 'hello'
d=D()
print(ascii(d))       　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #hello

# bin 将十进制转换成2进制
# oct() hex()
print(bin(11))           　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #0b1011

#各种进制转换成十进制可以用int()
print(int('11',base=2))         　　　　　　　　　　　　　　　　　　　　　　　　　　 #将二进制'11'转换成十进制数 3

# bytearry   字节列表

# chr() 找到数字对于的ascii码
# ord() ascii码对应的数字
# chr ord 只适用于ascii码
print(chr(65))      　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 # A
print(ord('A'))     　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 # 65

# callable 后面加个括号是看否能执行
#complie() 接受一个字符串，将其转换成函数代码

# divmod 返回除法的（值，余数）
print(divmod(10,3))    　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 #(3,1)

# eval 计算器的功能 返回结果
print(eval('a+60',{'a':90}))        　　　　　　　　　　　　　　　　　　　　　　 # 150
print(eval('3+4*6/7+((1+2)-5)'))    　　　　　　　　　　　　　　　　　　　　　　 # 4.428571428571429

#exec,执行python代码,没有返回值
exec("for i in range(5):print(i)")  　　　　　　　　　　　　　　　　　　　　　　 # 直接循环输出0，1，2，3，4

# filter(函数，可迭代的对象）
# 循环可以迭代的对象，传入函数中执行，如果不符合就过滤
def fun(s):                 　　　　　　　　　　　　　　　　　　　　　　　　　　 #定义判断一个数是否是偶数的函数
    if s%2==0:
        return True
    else:
        return False
ret=filter(fun,[1,2,3,4,5,6,7,8])
for i in ret:
    print(i)               　　　　　　　　　　　　　　　　　　　　　　　　　　　# 打印出2，4，6，8

#用匿名函数改写一下
ret1=filter(lambda x:x%2==0,[1,2,3,4,5,6,7,8])
for i in ret1:
    print(i)                                      　　　　　　　　　　　　　 # 2,4,6,8

#map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
ret=map(lambda x:x+100,[1,2,3])
for i in ret:
    print(i)                                  　　　　　　　　　　　　　　　 # 101,102,103

# globals() 获取当前文件的所有全局变量
# locals()  获取当前文件的所有局部变量
# hash()    获取哈希值
# isinstance 看某个对象是不是某个类创建的

#iter() 创建一个可以被迭代的对象 next()取下一个值
k=iter([1,2,3,4])
print(next(k))                  　　　　　　　　　　　　　　　　　　　　　　   # 1

# pow() 求指数
print(pow(2,10))        　　　　　　　　　　　　　　　　　　　　　　　　　　　  #1024

# round() 四舍五入
# #zip
l1=[1,2,3,4]
l2=['a','b','c','d']
k=zip(l1,l2)
for i in k:
    print(i)                     　　　　　　　　　　　　　　　　　　　　　　 #打印出(1,a),(2,b)....

"""
匿名函数:
与有名函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字,但是让其有名字就没有意义
有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能
匿名函数：一次性使用，随时随时定义
应用：max，min，sorted,map,reduce,filter
"""
def func(x,y,z=1):
    return x+y+z

lambda x,y,z=1:x+y+z
func=lambda x,y,z=1:x+y+z  #让其有名字就没有意义
func(1,2,3)

"""
三元表达式：
格式： res=值1  if  条件  else  值2
"""
name = "tom"
res = "是 tom"  if name == "tom" else "不是tom"
print(res) #是 tom

"""
列表推导式：
优点：方便，改变了编程习惯，可称之为声明式编程
"""
lis_gen = [ i for i in range(1,10)]  #列表推导式  通过计算生成一个列表
print(lis_gen) #[1, 2, 3, 4, 5, 6, 7, 8, 9]

lis1_gen = [i for i in range(1,10) if i%2 == 0]  #生成一个偶数的列表
print(lis1_gen) #[2, 4, 6, 8]

lis2_gen = [ i * i for  i in range(1,10) if i%2 == 1]  #生成以个奇数乘自已本身奇数的列表
print(lis2_gen) #[1, 9, 25, 49, 81]

#推导式的套路
"""
variable = [out_exp_res for out_exp in input_list if out_exp == 2]
  out_exp_res:　　列表生成元素表达式，可以是有返回值的函数。
  for out_exp in input_list：　　迭代input_list将out_exp传入out_exp_res表达式中。
  if out_exp == 2：　　根据条件过滤哪些值可以。
"""

#列表推导式
#例一：30以内所有能被3整除的数
multiples = [i for i in range(30) if i % 3 is 0]
print(multiples) #  [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

#例二：30以内所有能被3整除的数的平方
def squared(x):
    return x*x
multiples = [squared(i) for i in range(30) if i % 3 is 0]
print(multiples) #[0, 9, 36, 81, 144, 225, 324, 441, 576, 729]


#字典推导式
mcase = {'a': 10, 'b': 34}
mcase_frequency = {mcase[k]: k for k in mcase}
print(mcase_frequency,type(mcase_frequency))  #{34: 'b', 10: 'a'} <class 'dict'>

#集合推导式
squared = {x**2 for x in [1, -1, 2]}
print(squared) #{1, 4}

#求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表
print([(x,y) for x in range(5) if x%2==0 for y in range(5) if y %2==1]) #[(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]

#求M中3,6,9组成的列表M = [[1,2,3],[4,5,6],[7,8,9]]
M = [[1,2,3],[4,5,6],[7,8,9]]
print([row[2] for row in M])  #[3, 6, 9]



##########################################
def func():pass
print(callable(func))   # True   判断一个变量是否可以调用 函数可以被调用

print(dir(123))  #返回值是列表       # 查看数字类型中含有哪些方法

print(eval('1+2-3*4/5'))  # 0.6000000000000001   执行字符串数据类型的代码并且将值返回
exec('print(123)') #123    执行字符串数据类型的代码但没有返回值


##################
"""
zip函数接收一个或多个可迭代对象作为参数，最后返回一个迭代器：
zip(x, y) 会生成一个可返回元组 (m, n) 的迭代器，其中m来自x，n来自y。
一旦其中某个序列迭代结束，迭代就宣告结束。 因此迭代长度跟参数中最短的那个序列长度一致。
"""
x = [1, 3, 5, 7, 9]
y = [2, 4, 6, 8]
for m, n in zip(x, y):
    print(m,n)

"""
1 2
3 4
5 6
7 8
"""

#如果上面不是你想要的效果，那么你还可以使用 itertools.zip_longest() 函数来代替这个例子中的zip。
from itertools import zip_longest
x = [1, 3, 5, 7, 9]
y = [2, 4, 6, 8]
for m, n in zip_longest(x, y):
    print(m,n)

"""
1 2
3 4
5 6
7 8
9 None
"""

keys = ["name", "age", "salary"]
values = ["Andy", 18, 50]

print(dict(zip(keys, values)))  #{'name': 'Andy', 'salary': 50, 'age': 18}
print(list(zip(keys, values)))  #[('name', 'Andy'), ('age', 18), ('salary', 50)]
print(tuple(zip(keys, values))) #(('name', 'Andy'), ('age', 18), ('salary', 50))
print(set(zip(keys, values)))  #{('age', 18), ('salary', 50), ('name', 'Andy')}

"""
eval与exec
语法：
    eval(str,[,globasl[,locals]])
    exec(str,[,globasl[,locals]])
"""

#示例1：
s='1+2+3'
print(eval(s)) #eval用来执行表达式，并返回表达式执行的结果 返回6
print(exec(s)) #exec用来执行语句，不会返回任何值，也就是返回None

#示例2：
dic = "{'x':3}"
print(eval(dic),type(eval(dic))) #{'x': 3} <class 'dict'>
print(exec(dic),type(exec(dic))) #返回None <class 'NoneType'>

# print(eval('for i in range(10):print(i)')) #语法错误，eval不能执行表达式
print(exec('for i in range(3):print(i)'))

"""
0
1
2
None
"""

salaries = {
    'tom': 3000,
    'jack': 122121221,
    'rose': 100,
}
k_and_v = zip(salaries.values(), salaries.keys())

print(k_and_v)  # <zip object at 0x0000000000C07BC8>
print(max(k_and_v))  # (122121221, 'jack')
#k_and_v是迭代器，因而只能访问一次
# print(min(k_and_v)) #报错了

k_and_v2 = zip(salaries.values(), salaries.keys())
# print(list(k_and_v2))  # [(3000, 'tom'), (122121221, 'jack'), (100, 'rose')]
# print(list(zip(k_and_v2))) #[((3000, 'tom'),), ((122121221, 'jack'),), ((100, 'rose'),)]
# print(list(zip(*k_and_v2))) #[(3000, 122121221, 100), ('tom', 'jack', 'rose')]
print(list(map(list, zip(*k_and_v2)))) #[[3000, 122121221, 100], ['tom', 'jack', 'rose']]

list_items = ["id", "name", "age", "phone", "dept", "enroll_data"]

with open(r'aa','r',encoding='utf-8') as fp:
    staff_list = [line.strip().split(',') for line in fp]

staff_list =[['1', 'tom', '22', '13651054608', 'IT', '2013-04-01'], ['2', 'rose', '28', '13451024608', 'HR', '2015-01-07']]
print(list(zip(*staff_list)))
#[('1', '2'), ('tom', 'rose'), ('22', '28'), ('13651054608', '13451024608'), ('IT', 'HR'), ('2013-04-01', '2015-01-07')]

print(list(map(list, zip(*staff_list))))
#[['1', '2'], ['tom', 'rose'], ['22', '28'], ['13651054608', '13451024608'], ['IT', 'HR'], ['2013-04-01', '2015-01-07']]

print(list(zip(list_items, map(list, zip(*staff_list)))))
#[('id', ['1', '2']), ('name', ['tom', 'rose']), ('age', ['22', '28']), ('phone', ['13651054608', '13451024608']), ('dept', ['IT', 'HR']), ('enroll_data', ['2013-04-01', '2015-01-07'])]

print(dict(zip(list_items, map(list, zip(*staff_list)))))
#{'phone': ['13651054608', '13451024608'], 'name': ['tom', 'rose'], 'enroll_data': ['2013-04-01', '2015-01-07'], 'age': ['22', '28'], 'dept': ['IT', 'HR'], 'id': ['1', '2']}

max/min

• max函数处理的是可迭代对象，相当于一个for循环取出每一个元素进行比较
• 注意：不同类型之间不能进行比较
• 每一个元素间进行比较，是从每一个元素的第一个位置依次比较，如果这一个位置分出大小，后面的都不需要比较了，直接得出这两元素的大小

"""
max min
字典的运算：最小值，最大值，排序
迭代字典，取得是key，因而比较的是key的最大和最小值
"""
salaries={
    'tom':3000,
    'jack':122121221,
    'rose':100,
}
#比较的是key
print(max(salaries)) #tom
print(min(salaries)) #jack

#比较的是values
print(max(salaries.values())) #122121221
print(min(salaries.values())) #100

#即要key也要value
print(max(zip(salaries.values(),salaries.keys()))) #(122121221, 'jack')
print(max(salaries)) #jack

people=[
    {'name':'tom','age':12},
    {'name':'rose','age':50},
    {'name':'jack','age':99},
]
print('===',max(people,key=lambda dic:dic['age']))  #=== {'age': 99, 'name': 'jack'}

二、匿名函数

当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。

匿名函数没有函数名，只使用一次。

在Python中，对匿名函数提供了有限支持。还是以map()函数为例，计算f(x)=x2时，除了定义一个f(x)的函数外，还可以直接传入匿名函数：

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

通过对比可以看出，匿名函数lambda x: x * x实际上就是：

def f(x):
    return x * x

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

同样，也可以把匿名函数作为返回值返回，比如：

def build(x, y):
    return lambda: x * x + y * y

三、递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

于是，fact(n)用递归的方式写出来就是：

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

上面就是一个递归函数。可以试试：

>>> fact(1)
1
>>> fact(5)
120
>>> fact(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

如果我们计算fact(5)，可以根据函数定义看到计算过程如下：

===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：

>>> fact(1000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in fact
  ...
  File "<stdin>", line 4, in fact
RuntimeError: maximum recursion depth exceeded in comparison

解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。

fact(5)对应的fact_iter(5, 1)的调用如下：

===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

def age(n):
    if n == 5:
        return 18
    return age(n+1)+2


print(age(1))

l=[1,[2,3,[4,5,[6,7,[8,9,[10,11,[12,13]]]]]]]
def func(l):
    for i in l:
        if isinstance(i,list):
            func(i)
        else:
            print(i)

func(l)

四、高阶函数

函数作为参数传入或者return返回一个函数，满足其中一个条件，这样的函数就称为高阶函数。

1、map函数(映射)

map函数接受两个参数，一个是函数，一个可迭代的对象(iterable),map将传入的函数依次作用到序列的每个元素，并把结果作为新的 可迭代的对象 的结果返回

举例说明，比如我们有一个函数f(x)=x2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：

现在，我们用Python代码实现：

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

你可能会想，不需要map()函数，写一个循环，也可以计算出结果：

L = []
for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    L.append(f(n))
print(L)

的确可以，但是，从上面的循环代码，能一眼看明白“把f(x)作用在list的每一个元素并把结果生成一个新的list”吗？

所以，map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

number = [1,2,3,4,5,6]
#1.用普通函数定义方法
def add_one(x):
    return x+1
def map_test(func,arrey):
    res = []
    for i in arrey:
        i = func(i)
        res.append(i)
    return res
print(map_test(add_one,number)) #[2, 3, 4, 5, 6, 7]

#2.用lambda函数定义的得到结果，借助1定义的map_test函数
print(map_test(lambda x:x+1,number))  #[2, 3, 4, 5, 6, 7]

#3.用map()本身函数去定义
print(map(lambda x:x+1 ,number)) #<map object at 0x00000000010EAC18>  返回一个可迭代对象
print(list(map(lambda x:x+1 ,number))) #[2, 3, 4, 5, 6, 7]

#注：map（）得出的结果是一个iterator ，需要用list（）函数让它个整个序列都计算出来返回一个list

2、filter函数(过滤)

　　filter()函数用于过滤序列和map()类似，filter()也接受一个函数和一个可迭代的对象(iterable)，不同的是fillter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

# 把列表中空字符串，空元素，都去掉
aa = ['A', '', 'B', None, 'C', '  ']
#1.自定义函数测试
def not_empty(s):
    return  s and s.strip()
def filter_test(func,iter):
    res = []
    for i in iter:
        i = func(i)
        if i:
            res.append(i)
    return res

print(filter_test(not_empty,aa)) #['A', 'B', 'C']

#2.用lambda函数定义的得到结果
print(filter_test(lambda s:s and s.strip(),aa)) #['A', 'B', 'C']

#3.filter内置函数测试
print(filter(not_empty,aa))#<filter object at 0x00000000010FAC18>
print(list(filter(not_empty,aa)))#['A', 'B', 'C']
#注：filter()函数返回的是一个iterator，内存地址，需要看内存地址的值， 用list()函数或得该地址的值

3、reduce函数

　　reduce(function, sequence, initial=None) 在python2可以直接用reduce()函数，在python3需要导入reduce模块 from functools import reduce reduce函数，将function作用sequence序列的元素，每次携带一对(先前的结果以及下一序列的元素)，得到一个最终结果的返回值

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方说对一个序列求和，就可以用reduce实现：

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。

但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

这个例子本身没多大用处，但是，如果考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579

整理成一个str2int的函数就是：

from functools import reduce

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    return reduce(fn, map(char2num, s))

还可以用lambda函数进一步简化成：

from functools import reduce

def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

from functools import reduce

#使用reduce()，结合lambda()
number1 = [2, 3, 4, 10]
print(reduce(lambda x, y: x * y, number1))  # 240

# 1.普通函数定义
def mul(x, y):
    return x * y  # 返回得到两个数相乘的结果


def reduce_test(func, seq, init=None):
    if init is None:
        res = seq.pop(0)  # seq删除第一个元素，并获取删除这个元素 赋值给res
    else:
        res = init
    for i in seq:
        res = func(res, i)  # 循环一次，执行func这个函数
    return res
print(number1)  #[2, 3, 4, 10]
print(reduce_test(mul, number1))  # 240
print(number1)  #[3, 4, 10]
print(reduce_test(mul, number1, 10))  # 2400
print(number1)  #[3, 4, 10]
# 2.lambda函数，借助reduce_test()函数定义
print(reduce_test(lambda x, y: x * y, number1, init=3))  # 720
print(number1)  #[3, 4, 10]

4、sorted函数

　　sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序,key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。

# _*_coding:utf-8_*_
#sorted
print(sorted([36, 5, -12, 9, -21], key=abs))
#[5, 9, -12, -21, 36]
print(sorted([36, 5, -12, 9, -21], key=abs, reverse=True)) #reverse=True 倒序
#[36, -21, -12, 9, 5]
#成绩从高到底排序
li = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
print(sorted(li, key=lambda x: x[1], reverse=True))
#[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]
#以列表中每个元素的第二个字母倒序排序
li = ['alex', 'egon', 'smith', 'pizza', 'alen']
print(sorted(li, key=lambda x: x[1], reverse=True))


#map
name=['alex','wupeiqi','yuanhao','egon']
def nb(x):
   return x+'_nb'
res = map(nb,name)
print(list(res))  #['alex_nb', 'wupeiqi_nb', 'yuanhao_nb', 'nezha_nb']

#用filter函数处理数字列表，将列表中所有的偶数筛选出来
num = [1,3,5,6,7,8]
def func(x):
   if x%2 == 0:
       return True
ret = filter(func,num)
print(list(ret)) #[6, 8]
#用filter过滤出，单价大于100的股票有哪些
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}
]
f = filter(lambda d:d['price']>=100,portfolio)
print(list(f))