NumPy的基本操作

1 简介

　　NumPy 是用于处理数组的 python 库，部分用 Python 编写，但是大多数需要快速计算的部分都是用 C 或 C ++ 编写的。它还拥有在线性代数、傅立叶变换和矩阵领域中工作的函数。NumPy 由 Travis Oliphant 于 2005 年创建。它是一个开源项目，您可以自由使用它。NumPy 指的是数值 Python（Numerical Python）。

　　在 Python 中，我们有满足数组功能的列表，但是处理起来很慢。NumPy 旨在提供一个比传统 Python 列表快 50 倍的数组对象。与列表不同，NumPy 数组存储在内存中的一个连续位置，因此进程可以非常有效地访问和操纵它们。这种行为在计算机科学中称为引用的局部性。这是 NumPy 比列表更快的主要原因。它还经过了优化，可与最新的 CPU 体系结构一同使用。NumPy 中的数组对象称为 ndarray，它提供了许多支持函数，使得利用 ndarray 非常容易。数组在数据科学中非常常用，因为速度和资源非常重要。

2 NumPy 入门

2.1 安装NumPy

pip install numpy

如果安装失败，可指定国内源安装，例：指定豆瓣源。

pip install numpy -i http://pypi.douban.com/simple/

2.2 导入NumPy

import numpy as np 

arr = np.array([1, 2, 3, 4, 5])

print(arr)

2.3 检查 NumPy 版本

import numpy as np

print(np.__version__)

3 NumPy的基本操作

3.1 数组创建

import numpy as np 

#0维

arr = np.array(61)

#一维

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

#二维

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

#三维

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

#检查维数

print(arr3.ndim)

#创建高维数组

arr5= np.array([1, 2, 3, 4], ndmin=5)

print(arr5)

print('number of dimensions :', arr5.ndim)

3.2 数组索引

import numpy as np

#访问数组元素

#NumPy 数组中的索引以 0 开头，这意味着第一个元素的索引为 0，第二个元素的索引为 1，以此类推。

arr = np.array([1, 2, 3, 4])

print("第一个元素：",arr[0])

print("第三个元素和第四个元素相加：",arr[2] + arr[3])

#访问2维数组

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

print('第一维中的第二个元素: ', arr[0, 1])

#访问3维数组

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

print("第一个数组的第二个数组的第三个元素",arr[0, 1, 2])

#负索引。使用负索引从尾开始访问数组。

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

print('第二个维中的的最后一个元素: ', arr[1, -1])

运行结果：

第一个元素： 1
第三个元素和第四个元素相加： 7
第一维中的第二个元素: 2
第一个数组的第二个数组的第三个元素 6
第二个维中的的最后一个元素: 10

3.3 数组裁切

python 中裁切的意思是将元素从一个给定的索引带到另一个给定的索引。

我们像这样传递切片而不是索引：[start：end]。

我们还可以定义步长，如下所示：[start：end：step]。

如果我们不传递 start，则将其视为 0。

如果我们不传递 end，则视为该维度内数组的长度。

如果我们不传递 step，则视为 1。

实例：

import numpy as np

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

print("裁切索引 1 到索引 5 的元素",arr[1:5])

print("裁切数组中索引 4 到结尾的元素",arr[4:])

print("裁切从开头到索引 4（不包括）的元素",arr[:4])

#负裁切

print("末尾开始的索引 3 到末尾开始的索引 1",arr[-3:-1])

print("从索引 1 到索引 5,步长为2",arr[1:5:2])

#裁切二维数组

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

print("从第二个元素开始，对从索引 1 到索引 4（不包括）的元素进行切片；",arr[1, 1:4])

运行结果：

裁切索引 1 到索引 5 的元素: [2 3 4 5]
裁切数组中索引 4 到结尾的元素: [5 6 7]
裁切从开头到索引 4（不包括）的元素: [1 2 3 4]
末尾开始的索引 3 到末尾开始的索引 1: [5 6]
从索引 1 到索引 5,步长为2: [2 4]
从第二个元素开始，对从索引 1 到索引 4（不包括）的元素进行切片； [7 8 9]

3.4 数组类型

默认情况下，Python 拥有以下数据类型：

strings - 用于表示文本数据，文本用引号引起来。例如 "ABCD"。
integer - 用于表示整数。例如 -1, -2, -3。
float - 用于表示实数。例如 1.2, 42.42。
boolean - 用于表示 True 或 False。
complex - 用于表示复平面中的数字。例如 1.0 + 2.0j，1.5 + 2.5j。

NumPy 中所有数据类型的列表以及用于表示它们的字符。

i - 整数
b - 布尔
u - 无符号整数
f - 浮点
c - 复合浮点数
m - timedelta
M - datetime
O - 对象
S - 字符串
U - unicode 字符串
V - 固定的其他类型的内存块 ( void )

3.5 数组副本/视图

副本和视图的区别：

　　副本和数组视图之间的主要区别在于副本是一个新数组，而这个视图只是原始数组的视图。副本拥有数据，对副本所做的任何更改都不会影响原始数组，对原始数组所做的任何更改也不会影响副本。视图不拥有数据，对视图所做的任何更改都会影响原始数组，而对原始数组所做的任何更改都会影响视图。

实例：

import numpy as np

#副本

arr = np.array([1, 2, 3, 4, 5])

x = arr.copy()

arr[0] = 61

print(arr)

print(x)

#视图

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

x1 = arr.view()

arr1[0] = 61

print(arr1)

print(x1)

运行结果：

[61 2 3 4 5]
[1 2 3 4 5]
[61 2 3 4 5]
[61 2 3 4 5]

3.6 数组形状

　　数组的形状是每个维中元素的数量。

import numpy as np

#获取数组的形状

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

print(arr.shape)

3.7 数组重塑

　　重塑意味着更改数组的形状。数组的形状是每个维中元素的数量。通过重塑，我们可以添加或删除维度或更改每个维度中的元素数量

import numpy as np

#从 1-D 重塑为 2-D

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(4, 3)

print(newarr)

#从 1-D 重塑为 3-D

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(2, 3, 2)

print(newarr)

#展平数组

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

newarr = arr.reshape(-1)

print(newarr)

3.8 数组重塑

　　迭代意味着逐一遍历元素。当我们在 numpy 中处理多维数组时，可以使用 python 的基本 for 循环来完成此操作。如果我们对 1-D 数组进行迭代，它将逐一遍历每个元素。

import numpy as np

#迭代1维

arr = np.array([1, 2, 3])

for x in arr:

    print(x)

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

#迭代2维

for x in arr:

    print(x)

for x in arr:

    for y in x:

        print(y)

#迭代3维

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

for x in arr:

    print(x)

for x in arr:

    for y in x:

        for z in y:

            print(z)

#使用 nditer() 迭代数组

for x in np.nditer(arr):

    print(x)

#以字符串形式遍历数组：

for x in np.nditer(arr, flags=['buffered'], op_dtypes=['S']):

    print(x)

# ndenumerate() 进行枚举迭代

#枚举以下 1D 数组元素：

arr = np.array([1, 2, 3])

for idx, x in np.ndenumerate(arr):

    print(idx, x)

#枚举以下 2D 数组元素：

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

for idx, x in np.ndenumerate(arr):

    print(idx, x)

3.9 数组连接

连接两个数组：

import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr = np.concatenate((arr1, arr2))

print(arr)

沿着行 (axis=1) 连接两个 2-D 数组：

import numpy as np

arr1 = np.array([[1, 2], [3, 4]])

arr2 = np.array([[5, 6], [7, 8]])

arr = np.concatenate((arr1, arr2), axis=1)

print(arr)

print(arr.shape)

使用堆栈函数连接数组

　　堆栈与级联相同，唯一的不同是堆栈是沿着新轴完成的。我们可以沿着第二个轴连接两个一维数组，这将导致它们彼此重叠，即，堆叠（stacking）。我们传递了一系列要与轴一起连接到 concatenate() 方法的数组。如果未显式传递轴，则将其视为 0

import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr = np.stack((arr1, arr2), axis=1)

print(arr)

print(arr.shape)

沿不同方向堆栈

import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr3 = np.array([7, 8, 9])

#沿行堆叠

arr = np.hstack((arr1, arr2,arr3))

print(arr)

print(arr.shape)

#沿列堆叠

arr = np.vstack((arr1, arr2,arr3))

print(arr)

print(arr.shape)

#沿行堆叠

arr = np.dstack((arr1, arr2,arr3))

print(arr)

print(arr.shape)

运行结果：

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

3.10 数组拆分

　　拆分是连接的反向操作。连接（Joining）是将多个数组合并为一个，拆分（Spliting）将一个数组拆分为多个。我们使用 array_split() 分割数组，将要分割的数组和分割数传递给它。

import numpy as np

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

newarr = np.array_split(arr, 3)

print(newarr)

分割二维数组

import numpy as np

arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])

newarr = np.array_split(arr, 3)

print(newarr)

#使用 hsplit() 方法将 2-D 数组沿着行分成三个 2-D 数组

newarr = np.hsplit(arr, 3)

3.11 数组搜索

　　数组中搜索（检索）某个值，然后返回获得匹配的索引。要搜索数组，请使用 where() 方法

import numpy as np

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

x = np.where(arr == 4)

print(x)

#将新值赋予索引结果

arr[x] =7

print(arr)

# 将所有4改为为0 
array = np.where(arr==4, 0, arr)

运行结果：

(array([0, 0, 0, 1, 1], dtype=int64), array([3, 5, 6, 2, 5], dtype=int64))
[[1 2 3 7 5 7 7]
[2 2 7 3 5 7 6]]

3.12 数组过滤

直接从数组创建过滤器

import numpy as np

arr = np.array([61, 62, 63, 64, 65])

filter_arr = arr > 62

newarr = arr[filter_arr]

print(filter_arr)

print(newarr)

3.13 随机

生成一个 0 到 100 之间的随机浮点数：

from numpy import random

#生成一个 0 到 100 之间的随机整数：

x1 = random.randint(100)

print(x1)

#random 模块的 rand() 方法返回 0 到 1 之间的随机浮点数

#生成一个 0 到 100 之间的随机浮点数

x2 = random.rand()*100

print(x2)

生成随机数组

from numpy import random

#生成一个 1-D 数组，其中包含 5 个从 0 到 100 之间的随机整数：

x=random.randint(100, size=(5))

print(x)

生成有 3 行的 2-D 数组，每行包含 5 个从 0 到 100 之间的随机整数：

x2 = random.randint(100, size=(3, 5))

print(x2)

#生成包含 5 个随机浮点数的 1-D 数组：

x3 = random.rand(5)

print(x3)

从数组生成随机数

choice() 方法使您可以基于值数组生成随机值。方法将数组作为参数，并随机返回其中一个值。

from numpy import random

x = random.choice([3, 5, 7, 9])

print(x)

x2 = random.choice([3, 5, 7, 9], size=(3, 5))

print(x2)

巴特西

NumPy的基本操作

1 简介

2 NumPy 入门

2.1 安装NumPy

2.2 导入NumPy

2.3 检查 NumPy 版本

3 NumPy的基本操作

3.1 数组创建

3.2 数组索引

3.3 数组裁切

3.4 数组类型

3.5 数组副本/视图

3.6 数组形状

3.7 数组重塑

3.8 数组重塑

3.9 数组连接

3.10 数组拆分

3.11 数组搜索

3.12 数组过滤

3.13 随机

最新文章

热门文章