python - 在 Python 运行时，有没有办法区分文字字符串实例和动态创建的实例？

Question

在 Python 运行时，有没有办法区分文字字符串实例和动态创建的实例？

例如，我希望能够区分这两个值:

val1 = "Foo"
var2 = "%s" % "Foo"

此检查的一个示例用例是保护类似 string.Template 的函数免受任何攻击，例如暴露局部变量的值。

如果不可能，有什么好的理由吗？

---

还有一个旁注...

PEP 498 -- Literal String Interpolation引入了 f-strings，它是字符串文字，可以在标记化时拆分为文字和表达式。

F 字符串的工作方式与 string.Template() 非常相似，但强制输入是文字字符串，代价是语言的语法更新。

如果这种检查在运行时可用，则 f-strings 可以作为函数实现。

---

更新1

正如@kevin 在他的回答中指出的那样，CPython 进行了优化，允许它在不需要创建新实例时重用现有实例。在我的第一个示例中，"%s"% "Foo" 被跳过，只是链接到现有的 "Foo" 实例。

但这不是语言要求，事实上并不总是如此。除了一些明显的字符串格式外，任何字符串格式都会导致创建新实例。

在下面的示例中，您可以看到尽管字符串在值上相等，但它们不是同一个对象。使用sys.intern()不过，会给我们同样的例子。

In [1]: import dis
   ...: import sys
   ...:
   ...: def foo():
   ...:     var1 = "Foo Bar"
   ...:     var2 = "%s %s" % ("Foo", "Bar")
   ...:     print(f'plain eq: {var1 == var2}')
   ...:     print(f'plain is: {var1 is var2}')
   ...:     print(f'intern is: {sys.intern(var1) is sys.intern(var2)}')
   ...:
   ...: dis.dis(foo)
   ...: foo()
   ...:
  5           0 LOAD_CONST               1 ('Foo Bar')
              2 STORE_FAST               0 (var1)

  6           4 LOAD_CONST               9 ('Foo Bar')
              6 STORE_FAST               1 (var2)

  7           8 LOAD_GLOBAL              0 (print)
             10 LOAD_CONST               5 ('plain eq: ')
             12 LOAD_FAST                0 (var1)
             14 LOAD_FAST                1 (var2)
             16 COMPARE_OP               2 (==)
             18 FORMAT_VALUE             0
             20 BUILD_STRING             2
             22 CALL_FUNCTION            1
             24 POP_TOP

  8          26 LOAD_GLOBAL              0 (print)
             28 LOAD_CONST               6 ('plain is: ')
             30 LOAD_FAST                0 (var1)
             32 LOAD_FAST                1 (var2)
             34 COMPARE_OP               8 (is)
             36 FORMAT_VALUE             0
             38 BUILD_STRING             2
             40 CALL_FUNCTION            1
             42 POP_TOP

  9          44 LOAD_GLOBAL              0 (print)
             46 LOAD_CONST               7 ('intern is: ')
             48 LOAD_GLOBAL              1 (sys)
             50 LOAD_ATTR                2 (intern)
             52 LOAD_FAST                0 (var1)
             54 CALL_FUNCTION            1
             56 LOAD_GLOBAL              1 (sys)
             58 LOAD_ATTR                2 (intern)
             60 LOAD_FAST                1 (var2)
             62 CALL_FUNCTION            1
             64 COMPARE_OP               8 (is)
             66 FORMAT_VALUE             0
             68 BUILD_STRING             2
             70 CALL_FUNCTION            1
             72 POP_TOP
             74 LOAD_CONST               0 (None)
             76 RETURN_VALUE
plain eq: True
plain is: False
intern is: True

如 sys.intern() 中所述，“通常情况下，Python 程序中使用的名称是自动驻留的，用于保存模块、类或实例属性的字典具有驻留键。”换句话说，通常情况下，运行时字符串实例不会被保留。

Answer 1

不，你不能那样做。或者至少，您不能在运行时执行此操作。如果您愿意接受编译时分析的限制，您可以使用 ast 来解析和检查 Python 代码。 ，但这可能是一个比您正在寻找的工具复杂得多的工具，并且肯定不会允许您“将 f-strings 作为一个函数来实现。”

对于您示例的特定情况，Python 语言规范允许 var1 和 var2 都指向同一个对象(如果您同时传递这两个对象，它们肯定会指向同一个对象)它们通过 sys.intern() 函数并比较结果)。由于符合规范的 Python 实现可能会给它们起别名，因此没有可靠的方法来区分它们。事实上，当我在 CPython 3.6.1 中尝试时，它们被别名化了:

import dis

def foo():
    var1 = "Foo"
    var2 = "%s" % "Foo"
    return var1 is var2

dis.dis(foo)
print(foo())

输出:

  4           0 LOAD_CONST               1 ('Foo')
              2 STORE_FAST               0 (var1)

  5           4 LOAD_CONST               3 ('Foo')
              6 STORE_FAST               1 (var2)

  6           8 LOAD_FAST                0 (var1)
             10 LOAD_FAST                1 (var2)
             12 COMPARE_OP               8 (is)
             14 RETURN_VALUE
True

请注意，它甚至没有浪费时间计算 var2。它得到了constant-folded到字面值 'Foo' 中，然后与函数已经用于 var1 的另一个 'Foo' 进行重复数据删除。

(一个更积极的优化器可能会传播这些常量并将 var1 is var2 转换为 True，但 CPython 还没有这样做(还？)，可能是因为它很少将 is 用于像字符串这样的免疫值。大多数可能从常量传播中受益的其他操作都受制于各种 monkey patching ，这在绝大多数实际中阻止了这种优化-世界用例。因此，我认为它不值得实现。)

If it's not possible, is there any good reason for it?

因为 Python 和大多数命令式语言一样，使用 eager evaluation ，它会立即丢弃此信息。使用延迟评估的语言，这个问题至少是合理的，但我不相信他们中的大多数人也不会保留这些信息。在大多数处理字符串的编程语言中，字符串是文字还是非文字的问题根本不被视为字符串值的一部分。