In Python, how to create a large number of variables in a loop?

Question

I'm looking for a way, in python 3.2, to create a large number of variables and assign them values. Something like

X = 10
Y = 10
A = 0
B = 0
while X >= 0:
    while Y >= 0:
        cell[C]X[A] = A
        cell[C]Y[B] = B
        B = B + 1
        Y = Y - 1
        C = C + 1
    A = A + 1
    X = X - 1

Which would optimally create 200 variables of cell1X1, cell1Y1, cell2X1, cell2Y2, etc etc etc.

Is this possible? How would it be done?

Please keep in mind that I'm still very new to python, so please make things as simple as possible.

Also, while I understand that there are other ways to do this, and they they are probably better, I still want to know how to do things this way.

I understand dictionaries might be better in every possible way, but that's not what I'm asking for.

Thanks for the help.

Edit: When I say new to python, I meant to say new to programming in general. Like very new. Like, just recently learned how to write functions.

Answer 1

Honestly, the only reasonable answer to this question is: Don't do that, and learn how to use dictionaries instead.

I believe this is also the most helpful answer as well. You have already stated in your question that (1) you are new to Python, (2) you are new to programming in general, and (3) you accept that dictionaries are possibly better in every way to what you are asking.

You say you are asking "for learning purposes". Well, the more productive approach is to learn a bit more of the language first, before insisting on a way to do something that you acknowledge is not encouraged by the language itself, and certainly not encouraged by anyone who is offering their comments and answers.

In this case, learn how dictionaries work. I think you will not find them that complicated. Even if you do, it will be worth your time and effort to really understand them anyway, because dictionaries are a very fundamental feature of Python. They are used all over the place in Python, and even if you don't stick with Python, many other languages use the same concept very heavily (though often using a different name, such as "associative array", "hash", "table", or perhaps other things).

After you are comfortable with dictionaries themselves, if you still can't figure out how to apply them to some specific programming problem, then maybe it will be time to ask another question.

Answer 2

Like everyone else is saying: don't do that. Unfortunately, there is no way for your program to have the names of variables themselves depend on variables (actually, there are ways to do this, but it's complicated and rarely the right way to do this).

It's probably important to point out that the reason you shouldn't do that is not merely that it's complicated in Python, but that wanting to do it that way indicates a fundamental misunderstanding of the distinction in most languages between code (including the names of things in the language) and data (the changeable values of things).

In this case, what you actually need are dictionaries, lists or something similar:

At least in your example, you've only got two sorts of things, which you call cell[C]X[A] and cell[C]Y[B]. You could just make these into cellX[A,B] and cellY[A,B] which are perfectly legal constructions in python.

So before the loop, do this, which initialises an empty dictionary.

cellX = {}
cellY = {}

then, inside the loop, you can have

 cellX[C,A]=A
 cellY[C,B]=B

Also note that your loop, as it is now, isn't very "pythonic". You should consider looping like for X in range(10,-1,-1):

Answer 3

It's dark and hacky, but you could try:

 for i in range(100):
     locals()['A%i'%i] = i

But please don't do this. It's usually terrible practice.

As @delnan points out, it probably won't work on some python versions and implementations. locals() is the local namespace, which is part of Python's implementation. You don't really want to play with it.

Another more important reason why you don't want to do this - it's a security and reliability nightmare. You can't see what all the variable names will be, so it's possible you will accidentally overwrite one of your other variables. You are getting all these "variables" from the same place, so it's logical to put them all together in a dictionary.

I'll explain why it works, at least in some cases: the local namespace is often implemented as a dictionary, and locals() will sometimes return the local namespace dictionary, not a copy.

Did that make no sense at all?

Python variables are like items in a dictionary. There's one namespace for the module, one for the function, one "global" namespace, and so on. locals() gets you the most local namespace, and globals() gets you the global namespace.

If the local namespace is actually implemented as a dictionary, you may be able edit it by editing locals() (reaching into the guts of the python interpreter). HOWEVER, sometimes the local namespace is not implemented as a dictionary (for performance reasons) - this happens inside functions. In that case, locals() will give you a copy of the namespace, and you will not be able to edit it (or at least, it won't change the local namespace).

Still confused? Don't do it.

Answer 4

Global scope is not something you want to create variables in, i can offer you couple of ways to create arrays instead:

There is a couple of ways you can take. one would be to multiply like so:

a = [1]*5

This will actually build you a list of references to the same array which is not what we need - good catch @Aaron Dufour

b = [[0]*5]*5

but here is a way that avoids creating references:

list(map(lambda x: [x]*6,[1]*5))

and so on. another way might be range in python 3 it returns itself so you can turn it into an array like so:

list(range(0,10))

another way might be writing an actual loop, if you need special values that are affected by the loop or something else you can write a lambda function inside a map call on an array.

A good start with python is this book: Dive into Python 3

Good luck!

edit: contaminating your global scope with variables is a bad practice - no matter what's the language, try to avoid it.