day14(内置函数)

print（list(map(func, lambda x : x)）

print（list(filter lambda x : x > len(x))）

print(zip(l1,l2,tu)[2:])

print(fileter lambda x,y : len(x)> 3 and y>2 )

13.有两个字符串列表,a和b,每个字符是由逗号分隔的一些字符,(升级题)尽量做得支持扩展
a = [
'a,1',
'b,3,22',
'c,3,4'
'f,5'
]
b=[
'a,2',
'b,4',
'd,2'
'e,12'
]
按每个字符串的第一个值,合并a和b到c
c = [
'a,1,2',
'b,3,22,4',
'c,3,4',
'd,2',
'e,12',
'f,5'
]

# 老师的方法，老师善用字典，添加增加  get 方法  遍历  推导式的对应很厉害

# 老师的方法，老师善用字典，添加增加  get 方法  遍历  推导式
dic = { i[0]:i for i in  d}#{'a': 'a,1', 'b': 'b,3,22', 'c': 'c,3,4', 'f': 'f,5'}
l = []
for em in b:  #遍历好
    if dic.get(em[0]):   # 如果在里面 则是真
        # em += dic[em[0]][1:]
        # l.append(em)      # 我的垃圾思想
        dic[em[0]]+=em[1:]# 添加值   切片一下
    else:
        # l.append(dic)
        # l.append(em)
        dic[em[0]] = em   #不在里面  添加键值对
        # l.append(dic)     #这里蒙住了
print(dic.values())#dict_values(['a,1,2', 'b,3,22,4', 'c,3,4', 'f,5', 'd,2', 'e,12'])
print(list(dic.values()))#['a,1,2', 'b,3,22,4', 'c,3,4', 'f,5', 'd,2', 'e,12']

#我做的，每次都弄成 reduce 不会用 乱用 做出来了才是  好方法

from functools import reduce
# i = 0
lis = []
# def func(x,y):      # x=12345

for i in range(len(x)):
    if x[i][0] == y[i][0]:
        # print(x[i][0])
        lis.append(x[i]+y[i][1:])
    else:
        lis.append(x[i])
        lis.append(y[i])
    # return x[i][i],y[i][i]     # reduce 是做累计算的
# print(reduce(func,(a,b)))
# func(a,b)
print(lis)

'''
12.    求结果
v = (lambda :x for x in range(10))
print(v)
print(v[0])
print(v[0]())
print(next(v))
print(next(v)())'''

print(v)#<generator object <genexpr> at 0x000000000289E938>
# print(v[0])#TypeError: 'generator' object is not subscriptable
# print(v[0]())#TypeError: 'generator' object is not subscriptable
print(next(v)())  #
a = v.__next__()
print(v.__iter__().__next__())#<function <genexpr>.<lambda> at 0x00000000028AA268>
print(v.__next__)#<method-wrapper '__next__' of generator object at 0x000000000286E938>  # 就这个每迭代 前面有括号的都调用了
print(next(v))#<function <genexpr>.<lambda> at 0x000000000288A2F0>
print(next(v)())#
print(next(v)())#
print(next(v)())#

# 和迭代器似的，

# 11.    求结果
# v = [lambda :x for x in range(10)]
# print(v)
# print(v[0])
# print(v[0]())

自己写

la = []
def func(i):  #我自己听了老师自己写的  ，写的函数地址一样 结果对的
    for i in range(10):
        print(end='')
        print(func)
        la.append(func)  #<function func at 0x0000000000441E18>
                            #<function func at 0x0000000000441E18>
    return func
func(0)
print(la)

老师举例

li = []
for x in range(10):# 老师说的太棒了
    def func():
        return x
    li.append(func)
print(li)
v = [lambda :x for x in range(10)]
print('\n',v,'\n',li) # 两个 分别是lambda 和函数的 10个地址
print(v[0],li[0])#<function <listcomp>.<lambda> at 0x000000000290F0D0> <function func at 0x00000000028FAA60>
print(v[0](),li[0]())#9 9

# 10.有如下数据类型：
 # 将l1按照列表中的每个字典的values大小进行排序，形成一个新的列表。
l1 = [{'sales_volumn': 0},
      {'sales_volumn': 108},
      {'sales_volumn': 337},
      {'sales_volumn': 475},
      {'sales_volumn': 396},
      {'sales_volumn': 172},
      {'sales_volumn': 9},
      {'sales_volumn': 58},
      {'sales_volumn': 272},
      {'sales_volumn': 456},
      {'sales_volumn': 440},
      {'sales_volumn': 239}]

print(list(sorted(l1,key=lambda x :x['sales_volumn']))) 

# 这个题 的 key 使用 lambda 传的， 还有 sorted 还得用列表包一下啊

# 9.有下列三种数据类型，
#  l1 = [1,2,3,4,5,6]
#  l2 = ['oldboy','alex','wusir','太白','日天']
#  tu = ('**','***','****','*******')
# 写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个。）
#  [(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。

#前后写了许久，因为zip不明白意思，是拉链，是多个拉起来，一个的话默认不拉  还有判断的那个 第一个元素用索引x[0]and  第三个 用索引x[-1] 都是基础 但是不会

#老师的方法
print(list(filter(lambda x:x[0]>2 and len(x[-1])>3 ,list(zip(l1,l2,tu)))))

出错过程

# l = list(zip(l1,l2,tu))
# print(list(zip(l)))
# l = (l1,l2,tu)  # 这样包是元组
# print(list(zip(l)))
# l1 = list(zip(l1,l2,tu)) #这样包是括号  拉链 一个对应一个的咬合
# print(l1)
# print(list(filter(lambda x: ,list(zip(l)))))  #耻辱
print(list(filter(lambda x:x[0]>2 and len(x[-1])>3 ,list(zip(l1,l2,tu)))))
#前后写了许久，因为zip不明白意思，是拉链，是多个拉起来，一个的话默认不拉  还有判断的那个 第一个元素用索引x[0]and  第三个 用索引x[-1] 都是基础 但是不会

自己的做法

l1 = [1, 2, 3, 4, 5, 6]
l2 = ['oldboy', 'alex', 'wusir', '太白', '日天']
tu = ('**', '***', '****', '*******')
# print( list(filter(lambda x,y,z:(x>2,len(x)>=4,len(x)>=4),(l1,tu,l2))))
b = list(filter(lambda x:len(x)>=4,tu))
c = list(filter(lambda x:len(x)>=4,l2))
a = list(filter(lambda x:x>2,l1))
print(list(zip(a,b,c)))

# 7.有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。
# 结果：list一下[9110.0, 27161.0,......]
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}]

自己做法

from functools import reduce
# l = []
# def func(x,y):
    # for i in portfolio:
    # l.append((i['shares']*i['price']))
    # l.append(x*y)
# print(list(reduce(func,(portfolio['shares']))))
ll = []
for i in portfolio:
    ll.append(i['price']*i['shares'])
print(ll)
#强行用函数

老师做法

# print(([i['shares']*i['price']for i in portfolio]))

8.还是上面的字典，用filter过滤出单价大于100的股票。（怎么凑出来的？）

print(list(filter(lambda x:x['price']>100,portfolio)))

'''
6.用filter来处理,得到股票价格大于20的股票名字
shares={'IBM':36.6,
    'Lenovo':23.2,
   'oldboy':21.2,
    'ocean':10.2,}
'''

print(list(filter(lambda x:shares[x]>20,shares)))

5.用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
 l=[{'name':'alex'},{'name':'y'}]

print(list(map((lambda x:x['name']+'_sb'),l)))

# 4.用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
#  name=[‘oldboy’,'alex','wusir']

print(list(map((lambda x:x+'_sb'),name)))