cs231n------使用到的Python函数汇总

01 Assignment1

011 KNN

1.enumerate

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> for index,value in enumerate(seasons):
  print ('%s,%s' % (index,value))

0,Spring
1,Summer
2,Fall
3,Winter

2 numpy.flatnonzero

该函数的输入为矩阵，使用的方法有两种：
1.输出矩阵中非零元素的索引
2.输出矩阵中某特定元素的索引

>>> a=[1,2,3,4,5,3,2,3,1,2,4,0,0,0,0,0,0,0]
>>> b=np.array(a)
>>> np.flatnonzero(b)
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
>>> np.flatnonzero(b==3)
array([2, 5, 7])

3 numpy.random.choice

输入的参数 numpy.random.choice(a, size, repalce, p)
从a中以p的概率分布取size个，repalce表明有无放回
a可以是一维矩阵或者整数

>>> np.random.choice(5,3,replace=False,p=None)
array([2, 3, 1])
>>> np.random.choice(a,5,replace=False,p=None)
array([0, 0, 2, 0, 3])

关于random类的其它功能

4 range

输入的参数 range(start, stop, step)

>>> a=range(0,10,2)
>>> for i in range(len(a)):
	print(a[i])

	
0
2
4
6
8

5 shape

list是没有shape属性的，只有矩阵才有。

>>> a = [[1,1,1],
     [1,1,1]]
>>> b=np.array(a)
>>> b.shape
(2, 3)
>>> b.shape[0]
2
>>> b.shape[1]
3

6 numpy.reshape

输入参数 numpy.reshape(a, newshape, order)

a : 数组——需要处理的数据。

newshape : 新的格式——整数或整数数组，如(2,3)表示2行3列。新的形状应该与原来的形状兼容，即行数和列数相乘后等于a中元素的数量。如果是整数，则结果将是长度的一维数组，所以这个整数必须等于a中元素数量。若这里是一个整数数组，那么其中一个数据可以为-1。在这种情况下，这个个值python会自动从根据第二个数值和剩余维度推断出来。

order : 可选范围——{‘C’, ‘F’, ‘A’}。使用索引顺序读取a的元素，并按照索引顺序将元素放到变换后的的数组中。“C”指的是用类C写的读/索引顺序的元素，横着读，横着写，优先读/写一行。“F”是指用FORTRAN类索引顺序读/写元素，竖着读，竖着写，优先读/写一列。注意，“C”和“F”选项不考虑底层数组的内存布局，只引用索引的顺序。“A”竖着读，横着写。这里可能听起来有点模糊，下面会给出示例。如果不进行order参数的设置，默认为C。

z=np.array([[1, 2, 3, 4],[5, 6, 7, 8]])
print('原始数据：', z)

x=np.reshape(z,-1)
print('换成一行', x)

x1=np.reshape(z,(-1,1))
print('换成一列', x1)

y=np.reshape(z,(4,2))
print('换成4*2:', y) 

y=np.reshape(z,(4,2),order='F')
print('按列读取数据换成4*2:', y) 

结果：
原始数据： [[1 2 3 4]
[5 6 7 8]]
换成一行 [1 2 3 4 5 6 7 8]
换成一列 [[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]]
换成42: [[1 2]
[3 4]
[5 6]
[7 8]]
按列读取数据换成42: [[1 3]
[5 7]
[2 4]
[6 8]]

7 numpy.sum

a=[[1,2,3],[4,5,6]]

print(a)
c1=np.sum(a,axis=0)
c2=np.sum(a,axis=1)

print('按行压缩：',c1)
print('按列压缩：',c2)

结果：
[[1, 2, 3], [4, 5, 6]]
按行压缩： [5 7 9]
按列压缩： [ 6 15]

8 矩阵表示中的冒号：

x[m,:]表示m行的所有数据
x[:,n]表示n列的所有数据
x[:,m:n]表示m列到n-1列的所有数据，即含左不含右。

9numpy.argsort

argsort函数返回的是数组值从小到大的索引值

a=[[1,2,3],[4,5,6]]
b=[1,2,3,1,2,1,5,3,4,7,5,6,5,9,4,5,6]
b=np.array(b)

c1=np.argsort(b)
c11=b[c1]

c2=np.argsort(a,axis=0)
c3=np.argsort(a,axis=1)

print('一维数组的排序的索引',c1)
print('一维数组升序排序',c11)
print('二维按列排序的索引',c2)
print('二维数组按行排序的索引',c3)

结果：
一维数组的排序的索引 [ 0 3 5 1 4 2 7 14 8 10 12 6 15 11 16 9 13]
一维数组升序排序 [1 1 1 2 2 3 3 4 4 5 5 5 5 6 6 7 9]
二维按列排序的索引 [[0 0 0]
[1 1 1]]
二维数组按行排序的索引 [[0 1 2]
[0 1 2]]

10 numpy.bincout

numpy.bincount(x, weights=None, minlength=0)

# 我们可以看到x中最大的数为7，因此bin的数量为8，那么它的索引值为0->7
x = np.array([0, 1, 1, 3, 2, 1, 7])
# 索引0出现了1次，索引1出现了3次......索引5出现了0次......
np.bincount(x)
#因此，输出结果为：array([1, 3, 1, 1, 0, 0, 0, 1])

w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6])
# 我们可以看到x中最大的数为4，因此bin的数量为5，那么它的索引值为0->4
x = np.array([2, 1, 3, 4, 4, 3])
# 索引0 -> 0
# 索引1 -> w[1] = 0.5
# 索引2 -> w[0] = 0.3
# 索引3 -> w[2] + w[5] = 0.2 - 0.6 = -0.4
# 索引4 -> w[3] + w[4] = 0.7 + 1 = 1.7
np.bincount(x,  weights=w)
# 因此，输出结果为：array([ 0. ,  0.5,  0.3, -0.4,  1.7])

# 我们可以看到x中最大的数为3，因此bin的数量为4，那么它的索引值为0->3
x = np.array([3, 2, 1, 3, 1])
# 本来bin的数量为4，现在我们指定了参数为7，因此现在bin的数量为7，所以现在它的索引值为0->6
np.bincount(x, minlength=7)
# 因此，输出结果为：array([0, 2, 1, 2, 0, 0, 0])

# 我们可以看到x中最大的数为3，因此bin的数量为4，那么它的索引值为0->3
x = np.array([3, 2, 1, 3, 1])
# 本来bin的数量为4，现在我们指定了参数为1，那么它指定的数量小于原本的数量，因此这个参数失去了作用，索引值还是0->3
np.bincount(x, minlength=1)
# 因此，输出结果为：array([0, 2, 1, 2])

11 numpy.argmax

返回最大值的索引

a=[1,2,4,5,6,7,8,9,4,3,2,5]
b=[[3,4,6],[5,2,9]]

a1=np.argmax(a) #7
a2=np.array(a)[a1]#9
b1=np.argmax(b,axis=0)#[1 0 1]
b2=np.argmax(b,axis=1)#[2 2]

12 numpy.array_split

numpy.array_split（ary，indices_or_sections，axis = 0 ）
与split类似

13 sorted

sorted(iterable,cpm,key,reverse)
iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。