做静态网站步骤/西安发布最新通知

练习39 源代码

# create a mapping of state to abbreviation
#创建一个州与缩写的映射
states = {'Oregon':'OR','Florida':'FL','California': 'CA',
'New York': 'NY','Michigan':'MI'} #创建一个字典，key为州名，value为州缩写#Create a basic set of states and some cities in them
#创造一系列州与其中的一些城市
cities = {'CA':'San Francisco','MI': 'Detroit',
'FL': 'Jacksonvill'} #创建字典，key为州缩写，value为城市#add some more cities
#增加更多的城市
cities['NY'] = 'New York' #添加cities字典的key为NY,value为New York
cities['OR'] = 'Portland' #添加cities字典的key为OR，value为Portland#print out some cities 打印一些城市
print('-' * 10)
print("NY State has: ",cities['NY']) #通过cities字典的key为NY，打印对应Value
print("OR State has: ",cities['OR']) #同上#print some states 打印一些州
print('-' * 10)
print("Michigan's abbreviation is: ",states['Michigan']) #通过字典states的key'Michigan'，打印对应的Value
print("Florida's abbreviation is: ",states['Florida']) #同上#do it by using the state then cities dict
# 通过使用州和城市的字典来打印
print('-' * 10) 
print("Michigan has: ",cities[states['Michigan']]) 
#step1，通过states字典的key 'Michigan'找到对应的value 'MI'；step2，'MI'又作为cities字典的key，打印对应的value 'Detroit'。
print("Florida has: ",cities[states['Florida']]) #原理同上# print every state abbreviation 打印每个州的缩写
print('-' * 10)
#items()函数以列表返回可遍历的（键值）元组数组。列表内为元组，元组内包含了字典的key和value
for state,abbrev in list(states.items()): 
#items()函数以列表返回可遍历的（键值）元组数组。列表内为元组，元组内包含了字典的key和valueprint(f"{state} is abbreviated {abbrev}")#print every city in states
print('-' * 10)
#for循环遍历字典，items()将字典转化为字典视图特殊序列
for abbrev, city in list(cities.items()):print(f"{abbrev} has the city {city}")# now do both at the same time 同时打印所以州和城市
print('-' * 10)
#for循环遍历字典，items()将字典转化为字典视图特殊序列
for state, abbrev in list(states.items()):print(f"{state} state is abbreviated {abbrev}")print(f"and has city {cities[abbrev]}")print('-' * 10)# safely get a abbreviation by state that might not be there
#安全的获得一个可能不存在的州的缩写
state = states.get('Texas') #get()函数，获取指定键对应的值，若键不存在，则可自定义输出值，不会报错。if not state:print("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:  Jacksonvill
----------
Oregon is abbreviated OR
Florida is abbreviated FL
California is abbreviated CA
New York is abbreviated NY
Michigan is abbreviated MI
----------
CA has the city San Francisco
MI has the city Detroit
FL has the city Jacksonvill
NY has the city New York
OR has the city Portland
----------
Oregon state is abbreviated OR
and has city Portland
Florida state is abbreviated FL
and has city Jacksonvill
California state is abbreviated CA
and has city San Francisco
New York state is abbreviated NY
and has city New York
Michigan state is abbreviated MI
and has city Detroit
----------
Sorry, no Texas.
The city for the state 'TX' is Does Not Exist

知识点：

1.字典是什么？
**作用：**字典是用来把你想要存储的东西映射或关联到一些键（keys），以便你能够获取到它们。可存储任意类型对象。
**格式：**字典的每个键值(key=>value)用冒号分割，每个对之间用逗号分割，整个字典包括在花括号中，格式为：d = {key1 : value1, key2 : value2}。
**规则：**键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

2. 字典和列表的区别
（1）字典不仅可以通过数值查找元素，还可以通过字符串来查找元素。列表只能通过数值查找元素。
（2）字典可以通过字符串往里添加元素，也可以通过字符串或数值来删除元素。而列表只能通过数值来添加和删除元素。

3.字典和列表的应用场景
（1）字典可以用在各种需要通过某个值去查看另一个值的场合。
（2）列表可以用在专供需要有序排列的数据使用的。
（3）字典是键值对的组合，列表是一些项的有序排列。

4.字典的items（）函数
返回字典中成对的键和值形成的元组，返回的是一种名叫字典视图的特殊序列，其中每个元素都是一个元组。可以用于 for 来循环遍历；
示例：

cities = {'CA':'San Francisco','MI': 'Detroit',
'FL': 'Jacksonvill'}
#items函数，将字典的key和value作为元组，返回存在dict_items开始的字典视图特殊序列
cities_it = cities.items()
print(cities_it)
#加list函数后，将字典视图特殊序列转化为列表
cities_li = list(cities.items())
print(cities_li)#dict_items可用于for循环遍历字典的键和值
for key, value in cities_it:print(f"the key is {key}, the value is {value}." )#items()和list()函数合用，返回列表，用于for循环
for key, value in cities_li:print (f"the key is {key}, the value is {value}.")

输出结果：

dict_items([('CA', 'San Francisco'), ('MI', 'Detroit'), ('FL', 'Jacksonvill')])
[('CA', 'San Francisco'), ('MI', 'Detroit'), ('FL', 'Jacksonvill')]
the key is CA, the value is San Francisco.
the key is MI, the value is Detroit.
the key is FL, the value is Jacksonvill.
the key is CA, the value is San Francisco.
the key is MI, the value is Detroit.
the key is FL, the value is Jacksonvill.

5.字典get（）函数
get()函数用法：在获取键对应的值的时候，使用get()方法可以避免因未找到相应目标而引发异常的情况。
语法：

my.dict.get(key,default)

Key为我们要查询的键，default为未找到时的默认返回值，我们可以进行自定义。
示例：

#dict.get()函数
cities = {'CA':'San Francisco','MI': 'Detroit',
'FL': 'Jacksonvill'}
abbrev = cities.get('CA') #获取对应键的值
print(abbrev)#若该键不存在,使用get函数不会报错
abbrev_no = cities.get('NI')
print(abbrev_no)#若该键不存在，可自定义输出内容
#第一种
abbrev_no1 = cities.get('AB')
if not abbrev_no1:print("NO EXIT.")
#第二种
abbrev_no1 = cities.get('AB', "Does not exit the key.")
print(abbrev_no1) 

输出结果：

San Francisco
None
NO EXIT.
Does not exit the key.

附加练习

1.找找 Python 的字典文档，试试多进行一些操作。
python字典常用的函数：clear、get、items、keys、values、pop。
（1）clear（）函数
使用clear()方法会清空字典中的所有元素。
示例：

#输入
# dict.clear()函数
cities = {'CA':'San Francisco','MI': 'Detroit',
'FL': 'Jacksonvill'}
cities.clear()
print(cities)#输出
{}

（2）get()函数
见知识点。

（3）items()函数
见知识点。

（4）keys()函数
它的使用方式和items使用方法类似，keys返回字典中的键。输出形式字典视图特殊序列。
示例：

#输入
#dict.key()函数
cities = {'CA':'San Francisco','MI': 'Detroit',
'FL': 'Jacksonvill'}
print(cities.keys())#输出
dict_keys(['CA', 'MI', 'FL'])

（5）values()函数
vlaues()返回字典中的所有值。输出形式字典视图特殊序列。
示例：

#dict.values()函数
#输入
cities = {'CA':'San Francisco','MI': 'Detroit',
'FL': 'Jacksonvill'}
print(cities.values())#输出
dict_values(['San Francisco', 'Detroit', 'Jacksonvill'])

（6）pop()函数
pop()方法会删除指定的键，并返回其值，如果没有找到相应键可输出默认值。
语法：

my_dict.pop(key,default)

Key为我们要删除的键，当没有找到该键的时候会输出default，default可自定义，当没有default时返回的是None。类似get()函数。

示例：

#dict.pop()函数
cities = {'CA':'San Francisco','MI': 'Detroit',
'FL': 'Jacksonvill'}
print(cities.pop('CA')) #删除除键'CA'及对应值
print(cities)#删除键对，若键'NI'不存在，输出'NO Exit'
cities_pop = cities.pop("NI","NO Exit")
print(cities_pop)

输出结果：

{'MI': 'Detroit', 'FL': 'Jacksonvill'}
NO Exit

2. 看看你不能用字典做什么。很重要的一点是它们没有次序，试着玩玩看。
值得注意的是，从Python3.6开始，Python中内置的字典是有序的，这里的有序是指输出有序，是按照插入的顺序输出的，而不是指按照key的字母数字顺序。原先字典是无序的。
（1）字典的无序是指，不能人为重新排序，只能通过转化为字典视图特殊序列（类似元组和列表组合）进行排序，字典本身的顺序不会发生改变，但也可以通过排序后的字典视图特殊序列输出键值对。
示例：

#字典排序sorted()函数，及字典的顺序
cities = {'CA':'San Francisco','MI': 'Detroit',
'FL': 'Jacksonvill'}#for循环遍历字典
print("-" * 20)
for key,value in list(cities.items()):print(f"key: {key}, value: {value}")#按照字典的键排序
print("-" * 20)
cities_s1 = sorted(cities.items(), key= lambda x : x[0]) 
print(cities_s1)#按照字典的值排序
print("-" * 20)
cities_s2 = sorted(cities.items(), key= lambda x : x[1]) 
print(cities_s2)#for循环遍历
print("-" * 20)
for key, value in list(cities_s1):print(key,value)

输出结果：

--------------------
key: CA, value: San Francisco
key: MI, value: Detroit
key: FL, value: Jacksonvill
--------------------
[('CA', 'San Francisco'), ('FL', 'Jacksonvill'), ('MI', 'Detroit')]
--------------------
[('MI', 'Detroit'), ('FL', 'Jacksonvill'), ('CA', 'San Francisco')]
--------------------
CA San Francisco
FL Jacksonvill
MI Detroit

（2）由于字典中的元素具有特定的顺序，但没办法直接做到取第N个值。

#输入
cities = {'CA':'San Francisco','MI': 'Detroit',
'FL': 'Jacksonvill'}
print(cities[1])#输出报错
Traceback (most recent call last):File "c:\Users\Desktop\Python3_exercises\text39.py", line 3, in <module>print(cities[1])
KeyError: 1

（3）字典无法按照指定位置添加键值对。默认从尾部添加。

常见问题

1. 列表和字典有哪些区别? 列表是元素的有序排列。而字典是把一些元素（称为“键”，keys）和另一些元素（称为“值”，values）匹配起来。
2. 我能用字典做什么？ 当你需要用一个东西去查另一个东西的时候。其实，你可以把字典称为“查询表”（look up tables）。
3. 我能用列表做什么？ 可以用于任何有序排列的东西，同时你只需要用数字索引来查找它们。
   4.如果我需要一个字典，但我又想让它们有序排列怎么办呢？ 参考常见问题中的sorted()函数。示例可见常见问题2
   sorted()函数：
   语法：

sorted(iterable, key=None,reverse=False)

参数说明：
(1)iterable:代表的是可迭代的对象。
(2) key=None：用来进行比较的元素，具体的值来源于可迭代的对象中。
(3)reverse=False：排序规则，reverse=False升序(默认)，reverse=True降序。

5.字典可以转化为列表和元组，列表和元组不能转化为字典。