GVKun编程网logo

在python中使用lambda表达式在循环内部生成函数（python lambda 循环）

22

如果您对在python中使用lambda表达式在循环内部生成函数和pythonlambda循环感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解在python中使用lambda表达式在循环内部生成

如果您对在python中使用lambda表达式在循环内部生成函数和python lambda 循环感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解在python中使用lambda表达式在循环内部生成函数的各种细节，并对python lambda 循环进行深入的分析，此外还有关于python lambda表达式、Python Lambda表达式在人工智能中的应用：探索无限可能、python max函数使用'key'和lambda表达式、python — lambda表达式与内置函数的实用技巧。

本文目录一览：

在python中使用lambda表达式在循环内部生成函数（python lambda 循环）

在python中使用lambda表达式在循环内部生成函数（python lambda 循环）

如果我列出两个函数列表：

def makeFun(i):
    return lambda: i

a = [makeFun(i) for i in range(10)]
b = [lambda: i for i in range(10)]

为什么名单a，并b没有保存的行为方式？

例如：

>>> a[2]()
2
>>> b[2]()
9

python lambda表达式

python lambda表达式

最近在coding时发现使用lambda还是有诸多优点的，很多时候代码更整洁，更pythonic，所以在此简单总结一下

1.lambda是什么

举个简单的例子：

func = lambda x: x*x

def func(x):
    return x*x

两个func的定义是完全相同的，那两种函数定义方法配合map使用，将list中所有元素求平方，代码会是什么样的，

def func(x):
    return x*x
map(func, [i for i in range(10)])

map(lambda x: x*x, [i for i in range(10)])

对比之下，效果还是显而易见。首先func函数的功能十分简单，而且很有可能只使用这一次，所以说我们在这里定义了一个功能简单、使用频次不高的函数。在这个例子中，使用lambda创建匿名函数不但不会影响代码的可读性，还能精简代码，减少不必要的函数调用。其实这种场景很常见，我们需要一个简单的单行函数，做一件简单的事，我们甚至连函数的名字都无需在意，此时lambda就是我们不错的选择。

 

2.是否使用lambda

lambda定义了一个匿名函数，使用它并不会带来代码执行效率的提升。lambda通常与map，reduce，filter在遍历列表时配合使用，但是一味的追求lambda的使用，对代码可读性往往带来灾难性的后果。python对lambda有着严苛的约束，毕竟它只能由一条表达式组成。lambda很方便不假，但是如果使用过度，程序的逻辑性看起来就不那么清晰，毕竟每个人对抽象的理解是不同的。

如果一个列表生成式，仅使用for，if，in就能实现，我不会使用lambda

如果函数不足够简单，涉及到循环等复杂逻辑，我会定义函数，让代码更具可读性，此时我不会使用lambda

在我看来，lambda的存在是为了减少单行函数的定义，所以只用来代替单行函数的定义就足够了。

 

Python Lambda表达式在人工智能中的应用：探索无限可能

Python Lambda表达式在人工智能中的应用：探索无限可能

python lambda表达式在人工智能中的应用：探索无限可能

Lambda表达式是python中一种匿名函数，可以简化代码并提高效率。在人工智能领域，Lambda表达式可以用于各种任务，例如数据预处理、模型训练和预测等。

一、Lambda表达式的应用场景

  1. 数据预处理：Lambda表达式可以用于对数据进行预处理，例如归一化、标准化和特征提取等。
# 归一化数据
nORMalized_data = list(map(lambda x: (x - min(data)) / (max(data) - min(data)), data))

# 标准化数据
standardized_data = list(map(lambda x: (x - mean(data)) / std(data), data))

# 特征提取
features = list(map(lambda x: x[0], data))
登录后复制
  1. 模型训练：Lambda表达式可以用于训练机器学习模型。
# 训练决策树模型
model = DecisionTreeClassifier()
model.fit(X_train, y_train)

# 训练神经网络模型
model = Sequential()
model.add(Dense(128, activation="relu", input_dim=784))
model.add(Dense(10, activation="softmax"))
model.compile(loss="cateGorical_crossentropy", optimizer="adam", metrics=["accuracy"])
model.fit(X_train, y_train, epochs=10)
登录后复制
  1. 预测：Lambda表达式可以用于对数据进行预测。
# 对数据进行预测
predictions = model.predict(X_test)

# 计算准确率
accuracy = sum(predictions == y_test) / len(y_test)
登录后复制

二、Lambda表达式的优势

  1. 代码简化：使用Lambda表达式，可以简化代码并提高可读性。
# 使用Lambda表达式
result = list(map(lambda x: x**2, numbers))

# 不使用Lambda表达式
result = []
for number in numbers:
result.append(number**2)
登录后复制
  1. 提高效率：在某些情况下，使用Lambda表达式可以提高代码的执行效率。
# 使用Lambda表达式
result = list(filter(lambda x: x > 10, numbers))

# 不使用Lambda表达式
result = []
for number in numbers:
if number > 10:
result.append(number)
登录后复制

三、Lambda表达式的局限性

立即学习“Python免费学习笔记（深入）”；

  1. 代码可读性：在某些情况下，使用Lambda表达式可能会降低代码的可读性。
# 使用Lambda表达式
result = list(map(lambda x: x**2 + 2*x + 1, numbers))

# 不使用Lambda表达式
result = []
for number in numbers:
result.append(number**2 + 2*number + 1)
登录后复制
  1. 性能开销：在某些情况下，使用Lambda表达式可能会增加代码的性能开销。

结论：

Lambda表达式是一种强大的工具，可以简化代码并提高效率。在人工智能领域，Lambda表达式可以用于各种任务，例如数据预处理、模型训练和预测等。然而，在使用Lambda表达式时，也需要考虑代码的可读性和性能开销。

以上就是Python Lambda表达式在人工智能中的应用：探索无限可能的详细内容，更多请关注php中文网其它相关文章！

python max函数使用'key'和lambda表达式

python max函数使用'key'和lambda表达式

我来自 OOP 背景并尝试学习 python。我正在使用max使用 lambda
表达式的函数来返回列表中Player具有最大值的类型的实例。totalScore``players

def winner():    w = max(players, key=lambda p: p.totalScore)

Player该函数正确返回具有最大值的类型的实例totalScore。我对以下三件事感到困惑：

  1. 该功能如何max工作？它的论据是什么？我查看了文档，但未能理解。
  2. keymax函数中的关键字有什么用？我知道它也用于sort函数上下文
  3. lambda 表达式的含义？如何阅读它们？它们是如何工作的？

这些都是非常无聊的概念性问题，但会帮助我理解语言。如果你能举出例子来解释会有所帮助。谢谢

答案1

小编典典

lambda是一个匿名函数，它等价于：

def func(p):   return p.totalScore

现在max变成：

max(players, key=func)

但是由于def语句是复合语句，它们不能用于需要表达式的地方，这就是有时lambda使用 ‘s 的原因。

请注意，这lambda相当于您在 a 的 return 语句中放入的内容def。因此，您不能在 a 中使用语句lambda，只允许使用表达式。

做什么max？

max(a, b, c, …[, key=func]) -> 值

使用单个可迭代参数，返回其最大的项目。使用两个或更多参数，返回最大的参数。

因此，它只是返回最大的对象。

如何key工作？

默认情况下，在 Python
2中，基于对象类型的一组规则key比较项目（例如，字符串总是大于整数）。

要在比较之前修改对象，或根据特定属性/索引进行比较，您必须使用key参数。

示例 1：

一个简单的例子，假设你有一个字符串形式的数字列表，但是你想通过它们的整数值来比较这些项目。

>>> lis = [''1'', ''100'', ''111'', ''2'']

这里max使用它们的原始值比较项目（字符串是按字典顺序比较的，所以你会得到''2''输出）：

>>> max(lis)''2''

要通过它们的整数值比较项目，请使用key简单的lambda：

>>> max(lis, key=lambda x:int(x))  # compare `int` version of each item''111''

示例 2：应用于max元组列表。

>>> lis = [(1,''a''), (3,''c''), (4,''e''), (-1,''z'')]

默认情况下max，将按第一个索引比较项目。如果第一个索引相同，那么它将比较第二个索引。在我的示例中，所有项目都有一个唯一的第一个索引，所以你会得到这个答案：

>>> max(lis)(4, ''e'')

但是，如果您想通过索引 1 处的值比较每个项目怎么办？简单：使用lambda：

>>> max(lis, key = lambda x: x[1])(-1, ''z'')

比较包含不同类型对象的迭代中的项目 ：

包含混合项目的列表：

lis = [''1'',''100'',''111'',''2'', 2, 2.57]

在 Python 2
中，可以比较两种不同类型的项目：

>>> max(lis)  # works in Python 2''2''>>> max(lis, key=lambda x: int(x))  # compare integer version of each item''111''

但是在 Python 3
中你不能再这样做了：

>>> lis = [''1'', ''100'', ''111'', ''2'', 2, 2.57]>>> max(lis)Traceback (most recent call last):  File "<ipython-input-2-0ce0a02693e4>", line 1, in <module>    max(lis)TypeError: unorderable types: int() > str()

但这有效，因为我们正在比较每个对象的整数版本：

>>> max(lis, key=lambda x: int(x))  # or simply `max(lis, key=int)`''111''

python — lambda表达式与内置函数

python — lambda表达式与内置函数

目录

  • 1 lambda表达式 （匿名函数）
  • 2 内置函数

1 lambda表达式 （匿名函数）

用于表示简单的函数

lambda表达式，为了解决简单函数的情况：

def func(a1,a2):       =====> func = lambda a1,a2:a1+a2  # 函数直接得到返回值，这里隐藏了return
    return a1+a2       简化
# 三元运算，为了解决简单的if else的情况，如：
if 1 == 1:
    a = 123
else:
    a = 456

a =  123  if 1 == 1 else 456

# lambda表达式，为了解决简单函数的情况，如：
def func(a1,a2):
    return a1 + 100 

func = lambda a1,a2: a1+100
func1 = lambda : 100 

func2 = lambda x1: x1 * 10

func3 = lambda *args,**kwargs: len(args) + len(kwargs)

DATA = 100
func4 = lambda a1: a1 + DATA
v = func4(1)
print(v)

DATA = 100
def func():
    DATA = 1000
    func4 = lambda a1: a1 + DATA
    v = func4(1)
    print(v)
func()

func5 = lambda n1,n2: n1 if n1 > n2 else n2
v = func5(1111,2)
print(v)

lambda表达式只能用一行来表示函数，只能用参数来作为变量。

练习题

# 练习题1
USER_LIST = []
def func0(x):
    v = USER_LIST.append(x)
    return v 

result = func0('alex')
print(result)


# 练习题2

def func0(x):
    v = x.strip()
    return v 

result = func0(' alex ')
print(result)

############## 总结：列表所有方法基本上都是返回None；字符串的所有方法基本上都是返回新值 #################
# 练习题3
USER_LIST = []
func1 = lambda x: USER_LIST.append(x)

v1 = func1('alex')
print(v1)
print(USER_LIST)

# 练习题4
func1 = lambda x: x.split('l')

v1 = func1('alex')
print(v1)

# 练习题5
func_list = [lambda x:x.strip(),lambda y:y+199,lambda x,y:x+y]

v1 = func_list[0]('alex ')
print(v1)

v2 = func_list[1](100)
print(v2)

v3 = func_list[2](1,2)
print(v3)

总结：

列表所有方法基本上都是返回None，字符串的所有方法基本上都是返回新值。

2 内置函数

函数分为：自定义函数 和 内置函数

目前python的内置函数分为几大类：

  • 1.强制转换

    bool() / int() / str() / list() / dict() /tuple() / set()

  • 2.输入输出

    print() / input()

  • 3.其他

    len() / open() / id() / range() / type()

  • 4.数学相关

      1. abs() 绝对值

        v = abs(-1)
print(v)   # 1

      2. float() 转换成浮点型（小数）

        v = 55
v1 = float(v)
print(v1)    # 55.0

      3. max() 找到最大值

        v = [1,2,33,5,9]
result = max(v)
print(result)   # 33

      4. min() 找到最小值

        v = [1,311,11,8]
v2 = min(v)
print(v2)  # 1

      5. sum() 求和

        v = [1,9]
v1 = sum(v)
print(v1)  # 334

      6. divmod() 两数相除的商和余数

        a,b = divmod(1001,5)
print(a,b)   # 200  1

        补充：字符串格式化：‘你少妻-%s‘ %(i,) ------>后面%(i,)如果括号中只有一个变量，可以写成：‘你少妻-%s‘ %i

        # 练习题  请通过分页对数据进行展示
"""
要求：
    每页显示10条数据
    让用户输入要查看的页面：页码
"""

USER_LIST = []
for i in range(1,836):
    temp = {'name':'你少妻-%s' %i,'email':'123%[email protected]' %i }
    USER_LIST.append(temp)

# 数据总条数
total_count = len(USER_LIST)

# 每页显示10条
per_page_count= 10

# 总页码数
max_page_num,a = divmod(total_count,per_page_count)
if a>0:
    max_page_num += 1

while True:
    pager = int(input('要查看第几页：'))
    if pager < 1 or pager > max_page_num:
        print('页码不合法，必须是 1 ~ %s' %max_page_num )
    else:
        """
        # 第1页：USER_LIST[0:10] -> 0123456789
        # 第2页：USER_LIST[10:20]
        # 第3页：USER_LIST[20:30]
        ...
        """
        start = (pager-1) * per_page_count
        end = pager * per_page_count
        data = USER_LIST[start:end]
        for item in data:
            print(item)

      • 7.pow

        pow(x,y) 表示x的y次方

        v = pow(2,3)
print(v)   # 8

      • 8.round 保留小数点后几位小数，还会四舍五入。

        V = round(1.127,1/2)
print(v)   # 1.1 / 1.13

  • 5.进制转换相关

    • bin() 将十进制转换成二进制

      num = 13
v1 = bin(num)
print(v1)  # 0b1101

    • oct() 将十进制转换成八进制

      num = 8
v1 = oct(num)
print(v1)  # 0o10

    • int() 将其他的进制转换成十进制

      # 二进制转化成十进制
v1 = '0b1101'
result = int(v1,base=2)
print(result)  # 13

# 八进制转化成十进制
v1 = '0o1101'
result = int(v1,base=8)
print(result)

# 十六进制转化成十进制
v1 = '0x1101'
result = int(v1,base=16)
print(result)

    • hex() 将十进制转换成十六进制

      num = 16
v1 = hex(num)
print(v1)  # 0x10

      练习题

      # 1字节等于8位
# IP: 192.168.12.79  ->  001010010 . 001010010 . 001010010 . 001010010

# 1. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制并通过,连接起来生成一个新的字符串。
ip = "192.168.12.79"
ip_list = ip.split('.') # ['192','168','12','79']
result = []
for item in ip_list:
    result.append(bin(int(item)))
print(','.join(result))


# 2. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制: 
#          0010100100001010010001010010001010010 -> 十进制的值。

# 3232238671

ip = "192.168.12.79"
ip1 = ip.split('.')
lis = []
for i in ip1: 
    lis.append(bin(int(i)))
# val = ','.join(lis)
# b = val.replace('0b','')
# b1 = b.split(',')
b1 = ','.join(lis).replace('0b','').split(',')
e = []
#f or c in b1:
for c in ','):
    if len(c) < 8:
        val = 8 - len(c)
        d = list(c)
        d.insert(0,'0' * val)
        d1 = ''.join(d)
        e.append(d1)
    else:
        e.append(c)
f = ''.join(e)
f1 = int(f,base = 2 )
print(f1)

  • 6.编码相关

    • chr 将十进制数字转换成Unicode编码中的对应字符串

      v = chr(65)
print(v)   # A

    • ord 根据字符在Unicode编码中找到其对应的十进制

      v = ord('中')
print(v)    # 20013

    • 应用：

      import random

v = random.randint(65,90)
print(v)   # 随机获得65~90之间的数字


import random

data = []
for i in range(6)
    v = random.randint(65,90)
    data.append(chr(v))
print(''.join(data))   # 6位随机字符串验证码


import random

def get_random_code(length=6):
    data = []
    for i in range(length):
        v = random.randint(65,90)
        data.append(chr(v))

    return  ''.join(data)


code = get_random_code()
print(code)    # 6位随机字符串验证码
      import random # 导入一个模块 

v = random.randint(起始,终止) # 得到一个随机数

  • 7.高级一点的内置函数

    • map 循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。

      V1 = [11,22,44]
# map(x,v1) 第一个参数必须是函数，第二个参数必须是可迭代类型（可以被for循环的）
def func(arg):
    print(arg)
# map(func,v1)    # 执行后并不打印arg,这是py3的一个特性，py3现在还不执行以后会执行
result = map(func,v1)  # 然后将函数的返回值添加到一个[]中

# print(result)  py2会直接返回列表
# print(result)  py3不会，会得到一个对象/东西，想返回列表的话需要强制转换成列表

print(list(ruselt))  # result得到的是一个对象<map.objecta……>，需要list()才能打印列表
      v1 = [11,44]
result = map(lambda x:x+100,v1)
print(list(result)) # 特殊

    • filter

      result = filter(函数，参数)

      v1 = [11,'asd',44,'xf']

def func(x):
    if type(x) == int:
        return True
    return False
result = filter(func,v1) # [11,]
print(list(result))


result = filter(lambda x: True if type(x) == int else False,v1)
print(list(result))

result = filter(lambda x: type(x) == int,v1)
print(list(result))

    • reduce 累计得到一个结果

      reduce现在不在py3的内置函数种了 ，但py2的内置函数里包含。

      import functools
v1 = ['wo','hao','e']

def func(x,y):
    return x+y
result = functools.reduce(func,v1) 
print(result)

result = functools.reduce(lambda x,y:x+y,v1)
print(result)

  • 8.类相关的

      1. type，查看类型

        class Foo:
    pass

obj = Foo()

if type(obj) == Foo:
    print('obj是Foo类的对象')

      2. issubclass

        判断某个类是不是另一个类或其基类的子类。

        issubclass(类1，类2) 类1—>子类名，类2—>基类名

        class Base:
    pass

class Base1(Base):
    pass

class Foo(Base1):
    pass

class Bar:
    pass

print(issubclass(Bar,Base))
print(issubclass(Foo,Base))

      3. isinstance

        判断某个对象是否是某个类或其基类的实例（对象）

        class Base(object):
    pass

class Foo(Base):
    pass

obj = Foo()

print(isinstance(obj,Foo))  # 判断obj是否是Foo类或其基类的实例（对象）
print(isinstance(obj,Base)) # 判断obj是否是Foo类或其基类的实例（对象）

      4. super

        class Base(object):
    def func(self):
        print('base.func')
        return 123


class Foo(Base):
    def func(self):
        v1 = super().func()
        print('foo.func',v1)

obj = Foo()
obj.func()
# super().func() 去父类中找func方法并执行
        class Bar(object):
    def func(self):
        print('bar.func')
        return 123

class Base(Bar):
    pass

class Foo(Base):
    def func(self):
        v1 = super().func()
        print('foo.func',v1)

obj = Foo()
obj.func()
# super().func() 根据类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)
        class Base(object): # Base -> object
    def func(self):
        super().func()
        print('base.func')

class Bar(object):
    def func(self):
        print('bar.func')

class Foo(Base,Bar): # Foo -> Base -> Bar
    pass

obj = Foo()
obj.func()

# 多继承
# super().func() 根据self对象所属类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)

        super().要查找的方法

        super().func() 根据self对象所属类的继承关系（从左向右依次查找），按照顺序挨个找func方法并执行(找到第一个就不再找了)

        super 遵循mro顺序查找上一个类的

        supper().func()不是查找父类，而是根据mro顺序，找到自己对应的下一个类

今天关于在python中使用lambda表达式在循环内部生成函数和python lambda 循环的讲解已经结束，谢谢您的阅读，如果想了解更多关于python lambda表达式、Python Lambda表达式在人工智能中的应用：探索无限可能、python max函数使用'key'和lambda表达式、python — lambda表达式与内置函数的相关知识，请在本站搜索。

本文标签：

上一篇萨克斯-ExpatParser $ ParseException（萨克斯十大名曲播放）

下一篇Python：在Windows上启动新的命令提示符，然后等待其完成/退出（python启动windows程序）

相关文章