科学计算工具numpy-ndarray的矩阵处理，索引切片，拼接，函数，数组转换以及nan等

轴(axis)

在numpy中可以理解为方向,使用0,1,2…数字表示,
对于一个一维数组,只有一个0轴,
对于二维数组(shape(2,2)),有0轴和1轴,
对于三维数组(shape(2,2, 3)),有0,1,2轴

有了轴的概念之后,我们计算会更加方便,比如计算一个2维数组的平均值,必须指定是计算哪个方向上面的数字的平均值

np.arange(0,10).reshape((2,5))， reshape中2表示0轴长度(包含数据的条数)为2, 1轴长度为5, 2X5一共10个数据

索引与切片

1. 一维数组的索引与切片（与Python的列表索引功能相似）

# 一维数组
arr1 = np.arange(10)
print(arr1)
print(arr1[2:5])

运行结果

[0 1 2 3 4 5 6 7 8 9]
[2 3 4]

2. 多维数组的索引与切片：

arr[r1:r2, c1:c2]
arr[1,1] 等价 arr[1][1]
[:] 代表某个维度的数据

# 多维数组
arr2 = np.arange(12).reshape(3,4)
print(arr2)

print(arr2[1])

print(arr2[0:2, 2:])

print(arr2[:, 1:3])

运行结果

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

[4 5 6 7]

[[2 3]
 [6 7]]

[[ 1  2]
 [ 5  6]
 [ 9 10]]

3. 条件索引

布尔值多维数组：arr[condition]，condition也可以是多个条件组合。
注意，多个条件组合要使用 & | 连接，而不是Python的 and or。

# 条件索引

# 找出 data_arr 中 2005年后的数据
data_arr = np.random.rand(3,3)
print(data_arr)

year_arr = np.array([[2000, 2001, 2000],
                     [2005, 2002, 2009],
                     [2001, 2003, 2010]])

is_year_after_2005 = year_arr >= 2005
print(is_year_after_2005, is_year_after_2005.dtype)

filtered_arr = data_arr[is_year_after_2005]
print(filtered_arr)

#filtered_arr = data_arr[year_arr >= 2005]
#print(filtered_arr)

# 多个条件
filtered_arr = data_arr[(year_arr <= 2005) & (year_arr % 2 == 0)]
print(filtered_arr)

运行结果：

[[ 0.53514038  0.93893429  0.1087513 ]
 [ 0.32076215  0.39820313  0.89765765]
 [ 0.6572177   0.71284822  0.15108756]]

[[False False False]
 [ True False  True]
 [False False  True]] bool

[ 0.32076215  0.89765765  0.15108756]

#[ 0.32076215  0.89765765  0.15108756]

[ 0.53514038  0.1087513   0.39820313]

numpy中数值的更改

numpy中布尔索引

numpy中的三元运算符

把小于10的替换为0，其他的为10

numpy中的clip(裁剪)

numpy中的nan和inf

numpy中nan的注意点

那么问题来了，在一组数据中单纯的把nan替换为0，合适么？会带来什么样的影响？

比如，全部替换为0后，替换之前的平均值如果大于0，替换之后的均值肯定会变小，所以更一般的方式是把缺失的数值替换为均值（中值）或者是直接删除有缺失值的一行

ndarray缺失值填充均值

t中存在nan值，如何操作把其中的nan填充为每一列的均值
代码：

# coding=utf-8

import numpy as np


def fill_ndaeeay(t1):
    for i in range(t1.shape[1]):    # 遍历每一列
        temp_col = t1[:,i]  # 当前的一列
        nan_num = np.count_nonzero(temp_col != temp_col)	# 数据不相等，说明有nan值
        if nan_num !=0:     # 不为0,说明当前这一列有nan
            temp_not_nan_col = temp_col[temp_col==temp_col]     # 当前一列不为nan的array

            # 选中当前为nan的位置,把值赋值为不为nan的均值
            temp_col[np.isnan(temp_col)] = temp_not_nan_col.mean()
    return t1

if __name__ == '__main__':
    t1 = np.arange(12).reshape(3, 4).astype('float')

    t1[1, 2:] = np.nan
    print(t1)
    print('-'*66)
    t1 = fill_ndaeeay(t1)
    print(t1)

运行结果：

[[ 0.  1.  2.  3.]
 [ 4.  5. nan nan]
 [ 8.  9. 10. 11.]]
------------------------------------------------------------------
[[ 0.  1.  2.  3.]
 [ 4.  5.  6.  7.]
 [ 8.  9. 10. 11.]]

元素计算函数

1.ceil(): 向上最接近的整数，参数是 number 或 array
2.floor(): 向下最接近的整数，参数是 number 或 array
3.rint(): 四舍五入，参数是 number 或 array
4.isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
5.multiply(): 元素相乘，参数是 number 或 array
6.divide(): 元素相除，参数是 number 或 array
7.abs()：元素的绝对值，参数是 number 或 array
8.where(condition, x, y): 三元运算符，x if condition else y

示例代码（1、2、3、4、5、6、7）：

# randn() 返回具有标准正态分布的序列。
arr = np.random.randn(2,3)

print(arr)

print(np.ceil(arr))

print(np.floor(arr))

print(np.rint(arr))

print(np.isnan(arr))

print(np.multiply(arr, arr))

print(np.divide(arr, arr))

print(np.where(arr > 0, 1, -1))

运行结果

# print(arr)
[[-0.75803752  0.0314314   1.15323032]
 [ 1.17567832  0.43641395  0.26288021]]

# print(np.ceil(arr))
[[-0.  1.  2.]
 [ 2.  1.  1.]]

# print(np.floor(arr))
[[-1.  0.  1.]
 [ 1.  0.  0.]]

# print(np.rint(arr))
[[-1.  0.  1.]
 [ 1.  0.  0.]]

# print(np.isnan(arr))
[[False False False]
 [False False False]]

# print(np.multiply(arr, arr))
[[  5.16284053e+00   1.77170104e+00   3.04027254e-02]
 [  5.11465231e-03   3.46109263e+00   1.37512421e-02]]

# print(np.divide(arr, arr))
[[ 1.  1.  1.]
 [ 1.  1.  1.]]

# print(np.where(arr > 0, 1, -1))
[[ 1  1 -1]
 [-1  1  1]]

元素统计函数

1.np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array
2.np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array
3.np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
4.np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
5.np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array
6.多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。

示例代码：

arr = np.arange(12).reshape(3,4)
print(arr)

print(np.cumsum(arr)) # 返回一个一维数组，每个元素都是之前所有元素的 累加和

print(np.sum(arr)) # 所有元素的和

print(np.sum(arr, axis=0)) # 数组的按列统计和

print(np.sum(arr, axis=1)) # 数组的按行统计和

运行结果：

# print(arr)
[[ 0  1  2  3