1、 numpy是numerical python的简称，调用时习惯使用import numpy as np
2、 ndarray称为n维数组对象，其中的所有元素必须是相同类型
3、 array函数将序列性对象转化为数组
>>> import numpy as np
>>> data=[[1,2,3,4],[5,6,7,8]]
>>> arr=np.array(data)
>>> arr
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
4、 ndim返回数组的维度，shape返回一个表示数组各维度大小的元组，dtype返回数组的数据类型
>>> arr.ndim
2
>>> arr.shape
(2, 4)
>>> arr.dtype
dtype(‘int32‘)
5、 arrange是Python内置函数range的数组版，返回的是一个数组而不是列表
>>> np.arange(5)
array([0, 1, 2, 3, 4])
6、 zeros、ones分别可以创建指定维度的全0或全1的数组
np.zeros((2,3))
Out[6]:
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
np.zeros(5)
Out[7]: array([ 0., 0., 0., 0., 0.])
np.ones((2,3))
Out[9]:
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
7、 empty可以创建一个没有任何具体值的数组
np.empty((2,3))
Out[10]:
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
np.empty((2,3,2))
Out[11]:
array([[[ 7.74942607e-312, 3.16202013e-322],
[ 0.00000000e+000, 0.00000000e+000],
[ 0.00000000e+000, 7.60234188e-042]],
[[ 4.47166461e-062, 1.73323478e+185],
[ 1.31329715e-071, 5.22012831e-037],
[ 3.31261422e-033, 1.25824126e-075]]])
Np.empty不一定会返回全0数组，可能返回一些未初始化的垃圾值
8、 eye可以创建一个正方的n阶单位矩阵
np.eye(3)
Out[14]:
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
9、 ndarray的数据类型
1) dtype可以显示数组的数据类型，
arr=np.array([3.7,-1.2,-2.6,0.5,12.9,10.1])
arr.dtype
Out[14]: dtype(‘float64‘)
2) astype可以显式转换数组的数据类型
arr1=arr.astype(np.int16) #指定转换为int16类型
arr1
Out[16]: array([ 3, -1, -2, 0, 12, 10], dtype=int16)
arr2=arr.astype(int) #默认转换为int32类型
arr2
Out[24]: array([ 3, -1, -2, 0, 12, 10])
arr2.dtype
Out[25]: dtype(‘int32‘)
10、 基本的索引和切片
arr=np.arange(10)
arr
Out[16]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr[5:8] #不是选取索引值为5至8对应的值，而是5至7对应的值
Out[17]: array([5, 6, 7])
arr[5:8]=12 #将一个标量值赋值给一个切片
arr
Out[19]: array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])
将一个标量值赋值给一个切片时，该值会自动传播（广播）到整个选区。
11、 两个等价的索引方式
arr=np.array([[1,2,3],[4,5,6],[7,8,9]])
arr[0][2]
Out[21]: 3
arr[0,2]
Out[22]: 3
12、 关于多维数组
对于2*2*3数组arr3d,第一个2表示arr3d包含2个子数组，后面的2*3表示每一个子数组的维度
arr3d=np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
arr3d
Out[24]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
arr3d[1,1] （等价于arr3d[1][1]）
Out[25]: array([10, 11, 12])
arr3d[1,1,1]
Out[27]: 11
13、 切片索引
arr2d=np.array([[1,2,3],[4,5,6],[7,8,9]])
arr2d[1,2] #切片不含有冒号，因此只返回一个标量值，而不是一个数组
Out[30]: 6
arr2d[:2] #只有含有冒号的切片才返回一个数组，且注意只返回最终索引值前一个对应的值
Out[29]:
array([[1, 2, 3],
[4, 5, 6]])
arr2d[1,:2] #切记只返回索引值前一个对应的值
Out[32]: array([4, 5])
根据切片中冒号的有无、位置可以判断返回结果中数组的有无与位置，仔细比较arr2d[:,0]和arr2d[:,:1]
arr2d[:,0] #逗号右边不含逗号，意味着每个向量第1个值返回一个标量值而不是一个数组
Out[33]: array([1, 4, 7])
arr2d[:,:1] #逗号右边含逗号，意味着每个向量第1个值返回一个数组
Out[34]:
array([[1],
[4],
[7]])
对切片表达式的赋值操作也会被扩撒到整个选区
14、 布尔型索引
data=np.random.randn(7,4)
data
Out[32]:
array([[-0.45669705, -1.52395492, -0.68237624, 0.28242954],
[ 0.13949345, 0.32292273, -1.69858774, -0.00997388],
[-0.35983191, 0.65950176, -0.61423896, -1.40462237],
...,
[ 0.32777344, -2.46573016, -1.10936753, -0.20069354],
[ 0.02787376, -0.23166792, 1.50544933, 1.27843251],
[ 0.41026094, 2.33371247, 0.02932889, -0.18193204]])
names==‘Bob‘
Out[35]: array([ True, False, False, True, False, False, False], dtype=bool)
data[names==‘Bob‘]
Out[36]:
array([[-0.45669705, -1.52395492, -0.68237624, 0.28242954],
[ 0.61920896, 0.67665097, -0.47702115, 0.23167565]])
可以将布尔型数组跟切片混合使用
data[names==‘Bob‘,2:]
Out[37]:
array([[-0.68237624, 0.28242954],
[-0.47702115, 0.23167565]])
data[names==‘Bob‘,3]
Out[38]: array([ 0.28242954, 0.23167565])
可以使用不等于符号（！=）或负号（-）对条件进行否定
names!=‘Bob‘
Out[39]: array([False, True, True, False, True, True, True], dtype=bool)
data[-(names==‘Bob‘)]
Out[41]:
array([[ 0.13949345, 0.32292273, -1.69858774, -0.00997388],
[-0.35983191, 0.65950176, -0.61423896, -1.40462237],
[ 0.32777344, -2.46573016, -1.10936753, -0.20069354],
[ 0.02787376, -0.23166792, 1.50544933, 1.27843251],
[ 0.41026094, 2.33371247, 0.02932889, -0.18193204]])
运用&（和）、|（或）来组合多个条件，python关键字and和or在布尔型数组中无效
mask=(names==‘Bob‘)|(names==‘Will‘)
mask
Out[43]: array([ True, False, True, True, True, False, False], dtype=bool)
data[mask]
Out[44]:
array([[-0.45669705, -1.52395492, -0.68237624, 0.28242954],
[-0.35983191, 0.65950176, -0.61423896, -1.40462237],
[ 0.61920896, 0.67665097, -0.47702115, 0.23167565],
[ 0.32777344, -2.46573016, -1.10936753, -0.20069354]])
通过布尔型数组设置值是一种常用方法
data[data<0]=0
data[names!=‘Joe‘]=7
15、 花式索引：花式索引是指利用整数组进行索引
arr=np.empty((8,4))
for i in range(8):
arr[i]=i
为了以特定顺序选取行子集，只需传入一个用于指定顺序的整数列表或ndarray即可
arr[[4,3,0,6]]
Out[51]:
array([[ 4., 4., 4., 4.],
[ 3., 3., 3., 3.],
[ 0., 0., 0., 0.],
[ 6., 6., 6., 6.]])
使用负数索引将会从末尾开始选取行
arr[[-3,-5,-7]]
Out[52]:
array([[ 5., 5., 5., 5.],
[ 3., 3., 3., 3.],
[ 1., 1., 1., 1.]])
一次传入多个索引组返回一个一维数组，其中的元素对应各个索引元组
arr=np.arange(32).reshape((8,4))
arr
Out[62]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
...,
[20, 21, 22, 23],
[24, 25, 26, 27],
[28, 29, 30, 31]])
arr[[1,5,7,2],[0,3,1,2]] #最终选取的元素是（1,0），（5,3），（7,1），（2,2）
Out[57]: array([ 4, 23, 29, 10])
arr[[1,5,7,2]][:,[0,3,1,2]] #先选择第1/5/7/2行，再进行切片处理
Out[65]:
array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
arr[np.ix_([1,5,7,2],[0,3,1,2])]
Out[66]:
array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
16、 通用函数：快速的元素级数组函数
一元（unary）ufunc：只需输入一个数组，例如sqrt、exp
arr=np.arange(10)
np.sqrt(arr)
Out[91]:
array([ 0. , 1. , 1.41421356, 1.73205081, 2. ,
2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ])
np.exp(arr)
Out[92]:
array([ 1.00000000e+00, 2.71828183e+00, 7.38905610e+00,
2.00855369e+01, 5.45981500e+01, 1.48413159e+02,
4.03428793e+02, 1.09663316e+03, 2.98095799e+03,
8.10308393e+03])
常用一元ufunc
abs、fabs:计算整数、浮点数、复数的绝对值，对于非复数可以使用更快的fabs
sqrt:计算各元素的平方根
square:计算各元素的平方
exp:计算各元素的指数幂
log、log10、log2、log1p:分别为自然对数、底数为10的log、底数为2的log、log(1+x)
sign:返回各元素的正负号：1（正数）、0（零）、-1（负数）
ceil：返回大于等于各元素的最小整数
floor：返回小于等于各元素的最大整数
rint:返回各元素四舍五入得到的整数，保留原dtype
modf:将数组的小数和整数部分以两个独立数组的形式返回
isnan:返回一个表示各元素是否为NaN的布尔型数组
isfinite、isinf:返回一个表示各元素是否为有穷或无穷的布尔型数组
logical_not:计算各元素not x的真值
二元（binary）ufunc：需要输入两个数组,例如add或maximum
x=np.random.randn(8)
x
Out[95]:
array([-0.73665555, -1.08225703, 0.396678 , 0.27265501, 0.20515391,
-0.0077888 , 0.65757567, 0.59417019])
y=np.random.randn(8)
y
Out[97]:
array([ 1.67000867e-02, -9.78981079e-01, -5.10291947e-02,
-1.25185821e+00, 1.60270406e-01, 1.73204017e+00,
-6.71498427e-04, -3.69454256e-01])
np.maximum(x,y)
Out[98]:
array([ 0.01670009, -0.97898108, 0.396678 , 0.27265501, 0.20515391,
1.73204017, 0.65757567, 0.59417019])
常用的二元ufunc
add、subtract:将数组中对应元素相加或相减
multiply:数组元素相乘
divide、floor_divide:除法或向下圆整除法（丢弃余数）
power:对第一个数组中的元素A，第二个数组中对应元素B，计算A的B次方
maximum、fmax/minimun、fmin:元素级的最大/小值运算，fmax/fmin将忽略NaN
mod:元素级的求模运算（即返回除法的余数）
copysign:将第二个数组中各元素的符号复制给第一个数组中的各元素
greater、greater_equal/less、less_equal/equal、not_equal:执行元素级的比较运算，返回一个布尔型数组，分别相当于>、>=、<、<=、==、!=
logical_and、logical_or、logical_xor:执行元素级的真值逻辑运算，分别相当于&、|、^
17、 关于np.where函数
arr=np.random.randn(4,4)
arr
Out[133]:
array([[-1.72563784, 0.32807733, 0.23763017, -1.35535678],
[ 2.26811565, -1.16152395, 0.10114204, 0.14026815],
[-1.75903744, -3.11583062, -2.26546412, 1.70422696],
[-0.41677835, 0.34599268, 0.89238852, -0.52528288]])
np.where(arr>0,2,-2)
Out[134]:
array([[-2, 2, 2, -2],
[ 2, -2, 2, 2],
[-2, -2, -2, 2],
[-2, 2, 2, -2]])
np.where(arr>0,2,arr)
Out[136]:
array([[-1.72563784, 2. , 2. , -1.35535678],
[ 2. , -1.16152395, 2. , 2. ],
[-1.75903744, -3.11583062, -2.26546412, 2. ],
[-0.41677835, 2. , 2. , -0.52528288]])
18、 用于布尔型数组的方法
在对数组进行sum、mean、min等运算时，布尔值会被强制转换为1和0，因此sum经常被用来对布尔型数组中的True值计数：
arr=np.random.randn(10)
arr
Out[148]:
array([-0.15863925, 0.45656155, 0.3049392 , -1.94173424, 0.3308966 ,
0.96004094, -1.47326692, -0.25883203, 0.50200098, 0.46647641])
(arr>0).sum()
Out[149]: 6
any用于测试数组中是否存在一个或多个True,而all则检查数组中所有值是否都是True:
bools=np.array([False,False,True,False])
bools.any()
Out[151]: True
bools.all()
Out[152]: False
19、 排序
arr=np.random.randn(5,3)
arr
Out[159]:
array([[ 4.58258109e-01, 2.34139626e-01, 5.68535912e-01],
[ -1.39700583e-03, 2.25698280e-01, -1.37764403e-01],
[ 2.15419998e-01, 4.98692282e-01, -7.79053967e-01],
[ -8.64182544e-01, -1.84197701e+00, -5.48066394e-01],
[ 1.25435316e+00, -3.22412013e-01, 6.84147453e-01]])
arr.sort(0) #np.sort返回的是数组的已排序副本，而sort（）会修改数组本身
arr
Out[170]:
array([[ -8.64182544e-01, -1.84197701e+00, -7.79053967e-01],
[ -1.39700583e-03, -3.22412013e-01, -5.48066394e-01],
[ 2.15419998e-01, 2.25698280e-01, -1.37764403e-01],
[ 4.58258109e-01, 2.34139626e-01, 5.68535912e-01],
[ 1.25435316e+00, 4.98692282e-01, 6.84147453e-01]])
arr.sort(1)
arr
Out[172]:
array([[ -1.84197701e+00, -8.64182544e-01, -7.79053967e-01],
[ -5.48066394e-01, -3.22412013e-01, -1.39700583e-03],
[ -1.37764403e-01, 2.15419998e-01, 2.25698280e-01],
[ 2.34139626e-01, 4.58258109e-01, 5.68535912e-01],
[ 4.98692282e-01, 6.84147453e-01, 1.25435316e+00]])
20、 唯一化以及其他的集合逻辑
names=np.array([‘Bob‘,‘Joe‘,‘Will‘,‘Bob‘,‘Joe‘])
np.unique(names) #np.unique用于找出数组中的唯一值并返回已排序的结果
Out[199]:
array([‘Bob‘, ‘Joe‘, ‘Will‘],
dtype=‘<U4‘)
np.array(list(set(names))) #运用set稍微繁琐一些
Out[206]:
array([‘Bob‘, ‘Joe‘, ‘Will‘],
dtype=‘<U4‘)