本节书摘来自异步社区《Python极客项目编程 》一书中的第1章，第1.3节，作者 [美] Mahesh Venkitachalam，王海鹏 译，更多章节内容可以访问云栖社区“异步社区”公众号查看。

1.3　代码

该项目的目标是找到你的音乐收藏中的重复乐曲，确定播放列表之间共同的音轨，绘制音轨时长的分布图，以及歌曲评分和时长之间的关系图。

随着音乐收藏不断增加，你总会遇到重复的乐曲。为了确定重复的乐曲，查找与Tracks键关联的字典中的名称（前面讨论过），找到重复的乐曲，并用音轨长度作为附加准则来检测重复的乐曲，因为名称相同、但长度不同的音轨，可能是不一样的。

要找到两个或多个播放列表之间共同的音轨，你需要将音乐收藏导出为播放列表文件，收集每个播放列表的音轨名称，作为集合进行比较，通过发现集合的交集来找到共同的音轨。

在收集音乐收藏数据的同时，我们将使用强大的matplotlib（http://matplotlib.org/） 绘图软件包来创建一些图，该软件包由已故的John Hunter开发。我们可以绘制直方图来显示音轨时长的分布，绘制散点图来比较乐曲评分与长度。

要查看完整的项目代码，请直接跳到1.4节。

1.3.1　查找重复

首先可以用findDuplicates()方法来查找重复的曲目，如下所示：

　 def findDuplicates(fileName):
　     print('Finding duplicate tracks in %s...' % fileName)
　     # read in a playlist
   1  plist = plistlib.readPlist(fileName)
　     # get the tracks from the Tracks dictionary
    2tracks = plist['Tracks']
　     # create a track name dictionary
  3   trackNames = {}
　     # iterate through the tracks
  4   for trackId, track in tracks.items():
　         try:
      5      name = track['Name']
　             duration = track['Total Time']
　             # look for existing entries
    6         if name in trackNames:
　                 # if a name and duration match, increment the count
　                 # round the track length to the nearest second
      7           if duration//1000 == trackNames[name][0]//1000:
　                     count = trackNames[name][1]
        8             trackNames[name] = (duration, count+1)
　             else:
　                 # add dictionary entry as tuple (duration, count)
                trackNames[name] = (duration, 1)
　    9     except:
　             # ignore
　             pass

在1行，readPlist()方法接受一个p-list文件作为输入，并返回顶层字典。在2行，访问Tracks字典，在3行，创建一个空的字典，用来保存重复的乐曲。在4行，开始用items()方法迭代Tracks字典，这是Python在迭代字典时取得键和值的常用方法。

在5行，取得字典中每个音轨的名称和时长。用in关键字，检查当前乐曲的名称是否已在被构建的字典中6。如果是这样的，程序检查现有的音轨和新发现的音轨长度是否相同7，用//操作符，将每个音轨长度除以1000，由毫秒转换为秒，并四舍五入到最接近的秒，以进行检查（当然，这意味着，只有毫秒差异的两个音轨被认为是相同的）。如果确定这两个音轨长度相等，就取得与name关联的值，这是（duration，count）元组，并在8行增加计数。如果这是程序第一次遇到的音轨名称，就创建一个新条目，count为1。9

将代码的主for循环放在try语句块中，这是因为一些乐曲音轨可能没有定义乐曲名称。在这种情况下，跳过该音轨，在except部分只包含pass（什么也不做）。

1.3.2　提取重复

利用以下代码，提取重复的音轨：

　     # store duplicates as (name, count) tuples
1     dups = []
　     for k, v in trackNames.items():
2     if v[1] > 1:
　             dups.append((v[1], k))
　     # save duplicates to a file
3     if len(dups) > 0:
　         print("Found %d duplicates. Track names saved to dup.txt" % len(dups))
　     else:
　         print("No duplicate tracks found!")
4    f = open("dups.txt", "w")
　     for val in dups:
5         f.write("[%d] %s\n" % (val[0], val[1]))
　     f.close()

在1行，创建一个空列表，保存重复乐曲。接下来，迭代遍历trackNames字典，如果count（用v[1]访问，因为它是元组的第二个元素）大于1 2，则将元组（name，count）添加到列表中。在3行，程序打印它找到的信息，然后用open()方法将信息存入文件4。在5行，迭代遍历dups列表，写下重复的条目。

1.3.3　查找多个播放列表*同的音轨

现在，让我们来看看如何找到多个播放列表*同的乐曲音轨：

　 def findCommonTracks(fileNames):
　     # a list of sets of track names
1     trackNameSets = []
　     for fileName in fileNames:
　         # create a new set
2         trackNames = set()
　         # read in playlist
3         plist = plistlib.readPlist(fileName)
　         # get the tracks
　         tracks = plist['Tracks']
　         # iterate through the tracks
　         for trackId, track in tracks.items():
　             try:
　                 # add the track name to a set
4                trackNames.add(track['Name'])
　         except:
　             # ignore
　             pass
　     # add to list
5     trackNameSets.append(trackNames)
　     # get the set of common tracks
6     commonTracks = set.intersection(*trackNameSets)
　     # write to file
　     if len(commonTracks) > 0:
7         f = open("common.txt", "w")
　         for val in commonTracks:
　             s = "%s\n" % val
8            f.write(s.encode("UTF-8"))
　         f.close()
　         print("%d common tracks found. "
　               "Track names written to common.txt." % len(commonTracks))
　     else:
　         print("No common tracks!")

首先，将播放列表的文件名列表传入findCommonTracks()，它创建一个空列表1，保存从每个播放列表创建的一组对象。然后程序迭代遍历列表中的每个文件。对每个文件，创建一个名为trackNames的Python set对象2，然后像在findDuplicates()中一样，用plistlib读入文件3，取得Tracks字典。接下来，迭代遍历该字典中的每个音轨，并添加trackNames对象4。程序读完一个文件中的所有音轨后，将这个集合加入trackNameSets5。

在6行，使用set.intersection()方法来获得集合之间共同音轨的集合（用Python*的运算符来展开参数列表）。如果程序发现集合之间的共同音轨，就将音轨名称写入一个文件。在7行，打开文件，接下来的两行代码完成写入。使用encode()来格式化输出，确保所有Unicode字符都正确处理8。

1.3.4　收集统计信息

接下来，用plotStats()方法，针对这些音轨名称收集统计信息：

　 def plotStats(fileName):
　     # read in a playlist
1     plist = plistlib.readPlist(fileName)
　     # get the tracks from the playlist
　     tracks = plist['Tracks']
　     # create lists of song ratings and track durations
2    ratings = []
　     durations = []
　     # iterate through the tracks
　     for trackId, track in tracks.items():
　         try:
3         ratings.append(track['Album Rating'])
　             durations.append(track['Total Time'])
　         except:
　             # ignore
　             pass

　     # ensure that valid data was collected
4    if ratings == [] or durations == []:
　         print("No valid Album Rating/Total Time data in %s." % fileName)
　         return

这里的目标是收集评分和音轨时长，然后画一些图。在1行和接下来的代码行中，读取了播放列表文件，并访问Tracks字典。接下来，创建两个空列表，保存评分和时长2（在iTunes播放列表中，评分是一个整数，范围是[0，100]）。迭代遍历音轨，在3行，将评分和时长添加到相应的列表中。最后，在4行检查完整性，确保从播放列表文件收集了有效数据。

1.3.5　绘制数据

我们已准备好绘制一些数据了。

    # scatter plot
1     x = np.array(durations, np.int32)
　    # convert to minutes
2     x = x/60000.0
3     y = np.array(ratings, np.int32)
4     pyplot.subplot(2, 1, 1)
5    pyplot.plot(x, y, 'o')
6    pyplot.axis([0, 1.05*np.max(x), -1, 110])
7     pyplot.xlabel('Track duration')
8    pyplot.ylabel('Track rating')

　    # plot histogram
　    pyplot.subplot(2, 1, 2)
9    pyplot.hist(x, bins=20)
　    pyplot.xlabel('Track duration')
　    pyplot.ylabel('Count')

　    # show plot
10     pyplot.show()

在1行，利用numpy.array()（在代码中作为np导入），将音轨时长数据放到32位整数数组中。然后在2行，利用numpy，将一个操作应用于数组中的每个元素。在这个例子中，将每个以毫秒为单位的时长值除以值60×1000。在3行，将乐曲评分保存另一个numpy数组y中。

用matplotlib在同一图像上绘制两张图。在4行，提供给subplot()的参数（即，(2, 1, 1)）告诉matplotlib，该图应该有两行（2）一列（1），且下一个点应在第一行（1）。在5行，通过调用plot()创建一个点，并且o告诉matplotlib用圆圈来表示数据。

在6行，为x轴和y轴设置略微大一点儿的范围，以便在图和轴之间留一些空间。在7和8行，为x轴和y轴设置说明文字。

现在用matplotlib的方法hist()，在同一张图中的第二行中，绘制时长直方图9。bins参数设置了数据分区的个数，其中每分区用于添加在这个范围内的计数。最后，调用show()10，matplotlib在新窗口中显示出漂亮的图。

1.3.6　命令行选项

现在，我们来看看该程序的main()方法如何处理命令行参数：

　 def main():
　     # create parser
　     descStr = """
　     This program analyzes playlist files (.xml) exported from iTunes.
　     """
1     parser = argparse.ArgumentParser(description=descStr)
　     # add a mutually exclusive group of arguments
2     group = parser.add_mutually_exclusive_group()

　     # add expected arguments
3     group.add_argument('--common', nargs='*', dest='plFiles', required=False)
4     group.add_argument('--stats', dest='plFile', required=False)
5     group.add_argument('--dup', dest='plFileD', required=False)

　     # parse args
6     args = parser.parse_args()

　     if args.plFiles:
　         # find common tracks
　         findCommonTracks(args.plFiles)
　     elif args.plFile:
　         # plot stats
　         plotStats(args.plFile)
　     elif args.plFileD:
　         # find duplicate tracks
　         findDuplicates(args.plFileD)
　     else:
7        print("These are not the tracks you are looking for.")

本书的大多数项目都有命令行参数。不要尝试手工分析它们并搞得一团糟，要将这个日常的任务委派给Python的argparse模块。在1行，为此创建了一个ArgumentParser对象。该程序可以做三件不同的事情，如发现播放列表之间的共同音轨，绘制统计数据，或发现播放列表中重复的曲目。但是，一个时间程序只能做其中一件事，如果用户决定同时指定两个或多个选项，我们不希望它崩溃。argparse模块为这个问题提供了一个解决方案，即相互排斥的参数分组。在2行，用parser.add_mutually_exclusive_group()方法来创建这样一个分组。

在3、4和5行，指定了前面提到的命令行选项，并输入应该将解析值存入的变量名（args.plFiles、args.plFile和args.plFileD），实际解析在6行完成。参数解析后，就将它们传递给相应的函数，findCommonTracks()、plotStats()和findDuplicates()，本章前面讨论过这些函数。

要查看参数是否被解析，就测试args中相应的变量名。例如，如果用户没有使用--common选项（该选项找出播放列表之间的共同音轨），解析后args.plFiles应该设置为None。

在7行，处理用户未输入任何参数的情况。