如果要一个变量序列，请创建一个序列。而不是尝试创建自变量，例如：

variable0
variable1
variable2
variable3
@H_301_7@
您应该查看创建一个list。这类似于S.Lott的建议（S.Lott通常有很好的建议），但是更整洁地映射到您的for循环中：
sequence = []
for _ in xrange(10):
    sequence.append(function_that_returns_data())
@H_301_7@
（注意，我们放弃了循环变量（_）。我们只是试图获得10次传递。）
然后，您的数据将以以下形式提供：
sequence[0]
sequence[1]
sequence[2]
sequence[3]
[...]
sequence[9]
@H_301_7@
另外，您可以执行以下操作：
for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
      

          
解决方法
      

                    
       
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

       
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


       
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

       


        
vars（）[x] = y

       

       
创建一个新的[x：y]字典条目？

       
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

       
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

       
所以我的问题是（至少）两方面的：

       
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

       
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

       
3.这是否是好的编程习惯。

       
提前致谢！
                
      
      


      

       
      

      


      


       

        喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
       

       

         编程之家官方1群
       
       

         编程之家官方2群
       
       

         编程之家官方3群
       
       

         编程之家官方4群
       
      

      




      


       


        

        

        

       

       


        

        

        

       

      
 
      

sequence = []
for _ in xrange(10):
    sequence.append(function_that_returns_data())
@H_301_7@
（注意，我们放弃了循环变量（_）。我们只是试图获得10次传递。）
然后，您的数据将以以下形式提供：
sequence[0]
sequence[1]
sequence[2]
sequence[3]
[...]
sequence[9]
@H_301_7@
另外，您可以执行以下操作：
for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
     

          
解决方法
     

                    
      
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

      
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


      
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

      


       
vars（）[x] = y

      

      
创建一个新的[x：y]字典条目？

      
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

      
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

      
所以我的问题是（至少）两方面的：

      
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

      
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

      
3.这是否是好的编程习惯。

      
提前致谢！
                
     
     


     

      
     

     


     


      

       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      

        编程之家官方1群
      
      

        编程之家官方2群
      
      

        编程之家官方3群
      
      

        编程之家官方4群
      
     

     




     


      


       

       

       

      

      


       

       

       

      

     
 
      

sequence[0]
sequence[1]
sequence[2]
sequence[3]
[...]
sequence[9]
@H_301_7@
另外，您可以执行以下操作：
for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
    

          
解决方法
    

                    
     
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

     
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


     
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

     


      
vars（）[x] = y

     

     
创建一个新的[x：y]字典条目？

     
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

     
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

     
所以我的问题是（至少）两方面的：

     
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

     
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

     
3.这是否是好的编程习惯。

     
提前致谢！
                
    
    


    

     
    

    


    


     

      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     

       编程之家官方1群
     
     

       编程之家官方2群
     
     

       编程之家官方3群
     
     

       编程之家官方4群
     
    

    




    


     


      

      

      

     

     


      

      

      

     

    
 
      

for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
   

          
解决方法
   

                    
    
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

    
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


    
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

    


     
vars（）[x] = y

    

    
创建一个新的[x：y]字典条目？

    
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

    
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

    
所以我的问题是（至少）两方面的：

    
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

    
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

    
3.这是否是好的编程习惯。

    
提前致谢！
                
   
   


   

    
   

   


   


    

     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    

      编程之家官方1群
    
    

      编程之家官方2群
    
    

      编程之家官方3群
    
    

      编程之家官方4群
    
   

   




   


    


     

     

     

    

    


     

     

     

    

   
 
      

locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
  

          
解决方法
  

                    
   
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

   
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


   
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

   


    
vars（）[x] = y

   

   
创建一个新的[x：y]字典条目？

   
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

   
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

   
所以我的问题是（至少）两方面的：

   
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

   
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

   
3.这是否是好的编程习惯。

   
提前致谢！
                
  
  


  

   
  

  


  


   

    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   

     编程之家官方1群
   
   

     编程之家官方2群
   
   

     编程之家官方3群
   
   

     编程之家官方4群
   
  

  




  


   


    

    

    

   

   


    

    

    

   

  
 
      

>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
 

          
解决方法
 

                    
  
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

  
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


  
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

  


   
vars（）[x] = y

  

  
创建一个新的[x：y]字典条目？

  
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

  
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

  
所以我的问题是（至少）两方面的：

  
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

  
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

  
3.这是否是好的编程习惯。

  
提前致谢！
                
 
 


 

  
 

 


 


  

   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  

    编程之家官方1群
  
  

    编程之家官方2群
  
  

    编程之家官方3群
  
  

    编程之家官方4群
  
 

 




 


  


   

   

   

  

  


   

   

   

  

 
 
      

myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)

您应该查看创建一个list。这类似于S.Lott的建议（S.Lott通常有很好的建议），但是更整洁地映射到您的for循环中：

（注意，我们放弃了循环变量（_）。我们只是试图获得10次传递。）

然后，您的数据将以以下形式提供：

另外，您可以执行以下操作：

刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。

的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4] = 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。

请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。

我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

这将创建字典条目[result1：data1]，我可以使用myDict
[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

vars（）[x] = y

创建一个新的[x：y]字典条目？

我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

所以我的问题是（至少）两方面的：

1. vars（）或确切地说vars（）[x] = y到底是做什么的，

2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

3.这是否是好的编程习惯。

提前致谢！

您应该查看创建一个list。这类似于S.Lott的建议（S.Lott通常有很好的建议），但是更整洁地映射到您的for循环中：

sequence = []
for _ in xrange(10):
    sequence.append(function_that_returns_data())
@H_301_7@
（注意，我们放弃了循环变量（_）。我们只是试图获得10次传递。）
然后，您的数据将以以下形式提供：
sequence[0]
sequence[1]
sequence[2]
sequence[3]
[...]
sequence[9]
@H_301_7@
另外，您可以执行以下操作：
for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
     

          
解决方法
     

                    
      
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

      
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


      
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

      


       
vars（）[x] = y

      

      
创建一个新的[x：y]字典条目？

      
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

      
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

      
所以我的问题是（至少）两方面的：

      
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

      
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

      
3.这是否是好的编程习惯。

      
提前致谢！
                
     
     


     

      
     

     


     


      

       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      

        编程之家官方1群
      
      

        编程之家官方2群
      
      

        编程之家官方3群
      
      

        编程之家官方4群
      
     

     




     


      


       

       

       

      

      


       

       

       

      

     
 
      

sequence[0]
sequence[1]
sequence[2]
sequence[3]
[...]
sequence[9]
@H_301_7@
另外，您可以执行以下操作：
for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
    

          
解决方法
    

                    
     
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

     
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


     
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

     


      
vars（）[x] = y

     

     
创建一个新的[x：y]字典条目？

     
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

     
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

     
所以我的问题是（至少）两方面的：

     
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

     
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

     
3.这是否是好的编程习惯。

     
提前致谢！
                
    
    


    

     
    

    


    


     

      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     

       编程之家官方1群
     
     

       编程之家官方2群
     
     

       编程之家官方3群
     
     

       编程之家官方4群
     
    

    




    


     


      

      

      

     

     


      

      

      

     

    
 
      

for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
   

          
解决方法
   

                    
    
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

    
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


    
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

    


     
vars（）[x] = y

    

    
创建一个新的[x：y]字典条目？

    
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

    
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

    
所以我的问题是（至少）两方面的：

    
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

    
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

    
3.这是否是好的编程习惯。

    
提前致谢！
                
   
   


   

    
   

   


   


    

     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    

      编程之家官方1群
    
    

      编程之家官方2群
    
    

      编程之家官方3群
    
    

      编程之家官方4群
    
   

   




   


    


     

     

     

    

    


     

     

     

    

   
 
      

locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
  

          
解决方法
  

                    
   
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

   
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


   
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

   


    
vars（）[x] = y

   

   
创建一个新的[x：y]字典条目？

   
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

   
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

   
所以我的问题是（至少）两方面的：

   
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

   
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

   
3.这是否是好的编程习惯。

   
提前致谢！
                
  
  


  

   
  

  


  


   

    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   

     编程之家官方1群
   
   

     编程之家官方2群
   
   

     编程之家官方3群
   
   

     编程之家官方4群
   
  

  




  


   


    

    

    

   

   


    

    

    

   

  
 
      

>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
 

          
解决方法
 

                    
  
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

  
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


  
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

  


   
vars（）[x] = y

  

  
创建一个新的[x：y]字典条目？

  
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

  
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

  
所以我的问题是（至少）两方面的：

  
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

  
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

  
3.这是否是好的编程习惯。

  
提前致谢！
                
 
 


 

  
 

 


 


  

   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  

    编程之家官方1群
  
  

    编程之家官方2群
  
  

    编程之家官方3群
  
  

    编程之家官方4群
  
 

 




 


  


   

   

   

  

  


   

   

   

  

 
 
      

myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)

（注意，我们放弃了循环变量（_）。我们只是试图获得10次传递。）

然后，您的数据将以以下形式提供：

另外，您可以执行以下操作：

刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。

的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4] = 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。

请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。

我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

这将创建字典条目[result1：data1]，我可以使用myDict
[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

vars（）[x] = y

创建一个新的[x：y]字典条目？

我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

所以我的问题是（至少）两方面的：

1. vars（）或确切地说vars（）[x] = y到底是做什么的，

2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

3.这是否是好的编程习惯。

提前致谢！

（注意，我们放弃了循环变量（_）。我们只是试图获得10次传递。）

然后，您的数据将以以下形式提供：

sequence[0]
sequence[1]
sequence[2]
sequence[3]
[...]
sequence[9]
@H_301_7@
另外，您可以执行以下操作：
for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
    

          
解决方法
    

                    
     
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

     
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


     
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

     


      
vars（）[x] = y

     

     
创建一个新的[x：y]字典条目？

     
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

     
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

     
所以我的问题是（至少）两方面的：

     
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

     
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

     
3.这是否是好的编程习惯。

     
提前致谢！
                
    
    


    

     
    

    


    


     

      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     

       编程之家官方1群
     
     

       编程之家官方2群
     
     

       编程之家官方3群
     
     

       编程之家官方4群
     
    

    




    


     


      

      

      

     

     


      

      

      

     

    
 
      

for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
   

          
解决方法
   

                    
    
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

    
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


    
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

    


     
vars（）[x] = y

    

    
创建一个新的[x：y]字典条目？

    
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

    
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

    
所以我的问题是（至少）两方面的：

    
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

    
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

    
3.这是否是好的编程习惯。

    
提前致谢！
                
   
   


   

    
   

   


   


    

     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    

      编程之家官方1群
    
    

      编程之家官方2群
    
    

      编程之家官方3群
    
    

      编程之家官方4群
    
   

   




   


    


     

     

     

    

    


     

     

     

    

   
 
      

locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
  

          
解决方法
  

                    
   
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

   
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


   
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

   


    
vars（）[x] = y

   

   
创建一个新的[x：y]字典条目？

   
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

   
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

   
所以我的问题是（至少）两方面的：

   
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

   
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

   
3.这是否是好的编程习惯。

   
提前致谢！
                
  
  


  

   
  

  


  


   

    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   

     编程之家官方1群
   
   

     编程之家官方2群
   
   

     编程之家官方3群
   
   

     编程之家官方4群
   
  

  




  


   


    

    

    

   

   


    

    

    

   

  
 
      

>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
 

          
解决方法
 

                    
  
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

  
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


  
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

  


   
vars（）[x] = y

  

  
创建一个新的[x：y]字典条目？

  
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

  
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

  
所以我的问题是（至少）两方面的：

  
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

  
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

  
3.这是否是好的编程习惯。

  
提前致谢！
                
 
 


 

  
 

 


 


  

   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  

    编程之家官方1群
  
  

    编程之家官方2群
  
  

    编程之家官方3群
  
  

    编程之家官方4群
  
 

 




 


  


   

   

   

  

  


   

   

   

  

 
 
      

myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)

另外，您可以执行以下操作：

刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。

的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4] = 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。

请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。

我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

这将创建字典条目[result1：data1]，我可以使用myDict
[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

vars（）[x] = y

创建一个新的[x：y]字典条目？

我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

所以我的问题是（至少）两方面的：

1. vars（）或确切地说vars（）[x] = y到底是做什么的，

2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

3.这是否是好的编程习惯。

提前致谢！

另外，您可以执行以下操作：

for datum in sequence:
    process_data(datum)
@H_301_7@
刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。
locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
   

          
解决方法
   

                    
    
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

    
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


    
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

    


     
vars（）[x] = y

    

    
创建一个新的[x：y]字典条目？

    
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

    
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

    
所以我的问题是（至少）两方面的：

    
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

    
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

    
3.这是否是好的编程习惯。

    
提前致谢！
                
   
   


   

    
   

   


   


    

     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    

      编程之家官方1群
    
    

      编程之家官方2群
    
    

      编程之家官方3群
    
    

      编程之家官方4群
    
   

   




   


    


     

     

     

    

    


     

     

     

    

   
 
      

locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
  

          
解决方法
  

                    
   
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

   
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


   
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

   


    
vars（）[x] = y

   

   
创建一个新的[x：y]字典条目？

   
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

   
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

   
所以我的问题是（至少）两方面的：

   
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

   
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

   
3.这是否是好的编程习惯。

   
提前致谢！
                
  
  


  

   
  

  


  


   

    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   

     编程之家官方1群
   
   

     编程之家官方2群
   
   

     编程之家官方3群
   
   

     编程之家官方4群
   
  

  




  


   


    

    

    

   

   


    

    

    

   

  
 
      

>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
 

          
解决方法
 

                    
  
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

  
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


  
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

  


   
vars（）[x] = y

  

  
创建一个新的[x：y]字典条目？

  
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

  
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

  
所以我的问题是（至少）两方面的：

  
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

  
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

  
3.这是否是好的编程习惯。

  
提前致谢！
                
 
 


 

  
 

 


 


  

   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  

    编程之家官方1群
  
  

    编程之家官方2群
  
  

    编程之家官方3群
  
  

    编程之家官方4群
  
 

 




 


  


   

   

   

  

  


   

   

   

  

 
 
      

myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)

刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。

的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4] = 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。

请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。

我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

这将创建字典条目[result1：data1]，我可以使用myDict
[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

vars（）[x] = y

创建一个新的[x：y]字典条目？

我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

所以我的问题是（至少）两方面的：

1. vars（）或确切地说vars（）[x] = y到底是做什么的，

2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

3.这是否是好的编程习惯。

提前致谢！

刚开始，您可能会抽搐，使序列从0开始。您可以经过各种曲折，使实际数据从1开始，但这比它的价值还要痛苦。我建议您习惯使用从零开始的列表。一切都围绕着他们建立，他们很快就开始感觉自然。

现在，回答您问题的另一部分。 vars()（或locals()）提供对python创建的变量的低级访问。因此，以下两行是等效的。

locals()['x'] = 4
x = 4
@H_301_7@
的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4]
= 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。
>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
  

          
解决方法
  

                    
   
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

   
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


   
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

   


    
vars（）[x] = y

   

   
创建一个新的[x：y]字典条目？

   
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

   
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

   
所以我的问题是（至少）两方面的：

   
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

   
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

   
3.这是否是好的编程习惯。

   
提前致谢！
                
  
  


  

   
  

  


  


   

    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   

     编程之家官方1群
   
   

     编程之家官方2群
   
   

     编程之家官方3群
   
   

     编程之家官方4群
   
  

  




  


   


    

    

    

   

   


    

    

    

   

  
 
      

>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
 

          
解决方法
 

                    
  
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

  
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


  
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

  


   
vars（）[x] = y

  

  
创建一个新的[x：y]字典条目？

  
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

  
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

  
所以我的问题是（至少）两方面的：

  
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

  
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

  
3.这是否是好的编程习惯。

  
提前致谢！
                
 
 


 

  
 

 


 


  

   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  

    编程之家官方1群
  
  

    编程之家官方2群
  
  

    编程之家官方3群
  
  

    编程之家官方4群
  
 

 




 


  


   

   

   

  

  


   

   

   

  

 
 
      

myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)

的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4] = 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。

请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。

我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

这将创建字典条目[result1：data1]，我可以使用myDict
[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

vars（）[x] = y

创建一个新的[x：y]字典条目？

我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

所以我的问题是（至少）两方面的：

1. vars（）或确切地说vars（）[x] = y到底是做什么的，

2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

3.这是否是好的编程习惯。

提前致谢！

的范围与的范围vars()['x']完全相同x。locals()（或vars()）的一个问题是，它将使您将东西放到通常无法通过名称空间移出的名称空间中。因此，您可以执行以下操作：locals()[4] = 'An integer'，但是您必须再次使用locals才能将其删除，因为local名称空间（与所有python名称空间一样）仅用于保存字符串。

>>> x = 5
>>> dir()
['__builtins__', '__doc__', '__name__', 'x']
>>> locals()[4] = 'An integer'
>>> dir()
[4, '__builtins__', '__doc__', '__name__', 'x']
>>> x
5
>>> 4
4
>>> locals()[4]
'An integer'
@H_301_7@
请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。
 

          
解决方法
 

                    
  
我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

  
myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)


  
这将创建字典条目[result1：data1]，我可以使用myDict

[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

  


   
vars（）[x] = y

  

  
创建一个新的[x：y]字典条目？

  
我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

  
我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

  
所以我的问题是（至少）两方面的：

  
1. vars（）或确切地说vars（）[x] = y到底是做什么的，

  
2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

  
3.这是否是好的编程习惯。

  
提前致谢！
                
 
 


 

  
 

 


 


  

   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  

    编程之家官方1群
  
  

    编程之家官方2群
  
  

    编程之家官方3群
  
  

    编程之家官方4群
  
 

 




 


  


   

   

   

  

  


   

   

   

  

 
 
      

myDict = {}
for i in range (1,10):
    temp = "variable"+str(i) 
    vars()[temp] = myFunctionThatReturnsData() # variable1= data1,variable2 = data2,etc.
    myDict[temp] = vars(temp)

请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。

我发现能够在运行时创建新变量并创建结果字典以供以后处理（即写入文件）非常有用。

这将创建字典条目[result1：data1]，我可以使用myDict
[result1]对其进行调用。我一直在使用vars（）而不真正了解我在做什么。我认为它vars()返回带有局部变量（？）的字典，并且

vars（）[x] = y

创建一个新的[x：y]字典条目？

我有一个脚本，其中传递了一个用{input1：data1，input2：data2}准备的字典，并使用此方法遍历所有值，存储所有结果并将其输出到文件。这部分代码在类的函数内，并且可以正常工作。

我感到困惑的是，我读过各种文章，这些文章不应该弄乱locals（），以及vars（）如何等效于locals（）或globals（）。

所以我的问题是（至少）两方面的：

1. vars（）或确切地说vars（）[x] = y到底是做什么的，

2，这本词典的范围是什么（在编写更大的程序时我需要记住的是

3.这是否是好的编程习惯。

提前致谢！

请注意，4不会返回与locals（）[4]相同的东西。这可能会导致一些意外的，难以调试的问题。这是避免使用的原因之一locals()。另一个是，做python提供了更简单，更不易出错的方式（例如创建变量序列），这通常会很复杂。