Python 字典|极客教程

Python 字典是键-值对的容器。它是可变的，可以包含混合类型，字典是无序集合。 Python 词典在其他语言中称为关联数组或哈希表。字典中的键必须是不可变的对象，例如字符串或数字，它们在字典中也必须是唯一的。

Python 字典创建

首先，我们展示如何创建 Python 字典。

create_dict.py

#!/usr/bin/env python

# create_dict.py

weekend = { "Sun": "Sunday", "Mon": "Monday" }
vals = dict(one=1, two=2)

capitals = {}
capitals["svk"] = "Bratislava"
capitals["deu"] = "Berlin"
capitals["dnk"] = "Copenhagen"

d = { i: object() for i in range(4) }

print(weekend)
print(vals)
print(capitals)
print(d)

在示例中，我们以四种不同方式创建四个字典。稍后，我们将这些词典的内容打印到控制台。

weekend = { "Sun": "Sunday", "Mon": "Monday" }

我们使用字典文字表示法创建周末字典。键值对用大括号括起来。两对之间用逗号分隔。一对的第一个值是键，后跟一个冒号和一个值。 "Sun"字符串是键，"Sunday"字符串是值。

vals = dict(one=1, two=2)

可以使用dict()功能创建字典。

capitals = {}
capitals["svk"] = "Bratislava"
capitals["deu"] = "Berlin"
capitals["dnk"] = "Copenhagen"

第三种方法是创建一个空的大写字典。三对将添加到词典中。键位于方括号内，值位于分配的右侧。

d = { i: object() for i in range(4) }

使用字典推导式来创建字典。理解分为两个部分。第一部分是i: object()表达式，该表达式在循环的每个循环中执行。第二部分是for i in range(4)循环。字典推导式将创建具有四对的字典，其中键为数字 0、1、2 和 3，值为简单对象。

$ ./create_dict.py
{'Sun': 'Sunday', 'Mon': 'Monday'}
{'two': 2, 'one': 1}
{'svk': 'Bratislava', 'dnk': 'Copenhagen', 'deu': 'Berlin'}
{0: <object object at 0xb76cb4a8>, 1: <object object at 0xb76cb4b0>,
2: <object object at 0xb76cb4b8>, 3: <object object at 0xb76cb4c0>}

这是示例输出。

Python 字典推导式

词典理解是一种基于现有词典创建词典的语法结构。

D = { expression for variable in sequence [if condition] }

字典推导式放在两个大括号之间；它包含三个部分：for 循环，条件和表达式。

在 for 循环中，我们浏览了字典。可选的 if 条件指定必须满足的条件。最后，对表达式进行求值。该表达式从满足条件的输入序列成员中产生输出字典的元素。

comprehension.py

#!/usr/bin/env python

# comprehension.py

capitals = { "Bratislava": 424207, "Vilnius": 556723, "Lisbon": 564657,
             "Riga": 713016, "Jerusalem": 780200, "Warsaw": 1711324,
             "Budapest": 1729040, "Prague": 1241664, "Helsinki": 596661,
             "Yokyo": 13189000, "Madrid": 3233527 }

capitals2 = { key:val for key, val in capitals.items() if val < 1000000 }

print(capitals2)

在示例中，我们从现有字典创建一个新字典。

capitals = { "Bratislava": 424207, "Vilnius": 556723, "Lisbon": 564657,
             "Riga": 713016, "Jerusalem": 780200, "Warsaw": 1711324,
             "Budapest": 1729040, "Prague": 1241664, "Helsinki": 596661,
             "Yokyo": 13189000, "Madrid": 3233527 }

我们有一个大写的字典。关键在于资本，而人口就是价值。

capitals = { key:val for key, val in capitals.items() if val < 1000000 }

使用字典推导式来创建新字典。它包含人口少于一百万的首都。

$ ./comprehension.py
{'Bratislava': 424207, 'Vilnius': 556723, 'Jerusalem': 780200, 'Riga': 713016,
    'Lisbon': 564657, 'Helsinki': 596661}

这些首都的人口少于一百万。

Python 字典的基本操作

以下示例显示了使用 Python 词典的一些基本操作。

basics.py

#!/usr/bin/env python

# basics.py

basket = { 'oranges': 12, 'pears': 5, 'apples': 4 }

basket['bananas'] = 5

print(basket)
print("There are {0} various items in the basket".format(len(basket)))

print(basket['apples'])
basket['apples'] = 8
print(basket['apples'])

print(basket.get('oranges', 'undefined'))
print(basket.get('cherries', 'undefined'))

我们有一个装着不同水果的篮子。我们对购物篮字典执行一些操作。

basket = { 'oranges': 12, 'pears': 5, 'apples': 4 }

将创建篮子字典。它最初具有三个键值对。

basket['bananas'] = 5

将创建一个新的配对。 'bananas'字符串是键，5整数是值。

print("There are {0} various items in the basket".format(len(basket)))

len()函数给出字典中的对数。

print(basket['apples'])

“苹果”键的值会打印到终端上。

basket['apples'] = 8

“苹果”键的值被修改。设置为数字 8。

print(basket.get('oranges', 'undefined'))

get()方法检索指定键的值。如果没有这样的键，则返回该方法的第二个参数。

print(basket.get('cherries', 'undefined'))

该行返回“未定义”。篮子里没有樱桃。

$ ./basics.py
{'bananas': 5, 'pears': 5, 'oranges': 12, 'apples': 4}
There are 4 various items in the basket
4
8
12
undefined

这是示例输出。

Python 字典`fromkeys`和`setdefault`

下一个示例介绍了两种字典方法：fromkeys()和setdefault()。

fruits.py

#!/usr/bin/env python

# fruits.py

basket = ('oranges', 'pears', 'apples', 'bananas')

fruits = {}.fromkeys(basket, 0)
print(fruits)

fruits['oranges'] = 12
fruits['pears'] = 8
fruits['apples'] = 4

print(fruits.setdefault('oranges', 11))
print(fruits.setdefault('kiwis', 11))

print(fruits)

fromkeys()方法从列表创建一个新字典。如果存在键，则setdefault()方法将返回一个值。否则，它将插入具有指定默认值的键并返回该值。

basket = ('oranges', 'pears', 'apples', 'bananas')

我们有一个字符串列表。从该列表中将构建新的字典。

fruits = {}.fromkeys(basket, 0)

fromkeys()方法创建一个新的词典，列表项将作为关键字。每个键都将初始化为 0。请注意fromkeys()方法是一个类方法，需要调用该类名，在本例中为{}。

fruits['oranges'] = 12
fruits['pears'] = 8
fruits['apples'] = 4

在这里，我们向fruits字典添加一些值。

print(fruits.setdefault('oranges', 11))
print(fruits.setdefault('kiwis', 11))

第一行将12打印到终端。 'oranges'键存在于词典中。在这种情况下，该方法将返回其值。在第二种情况下，键尚不存在。一对新的'kiwis': 11被插入字典。值11被打印到控制台。

$ ./fruits.py
{'bananas': 0, 'pears': 0, 'oranges': 0, 'apples': 0}
12
11
{'kiwis': 11, 'bananas': 0, 'pears': 8, 'oranges': 12, 'apples': 4}

当启动fruits.py脚本时，我们会收到此输出。

Python 字典更新方法

下一个代码示例演示如何使用update()方法添加两个 Python 字典。

domains.py

#!/usr/bin/env python

# domains.py

domains = { "de": "Germany", "sk": "Slovakia", "hu": "Hungary"}
domains2 = { "us": "United States", "no": "Norway" }

domains.update(domains2)

print(domains)

两个字典通过update()方法结合在一起。

domains.update(domains2)

使用update()方法将domains2字典添加到域字典中。

$ ./domains.py
{'sk': 'Slovakia', 'de': 'Germany', 'no': 'Norway',
'us': 'United States', 'hu': 'Hungary'}

结果显示所有值。

Python 从字典中删除项目

现在我们展示如何从字典中删除一对。

removing.py

#!/usr/bin/env python

# removing.py

items = { "coins": 7, "pens": 3, "cups": 2,
    "bags": 1, "bottles": 4, "books": 5 }

print(items)

item = items.pop("coins")
print("Item having value {0} was removed".format(item))

print(items)

del items["bottles"]
print(items)

items.clear()
print(items)

项目字典有六个键值对，我们将从该词典中删除配对。

item = items.pop("coins")
print("Item having value {0} was removed".format(item))

pop()方法删除具有指定键的一对；它返回已删除键的值。

del items["bottles"]

del关键字从项目字典中删除"bottles": 4对。

items.clear()

clear()方法清除字典中的所有项目。

$ ./removing.py
{'bags': 1, 'pens': 3, 'coins': 7, 'books': 5, 'bottles': 4, 'cups': 2}
Item having value 7 was removed
{'bags': 1, 'pens': 3, 'books': 5, 'bottles': 4, 'cups': 2}
{'bags': 1, 'pens': 3, 'books': 5, 'cups': 2}
{}

Python 字典键和值

Python 字典由键值对组成。 keys()方法从字典中返回键列表。 values()方法创建一个值列表。并且items()方法返回键值元组的列表。

keys_values.py

#!/usr/bin/env python

# keys_values.py

domains = { "de": "Germany", "sk": "Slovakia", "hu": "Hungary",
    "us": "United States", "no": "Norway"  }

print(domains.keys())
print(domains.values())
print(domains.items())

print("de" in domains)
print("cz" in domains)

我们演示了上述方法。我们还检查in关键字是否存在键。

print(domains.keys())

我们使用keys()方法打印domains词典的键列表。

print(domains.values())

我们使用values()方法打印domains词典的值列表。

print(domains.items())

最后，我们使用items()方法打印域字典的键值元组列表。

print("de" in domains)
print("cz" in domains)

使用in关键字，我们检查domains字典中是否存在"de"和"cz"键。返回值为True或False。

$ ./keys_values.py
['sk', 'de', 'no', 'us', 'hu']
['Slovakia', 'Germany', 'Norway', 'United States', 'Hungary']
[('sk', 'Slovakia'), ('de', 'Germany'), ('no', 'Norway'),
('us', 'United States'), ('hu', 'Hungary')]
True
False

Python 字典循环

遍历字典是常见的编程工作。这可以通过 for 关键字完成。

looping.py

#!/usr/bin/env python

# looping.py

domains = { "de": "Germany", "sk": "Slovakia", "hu": "Hungary",
    "us": "United States", "no": "Norway" }

for key in domains:
    print(key)

for val in domains.values():
    print(val)

for k, v in domains.items():
    print(": ".join((k, v)))

在该示例中，我们遍历domains字典以打印键，值以及字典的键和值。

for key in domains:
    print(key)

此循环将打印字典的所有键。

for val in domains.values():
    print(val)

第二个循环打印字典的所有值。

for k, v in domains.items():
    print(": ".join((k, v)))

在第三个循环中，将打印所有键和值。

$ ./looping.py
sk
de
no
us
hu
Slovakia
Germany
Norway
United States
Hungary
sk: Slovakia
de: Germany
no: Norway
us: United States
hu: Hungary

Python 字典成员性测试

使用in和not in运算符，我们可以检查字典中是否存在键。

membership.py

#!/usr/bin/env python

# membership.py

domains = { "de": "Germany", "sk": "Slovakia", "hu": "Hungary",
    "us": "United States", "no": "Norway"  }

key = "sk"

if key in domains:
    print("{0} is in the dictionary".format(domains[key]))

在示例中，我们使用in运算符检查国家/地区是否在字典中。

Python 字典排序

Python 字典是无序的，这也意味着它们不能像 Python 列表那样排序，程序员可以创建 Python 字典的排序表示形式。在本节中，我们展示了几种创建排序输出的方法。

程序员可能希望以正常或相反的顺序对数据进行排序。他们可以按键或按值对数据进行排序。

simple_sort.py

#!/usr/bin/env python

# simple_sort.py

items = { "coins": 7, "pens": 3, "cups": 2,
    "bags": 1, "bottles": 4, "books": 5 }

kitems = list(items.keys())
kitems.sort()

for k in kitems:
    print(": ".join((k, str(items[k]))))

第一个示例提供了最简单的解决方案，以按键对数据进行排序。

kitems = items.keys()
kitems.sort()

从字典中获得键列表。该列表使用sort()方法排序。

for k in kitems:
    print(": ".join((k, str(items[k]))))

在循环中，我们从字典中打印排序的键以及它们的值。

$ ./simple_sort.py
bags: 1
books: 5
bottles: 4
coins: 7
cups: 2
pens: 3

项目字典按其键排序。

内置的sorted()功能可以完成更有效的分类。

sorting.py

#!/usr/bin/env python

# sorting.py

items = { "coins": 7, "pens": 3, "cups": 2,
    "bags": 1, "bottles": 4, "books": 5 }

for key in sorted(items.keys()):
    print("%{0}: {1}".format(key, items[key]))

print("###############")

for key in sorted(items.keys(), reverse=True):
    print("{0}: {1}".format(key, items[key]))

在示例中，我们使用sorted()功能按其键升序和降序打印排序的数据。

for key in sorted(items.keys()):
    print("%{0}: {1}".format(key, items[key]))

在此 for 循环中，我们打印按升序排序的对。 iteritems()函数在字典的（键，值）对上返回一个迭代器。

for key in sorted(items.keys(), reverse=True):
    print("{0}: {1}".format(key, items[key]))

在第二个 for 循环中，数据按降序排序。订单类型由reverse参数控制。

$ ./sorting.py
bags: 1
books: 5
bottles: 4
coins: 7
cups: 2
pens: 3
###############
pens: 3
cups: 2
coins: 7
bottles: 4
books: 5
bags: 1

sorting.py脚本的输出。

在下一个示例中，我们将按项目的值对项目进行排序。

sorting2.py

#!/usr/bin/env python

# sorting2.py

items = { "coins": 7, "pens": 3, "cups": 2,
    "bags": 1, "bottles": 4, "books": 5 }

for key, value in sorted(items.items(), key=lambda pair: pair[1]):

    print("{0}: {1}".format(key, value))

print("###############")

for key, value in sorted(items.items(), key=lambda pair: pair[1], reverse=True):

    print("{0}: {1}".format(key, value))

该示例按值的升序和降序打印数据。

for key, value in sorted(items.iteritems(),
    key=lambda (k,v): (v,k)):

字典对按其值排序并打印到控制台。 key 参数具有一个函数，该函数指示如何对数据进行排序。

$ ./sorting2.py
bags: 1
cups: 2
pens: 3
bottles: 4
books: 5
coins: 7
###############
coins: 7
books: 5
bottles: 4
pens: 3
cups: 2
bags: 1

从输出中我们可以看到，这次按它们的值排序。

Python 字典

Python 字典创建

Python 字典推导式

Python 字典的基本操作

Python 字典`fromkeys`和`setdefault`

Python 字典更新方法

Python 从字典中删除项目

Python 字典键和值

Python 字典循环

Python 字典成员性测试

Python 字典排序

Python教程

Java教程

Web教程

数据库教程

图形图像教程

大数据教程

开发工具教程

计算机教程

Python 教程

回顶部

Python 字典创建

Python 字典推导式

Python 字典的基本操作

Python 字典fromkeys和setdefault

Python 字典更新方法

Python 从字典中删除项目

Python 字典键和值

Python 字典循环

Python 字典成员性测试

Python 字典排序

Python教程

Java教程

Web教程

数据库教程

图形图像教程

大数据教程

开发工具教程

计算机教程

Python 教程

回顶部

切换注册登录

用户名或邮箱

密码

切换登录注册

昵称

邮箱

Python 字典`fromkeys`和`setdefault`