【Python基础】lpthw - Exercise 39 字典

　　1. 字典和列表的区别

　　对于列表，它是一些项的有序排列，只能通过数值来进行索引；对于字典，则可以通过许多东西进行索引，它采用键-值映射的方式，不存在一个特定的顺序，因此不能用类似列表的数值索引，但它的键可以是数值。

 stuff = {'name':'zed','age':18,'weight':'50kg'}
 print(stuff['name'])
 print(stuff['age'])
 stuff['age'] = 40
 print(stuff["age"])
 stuff[1] = 'test'       # 在列表中创建一个新的键值对
 print(stuff[1])
 print(stuff)

　　输出为

zed
18
40
test
{'name': 'zed', 'age': 40, 'weight': '50kg', 1: 'test'}

　　2. 删除字典中的内容

　　del dict['key_name']

　　3. 编程练习

 # create a mapping of state to abbreviation
 states = {
 'Oregon':'OR',
 'Florida':'FL',
 'California':'CA',
 'New York':'NY',
 'Michigan':'MI'
 }

 # create a basic set of  states and some cities in them
 cities = {
 'CA':'San Francisco',
 'MI':'Detroit',
 'FL':'Jacksonville'
 }

 # add some mor cities
 cities['NY'] = 'New York'
 cities['OR'] = 'Portland'

 # print out some cities
 print('-' * 10)
 print("NY state has: ",cities['NY'])
 print("OR state has: ",cities['OR'])

 # print some states
 print('-' * 10)
 print("Michigan's abbreviation is: ",states['Michigan'])
 print("Florida's abbreviation is: ",states['Florida'])

 # do it by using the sate then cities dict
 print('-' * 10)
 print("Michigan has: ", cities[states['Michigan']])
 print("Florida has: ", cities[states['Florida']])

 # print every state abbreviation
 print('-' * 10)
 for state, abbrev in list(states.items()):
     print(f"{state} is abbreviated as {abbrev}.")

 # print every city in state
 print('-' * 10)
 for abbrev, city in list(cities.items()):
     print(f"{abbrev} has the city {city}.")

 # now do both at the same time
 print('-' * 10)
 for state, abbrev in list(states.items()):
     print(f"{state} is abbreviated as {abbrev} and has city {cities[abbrev]}")

 print('-' * 10)
 # safely get a abbreviation by state that might not be there
 state = states.get('Texas')

 if not state:
     print(f'Sorry, no Texas.')

 # get a city with a default value
 city = cities.get('Tx','Does not exist')
 print(f"The city for the state 'TX' is: {city}")

　　输出

----------
NY state has:  New York
OR state has:  Portland
----------
Michigan's abbreviation is:  MI
Florida's abbreviation is:  FL
----------
Michigan has:  Detroit
Florida has:  Jacksonville
----------
Oregon is abbreviated as OR.
Florida is abbreviated as FL.
California is abbreviated as CA.
New York is abbreviated as NY.
Michigan is abbreviated as MI.
----------
CA has the city San Francisco.
MI has the city Detroit.
FL has the city Jacksonville.
NY has the city New York.
OR has the city Portland.
----------
Oregon is abbreviated as OR and has city Portland
Florida is abbreviated as FL and has city Jacksonville
California is abbreviated as CA and has city San Francisco
New York is abbreviated as NY and has city New York
Michigan is abbreviated as MI and has city Detroit
----------
Sorry, no Texas.
The city for the state 'TX' is: Does not exist

　　4. 上述练习中的语法点

　　① 向字典中添加键值对

dict['key'] = value

　　② 字典的嵌套

　　例如dict1的值是dict2的键时，可以做如下嵌套

dict2[dict1['key1']]

　　③ dict.items()函数

　　以列表的形式返回可遍历的（键，值）元组数组。

　　参数：无。

　　书中所用加list()的形式和不加list()实现的功能似乎一致。

 states = {
 'Oregon':'OR',
 'Florida':'FL',
 'California':'CA',
 'New York':'NY',
 'Michigan':'MI'
 }

 for state, abbr in states.items():
     print(state,abbr)

 for state, abbr in list(states.items()):
     print(state,abbr)

　　④ dict.get()函数

　　用于返回dict中指定键的值，如果键不在dict中，则返回设置的默认值，语法如下

dict.get(key, default = None)
dict.get('TX', 'Does not exist.')

　　5. 字典键的特性

　　字典的值可以是python中的任何数据类型，也可以是用户自定义的，但字典的键不行。

　　① 字典的键不可以重复定义，如果一个键在字典中被定义两次，则只会记住最后一个值，如

 dict = {'name':'Tom','age':18,'height':'170 cm','name':'Jerry'}
 print("dict['name']: {}".format(dict['name']))

　　输出为

dict['name']: Jerry

　　② 字典的值必须是不可变的，因此只能使用数值，字符串或者元组，而不能使用列表，如

 dict = {['name']:'Tom','age':18,'height':'170 cm'}
 print("dict[['name']]: {}".format(dict[['name']]))

　　报错

Traceback (most recent call last):
  File "ex23.py", line 1, in <module>
    dict = {['name']:'Tom','age':18,'height':'170 cm'}
TypeError: unhashable type: 'list'

　　6.字典的内置函数

　　len(dict): 求字典长度

　　str(dict): 以可打印的字符串的形式返回列表

　　type(variable): 返回输入变量的类型，对字典就是<class 'dict'>

　　7. 字典的常用操作

　　dict.clear()  删除字典中所有元素

　　dict.copy()  返回一个字典的浅复制 【参考】直接赋值和copy的区别

　　dict.fromkeys(sequence[, value]) 创建一个新的字典，以序列sequence中的元素做字典的键，value为所有键对应的初始值

　　 key in dict 如果key在dict中，返回True，否则返回False

　　dict.keys() 返回一个由所有键组成的迭代器，可以用list转换为列表（注意与dict.items()的区别，items()是直接返回列表）

　　dictl.values() 返回一个由所有值组成的迭代器，可以用list转换为列表

　　dict.setdefault(key, default = None) 和dict.get()类似，但如果key不在dict中则会添加这个键并将其值设为default

　　dict1.update(dict2) 用dict2的键值对更新dict1

　　dict.pop(key[,default]) 删除字典中给定key所给定的值，返回被删除的值；如果key不存在，则必须设定default的值（否则报错），并且函数将返回default的值

　　8. dict.popitem() 详解

　　官方文档：“Remove and return a (key, value) pair from the dictionary. Pairs are returned in LIFO order. ”

　　　　　　　"Changed in version 3.7: LIFO order is now guaranteed. In prior versions, popitem() would return an arbitrary key/value pair."

　　在3.7版本以前，popitem是按所谓的“随机”顺序从字典中取出值的。在3.7以后的版本，官方文档对此作出了修改，明确指出popitem()是按照“后进先出”的顺序取出并返回字典中的键值对的。也就是说，其返回的是最后一个被添加到字典中的键值对。

 dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
 print(dict)
 print(dict.popitem())
 print(dict)
 dict['e'] = 5
 print(dict.popitem())

　　输出为

{'a': 1, 'b': 2, 'c': 3, 'd': 4}
('d', 4)
{'a': 1, 'b': 2, 'c': 3}
('e', 5)

　　9. get()  pop()  popitem() 的安全性讨论

　　get() 可以为key设定缺省值，也可以不设定。当没有设置default时，如果dict中没有输入的key，则返回default的缺省值None；是一种相对安全的方法。　

　　pop()也可以设定缺省值，如果不设定，而key又不存在于dict中，则也会报错。

　　popitem()不能设定缺省值，如果dict为空时，dict.popitem()会报错：KeyError