You could just iterate over the indices of the range of the len of your list:

dataList = [{'a': 1}, {'b': 3}, {'c': 5}]
for index in range(len(dataList)):
    for key in dataList[index]:
        print(dataList[index][key])

or you could use a while loop with an index counter:

dataList = [{'a': 1}, {'b': 3}, {'c': 5}]
index = 0
while index < len(dataList):
    for key in dataList[index]:
        print(dataList[index][key])
    index += 1

you could even just iterate over the elements in the list directly:

dataList = [{'a': 1}, {'b': 3}, {'c': 5}]
for dic in dataList:
    for key in dic:
        print(dic[key])

It could be even without any lookups by just iterating over the values of the dictionaries:

dataList = [{'a': 1}, {'b': 3}, {'c': 5}]
for dic in dataList:
    for val in dic.values():
        print(val)

Or wrap the iterations inside a list-comprehension or a generator and unpack them later:

dataList = [{'a': 1}, {'b': 3}, {'c': 5}]
print(*[val for dic in dataList for val in dic.values()], sep='\n')

the possibilities are endless. It's a matter of choice what you prefer.

When you iterate over a list, you get the elements, not the indices. Consider

for car in cars:
  for x, y in car["coded"].items():
    print(x, y)

While operator.itemgetter is a more efficient alternative to an equivalent lambda function, it does not beat normal dictionary lookup [], and using it for that purpose makes code harder to read.

Your code looks very complicated to me and I find it hard to follow, but the most likely bottleneck is the five-fold nested for loop.

In there, my first thought would be to consider if these lines...

            for pred in getter(val):
                for items in getter_2(val_2):
                    if(items == pred):

...or, if we eliminate the getter...

            for pred in val["predecessor"]:
                for items in val_2["setid_hash"]:
                    if(items == pred):

...could be replaced by a set operation such as:

            if not val["predecessor"].isdisjoint(val_2["setid_hash"]):

You could use a generator to only grab ages.

# Get a dictionary 
myList = [{'age':x} for x in range(1,10)]

# Enumerate ages
for i, age in enumerate(d['age'] for d in myList): 
    print i,age

And, yeah, don't use semicolons.

Try r/learnpython for learning the language. This sub is more focused on news according to the sidebar.

key is just a variable name.

for key in d:

will simply loop over the keys in the dictionary, rather than the keys and values. To loop over both key and value you can use the following:

For Python 3.x:

for key, value in d.items():

For Python 2.x:

for key, value in d.iteritems():

To test for yourself, change the word key to poop.

In Python 3.x, iteritems() was replaced with simply items(), which returns a set-like view backed by the dict, like iteritems() but even better. This is also available in 2.7 as viewitems().

The operation items() will work for both 2 and 3, but in 2 it will return a list of the dictionary's (key, value) pairs, which will not reflect changes to the dict that happen after the items() call. If you want the 2.x behavior in 3.x, you can call list(d.items()).

items doesn't work because you are calling it on the list, but you don't need to do that either. As you have the same keys in your dictionaries, just loop over the list and access the dictionary directly:

{% for item in foo %}
   {{ item.name }}
   {{ item.age }}
{% endfor %}

The documentation on template variables explains how/why the . works when it comes to dictionaries:

Technically, when the template system encounters a dot, it tries the following lookups, in this order:

• Dictionary lookup
• Attribute lookup
• Method call
• List-index lookup