1. Toy模板网首页
  2. > Toy博客

Python之Numpy库知识大全

10月前 作者：北山北. 分类：Toy博客 阅读(32) 违法举报

这篇具有很好参考价值的文章主要介绍了Python之Numpy库知识大全。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

1.数组概念及对象属性

2.数组的创建

常用函数创建数组

已知尺度大小创建数组

数组对象的属性

数组维度的改变

将一维数组转化为列表：

数组的组合操作

数组的分割操作

3.数组的索引

一维数组的基本索引

二维数组的切片索引

二维数组增删改查操作

4.数组的矢量化

布尔型索引

一元算数函数

二元运算函数

二元函数--meshgrid函数

三元函数

集合逻辑

 线性代数

 专用函数

5.Numpy文件操作

读取文件

写入文件

1.数组概念及对象属性

NumPy（Numerical Python的简称）是高性能科学计算和数据分析的基

础包，其中包含了数组对象 ( 向量、矩阵、图像等 ) 以及线性代数等。
NumPy 库主要功能
– ndarray( 数组 ) 是具有矢量算术运算和复杂广播能力的多维数组。
– 具有用于对数组数据进行快速运算的标准数学函数。
– 具有用于读写磁盘数据、操作内存映射文件的工具。
– 具有线性代数、随机数生成以及傅里叶变换功能。
– 具有用于集成由 C 、 C++ 、 Fortran 等语言编写的代码的工具。
举例： 
#A,B是一维数组，计算A^2+B^3
#方法一
# a=[0,1,2,3,4]
# b=[5,6,7,8,9]
# c=[]
# for i in range(0,5):
#     c.append(a[i]**2+b[i]**3)
# print(c)
#方法二:
import numpy as np
a=[0,1,2,3,4]
b=[5,6,7,8,9]
a_array=np.array(a)
b_array=np.array(b)
c=a_array**2+b_array**3
print(c)

数组的优势：

◆ 数组对象可以去掉元素间运算所需的循环，使一维向量更像单个数据
◆ 设置专门的数组对象，经过优化，可以提升这类应用的运算速度
◆ 观察： 科学计算中，一个维度所有数据的类型往往相同
◆ 数组对象采用相同的数据类型，有助于节省运算和存储空间
NumPy 库处理的最基础数据类型是由
同种元素 构成的多维数组 (ndarry) ，
简称“数组”。
◆ numpy 数组的维数称为 秩 ，每一个线
性的数组称为 轴 。
◆ 同一个 numpy 数组中所有元素的类型
一般是相同的。 
import numpy as np
a_array=np.arange(9).reshape((3,3))
print(a_array)
print(np.sum(a_array,axis=0))        #axis=0表示列
print(np.max(a_array,axis=1))        #axis=1表示行

E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/2.py"
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[ 9 12 15]
[2 5 8]

Process finished with exit code 0

2.数组的创建

数组创建的主要方式

◆ 从 Python 中的列表、元组等类型创建 ndarray 数组
◆ 使用 NumPy 中函数创建 ndarray 数组，如： arange, ones, zeros 等
◆ 从字节流（ raw bytes ）中创建 ndarray 数组
◆ 从文件中读取特定格式，创建 ndarray 数组
内置数据结构创建数组

基本格式：

np.array (list/tuple,dtype=np.float32)
实例： 
import numpy as np
a_array=np.array(((1,2),(3,4)))
b_array=np.array([[1.5,2],[2.5,3]])
print(a_array)
print(b_array)

结果:
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/3.py"
[[1 2]
 [3 4]]
[[1.5 2. ]
 [2.5 3. ]]

Process finished with exit code 0
数组元素的类型（一）

numpy库,python,numpy,线性代数

 数组元素的类型（二）

numpy库,python,numpy,线性代数

ndarray 为什么要支持这么多种元素类型？
Python 语法仅支持整数、浮点数和复数 3 种类型
Ndarry 的优势
◆ 科学计算涉及数据较多，对存储和性能都有较高要求
◆ 对元素类型精细定义，有助于 NumPy 合理使用存储空间并优化性能
◆ 对元素类型精细定义，有助于程序员对程序规模有合理评估

常用函数创建数组

numpy库,python,numpy,线性代数

 实例：

import numpy as np
a_array=np.arange(10)
print(a_array)
b_array=np.ones((3,4))
print(b_array)
c_array=np.ones((3,4),dtype=np.int32)
print(c_array)
d_array=np.zeros((3,4),dtype=np.int32)
print(d_array)
e_array=np.eye(4,dtype=np.int32)
print(e_array)
f_array=np.full((3,4),6)
print(f_array)

结果：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/4.py"
[0 1 2 3 4 5 6 7 8 9]

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

[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]

[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]

[[1 0 0 0]
 [0 1 0 0]
 [0 0 1 0]
 [0 0 0 1]]

[[6 6 6 6]
 [6 6 6 6]
 [6 6 6 6]]

Process finished with exit code 0

已知尺度大小创建数组

numpy库,python,numpy,线性代数

实例：

import numpy as np
a=np.arange(9).reshape((3,3))
print(a)
b=np.ones_like(a)
c=np.zeros_like(a)
d=np.full_like(a,6)
print(f'b={b}')
print(f'c={c}')
print(f'd={d}')

结果：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/5.py"
[[0 1 2]
 [3 4 5]
 [6 7 8]]
b=[[1 1 1]
 [1 1 1]
 [1 1 1]]
c=[[0 0 0]
 [0 0 0]
 [0 0 0]]
d=[[6 6 6]
 [6 6 6]
 [6 6 6]]

Process finished with exit code 0

数组对象的属性

numpy库,python,numpy,线性代数

 实例：

import numpy as np
a=np.array([[1,2,3,4,5],[6,7,8,9,10]])
b=np.array([6,66,666])
c=np.array([[6,7,77]])
print(a.ndim)            #数组的维度
print(a.shape)             #数组的结构
print(b.shape)
print(c.shape)
print(a.size)           #数组的大小
print(a.dtype)           #数组的类型
print(a.itemsize)         #数组中每个元素所占的类型

结果：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/6.py"
2
(2, 5)
(3,)
(1, 3)
10
int32
4

Process finished with exit code 0

数组维度的改变

numpy库,python,numpy,线性代数

 实例：

import numpy as np
a=np.ones((2,3,4),dtype=np.int32)       #两个三行四列的数组，类型为int32
print(a)
b=a.reshape((3,8))
print(b)
# c=a.resize((3,8))
# print(c)
d=a.reshape((4,-1))              #4行n列，-1表示不知道有多少列
print(d)
e=a.flatten()
print(e)                          #降维，降成一维数组（平铺）
f=a.swapaxes(1,2)
print(f)                         #a中的两个三行四列变为两个四行三列
g=b.transpose()
print(g)                         #b中的3*8数组转置为8*3数组

结果：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/7.py"
[[[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]

 [[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]]
[[1 1 1 1 1 1 1 1]
 [1 1 1 1 1 1 1 1]
 [1 1 1 1 1 1 1 1]]
[[1 1 1 1 1 1]
 [1 1 1 1 1 1]
 [1 1 1 1 1 1]
 [1 1 1 1 1 1]]
[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
[[[1 1 1]
  [1 1 1]
  [1 1 1]
  [1 1 1]]

 [[1 1 1]
  [1 1 1]
  [1 1 1]
  [1 1 1]]]
[[1 1 1]
 [1 1 1]
 [1 1 1]
 [1 1 1]
 [1 1 1]
 [1 1 1]
 [1 1 1]
 [1 1 1]]

Process finished with exit code 0

将一维数组转化为列表：

array.tolist()

实例：

import numpy as np
print(np.arange(10).reshape(2,5))
print(np.arange(10).reshape(2,5).tolist())

结果：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/8.py"
[[0 1 2 3 4]
 [5 6 7 8 9]]
[[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]

Process finished with exit code 0

数组的组合操作

import numpy as np
a=np.arange(9).reshape((3,3))
b=np.arange(10,19).reshape((3,3))
print(a)
print(b)
c=np.hstack((a,b))         #水平组合
d=np.vstack((a,b))         #垂直组合
e=np.dstack((a,b))         #深度组合
print(c)
print(d)
print(e)

结果：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/9.py"
[[0 1 2]
 [3 4 5]
 [6 7 8]]

[[10 11 12]
 [13 14 15]
 [16 17 18]]

[[ 0  1  2 10 11 12]
 [ 3  4  5 13 14 15]
 [ 6  7  8 16 17 18]]

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [10 11 12]
 [13 14 15]
 [16 17 18]]

[[[ 0 10]
  [ 1 11]
  [ 2 12]]

 [[ 3 13]
  [ 4 14]
  [ 5 15]]

 [[ 6 16]
  [ 7 17]
  [ 8 18]]]

Process finished with exit code 0

数组的分割操作

import numpy as np
a=np.arange(9).reshape(3,3)
# print(a)
b=np.split(a,3,axis=1)   #与b=np.hsplit(a,3)功能相同,垂直分割
c=np.split(a,3,axis=0)   #与c=np.vsplit(a,3)功能相同,平行分割
print(b)
print(c)

结果：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/数组分割.py"
[array([[0],
       [3],
       [6]]), array([[1],
       [4],
       [7]]), array([[2],
       [5],
       [8]])]
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

Process finished with exit code 0

3.数组的索引

一维数组的基本索引

import numpy as np
a=np.arange(9)
print(a)
print(a[1])               #索引
print(a[1:3])             #切片
print(a[1:9:2])           #切片，每隔两个..

b=a[:]                   #数组是一个可变对象
b[-1]=9
print(a)
print(b)

c=a[1:3].copy()             #数组切片是原始数组的视图，数据不会被复制，视图上的任何修改都会直接反映到源数组。
c[-1]=10
print(a)
print(c)




输出：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/基本索引.py"
[0 1 2 3 4 5 6 7 8]
1
[1 2]
[1 3 5 7]
[0 1 2 3 4 5 6 7 9]
[0 1 2 3 4 5 6 7 9]
[0 1 2 3 4 5 6 7 9]
[ 1 10]

Process finished with exit code 0

二维数组的切片索引

import numpy as np
a=np.arange(9).reshape(3,3)
b=np.arange(12).reshape(3,4)
print(a)
print(a[1,2])           #取第二行，第三列的元素
print(a[1,:])           #取第二行的元素
print(a[:,1])           #取第二列的元素
print(a[1:,1:])         #取第二行到最后一行，第二列到最后一列的所有元素
print(a[:1])            #取第一行的所有元素
print(a[1:])            #取除了第一行的所有元素


输出：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/二维数组索引.py"
[[0 1 2]
 [3 4 5]
 [6 7 8]]
5
[3 4 5]
[1 4 7]
[[4 5]
 [7 8]]
[[0 1 2]]
[[3 4 5]
 [6 7 8]]

Process finished with exit code 0

二维数组增删改查操作

import numpy as np
a=np.arange(9).reshape(3,3)
print(a)
b=np.insert(a,1,[6,6,6],0)         #增:np.insert(arr, obj, values, axis=None)    # obj为索引,在该行（列）之前插入values
print(b)                           #axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反

c=np.delete(a,1,0)                 #numpy.delete(arr, obj, axis)      axis=0对行进行操作  axis=1对列进行操作
print(c)

d=np.append(a,[[666,666,666]],0)                #numpy.append(arr, values, axis=None)  在最后一行进行添加操作（沿轴0）
print(d)
e=np.append(a,[[11,22],[44,55],[77,88]],1)        #沿轴1  进行列操作
print(e)

f=np.where(a==5)                              #查找元素5所在的行和列，并返回元素的类型
print(f)



输出：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/增删改查操作.py"
[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[0 1 2]
 [6 6 6]
 [3 4 5]
 [6 7 8]]
[[0 1 2]
 [6 7 8]]
[[  0   1   2]
 [  3   4   5]
 [  6   7   8]
 [666 666 666]]
[[ 0  1  2 11 22]
 [ 3  4  5 44 55]
 [ 6  7  8 77 88]]
(array([1], dtype=int64), array([2], dtype=int64))

Process finished with exit code 0

4.数组的矢量化

◆ 矢量化 (vectorization) ：数组不用编写循环即可实现对数据执行批量运算。
◆ 大小相等的数组之间的任何算数运算都将应用至 元素级 。
◆ 数组与标量之间的运算作用于数组的 每一个元素 。 
import numpy as np
a=np.arange(1,9).reshape(2,4)
print(a)
print(a*a)
print(1/a)

输出：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/数组的矢量化.py"
[[1 2 3 4]
 [5 6 7 8]]
[[ 1  4  9 16]
 [25 36 49 64]]
[[1.         0.5        0.33333333 0.25      ]
 [0.2        0.16666667 0.14285714 0.125     ]]

Process finished with exit code 0

布尔型索引

import numpy as np
data=np.random.randn(7,4)
data_bool=(data>=0)
print(data)
data[data<0]=0
print(data)
print(data_bool.sum())                #大于等于0的个数
print(data_bool.any())                #有大于0的数
print(data_bool.all())                #是否均大于0

输出：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/布尔型索引.py"
[[ 1.63811042  1.54445329 -0.50855556  0.66308194]
 [ 0.12879628 -2.03570072  0.01191314 -0.06932157]
 [ 0.33557615  0.71268317 -0.68343232 -0.63477468]
 [-1.39206954  1.00314553 -0.34956396  0.1029916 ]
 [ 2.70711258  1.42974385 -0.41166823 -1.51228186]
 [-0.21329145 -0.80455934 -1.24286032  0.8425069 ]
 [-0.03085091  1.29717035 -0.77213397 -1.98034943]]
[[1.63811042 1.54445329 0.         0.66308194]
 [0.12879628 0.         0.01191314 0.        ]
 [0.33557615 0.71268317 0.         0.        ]
 [0.         1.00314553 0.         0.1029916 ]
 [2.70711258 1.42974385 0.         0.        ]
 [0.         0.         0.         0.8425069 ]
 [0.         1.29717035 0.         0.        ]]
13
True
False

Process finished with exit code 0

一元算数函数

numpy库,python,numpy,线性代数

numpy库,python,numpy,线性代数

import numpy as  np
a=np.arange(1,10).reshape(3,3)
b=np.array([[-1,-2,-3],[-4,-5,-6]])
print(a,'\n')
print(np.sqrt(a),'\n')        #求平方根
print(np.modf(a),'\n')        #计算
print(np.abs(b),'\n')         #计算各个元素的绝对值，功能和np.fabs()相同
print(np.square(a),'\n')      #计算各个元素的平方
print(np.log(a),'\n')         #取对数，相当于loge，
print(np.log10(a),'\n')       #求10底对数
print(np.log2(a),'\n')        #求2底对数
print(np.ceil(a),'\n')        #向上取整
print(np.floor(a),'\n')       #向下取整
print(np.rint(a),'\n')        #计算元素的四舍五入值
print(np.exp(a),'\n')         #计算各个元素的指数值


outer：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/一元算术函数.py"
[[1 2 3]
 [4 5 6]
 [7 8 9]] 

[[1.         1.41421356 1.73205081]
 [2.         2.23606798 2.44948974]
 [2.64575131 2.82842712 3.        ]] 

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

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

[[ 1  4  9]
 [16 25 36]
 [49 64 81]] 

[[0.         0.69314718 1.09861229]
 [1.38629436 1.60943791 1.79175947]
 [1.94591015 2.07944154 2.19722458]] 

[[0.         0.30103    0.47712125]
 [0.60205999 0.69897    0.77815125]
 [0.84509804 0.90308999 0.95424251]] 

[[0.         1.         1.5849625 ]
 [2.         2.32192809 2.5849625 ]
 [2.80735492 3.         3.169925  ]] 

[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]] 

[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]] 

[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]] 

[[2.71828183e+00 7.38905610e+00 2.00855369e+01]
 [5.45981500e+01 1.48413159e+02 4.03428793e+02]
 [1.09663316e+03 2.98095799e+03 8.10308393e+03]] 


Process finished with exit code 0

二元运算函数

numpy库,python,numpy,线性代数

 文章来源地址https://www.toymoban.com/news/detail-729181.html

import numpy as np
a=np.arange(1,10).reshape(3,3)
b=np.sqrt(a)
print(np.fmax(a,b))     #计算a，b数组最大值 相当于np.maximum(a,b)
print(np.fmin(a,b))     #计算最小值    相当于np.minimum(a,b)
print(np.mod(a,b))      #模运算求余数
print(a>b)              #算数比较，产生布尔型数组

outer:
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/二元算术函数.py"
[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]]
[[1.         1.41421356 1.73205081]
 [2.         2.23606798 2.44948974]
 [2.64575131 2.82842712 3.        ]]
[[0.         0.58578644 1.26794919]
 [0.         0.52786405 1.10102051]
 [1.70849738 2.34314575 0.        ]]
[[False  True  True]
 [ True  True  True]
 [ True  True  True]]

Process finished with exit code 0

二元函数--meshgrid函数

适用于生成网格型数据，可以接受两个一维数组生成两个二维矩阵，对应两个数组
中所有的 (x,y) 对。 
import numpy as np
x=np.array([0,1,2,3])
y=np.array([0,1,2,3,4])
xx,yy=np.meshgrid(x,y)
print(xx)                       #以x为行，共len(y)=5行的向量
print('---------------')
print(yy)                       #以y为列，共len(x)=4列的向量

outer:
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/二元函数--meshgrid函数.py"
[[0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]
 [0 1 2 3]]
---------------
[[0 0 0 0]
 [1 1 1 1]
 [2 2 2 2]
 [3 3 3 3]
 [4 4 4 4]]

Process finished with exit code 0

三元函数

numpy.where 函数是三元表达式 x if condition else y 的矢量化版本。 
import numpy as np
a=np.arange(-3,6).reshape(3,3)
print(a)
print(np.where(a>0,1,-1))      # np.where(condition,x,y)  相当于 x if condition else y
                                #if 满足condition 则输出x，否则输出y

outer：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/三元函数where.py"
[[-3 -2 -1]
 [ 0  1  2]
 [ 3  4  5]]
[[-1 -1 -1]
 [-1  1  1]
 [ 1  1  1]]

Process finished with exit code 0

集合逻辑

NumPy 提供了一些针对一维 ndarray 的基本集合运算，其中 np.unique 用于找出数组中
的唯一值并返回已排序的结果。

numpy库,python,numpy,线性代数

import numpy as np
a=np.arange(-1,8).reshape(3,3)
b=np.arange(-5,4).reshape(3,3)
print(a)
print(b)
print(np.intersect1d(a,b))

outer:
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/第四节.py"
[[-1  0  1]
 [ 2  3  4]
 [ 5  6  7]]
[[-5 -4 -3]
 [-2 -1  0]
 [ 1  2  3]]
[-1  0  1  2  3]

Process finished with exit code 0

 统计函数

通过数组上的一组数学函数对整个数组或某个轴向的数据进行统计计算。聚合计算
（ aggregation ，通常叫做约简（ reduction ））

numpy库,python,numpy,线性代数

 

import numpy as np
a=np.arange(-1,8).reshape(3,3)
b=np.arange(-5,4).reshape(3,3)
print(a)
print(b)
print(np.intersect1d(a,b))
print(np.sum(a))
print(np.cumsum(a,axis=0))   #元素(按列)逐个相加（每列求和）
print(np.cumsum(a,axis=1))   #元素(按行)逐个相加（每行求和）
print(np.cumsum(a))          #所有元素逐个相加

outer：
E:\anaconda\python.exe "E:/pythonProject1 hello world/Numpy/第四节.py"
[[-1  0  1]
 [ 2  3  4]
 [ 5  6  7]]
[[-5 -4 -3]
 [-2 -1  0]
 [ 1  2  3]]
[-1  0  1  2  3]
27
[[-1  0  1]
 [ 1  3  5]
 [ 6  9 12]]
[[-1 -1  0]
 [ 2  5  9]
 [ 5 11 18]]
[-1 -1  0  2  5  9 14 20 27]

Process finished with exit code 0

常用分布函数的随机数

numpy库,python,numpy,线性代数

 线性代数

线性代数是任何数组库的重要组成部分， linalg 模块 中有标准的矩阵分解运算以及诸
如求逆和行列式之类的函数。
numpy库,python,numpy,线性代数

 专用函数

◆ sort 函数返回排序后的数组
◆ argsort 函数返回输入数组排序后的下标；
◆ lexsort 函数根据键值的字典序进行排序；
例如： ind = np.lexsort((b,a)) # Sort by a, then by b
◆ ndarray 类的 sort 方法可对数组进行原地排序；
◆ msort 函数沿着第一个轴排序；
◆ sort_complex 函数对复数按照先实部后虚部的顺序进行排序。

 

5.Numpy文件操作

◆ tofile() 和 fromfile()
数据以 二进制格式写进文件 ，事先知道存入文件时数组的维度和元
素类型 。
◆ save() 和 load()
用的二进制格式 保存数据 ，它们会自动处理元素类型和形状等信
息，以 .npy 或 .npz 为扩展名。
◆ savetxt() 和 loadtxt()
读写 1 维和 2 维数组的文本文件 。

读取文件

np.loadtxt(frame,dtype=np.float, delimiter=None,unpack=False)

写入文件

np.savetxt(frame, array, fmt='%.18e', delimiter=None)

numpy库,python,numpy,线性代数

 

 

到了这里，关于Python之Numpy库知识大全的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • NumPy之矩阵、向量、线性代数等的操作

    NumPy之矩阵、向量、线性代数等的操作

    在NumPy中，矩阵可以看作是一个二维数组，其中每个元素都可以通过行列坐标来定位。它表示为一个m×n的矩形网格，其中m表示矩阵的行数，n表示矩阵的列数。在计算机科学中，矩阵通常用数字或符号表示，并且可以进行加、减、乘等运算。 一个 M X N 的矩阵是一个由 M 行（

    2024年02月02日
    浏览(42)
  • NumPy 特性：n维数组上的线性代数

    NumPy 特性：n维数组上的线性代数

    在阅读本教程之前，您应该对 Python 有一定的了解。如果您想恢复记忆，请参考 Python 教程。 如果您想要运行本教程中的示例，您还应该在计算机上安装 matplotlib 和 SciPy。 本教程适用于对线性代数和 NumPy 中的数组有基本了解，并希望了解如何表示和操作 n 维数组的人。特别是

    2024年03月18日
    浏览(47)
  • [数据分析大全]基于Python的数据分析大全——Numpy基础

    [数据分析大全]基于Python的数据分析大全——Numpy基础

    NumPy 的全称为 Numeric Python，它是 Python 的第三方扩展包，主要用来计算、处理一维或多维数组。   步入8月了，7月时因为项目所需，自学了 深度学习 相关的内容，现在 已经把项目所需要的神经网络框架搭建起来了，输入输出也都归一化了，模拟误差也加上了，图像的参数

    2024年02月14日
    浏览(65)
  • 三分钟学习一个python小知识4-----------我的对python中numpy的理解, 我列举了关于numpy常用的10个例子来深入理解numpy

    三分钟学习一个python小知识4-----------我的对python中numpy的理解, 我列举了关于numpy常用的10个例子来深入理解numpy

    NumPy 是专门用于数值计算的Python库。它提供了实现向量、矩阵和高维数组的高效数据结构和函数，以及用于数学计算的工具。NumPy使得Python语言与MATLAB和R语言相比，更适合探索性数据分析、科学计算和大规模数据处理等领域。 NumPy中的核心数据结构是 ndarray （N维数组），它是

    2024年02月10日
    浏览(91)
  • Python库第一课：基础Numpy知识（下）：矩阵

    Python库第一课：基础Numpy知识（下）：矩阵

            好的，我们今天继续来学习Numpy的基础，昨天，已经介绍完Numpy的成员之一——数组，今天，在接着介绍其另一大成员——矩阵，也是应用非常广泛的成员。         矩阵，在线性代数中是几乎贯穿全文的成员，因此，这里需要较高的线性代数的基础。在这里，默认

    2024年02月03日
    浏览(55)
  • 【Python入门知识】NumPy 数组搜索，案例+理论讲解

    【Python入门知识】NumPy 数组搜索，案例+理论讲解

    前言 嗨喽~大家好呀，这里是魔王呐 ❤ ~! 搜索数组 可以在数组中搜索（检索）某个值，然后返回获得匹配的索引。 要搜索数组，请使用 where() 方法。 实例 查找值为 4 的索引： 运行实例 更多python资料、源码、教程: 点击此处跳转文末名片获取 上例会返回一个元组：(array([

    2024年02月03日
    浏览(48)
  • 【Python入门知识】NumPy 中的随机数及ufuncs函数

    【Python入门知识】NumPy 中的随机数及ufuncs函数

    前言 嗨喽~大家好呀，这里是魔王呐 ❤ ~! 什么是随机数？ 随机数并不意味着每次都有不同的数字。随机意味着无法在逻辑上预测的事物。 伪随机和真随机 计算机在程序上工作，程序是权威的指令集。 因此，这意味着必须有某种算法来生成随机数。 如果存在生成随机数的程

    2024年02月03日
    浏览(98)
  • python库，科学计算与数据可视化基础，知识笔记（numpy+matplotlib）

    python库，科学计算与数据可视化基础，知识笔记（numpy+matplotlib）

    这篇主要讲一下数据处理中科学计算部分的知识。 之前有一篇pandas处理数据的。 讲一下这几个库的区别。 Pandas主要用来处理类表格数据（excel，csv），提供了计算接口，可用Numpy或其它方式进行计算。 NumPy 主要用来处理数值数据（尤其是矩阵，向量为核心的），本质上是纯

    2024年02月02日
    浏览(50)
  • python机器学习（三）特征预处理、鸢尾花案例--分类、线性回归、代价函数、梯度下降法、使用numpy、sklearn实现一元线性回归

    python机器学习（三）特征预处理、鸢尾花案例--分类、线性回归、代价函数、梯度下降法、使用numpy、sklearn实现一元线性回归

    数据预处理的过程。数据存在不同的量纲、数据中存在离群值，需要稳定的转换数据，处理好的数据才能更好的去训练模型，减少误差的出现。 标准化 数据集的标准化对scikit-learn中实现的大多数机器学习算法来说是常见的要求，很多案例都需要标准化。如果个别特征或多或

    2024年02月16日
    浏览(46)
  • 深入探索NumPy：科学计算利器的常用函数大全【第86篇—NumPy常用函数大全】

    深入探索NumPy：科学计算利器的常用函数大全【第86篇—NumPy常用函数大全】

    在数据科学和机器学习领域，NumPy（Numerical Python）模块是Python中最常用的科学计算库之一。它提供了丰富的功能，包括数组操作、数学函数、统计方法等，为数据处理和分析提供了强大的工具。本文将重点介绍NumPy模块中常用的函数，涵盖字符串处理、数学运算、算术操作、

    2024年02月20日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包