Wie konvertiere ich String-Konstanten in Variablen in Python? (mit Beispielen)

In diesem Artikel erfahren Sie, wie Sie in Python Zeichenfolgenkonstanten in Variablen umwandeln. (Mit Beispielen) hat es einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen.

Dieser Artikel sortiert die relevanten Inhaltspunkte und erweitert sie auf weitere Lernthemen. Ich hoffe, dass er für Sie hilfreich sein wird.

1. Wie generiert man dynamisch Variablennamen?

Die Frage von M Student lautet wie folgt:

Entschuldigung, ich möchte eine Frage stellen = ['A', 'B', 'C', 'D'], Wie wäre es, wenn eine neue Liste A = [], B = [], C = [], D = [] nach den Elementen in der Liste benannt wird?

Um die Bedeutung dieser Frage einfach zu verstehen besteht darin, den String-Inhalt als Variablennamen anderer Objekte zu verwenden. Die Elemente in der

Liste sind Zeichenfolgen, wobei „A“-„D“ Konstanten und im erforderlichen Ergebnis A-D Variablen sind.

Wenn Sie die direkte Verwendung einer Konstante als Variable erzwingen, wird ein Fehler gemeldet:

>>> 'A' = []
...SyntaxError: can't assign to literal

Das literal im Fehlerbericht bezieht sich auf 字面量, was häufig vorkommt Konzept in der Informatik, Wird verwendet, um feste Werte im Quellcode auszudrücken. Beispielsweise sind Grundtypen wie Ganzzahlen, Gleitkommazahlen und Zeichenfolgen Literale.

Wörtliche Menge bezieht sich auf eine Größe selbst, die als atomare Einheit verstanden werden kann und der natürlich kein Wert zugewiesen werden kann.

Daher kann der abgerufene String-Inhalt nicht direkt als Variablenname verwendet werden und es muss eine andere Methode gefunden werden.

Einige Anfänger fragen sich vielleicht: Ist list[0] = [] in Ordnung? Natürlich nicht, denn A kommt nicht vor. Was ist mit A = list[0] und dann A = []? Das wird nicht funktionieren, denn A wird hier von Ihnen aus dem Nichts definiert und nicht aus bestehenden Bedingungen generiert.

Zu diesem Zeitpunkt beteiligten sich nur zwei oder drei Schüler der Gruppe an der Diskussion und wir dachten nicht an eine Lösung. Ich halte dieses Thema jedoch für sehr interessant und eine Überlegung wert.

Denn wenn dieses Problem gelöst werden kann, bedeutet dies, dass Variablennamen dynamisch generiert werden können, anstatt vordefiniert zu werden. Dies reduziert nicht nur den Aufwand bei der Benennung von Variablen, sondern ermöglicht auch eine automatische Codierung!

Sie können sich die Zukunft vorstellen, wenn künstliche Intelligenz Code schreibt. Wenn künstliche Intelligenz dynamisch Variablennamen basierend auf bekannten Bedingungen generieren kann, wäre der Prozess des Codeschreibens dann nicht viel reibungsloser? (Man sagt, dass künstliche Intelligenz mittlerweile Codes schreiben kann. Ich frage mich, welche Methode sie beim Benennen von Variablen verwendet?)

2. Es gibt immer Möglichkeiten

Vor kurzem haben sich ein paar Werbetreibende eingeschlichen Aus diesem Grund habe ich beschlossen, die Bewertungsschwelle anzuheben. Ich habe beispielsweise die Fragen in der Gruppe verwendet, um eine Bewertung vorzunehmen.

Was ich nie erwartet hätte, war, dass der erste Student Q, der fast ohne nachzudenken eine Idee zur Lösung des oben genannten Problems hatte. Aber was für ein Zufall, fast zur gleichen Zeit kam Klassenkamerad J in der Gruppe auf eine andere Lösung (er sah nicht die Diskussion in der Gruppe, sondern die Aufzeichnungen von Knowledge Planet und erfuhr nur von diesem Problem).

Mit anderen Worten: Ein Problem, das am Abend zuvor für unlösbar gehalten wurde, bekam am nächsten Tag tatsächlich zwei verschiedene Lösungen!

Also, was ist ihre Antwort?

# J 同学的解答
>>> list1 = ['A', 'B', 'C', 'D']
>>> for i in list1:
>>>     globals()[i] = []
>>> A
[]

Diese Methode „definiert“ auf clevere Weise neue Variablen, indem sie den globalen Namensraum ändert. Die Methode globals() entnimmt ein Wörterbuch, die Zeichenfolge „A“ ist einer der Schlüssel, und dieser Schlüssel ist genau eine Variable im globalen Namensraum, der die Konvertierung von Konstanten in Variablen realisiert.

Auf der Datenstrukturebene ist die leere Liste [] als Wert an ihren Zeichenfolgenschlüsselwert gebunden, und auf der Anwendungsebene ist sie als gemeinsamer Variableninhalt an den Variablennamen gebunden.

Als ich diese Antwort sah, fiel mir plötzlich ein, dass ich letzten Monat einen Artikel „Fallen der dynamischen Zuweisung in Python“ nachgedruckt hatte, in dem es um Dynamische Variablenzuweisung Das Problem ging! Ich habe mich anscheinend nur auf den Unterschied zwischen der Verwendung von globals() und locals() konzentriert, aber ihre ursprüngliche Verwendung nicht wirklich verstanden.

Klassenkamerad J sagte, dass er diese Methode gelernt habe, nachdem er diesen Artikel gelesen hatte. Das ist interessant. Ich teilte ein Stück Wissen mit, das ich voll und ganz geschluckt hatte, und dann wurde es von Klassenkamerad J aufgenommen und gemeistert, und schließlich kam das Feedback zurück, um mein Problem zu lösen.

Ich spüre wirklich den Charme des Wissensaustauschs: Wissen gewinnt im Fluss an Leben und erstrahlt im Zusammenstoß.

Gleichzeitig verstehe ich auch wirklich die Vorteile einer sich gegenseitig unterstützenden Lerngruppe: Wer anderen etwas nützt, kommt auch sich selbst zugute, und wer sich gegenseitig hilft, kommt gemeinsam voran.

3. Methode zur dynamischen Ausführung von Code

Q, ein neues Mitglied der Gruppe, gab eine andere Antwort:

# Q 同学的解答
>>> list1 = ['A', 'B', 'C', 'D']
>>> for i in list1:
>>>     exec(f"{i} = []")
>>> A
[]

Ihn Die Schreibmethode verwendet die in Python 3.6 eingeführte F-Strings-Funktion. Sie kann tatsächlich auch in niedrigeren Versionen implementiert werden. Sie müssen lediglich sicherstellen, dass der von der exec()-Methode empfangene Parameter eine Zeichenfolge ist, die die Variable i enthält Beispiel Schreiben Sie so:

# 以下代码可替换上例的第 4 行
exec(i + " = []")
# 或者：
exec("{} = []".format(i))
# 或者：
exec(' '.join([i, '= []']))

Der Unterschied zwischen diesen Schreibmethoden besteht nur in den Methoden zum Spleißen von Zeichenfolgen. Informationen zum Spleißen von Zeichenfolgen und zu den Unterschieden zwischen den verschiedenen Methoden finden Sie unter „Detaillierte Erläuterung der sieben Methoden“. um Strings in Python zu verbinden“ 》.

Q 同学这个答案的核心在于 exec() 方法，它是内置的，用途是执行储存在字符串或文件中的代码段。

它的基础用法如下：

>>> exec('x = 1 + 2')
>>> x
3

# 执行代码段
>>> s = """
>>> x = 10
>>> y = 20
>>> sum = x + y
>>> print(sum)
>>> """
>>> exec(s)
30

看完了 exec() 的用法，我们再回来看 Q 同学的答案。for-循环中取出来的 i 是字符串，而拼接后的字符串经过 exec() 的处理，就获得了动态编写代码的效果。

也就是说，因为字符串常量的内容被当做有效代码而执行了，其中的 'A'-'D' 元素，就取得了新的身份，变成了最终的 A-D 变量名。

这个方法看起来很简单啊，可是由于 exec() 方法太生僻了，直到 Q 同学提出，我们才醒悟过来。

注意：在 Python3 中，exec() 是个内置方法；而在 Python2 中，exec 是个语句（statement），另外有个 execfile() 方法，两者相合并，就成了 Python3 中的 exec() 方法。本文使用的是 Python3。

4、总结

抽象一下最初的问题，它实际问的是“如何将字符串内容作为其它对象的变量名”，更进一步地讲是——“如何将常量转化为变量 ”。

使用直接进行赋值的静态方法，行不通。

两位同学提出的方法都是间接的动态方法：一个是动态地进行变量赋值，通过修改命名空间而植入变量；一个是动态地执行代码，可以说是通过“走后门”的方式，安插了变量。

两种方法殊途同归，不管是白猫还是黑猫，它们都抓到了老鼠。

这两种方法已经给我们带来了很有价值的启发，同时，因为它们，群内小伙伴们更是发散地讨论一些相关联的话题，例如：S 同学提出了另一种修改命名空间中变量的写法、L 同学提到了 eval() 的意义、eval() 与 exec() 的区别、我查到了为什么要慎用 eval() 、C 与 H 同学提到了 eval() 的安全用法……

Das obige ist der detaillierte Inhalt vonWie konvertiere ich String-Konstanten in Variablen in Python? (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!