Comment convertir des constantes de chaîne en variables en Python ? (avec des exemples)

Cet article vous explique comment convertir des constantes de chaîne en variables en Python ? (Avec des exemples), il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Cet article trie les points de contenu pertinents et l'étend à d'autres sujets d'apprentissage. J'espère qu'il vous sera utile.

1. Comment générer dynamiquement des noms de variables ?

La question de l'élève M est la suivante :

Excusez-moi, je veux poser une question Liste donnée = ['A', 'B', 'C', 'D'], comment puis-je Que diriez-vous d'obtenir une nouvelle liste A = [], B = [], C = [], D = [] nommée d'après les éléments de la liste ?

Pour comprendre simplement, la signification de ceci La question est d'utiliser le contenu de la chaîne comme noms de variables d'autres objets. Les éléments de la

liste sont des chaînes, où « A »-« D » sont des constantes, et dans le résultat requis, A-D sont des variables.

Si vous forcez une constante à être utilisée directement comme variable, elle signalera une erreur :

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

Le literal dans le rapport d'erreur fait référence à 字面量, qui est concept courant en informatique, est utilisé pour exprimer des valeurs fixes dans le code source. Par exemple, les types de base tels que les entiers, les nombres à virgule flottante et les chaînes sont des littéraux.

La quantité littérale fait référence à une quantité elle-même, qui peut être comprise comme une entité atomique et bien sûr ne peut pas se voir attribuer de valeur.

Par conséquent, le contenu de la chaîne récupéré ne peut pas être directement utilisé comme nom de variable et une autre méthode doit être trouvée.

Certains débutants peuvent se demander : est-ce que list[0] = [] est d'accord ? Bien sûr que non, car A n'apparaît pas. Qu'en est-il de A = list[0] puis de A = [] ? Cela ne fonctionnera pas, car A ici est défini par vous à partir de rien, et non généré à partir de conditions existantes.

A cette époque, seuls deux ou trois étudiants du groupe participaient à la discussion, et nous n'avons pas pensé à une solution. Cependant, je pense que ce sujet est très intéressant et mérite réflexion.

Parce que si ce problème peut être résolu, cela signifie que les noms de variables peuvent être générés dynamiquement au lieu d'être prédéfinis. Cela réduit non seulement la difficulté de nommer les variables, mais permet également un codage automatique !

Vous pouvez imaginer l'avenir. Lorsque l'intelligence artificielle écrit du code, si l'intelligence artificielle peut générer dynamiquement des noms de variables basés sur des conditions connues, le processus d'écriture de code ne serait-il pas beaucoup plus fluide ? (On dit que l'intelligence artificielle peut désormais écrire des codes. Je me demande quelle méthode elle utilise pour nommer les variables ?)

2 Il y a toujours des moyens

Récemment, quelques annonceurs se sont faufilés dans le domaine. Pour cette raison, j'ai décidé d'augmenter le seuil d'évaluation. Par exemple, j'ai utilisé des questions en groupe pour faire une évaluation.

Ce à quoi je ne m'attendais pas, c'est que le premier étudiant Q à être évalué presque sans réfléchir ait une idée pour résoudre le problème ci-dessus. Mais quelle coïncidence, presque au même moment, le camarade de classe J du groupe a proposé une autre solution (il n'a pas vu la discussion dans le groupe, mais a vu les enregistrements de Knowledge Planet et n'a appris que ce problème).

En d’autres termes, un problème que l’on pensait insoluble la veille a en réalité reçu deux solutions différentes le lendemain !

Alors, quelle est leur réponse ?

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

Cette méthode "définit" intelligemment de nouvelles variables en modifiant l'espace de noms global. La méthode globals() extrait un dictionnaire, la chaîne « A » est l'une des clés, et cette clé est exactement une variable dans l'espace de noms global, qui réalise la conversion des constantes en variables.

Au niveau de la structure des données, la liste vide [] est liée à sa valeur de clé de chaîne en tant que valeur, et au niveau de l'application, elle est liée au nom de la variable en tant que contenu de la variable.

Quand j'ai vu cette réponse, je me suis soudainement souvenu que le mois dernier j'avais réimprimé un article "Pièges de l'affectation dynamique en Python", qui parlait de Assignation dynamique de variables Le problème ! Il me semble que je me concentre uniquement sur la différence entre l'utilisation de globals() et de locals(), mais je ne saisis pas vraiment leurs utilisations originales.

Le camarade de classe J a dit qu'il avait appris cette méthode après avoir lu cet article. C'est intéressant, j'ai partagé une connaissance que j'avais avalée de tout mon cœur, puis elle a été absorbée et maîtrisée par mon camarade de classe J, et finalement les retours sont revenus pour résoudre mon problème.

Je ressens vraiment le charme du partage des connaissances : La connaissance prend vie dans le flux et brille dans la collision.

En même temps, je comprends aussi vraiment les avantages d'un groupe d'apprentissage qui se soutient mutuellement : Ceux qui profitent aux autres en profitent également à eux-mêmes, et ceux qui s'aident mutuellement progressent ensemble.

3. Méthode d'exécution dynamique du code

Q, un nouveau membre du groupe, a fourni une réponse différente :

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

Sa méthode d'écriture utilise la fonctionnalité f-strings introduite dans Python 3.6. En fait, elle peut également être implémentée dans les versions inférieures. Il suffit de s'assurer que le paramètre reçu par la méthode exec() est une chaîne contenant la variable i. , par exemple, écrivez comme ceci :

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

La différence entre ces méthodes d'écriture réside uniquement dans la différence dans les méthodes d'épissage de chaînes. Pour plus d'informations sur la façon d'épisser des chaînes et les différences entre les différentes méthodes, veuillez vous référer à ". Explication détaillée des chaînes d'épissage Python "" Sept façons ".

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() 的安全用法……

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!