python如何将字符串作为变量

一共三种方法：

[python] view plain copy

print?

1. >>> var = "This is a string"  
2. >>> varName = 'var'  
3. >>> s= locals()[varName]  
4. >>> s  
5. 'This is a string'  
6. >>> s2=vars()[varName]  
7. >>> s2  
8. 'This is a string'  
9. >>> s3=eval(varName)  
10. >>> s3  
11. 'This is a string'  

>>> var = "This is a string">>> varName = 'var'>>> s= locals()[varName]>>> s'This is a string'>>> s2=vars()[varName]>>> s2'This is a string'>>> s3=eval(varName)>>> s3'This is a string'

1. locals()

locals是Python的内置函数，他可以以字典的方式去访问局部和全局变量。

python里面用名字空间记录着变量，就像JavaScript的window一样，他记录着各种全局变量。

每个模块，每个函数都有自己的名字空间，记录着变量，常量，类的命名和值。

就像JS一样，当python在使用变量时，会按照下面的步骤去搜索：

• 函数或类的局部变量。
• 全局变量。
• 内置变量。

以上三个步骤，其中一步骤找到对应的变量，就不会再往下找。如果在这三个步骤都找不到，就会抛出异常。

locals与globals的区别

• locals()是只读的。globals()不是。这里说的只读，是值对于原有变量的只读。其实还可以对locals()赋值的。
• globals返回的是当前模块的全局变量 locals返回的是局部变量。注意，locals返回的是当前所在最小命名空间的局部变量的一个拷贝。

体检locals

[python] view plain copy

print?

1. list1 = [1,2,3]  
2. locals()  
3.   
4. # 在全局中使用locals，会打印出list1和__builtins__、__name__、__doc__、__package__  
5. 复制代码  
6. def foo(args):  
7.     x=1  
8.     print locals()  
9.   
10. foo(123)  
11.   
12. #将会得到 {'arg':123,'x':1}  

list1 = [1,2,3]locals()# 在全局中使用locals，会打印出list1和__builtins__、__name__、__doc__、__package__复制代码def foo(args):    x=1    print locals()foo(123)#将会得到 {'arg':123,'x':1}

2. vars()

本函数是实现返回对象object的属性和属性值的字典对象。如果默认不输入参数，就打印当前调用位置的属性和属性值，相当于locals()的功能。如果有参数输入，就只打印这个参数相应的属性和属性值。

[python] view plain copy

print?

1. #vars()    
2.     
3. print(vars())    
4.     
5. class Foo:    
6.     a = 1    
7. print(vars(Foo))    
8.     
9. foo = Foo()    
10. print(vars(foo))   

#vars()    print(vars())    class Foo:      a = 1  print(vars(Foo))    foo = Foo()  print(vars(foo)) 

3. eval()

eval()函数十分强大，官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。

结合math当成一个计算器很好用。

其他用法，可以把list,tuple,dict和string相互转化。见下例子：

[python] view plain copy

print?

1. a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"  
2. b = eval(a)  
3. b  
4. Out[3]: [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]  
5. type(b)  
6. Out[4]: list  
7. a = "{1: 'a', 2: 'b'}"  
8. b = eval(a)  
9. b  
10. Out[7]: {1: 'a', 2: 'b'}  
11. type(b)  
12. Out[8]: dict  
13. a = "([1,2], [3,4], [5,6], [7,8], (9,0))"  
14. b = eval(a)  
15. b  
16. Out[11]: ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))  

a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"b = eval(a)bOut[3]: [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]type(b)Out[4]: lista = "{1: 'a', 2: 'b'}"b = eval(a)bOut[7]: {1: 'a', 2: 'b'}type(b)Out[8]: dicta = "([1,2], [3,4], [5,6], [7,8], (9,0))"b = eval(a)bOut[11]: ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))

强大的函数有代价。安全性是其最大的缺点。

想一想这种使用环境：需要用户输入一个表达式，并求值。

如果用户恶意输入，例如：

__import__('os').system('dir')

那么eval()之后，你会发现，当前目录文件都会展现在用户前面。

那么继续输入：

open('文件名').read()

代码都给人看了。获取完毕，一条删除命令，文件消失。哭吧！

怎么避免安全问题？

(1) 自行写检查函数；

(2) 使用ast.literal_eval