一.numpy介绍

1.概述

NumPy是一个Python语言的软件包，它非常适合于科学计算。在我们使用Python语言进行机器学习编程的时候，这是一个非常常用的基础库。

1.介绍

NumPy是一个用于科技计算的基础软件包，它是Python语言实现的。它包含了：

  • 强大的N维数组结构
  • 精密复杂的函数
  • 可集成到C/C++和Fortran代码的工具
  • 线性代数，傅里叶变换以及随机数能力

除了科学计算的用途以外，NumPy也可被用作高效的通用数据的多维容器。由于它适用于任意类型的数据，这使得NumPy可以无缝和高效的集成到多种类型的数据库中。

3.安装

pip3 install numpy

二.numpy的基础属性与数组的创建

1.数组相关介绍

NumPy的基础是一个同构的多维数据，数组中的元素可以通过下标来索引。在NumPy中，维度称之为axis（复数是axes），维度的数量称之为rank。

例如：　

#1.下面是一个具有rank 1的数组，axis的长度为3：
[1,2,3]

#2.下面是一个具有rank 2的数组，axis的长度也是3：
[[1,2,3],[3,4,5]]

2.创建数组

#1.创建数组
from numpy import *
a=array([1,2,2])
b=array([(1,2,3.1),(4.2,5,6),[7,8,8],[9,9,9]])


#2.创建数组错误的方法
c=array(1,2,2)#错误的，一定要在括号内加上中括号在进行创建

NumPy的数组类是ndarray，它有一个别名是 numpy.array，但这与Python标准库的array.array并不一样。后者仅仅是一个一维数组。而ndarray具有以下的属性：

  • ndarray.ndim：数组的维数。在Python世界中，维数称之为rank
  • ndarray.shape：数组的维度。这是一系列数字，长度由数组的维度（ndim）决定。例如：长度为n的一维数组的shape是n。一个n行m列的矩阵的shape是n,m
  • ndarray.size：数组中所有元素的数量
  • ndarray.dtype：数组中元素的类型，例如numpy.int32, numpy.int16或者numpy.float64
  • ndarray.itemsize：数组中每个元素的大小，单位为字节
  • ndarray.data：存储数组元素的缓冲。通常我们只需要通过下标来访问元素，而不需要访问缓冲

 

示例代码如下：

from numpy import *
a=array([1,2,2])
b=array([(1,2,3.1),(4.2,5,6),[7,8,8],[9,9,9]])

print(a.ndim)# 1
print(a.shape)# (3,)
print(a.dtype)# int32
print(a.size)# 3
print(a.itemsize)# 4
print(a.data)# <memory at 0x00000237C861F888>

print(b.ndim)# 2
print(b.shape)# (4, 3)
print(b.dtype)# float64
print(b.size)# 12
print(b.itemsize)# 8
print(b.data)# <memory at 0x00000237C1658480>

#注意：我们在创建数组的时候，我们可以指定元素的类型
c=array([[1,2,3],[4,5,6]],dtype=float)
print(c) #[[1. 2. 3.][4. 5. 6.]]

3.创建特定的array数组

在实际上的项目工程中，我们常常会需要一些特定的数据，NumPy中提供了这么一些辅助函数:

  • zeros：用来创建元素全部是0的数组
  • ones：用来创建元素全部是1的数组
  • empty：用来创建未初始化的数据，因此是内容是不确定的
  • arange：通过指定范围和步长来创建数组
  • linespace：通过指定范围和元素数量来创建数组
  • random：用来生成随机数

示例如下：

from numpy import *
a=zeros((2,3))
print(a)

b=ones((2,3))
print(b)

c=empty((2,3))
print(c)

d=arange(2,6,2)
print(d)

e=linspace(6,10,2)
print(e)

f=random.random((2,3))
print(f)


#输出结果如下：
"""
[[0. 0. 0.]
 [0. 0. 0.]]
 
[[1. 1. 1.]
 [1. 1. 1.]]
 
[[1. 1. 1.]
 [1. 1. 1.]]
 
[2 4]

[ 6. 10.]

[[0.82896183 0.55448166 0.97457398]
 [0.64787248 0.60058101 0.13440148]]
"""

4.对原有的数组进行shape与操作

除了生成数组之外，当我们已经持有某个数据之后，我们可能会需要根据已有数组来产生一些新的数据结构，这时候我们可以使用下面这些函数：

  • reshape：根据已有数组和指定的shape，生成一个新的数组
  • vstack：用来将多个数组在垂直（v代表vertical）方向拼接（数组的维度必须匹配）
  • hstack：用来将多个数组在水平（h代表horizontal）方向拼接（数组的维度必须匹配）
  • hsplit：用来将数组在水平方向拆分
  • vsplit：用来将数组在垂直方向拆分

1.vstack和hstack的用法

#vstack和hstack的用法

#1.vstack的用法
a=np.arange(15).reshape(3,5)
'''array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])'''

b=np.array([1,1,1,1,1])
f=np.vstack([a,b])

'''f=array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [ 1,  1,  1,  1,  1]])'''

#2.hstack的用法
c=np.array([1,2,3,4])
e=np.hstack([f,c.reshape(4,-1)])
'''
e=array([[ 0,  1,  2,  3,  4,  1],
       [ 5,  6,  7,  8,  9,  2],
       [10, 11, 12, 13, 14,  3],
       [ 1,  1,  1,  1,  1,  4]])'''

2.hsplit和vsplit的用法

#hsplit和vsplit的用法
#1.vspllit的用法
upper,lower=np.vsplit(e,[2])


'''
upper=array([[0, 1, 2, 3, 4, 1],
       [5, 6, 7, 8, 9, 2]])
lower=array([[10, 11, 12, 13, 14,  3],
       [ 1,  1,  1,  1,  1,  4]])

'''
#2.hsplit的用法
left,right=np.hsplit(e,[-1])

'''
left=array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [ 1,  1,  1,  1,  1]])

right=array([[1],
       [2],
       [3],
       [4]])
'''

#一些特殊的用法
#把一列变成一行
right[:,0]
array([1, 2, 3, 4])

相关测试代码：

为了便于测试，我们先创建几个数据。这里我们创建了：

  • zero_line：一行包含3个0的数组
  • one_column：一列包含3个1的数组
  • a：一个2行3列的矩阵
  • b：[11, 20)区间的整数数组

测试代码示例：

from numpy import *

zero_line = zeros((1,3))
one_column = ones((3,1))
print(zero_line,'\n')
print(one_column,'\n')

a = array([(1,2,3), (4,5,6)])
b = arange(11, 20)
print(a,'\n')
print(b,'\n')


#上述结果如下：
"""
[[0. 0. 0.]] 

[[1.]
 [1.]
 [1.]] 

[[1 2 3]
 [4 5 6]] 

[11 12 13 14 15 16 17 18 19] 
"""

#数组b原先是一个一维数组，现在我们通过reshape方法将其调整成为一个3行3列的矩阵：

b = b.reshape(3, 3)
# print(b,'\n')

"""
[[11 12 13]
 [14 15 16]
 [17 18 19]] 
"""

#接着，我们通过vstack函数，将三个数组在垂直方向拼接：
c = vstack((a, b, zero_line))
print(c)

"""
[[ 1.  2.  3.]
 [ 4.  5.  6.]
 [11. 12. 13.]
 [14. 15. 16.]
 [17. 18. 19.]
 [ 0.  0.  0.]]
"""


#同样的，我们也可以通过hstack进行水平方向的拼接。为了可以拼接我们需要先将数组a调整一下结构：
a = a.reshape(3, 2)
print(a,'\n')

"""
[[1 2]
 [3 4]
 [5 6]] 

"""

d = hstack((a, b, one_column))
print(d,'\n')

"""
[[ 1.  2. 11. 12. 13.  1.]
 [ 3.  4. 14. 15. 16.  1.]
 [ 5.  6. 17. 18. 19.  1.]] 
"""

#请注意，如果两个数组的结构是不兼容的，拼接将无法完成。例如下面这行代码，它将无法执行：
# vstack((a,b))#ValueError: all the input array dimensions except for the concatenation axis must match exactly


# 这是因为数组a具有两列，而数组b具有3列，所以它们无法拼接。



#数组的水平拆分
print(d,'\n')
e = hsplit(d, 3)
print(e,'\n')
print(e[1],'\n')


#运行结果
'''
[[ 1.  2. 11. 12. 13.  1.]
 [ 3.  4. 14. 15. 16.  1.]
 [ 5.  6. 17. 18. 19.  1.]] 

[array([[1., 2.],
       [3., 4.],
       [5., 6.]]), array([[11., 12.],
       [14., 15.],
       [17., 18.]]), array([[13.,  1.],
       [16.,  1.],
       [19.,  1.]])] 

[[11. 12.]
 [14. 15.]
 [17. 18.]] 

'''

#另外，假设我们设置的拆分数量使得原先的数组无法平均拆分，则操作会失败：
# hsplit(d, 4) # ValueError: array split does not result in an equal division

三.索引

1.普通一维数组的操作

ndarray 对象的内容可以通过索引或切片来访问和修改，就像 Python 的内置容
器对象一样。
如前所述， ndarray 对象中的元素遵循基于零的索引。 有三种可用的索引方法类
型： 字段访问，基本切片和高级索引。
基本切片是 Python 中基本切片概念到 n 维的扩展。 通过
将 start ， stop 和 step 参数提供给内置的 slice 函数来构造一个 Python
slice 对象。 此 slice 对象被传递给数组来提取数组的一部分。

相关示例代码：

#1.示例一：slice的用法
import numpy as np
a = np.arange(10)
s = slice(2,7,2)
print(a[s])#[2 4 6]


#2.示例二：通过将由冒号分隔的切片参数（ start:stop:step ） 直接提供给 ndarray 对象，也可以获得相同的结果。
import numpy as np
a = np.arange(10)
b = a[2:7:2]
print(b)#[2 4 6]


#3.示例三：对单个元素进行切片
import numpy as np
a = np.arange(10)
b = a[5]
print(b) #5


#4.示例四：对始于索引的元素进行切片
import numpy as np
a = np.arange(10)
print( a[2:])#[2 3 4 5 6 7 8 9]


#5.示例五：对索引之间的元素进行切片
import numpy as np
a = np.arange(10)
print (a[2:5])#[2 3 4]



#6.示例六：对多维 ndarray进行操作

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a,'\n')
# 对始于索引的元素进行切片
print (a[1:])

'''
[[1 2 3]
 [3 4 5]
 [4 5 6]] 

[[3 4 5]
 [4 5 6]]

'''
#7.示例七：切片还可以包括省略号（ ... ） ，来使选择元组的长度与数组的维度相同。 如果
#在行位置使用省略号，它将返回包含行中元素的 ndarray
# 最开始的数组
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print('我们的数组是：')
print(a,'\n')
# 这会返回第二列元素的数组：
print ('第二列的元素是：')
print(a[...,1],'\n')
# 现在我们从第二行切片所有元素：
print ('第二行的元素是：')
print(a[1,...],'\n')
# 现在我们从第二列向后切片所有元素：
print ('第二列及其剩余元素是：')
print (a[...,1:])


'''
我们的数组是：
[[1 2 3]
 [3 4 5]
 [4 5 6]] 

第二列的元素是：
[2 4 5] 

第二行的元素是：
[3 4 5] 

第二列及其剩余元素是：
[[2 3]
 [4 5]
 [5 6]]
'''

 2.二维数组的操作

#普通操作
X=np.arange(15).reshape(3,5)

#X=array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])


#索引取值
#1.取前两行和前三列
a=X[:2,:3]

#a=array([[0, 1, 2],
       [5, 6, 7]])

#2.取特定的某个值

b=X[1,1] #取第二行的第二个元素
#b=6



#注意：reshape的用法
#reshape的把现有的数组改成相应的几行几列的数组
#例如：X=np.arange(15).reshape(3,5)
#上述就把一个一维数组改成了一个3行5列的数组了

###特别注意：改成的数组一定要符合行数和列数想乘起来要等于原数组的个数