Python 中的三个不寻常的事情柯里化、海象和 Interning

off999 2025-05-23 19:19 27 浏览 0 评论

柯里化

柯里化是指不是一次性给函数所有参数，而是逐个给出。因此，每次都会创建一个新的函数。让我们看看 Python 中的快速手动实现


def add_curried(x):
  def inner(y):
    return x + y
  return inner

# Usage
add_five = add_curried(5)  # Now adds 5 to any number
result = add_five(3)  # result will be 8

所以，通过柯里化，你可以将一个函数转换为多个单参数函数。这对于代码重用和函数式编程很有用。实际上，将这一功能添加到 Python 语言的建议（PEP 309，已被拒绝）来自我们的函数式编程大师 Haskell。在 Haskell 和 ML 等语言中，函数应用的方式是这样的：

f x y z

实际上意味着：

(((f x) y) z)

所以，尽管这种实现被拒绝了，但仍然有方法可以在 Python 中实现它。你上面看到了手动实现，还有其他实现方法，包括使用 lambda 函数、装饰器和 functools.partial 函数。使用 partial 的相同示例看起来像：

from functools import partial

def add(x, y):
  return x + y

add_five = partial(add, 5) 
result = add_five(3)

这个功能的实际应用之一是日志记录，你可以创建一个函数，固定一些参数（级别），同时仍然允许动态输入（消息），而且还能自动添加时间戳。

但请记住，这并不是递归（是的，我首先想到了这个）。递归是函数直接或间接地调用自身。而柯里化则是创建一系列函数链。

海象运算符

海象操作符允许你在表达式中同时将值赋给一个属性。它之所以得名，是因为它的形状像海象的眼睛和獠牙 :=。开发者们没有幽默感吗？当你思考的时候，我们将探讨一些例子：

列表推导：half 在列表推导中被赋值！

numbers = [10, 20, 30, 5, 3, 25]
large_numbers = [(half, n) for n in numbers if (half := n / 2) > 10]
print(large_numbers)  # Output: [(15.0, 30), (12.5, 25)]

if/else： 避免冗余计算（在这种情况下是 len）。节省一行代码并保持代码整洁。

my_list = [1, 'hetero', 'list', 'of length', 5.0]

if (n:=len(my_list)) < 10:
    print(f'this works') #prints this works
    
print(f'I can still print the value of n = {n}')
#I can still print the value of n = 5

正如你所见，它在条件和推导中非常有用。你还可以在循环中读取输入，使代码更加简洁易读。虽然你可能想用它来减少代码行数并使表达式更简洁，但尽量不要过度使用。特别是在它降低了可读性，而常规赋值更好时。PEP 提案链接→ 这里

中间变量

在 Python 中，interning 是一种优化字符串字面量的技术。它不会保存多个相同的字符串字面量的副本，而是只保存一个副本。这有助于提高内存使用效率，并加快查找和比较的速度。让我们通过一些示例来了解一下。

import sys

s1 = 'Medium does not support basic HTML tables'
s2 = 'Medium does not support basic HTML tables'

print(s1 is s2) # false
print(id(s1))   # 139912277338320
print(id(s2))   # 140434884249808


s3 = sys.intern('Medium does not support basic HTML tables')
s4 = sys.intern('Medium does not support basic HTML tables')

print(s3 is s4) # true

sys.intern() 显式地进行字符串 interning。 s3 和 s4 使用 sys.intern 进行 interning，因此它们引用的是同一个对象。当你处理大量文本并需要节省内存时，这是一个很好的方法。

尝试了以下方法来明确地让字符串字面量不指向相同的对象，但它们总是指向同一个对象。因为 Python 在这些场景下会自动进行字符串内部化。

s1 = 'a really large text'
s2 = 'a really large text' + ''
s3 = s1[:]
s4 = str('a really large text')

，它不会对长字符串（超过800个字符）、动态创建的字符串、作用域/时间相似性（如在这里的相同脚本）进行内部化。但是，字典中的字符串键也是相同的对象，这使得查找操作更加容易。

sample_dict = {
    'name' : 'Harshit',
    'gender': 'M'
}

another_dict = {
    'name' : 'Novak',
    'gender': 'M'
}

print(hex(id(another_dict.keys()))) # 0x7fb4bce718b0
print(hex(id(sample_dict.keys())))  # 0x7fb4bce718b0

所以 Python 有很多隐藏的宝石。《 柯里化 》可以帮助你模块化函数，《海象》操作符可以使表达式更加简洁，《 内部化 》优化了内存的使用。