Numpy（Numerical Python的简称）高性能科学计算和数据分析的基础包。其部分功能如下：
- ndarray，具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组。
- 数组运算，不用编写循环
- 可以读写磁盘数据，操作内存映射
- 线性代数
- 集成c，c++等语言
python能够包装c、c++以numpy数组形式的数据。pandas提供了结构化或表格化数据的处理高级接口，
还提供了numpy不具备的时间序列处理等；
1.ndarray：多维数组对象
多维数组，要求所有元素的类型一致，通常说的“数组”、“Numpy数组”、“ndarray”都是指“ndarray”对象。
1.1 创建ndarray
| 函数 | 说明 |
|---|---|
| array | 输入数据转换为ndarray对象，可以是python元组、列表或其他序列类型。可以自动识别dtype，或者手动指定类型 |
| asarray | 将输入数据转换为ndarray对象 |
| arange | 类似range，返回ndarray的一维序列数组 |
| ones，ones_like | 创建全1数组，默认float类型。ones_like创建一个类型输入数组的全1数组 |
| zeros，zeros_like | 与ones相同，创建全0数组 |
| empty，empty_like | 全空数组，只分配内存空间，不填充任何值 |
| eye、identity | 创建一个n*n的单位矩阵（阵列） |
In [1]: import numpy as np
In [2]: np.arange(10)
Out[2]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [3]: np.array([1,2,3,5,6,7])
Out[3]: array([1, 2, 3, 5, 6, 7])
In [4]: np.ones((3,1))
Out[4]:
array([[ 1.],
[ 1.],
[ 1.]])
In [5]: np.zeros((2,5))
Out[5]:
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
In [6]: np.eye(3)
Out[6]:
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
In [7]: np.empty((2,4))
Out[7]:
array([[ 0.00000000e+000, 0.00000000e+000, 2.12267575e-314,
2.19986168e-314],
[ 2.15551710e-314, 2.19976181e-314, 2.31584192e+077,
5.56268597e-309]])
1.2 ndarray数据类型
ndarry数组相关的数据类型
In [1]: import numpy as np
In [5]: a = np.array([1,2,4],dtype="int32")
In [6]: b = np.array([1,3,5],dtype=np.float32)
In [9]: a.dtype
Out[9]: dtype('int32')
In [10]: b.dtype
Out[10]: dtype('float32')
当需要控制数据在内存和磁盘中的存储方式时，尤其是大数据集，就需要了解如何控制存储类型。
dtype的表示形式有几种：
- 类型列中的值，使用字符串方式：如“int8”；
- 类型列中的值，使用如np.int8表示；
- 类型代码列中的值，使用字符串表示，如“f2”；
下表是所有支持的类型和说明：
也可以使用astype修改dtype。
In [11]: a
Out[11]: array([1, 2, 4])
In [12]: c = a.astype("float64")
In [13]: c
Out[13]: array([ 1., 2., 4.])
In [14]: c.dtype
Out[14]: dtype('float64')
在格式转换过程中：
- 浮点数转换成整数，浮点数小数部分会被去掉；
- 如果字符串格式的数字，可以转换为数值形式；
- 复数转换
1.3 数组和标量之间的运算
数组的优势在于“矢量化”的运算，运算会应用到数组中的元素。
不需要编写循环进行运算，而且效率也比使用循环高。
In [17]: a
Out[17]:
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
In [18]: b
Out[18]:
array([[ 0, 2, 4, 6, 8],
[10, 12, 14, 16, 18]])
In [19]: a + b # 计算两个数组的和
Out[19]:
array([[ 0, 3, 6, 9, 12],
[15, 18, 21, 24, 27]])
In [21]: a * 10 # 每个元素*10
Out[21]:
array([[ 0, 10, 20, 30, 40],
[50, 60, 70, 80, 90]])
1.4 基本索引和切片
1.4.1 切片
Numpy切片功能与python的列用法是相同的，但是在是否复制切片数据是有区别的。
- python列表切片的时候复制数据
- Numpy数组切片直接操作原数组
python 列表切片操作
#
In [24]: list1 = list(range(10))
In [25]: list1
Out[25]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [26]: id(list1)
Out[26]: 104821896
In [27]: list1_slice = list1[2:5]
In [28]: id(list1_slice)
Out[28]: 104992840
In [29]: list1_slice
Out[29]: [2, 3, 4]
In [30]: list1_slice[0] = 100
In [31]: list1_slice
Out[31]: [100, 3, 4]
In [32]: list1 # 注意2号位置没有变化
Out[32]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Numpy 数组切片操作
In [33]: arr = np.arange(10)
In [34]: arr
Out[34]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [35]: id(arr)
Out[35]: 105028784
In [36]: arr_slice = arr[2:5]
In [37]: arr_slice
Out[37]: array([2, 3, 4])
In [38]: arr_slice[0] = 100
In [39]: arr_slice
Out[39]: array([100, 3, 4])
In [40]: id(arr_slice)
Out[40]: 105029024
In [41]: arr #2号位置被赋值了。
Out[41]: array([ 0, 1, 100, 3, 4, 5, 6, 7, 8, 9])
这样做的原因是Numpy为了能够更好的处理大数据集。如果每次复制将会大大的消耗内存。
1.4.2 索引
二维数组索引如下
可以使用两种方式：
- 使用两个索引
- 使用两个值表示的列表作为索引
In [43]: a
Out[43]:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
In [44]: a[0] #先行后列
Out[44]: array([0, 1, 2])
In [45]: a[0][1]
Out[45]: 1
In [46]: a[0,1]
Out[46]: 1
如果是多维数组的话,可以使用标量值或者数组来赋值。
In [50]: b
Out[50]:
array([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
In [51]: b[0]
Out[51]:
array([[1, 2, 3],
[4, 5, 6]])
In [52]: old_values = b[0]
In [53]: b[0] = 100
In [54]: b
Out[54]:
array([[[100, 100, 100],
[100, 100, 100]],
[[ 7, 8, 9],
[ 10, 11, 12]]])
In [55]: b[0] = old_values
In [56]: b
Out[56]:
array([[[100, 100, 100],
[100, 100, 100]],
[[ 7, 8, 9],
[ 10, 11, 12]]])
1.4.3 布尔型索引
直接看例子,有一组7*4的数据data，每行分别属于names数组中的人所有。
names = np.array(["Bob","Joe","Will","Bob","Will","Joe","Joe"])
data = np.random.randn(7,4)
names
Out[4]:
array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'],
dtype='<U4')
data
Out[5]:
array([[-0.3153179 , 1.01375816, -0.34210821, -0.74311504],
[-0.4196392 , -0.80468813, 0.65295259, 0.10492046],
[-0.40579151, 0.83195776, 0.71036512, -1.66161549],
[ 0.043161 , -0.68926623, -0.20530643, 0.82019059],
[-0.0088418 , -1.16661084, 0.36412278, -0.9806821 ],
[-0.02528605, -0.42485406, 0.26363666, -0.3005965 ],
[-1.62686502, 0.64529883, -0.23470384, 0.77666136]])
通过比较运算可以产生一个布尔型的数组,并把它作为索引
names == "Bob"
Out[6]: array([ True, False, False, True, False, False, False], dtype=bool)
data[names=="Bob"] #作为索引
Out[7]:
array([[-0.3153179 , 1.01375816, -0.34210821, -0.74311504],
[ 0.043161 , -0.68926623, -0.20530643, 0.82019059]])
data[names=="Bob",:2] #还能跟整数混用
Out[8]:
array([[-0.3153179 , 1.01375816],
[ 0.043161 , -0.68926623]])
还能这么用：
data[names!="Bob"]
Out[9]:
array([[-0.4196392 , -0.80468813, 0.65295259, 0.10492046],
[-0.40579151, 0.83195776, 0.71036512, -1.66161549],
[-0.0088418 , -1.16661084, 0.36412278, -0.9806821 ],
[-0.02528605, -0.42485406, 0.26363666, -0.3005965 ],
[-1.62686502, 0.64529883, -0.23470384, 0.77666136]])
data[-(names=="Bob")] # - 号已经不太使用，请使用~代替
Out[10]:
array([[-0.4196392 , -0.80468813, 0.65295259, 0.10492046],
[-0.40579151, 0.83195776, 0.71036512, -1.66161549],
[-0.0088418 , -1.16661084, 0.36412278, -0.9806821 ],
[-0.02528605, -0.42485406, 0.26363666, -0.3005965 ],
[-1.62686502, 0.64529883, -0.23470384, 0.77666136]])
data[~(names=="Bob")]
Out[11]:
array([[-0.4196392 , -0.80468813, 0.65295259, 0.10492046],
[-0.40579151, 0.83195776, 0.71036512, -1.66161549],
[-0.0088418 , -1.16661084, 0.36412278, -0.9806821 ],
[-0.02528605, -0.42485406, 0.26363666, -0.3005965 ],
[-1.62686502, 0.64529883, -0.23470384, 0.77666136]])
还有：
&表示和，|表示或- python中的and和or在ndarray中不能使用
mask = (names == "Bob")|(names =="Will" )
mask
Out[13]: array([ True, False, True, True, True, False, False], dtype=bool)
data[mask]
Out[14]:
array([[-0.3153179 , 1.01375816, -0.34210821, -0.74311504],
[-0.40579151, 0.83195776, 0.71036512, -1.66161549],
[ 0.043161 , -0.68926623, -0.20530643, 0.82019059],
[-0.0088418 , -1.16661084, 0.36412278, -0.9806821 ]])
同样，还能赋值
data[data < 0] =0
data
Out[16]:
array([[ 0. , 1.01375816, 0. , 0. ],
[ 0. , 0. , 0.65295259, 0.10492046],
[ 0. , 0.83195776, 0.71036512, 0. ],
[ 0.043161 , 0. , 0. , 0.82019059],
[ 0. , 0. , 0.36412278, 0. ],
[ 0. , 0. , 0.26363666, 0. ],
[ 0. , 0.64529883, 0. , 0.77666136]])
data[names=="Joe"] = 2
data
Out[20]:
array([[ 0. , 1.01375816, 0. , 0. ],
[ 2. , 2. , 2. , 2. ],
[ 0. , 0.83195776, 0.71036512, 0. ],
[ 0.043161 , 0. , 0. , 0.82019059],
[ 0. , 0. , 0.36412278, 0. ],
[ 2. , 2. , 2. , 2. ],
[ 2. , 2. , 2. , 2. ]])
1.4.4 花式索引
为了特定的选取行的子集，可以传入一个列表或者ndarray。
arr
Out[26]:
array([[ 0., 0., 0., 0.],
[ 1., 1., 1., 1.],
[ 2., 2., 2., 2.],
[ 3., 3., 3., 3.],
[ 4., 4., 4., 4.],
[ 5., 5., 5., 5.],
[ 6., 6., 6., 6.],
[ 7., 7., 7., 7.]])
arr[[4,2,1,5]]
Out[27]:
array([[ 4., 4., 4., 4.],
[ 2., 2., 2., 2.],
[ 1., 1., 1., 1.],
[ 5., 5., 5., 5.]])
arr_slice = [4,3,2,0]
arr[arr_slice]
Out[29]:
array([[ 4., 4., 4., 4.],
[ 3., 3., 3., 3.],
[ 2., 2., 2., 2.],
[ 0., 0., 0., 0.]])
也可以同时传入两个参数：
arr = np.arange(32).reshape(8,4)
arr
Out[31]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23],
[24, 25, 26, 27],
[28, 29, 30, 31]])
arr[[1,5,7,2],[0,3,1,2]]
Out[32]: array([ 4, 23, 29, 10])
# 两个列表的值分别对应一个索引值，形成4对索引。
花式索引与切片不一样，总是复制到新的数组中。
1.4.5 数组转置和轴对换
arr = np.arange(15).reshape(3,5)
arr
Out[34]:
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
arr.T
Out[35]:
array([[ 0, 5, 10],
[ 1, 6, 11],
[ 2, 7, 12],
[ 3, 8, 13],
[ 4, 9, 14]])
# 来计算两个数组的内积
arr = np.random.randn(3,6)
np.dot(arr.T,arr)
Out[37]:
array([[ 3.72937613, -0.86744575, -1.62911498, -3.47666555, 0.32576022,
0.23910857],
[-0.86744575, 1.0711547 , 1.02242329, -1.08977196, -1.10673674,
0.33153465],
[-1.62911498, 1.02242329, 1.84009989, -0.32508586, -1.30894879,
-0.33134049],
[-3.47666555, -1.08977196, -0.32508586, 7.68163281, 2.21901489,
-0.72295841],
[ 0.32576022, -1.10673674, -1.30894879, 2.21901489, 1.50075102,
-0.12049286],
[ 0.23910857, 0.33153465, -0.33134049, -0.72295841, -0.12049286,
0.5919756 ]])
轴变换还没弄明白，待续。。。。
2.通用函数
快速的元素级数组函数
通用函数ufunc是一种对ndarray中的数据执行元素级运算的函数，可以理解为“简单函数的矢量化包装”。
现有的通用函数，如sqrt,exp等
a = np.arange(10)
np.sqrt(a) #求所有元素的平方根
Out[53]:
array([ 0. , 1. , 1.41421356, 1.73205081, 2. ,
2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ])
np.exp(a) #求所有元素以e为底的幂
Out[54]:
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])
2.1 一元通用函数
实例：
a = np.random.randn(4,4)
a
Out[65]:
array([[-1.35563407, 0.80045511, -0.750681 , -0.15750773],
[ 0.91350028, -0.73936677, -0.10522787, 1.95409707],
[-0.01240254, -3.28275315, 0.75904837, -0.78694871],
[ 2.13713841, -1.19244608, -0.11900042, -0.60834012]])
np.abs(a)
Out[68]:
array([[ 1.35563407, 0.80045511, 0.750681 , 0.15750773],
[ 0.91350028, 0.73936677, 0.10522787, 1.95409707],
[ 0.01240254, 3.28275315, 0.75904837, 0.78694871],
[ 2.13713841, 1.19244608, 0.11900042, 0.60834012]])
np.sqrt(a)
Out[69]:
array([[ nan, 0.89468157, nan, nan],
[ 0.95577208, nan, nan, 1.39789022],
[ nan, nan, 0.87123382, nan],
[ 1.46189549, nan, nan, nan]])
np.square(a)
Out[70]:
array([[ 1.83774372e+00, 6.40728378e-01, 5.63521970e-01,
2.48086851e-02],
[ 8.34482755e-01, 5.46663223e-01, 1.10729041e-02,
3.81849537e+00],
[ 1.53822884e-04, 1.07764683e+01, 5.76154422e-01,
6.19288270e-01],
[ 4.56736059e+00, 1.42192765e+00, 1.41610995e-02,
3.70077706e-01]])
np.exp(a)
Out[71]:
array([[ 0.25778379, 2.22655402, 0.47204498, 0.85427021],
[ 2.49303359, 0.47741613, 0.90011939, 7.0575437 ],
[ 0.98767406, 0.0375248 , 2.13624233, 0.45523172],
[ 8.47515051, 0.30347802, 0.88780743, 0.54425351]])
np.log10(a)
Out[72]:
array([[ nan, -0.09666302, nan, nan],
[-0.03929132, nan, nan, 0.29094613],
[ nan, nan, -0.11973055, nan],
[ 0.32983265, nan, nan, nan]])
np.sign(a)
Out[73]:
array([[-1., 1., -1., -1.],
[ 1., -1., -1., 1.],
[-1., -1., 1., -1.],
[ 1., -1., -1., -1.]])
np.ceil(a)
Out[74]:
array([[-1., 1., -0., -0.],
[ 1., -0., -0., 2.],
[-0., -3., 1., -0.],
[ 3., -1., -0., -0.]])
np.floor(a)
Out[75]:
array([[-2., 0., -1., -1.],
[ 0., -1., -1., 1.],
[-1., -4., 0., -1.],
[ 2., -2., -1., -1.]])
np.rint(a)
Out[76]:
array([[-1., 1., -1., -0.],
[ 1., -1., -0., 2.],
[-0., -3., 1., -1.],
[ 2., -1., -0., -1.]])
np.isnan(a)
Out[77]:
array([[False, False, False, False],
[False, False, False, False],
[False, False, False, False],
[False, False, False, False]], dtype=bool)
np.isfinite(a)
Out[78]:
array([[ True, True, True, True],
[ True, True, True, True],
[ True, True, True, True],
[ True, True, True, True]], dtype=bool)
np.cos(a)
Out[79]:
array([[ 0.21350595, 0.69638016, 0.7312245 , 0.98762128],
[ 0.61097851, 0.73889539, 0.99446865, -0.37398373],
[ 0.99992309, -0.99005339, 0.72549128, 0.70600953],
[-0.53654884, 0.3693879 , 0.9929278 , 0.82059778]])
np.arccos(a)
Out[80]:
array([[ nan, 0.64274221, 2.41988859, 1.7289627 ],
[ 0.41899009, 2.40292572, 1.67621936, nan],
[ 1.58319918, nan, 0.70894619, 2.47664439],
[ nan, nan, 1.69007941, 2.22476386]])
np.logical_not(a)
Out[81]:
array([[False, False, False, False],
[False, False, False, False],
[False, False, False, False],
[False, False, False, False]], dtype=bool)
2.2 二元通用函数
a = np.random.randint(0,100,(2,5))
a
Out[85]:
array([[44, 64, 35, 50, 79],
[68, 91, 62, 95, 8]])
b = np.random.randint(0,100,(2,5))
b
Out[87]:
array([[73, 17, 85, 19, 68],
[77, 62, 45, 49, 15]])
np.add(a,b)
Out[88]:
array([[117, 81, 120, 69, 147],
[145, 153, 107, 144, 23]])
np.subtract(a,b)
Out[89]:
array([[-29, 47, -50, 31, 11],
[ -9, 29, 17, 46, -7]])
np.multiply(a,b)
Out[90]:
array([[3212, 1088, 2975, 950, 5372],
[5236, 5642, 2790, 4655, 120]])
np.divide(a,b)
Out[91]:
array([[ 0.60273973, 3.76470588, 0.41176471, 2.63157895, 1.16176471],
[ 0.88311688, 1.46774194, 1.37777778, 1.93877551, 0.53333333]])
np.floor_divide(a,b)
Out[92]:
array([[0, 3, 0, 2, 1],
[0, 1, 1, 1, 0]], dtype=int32)
np.power(a,b) # 全超了最大值了
Out[93]:
array([[-2147483648, -2147483648, -2147483648, -2147483648, -2147483648],
[-2147483648, -2147483648, -2147483648, -2147483648, -2147483648]], dtype=int32)
np.maximum(a,b) #与max的区别
Out[94]:
array([[73, 64, 85, 50, 79],
[77, 91, 62, 95, 15]])
np.minimum(a,b)
Out[95]:
array([[44, 17, 35, 19, 68],
[68, 62, 45, 49, 8]])
np.mod(a,b)
Out[97]:
array([[44, 13, 35, 12, 11],
[68, 29, 17, 46, 8]], dtype=int32)
np.greater(a,b)
Out[98]:
array([[False, True, False, True, True],
[False, True, True, True, False]], dtype=bool)
a >ｂ
Out[99]:
array([[False, True, False, True, True],
[False, True, True, True, False]], dtype=bool)
np.logical_and(a,b)
Out[100]:
array([[ True, True, True, True, True],
[ True, True, True, True, True]], dtype=bool)
待续。。。