Python Numpy库教程

最新推荐文章于 2024-04-13 20:36:03 发布
最新推荐文章于 2024-04-13 20:36:03 发布
阅读量3.6w 收藏 515
点赞数 79
分类专栏： python 文章标签： python numpy 机器学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xjl271314/article/details/80409034
版权

本章节主要介绍的是python的一个常用库numpy，通过本章教程希望能够掌握numpy库一些常用的方法。

简介

NumPy 是一个 Python 的第三方库，代表 “Numeric Python”，主要用于数学/科学计算。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。

使用 Numpy 我们可以轻松进行如下等计算：

  • 数组的算数和逻辑运算。
  • 傅立叶变换和用于图形操作的例程。
  • 与线性代数有关的操作。 NumPy 拥有线性代数和随机数生成的内置函数。
安装

推荐使用pip命令进行安装或者下载 Anaconda (一个python集成环境应用，内置numpy等常用库)

pip install numpy
检查

我们可以引入numpy，如果未报错说明已经正常安装

import numpy as np
开始

这里介绍一个概念：NumPy - Ndarray 对象，Ndarray对象是numpy里面最重要的一个 N维数组 对象。

调用numpy.array方法可以从任何暴露数组接口的对象，或从返回数组的任何方法创建一个ndarray类型的对象。

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
语法：
参数描述
object任何暴露数组接口方法的对象都会返回一个数组或任何(嵌套)序列。
dtype数组的所需数据类型，可选。
copy可选，默认为true，对象是否被复制。
orderC(按行)、F(按列)或A(任意，默认)。
subok默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类。
ndimin指定返回数组的最小维数。

我们先看几个简单的栗子帮助我们理解：

  • 使用numpy创建一维数组：
import numpy as np
list = [1,2,3,4]
oneArray = np.array(list)

print(list)     #[1, 2, 3, 4]  这是python的列表对象
print(oneArray) #[1 2 3 4]     这是一个一维数组
  • 使用numpy创建二维数组：
import numpy as np
twoArray = np.array([[1,2],[3,4],[5,6]])

print(twoArray) #[[1 2] [3 4] [5 6]]  这是一个二维数组
数据类型：

了解了一些概念之后我们看一下numpy的数据类型：

类型描述
bool存储为一个字节的布尔值(True或False)。
int默认整数，通常为int32或int64。
int8字节（-128 ~ 127）。
int16整数（-32768 ~ 32767）。
int32整数（-2 * 31 ~ 2 * 31 - 1）。
int64整数（-2 * 63 ~ 2 * 63 - 1）。
uint8无符号整数（0 ~ 255）。
uint16无符号整数（0 ~ 65535）。
uint32无符号整数（0 ~ 2 ** 32 - 1）。
uint64无符号整数（0 ~ 2 ** 64 - 1）。
float16半精度浮点，符号位，5 位指数，10 位尾数。
float32单精度浮点，符号位，8 位指数，23 位尾数。
float64或float双精度浮点，符号位，11 位指数，52 位尾数。
complex64复数，由两个 32 位浮点表示（实部和虚部）。
complex128或complex复数，由两个 64 位浮点表示（实部和虚部）。

NumPy 数字类型是dtype(数据类型)对象的实例，每个对象具有唯一的特征。

数据类型对象 (dtype)：

数据类型对象描述了对应于数组的固定内存块的解释，取决于以下方面：

  • 数据类型(整数、浮点或者 Python 对象)
  • 数据大小
  • 字节序(小端或大端)
  • 在结构化类型的情况下，字段的名称，每个字段的数据类型，和每个字段占用的内存块部分。
  • 如果数据类型是子序列，它的形状和数据类型。
dtype构造语法：
numpy.dtype(object, align, copy)
参数描述
Object存储为一个字节的布尔值(True或False)。
Align如果为true，则向字段添加间隔，使其类似 C 的结构体。
Copy生成dtype对象的新副本，如果为flase，结果是内建数据类型对象的引用。

示例：

import numpy as np

#int 32
dt = np.dtype(np.int32)  
print(dt)

#int8，int16，int32，int64 可替换为等价的字符串 'i1'，'i2'，'i4'，以及其他。

dt4 = np.dtype('i4')  
print(dt4) # int32

dt8 = np.dtype('i8')  
print(dt8) # int64

# 使用端记号  

dt11 = np.dtype('>i4')  
print dt11 # >i4

# 创建结构化数据类型。  

dts = np.dtype([('age',np.int8)])  
print dts # [('age', 'i1')]

# 以下示例定义名为 student 的结构化数据类型，其中包含字符串字段name，整数字段age和浮点字段marks。 此dtype应用于ndarray对象

student = np.dtype([('name','S20'),  ('age',  'i1'),  ('marks',  'f4')])  
print student

#[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
dtype数组属性：

在了解了dtype数组的构造方法后，我们来了解dtype的数组属性。

方法描述
ndarray.shape返回一个包含数组维度的元组，它也可以用于调整数组大小
ndarray.reshape用来调整数组大小
ndarray.ndim返回数组的维数。
numpy.itemsize返回数组中每个元素的字节单位长度。
# ndarray.shape 返回一个包含数组维度的元组，它也可以用于调整数组大小

import numpy as np 

a = np.array([[1,2,3],[4,5,6]])  
print a.shape #(2,3) 表示这是一个二行三列的数组


----------
#改变数组的大小
b = a 
b.shape =  (3,2)  
print(b) # b成为了一个三行两列的新数组

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


----------
# 直接使用reshape方法进行转化

c = a.reshape(3,2)
print(c)

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

----------
# ndarray.ndim 返回数组的维数

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

print(d.ndim) # 1
print(e.ndim) # 2


----------
# numpy.itemsize

f = np.array([1,2,3,4,5], dtype = np.int8)  
print(f.itemsize) # 1 np.int8(一个字节)

g = np.array([1,2,3,4,5], dtype = np.float32)  
print(g.itemsize) # 4 np.float32(四个字节)
#创建数组

使用numpy创建数组有多种形式，我们一一来了解一下

  • numpy.empty # 创建指定形状和dtype的未初始化数组
  • numpy.zeros # 返回特定大小，以 0 填充的新数组
  • numpy.ones # 返回特定大小，以 1 填充的新数组

这三种方法有相同的参数列表：

参数描述
shape空数组的形状，整数或整数元组
dtype所需的输出数组类型，可选
order‘C’为按行的 C 风格数组，’F’为按列的 Fortran 风格数组

以下是这三种方法的Demo：

import numpy as np 

# 使用 numpy.empty

x = np.empty([2,2], dtype = int)  
print(x)

#由于我们未给定初始化值，所以初始化出来的值是随机int8类型

# [
#   [ 1152921504606846976 -8070441754919082034]
#   [ 4333764610           562954288073672]
# ]

----------
# 使用 numpy.zeros 

y = np.zeros([4], dtype = int)  
print(y)

#我们使用zeros方法创建了4个0元素
# [0 0 0 0]

----------
# 使用 numpy.ones 

z = np.ones([3], dtype = int)  
print(z)

#我们使用ones方法创建了3个1元素
# [1 1 1]
从已有的数据创建数组
  • numpy.asarray # 类似于numpy.array
  • numpy.fromiter # 此函数从任何可迭代对象构建一个ndarray对象，返回一个新的一维数组。 
numpy.asarray(a, dtype = None, order = None)
参数描述
a任意形式的输入参数，比如列表、列表的元组、元组、元组的元组、元组的列表
dtype输入出的数组类型，可选
order‘C’为按行的 C 风格数组，’F’为按列的 Fortran 风格数组
import numpy as np 

x =  [1,2,3]  # x是python的列表类型 不是数组
a = np.asarray(x)  
print(a)  # [1  2  3]

y = (4,5,6) # y是python的元组类型
b = np.asarray(y, dtype = float, order = 'F')
print(b)  # [4. 5. 6.]
使用numpy.fromiter
numpy.fromiter(iterable, dtype, count = -1)
参数描述
iterable任何可迭代对象
dtype返回数组的数据类型
count需要读取的数据数量，默认为-1，读取所有数据
import numpy as np 

x = range(5) # range方法创建了一个列表
a = np.fromiter(x)
print(a) #[0. 1. 2. 3. 4.]
#根据一定的步进创建数值数组

在某些特定的情况下我们可能需要创建某些数值数组，这时我们可以使用numpy.arange方法。

numpy.arange(start, stop, step, dtype)
参数描述
start范围的起始值，默认为0
stop范围的终止值(不包含)
step两个值的间隔，默认为1
dtype返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
import numpy as np

#从2开始，到15结束，不包含15，步长为2创建一个数组 
x = np.arange(2,15,2, dtype = int)  
print(x) # [ 2  4  6  8 10 12 14]
numpy.linspace 根据已有范围创建等间距的数组

这个方法常用于类似绘制直方图的时候，我们需要进行组数的分组，然后每隔一个组间距来绘制，类似这种情况用此方法来生成数组最佳。

numpy.linspace(start, stop, num, endpoint, retstep, dtype)
参数描述
start范围的起始值
stop序列的终止值，如果endpoint为true，该值包含于序列中
num要生成的等间隔样例数量，默认为50
endpoint序列中是否包含stop值，默认为ture
retstep如果为true，返回样例，以及连续数字之间的步长
dtype输出ndarray的数据类型
import numpy as np

# 假设统计 2000到10000工资的人群所占的比例，分组为21
group = 21
start = 2000
stop   = 10000

x = np.linspace(start,stop,group, retstep=True,dtype = int)
print(x)

#(array([ 2000,  2400,  2800,  3200,  3600,  4000,  4400,  4800,  5200,
        5600,  6000,  6400,  6800,  7200,  7600,  8000,  8400,  8800,
        9200,  9600, 10000]), 400.0)
切片和索引的调用

我们先来看一下python中的切片和索引

#创建一个列表

pyList = []

for item in range(1,11):
    pyList.append(item)

print(pyList)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

x = pyList[2]
print(x)
# 3 下标从0开始

y = pyList[:5]
print(y)
# [1, 2, 3, 4, 5] 从索引0开始取，直到索引5为止，但不包括索引5

z = pyList[-2:]
print(z)
# [9, 10]  从倒数第一个数开始取，直到索引-2为止，倒数第一个数索引为-1

我们再来看看 numpy中的索引和切片

import numpy as np

#slice(start，stop, step)

a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
s = slice(2,7,2)  # 从数组索引为 2开始，到7结束，步长为2  ——>  2 4 6
print a[s]  # [2 4 6]

s2 = slice(3,8,1) #  stop不会包含在内
print(a[s2])# [3 4 5 6 7]

# 我们可以直接将切片数据通过冒号的间隔方式直接传递

b = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
print(b[2:7:2])  # [2 4 6]

# 如果只输入一个参数，则将返回与索引对应的单个项目

c  = b[3]
print(c) # 3

#  如果使用a:，则从该索引向后的所有项目将被提取。

d = b[3:]
print(d) # [3 4 5 6 7 8 9]

# 如果使用两个参数(以:分隔)，则对两个索引(不包括停止索引)之间的元素以默认步骤进行切片。

e = b[3:7]
print(e)  # [3 4 5 6]

# 如果只传冒号 类似与python的拷贝

f = b[:]
print(f) # [0 1 2 3 4 5 6 7 8 9]
numpy 广播

NumPy 广播 指的是在算术运算期间处理不同形状的数组的能力。

譬如我们将一个一维数组与一维数组相加肯定是可以操作的，那么我们如果将一个一维数组与一个二维数组相加呢？本身这种操作是不可行的但是使用numpy我们就可以进行这种操作。

如果满足以下规则，可以进行广播：
  • ndim(维度)较小的数组会在前面追加一个长度为 1 的维度。
  • 输出数组的每个维度的大小是输入数组该维度大小的最大值。
  • 如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。
  • 如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。
如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。
  • 数组拥有相同形状。
  • 数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。
  • 数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。

我们看下下面的这个栗子：

import numpy as np 
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) 
b = np.array([1.0,2.0,3.0])  

print('第一个数组：') 
print(a)
print('\n' )   
print('第二个数组：')  
print(b)
print('\n') 
print('第一个数组加第二个数组：')  
print(a + b)

# 第一个数组：
[[ 0.  0.  0.]
 [10. 10. 10.]
 [20. 20. 20.]
 [30. 30. 30.]]

# 第二个数组：
[1. 2. 3.]

# 第一个数组加第二个数组：
[[ 1.  2.  3.]
 [11. 12. 13.]
 [21. 22. 23.]
 [31. 32. 33.]]

第二个数组维度小于第一个，使用加法相加的时候，第二数数组会扩展成为

[[1. 2. 3.]
 [1. 2. 3.]
 [1. 2. 3.]
 [1. 2. 3.]]
NumPy - 常用数组操作
方法描述
flat数组上的一维迭代器
flatten返回折叠为一维的数组副本
ravel返回连续的展开数组
transpose翻转数组的维度
ndarray.T和self.transpose()相同
rollaxis向后滚动指定的轴
swapaxes互换数组的两个轴
flat 将多维数组转化为一维后返回对应下标的元素：
import numpy as np
a = np.arange(8).reshape(2,4)
print('原始数组：')
print(a)
print('\n')

print('调用 flat 函数之后：')
# 返回展开数组中的下标的对应元素
print(a.flat[5])

# 原始数组：
[[0 1 2 3]
 [4 5 6 7]]

# 调用 flat 函数之后：
5
numpy.ndarray.flatten 返回折叠为一维的数组副本，函数接受下列参数：
ndarray.flatten(order)
# order：
# 'C' — 按行，
# 'F' — 按列，
# 'A' — 原顺序，
# 'k' — 元素在内存中的出现顺序。
import numpy as np
a = np.arange(8).reshape(2,4)

print('原数组：')
print(a)
print('\n') 
# default is column-major

print('展开的数组：')
print(a.flatten())
print('\n')  

print('以 F 风格顺序展开的数组：')
print(a.flatten(order = 'F'))

# 原数组：
[[0 1 2 3]
 [4 5 6 7]]

# 展开的数组：
[0 1 2 3 4 5 6 7]

# 以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]
numpy.ravel返回展开的一维数组，并且按需生成副本。返回的数组和输入数组拥有相同数据类型。这个函数接受两个参数:
numpy.ravel(a, order)
# order：
# 'C' — 按行，
# 'F' — 按列，
# 'A' — 原顺序，
# 'k' — 元素在内存中的出现顺序。


import numpy as np
a = np.arange(8).reshape(2,4)

print('原数组：')
print(a)
print('\n')  

print('调用 ravel 函数之后：')
print(a.ravel())  
print('\n')

print('以 F 风格顺序调用 ravel 函数之后：')
print(a.ravel(order = 'F'))

# 原数组：
[[0 1 2 3]
 [4 5 6 7]]

# 调用 ravel 函数之后：
[0 1 2 3 4 5 6 7]

# 以 F 风格顺序调用 ravel 函数之后：
[0 4 1 5 2 6 3 7]
numpy.transpose 翻转给定数组的维度。如果可能的话它会返回一个视图。函数接受下列参数:
numpy.transpose(arr, axes)
# arr：要转置的数组
# axes：整数的列表，对应维度，通常所有维度都会翻转。


import numpy as np
a = np.arange(12).reshape(3,4)

print('原数组：')
print(a)  
print('\n')

print('转置数组：')
print(np.transpose(a)) #等同于 a.T

# 原数组：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]]

# 转置数组：
[[ 0 4 8]
 [ 1 5 9]
 [ 2 6 10]
 [ 3 7 11]]
numpy.rollaxis向后滚动特定的轴，直到一个特定位置。这个函数接受三个参数：
numpy.rollaxis(arr, axis, start)

# arr：输入数组
# axis：要向后滚动的轴，其它轴的相对位置不会改变
# start：默认为零，表示完整的滚动。会滚动到特定位置。

# 创建了三维的 ndarray
import numpy as np
a = np.arange(8).reshape(2,2,2)

print('原数组：')
print(a)
print('\n')
# 将轴 2 滚动到轴 0(宽度到深度)

print('调用 rollaxis 函数：')
print(np.rollaxis(a,2))  
# 将轴 0 滚动到轴 1：(宽度到高度)
print('\n')

print('调用 rollaxis 函数：')
print(np.rollaxis(a,2,1))

# 原数组：
[[
   [0 1]
   [2 3]
 ]
 [
   [4 5]
   [6 7]
 ]
]

# 调用 rollaxis 函数：
[[[0 2]
 [4 6]]
 [[1 3]
 [5 7]]]

# 调用 rollaxis 函数：
[[[0 2]
 [1 3]]
 [[4 6]
 [5 7]]]
numpy.swapaxes交换数组的两个轴。对于 1.10 之前的 NumPy 版本，会返回交换后数组的试图。这个函数接受下列参数：
numpy.swapaxes(arr, axis1, axis2)

# arr：要交换其轴的输入数组
# axis1：对应第一个轴的整数
# axis2：对应第二个轴的整数


# 创建了三维的 ndarray
import numpy as np
a = np.arange(8).reshape(2,2,2)

print('原数组：')
print(a)
print('\n')  
# 现在交换轴 0(深度方向)到轴 2(宽度方向)

print('调用 swapaxes 函数后的数组：')
print(np.swapaxes(a, 2, 0))

# 原数组：
[[[0 1]
 [2 3]]

 [[4 5]
  [6 7]]]

# 调用 swapaxes 函数后的数组：
[[[0 4]
 [2 6]]

 [[1 5]
  [3 7]]]

常用修改维度：

方法描述
broadcast产生模仿广播的对象
broadcast_to将数组广播到新形状
expand_dims扩展数组的形状
squeeze从数组的形状中删除单维条目
broadcast 此功能模仿广播机制。 它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果：
import numpy as np
x = np.array([[1], [2], [3]])
y = np.array([4, 5, 6])  

# 对 y 广播 x
b = np.broadcast(x,y)  
# 它拥有 iterator 属性，基于自身组件的迭代器元组

print('对 y 广播 x：')
r,c = b.iters
print(r.next(), c.next() )
print(r.next(), c.next() )
print('\n')  
# shape 属性返回广播对象的形状

print('广播对象的形状：')
print(b.shape)
print('\n')  
# 手动使用 broadcast 将 x 与 y 相加
b = np.broadcast(x,y)
c = np.empty(b.shape)

print('手动使用 broadcast 将 x 与 y 相加：')
print(c.shape)
print('\n')  
c.flat = [u + v for (u,v) in b]

print('调用 flat 函数：')
print(c)
print('\n')  
# 获得了和 NumPy 内建的广播支持相同的结果

print('x 与 y 的和：')
print(x + y)

# 对 y 广播 x：
1 4
1 5

# 广播对象的形状：
(3, 3)

# 手动使用 broadcast 将 x 与 y 相加：
(3, 3)

# 调用 flat 函数：
[[ 5. 6. 7.]
 [ 6. 7. 8.]
 [ 7. 8. 9.]]

# x 与 y 的和：
[[5 6 7]
 [6 7 8]
 [7 8 9]]
numpy.broadcast_to将数组广播到新形状。 它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError:
numpy.broadcast_to(array, shape, subok)

import numpy as np
a = np.arange(4).reshape(1,4)

print('原数组：')
print(a)
print('\n')  

print('调用 broadcast_to 函数之后：')
print(np.broadcast_to(a,(4,4)))

# 原数组：
[[0 1 2 3]]


# 调用 broadcast_to 函数之后：
[[0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]]
numpy.expand_dims函数通过在指定位置插入新的轴来扩展数组形状。该函数需要两个参数:
numpy.expand_dims(arr, axis)

# arr：输入数组
# axis：新轴插入的位置

import numpy as np
x = np.array(([1,2],[3,4]))

print('数组 x：')
print(x)
print('\n') 
y = np.expand_dims(x, axis = 0)

print('数组 y：')
print(y)
print('\n')

print('数组 x 和 y 的形状：')
print(x.shape, y.shape)
print('\n')  
# 在位置 1 插入轴
y = np.expand_dims(x, axis = 1)

print('在位置 1 插入轴之后的数组 y：')
print( y)
print('\n') 

print('x.ndim 和 y.ndim：')
print(x.ndim,y.ndim)
print('\n')  

print('x.shape 和 y.shape：')
print(x.shape, y.shape)


# 数组 x：
[[1 2]
 [3 4]]


# 数组 y：
[[[1 2]
  [3 4]]]


# 数组 x 和 y 的形状：
(2, 2) (1, 2, 2)


# 在位置 1 插入轴之后的数组 y：
[[[1 2]]

 [[3 4]]]


# x.ndim 和 y.ndim：
2 3


# x.shape 和 y.shape：
(2, 2) (2, 1, 2)
numpy.squeeze从给定数组的形状中删除一维条目。 此函数需要两个参数:
numpy.squeeze(arr, axis)

# arr：输入数组
# axis：整数或整数元组，用于选择形状中单一维度条目的子集

import numpy as np  
x = np.arange(9).reshape(1,3,3)

print('数组 x：')
print(x)
print('\n')  
y = np.squeeze(x)

print('数组 y：')
print(y)
print('\n')  

print('数组 x 和 y 的形状：')
print(x.shape, y.shape)

# 数组 x：
[[[0 1 2]
  [3 4 5]
  [6 7 8]]]


# 数组 y：
[[0 1 2]
 [3 4 5]
 [6 7 8]]


# 数组 x 和 y 的形状：
(1, 3, 3) (3, 3)
数组的连接
方法描述
concatenate沿着现存的轴连接数据序列
stack沿着新轴连接数组序列
hstack水平堆叠序列中的数组(列方向)
vstack竖直堆叠序列中的数组(行方向)
numpy.concatenate沿指定轴连接相同形状的两个或多个数组：
numpy.concatenate((a1, a2, ...), axis)

# a1, a2, ...：相同类型的数组序列
# axis：沿着它连接数组的轴，默认为 0

import numpy as np
a = np.array([[1,2],[3,4]])

print('第一个数组：')
print(a)
print('\n')  
b = np.array([[5,6],[7,8]])

print('第二个数组：')
print(b)
print('\n') 
# 两个数组的维度相同

print('沿轴 0 连接两个数组：')
print(np.concatenate((a,b)))
print('\n')  

print('沿轴 1 连接两个数组：')
print(np.concatenate((a,b),axis = 1))

# 第一个数组：
[[1 2]
 [3 4]]


# 第二个数组：
[[5 6]
 [7 8]]


# 沿轴 0 连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]


# 沿轴 1 连接两个数组：
[[1 2 5 6]
 [3 4 7 8]]
numpy.stack沿新轴连接数组序列：
numpy.stack(arrays, axis)

# arrays：相同形状的数组序列
# axis：返回数组中的轴，输入数组沿着它来堆叠

import numpy as np
a = np.array([[1,2],[3,4]])

print('第一个数组：')
print(a)
print('\n')
b = np.array([[5,6],[7,8]])

print('第二个数组：')
print(b)
print('\n')  

print('沿轴 0 堆叠两个数组：')
print(np.stack((a,b),0))
print('\n')  

print('沿轴 1 堆叠两个数组：')
print(np.stack((a,b),1))

# 第一个数组：
[[1 2]
 [3 4]]


# 第二个数组：
[[5 6]
 [7 8]]


# 沿轴 0 堆叠两个数组：
[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]


# 沿轴 1 堆叠两个数组：
[[[1 2]
  [5 6]]

 [[3 4]
  [7 8]]]
numpy.hstack —— numpy.stack函数的变体，通过堆叠来生成水平的单个数组:
import numpy as np
a = np.array([[1,2],[3,4]])

print('第一个数组：')
print(a)
print('\n')
b = np.array([[5,6],[7,8]])

print('第二个数组：')
print(b)
print('\n')  

print('水平堆叠：')
c = np.hstack((a,b))
print(c)
print('\n')

# 第一个数组：
[[1 2]
 [3 4]]


# 第二个数组：
[[5 6]
 [7 8]]


# 水平堆叠：
[[1 2 5 6]
 [3 4 7 8]]
numpy.vstack——>numpy.stack函数的变体，通过堆叠来生成竖直的单个数组:
import numpy as np
a = np.array([[1,2],[3,4]])

print('第一个数组：')
print(a)
print('\n')
b = np.array([[5,6],[7,8]])

print('第二个数组：')
print(b)
print('\n')  

print('垂直堆叠：')
c = np.vstack((a,b))
print(c)
print('\n')

# 第一个数组：
[[1 2]
 [3 4]]


# 第二个数组：
[[5 6]
 [7 8]]


# 垂直堆叠：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
数组分割常用方法：
方法描述
split将一个数组分割为多个子数组
hsplit将一个数组水平分割为多个子数组(按列)
vsplit将一个数组竖直分割为多个子数组(按行)
numpy.split：
numpy.split(ary, indices_or_sections, axis)

# ary：被分割的输入数组
# indices_or_sections：可以是整数，表明要从输入数组创建的，等大小的子数组的数量。  如果此参数是一维数组，则其元素表明要创建新子数组的点。
# axis：默认为 0


import numpy as np
a = np.arange(9)

print('第一个数组：')
print(a)
print('\n' ) 

print('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print(b)
print('\n' ) 

print('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print(b)

# 第一个数组：
[0 1 2 3 4 5 6 7 8]


# 将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]


# 将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
numpy.hsplit是split()函数的特例，其中轴为 1 表示水平分割，无论输入数组的维度是什么:
import numpy as np
a = np.arange(16).reshape(4,4)

print('第一个数组：')
print(a)
print('\n')  

print('水平分割：')
b = np.hsplit(a,2)
print(b)
print('\n')

# 第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]


# 水平分割：
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
numpy.vsplit是split()函数的特例，其中轴为 0 表示竖直分割，无论输入数组的维度是什么:
import numpy as np
a = np.arange(16).reshape(4,4)

print('第一个数组：')
print(a)
print('\n')  

print('竖直分割：')
b = np.vsplit(a,4)
print(b)
print('\n')

# 第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]


# 竖直分割：
[array([[0, 1, 2, 3]]), 
 array([[4, 5, 6, 7]]), 
 array([[ 8,  9, 10, 11]]), 
 array([[12, 13, 14, 15]])
]
添加/删除元素：
方法描述
resize返回指定形状的新数组
append将值添加到数组末尾
insert沿指定轴将值插入到指定下标之前
delete返回删掉某个轴的子数组的新数组
unique寻找数组内的唯一元素
numpy.resize返回指定大小的新数组。 如果新大小大于原始大小，则包含原始数组中的元素的重复副本：
numpy.resize(arr, shape)

# arr：要修改大小的输入数组
# shape：返回数组的新形状

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

print('第一个数组：')
print(a)
print('\n')

print('第一个数组的形状：')
print(a.shape)
print('\n' ) 
b = np.resize(a, (3,2))

print('第二个数组：')
print(b)
print('\n')

print('第二个数组的形状：')
print(b.shape)
print('\n') 
# 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了

print('修改第二个数组的大小：')
b = np.resize(a,(3,3))
print(b)

# 第一个数组：
[[1 2 3]
 [4 5 6]]


# 第一个数组的形状：
(2, 3)


# 第二个数组：
[[1 2]
 [3 4]
 [5 6]]


# 第二个数组的形状：
(3, 2)


# 修改第二个数组的大小：首先转为2*3然后补了一行
[[1 2 3]
 [4 5 6]
 [1 2 3]]
numpy.append在输入数组的末尾添加值。 附加操作不是原地的，而是分配新的数组。 此外，输入数组的维度必须匹配否则将生成ValueError：
numpy.append(arr, values, axis)

# arr：输入数组
# values：要向arr添加的值，比如和arr形状相同(除了要添加的轴)
# axis：沿着它完成操作的轴。如果没有提供，两个参数都会被展开。

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

print('第一个数组：')
print(a)
print('\n'  )

print('向数组添加元素：')
print(np.append(a, [7,8,9]))
print('\n' ) 

print('沿轴 0 添加元素：')
print(np.append(a, [[7,8,9]],axis = 0))
print('\n')  

print ('沿轴 1 添加元素：')
print(np.append(a, [[5,5,5],[7,8,9]],axis = 1))

# 第一个数组：
[[1 2 3]
 [4 5 6]]


# 向数组添加元素：
[1 2 3 4 5 6 7 8 9]


# 沿轴 0 添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]


# 沿轴 1 添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]
numpy.insert在给定索引之前，沿给定轴在输入数组中插入值。 如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开：
numpy.insert(arr, obj, values, axis)

# arr：输入数组
# obj：在其之前插入值的索引
# values：要插入的值
# axis：沿着它插入的轴，如果未提供，则输入数组会被展开

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

print('第一个数组：')
print(a)
print('\n')  

print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print(np.insert(a,3,[11,12]))
print('\n' ) 
print('传递了 Axis 参数。 会广播值数组来配输入数组。')

print('沿轴 0 广播：')
print(np.insert(a,1,[11],axis = 0))
print('\n')  

print('沿轴 1 广播：')
print(np.insert(a,1,11,axis = 1))

# 第一个数组：
[[1 2]
 [3 4]
 [5 6]]


# 未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]


# 传递了 Axis 参数。 会广播值数组来配输入数组。
# 沿轴 0 广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]


# 沿轴 1 广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]
numpy.delete返回从输入数组中删除指定子数组的新数组。 与insert()函数的情况一样，如果未提供轴参数，则输入数组将展开:
# arr：输入数组
# obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
# axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

import numpy as np
a = np.arange(12).reshape(3,4)

print('第一个数组：')
print(a)
print('\n' ) 

print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print(np.delete(a,5))
print('\n')

print('删除第二列：') 
print(np.delete(a,1,axis = 1))
print('\n')  

print('包含从数组中删除的替代值的切片：')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print(np.delete(a, np.s_[::2]))

# 第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]


# 未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0  1  2  3  4  6  7  8  9 10 11]


# 删除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]


# 包含从数组中删除的替代值的切片：
[ 2  4  6  8 10]
numpy.unique返回输入数组中的去重元素数组。 该函数能够返回一个元组，包含去重数组和相关索引的数组。 索引的性质取决于函数调用中返回参数的类型:
numpy.unique(arr, return_index, return_inverse, return_counts)

# arr：输入数组，如果不是一维数组则会展开
# return_index：如果为true，返回输入数组中的元素下标
# return_inverse：如果为true，返回去重数组的下标，它可以用于重构输入数组
# return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

import numpy as np
a = np.array([5,2,6,2,7,5,6,8,2,9])

print('第一个数组：')
print(a)
print('\n')  

print('第一个数组的去重值：')
u = np.unique(a)
print(u)
print('\n' ) 

print('去重数组的索引数组：')
u,indices = np.unique(a, return_index = True)
print(indices)
print('\n' ) 

print('我们可以看到每个和原数组下标对应的数值：')
print(a)
print('\n')  

print('去重数组的下标：')
u,indices = np.unique(a,return_inverse = True)
print(u)
print('\n')

print('下标为：')
print(indices)
print('\n')  

print('使用下标重构原数组：')
print(u[indices])
print('\n')  

print('返回去重元素的重复数量：')
u,indices = np.unique(a,return_counts = True)
print(u)
print(indices)

# 第一个数组：
[5 2 6 2 7 5 6 8 2 9]


# 第一个数组的去重值：
[2 5 6 7 8 9]


# 去重数组的索引数组：
[1 0 2 4 7 9]


# 我们可以看到每个和原数组下标对应的数值：
[5 2 6 2 7 5 6 8 2 9]


# 去重数组的下标：
[2 5 6 7 8 9]


# 下标为：
[1 0 2 0 3 1 2 4 0 5]


# 使用下标重构原数组：
[5 2 6 2 7 5 6 8 2 9]


# 返回去重元素的重复数量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]
NumPy - 位运算

Numpy的未运算主要包括了常见的与或非等二进制运算。

方法描述
bitwise_and对数组元素执行位 与 操作
bitwise_or对数组元素执行位 或 操作
invert计算位非
left_shift向左移动二进制表示的位
right_shift向右移动二进制表示的位
np.bitwise_and()对输入数组中的整数的二进制表示的相应位执行位与运算：
import numpy as np 
print('13 和 17 的二进制形式：')
a,b = 13,17 

# bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

print(bin(a), bin(b)) 
print('\n')  

print('13 和 17 的位与：') 
print(np.bitwise_and(13, 17))

# 我们知道二进制与十进制之间的转换是，例如 10 = 1010 即1*2^3+0*2^2+1*2^1+0*2^0。
# 13 和 17 的二进制形式：
0b1101 0b10001

# 13 和 17 的位与：
# 只有同为1的时候为1 10001与 1101 得到 00001
1
np.bitwise_or()对输入数组中的整数的二进制表示的相应位执行位或运算：
import numpy as np 
print('13 和 17 的二进制形式：')
a,b = 13,17 
print(bin(a), bin(b)) 
print('\n')  

print('13 和 17 的位或：') 
print(np.bitwise_or(13, 17))

# 13 和 17 的二进制形式：
0b1101 0b10001


# 13 和 17 的位或：
# 位或操作是只要满足其中一个为1，即为真 1101 或 10001等于 11101 = 16+8+4+1 = 29
29
invert计算输入数组中整数的位非结果。 对于有符号整数，返回补码:
import numpy as np 

print('13 的位反转，其中 ndarray 的 dtype 是 uint8：' )
print(np.invert(np.array([13], dtype = np.uint8))) 
print('\n')  
# 比较 13 和 242 的二进制表示，我们发现了位的反转

print('13 的二进制表示：') 
print(np.binary_repr(13, width = 8)) 
print('\n')  

print('242 的二进制表示：') 
print(np.binary_repr(242, width = 8))

# 13 的位反转，其中 ndarray 的 dtype 是 uint8：
[242]


# 13 的二进制表示： 由于我们设置的是int8类型 所以在前面补了4个0
00001101

# np.binary_repr()函数返回给定宽度中十进制数的二进制表示
# 242 的二进制表示： 
11110010
numpy.left_shift()将数组元素的二进制表示中的位向左移动到指定位置，右侧附加相等数量的 0：
import numpy as np 

print('将 10 左移两位：') 
print(np.left_shift(10,2))  
print('\n')   

print('10 的二进制表示：')  
print(np.binary_repr(10, width = 8))  
print('\n')   

print('40 的二进制表示：')  
print(np.binary_repr(40, width = 8))  
#  '00001010' 中的两位移动到了左边，并在右边添加了两个 0。

# 将 10 左移两位：
40


# 10 的二进制表示：
00001010


# 40 的二进制表示：
00101000
numpy.right_shift()函数将数组元素的二进制表示中的位向右移动到指定位置，左侧附加相等数量的 0:
import numpy as np 

print('将 40 右移两位：') 
print(np.right_shift(40,2))  
print('\n')   

print('10 的二进制表示：')  
print(np.binary_repr(10, width = 8))  
print('\n')   

print('40 的二进制表示：')  
print(np.binary_repr(40, width = 8))  
#  '00001010' 中的两位移动到了右边，并在左边添加了两个 0。

# 将 40 右移两位：
10


# 10 的二进制表示：
00001010


# 40 的二进制表示：
00101000
NumPy - 字符串函数
方法描述
add()返回两个str或Unicode数组的逐个字符串连接
multiply()返回按给定参数多重连接后的字符串
center()返回给定字符串的副本，其中元素位于特定字符串的中央
capitalize()返回给定字符串的副本，其中只有第一个字符串大写
title()返回字符串或 Unicode 的按参数转换成开头字母大写
lower() 返回给定参数每个字符转化为小写的副本
upper()返回给定参数每个字符转化为大写的副本
split()返回字符串中的单词列表，并使用分隔符来分割
splitlines()返回元素中的行列表，以换行符分割
strip()返回数组副本，其中元素移除了开头或者结尾处的特定字符
join()返回一个字符串，它是序列中字符串的连接
replace()返回字符串的副本，其中所有子字符串的出现位置都被新字符串取代
decode()按参数调用str.decode
encode()按参数调用str.encode
numpy.char.add()：
import numpy as np 
print('连接两个字符串：')
print(np.char.add(['hello'],[' world'])) 
print('\n')

print('连接示例：') 
print(np.char.add(['hello', 'world'],[' hello', ' python']))

# 连接两个字符串：
['hello world']


# 连接示例：
['hello hello' 'world python']
numpy.char.multiply()返回给定参数的多重连接：
import numpy as np 
print(np.char.multiply('hello ',3))

# hello hello hello
numpy.char.center()返回所需宽度的数组，以便输入字符串位于中心，并使用fillchar在左侧和右侧进行填充:
import numpy as np 
# np.char.center(arr, width,fillchar) 
print(np.char.center('hello', 10,fillchar = '*'))

# **hello***  总宽度为10 文本占位为5 其余 5位 *补充分别添加在两侧

print(np.char.center('hello', 11,fillchar = '-'))

# ---hello---  单数的时候默认多的补在右侧
numpy.char.capitalize()返回字符串的副本，其中第一个字母大写：
import numpy as np 
print(np.char.capitalize('hello world'))

# Hello world
numpy.char.title()返回输入字符串的按元素标题转换版本，其中每个单词的首字母都大写:
import numpy as np 
print(np.char.capitalize('hello world'))

# Hello World
numpy.char.lower()返回一个数组，其元素转换为小写。它对每个元素调用str.lower：
import numpy as np 
print(np.char.lower('HELLO WORLD'))

# hello world
numpy.char.upper()返回一个数组，其元素转换为大写。它对每个元素调用str.upper：
import numpy as np 
print(np.char.upper('hello world'))

# HELLO WORLD
numpy.char.split()返回输入字符串中的单词列表。 默认情况下，空格用作分隔符。 否则，指定的分隔符字符用于分割字符串：
import numpy as np 
print(np.char.split ('hello how are you?')) 
print(np.char.split ('Hello,python,numpy', sep = ','))

# ['hello', 'how', 'are', 'you?']
# ['Hello', 'python', 'numpy']
numpy.char.splitlines()回数组中元素的单词列表，以换行符分割:
import numpy as np 
print(np.char.splitlines ('hello\rhow are you?')) 
print(np.char.splitlines ('Hello,python\nnumpy'))

# ['hello', 'how are you?']
# ['Hello,python', 'numpy']

# '\n'，'\r'，'\r\n'都会用作换行符。
numpy.char.strip()返回数组的副本，其中元素移除了开头或结尾处的特定字符:
import numpy as np 
print(np.char.strip ('hello world','@')) 
print(np.char.strip (['javascript','python'],'node@'))

# hello world
# ['javascript' 'pyth']
numpy.char.join()返回一个字符串，其中单个字符由特定的分隔符连接:
import numpy as np 
print(np.char.join(':','ymd')) 
print(np.char.join([':','-'],['abc','ymd']))

# y:m:d
# ['a:b:c' 'y-m-d']
numpy.char.replace()返回字符串副本，其中所有字符序列的出现位置都被另一个给定的字符序列取代：
import numpy as np 
print(np.char.replace ('Lxq is a good gril', 'good', 'pretty'))

# Lxq is a pretty gril
numpy.char.decode()在给定的字符串中使用特定编码调用str.decode():
import numpy as np 

a = np.char.encode('hello', 'cp500') 
print(a) 
print(np.char.decode(a,'cp500'))

# b'\x88\x85\x93\x93\x96'
# hello
numpy.char.encode()对数组中的每个元素调用str.encode函数。 默认编码是utf_8，可以使用标准 Python 库中的编解码器:
import numpy as np 
a = np.char.encode('hello', 'cp500') 
print(a)

# b'\x88\x85\x93\x93\x96'
NumPy - 算数函数
三角函数 NumPy 拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值:
# 1 弧度 = 360 / 2 π = 180 / π

import numpy as np
a = np.array([0,30,45,60,90])  
print('不同角度的正弦值：')  
# 通过乘 pi/180 转化为弧度  
print(np.sin(a*np.pi/180))   
print('\n')  
print('数组中角度的余弦值：')   
print(np.cos(a*np.pi/180))   
print('\n')   
print('数组中角度的正切值：')   
print(np.tan(a*np.pi/180)) 

# 不同角度的正弦值：
[0.         0.5        0.70710678 0.8660254  1.        ]


# 数组中角度的余弦值：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
 6.12323400e-17]


# 数组中角度的正切值：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
 1.63312394e+16]
arcsin，arccos，和arctan函数返回给定角度的sin，cos和tan的反三角函数。 这些函数的结果可以通过numpy.degrees()函数通过将弧度制转换为角度制来验证。

y=sinx ==> x = arcsiny 通过已知对应的y值来求所对应的x弧度值

import numpy as np
a = np.array([0,30,45,60,90])  
print('含有正弦值的数组：')
sin = np.around(np.sin(a*np.pi/180),2)  
print(sin)
print('\n')  
print('计算角度的反正弦，返回值以弧度为单位：')
inv = np.around(np.arcsin(sin),2)  
print(inv)
print('\n')  
print('通过转化为角度制来检查结果：')  
print(np.around(np.degrees(inv)),2)   
print('\n')  
print('arccos 和 arctan 函数行为类似：')
cos = np.cos(a*np.pi/180)  
print(np.around(cos),2) 
print('\n')  
print('反余弦：')
inv = np.arccos(cos)  
print(np.around(inv),2) 
print('\n')  
print('角度制单位：')  
print(np.around(np.degrees(inv)),2)   
print('\n')  
print('tan 函数：')
tan = np.tan(a*np.pi/180)  
print(np.around(tan),2) 
print('\n')  
print('反正切：')
inv = np.arctan(tan)  
print(np.around(inv),2) 
print('\n')  
print('角度制单位：')  
print(np.around(np.degrees(inv)),2) 

# 含有正弦值的数组：
[0.   0.5  0.71 0.87 1.  ]


# 计算角度的反正弦，返回值以弧度为单位：
[0.   0.52 0.79 1.06 1.57]


# 通过转化为角度制来检查结果：
[ 0. 30. 45. 61. 90.] 2


# arccos 和 arctan 函数行为类似：
[1. 1. 1. 1. 0.] 2


# 反余弦：
[0. 1. 1. 1. 2.] 2


# 角度制单位：
[ 0. 30. 45. 60. 90.] 2


# tan 函数：
[0.00000000e+00 1.00000000e+00 1.00000000e+00 2.00000000e+00
 1.63312394e+16] 2


# 反正切：
[0. 1. 1. 1. 2.] 2


# 角度制单位：
[ 0. 30. 45. 60. 90.] 2
numpy.around()返回四舍五入到所需精度的值：
参数描述
a输入数组
decimals要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
import numpy as np
a = 1.0455333
b = [1.034,5.36,3.999]

print(np.around(a,2))
print(np.around(b,2))

# 1.05
# [1.03 5.36 4.  ]
numpy.floor()返回不大于输入参数的最大整数。 即标量x 的下限是最大的整数i ，使得i <= x。 注意在Python中，向下取整总是从 0 舍入:
import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print('提供的数组：')  
print(a)  
print('\n')    
print('修改后的数组：')    
print(np.floor(a))  

# 提供的数组：
[-1.7  1.5 -0.2  0.6 10. ]


# 修改后的数组：
[-2.  1. -1.  0. 10.]
numpy.ceil()返回输入值的上限，即，标量x的上限是最小的整数i ，使得i> = x:
import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
print('提供的数组：')  
print(a)  
print('\n')    
print('修改后的数组：')    
print(np.ceil(a))  

# 提供的数组：
[-1.7  1.5 -0.2  0.6 10. ]


# 修改后的数组：
[-1.  2. -0.  1. 10.]
NumPy - 算数运算

算术运算包括add()，subtract()，multiply()和divide())等方法，其中输入数组必须具有相同的形状或符合数组广播规则：

加减乘除：
import numpy as np 
a = np.arange(4, dtype = np.float_).reshape(2,2)  
print('第一个数组：')  
print(a) 
print('\n')  
print('第二个数组：') 
b = np.array([10,10])  
print(b) 
print('\n')  
print('两个数组相加：')  
print(np.add(a,b))  
print('\n')  
print('两个数组相减：')  
print(np.subtract(a,b))  
print('\n')  
print('两个数组相乘：')  
print(np.multiply(a,b))  
print('\n')  
print('两个数组相除：')  
print(np.divide(a,b))

# 第一个数组：
[[0. 1.]
 [2. 3.]]


# 第二个数组：
[10 10]


# 两个数组相加：
[[10. 11.]
 [12. 13.]]


# 两个数组相减：
[[-10.  -9.]
 [ -8.  -7.]]


# 两个数组相乘：
[[ 0. 10.]
 [20. 30.]]


# 两个数组相除：
[[0.  0.1]
 [0.2 0.3]]
numpy.reciprocal()返回参数逐元素的倒数，。 由于 Python 处理整数除法的方式，对于绝对值大于 1 的整数元素，结果始终为 0， 对于整数 0，则发出溢出警告：
import numpy as np 
a = np.array([0.25,  1.5,  1,  0,  100])  
print('我们的数组是：')  
print(a)  
print('\n')   
print('调用 reciprocal 函数：')   
print(np.reciprocal(a))   
print('\n')  
b = np.array([100], dtype =  int)  
print('第二个数组：')   
print(b) 
print('\n')   
print('调用 reciprocal 函数：')   
print(np.reciprocal(b)) 

# 我们的数组是：
[  0.25   1.5    1.     0.   100.  ]


# 调用 reciprocal 函数：  对于整数 0，则发出溢出警告
/__dirname/test.py:7: RuntimeWarning: divide byzero encountered in reciprocal
  print(np.reciprocal(a))
[4.         0.66666667 1.                inf 0.01      ]


# 第二个数组：
[100]


# 调用 reciprocal 函数： 对于绝对值大于 1 的整数元素，结果始终为 0
[0]
numpy.power()将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂：
import numpy as np 
a = np.array([1,  2,  3,  4,  5])  

print(np.power(a,2))

# [ 1  4  9 16 25]
numpy.mod()返回输入数组中相应元素的除法余数：
import numpy as np 
a = np.array([10,20,30]) 
b = np.array([3,5,7]) 

print(np.mod(a,b))

# [1 0 2]

以下函数用于操作复数：

方法描述
numpy.real()返回复数类型参数的实部
numpy.imag()返回复数类型参数的虚部
numpy.conj()返回通过改变虚部的符号而获得的共轭复数
numpy.angle()返回复数参数的角度。 函数的参数是degree。 如果为true，返回的角度以角度制来表示，否则为以弧度制来表示
import numpy as np 
a = np.array([-5.6j,  0.2j,  11.  ,  1+1j])  
print('我们的数组是：')  
print(a)  
print('\n')   
print('调用 real() 函数：')   
print(np.real(a))   
print('\n')   
print('调用 imag() 函数：')   
print(np.imag(a))   
print('\n')   
print('调用 conj() 函数：')   
print(np.conj(a))   
print('\n')   
print('调用 angle() 函数：')   
print(np.angle(a))   
print('\n')   
print('再次调用 angle() 函数(以角度制返回)：')   
print(np.angle(a, deg =  True)) 

# 我们的数组是：
[-0.-5.6j  0.+0.2j 11.+0. j  1.+1. j]


# 调用 real() 函数：
[-0.  0. 11.  1.]


# 调用 imag() 函数：
[-5.6  0.2  0.   1. ]


# 调用 conj() 函数：
[-0.+5.6j  0.-0.2j 11.-0. j  1.-1. j]


# 调用 angle() 函数：
[-1.57079633  1.57079633  0.          0.78539816]


# 再次调用 angle() 函数(以角度制返回)：
[-90.  90.   0.  45.]
NumPy - 统计函数
方法描述
numpy.amin()从给定数组中的元素沿指定轴返回最小值
numpy.amax()从给定数组中的元素沿指定轴返回最大值
numpy.ptp()返回沿轴的值的范围(最大值 - 最小值)
numpy.percentile()百分位数是统计中使用的度量，表示小于这个值得观察值占某个百分比
numpy.median()定义为将数据样本的上半部分与下半部分分开的值
numpy.mean()返回数组中元素的算术平均值
numpy.average()根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值
标准差标准差是与均值的偏差的平方的平均值的平方根
import numpy as np 
a = np.array([[3,7,5],[8,4,3]]) 

print(np.amin(a,0))
print(np.amin(a,1))

b = np.array([[3,7,5],[8,4,3],[2,4,9]]) 
print(np.amax(b,0))
print(np.amax(b,1))

# [3 4 3]
# [3 3]

# [8 7 9]
# [7 8 9]

# 实际上axis = 1，指的是沿着行求所有列，代表了横轴，那axis = 0，就是沿着列求所有行，代表了纵轴。
numpy.ptp():
import numpy as np 

b = np.array([[3,7,5],[8,4,3],[2,4,9]]) 
print(np.ptp(b))
print(np.ptp(b,0))
print(np.ptp(b,1))

# 7  不传轴的时候和=默认返回所有数据的对比
# [6 3 6] 对比纵轴
# [4 5 7] 对比横轴
numpy.percentile()百分位数是统计中使用的度量，表示小于这个值得观察值占某个百分比：
numpy.percentile(a, q, axis)

# a 输入数组
# q 要计算的百分位数，在 0 ~ 100 之间
# axis 沿着它计算百分位数的轴

import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print('我们的数组是：' ) 
print(a) 
print('\n')   
print('调用 percentile() 函数：')   
print(np.percentile(a,50))   
print('\n')   
print('沿轴 1 调用 percentile() 函数：')   
print(np.percentile(a,50, axis =  1) )  
print('\n')   
print('沿轴 0 调用 percentile() 函数：')   
print(np.percentile(a,50, axis =  0)) 


# 我们的数组是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]


# 调用 percentile() 函数：
50.0


# 沿轴 1 调用 percentile() 函数：
[40. 20. 60.]


# 沿轴 0 调用 percentile() 函数：
[50. 40. 60.]
numpy.median()定义为将数据样本的上半部分与下半部分分开的值：
import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print('我们的数组是：' ) 
print(a) 
print('\n')   
print('调用 median() 函数：')   
print(np.median(a))   
print('\n')   
print('沿轴 1 调用 median() 函数：')   
print(np.median(a,axis =  1) )  
print('\n')   
print('沿轴 0 调用 median() 函数：')   
print(np.median(a, axis =  0)) 

# 我们的数组是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]


# 调用 median() 函数：
50.0


# 沿轴 1 调用 median() 函数：
[40. 20. 60.]


# 沿轴 0 调用 median() 函数：
[50. 40. 60.]
numpy.mean()返回数组中元素的算术平均值：

算术平均值是数组中所有元素相加后除以数组的元素个数得到的值。

import numpy as np 
a = np.array([10,20,30,40])
b = np.array([[30,40,70],[80,20,10],[50,90,60]])  

print(np.mean(a))
print(np.mean(b))
print(np.mean(b,axis=0))
print(np.mean(b,axis=1))

# 25.0
# 50.0
# [53.33333333 50.         46.66666667]
# [46.66666667 36.66666667 66.66666667]
numpy.average()根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值：

加权平均值是由每个分量乘以反映其重要性的因子得到的平均值

import numpy as np 
a = np.array([1,2,3,4])  
print('我们的数组是：')  
print(a) 
print('\n')  
print('调用 average() 函数：')  
print(np.average(a))  
print('\n')  
# 不指定权重时相当于 mean 函数
wts = np.array([4,3,2,1])  
print('再次调用 average() 函数：')  
print(np.average(a,weights = wts))  
print('\n')  
# 如果 returned 参数设为 true，则返回权重的和  
print('权重的和：')  
print(np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))

# 我们的数组是：
[1 2 3 4]


# 调用 average() 函数：   10 / 4 = 2.5
2.5


# 再次调用 average() 函数： 0.4+0.6+0.6+0.4 = 2.0
2.0


# 权重的和：
(2.0, 10.0)
标准差 标准差是与均值的偏差的平方的平均值的平方根:
std = sqrt(mean((x - x.mean())**2))

# 如果数组是[1，2，3，4]，则其平均值为2.5。 
# 因此，差的平方是[2.25,0.25,0.25,2.25]，并且其平均值的平方根除以4，即sqrt(5/4)是1.1180339887498949

import numpy as np 
print(np.std([1,2,3,4]))

# 1.118033988749895
方差是偏差的平方的平均值 即mean((x - x.mean())** 2)。 换句话说，标准差是方差的平方根:
import numpy as np 
print(np.var([1,2,3,4])) 

# 1.25
NumPy - 排序、搜索和计数函数

常用排序算法：

分类速度最坏情况工作空间稳定性
‘quicksort’(快速排序)11O(n^2)0
‘mergesort’(归并排序)21O(n*log(n))~n/2
‘heapsort’(堆排序)31O(n*log(n))0
numpy.sort()返回输入数组的排序副本：
numpy.sort(a, axis, kind, order)

# a 要排序的数组
# axis 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序
# kind 默认为'quicksort'(快速排序)
# order 如果数组包含字段，则是要排序的字段

# print(np.var([1,2,3,4]))
import numpy as np  
a = np.array([[3,7],[9,1]])  
print('我们的数组是：')  
print(a) 
print('\n')  
print('调用 sort() 函数：')  
print(np.sort(a))  
print('\n')  
print('沿轴 0 排序：')  
print(np.sort(a, axis =  0))  
print('\n')  
# 在 sort 函数中排序字段 
dt = np.dtype([('name',  'S10'),('age',  int)]) 
a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
print('我们的数组是：')  
print(a) 
print('\n')  
print('按 name 排序：')  
print(np.sort(a, order =  'name'))

# 我们的数组是：
[[3 7]
 [9 1]]


# 调用 sort() 函数：
[[3 7]
 [1 9]]


# 沿轴 0 排序：
[[3 1]
 [9 7]]


# 我们的数组是：
[(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]


# 按 name 排序：
[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]
numpy.argsort()对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。 这个索引数组用于构造排序后的数组：

返回的是数组值从小到大的索引值

import numpy as np 
x = np.array([3,  1,  2])  
print('我们的数组是：')  
print(x) 
print('\n')  
print('对 x 调用 argsort() 函数：') 
y = np.argsort(x)  
print(y) 
print('\n')  
print('以排序后的顺序重构原数组：')  
print(x[y])  
print('\n')  
print('使用循环重构原数组：')  
for i in y:  
    print(x[i]),


# 我们的数组是：
[3 1 2]


# 对 x 调用 argsort() 函数：
[1 2 0]


# 以排序后的顺序重构原数组：
[1 2 3]


# 使用循环重构原数组：
1
2
3
numpy.lexsort()函数使用键序列执行间接排序。 键可以看作是电子表格中的一列。 该函数返回一个索引数组，使用它可以获得排序数据。 注意，最后一个键恰好是 sort 的主键:
# print(np.var([1,2,3,4]))
import numpy as np 

a = [1,5,1,4,3,4,4] # First column
b = [9,4,0,4,0,2,1] # Second column
ind = np.lexsort((b,a)) 
print(int)
# 2 0 4 6 5 3 1

# 分析：
# b在前，a在后，即是先按照a的元素进行比较

# step1 调用argsort(a)   [1,5,1,4,3,4,4] => [1,1,3,4,4,4,5] => [0,2,4,3,5,6,1]

# 得到 a的排序结果索引后计算得到b对应的排序结果                      

# step2 调用argsort(b,a) [9,4,0,4,0,2,1] -- [0,2,4,3,5,6,1] => [9,0,0,4,2,1,4]

# 得到b的排序结果后与a的排序结果进行比较 按照a优先的顺序进行排列  

# [1,1,3,4,4,4,5]  
# [9,0,0,4,2,1,4]       

#  step3 我们发现 [1,0]最小 对应 原始数组索引 2
#  step4 我们发现 [1,9]最小 对应 原始数组索引 0
#  step5 我们发现 [3,0]最小 对应 原始数组索引 4
#  step6 我们发现 [4,1]最小 对应 原始数组索引 6
#  step7 我们发现 [4,2]最小 对应 原始数组索引 5
#  step8 我们发现 [4,4]最小 对应 原始数组索引 3
#  step9 我们发现 [5,4]最小 对应 原始数组索引 1


同理：我们可以将b放在前检验我们是否理解这个排序

ind2 = np.lexsort((a,b)) 
print(int2)

# [2 4 6 5 3 1 0]

根据上述的栗子我们可以发现，lexsort()其实就是现实生活中的两者之间的比较得到一个以某个为主要参考物后，来得到排序的结果，简单来说比如说，我想要购买一件衣服，我主要参考衣服的颜色和价格，假如我觉得价格比较重要，那么我会优先根据价格进行排序，排序完成之后然后根据价格排序得到的结果去根据颜色进行排序，最后得到性价比比较满意的结果。或者我可以先根据颜色进行排序，然后再根据价格进行排序来得到结果。

numpy.argmax() 和 numpy.argmin()分别沿给定轴返回最大和最小元素的索引:
import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
print('我们的数组是：')  
print(a) 
print('\n')  
print('调用 argmax() 函数：')  
print(np.argmax(a))  
print('\n')  
print('展开数组：')  
print(a.flatten())  
print('\n')  
print('沿轴 0 的最大值索引：') 
maxindex = np.argmax(a, axis =  0)  
print(maxindex) 
print('\n')  
print('沿轴 1 的最大值索引：' ) 
maxindex = np.argmax(a, axis =  1)  
print(maxindex )
print('\n')  
print('调用 argmin() 函数：') 
minindex = np.argmin(a)  
print(minindex )
print('\n')  
print('展开数组中的最小值：')  
print(a.flatten()[minindex])  
print('\n')  
print('沿轴 0 的最小值索引：') 
minindex = np.argmin(a, axis =  0)  
print(minindex) 
print('\n')  
print('沿轴 1 的最小值索引：' )
minindex = np.argmin(a, axis =  1)  
print(minindex)

# 我们的数组是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]

# 调用 argmax() 函数：
7

# 展开数组：
[30 40 70 80 20 10 50 90 60]

# 沿轴 0 的最大值索引：
[1 2 0]

# 沿轴 1 的最大值索引：
[2 0 1]

# 调用 argmin() 函数：
5

# 展开数组中的最小值：
10

# 沿轴 0 的最小值索引：
[0 1 1]

# 沿轴 1 的最小值索引：
[0 2 0]
numpy.nonzero()返回输入数组中非零元素的索引:
import numpy as np 
a = np.array([[30,40,0],[0,20,10],[50,0,60]])  
print('我们的数组是：')  
print(a) 
print('\n')  
print('调用 nonzero() 函数：')  
print(np.nonzero (a))

# 我们的数组是：
[[30 40  0]
 [ 0 20 10]
 [50  0 60]]


# 调用 nonzero() 函数： 先返回x轴坐标 再返回y轴坐标
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))
numpy.where()返回输入数组中满足给定条件的元素的索引：
import numpy as np 
x = np.arange(9.).reshape(3,  3)  
print('我们的数组是：')  
print(x) 
print('大于 3 的元素的索引：') 
y = np.where(x >  3)  
print(y) 
print('使用这些索引来获取满足条件的元素：')  
print(x[y])

# 我们的数组是：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]

# 大于 3 的元素的索引：
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))

#使用这些索引来获取满足条件的元素：
[4. 5. 6. 7. 8.]
numpy.extract()返回满足任何条件的元素：
import numpy as np 
x = np.arange(9.).reshape(3,  3)  
print('我们的数组是：')  
print(x) 
# 定义条件 
condition = np.mod(x,2)  ==  0  
print('按元素的条件值：')  
print(condition) 
print('使用条件提取元素：')  
print(np.extract(condition, x))

# 我们的数组是：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
# 按元素的条件值：
[[ True False  True]
 [False  True False]
 [ True False  True]]
# 使用条件提取元素：
[0. 2. 4. 6. 8.]

本篇教程比较长，但是完整学习下来也是很有帮助，大家一起��努力把。

xjl271314
关注
  • 79
    点赞
  • 踩
  • 515
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
numpy库的一些解释
weixin_46681128的博客
08-27 6952
Numpy库介绍 NumPy是一个的Python库，主要用于对多维数组执行计算。 NumPy这个词来源于两个单词-- Numerical [njuːˈmerɪkl] （数值;数值法;数值的;数字的）和 Python。主要用来进行数值计算。 有以下几个特点: 1.numpy内置了并行运算功能，当系统有多个核心时，做某种计算时，numpy会自动做并行计算。 2.Numpy底层使用C语言编写，其对数组的操作速度不受Python解释器的限制，效率远高于纯Python代码。 3.有一个强大的N维数组对象Array
史上最全详解NumPy库，小白也能看懂的python入门！
weixin_68789096的博客
10-30 9458
NumPy，全称Numerical Python，是一个开源的Python库，它为Python提供了强大的多维数组对象和用于处理这些数组的函数。NumPy的核心是ndarray，它是一个高效的多维数组容器，用于存储和处理大规模的数据。NumPy还提供了许多数学函数，用于数组之间的操作，以及用于线性代数、傅立叶变换和随机数生成等功能。NumPy是Python编程中的一个强大工具，它为处理大规模数据、科学计算和数学建模提供了便捷和高效的方法。
Python Numpy库的超详细介绍
hdxx2022的博客
12-07 2303
Numpy库是Python中的一个科学计算库,本文主要介绍了ndarray的基本操作、 ndarray运算等各种Numpy库的超详细教程,需要的朋友可以参考下123456 下面是random模块的一些常用函数 ::: hljs-center使用如下：12345678910111213141516171819 如果想使每次生成的数据相同，可以指定一个随机种子12345 主要有如下几种：1234567891011121314 在创建给定长度的等差数列时，要注意的是np.linspace
人工智能基础-Python之Numpy库教程
最新发布
weixin_46034279的博客
04-13 2156
Numpypython三大库numpy，pandas以及matplotlib在人工智能领域有广泛的营运。下面我将介绍一些关于Numpy的一些简单教程1、他的元素必须是同一种元素2、array对象可以是一维的也可是多维的本文仅仅简单介绍了numpy的简单应用，想要进一步了解numpy，还需要进行大量的实战项目。任重道远，道友，加油！！！
超详细的图解 Numpy，不收藏后悔！
weixin_42608414的博客
01-30 4573
一个 Numpy是关于机器学习,数据处理的Python基础库,了解 NumPy 的工作原理可以提高你的编码效率，可以让你的代码看上去更加简洁和优雅。NumPy 也可以GPU上运行代码而无需更改原始代码(或只做少量更改)。NumPy 的核心概念是 多维数组。它的美妙之处在于，无论数组有多少维，大多数操作看起来都是一样的。但是 1D 和 2D 的情况有点特殊。Numpy 数组与 Python 列表(list)粗看上去,NumPy 数组类似于 Python 列表。
pythonnumpy教程-PythonNumpy库常见用法入门教程.pdf
06-11
pythonnumpy教程_PythonNumpy库常见⽤法⼊门教程 本⽂实例讲述了Python Numpy库常见⽤法。分享给⼤家供⼤家参考，具体如下： 1、简介 Numpy是⼀个常⽤的Python科学技术库，通过它可以快速对数组进⾏操作，包括形状...
Python Numpy库常见用法入门教程
09-18
本教程将深入介绍Numpy库的基础知识和常用操作。 首先，Numpy的核心是ndarray对象，它允许快速高效地执行各种数组操作。与Python的列表不同，ndarray的元素类型是统一的，且在创建时就固定了大小，这使得数组在内存...
Python之Numpy详细教程
02-24
NumPy是一个Python包。它代表“NumericPython”。它是一个由多维数组对象和用于处理数组的例程集合组成的库。Numeric，即NumPy的前身，是由JimHugunin开发的。也开发了另一个包Numarray，它拥有一些额外的功能。2005...
Numpy使用教程库pdf版（python）
11-01
numpy库使用教程pdf版（python）
Python之numpy函数
醉蕤的博客
08-15 1万+
Python之numpy函数
python学习—最全Numpy教程
热门推荐
一键难忘的博客
12-15 1万+
1. Numpy概述 NumPy（Numerical Python的简称）是Python数值计算最重要的基础包。大多数提供科学计算的包都是用NumPy的数组作为构建基础。 1.1.1. Why NumPy? 1.一个强大的N维数组对象ndarray，具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组 2.用于集成由C、C++、Fortran等语言类库的C语言 API 3.线性代数、随机数生成以及傅里叶变换功能。 4.用于对整组数据进行快速运算的标准数学函数（无需编写循环）,支持大量的数据运算 5.
Python之Numpy使用详解
huanxiajioabu的博客
07-20 1412
NumPy 不仅仅是 Python 科学计算中使用最多的库，还是 SciPy，Pandas 等库的基础，它提供了更加高级有效的数据结构，是专门为科学计算而生的库。NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。
【Python入门】NumPy 入门知识介绍，看这一篇足矣
python56123的博客
04-21 2290
嗨喽~大家好呀，这里是魔王呐 ❤ ~!NumPy是用于处理数组的 python 库。它还拥有在线性代数、傅立叶变换和矩阵领域中工作的函数。NumPy 由 Travis Oliphant 于 2005 年创建。它是一个开源项目，你可以自由使用它。NumPy 指的是数值 Python（Numerical Python）。
Python语言用numpy库画sin图像
m0_71405022的博客
03-11 391
【代码】Python语言用numpy库画sin图像。
Numpy索引和切片
ccc369639963的博客
04-08 1139
Numpy索引和切片 在 NumPy 中，如果想要访问，或修改数组中的元素，您可以采用索引或切片的方式，比如使用从 0 开始的索引依次访问数组中的元素，这与 Python 的 list 列表是相同的。 NumPy 提供了多种类型的索引方式，常用方式有两种：基本切片与高级索引。本节重点讲解基本切片。 基本切片 NumPy 内置函数 slice() 可以用来构造切片对象，该函数需要传递三个参数值分别是 start（起始索引）、stop（终止索引） 和 step（步长） ，通过它可以实现从原数组的上切割出一个新数
Numpy 数组切片
岳来的博客
12-30 1万+
Numpy 数组切片
Python基础之NumPy教程——全网最全面最详细！！！
weixin_46228946的博客
09-13 238
NumPy（Numerical Python的简称）是Python数值计算最重要 的基础包。⼤多数提供科学计算的包都是⽤NumPy的数组作为 构建基础。多维数组对象，是同构数据多维容器，也就是说，他的内容类型是相同的。基于NumPy的算法要⽐纯Python快10到100倍（甚⾄更快），并 且使⽤的内存更少.专门为大数据计算所诞生的【注释：参考《书》P114】
numpy库的使用
oyqho的博客
11-12 1618
可以看到，a和a3的输出结果是一样的，可当我想要改变a3中[0][0]这个位置的值的时候，却连a的值也一起改变了，这说明用a和a3根本就是同一个东西，只不过a3相当于是a的别名，但它们所代表的都是同一个东西。而int和uint则是有符号和无符号的区别，其实说白了，int型会出现负数，而uint只有正数，上面表中就可以看到，int的范围类型都是在负数到正数之间，而uint则是大于等于0。首先是第一列，0和3输出了3，第二列10和4输出了10，而第三列2和5输出了5，所以共同组成了[3,10,5]进行输出。
python numpy库教程
10-07
Python Numpy库是一个用于进行科学计算的强大工具，它提供了高效的多维数组对象以及用于处理数组的函数。通过使用Numpy库，您可以在Python中快速进行数组操作、数值计算、线性代数等。下面是Python Numpy库的一些基本功能和常见操作技巧： 1. 创建Numpy数组 - 使用np.array()函数创建一维或多维数组。 - 使用np.zeros()函数创建全零数组。 - 使用np.ones()函数创建全一数组。 - 使用np.random.rand()函数创建随机数组。 2. 数组索引和切片 - 使用索引访问数组的特定元素。 - 使用切片操作提取数组的子集或分割数组。 3. 数组形状操作 - 使用numpy.reshape()函数改变数组的形状。 - 使用numpy.transpose()函数转置数组。 - 使用numpy.flatten()函数将多维数组转换为一维数组。 4. 数组运算 - 数组加法、减法、乘法和除法。 - 数组的逐元素运算，如平方、开根号、取对数等。 - 数组的矩阵乘法和点积运算。 5. 数组统计和聚合 - 使用numpy.mean()计算数组的均值。 - 使用numpy.sum()计算数组的总和。 - 使用numpy.min()和numpy.max()找到数组的最小值和最大值。 这些只是Python Numpy库的一些常见用法和操作。如果您想深入学习更多关于Python Numpy库的相关知识，可以参考引用中提供的教程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值