1.矩阵乘法np.dot()及np.multiply()以及*
- 同线性代数中矩阵乘法的定义： np.dot()
np.dot(A, B)：对于二维矩阵，计算真正意义上的矩阵乘积（仍是矩阵），同线性代数中矩阵乘法的定义。
对于一维矩阵，计算两者的内积。
见如下Python代码：
import numpy as np
# 2-D array: 2 x 3
two_dim_matrix_one = np.array([[1, 2, 3], [4, 5, 6]])
# 2-D array: 3 x 2
two_dim_matrix_two = np.array([[1, 2], [3, 4], [5, 6]])
two_multi_res = np.dot(two_dim_matrix_one, two_dim_matrix_two)
print('two_multi_res: %s' %(two_multi_res))
#1-D array
one_dim_vec_one = np.array([1, 2, 3])
one_dim_vec_two = np.array([4, 5, 6])
one_result_res = np.dot(one_dim_vec_one, one_dim_vec_two)
print('one_result_res: %s' %(one_result_res))
结果如下：
two_multi_res: [[22 28]
[49 64]]
one_result_res: 32
- 对应元素相乘(乘出来是矩阵) element-wise product: np.multiply(), 或 *
在Python中，实现对应元素相乘，有2种方式，一个是np.multiply()，另外一个是*,这种方式要求两个矩阵的的形状shape相同。见如下Python代码：
import numpy as np
# 2-D array: 2 x 3
two_dim_matrix_one = np.array([[1, 2, 3], [4, 5, 6]])
another_two_dim_matrix_one = np.array([[7, 8, 9], [4, 7, 1]])
# 对应元素相乘 element-wise product
element_wise = two_dim_matrix_one * another_two_dim_matrix_one
print('element wise product: %s' %(element_wise))
# 对应元素相乘 element-wise product
element_wise_2 = np.multiply(two_dim_matrix_one, another_two_dim_matrix_one)
print('element wise product: %s' % (element_wise_2))
结果如下：
element wise product: [[ 7 16 27]
[16 35 6]]
element wise product: [[ 7 16 27]
[16 35 6]]
2.argsort（）函数
简单说，就是把数组值从小到大的索引值输出来
看两个例子就懂了
One dimensional array:一维数组
a = array([9, 8, 7, 6, 5, 4, 3, 1, 2])
print(a.argsort())
结果
[7, 8, 6, 5, 4, 3, 2, 1, 0]
数组a最小的数字是1，其索引为7，所以输出数组第一个元素为7；第二小的数字是2，其索引为8，所以输出数组第二个元素为8，以此类推。
注意函数输出结果是索引值
Two-dimensional array:二维数组
x = np.array([[0, 3],
[2, 2]])
shape结果为(2,2)
axis=0即按第一维度排序（元素有2组）
即对两组元素进行排序(组与组比较)
x = np.array([[0, 3],
[2, 2]])
np.argsort(x, axis=0)
结果([[0, 1],
[1, 0]])
axis=1即按第二维度排序（每组有2个元素）
即对每组2个元素进行排序（组内比较）
np.argsort(x, axis=1)
结果([[0, 1],
[0, 1]])
3维数组
再举一个三维数组的例子（在应用方面三维数组比较少用，这里只是为了充分说明axis参数的作用）
b = array([[[0, 1, 2, 0, 1, 2], [1, 6, 3, 2, 5, 7]],
[[0, 1, 2, 0, 1, 2], [8, 9, 1, 0, 2, 4]]])
print('{0}\n'.format(b.shape))
print('{0}\n'.format(b.argsort())) //①
print('{0}\n'.format(b.argsort(axis=0))) //②
print('{0}\n'.format(b.argsort(axis=1))) //③
print('{0}\n'.format(b.argsort(axis=2))) //④
结果
(2, 2, 6)
[[[0, 3, 1, 4, 2, 5],
[0, 3, 2, 4, 1, 5]],
[[0, 3, 1, 4, 2, 5],
[3, 2, 4, 5, 0, 1]]]
[[[0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 1]],
[[1, 1, 1, 1, 1, 1],
[1, 1, 0, 0, 0, 0]]]
[[[0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1]],
[[0, 0, 1, 0, 0, 0],
[1, 1, 0, 1, 1, 1]]]
[[[0, 3, 1, 4, 2, 5],
[0, 3, 2, 4, 1, 5]],
[[0, 3, 1, 4, 2, 5],
[3, 2, 4, 5, 0, 1]]]
①不带参数，�此时我们在最深维度（第三维度），根据shape函数可知，有6个元素，所以我们要对每组的6个元素进行排序
②axis=0，此时我们在第一维度，�根据shape函数可知，有2个元素，所以我们要对每组的2个元素进行排序
③axis=1，此时我们在第二维度，根据shape函数可知，有2个元素，所以要对每组的2个元素进行排序
④axis=2，与①同
get()函数作用
以classCount.get(voteIlabel,0)为例：
classCount{}
for i in range(k):
voteIlabel=labels[sortedDistIndicies[i]]
classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1；
label中标签出现时，若第一次出现，则初始化置0，并执行+1；；表示其出现一次，当第二次出现时，则初始化失效，只需执行+1即可；
classCount.get(voteIlabel,0)返回字典classCount中voteIlabel元素对应的值,若无，则进行初始化....
当字典中有voteIlabel元素时，classCount.get(voteIlabel,0)作用是返回该元素对应的值，即0
若不存在voteIlabel，则字典classCount中生成voteIlabel元素，并使其对应的数字为0，即
classCount = {voteIlabel：0}
此时classCount.get(voteIlabel,0)作用是检测并生成新元素，括号中的0只用作初始化，之后再无作用（即再次出现这个标签时不再初始化，只执行+1即可）
items(） 函数
字典的items()方法和iteritems()方法，是python字典的内建函数，分别会返回Python列表和迭代器。
python字典的items方法作用：是可以将字典中的所有项，以列表方式返回。因为字典是无序的，所以用items方法返回字典的所有项，也是没有顺序的。
python字典的iteritems方法作用：与items方法相比作用大致相同，只是它的返回值不是列表，而是一个迭代器。
字典items()操作方法：
>>> x = {'title':'python web site','url':'www.iplaypy.com'}
>>> x.items()
[('url', 'www.iplaypy.com'), ('title', 'python web site')]
从结果中可以看到，items()方法是将字典中的每个项分别做为元组，添加到一个列表中，形成了一个新的列表容器。如果有需要也可以将返回的结果赋值给新变量，这个新的变量就会是一个列表数据类型。
>>> a=x.items()
>>> a
[('url', 'www.iplaypy.com'), ('title', 'python web site')]
>>> type(a)
<type 'list'>
以书中代码为例
classCount={}
for i in range(k):
voteIlabel = labels[sortedDistIndicies[i]]
classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
print(classCount[voteIlabel])
print(classCount.items())
输出字典 dict_items([('B', 2), ('A', 1)])
operator.itemgetter函数
operator模块提供的itemgetter函数用于获取对象的哪些维的数据，参数为一些序号（即需要获取的数据在对象中的序号），下面看例子。
a = [1,2,3]
b=operator.itemgetter(1) //定义函数b，获取对象的第1个域的值>
print b(a) //2
b=operator.itemgetter(1,0) //定义函数b，获取对象的第1个域和第0个的值
print b(a) //(2, 1)
要注意，operator.itemgetter函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值。
用 operator 函数进行多级排序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10),]
>>> sorted(students, key=itemgetter(1,2)) # sort by grade then by age
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
## 对字典排序
>>> d = {'data1':3, 'data2':1, 'data3':2, 'data4':4}
>>> sorted(d.iteritems(), key=itemgetter(1), reverse=True)
[('data4', 4), ('data1', 3), ('data3', 2), ('data2', 1)]
sorted和sort 函数
sort() 是Python列表的一个内置的排序方法，list.sort() 方法排序时直接修改原列表，返回None；
sorted() 是Python内置的一个排序函数，它会从一个迭代器返回一个排好序的新列表。
相比于 sort()，sorted() 使用的范围更为广泛，但是如果不需要保留原列表，sort更有效一点。另外，sort() 只是列表的一个方法，只适用于列表，而sorted() 函数接受一切迭代器，返回新列表。
两者的函数形式分别如下（Python3.5.2）：
sorted(iterable[, key][, reverse])
list.sort(*, key=None, reverse=None)
这两个方法有以下 2 个共同的参数：
1.key 是带一个参数的函数，返回一个值用来排序，默认为 None。这个函数只调用一次，所以fast。
2.reverse 表示排序结果是否反转
看例子：
>>> a = (1,2,4,2,3) # a 是元组，故不能用sort() 排序
>>> a.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'sort'
>>> sorted(a) # sorted() 可以为元组排序，返回一个新有序列表
[1, 2, 2, 3, 4]
>>> a=['1',1,'a',3,7,'n']
>>> sorted(a)
[1, 3, 7, '1', 'a', 'n']
>>> a # sorted() 不改变原列表
['1', 1, 'a', 3, 7, 'n']
>>> print a.sort()
None
>>> a # a.sort()直接修改原列表
[1, 3, 7, '1', 'a', 'n']
因此如果实际应用过程中需要保留原有列表，使用 sorted() 函数较为适合，否则可以选 择 sort() 函数，因为 sort() 函数不需要复制原有列表，消耗的内存较少，效率也较高。
sorted() 函数功能非常强大，它可以方便地针对不同的数据结构进行排序，从而满足不同需求。例子如下：
对字典进行排序
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}) # 根据字典键排序
[1, 2, 3, 4, 5]
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}.values()) # 根据字典值排序
['A', 'B', 'B', 'D', 'E']
对多维列表排序
>>> student_tuples = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10)]
>>> sorted(student_tuples, key = lambda student: student[0]) # 对姓名排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> sorted(student_tuples, key = lambda student: student[2]) # 年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
调用operator模块中的 itemgetter() 可以实现根据多个参数排序：
>>> sorted(student_tuples, key = itemgetter(2)) # 根据年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> sorted(student_tuples, key = itemgetter(1, 2)) # 根据成绩和年龄排序
[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
>>> sorted(student_tuples, key = itemgetter(1, 2), reverse=True) # 反转排序结果(本身从小到大，反转则从大到小)
从第一个域排序由大到小，BBA；；从第二个域排则B12,B10,A15
[('jane', 'B', 12), ('dave', 'B', 10), ('john', 'A', 15)]
ps: itemgetter 返回一个函数，实现取元素的功能。比如
f = itemgetter(2)，调用 f(r) 返回 r[2];
f = itemgetter(2, 5, 3)，调用 f(r) 返回元组 (r[2], r[5], r[3]).
