day 18 lambda表达式

Posted A-a

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了day 18 lambda表达式相关的知识,希望对你有一定的参考价值。

一、复习

迭代器:拥有__iter__,__next__;

怎样从迭代器中取值:_next 和 for

生成器:

自己定义一个能实现迭代器功能的函数就是生成器

生成器函数:带yield的函数,调用生成器函数,不会执行函数中的任何功能,只是返回一个生成器,调用next、时才执行函数中内容,遇到yield停止,并返回yield的值

 

send方法就是向函数中传值,把值赋给yield对应的变量,同时还执行next方法

一个要用send方法的生成器函数中至少要有两个yield、

一个生成器函数中有多少个yield就可以调用多少个(next+send)方法、

生成器的激活只能用next方法

#2.生成器表达式
#new_g = (i*i for i in range(100)) #new_g是一个生成器表达式

 

二、作业

读文件,找带关键字的行

 

# 3.处理文件,用户指定要查找的文件和内容
# 将文件中包含要查找内容的每一行都输出到屏幕

def read(fname,str):
    with open(fname,encoding="utf-8")as f:
        l=f.readlines();
        for i in l:
            if str in i:
                yield i

aa=read("1","奥特曼")
for i in aa:
    print(i)

、进阶版本

__author__ = Administrator

def init(fun):
    def inner(*args,**kwargs):
        g=fun(*args,**kwargs)
        next(g)
        return g
    return inner



@init
def read(g_read_line):
    while True:
        fname=yield
        str=yield
        with open(fname,encoding="utf-8")as f:
            l=f.readlines()
            for line in l:
                if str in line:
                    g_read_line.send(line)

@init
def read_line():
    while True:
        line=yield
        if line:print(line)



g_read=read(read_line())
g_read.send("1")
g_read.send("奥特曼")

列表推倒式和生成器表达式

new_l = []
for i in range(100):
    new_l.append(i*i)

#list(range(100))

new_l = [i*i for i in range(100)]

new_l = (i*i for i in range(100))  #生成器表达式

生成器相关面试题

# def demo():
#     for i in range(4):
#         yield i
# g=demo()
# g1=(i for i in g)
# g2=(i for i in g1)
# print(list(g2))
# print(list(g1))

def add(n,i):
    return n+i
def test():
    for i in range(4):
        yield i
g=test()
for n in [1,10]:
    g=(add(n,i) for i in g)

# # g=(add(n,i) for i in g)
# n = 10
# g=(add(n,i) for i in (add(n,i) for i in g))
# print(list(g))

# for i in [1,2]:
#     pass
#
# print(i)


import os

def init(func):   #预激活生成器的一个装饰器
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)  #func是一个生成器函数,返回的g是一个生成器
        next(g)   #预激活生成器
        return g #返回激活后的生成器g
    return wrapper

@init    #list_files = init(list_files) == wrapper
def list_files(target): #target = opener_g
    while 1:
        dir_to_search=yield
        for top_dir,dir,files in os.walk(dir_to_search): #os.walk   (路径,文件夹,文件)
            for file in files:  #从文件列表中获取一个一个的文件
                target.send(os.path.join(top_dir,file))  #把文件的绝对路径传给了opener_g
@init    #opener = init(opener)  ==  wrapper
def opener(target): #target = cat_g
    while 1:
        file=yield   #拿到了一个文件的路径
        fn=open(file,encoding=utf-8) #打开文件获取了一个文件句柄
        target.send((file,fn))  #cat_g发送了一个文件的路径和句柄
@init  #cat = init(cat) == wrapper
def cat(target):  #target = grep_g
    while 1:
        file,fn=yield  #文件路径和文件的句柄
        for line in fn:
            target.send((file,line))  #文件路径,文件中的一行
@init  #grep = init(grep) == wrapper
def grep(pattern,target):  #要搜索的关键字,printer_g
    lst = []
    while 1:
        file,line=yield  #文件的路径和每一行
        if pattern in line and file not in lst: #判断关键字是否在当前行
            lst.append(file)
            target.send(file) #printer_g.send文件路径
@init  #printer = init(printer) == wrapper
def printer():
    while 1:
        file=yield  #获取一个文件路径
        if file:
            print(file)  #打印文件的路径:文件里包含了要搜索的关键字

g=list_files(opener(cat(grep(python,printer()))))
# g=list_files(opener(cat(grep(‘python‘,printer_g))))
# g=list_files(opener(cat(grep_g)))
# g=list_files(opener(catg)))
# g=list_files(opener_g)
g.send(D:\Python代码文件存放目录\S6\day18)

#用户给一个路径和关键字
#可以从一个文件路径中找到所有包含关键字的文件

二、匿名函数、

匿名函数 简单的需要用函数去解决的问题 匿名函数的函数体 只有一行也叫lambda表达式

# cal2 = lambda n : n*n
# ret = cal2(20)
# print(ret)

# def add(x,y):return x+y
# add2 = lambda x,y : x+y
# ret = add2(1,2)
# print(ret)
print(max(dic))
func = lambda k:dic[k]
print(max(dic,key = func))
print(max(dic,key=lambda k:dic[k]))
l = [1,2,3,4]
d=lambda x:x*x
print(list(map(d,l)))
l = [10,11,8,12]
# def func(x):
#     return x>10
# print(list(filter(func,l)))
# print(list(filter(lambda x:x>10,l)))
#现有两个元组((‘a‘),(‘b‘)),((‘c‘),(‘d‘)),请使用python中匿名函数生成列表[{‘a‘:‘c‘},{‘b‘:‘d‘}]
t1 = ((a),(b))
t2 = ((c),(d))
print(list(zip(t1,t2)))
c=lambda t:{t[0]:t[1]}
d=map(c,zip(t1,t2))
print (list(d))


d=list(map(lambda z:{z[0],z[1]},zip(t1,t2)))
print(d)
l=[i for i in range(100) if i%3==0]
print(l)
print(len(l))
# names = [[‘Tom‘, ‘Billy‘, ‘Jefferson‘, ‘Andrew‘, ‘Wesley‘, ‘Steven‘, ‘Joe‘],
#          [‘Alice‘, ‘Jill‘, ‘Ana‘, ‘Wendy‘, ‘Jennifer‘, ‘Sherry‘, ‘Eva‘]]
# print([name for lst in names for name in lst if name.count(‘e‘) >=2])
mcase = {a: 10, b: 34}
for i in mcase:
    print(i)

[i for i in mcase]
print({key:key+1 for key in mcase})
print({key:mcase[key] for key in mcase})
print({mcase[key]:key for key in mcase})

mcase = {a: 10, b: 34, A: 7, Z: 3}
mcase_frequency = {k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase}
print(mcase_frequency)

 

以上是关于day 18 lambda表达式的主要内容,如果未能解决你的问题,请参考以下文章

Day03---集合,函数,三目运算,lambda表达式,内置函数,文件操作

18(番外)匿名方法+lambda表达式

IntelliJ:求值lambda表达式在调试时引发编译错误

Python全栈笔记04 [模块二] 18 Oct lambda表达式, 内置函数

day4之内置函数匿名函数,递归函数

使用 savedInstanceState 保存和恢复 Kotlin lambda