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)
时间: 2024-10-13 08:33:36

day 18 lambda表达式的相关文章

理解Lambda表达式和闭包

了解由函数指针到Lambda表达式的演化过程 Lambda表达式的这种简洁的语法并不是什么古老的秘法,因为它并不难以理解(难以理解的代码只有一个目的,那就是吓唬程序员) 1 #include "stdafx.h" 2 using namespace System; 3 4 typedef void(*FunctionPointer)(System::String ^str); 5 6 void HelloWorld(System::String ^str) 7 { 8 Console:

Lambda 表达式语法

本主题介绍 lambda 表达式的语法. 它演示提供 lambda 表达式的结构元素的示例,这些元素与示例. Lambda 表达式语法 lambda expression (items marked with the opt subscript are optional):' data-guid="7c06475b6c7e659231eab3f6a09da2c5">下面用于定义显示语法,ISO C++11 从标准,lambda 表达式 (项标记下标 选择 是可选的): lambd

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

lambda表达式 lambda表达式是函数的一种简化,如下面两种函数定义方法,实际上效果是一样的. 使用lambda表达式的函数,func2是函数名,lambda: 后面的123 即为返回值. 1 def func1(): 2 return 123 3 4 result1 = func1() 5 print(result1) 6 # 正常定义一个函数 => 123 7 8 9 func2 = lambda: 123 10 result2 = func2() 11 print(result2)

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

概念了解: 1.什么是匿名委托(匿名方法的简单介绍.为什么要用匿名方法) 2.匿名方法的[拉姆达表达式]方法定义 3.匿名方法的调用(匿名方法的参数传递.使用过程中需要注意什么) 什么是匿名方法? 匿名方法是C#2.0引入的一个新特性,它允许开发者声明自己的函数代码而无须使用委托函数. C#为委托提供一种机制,可以为委托定义匿名方法,匿名方法没有名称,编译器会定指定一个名称,匿名方法中不能使用跳转语句跳转到该匿名方法的外部,也不能跳转到该方法的内部.也不能在匿名方法外部使用的ref和out参数.

不一样的编码风格--Lambda表达式

Lambda表达式也是C#3.0中最重要的特性之一. 1.Lambda表达式的简介 Lambda表达式可以理解为一个匿名方法,它可以包含表达式和语句,并且用于创建委托或转换为表达式树.在使用Lambda表达式时,都会使用“=>”运算符,该运算符的左边是匿名方法的输入参数,右边则是表达式或语句块. 1.1 Lambda表达式的演变过程 其实Lambda表达式是匿名方法的投胎转世.下面以代码来鉴定: 1 C# 1.0 2 Func<string,int> delegatetest1=new

python中的lambda表达式与三元运算

1 >>> def add(x,y): #定义一个加法函数 2 return x+y #返回两个参数的相加的值 3 4 >>> z=f(3,4) 5 >>> print(z) 6 7 #调用加法函数返回7 7 >>> lambda x,y:x+y 8 <function <lambda> at 0x0000020F385B86A8> 9 #可以看到lambda是一个 function(函数)类对象 10 >

Java8新增的Lambda表达式

Lambda表达式支持将代码块作为方法参数,Lambda表达式允许使用更简单的代码来创建只有一个抽象方法的接口(这种接口被称为函数式接口)的实例. 5.8.1 Lambda 表达式入门 Command.java package code; public interface Command { // 接口里定义的process()方法用于封装"处理行为" void process(int[] target); } ProcessArray.java package code; publi

SqlDataReader生成动态Lambda表达式

上一扁使用动态lambda表达式来将DataTable转换成实体,比直接用反射快了不少.主要是首行转换的时候动态生成了委托. 后面的转换都是直接调用委托,省去了多次用反射带来的性能损失. 今天在对SqlServer返回的流对象 SqlDataReader 进行处理,也采用动态生成Lambda表达式的方式转换实体. 先上一版代码 1 using System; 2 using System.Collections.Generic; 3 using System.Data; 4 using Syst

【转载】C++ function、bind和lambda表达式

本篇随笔为转载,原贴地址:C++ function.bind和lambda表达式. 本文是C++0x系列的第四篇,主要是内容是C++0x中新增的lambda表达式, function对象和bind机制.之所以把这三块放在一起讲,是因为这三块之间有着非常密切的关系,通过对比学习,加深对这部分内容的理解.在开始之间,首先要讲一个概念,closure(闭包),这个概念是理解lambda的基础.下面我们来看看wikipedia上对于计算机领域的closure的定义: A closure (also le