Q:

reaching values in dictionary inside dictionary python 2.7

ok ill try to simplify this:
1st question: is a dictionary of dictionaries considered more appropriate than a list of dictionaries?
2nd Question: I'm struggling to reach the second level of my dictionaries to print them out in the right order.
I know dicts are not ordered, but I've managed to get lambda to order the first dictionary to get the notes printed out 1-10.
Now I need to get the second level to print out in the order they're written (ID & NAME before CONTENT). 
Any help to get control over this would be much appreciated ;)
annotations = {}
index = 1
for i in range(10):
annotations['Annotation #: '+str(i+1)+" --->>"] = {
    'ID' : index,
    'NAME:' : 'Tag Name',
    'CONTENT:' : 'Note Content: This space will have a lot of text',
    'URL:' : 'ref address',
    'URL Info:' : 'url info',
}
index += 1

for key, values in sorted(annotations.items(), key=lambda x: x[1]):
    print "\n"+key
    for k, v in sorted(values.items(), key = lambda item: item[1]):
        print k, v

outputs:
Annotation #: 1 --->>
ID 1
CONTENT: Note Content: This space will have a lot of text
NAME: Tag Name
URL: ref address
URL Info: url info

#....... etc.. to:

Annotation #: 10 --->>
ID 10
CONTENT: Note Content: This space will have a lot of text
NAME: Tag Name
URL: ref address
URL Info: url info

A:

If you want to tightly control the order of the things in your container, I think using dictionaries is a bad idea. As you note, the items in a dict are ordered arbitrarily. Currently your code sorts them by value, but that's not very meaningful.
I think it would be much more natural to use a list for the top level container, since you're creating the objects in order and want to keep that order. The keys of your top level dictionary were pretty meaningless, and can be replaced by indexes (e.g the output of enumerate).
For the inner container objects, there are more options. You could use an OrderedDict (from the collections module in the standard library) instead of a regular dict. That would let you iterate over the items of the dictionary in the same order you added them. You'd need to avoid using a dictionary literal to define the object though, or the order would be lost before the items were in the OrderedDict.
Another good option might be to create your own type with the namedtuple type-factory (also from collections). The type you'd get would be a kind of tuple that allows attribute access for its members, in addition to indexing.
You could also write your own class, which handles its attributes however you want. You could write a __str__ method that could turn the data into a string in whatever format you want.
As you requested in the comments, here's a quick and dirty implementation using a list of OrderedDicts:
from collections import OrderedDict

annotations = [OrderedDict([('ID', i + 1),     # need to initialize with a list of tuples
                            ('NAME', 'Tag Name'),   # to preserve the order of the items
                            ('CONTENT', 'Note Content: This space will have a lot of text'),
                            ('URL', 'ref address'),
                            ('URL Info', 'url info')])
               for i in range(10)]

for i, dct in enumerate(annotations):
    print("Annotation #{}".format(i+1))
    for key, value in dct.items():
        print("{}: {}".format(key, value))
    print()

I created all the annotations in a list comprehension here. When you're generating your real data with non-dummy data, you might not be able to do that as easily, but it should work just as well if you write out a regular for loop and append the OrderedDicts to it.

