How to convert string constants into variables in Python? (with examples)

This article brings you how to convert string constants into variables in Python? (With examples), it has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

This article sorts out the relevant content points and extends it to further learning topics. I hope it will be helpful to you.

1. How to dynamically generate variable names?

M students’ questions are as follows:

Excuse me, I would like to ask a question. Given list = ['A', 'B', 'C', 'D'], how can I do this? How about getting a new list A = [], B = [], C = [], D = [] named after the elements in the list?

To simply understand, the meaning of this question is to use the string content as Variable names of other objects.

The elements in list are strings, ‘A’-‘D’ here are constants, and in the required result, A-D are variables.

If you force a constant to be used directly as a variable, it will report an error:

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

literal in the error refers to literal, which is A common concept in computer science, is used to express fixed values ​​in source code. For example, basic types such as integers, floating point numbers, and strings are literals.

Literal refers to a quantity itself, which can be understood as an atomic entity. Of course, it cannot be assigned a value.

So, the retrieved string content cannot be directly used as a variable name, and another method needs to be found.

Some beginners may wonder, is list[0] = [] okay? Of course not, because A doesn't appear. What about A = list[0] and then A = []? That won't work, because A here is defined by you out of thin air, not generated from existing conditions.

At that time, only two or three students in the group participated in the discussion, and we did not think of a solution. However, I think this topic is very interesting and worth pondering.

Because, if this problem can be solved, it means that variable names can be dynamically generated instead of predefined. This not only reduces the trouble of naming variables, but also enables automatic coding!

You can imagine the future. When artificial intelligence is writing code, if it can dynamically generate variable names based on known conditions, wouldn’t the process of writing code be much smoother? (It is said that artificial intelligence can now write codes. I wonder what method it uses when naming variables?)

2. There are always ways

Recently, learning A few advertisers sneaked into the group. For this reason, I decided to raise the review threshold. For example, I used questions in the group to make an assessment.

What I never expected was that the first student Q to be assessed almost without thinking came up with an idea to solve the above problem. But what a coincidence, almost at the same time, classmate J in the group came up with another solution (he didn't see the discussion in the group, but saw the records of Knowledge Planet, and only learned about this problem).

In other words, a problem that I thought was unsolvable the night before actually got two different solutions the next day!

So, what is their answer?

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

This method cleverly "defines" new variables by modifying the global namespace. The globals() method takes out a dictionary, the string ‘A’ is one of the keys, and this key is exactly a variable in the global namespace, which realizes the conversion from constants to variables.

At the data structure level, the empty list [] is bound to its string key value as a value, and at the application level, it is bound to the variable name as the variable content. together.

When I saw this answer, I suddenly remembered that last month I reprinted an article "Traps of Python Dynamic Assignment", which was about Dynamic variable assignment The problem! I seem to only focus on the difference between globals() and locals() usage, but not really grasp their original uses.

J’s classmate said that he learned this method just after reading that article. This is interesting. I shared a piece of knowledge that I had swallowed wholeheartedly, and then it was absorbed and mastered by classmate J, and finally the feedback came back to solve my problem.

I truly feel the charm of knowledge sharing: Knowledge gains life in the flow and shines in the collision.

At the same time, I also truly understand the benefits of a mutually supportive learning group: Those who benefit others also benefit themselves, and those who help each other make progress together.

3. Method of dynamically executing code

Q, a new member of the group, provided a different answer:

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

him The writing method uses the f-strings feature introduced in Python 3.6. In fact, it can also be implemented in lower versions. You only need to ensure that the parameter received by the exec() method is a string containing the variable i, for example Write like this:

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

The difference between these writing methods is only the difference in string splicing methods. For information about how to splice strings and the differences between different methods, please refer to "Detailed explanation of seven ways to splice strings in Python" 》.

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

The above is the detailed content of How to convert string constants into variables in Python? (with examples). For more information, please follow other related articles on the PHP Chinese website!