考虑一个像

mydict = {
  'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
  'Grapes':{'Arabian':'25','Indian':'20'} }

例如，如何访问该词典的特定元素？例如，我想在对Apple的第一个元素进行某种格式设置后再打印第一个元素，在我们的例子中，该格式仅是“ American”？

附加信息上面的数据结构是通过在python函数中解析输入文件创建的。一旦创建，它在该运行中将保持不变。

我在函数中使用此数据结构。

因此，如果文件发生更改，则下次运行此应用程序时，文件的内容将有所不同，因此此数据结构的内容将有所不同，但格式将相同。因此，您在我的职能中看到我，我不知道Apple中的第一个元素是“ American”或其他任何元素，因此我不能直接使用“ American”作为键。

鉴于它是字典，您可以使用键来访问它。获取存储在“ Apple”下的词典，请执行以下操作：

>>> mydict["Apple"]
{'American': '16', 'Mexican': 10, 'Chinese': 5}

并让其中有多少是美国人（16），请执行以下操作：

>>> mydict["Apple"]["American"]
'16'

如果问题是，如果我知道我有一个包含“ Apple”作为水果和“ American”作为一种苹果的字典，我将使用：

myDict = {'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
          'Grapes':{'Arabian':'25','Indian':'20'} }


print myDict['Apple']['American']

正如其他人建议的那样。如果问题是，则当您将任意文件读入dict数据结构的dict中时，您不知道是否存在“ Apple”作为水果，是否存在“ American”作为“ Apple”类型，您可以执行以下操作：

print [ftype['American'] for f,ftype in myDict.iteritems() if f == 'Apple' and 'American' in ftype]

还是更好，所以如果您知道只有Apple拥有American类型，就不必不必要地遍历整个dict。

if 'Apple' in myDict:
    if 'American' in myDict['Apple']:
        print myDict['Apple']['American']

在所有这些情况下，字典实际存储条目的顺序都无关紧要。如果您确实担心订单，则可以考虑使用OrderedDict：

http://docs.python.org/dev/library/collections.html#collections.OrderedDict

正如我注意到您的描述一样，您只知道解析器将为您提供一个字典，其值也就是字典，如下所示：

sampleDict = {
              "key1": {"key10": "value10", "key11": "value11"},
              "key2": {"key20": "value20", "key21": "value21"}
              }

因此，您必须迭代父词典。如果要打印或访问sampleDict.values()列表中的所有第一个词典键，则可以使用以下方法：

for key, value in sampleDict.items():
    print value.keys()[0]

如果您只想访问中第一个项目的第一个键sampleDict.values()，这可能会很有用：

print sampleDict.values()[0].keys()[0]

如果使用您在问题中给出的示例，我的意思是：

sampleDict = {
              'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
              'Grapes':{'Arabian':'25','Indian':'20'}
              }

第一个代码的输出是：

American
Indian

第二个代码的输出是：

American

作为奖励，我想为您的问题提供一种不同的解决方案。您似乎正在处理嵌套字典，这通常很乏味，尤其是当您必须检查内部键的存在时。

在pypi上有一些与此有关的有趣库，这是您的快速搜索。

在您的特定情况下，dict_digger似乎很合适。

>>> import dict_digger
>>> d = {
  'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
  'Grapes':{'Arabian':'25','Indian':'20'} 
}

>>> print(dict_digger.dig(d, 'Apple','American'))
16
>>> print(dict_digger.dig(d, 'Grapes','American'))
None

您可以使用dict['Apple'].keys()[0]获取Apple字典中的第一个键，但是不能保证它会是American。词典中键的顺序可以根据词典的内容和键的添加顺序而变化。

我知道这是8岁，但似乎没有人真正阅读并回答过这个问题。

您可以在字典上调用.values（）以获得内部字典的列表，从而按索引访问它们。

>>> mydict = {
...  'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
...  'Grapes':{'Arabian':'25','Indian':'20'} }

>>>mylist = list(mydict.values())
>>>mylist[0]
{'American':'16', 'Mexican':10, 'Chinese':5},
>>>mylist[1]
{'Arabian':'25','Indian':'20'}

>>>myInnerList1 = list(mylist[0].values())
>>>myInnerList1
['16', 10, 5]
>>>myInnerList2 = list(mylist[1].values())
>>>myInnerList2
['25', '20']

您不能依赖字典的顺序。但是您可以尝试以下方法：

dict['Apple'].items()[0][0]

如果您希望保留订单，则可以使用以下网址：http : //www.python.org/dev/peps/pep-0372/#ordered-dict-api

简单示例以了解如何访问字典中的元素：-

创建字典

d = {'dog' : 'bark', 'cat' : 'meow' } 
print(d.get('cat'))
print(d.get('lion'))
print(d.get('lion', 'Not in the dictionary'))
print(d.get('lion', 'NA'))
print(d.get('dog', 'NA'))

探索有关Python词典的更多信息，并在此处进行交互学习...

尽管有很多问题的答案，但很少有人指出字典是无序的映射，因此（直到使用Python 3.7祝福插入顺序）字典中“第一个”条目的想法实际上是没道理 甚至OrderedDict只能通过使用诸如以下的丑陋的数字索引来访问mydict[mydict.keys()[0]]（仅Python 2，因为在Python 3中keys()是不可下标的迭代器。）

从3.7开始，并在3,6中付诸实践-引入了新的行为，但直到3.7才包含在语言规范中-在字典的键，值或项上进行迭代（我相信，也设置）将首先产生最近插入的对象。仍然没有简单的方法可以通过数字插入索引来访问它们。

关于选择和“格式化”项目的问题，如果您知道要在字典中检索的键，通常可以将该键用作下标来检索它（my_var = mydict['Apple']）。

如果您确实希望能够通过条目号为项目建立索引（而忽略了特定条目号会随着插入而改变的事实），那么适当的结构可能就是一个由两个元素组成的元组的列表。代替

mydict = {
  'Apple': {'American':'16', 'Mexican':10, 'Chinese':5},
  'Grapes':{'Arabian':'25','Indian':'20'} }

您可以使用：

mylist = [
    ('Apple', {'American':'16', 'Mexican':10, 'Chinese':5}),
    ('Grapes', {'Arabian': '25', 'Indian': '20'}
]

在这种情况下，第一个条目采用mylist[0]经典的列表扩展名形式，其值为('Apple', {'American':'16', 'Mexican':10, 'Chinese':5})。您可以如下遍历整个列表：

for (key, value) in mylist:  # unpacks to avoid tuple indexing
    if key == 'Apple':
        if 'American' in value:
            print(value['American'])

但是，如果您知道要查找键“ Apple”，那么为什么不使用字典呢？

您可以通过缓存键列表来引入更高级别的间接访问，但是保持两个数据结构同步的复杂性将不可避免地增加代码的复杂性。

使用以下小功能，挖掘树形字典变得非常容易：

def dig(tree, path):
    for key in path.split("."):
        if isinstance(tree, dict) and tree.get(key):
            tree = tree[key]
        else:
            return None
    return tree

现在，dig(mydict, "Apple.Mexican")返回10，而dig(mydict, "Grape")产生子树{'Arabian':'25','Indian':'20'}。如果字典中不包含键，则dig返回None。

请注意，您可以轻松地从'。'更改（甚至参数化）分隔符char。到“ /”，“ |” 等等