这是一个MIT课程“Introductionto Computational Thinking and Data Science”的学习笔记。
学习该课程的前提条件是：能够使用 Python 进行面向对象编程（最好是 Python3.5）
熟悉计算复杂性理论的概念
熟悉一些简单的算法
前几次课的主题是计算模型（computational models）：我们如何通过计算来理解现实世界？
什么是模型？它就像是一个设备帮助我们理解过去发生的事情（可以这么说：建一个模型来解释我们看见的现象）或者预测未来；例如气候模型，我们可以建一个气候模型来解释气候规律并预测未来的气候。
我们将学习三种模型：优化模型（optimization models）
统计模型（statisticalmodels）
仿真模型（simulationmodels）
Optimization Models 的概念：
优化模型其实就是一个求最大值或者最小值的目标函数；
举个例子：我想找出一个从纽约到波士顿的旅程时间最短的交通方式（汽车、飞机或者火车），这时我的目标函数就是花在交通上时间。
然后我们通常会给目标函数一些限制（限制也可以为空）；
接上上一个例子，时间最短的交通方式毫无疑问是飞机，但是我只有一百美元，所以飞机这个选项只能被移除。
具体的优化问题——背包问题（knapsack problem）
背包问题经常用在窃贼偷东西的情境，窃贼的背包只能装下有限的东西，如何取舍才能装走最有价值的东西就是一个目标函数。
他有两种情况： 0/1 背包问题（举个例子就是，我拿走一整个金条或者不拿）
部分背包问题 （这种情况就是把金条磨成粉，我可以拿一部分的金条）
部分背包问题有点无聊，你可以全部装最有价值的那个东西直到背包装满，如果最值钱的装完了背包还有空间，那就可以装第二值钱的；0/1背包问题会复杂得多，因为你每一次选择都会影响你未来的选择。
接下来看一个具体的例子（0/1背包问题）
假设允许你吃1500卡路里的食物，有一些选择：沙拉、冰淇淋、意面、三明治等，选择其中一些食物并且加起来不能超过1500ka，如果你已经吃了1480ka，那你不能再吃其他的了。所以你每做一个选择都会影响可能的结果，这就是贪心算法（greedy algorithm），他不会给你最好的答案。
来看一下它的数据结构：每一项都有两个值<value, weight>
背包能容纳的项的总量（weight）不能超过w
一个长度为n的矢量L，其中每个元素都代表一项
一个长度为n的矢量V，每个元素代表是否选取这一项，V[i] = 1，选取i项，V[i] = 0，则不选取。
我们的目的是要找到一个V能够使得 value 最大：
同时要满足最大限制：
最暴力的方法是列举出所有的组合并一一计算其value值，然后找出最大的，这时候的算法复杂度是指数阶的，耗时巨大；我们选用贪心算法，只要背包没有满，每次都选择最好的那一项，最好这个指标根据算法设计者而定，可以是 value 值最大的，也可以是最便宜的等等。
现在我们有一个菜单
| Food | wine | beer | pizza | burger | fries | coke | apple | donut |
| Value | 89 | 90 | 30 | 50 | 90 | 79 | 90 | 10 |
| calories | 123 | 154 | 258 | 354 | 365 | 150 | 95 | 195 |
现在我们用之前提到的数据结构来编写一个 Food 类（包括 getValue、getCost、density 方法）：
给每一个 food 一个 name、value 和 calories 初始化每个对象
class Food(object):
def __init__(self, n, v, w):
self.name = n
self.value = v
self.calories = w
def getValue(self):
return self.value
def getCost(self):
return self.calories
def density(self):
return self.getValue()/self.getCost()
def __str__(self):
return self.name + ': <' + str(self.value)\
+ ', ' + str(self.calories) + '>'编写一个 Menu List：
def buildMenu(names, values, calories):
"""names, values, calories lists of same length.
name a list of strings
values and calories lists of numbers
returns list of Foods"""
menu = []
for i in range(len(values)):
menu.append(Food(names[i], values[i],
calories[i]))
return menu接下来是贪心算法函数，其中的传入的一个参数 keyfunction 使得该算法具有一定的灵活度，这个函数的作用是对应你所传入的一串对象的某个数值，然后你可以通过 sorted 函数根据这个数值进行排序，你可以选择任何一个你想要排序的指标，本文在 testGreedy 函数中使用了 value 属性、calories 的倒数（lambda构造的就是calories的倒数）以及 density 属性三个指标进行测试：
def greedy(items, maxCost, keyFunction):
"""Assumes items a list, maxCost >= 0,
keyFunction maps elements of items to numbers"""
itemsCopy = sorted(items, key = keyFunction,
reverse = True)
result = []
totalValue, totalCost = 0.0, 0.0
for i in range(len(itemsCopy)):
if (totalCost+itemsCopy[i].getCost()) <= maxCost:
result.append(itemsCopy[i])
totalCost += itemsCopy[i].getCost()
totalValue += itemsCopy[i].getValue()
return (result, totalValue)
def testGreedys(foods, maxUnits):
print('Use greedy by value to allocate', maxUnits,
'calories')
testGreedy(foods, maxUnits, Food.getValue)
print('\nUse greedy by cost to allocate', maxUnits,
'calories')
testGreedy(foods, maxUnits,
lambda x: 1/Food.getCost(x))
print('\nUse greedy by density to allocate', maxUnits,
'calories')
testGreedy(foods, maxUnits, Food.density)现在我们来看一下这个算法的效率：
首先是 sorted 函数，Python 使用了 timsort 排序算法，它的复杂度和合并算法一样都是 nlogn ；
接下来是一个循环，循环次数是食物列表的长度，复杂度为 n ；
所以该算法的复杂度为 nlogn + n ，也就是 nlogn ，还是挺高效的。
最后我们来运行一下：
names = ['wine', 'beer', 'pizza', 'burger', 'fries',
'cola', 'apple', 'donut', 'cake']
values = [89,90,95,100,90,79,50,10]
calories = [123,154,258,354,365,150,95,195]
foods = buildMenu(names, values, calories)
testGreedys(foods, 1000)