|
|
李奇 2005200123
|
|
|
倪梓乘 2005200206
|
|
|
周文 2005200228
|
|
|
|
|
|
1. 答：
|
|
|
推荐系统的目标在信息过载的时代根据用户的历史数据找到用户感兴趣的物品，进而实现个性化推荐。推荐算法的本质是通过一定的方式将用户和物品联系起来推荐系统的应用广泛，比如网易云音乐的音乐推荐，Netflix的电影推荐，Amazon的商品推荐等等。
|
|
|
协同过滤 Collaborative Filtering
|
|
|
|
|
|
基于物品的推荐(Item-based)
|
|
|
适合Amanzon等电商平台，用户的数量往往大大超过物品的数量，同时物品的数据相对稳定，因此计算物品的相似度不但计算量较小，同时也不必频繁更新。
|
|
|
基于物品的 CF 的原理和基于用户的 CF 类似，只是在计算邻居时采用物品本身，而不是从用户的角度，即基于用户对物品的偏好找到相似的物品，然后根据用户的历史偏好，推荐相似的物品给他。从计算的角度看，就是将所有用户对某个物品的偏好作为一个向量来计算物品之间的相似度，得到物品的相似物品后，根据用户历史的偏好预测当前用户还没有表示偏好的物品，计算得到一个排序的物品列表作为推荐。
|
|
|
下图给出了一个例子，对于物品 A，根据所有用户的历史偏好，喜欢物品 A 的用户都喜欢物品 C，得出物品 A 和物品 C 比较相似，而用户 C 喜欢物品 A，那么可以推断出用户 C 可能也喜欢物品 C。
|
|
|
|
|
|
|
|
|
基于用户的推荐(User-based) 适合社交网络
|
|
|
基于用户对物品的偏好找到相邻邻居用户，然后将邻居用户喜欢的推荐给当前用户。计算上，就是将一个用户对所有物品的偏好作为一个向量来计算用户之间的相似度，找到 K 邻居后，根据邻居的相似度权重以及他们对物品的偏好，预测当前用户没有偏好的未涉及物品，计算得到一个排序的物品列表作为推荐。
|
|
|
下图给出了一个例子，对于用户 A，根据用户的历史偏好，这里只计算得到一个邻居 - 用户 C，然后将用户 C 喜欢的物品 D 推荐给用户 A。
|
|
|
|
|
|
其中相似性的度量可以是皮尔逊相关系数、余弦相似度、欧氏距离等等。
|
|
|
2. 答：
|
|
|
1-插入排序
|
|
|
描述
|
|
|
插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：
|
|
|
第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。
|
|
|
def insert_sort(lists):
|
|
|
# 插入排序
|
|
|
count = len(lists)
|
|
|
for i in range(1, count):
|
|
|
key = lists[i]
|
|
|
j = i - 1
|
|
|
while j >= 0:
|
|
|
if lists[j] > key:
|
|
|
lists[j + 1] = lists[j]
|
|
|
lists[j] = key
|
|
|
j -= 1
|
|
|
return lists
|
|
|
2-希尔排序
|
|
|
描述
|
|
|
希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。
|
|
|
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
|
|
|
'''
|
|
|
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
|
|
|
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
|
|
|
'''def shell_sort(lists):
|
|
|
# 希尔排序
|
|
|
count = len(lists)
|
|
|
step = 2
|
|
|
group = count / step
|
|
|
while group > 0:
|
|
|
for i in range(0, group):
|
|
|
j = i + group
|
|
|
while j < count:
|
|
|
k = j - group
|
|
|
key = lists[j]
|
|
|
while k >= 0:
|
|
|
if lists[k] > key:
|
|
|
lists[k + group] = lists[k]
|
|
|
lists[k] = key
|
|
|
k -= group
|
|
|
j += group
|
|
|
group /= step
|
|
|
return lists
|
|
|
1516
|
|
|
3-冒泡排序
|
|
|
描述
|
|
|
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
|
|
|
def bubble_sort(lists):
|
|
|
# 冒泡排序
|
|
|
count = len(lists)
|
|
|
for i in range(0, count):
|
|
|
for j in range(i + 1, count):
|
|
|
if lists[i] > lists[j]:
|
|
|
lists[i], lists[j] = lists[j], lists[i]
|
|
|
return lists8
|
|
|
4-快速排序
|
|
|
描述
|
|
|
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
|
|
|
'''
|
|
|
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
|
|
|
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
|
|
|
'''def quick_sort(lists, left, right):
|
|
|
# 快速排序
|
|
|
if left >= right:
|
|
|
return lists
|
|
|
key = lists[left]
|
|
|
low = left
|
|
|
high = right
|
|
|
while left < right:
|
|
|
while left < right and lists[right] >= key:
|
|
|
right -= 1
|
|
|
lists[left] = lists[right]
|
|
|
while left < right and lists[left] <= key:
|
|
|
left += 1
|
|
|
lists[right] = lists[left]
|
|
|
lists[right] = key
|
|
|
quick_sort(lists, low, left - 1)
|
|
|
quick_sort(lists, left + 1, high)
|
|
|
return lists
|
|
|
22
|
|
|
5-直接选择排序
|
|
|
描述
|
|
|
基本思想：第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。
|
|
|
def select_sort(lists):
|
|
|
# 选择排序
|
|
|
count = len(lists)
|
|
|
for i in range(0, count):
|
|
|
min = i
|
|
|
for j in range(i + 1, count):
|
|
|
if lists[min] > lists[j]:
|
|
|
min = j
|
|
|
lists[min], lists[i] = lists[i], lists[min]
|
|
|
return lists0
|
|
|
6-堆排序
|
|
|
描述
|
|
|
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
|
|
|
'''
|
|
|
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
|
|
|
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
|
|
|
'''def adjust_heap(lists, i, size):
|
|
|
lchild = 2 * i + 1
|
|
|
rchild = 2 * i + 2
|
|
|
max = i
|
|
|
if i < size / 2:
|
|
|
if lchild < size and lists[lchild] > lists[max]:
|
|
|
max = lchild
|
|
|
if rchild < size and lists[rchild] > lists[max]:
|
|
|
max = rchild
|
|
|
if max != i:
|
|
|
lists[max], lists[i] = lists[i], lists[max]
|
|
|
adjust_heap(lists, max, size)
|
|
|
def build_heap(lists, size):
|
|
|
for i in range(0, (size/2))[::-1]:
|
|
|
adjust_heap(lists, i, size)
|
|
|
def heap_sort(lists):
|
|
|
size = len(lists)
|
|
|
build_heap(lists, size)
|
|
|
for i in range(0, size)[::-1]:
|
|
|
lists[0], lists[i] = lists[i], lists[0]
|
|
|
adjust_heap(lists, 0, i)
|
|
|
7
|
|
|
7-归并排序
|
|
|
描述
|
|
|
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
|
|
|
归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
|
|
|
'''
|
|
|
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
|
|
|
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
|
|
|
'''def merge(left, right):
|
|
|
i, j = 0, 0
|
|
|
result = []
|
|
|
while i < len(left) and j < len(right):
|
|
|
if left[i] <= right[j]:
|
|
|
result.append(left[i])
|
|
|
i += 1
|
|
|
else:
|
|
|
result.append(right[j])
|
|
|
j += 1
|
|
|
result += left[i:]
|
|
|
result += right[j:]
|
|
|
return result
|
|
|
def merge_sort(lists):
|
|
|
# 归并排序
|
|
|
if len(lists) <= 1:
|
|
|
return lists
|
|
|
num = len(lists) / 2
|
|
|
left = merge_sort(lists[:num])
|
|
|
right = merge_sort(lists[num:])
|
|
|
return merge(left, right)
|
|
|
26
|
|
|
8-基数排序
|
|
|
描述
|
|
|
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog®m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。
|
|
|
import mathdef radix_sort(lists, radix=10):
|
|
|
k = int(math.ceil(math.log(max(lists), radix)))
|
|
|
bucket = [[] for i in range(radix)]
|
|
|
for i in range(1, k+1):
|
|
|
for j in lists:
|
|
|
bucket[j/(radix**(i-1)) % (radix**i)].append(j)
|
|
|
del lists[:]
|
|
|
for z in bucket:
|
|
|
lists += z
|
|
|
del z[:]
|
|
|
return lists
|
|
|
|
|
|
3.答
|
|
|
Web 应用开发
|
|
|
在因大数据、人工智能为人所熟知之前，Python 就已经在 Web 开发领域被广泛使用，产生了 Django、Flask、Tornado 等 Web 开发框架。得益于其简洁的语法和动态语言特性，Python 的开发效率很高，因而深受创业团队的青睐。
|
|
|
一些将 Python 作为主要开发语言的知名互联网企业/产品：
|
|
|
豆瓣
|
|
|
知乎
|
|
|
果壳网
|
|
|
Instagram
|
|
|
Quora
|
|
|
Dropbox
|
|
|
Reddit
|
|
|
由于后台服务器的通用性，除了狭义的网站之外，很多 App 和游戏的服务器端也同样用 Python 实现。
|
|
|
自动化运维
|
|
|
在 Web 开发领域，Python 只是众多语言选择之一；但在自动化运维领域，Python 则是必备技能。灵活的功能和丰富的类库使其成为运维工程师的首选语言。大量自动化运维工具和平台或以 Python 开发，或提供 Python 的配置接口。单从 Linux 内置 Python 这一点来看也足见其在服务器和运维领域的地位。
|
|
|
因此很多公司虽然核心业务不是使用 Python，但在管理系统、运维等方面也大量使用。比如 Facebook 工程师维护了上千个 Python 项目，包括基础设施管理、广告 API 等。
|
|
|
网络爬虫
|
|
|
也叫网络蜘蛛，是指从互联网采集数据的程序脚本。对于很多数据相关公司来说，爬虫和反爬虫技术都是其赖以生存的重要保障。尽管很多语言都可以编写爬虫，但灵活的 Python 无疑也是当前的首选。基于 Python 的爬虫框架 Scrapy 也很受欢迎。
|
|
|
这个星球上最大的“爬虫”公司 -- Google 一直力推 Python，不仅在公司内部大量使用 Python，也为开发社区做了巨大贡献。就连 Python 之父 Guido van Rossum 也曾在 Google 工作七年。
|
|
|
数据分析
|
|
|
当通过爬虫获取了海量数据之后，需要对数据进行清洗、去重、存储、展示、分析，在这方面 Python 有许多优秀的类库：NumPy、Pandas、Matplotlib 可以让你的数据分析工作事半功倍。
|
|
|
科学计算
|
|
|
虽然 Matlab 在科学计算领域有着不可取代的地位，但 Python 作为一门通用的编程语言，可以带来更广泛的应用和更丰富的类库。NumPy、SciPy、BioPython、SunPy 等类库在生物信息、地理信息、数学、物理、化学、建筑等领域发挥着重要作用。
|
|
|
而大名鼎鼎的 NASA 也早已把 Python 作为主要开发语言。
|
|
|
人工智能
|
|
|
Python 在人工智能大范畴领域内的数据挖掘、机器学习、神经网络、深度学习等方面都是主流的编程语言，得到广泛的支持和应用。
|
|
|
机器学习：Scikit-learn
|
|
|
自然语言处理：NLTK
|
|
|
深度学习：Keras、Google 的 TensorFlow、Facebook 的 PyTorch、Amazon 的 MxNet
|
|
|
这些已经占据业内主流的工具要么是用 Python 开发，要么也提供了 Python 版本。Python 无疑已成为 AI 领域的必修语言。
|
|
|
胶水语言
|
|
|
Python 简洁、灵活、通用，几乎可以在各种场景与各种平台、设备、语言进行连接，因此被称为胶水语言。有人把它比作小巧而又多功能的瑞士军刀。除了上面提到的，在其他领域也常常见到 Python 的身影：
|
|
|
金融：大量金融分析和量化交易工具使用 Python 作为的开发脚本语言
|
|
|
游戏：一些引擎使用 Python 作为开发脚本，比较有名的游戏有《文明》系列、网易的《阴阳师》
|
|
|
桌面应用：虽然不算主流，但 PyQT、wxPython、Tkinter 等 GUI 库也足以应付一般的桌面程序
|
|
|
|
|
|
|
