NumPy 入门

NumPy 中文网

NumPy 中文

NumPy 参考手册

NumPy 参考手册 | NumPy 中文

什么是 NumPy?

NumPy是使用Python进行科学计算的基础软件包。

安装 NumPy

如果已经在系统上安装了Python和PIP,则只需要在DOS命令输入:pip install numpy

或者其他IDE安装。

导入 NumPy

所有库(模块)导入方式一样,不再细说。

import numpy
import numpy as np

创建 NumPy ndarray 对象

NumPy 提供了一个N维数组类型,即 ndarray 它描述了相同类型的“项目”的集合。

所有ndarray都是同质的:每个项目占用相同大小的内存块, 并且所有块都以完全相同的方式解释。 如何解释数组中的每个项目由单独的数据类型对象指定, 其中一个对象与每个数组相关联。除了基本类型(整数,浮点数 等 )之外, 数据类型对象还可以表示数据结构。

# 示例1
import numpy as np 

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

print(arr)

print(type(arr))

数组中的维

数组的维是数组深度(嵌套数组)的一个级别。

嵌套数组:指的是将数组作为元素(项目)的数组。

简单来说,数组中的维,就像元素的壳,几维数组就有几层壳,要找到数组,就必须一层一层的深入。

NumPy 提供了一个.ndim属性,该属性返回数组维度。

# 示例2
import numpy as np   #导入 numpy 并另命名为np

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

print(arr1.ndim)
print(arr2.ndim)
print(arr3.ndim)
print(arr4.ndim)
# 结果为:
0
1
2
3
# 也可以使用,.ndim 来创建更高维度的数组
# 示例3
import numpy as np

arr = np.array([1, 2, 3],ndmin=5)
print(arr)
# 结果为:[[[[[1 2 3]]]]]
# 该数组,最里面的维度(dim)有三个元素,第4个到第1个dim都只有1个元素

数组索引

数组索引等同于访问数组元素,NumPy 数组中的索引以0开始,第一个元素的索引为 0

# 以示例3为基础
import numpy as np

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

print(arr[0])
print(arr[0,0])
print(arr[0,0,0])
print(arr[0,0,0,0])
print(arr[0,0,0,0,0])
# 结果为:
[[[[1 2 3]]]]  # arr 的第一个元素
[[[1 2 3]]]    # arr[0] 的第一个元素
[[1 2 3]]      # arr[0,0] 的第一个元素
[1 2 3]        # arr[0,0,0] 的第一个元素
1              # arr[0,0,0,0] 的第一个元素
# 负索引
# 从元素的倒数位置开始索引,最后一个为 -1

裁切数组

Python 中裁切的意思是将元素从开始的索引到结束的索引(不包含)组成一个新数组。

# 语法:
array_name[start:end:step]
# 参数:start  开始值,如果不传递,则默认是0
#       end    结束值,如果不传递,默认为该维度内数组的长度
#       step   步长,如果不传递,默认为1
# 更多示例:
import numpy as np

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

print(arr[2:])
# 裁切数组中索引2到结尾的元素
import numpy as np

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

print(arr[:4])
# 裁切数组中第一个元素开始到索引为4(不包含)的元素
# 负索引裁切,元素倒数与索引一致,同样,裁切之后的新数组不包含end值所属的元素
#多维数组的裁切
import numpy as np

arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]])
arr2 = arr[0:3, 1:4]    #0:3   是第一个维度里的元素,1:4则是第二个维度
arr3 = arr[0:3]

print("数组arr2为:", arr2)
print("------分割线--------------")
print("数组arr2的维度为:", rr2.ndim)
print("------分割线--------------")
print("数组arr3为:", arr3)
print("------分割线--------------")
print("数组arr3第二个元素为", arr3[1])

NumPy 入门_第1张图片

NumPy 中的数据类型

NumPy 有一些额外的数据类型,并通过字符引用数据类型。

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

检查数组的数据类型 .dtype

import numpy as np

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

print(arr.dtype)

NumPy 入门_第2张图片

副本和视图之间的区别

副本和数组视图之间的主要区别在于副本是一个新数组,而视图知识原始数组的视图。

副本拥有数据,对副本所做的任何更改都不会影响原始数组,对原始数组所做的任何更改也不会影响副本。

视图不拥有数据,对视图所做的任何更改都会影响原始数组,而对原始数组所做的任何更改都会影响视图。

简而言之,副本和原数组相互独立,视图和原数组相互影响;副本有数据,视图没数据。

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()   #创建副本
y = arr.view()   #创建视图

检查数组是否拥有数据

每个NumPy 数组都有一个base属性,如果该数组拥有数据,则这个属性返回None,将引用原对象。

# 示例
import numpy as np

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

x = arr.copy()
y = arr.view()

print(x.base)
print(y.base)
# 结果:
None
[1 2 3 4 5]

NumPy 数组形状

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

NumPy 数组有一个名为 shape 的属性,该属性返回一个元组,表示每个索引具有相应元素的数量。

import numpy as np

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

print(arr.shape)
# 结果为:(1,2,4)
# 表示:这时一个三维数组,第一个维度里有1个元素,第二个维度有2个元素,第三个维度有4个元素

数组重塑

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

import numpy as np

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

newarr = arr.reshape(4, 3)

print(newarr)
# 结果为:
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
# 重塑之后的元素总数必须和原数组一直,不然回报错。

未知的维

可以使用一个"未知"维度,这意味着,不必在reshape()方法中为维度之一指定确切的数字。但是也要主要数组元素数量是否支持更多的维度。传递 -1 作为值,NumPy 将计算该数字。

展平数组

是指将多维数组转换为一维数组。

# 示例
import numpy as np

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

newarr = arr.reshape(-1)

print(newarr)

数组迭代

用 for 迭代数组

用 for 循环迭代数组,如果是多维数组的话,将会在for 循环里面再嵌套for循环。如:

import numpy as np

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

for x in arr:
  for y in x:
    for z in y:
      print(z)

nditer() 迭代数组

函数 nditer() 是一个辅助函数,从非常基本的迭代到非常高级的迭代都可以使用。

import numpy as np

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

for x in np.nditer(arr):
  print(x)

数组连接

连接意味着将1个以上的数组的内容放到单个数组中。

import numpy as np

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

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

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

print(arr)
# 结果为:[1 2 3 4 5 6]

拆分数组

拆分是连接的方向操作。

# 语法
np.array_split(arr, num)
# 参数:arr  必须,固定参数
#      num   必须,拆分为几个数组
# 如果数组中的元素少于要求的数量,它将再末尾进行相应调整,见下图
# 最后一个数组为空数组

NumPy 入门_第3张图片

搜索数组

检查元素在数组中出现的位置。

import numpy as np

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

x = np.where(arr == 4)

print(x)
# (array([3, 5, 6])
# 意思说是4出现的索引的位置

数组排序

排序是指将元素按有序顺序排列。有序序列是拥有与元素相对应的顺序的任何蓄力,如:数字和字母、升序和降序。

import numpy as np

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

print(np.sort(arr))
# 此方法返回副本(副本和原数组相互独立)

数组过滤

从现有数组中取出一些元素并创建新数组成为过滤。

如果索引处的值为 True,则该元素包含在过滤后的数组中;如果索引处的值为 False,则该元素将从过滤后的数组中排除。

import numpy as np

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

x = [True, False, True, False, True]

newarr = arr[x]

print(newarr)
# 在此例中,对 True 和 False 值进行了硬编码,但通常的用途是根据条件创建过滤器数组。

创建过滤器数组

import numpy as np

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

# 创建一个空列表
filter_arr = []

# 遍历 arr 中的每个元素
for element in arr:
  # 如果元素大于 62,则将值设置为 True,否则为 False:
  if element > 62:
    filter_arr.append(True)
  else:
    filter_arr.append(False)

newarr = arr[filter_arr]

print(filter_arr)
print(newarr)

直接从数组创建过滤器

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)
# 创建一个过滤器数组,该数组仅返回原始数组中的偶数元素
import numpy as np

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

filter_arr = arr % 2 == 0

newarr = arr[filter_arr]

print(filter_arr)
print(newarr)

NumPy 中的随机

什么是随机数?

随机数并不意味着每次都有不同的数字,随机意味着无法在逻辑上预测的事物。

伪随机和真随机

计算机在程序上工作,程序是权威的指令集。因此,这意味着必须有某种算法来生成随机数。

如果存在生成随机数的程序,则可以预测他,因此它就不是真正的随机数。通过算法生产的随机数称为伪随机数。

生成伪随机数

NumPy 提供了 random 模块来处理随机数。

from numpy import random

x = random.randint(100)

print(x)
# 生成一个0到100之间的随机整数
from numpy import random

x = random.rand()

print(x)
# random 模块的 rand() 方法返回 0 到 1 之间的随机浮点数。
from numpy import random

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

print(x)
# 生成随机数组,size为数组的维度
# size=(5)表示一维数组有5个元素
# size=(2,5)表示二维数组,第一个维度有2个元素,第二个维度有5个元素

from numpy import random

x = random.rand(3, 5)

print(x)
# 浮点数,直接写数组形状即可

从数组中取随机值

choice() 方法可以基于值数组生成随机值。

from numpy import random

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

print(x)
# choice() 方法还允许返回一个值数组
from numpy import random

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

print(x)
# 生成由数组参数(3、5、7 和 9)中的值组成的二维数组

NumPy ufuncs

ufuncs 指的是“通用函数”(Universal Functions),他们是对ndarray对象进行操作的NumPy函数。

为什么要使用 ufuncs?

ufunc 用于在 NumPy 中实现矢量化,这比迭代元素要快得多。

它们还提供广播和其他方法,例如减少、累加等,它们对计算非常有帮助。

ufuncs 还接受其他参数,比如:

where 布尔值数组或条件,用于定义应在何处进行操作。

dtype 定义元素的返回类型。

out 返回值应被复制到的输出数组。

# 对两个列表元素进行相加
# Python 内置zip()方法
x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = []

for i, j in zip(x, y):
  z.append(i + j)
print(z)
# NumPy add()函数
import numpy as np

x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = np.add(x, y)

print(z)

你可能感兴趣的:(Python,学习日记,numpy,python,开发语言)