西北工业大学NOJ-Python程序设计作业题解集合：
NOJ-Python程序设计：第1季：水题(Season 1-Easy) （1-10）
NOJ-Python程序设计：第2季：小段代码(Season 2-Snippet) （11-20）
NOJ-Python程序设计：第3季：循环(Season 3-Loop) （21-30）
NOJ-Python程序设计：第4季：枚举算法(Season 4-Enumeration algorithm) （31-40）
NOJ-Python程序设计：第5季：模块化(Season 5-Modularization) （41-50）
NOJ-Python程序设计：第6季：字符串(Season 6-String) （51-60）
NOJ-Python程序设计：第7季：列表与元组(Season 7-List and Tuple) （61-70）
NOJ-Python程序设计：第8季：集合与字典(Season 8-Sets and Dictionary) （71-80）
NOJ-Python程序设计：第9季：类(Season 9-Class) （81-90）
NOJ-Python程序设计：第10季：挑战算法(Season 10-Challenges) （91-100）

第8季：集合与字典(Season 8-Sets and Dictionary)（71-80）

前置知识点

建议大概了解下述函数库的基本运用之后再完成题目会更顺利。

copy()与deepcopy()区别

• 寻常意义的复制就是深复制，即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。
• 浅复制并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。

sorted函数

sorted 可以对所有可迭代的对象进行排序操作。

• 语法sorted(iterable, key=None, reverse=False)
• 参数：
  • iterable – 可迭代对象。
  • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

生成字典Ⅲ

需要导入copy库用于复制字典，注意使用的是深拷贝，保证是两份字典。

当前的dic字典 l 1 [ i ] l1[i] l1[i]对应的value的值是上一次的字典ans，然后复制dic字典给ans，然后dic字典清空。重复len(l1)次，最后答案就是ans字典。

import copy
l1=list(input().split())
ans={}
dic={}
for i in range(len(l1)-1,-1,-1):
    dic[l1[i]]=ans
    ans=copy.deepcopy(dic)
    dic={}
print(ans)
# Code By Phoenix_ZH

差集

直接使用集合内置函数difference，然后输出答案，注意：一定要先排序在输出，因为set本身是无序的，并且测试机没有special judge。

s1=set(input().split())
s2=set(input().split())
ans=list(s1.difference(s2))
ans.sort()#需要从小到大排序，set本身无序
for it in ans:
    print(it,end=' ')
# Code By Phoenix_ZH

生成字典Ⅰ

直接创建字典，然后键值成对赋值即可。

n=int(input())
dic=dict()
for i in range(1,n+1):
    dic[i]=i*i
print(dic)

# Code By Phoenix_ZH

字典相加

先得到一个总列表，然后逐个加入字典，如果该键不存在就增加该新的键/值对，如果该键存在那就叠加value的值，最后输出字典。

l1=list(input().split(','))
l2=list(input().split(','))
dic=dict()
l1+=l2
for it in l1:
    x=it.split(':')
    if(x[0] in dic):
        dic[x[0]]+=int(x[1])
    else:
        dic[x[0]]=int(x[1])
print(dic)
# Code By Phoenix_ZH

对称差集

方法一：直接用symmetric_difference函数得到对称差集，最后转换成列表并且排序。

s1=set(input().split())
s2=set(input().split())
s3=list(s1.symmetric_difference(s2))
s3.sort()
print(' '.join(s3))

方法二：并集-交集，最后转换成列表并且排序。

s1=set(input().split())
s2=set(input().split())
s3=s1.union(s2)
s4=s1.intersection(s2)
s3=list(s3-s4)
s3.sort()
print(' '.join(s3))

并集

直接使用union函数，最后转换成列表并且排序。

s1=set(input().split())
s2=set(input().split())
ans=list(s1.union(s2))
ans.sort()
print(' '.join(ans))
# Code By Phoenix_ZH

交集

直接使用intersection函数，最后转换成列表并且排序。

s1=set(input().split())
s2=set(input().split())
ans=list(s1.intersection(s2))
ans.sort()
print(' '.join(ans))
# Code By Phoenix_ZH

字典排序

创建字典并且添加键值对，然后使用sorted函数，分别以字典元素对中第二个元素排序、第一个元素排序。

d1={}
while(1):
    s=input()
    if(s==''):
        break
    x=s.split()
    d1[x[0]]=x[1]
ans=sorted(d1.items(),key=lambda x:(x[1]))
print(ans)
ans=sorted(d1.items(),key=lambda x:(x[0]),reverse=True)
print(ans)
'''
语文 89
数学 91
英语 93
生物 77
地理 86
历史 85
'''
# Code By Phoenix_ZH

字典最大最小值

创建一个字典，线性访问列表，并且更新maxx和minn，如果字典不存在该键则加入，最后输出maxx和minn。

l=list(input().split(','))
dic={}
minn,maxx=1e9,-1e9
for it in l:
    x=it.split(':')
    maxx,minn=max(maxx,int(x[1])),min(minn,int(x[1]))
    if(x[0] in dic):
        continue
    else:
        dic[x[0]]=x[1]
print(maxx,minn)
'''
a:500,b:5874,c:560
'''
# Code By Phoenix_ZH

生成字典Ⅱ

将键和值分别存到l1和l2中，然后向字典中加入键值对，其实也可以使用zip函数。

l1=list(input().split())
l2=list(input().split())
dic={}
for i in range(len(l1)):
    dic[l1[i]]=l2[i]
print(dic)
# Code By Phoenix_ZH