将字符串转换为Python中的变量名的方法

DebugUsery
603 阅读14分钟

在Python中编程时，有几种情况下我们可能需要将一个字符串转换为一个变量名。例如，考虑到我们需要接受一些用户数据作为输入，用户需要输入一些字段名和它们相应的值。我们将需要把字段名转换为变量，这样我们就可以给它们赋值。在这篇文章中，我们将讨论在Python中把输入字符串转换为变量名称的不同方法。

表的内容

  1. Python中的字符串和变量
  2. 如何在Python中访问变量名？
  3. 在Python中使用locals()方法将字符串转换为变量名
  4. 在Python中使用globals()方法将字符串转换为变量名
  5. 在Python中使用vars()函数将字符串转化为变量名
  6. 在Python中使用exec()函数将字符串转换为变量名
  7. 在Python中使用setattr()函数将字符串转换为变量名
  8. 总结

Python中的字符串和变量

python中的变量是对内存中一个对象的引用。我们在Python中使用变量来处理不同类型的值。当我们给一个Python变量赋值时，解释器会为这个值创建一个Python对象。之后，变量名称指的是内存位置。你可以在python中定义一个变量，如下面的python程序所示。

myVar = 5
print("The value in myVar is:", myVar)

输出。

The value in myVar is: 5

python字符串是一个包含在单引号或双引号中的字头。 我们也可以使用三引号来定义字符串。我们可以定义一个字符串值并将其赋值给一个字符串变量，如下面的例子所示。

myStr = "PythonForBeginners"
print("The value in myStr is:", myStr)

输出。

The value in myStr is: PythonForBeginners

在上面的例子中，我们已经创建了一个变量myStr 。然后，我们将字符串 "PythonForBeginners" 赋给了myStr 。

如何在Python中访问变量名？

我们可以使用globals() 函数和locals() 函数访问 python 中的变量名。

globals() 函数在执行时，会返回一个字典，其中包含所有作为字符串字面的变量名和它们相应的值。它是一个全局符号表，包含所有在程序全局范围内定义的名称。你可以在下面的python代码中观察到这一点。

myStr = "PythonForBeginners"
myNum = 5
print("The variables in global scope and their values are:")
myVars = globals()
print(myVars)

输出。

The variables in global scope and their values are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fe3bfa934c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myStr': 'PythonForBeginners', 'myNum': 5, 'myVars': {...}}

在上面的例子中，你可以观察到由globals() 函数返回的 dictionary 包含一些默认值以及我们定义的变量。

globals() 函数返回的 dictionary 只包含全局变量作为它的 key。当我们在一个函数或其他内部作用域内定义一个变量时，我们不能使用globals() 函数访问在该作用域内定义的变量。例如，请看下面的代码。

def myFun():
    funvar1 = "Aditya"
    funVar2 = 1117
    print("I am in myFun. The variables in myFun are:")
    print(funvar1, funVar2)


myStr = "PythonForBeginners"
myNum = 5
myFun()
print("The variables in global scope and their values are:")
myVars = globals()
print(myVars)

输出。

I am in myFun. The variables in myFun are:
Aditya 1117
The variables in global scope and their values are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f9d18bb24c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myFun': <function myFun at 0x7f9d18b6f280>, 'myStr': 'PythonForBeginners', 'myNum': 5, 'myVars': {...}}

Process finished with exit code 0

在上面的例子中，我们在函数myFun中定义了funvar1和funvar2。然而，这些变量并没有出现在全局符号表中。

即使我们在函数myFun 中执行globals() ，在myFun 中定义的变量也不会被包含在全局符号表中。你可以在下面的例子中观察到这一点。

def myFun():
    funvar1 = "Aditya"
    funVar2 = 1117
    print("I am in myFun. The variables in myFun are:")
    print(funvar1, funVar2)
    print("The variables in global scope and their values are:")
    myVars = globals()
    print(myVars)


myStr = "PythonForBeginners"
myNum = 5
myFun()

输出。

I am in myFun. The variables in myFun are:
Aditya 1117
The variables in global scope and their values are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7eff3f70d4c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myFun': <function myFun at 0x7eff3f6ca280>, 'myStr': 'PythonForBeginners', 'myNum': 5}

为了打印在一个函数内定义的变量名称，我们可以使用 locals() 函数。

locals() 函数，当在一个函数或其他内部范围内调用时，会返回一个字典，其中的变量名和它们的相关值作为键值对出现。

你可以使用 print 语句来打印这个字典，如下所示。

def myFun():
    funvar1 = "Aditya"
    funVar2 = 1117
    print("I am in myFun. The variables in myFun are:")
    print(funvar1, funVar2)
    print("The variables in local scope of myFun and their values are:")
    myVars = locals()
    print(myVars)


myStr = "PythonForBeginners"
myNum = 5
myFun()

输出。

I am in myFun. The variables in myFun are:
Aditya 1117
The variables in local scope of myFun and their values are:
{'funvar1': 'Aditya', 'funVar2': 1117}

在上面的例子中，你可以看到locals() 函数返回的 dictionary 包含在myFun 中定义的变量。

locals() 函数在全局范围内执行时，会打印出包含全局变量及其值的字典。你可以在下面的例子中观察到这一点。

def myFun():
    funvar1 = "Aditya"
    funVar2 = 1117
    print("I am in myFun. The variables in myFun are:")
    print(funvar1, funVar2)


myStr = "PythonForBeginners"
myNum = 5
myFun()
print("The variables in the global scope and their values are:")
myVars = locals()
print(myVars)

输出。

I am in myFun. The variables in myFun are:
Aditya 1117
The variables in the global scope and their values are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fd4fec2e4c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myFun': <function myFun at 0x7fd4febeb280>, 'myStr': 'PythonForBeginners', 'myNum': 5, 'myVars': {...}}

现在我们已经讨论了如何在python中访问变量名，现在让我们讨论如何在python中创建动态变量和定义动态变量名。为此，有多种方法，我们将逐一讨论。

使用locals()方法将字符串转换为Python中的变量名

正如我们在上一节中所看到的，Python解释器以字典的形式将变量名和它们的值存储在一个符号表中。如果我们在程序中给了一个字符串作为输入，我们可以通过将输入的字符串作为一个键加入到符号表中来定义一个带有字符串的变量名。我们可以将单个字符、数值或字符串作为变量的关联值。

为了将字符串转换为变量名，我们将按照以下步骤进行。

  • 首先，我们将使用locals() 函数获得包含符号表的字典。locals() 函数在执行时，会返回当前范围的符号表。
  • 一旦我们获得了符号表，我们将使用下标符号添加字符串名称作为键，变量的值作为相关的值。
  • 在将键值对添加到符号表后，变量就以给定的字符串名称和关联值被创建。

你可以用这个简单的例子来观察。

myStr = "domain"
print("The string is:",myStr)
myVars = locals()
myVars[myStr] = "pythonforbeginners.com"
print("The variables are:")
print(myVars)
print("{} is {}".format(myStr, domain))

输出。

The string is: domain
The variables are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f2fb9cb44c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myStr': 'domain', 'myVars': {...}, 'domain': 'pythonforbeginners.com'}
domain is pythonforbeginners.com

在上面的例子中，我们使用了下标符号来对符号表进行修改。你可以使用__setitem__() 方法，而不是使用下标符号来添加新的字符串值作为符号表的一个键。

__setitem__() 方法，当在一个python 字典上调用时，将一个字符串字面作为它的第一个参数，将与新变量名称相关的值作为第二个参数。执行后，字符串和值作为字典中的键值对被添加到字典中。

由于locals() 方法返回的符号表也是一个字典，我们可以使用__setitem__() 方法将字符串转换成 python 中的变量名，如下所示。

myStr = "domain"
print("The string is:", myStr)
myVars = locals()
myVars.__setitem__(myStr, "pythonforbeginners.com")
print("The variables are:")
print(myVars)
print("{} is {}".format(myStr, domain))

输出。

The string is: domain
The variables are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f77830734c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myStr': 'domain', 'myVars': {...}, 'domain': 'pythonforbeginners.com'}
domain is pythonforbeginners.com

上述使用locals() 方法的方法只在当前范围内进行修改，因此，当我们想在局部范围内（如函数）将字符串转换为变量名时，这种方法很有用。如果你只想改变一个函数的符号表，你可以使用locals() 函数在python中把一个字符串转换为变量名，如下图所示。

def myFun():
    myStr = "domain"
    print("The string is:", myStr)
    myVars = locals()
    myVars.__setitem__(myStr, "pythonforbeginners.com")
    print("The variables are:")
    print(myVars)


myFun()

输出。

The string is: domain
The variables are:
{'myStr': 'domain', 'domain': 'pythonforbeginners.com'}

如果你想对全局符号表进行修改，将一个python字符串转换成一个全局变量名，你可以在全局范围内执行locals() 函数。之后，你可以使用下标符号或__setitem__() 方法添加变量，如前面例子所示。

使用 globals() 方法将字符串转换成 Python 中的变量名

如果你想在一个函数内部将一个字符串转换为全局变量，你不能使用locals() 函数。对于这个任务，你可以使用globals() 函数。

当执行时，globals() 函数返回全局符号表。你可以在任何作用域内对全局符号表进行修改，将一个字符串转换为全局变量名。为此，我们将执行以下步骤。

  • 首先，我们将使用globals() 函数获得全局符号表。globals() 函数在执行时，将全局符号表作为一个字典返回。
  • 一旦我们获得了符号表，我们将使用字典的下标符号，将字符串名称作为一个键，将变量的值作为相关的值。
  • 在向符号表添加键值对后，变量就会以给定的字符串名称和关联值创建。

在执行上述步骤后，我们可以将一个字符串转换为一个全局变量。你可以在下面的例子中观察到这一点。

myStr = "domain"
print("The string is:",myStr)
myVars = globals()
myVars[myStr] = "pythonforbeginners.com"
print("The variables are:")
print(myVars)
print("{} is {}".format(myStr, domain))

输出。

The string is: domain
The variables are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7ff717bd34c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myStr': 'domain', 'myVars': {...}, 'domain': 'pythonforbeginners.com'}
domain is pythonforbeginners.com

不使用下标符号，你可以使用__setitem__() 方法和globals() 函数来将一个字符串转换为python中的全局变量名，如下图所示。

myStr = "domain"
print("The string is:", myStr)
myVars = globals()
myVars.__setitem__(myStr, "pythonforbeginners.com")
print("The variables are:")
print(myVars)
print("{} is {}".format(myStr, domain))

输出。

The string is: domain
The variables are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fc4c62ba4c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myStr': 'domain', 'myVars': {...}, 'domain': 'pythonforbeginners.com'}
domain is pythonforbeginners.com

在Python中使用vars()函数将字符串转化为变量名

除了使用locals() 和globals() 函数将字符串转换为python中的变量名之外，我们还可以使用 vars() 函数。vars() 函数，当在全局范围内执行时，其行为与globals() 函数相同。当在一个函数或内部作用域中执行时，vars() 函数的行为与locals() 函数相同。

为了在全局范围内使用vars() 函数将一个字符串转换成一个变量名，我们将使用以下步骤。

  • 使用vars() 函数，我们将获得包含全局作用域中的变量名的字典。
  • 在获得字典后，我们将使用字典的下标符号将字符串名称作为键添加到字典中，并将变量的值作为关联值。
  • 一旦我们将字符串和关联值添加到字典中，变量就在全局范围内被创建。

下面是执行上述步骤的示例代码，在python中把一个字符串转换成一个变量名。

myStr = "domain"
print("The string is:",myStr)
myVars = vars()
myVars[myStr] = "pythonforbeginners.com"
print("The variables are:")
print(myVars)
print("{} is {}".format(myStr, domain))

输出。

The string is: domain
The variables are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fb9c6d614c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myStr': 'domain', 'myVars': {...}, 'domain': 'pythonforbeginners.com'}
domain is pythonforbeginners.com

你也可以在 dictionary 上使用__setitem__() 方法，而不是用下标符号来创建变量，如下例所示。

myStr = "domain"
print("The string is:", myStr)
myVars = vars()
myVars.__setitem__(myStr, "pythonforbeginners.com")
print("The variables are:")
print(myVars)
print("{} is {}".format(myStr, domain))

输出。

The string is: domain
The variables are:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fb5e21444c0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/home/aditya1117/PycharmProjects/pythonProject/string12.py', '__cached__': None, 'myStr': 'domain', 'myVars': {...}, 'domain': 'pythonforbeginners.com'}
domain is pythonforbeginners.com

要使用vars() 函数将字符串转换为像函数一样的局部范围内的变量名，你可以执行我们使用locals() 函数创建全局变量的相同步骤。你可以在下面的例子中观察到这一点。

def myFun():
    myStr = "domain"
    print("The string is:", myStr)
    myVars = vars()
    myVars.__setitem__(myStr, "pythonforbeginners.com")
    print("The variables are:")
    print(myVars)


myFun()

输出。

The string is: domain
The variables are:
{'myStr': 'domain', 'domain': 'pythonforbeginners.com'}

在前面的章节中，我们直接改变了符号表，将一个字符串转换为一个变量名。然而，这并不是执行任务的最佳方式。

现在让我们讨论一下如何在不直接改变符号表的情况下将字符串转换成python中的变量名。

在Python中使用exec()函数将字符串转换为变量名

我们可以使用exec()函数来动态执行一个Python语句。exec()函数接收一个字符串形式的python语句作为输入参数。然后，该python语句被执行，就像它是写在代码中的一个正常的python语句。例如，我们可以使用exec() 函数定义一个变量x，其值为5，如下图所示。

myStr = "x=5"
exec(myStr)
print(x)

输出。

5

为了使用exec()函数将一个字符串转换成一个变量名，我们将使用字符串格式化。我们可以用以下步骤完成整个过程。

  • 首先，我们将定义一个变量myStr，其中包含我们需要转换为变量名的原始字符串。
  • 之后，我们将创建一个字符串myTemplate ，格式为"{} = "{}""。在这里，我们将使用第一个占位符来表示字符串的名称，第二个占位符表示我们将从字符串变量中创建的变量的值。
  • myTemplate 在用占位符创建字符串后，我们将调用format() 方法，将myStr 作为第一个输入参数，将从myStr 创建的变量的值作为第二个输入参数。
  • 一旦执行，format() 方法将返回一个字符串，该字符串看起来像一个python语句，myStr 作为变量名，给定的值被分配给该变量。
  • 在获得包含python语句的字符串后，我们将把它传递给exec() 函数。
  • 一旦exec() 函数被执行，将以字符串myStr 作为变量名来创建变量。

你可以在下面的例子中观察到这一点。

myStr = "domain"
myVal = "pythonforbeginners.com"
myTemplate = "{} = \"{}\""
statement = myTemplate.format(myStr, myVal)
exec(statement)
print(domain)

输出。

pythonforbeginners.com

在 Python 中使用 setattr() 函数将字符串转换为变量名

不使用 exec() 函数，我们也可以使用setattr() 函数在 python 中把一个字符串转换成一个变量名。

setattr() 函数将一个 python 对象作为它的第一个输入参数，将属性（变量）名称作为第二个输入参数，将属性的值作为第三个输入参数。执行后，它将属性添加到对象中。

为了使用setattr() 函数将字符串转换为变量名，我们首先需要获得作为 python 对象的当前作用域，以便我们可以将变量作为属性添加到其中。为此，我们将不得不执行两项任务。

  • 首先，我们需要获得当前程序中加载的模块的名称。
  • 之后，我们需要找到当前正在执行的模块，也就是当前的范围。

为了找到当前加载在内存中的模块的名称，我们将使用sys.modules 属性。sys.modules 属性包含一个字典，其中有模块名称与已经加载的模块的映射。

获得字典后，我们需要找到当前的模块。为此，我们将使用__name__ 属性。__name__ 是一个内置的属性，其值为当前模块的名称。

__name__ 属性也存在于符号表中。你可以使用__name__ 属性找到当前模块的名称，如下图所示。

print("The current module name is:")
print(__name__)

输出。

The current module name is:
__main__

在这里，你可以看到我们目前是在__main__ 模块中。

在使用__name__ 属性获得当前模块的名称后，我们将使用sys.modules 属性的下标符号获得当前模块对象。

在获得当前模块后，我们将使用setattr() 函数将字符串转换为变量名。为此，我们将把当前模块作为第一个输入参数，把字符串作为第二个输入参数，把变量的值作为第三个输入参数传递给setattr() 函数。执行 setattr() 函数后，变量将在当前范围内创建，输入的字符串为变量名。

你可以在下面的例子中观察到这一点。

import sys

myStr = "domain"
myVal = "pythonforbeginners.com"
moduleName = __name__
currModule = sys.modules[moduleName]
setattr(currModule, myStr,myVal)
print(domain)

输出。

pythonforbeginners.com

结论

在这篇文章中，我们讨论了在python中把字符串转换为变量名的不同方法。在本文讨论的所有方法中，我建议你使用 exec() 方法的方法。这是因为有几个保留的关键字，我们不能作为变量名使用。这些关键字用于运行程序的不同任务。然而，如果我们直接改变符号表，有可能会改变与某个关键字相关的值。在这种情况下，程序会遇到错误。因此，尝试使用与 exec() 函数的方法，在Python中把字符串转换 为变量名。

avatar
文章
阅读
粉丝