Why don't you just construct a dictionary using the strings as keys?

>>> class test():
    def handy(self):
        a = raw_input('How many hands? ')
        d = { "hand" + str(i + 1) : self.do_something(i) for i in range(int(a)) }

        keys = d.keys()
        keys.sort()
        for x in keys:
            print x, '=', d[x]

    def do_something(self, i):
        return "something " + str(i)

>>> test().handy()
How many hands? 4
hand1 = something 0
hand2 = something 1
hand3 = something 2
hand4 = something 3

Edit: You updated the question to ask if you can store a dictionary as a value in a dictionary. Yes, you can:

>>> d = { i : { j : str(i) + str(j) for j in range(5) } for i in range(5) }
>>> d[1][2]
'12'
>>> d[4][1]
'41'
>>> d[2]
{0: '20', 1: '21', 2: '22', 3: '23', 4: '24'}
>> d[5] = { 1 : '51' }
>> d[5][1]
'51'

Use dictionaries

rows = [[1,2,3],[1,2,3],[1,2,3]]
dict_rows = {}

for idx, i in enumerate(rows):
   dict_rows[f'a{idx}'] = i

The output of this little script is: {'a0': [1, 2, 3], 'a1': [1, 2, 3], 'a2': [1, 2, 3]}

Dictionaries are iterable via keys.

Note: maybe next time try to give some more info on the script. Otherwise, it's a bit difficult to understand the question. I've supposed you have a list of lists and you want to "give them a name". If not, let me know

Edit To create a dataframe from a table instead you can do

import pandas as pd

rows = [...] # or you can obtain from a sting with file.striplines()
d = {}
for line in rows:
    for idx, data in enumerate(line.split()):
        if f'a{idx}' not in d: 
            d[f'a{idx}'] = []
        d[f'a{idx}'].append(data)
df = pd.DataFrame.from_dict(d)

This is a bad idea. You should not dynamically create variable names, use a dictionary instead:

Copyvariables = {}
for name, colour, shape in Applist:
    variables[name + "_n"] = name
    variables[name + "_c"] = colour
    variables[name + "_s"] = shape

Now access them as variables["Apple_n"], etc.

What you really want though, is perhaps a dict of dicts:

Copyvariables = {}
for name, colour, shape in Applist:
    variables[name] = {"name": name, "colour": colour, "shape": shape}

print "Apple shape: " + variables["Apple"]["shape"]

Or, perhaps even better, a namedtuple:

Copyfrom collections import namedtuple

variables = {}
Fruit = namedtuple("Fruit", ["name", "colour", "shape"])
for args in Applist:
    fruit = Fruit(*args)
    variables[fruit.name] = fruit

print "Apple shape: " + variables["Apple"].shape

You can't change the variables of each Fruit if you use a namedtuple though (i.e. no setting variables["Apple"].colour to "green"), so it is perhaps not a good solution, depending on the intended usage. If you like the namedtuple solution but want to change the variables, you can make it a full-blown Fruit class instead, which can be used as a drop-in replacement for the namedtuple Fruit in the above code.

Copyclass Fruit(object):
    def __init__(self, name, colour, shape):
        self.name = name
        self.colour = colour
        self.shape = shape

why wouldn't you do a dictionary of lists?

y = {}
for a in range (0,16777216):
    y[a] = []

also for brevity: https://stackoverflow.com/a/1747827/884453

y = {a : [] for a in range(0,16777216)}

Use a dict.

mylists = {}

x = 'abhishek'
mylists[x] = []

That way, in mylists you'll have all your lists. mylists[x] is the list with name x.

I think dictionaries are more suitable for this purpose:

>>> name = ['mike', 'john', 'steve']   

>>> age = [20, 32, 19] 

>>> dic=dict(zip(name, age))

>>> dic['mike']
20
>>> dic['john']
32

But if you still want to create variables on the fly you can use globals()[]:

>>> for x,y in zip(name, age):
    globals()[x] = y


>>> mike
20
>>> steve
19
>>> john
32

Use a list comprehension:

[[] for n in range(N)]

or a simple for loop

empt_lists = []
for n in range(N):
    empt_lists.append([])

Note that [[]]*N does NOT work, it will use the same pointer for all the items!!!

This code can help you:

user_contract = ['ZNZ6','TNZ6','ZBZ6']
data = [[1,2,3],[4,5,6],[7,8,9]]
dictionary = dict(zip(user_contract, data))
print(dictionary)

It creates a dictionary from the two lists and prints it:

python3 pyprog.py 
{'ZBZ6': [7, 8, 9], 'ZNZ6': [1, 2, 3], 'TNZ6': [4, 5, 6]}

Forget filtering locals()! The dictionary you give to the formatting string is allowed to contain unused keys:

>>> name = 'foo'
>>> zip = 123
>>> unused = 'whoops!'
>>> locals()
{'name': 'foo', 'zip': 123, ... 'unused': 'whoops!', ...}
>>> '%(name)s %(zip)i' % locals()
'foo 123'

With the new f-string feature in Python 3.6, using locals() is no longer necessary:

>>> name = 'foo'
>>> zip = 123
>>> unused = 'whoops!'
>>> f'{zip: >5} {name.upper()}'
'  123 FOO'

You could use a dictionary like this:

character = {'Name': 'Mary', 'xPos': 0, 'yPos': 0}
character['xPos'] = 10

You can do it with a dictionary:

mylist = ["a", "b", "c", "d"]

mydict = {}

for item in mylist:
    mydict[item] = input("What do you want " + str(item) + " to be defined as?")

More about dictionaries you can read here: https://docs.python.org/3.7/tutorial/datastructures.html#dictionaries

Use dict instead of globals

Use of global variables is not recommended practice. Much cleaner and easily maintainable is a dictionary of dictionaries. For example, using a dictionary comprehension:

fruits_lst = ['apples', 'oranges', 'bananas', 'guavas']

d = {fruit: {} for fruit in fruits_lst}

Then access a particular inner dictionary via d['apples'], d['oranges'], etc.

See this answer for an explanation why this is useful, and here for another example.