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
"""
eval与exec
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']]
zip
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']}
View Code

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'}
max与min

二、匿名函数

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

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

在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 - 1num * 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()实现如下:

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是一个IteratorIterator是惰性序列,因此通过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
map

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()函数或得该地址的值
filter

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]变换成整数13579reduce就可以派上用场:

>>> 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]
reduce

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))
sorted
posted @ 2018-12-24 01:04  silencio。  阅读(435)  评论(0编辑  收藏  举报