NumPy数值计算基础

目标：

1.掌握 NumPy 数组对象 ndarray

2.掌握 NumPy 矩阵与通用函数

3.利用 NumPy 进行统计分析

数据分析流程及学习路径

对应的使用环境：

简单介绍：NumPy（Numerical Python的简称）是Python数值计算最重要的基础包。大多数提供科学计算的包都是用NumPy的数组作为构建基础。

掌握 NumPy 数组对象 ndarray

创建数组对象
 

1．数组属性：ndarray（数组）是存储单一数据类型的多维数组。

例：

可以使用numpy.array()函数来创建numpy数组。这个函数接受一个列表作为输入，然后返回一个numpy数组。

以下是一个例子：

import numpy as np

# 创建一个一维数组
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1)
# 输出: [1 2 3 4 5]

# 创建一个二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr2)
# 输出:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

除了使用列表作为输入，numpy.array()函数还可以接受其他类型的输入，如元组、列表的列表、元组的元组等。

在使用array函数创建数组时，数组的数据类型默认是浮点型。自定义数组数据，则可以预先指定数据类型。

可以使用ravel函数展平数组or

使用flatten函数展平数组

组合数组

使用hstack函数实现数组横向组合：np.hstack((arr1,arr2))

使用vstack函数实现数组纵向组合：np.vstack((arr1,arr2))

使用concatenate函数实现数组横向组合：np.concatenate((arr1,arr2),axis = 1))

使用concatenate函数实现数组纵向组合：np.concatenate((arr1,arr2),axis = 0))

切割数组

1，使用hsplit函数（最常用）实现数组横向分割： np.hsplit(arr1, 2)

2，使用vsplit函数实现数组纵向分割： np.vsplit(arr, 2)

3，使用split函数实现数组横向分割： np.split(arr, 2, axis=1)

4，使用split函数实现数组纵向分割： np.split(arr, 2, axis=0)

np.hsplit(arr1, 2)函数可以将数组arr1在水平方向上均匀分割为两个部分。

例如，假设我们有一个两行四列的数组arr1：

arr1 = np.array([[1, 2, 3, 4],
                 [5, 6, 7, 8]])

使用np.hsplit(arr1, 2)会将arr1在水平方向上均匀分割为两个部分：

[array([[1, 2],
        [5, 6]]),
 array([[3, 4],
        [7, 8]])]

即将arr1的第一列和第二列组成一个新的数组作为第一个分割结果，将arr1的第三列和第四列组成一个新的数组作为第二个分割结果。

---

掌握 NumPy 矩阵与通用函数

创建NumPy矩阵：

使用mat函数创建矩阵： matr1 = np.mat("1 2 3;4 5 6;7 8 9")

使用matrix函数创建矩阵：matr2 = np.matrix([[123],[456],[789]])

使用bmat函数合成矩阵：np.bmat("arr1 arr2; arr1 arr2")

矩阵的运算：

矩阵与数相乘：matr1*3

矩阵相加减：matr1±matr2

矩阵相乘：matr1*matr2

矩阵对应元素相乘：np.multiply(matr1,matr2)

矩阵特有属性：

认识ufunc函数：

全称通用函数（universal function），是一种能够对数组中所有元素进行操作的函数。

四则运算：加（+）、减（-）、乘（*）、除（/）、幂（**）。数组间的四则运算表示对每个数组中的元素分别进行四则运算，所以形状必须相同。

比较运算：>、<、==、>=、<=、!=。比较运算返回的结果是一个布尔数组，每个元素为每个数组对应元素的比较结果。

逻辑运算：np.any函数表示逻辑“or”，np.all函数表示逻辑“and”。运算结果返回布尔值。

np.where(condition,x,y)满足条件值替换为x，不满足条件替换为y

ufunc函数是一种NumPy提供的用于对数组进行元素级别运算的函数。使用前记得导入：import numpy as np

以下是ufunc函数的一些示例：

加减乘除四则运算

ufunc是NumPy中的一种函数，可以对数组进行逐元素的计算。下面是使用加减乘除符号举例的一些常见ufunc函数：

1. 加法：使用+符号进行数组的逐元素加法计算。例如，使用np.add函数可以实现两个数组的逐元素相加：

import numpy as np

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

c = np.add(a, b)
print(c)  # 输出：[5 7 9]

1. 减法：使用-符号进行数组的逐元素减法计算。例如，使用np.subtract函数可以实现两个数组的逐元素相减：

import numpy as np

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

c = np.subtract(a, b)
print(c)  # 输出：[3 3 3]

1. 乘法：使用*符号进行数组的逐元素乘法计算。例如，使用np.multiply函数可以实现两个数组的逐元素相乘：

import numpy as np

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

c = np.multiply(a, b)
print(c)  # 输出：[4 10 18]

1. 除法：使用/符号进行数组的逐元素除法计算。例如，使用np.divide函数可以实现两个数组的逐元素相除：

import numpy as np

a = np.array([4, 5, 6])
b = np.array([2, 2, 2])

c = np.divide(a, b)
print(c)  # 输出：[2. 2.5 3.]

可以使用加减乘除符号进行数组的逐元素计算，也可以直接使用相应的NumPy函数进行计算。

ufunc函数比较运算

在NumPy中，ufunc函数是一种通用函数，可以对数组中的元素进行逐元素的操作。ufunc函数可以用于比较运算，比较运算包括等于、不等于、大于、小于、大于等于和小于等于等操作。

一些常用的ufunc函数比较运算包括：

• np.equal(x, y): 返回一个布尔数组，表示x和y元素是否相等。
• np.not_equal(x, y): 返回一个布尔数组，表示x和y元素是否不相等。
• np.greater(x, y): 返回一个布尔数组，表示x是否大于y。
• np.less(x, y): 返回一个布尔数组，表示x是否小于y。
• np.greater_equal(x, y): 返回一个布尔数组，表示x是否大于等于y。
• np.less_equal(x, y): 返回一个布尔数组，表示x是否小于等于y。

这些ufunc函数比较运算的返回值都是布尔数组，可以用于数组的逻辑运算或者索引操作。

ufunc函数逻辑运算

1. equal(x1, x2)：比较两个数组是否元素相等，返回一个布尔值数组。
2. not_equal(x1, x2)：比较两个数组是否元素不等，返回一个布尔值数组。
3. greater(x1, x2)：比较两个数组的元素是否x1大于x2，返回一个布尔值数组。
4. less(x1, x2)：比较两个数组的元素是否x1小于x2，返回一个布尔值数组。
5. greater_equal(x1, x2)：比较两个数组的元素是否x1大于等于x2，返回一个布尔值数组。
6. less_equal(x1, x2)：比较两个数组的元素是否x1小于等于x2，返回一个布尔值数组。

这些逻辑运算函数可以用于对数组进行条件判断、筛选和比较等操作。

np.where(condition,x,y)满足条件值替换为x，不满足条件替换为y。举例：

假设有一个数组 arr = np.array([1, 2, 3, 4, 5])，我们想要将大于等于3的值替换为10，小于3的值替换为0。

使用 np.where() 函数可以实现这个替换操作，代码如下：

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
new_arr = np.where(arr >= 3, 10, 0)

print(new_arr)

输出结果为： [0 0 10 10 10]。

解释：

• arr >= 3 是一个布尔数组 [False, False, True, True, True]，表示 arr 中每个元素是否大于等于3。
• np.where(arr >= 3, 10, 0) 表示对于 arr 中每个元素，如果其对应的布尔数组值为 True，则替换为 10，否则替换为 0。

---

---

利用 NumPy 进行统计分析

读写文件：

NumPy文件读写主要有二进制的文件读写和文件列表形式的数据读写两种形式。

save函数是以二进制的格式保存数据：

np.save("../tmp/save_arr",arr) load函数是从二进制的文件中读取数据。

np.load("../tmp/save_arr.npy") savez函数可以将多个数组保存到一个文件中。

np.savez('../tmp/savez_arr',arr1,arr2) 存储时可以省略扩展名，但读取时不能省略扩展名。

读取文本格式的数据：

1，savetxt函数是将数组写到某种分隔符隔开的文本文件中。      

np.savetxt("../tmp/arr.txt", arr, fmt="%d", delimiter=",")

2，loadtxt函数执行的是把文件加载到一个二维数组中。       np.loadtxt("../tmp/arr.txt",delimiter=",")delimiter usecols skiprows genfromtxt,

3，函数面向的是结构化数组和缺失数据。       np.genfromtxt("../tmp/arr.txt", delimiter = ",")

使用数组进行简单统计分析

1，直接排序

sort函数是最常用的排序方法。 arr.sort() sort函数也可以指定一个axis参数，使得sort函数可以沿着指定轴对数据集进行排序。axis=1为沿横轴排序； axis=0为沿纵轴排序。

例：

arr = [4, 2, 5, 1, 3]

arr.sort()

print(arr)

输出结果为：[1, 2, 3, 4, 5]

2，间接排序

argsort函数返回值为重新排序值的下标。 arr.argsort() lexsort函数返回值是按照最后一个传入数据排序的。 np.lexsort((a,b,c))

arr.argsort()和numpy.lexsort(arr)都是用于对数组进行间接排序的函数，但是它们的用法有一些不同。

首先，arr.argsort()是一个方法，它返回数组排序后的索引值。例如，对于一维数组arr，可以使用arr.argsort()来获取对arr进行升序排序后的索引值。

示例：

import numpy as np

arr = np.array([3, 1, 2])
sorted_indices = arr.argsort()
print(sorted_indices) 
# 输出：[1 2 0]

而lexsort函数是一个numpy库中的函数，它可以对一个多维数组进行排序，返回排序后的索引值。lexsort函数会先对最后一个传入的数组进行排序，再对倒数第二个数组进行排序，以此类推。

示例：

import numpy as np

arr1 = np.array([3, 1, 2])
arr2 = np.array([1, 2, 3])
sorted_indices = np.lexsort((arr1, arr2))
print(sorted_indices) 
# 输出：[1 2 0]

在上面的示例中，arr1和arr2都是一维数组。np.lexsort((arr1, arr2))首先对arr2进行排序，得到的排序结果是[1, 2, 0]，然后再基于这个排序结果对arr1进行排序，最终得到的排序结果也是[1, 2, 0]。

3，去重与重复数据

通过unique函数可以找出数组中的唯一值并返回已排序的结果。 tile函数主要有两个参数，参数“A”指定重复的数组，参数“reps”指定重复的次数。    

np.tile(A，reps) repeat函数主要有三个参数，参数“a”是需要重复的数组元素，参数“repeats”是重复次数，参数“axis”指定沿着哪个轴进行重复，axis = 0表示按行进行元素重复；axis = 1表示按列进行元素重复。    

numpy.repeat(a, repeats, axis=None) 这两个函数的主要区别在于，tile函数是对数组进行重复操作，repeat函数是对数组中的每个元素进行重复操作。

常用的统计函数

了：

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

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

那么问题来了：    

  如何计算一组数据的中值或者是均值       如何删除有缺失数据的那一行（列）[在pandas中介绍]