Python科学计算

article/2025/10/1 1:07:16

Python 科学计算

NumPy(MatLab 替代品之一)

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

SciPy（科学计算）

SciPy是一个开源的算法库和数学工具包。

其包含最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程常用的计算。

Matplotlib（科学绘图）

Matplotlib是Numpy的数值可视化包，它利用通用的图形用户界面工具包向应用程序嵌入式绘图提供接口。

NumPy

NumPy Ndarray

NumPy 是用来处理数组的，在其内部可生成 Ndarray 对象表示数组。

ndarray 对象用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小区域。

ndarrary 内部构成

一个指向数据的指针

数据类型 dtype(描述数据在内存中固定大小的格子)

一个表示数组形状 (shape) 的元组 (表示各维度大小的元组)

一个跨度元组 (stride) (可为负数意义大致和切片类似)

ndarray内部结构

numpy 创建 array

numpy.array(object, dtype = None,copy = True, order = None, subok = False， ndmin = 0)
参数说明：

名称描述
object数组或嵌套数列
dtype数组元素的类型
copy深拷贝
order创建数组样式（C 为行，F为列，A任意(default)）
subok默认返回一个与基类类型一致的数组
ndmin指定生成数组的最小维度

eg:

创建一维数组

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

创建二维数组

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

创建二维数组

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

创建最小维度为二维的数组

import numpy as np
a = np.array([1,2,3],ndmin = 2)
print(a)
【output】[[1,2,3]]

创建数据类型为复数的数组

import numpy as np
a = np.array([1,2,3],dtype = complex,dmin = 2)
print(a)
【output】[[1.+0.j,2.+0.j,3.+0.j]]

NumPy数据类型

numpy 支持大量的数据类型，可与C语言的数据类型做参照

名称描述字符代码
bool_布尔类型(True, False)b
int_默认整数类型(类比C语言的long->int32，int64)int
intc类比C语言的int->int32,int64int
intp用于索引的正数类型类比C语言的size_t->int32.int64int
int88bit，1字节，类比于char(-128 to 127)i1
int1616bit整数(-32768 to 32767)i2
int3232bit整数(-2147483648 to 2147483647)i3
int6464bit整数(-9223372036854775808 to 9223372036854775807)i4
uint8无符号8bit整数(0 to 255)u1
uint16无符号16bit整数(0 to 65535)u2
uint32无符号32bit整数(0 to 4294967295)u3
uint64无符号64bit整数(0 to 18446744073709551615)u4
float_float64类型简写f
float16半精度浮点型 ->1 个符号位，5 个指数位，10 个尾数位f2
float32单精度浮点型 ->1 个符号位，8 个指数位，23 个尾数位f4
float64双精度浮点型 ->1 个符号位，11 个指数位，52 个尾数位f8
complex_cpmplex128简写，128bit复数c16
complex6464bit复数c8
complex128128bit复数c16
符号描述
'?'boolean
'b'(signed) byte
'B'unsigned byte
'i'(signed) integer
'u'unsigned integer
'f'floating-point
'c'complex-floating point
'm'timedelta
'M'datetime
'O'(Python) objects
'S', 'a'zero-terminated bytes (not recommended)
'U'Unicode string
'V'raw data (void)
Build_In等价
intint_
boolbool_
floatfloat_
complexcfloat
bytesbytes_
strbytes_ (Python2) or unicode_ (Python3)
unicodeunicode_
buffervoid
(all others)object_

dtype 可取类型 np.bool_,np.int32,np.float_,np.complex128

*** 数据类型对象dtype ***

数据类型对象是用来描述与数组对应的内存区域如何使用

  • 数据的类型
  • 数据的大小
  • 数据的字节顺序 (‘<’:小端法(最小的存储在最小的地址，低位存前面，低位先存)，’>‘:大端法)

构造dtype np.dtype(object, align, copy)

align（True/False）如果为 true，填充字段使其类似 C 的结构体

copy（True/False）复制 dtype 对象 ，如果为 False，则是对内置数据类型对象的引用

eg:

import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) 
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student) 
print(student)
print(a['name'])
print(a['age'])
print(a['marks'])

输出

[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')]
[b'abc' b'xyz']
[21 18]
[50. 75.]

NumPy数组属性

数组的维度成为秩（rank), 一维数组 r=1，二维数组r=2…

每一个线性数组称为一个轴（axis）,也称为维度（dimensions）。秩是轴或维度的数量

axis表示轴，对于二维数组来说，axis = 0对列操作，axis = 1是对行操作。

NumPy比较重要的属性有：

属性描述
ndarray.ndim秩，即轴的数量或维度的数量
ndarray.shape数组的维度，对于矩阵（二维数组）来说即行列数（n, m）
ndarray.size数组元素的总个数(n*m)
ndarray.dtypendarray 对象的类型
ndarray.itemsizesndarray 每个元素的大小
ndarray.flagndarray 对象的信息
ndarray.realndarray 元素的实部
ndarray.imagndarray 元素的虚部
ndarray.data包含实际数组元素的缓冲区，一般通过数组的索引获得元素（可忽略）

eg:

np.arange1

import numpy as np
a = np.arange

range返回list，arange返回numpy.ndarray。

都是以三点切片方式控制生成的数列。

arange(start, end, step)
range(start, end, step)

但是arange的step可以是小数，其返回值数列元素类型也为float。

但是有一点类似，返回结果都不包括end。

ndarray.ndim

import numpy as np
a = np.arange(24)
print(a.ndim) #1
b = np.array(a,shape(3,4,2))
print(b)
print(b.ndim) #3

ndarray.shape

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

ndarray.reshape

注意:修改a.shape = shape或a.reshape()是返回一个视图，若返回的视图被修改，源数组也会发生改变。

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

ndarray.itemsize

import numpy as np
x = np.array([1,2,3,4,5,6],dtype = np.int8)
print(x.itemsize) #1
y = np.array([1,2,3,4,5],dtype = np.float64)
print(y.itemsize) #8

ndarray.flags

返回ndarray的对象信息

属性描述
C_CONTIGUOUS ©数据是在一个单一的C风格的连续段中
F_CONTIGUOUS (F)数据是在一个单一的Fortran风格的连续段中
OWNDATA (O)数组拥有它所使用的内存或从另一个对象中借用它
WRITEABLE (W)数据区域可以被写入，将该值设置为 False，则数据为只读
ALIGNED (A)数据和所有元素都适当地对齐到硬件上
UPDATEIFCOPY (U)这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新
import numpy as np
x = np.array([1, 2, 3, 4, 5])
print(x.flags)
# 
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False

NumPy创建数组

  1. b = np.array([…] ,dtype = …)

  2. numpy.empty(shape,dtype = float, order = ‘C’)

    参数描述
    shape数组形状
    dtype数据类型，可选
    order有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
    import numpy as np
x = np.empty([1,2],dtype = int)
print(x)
#未初始化所以是随机值
#未初始化所以是随机值
[[-5968 18343][32766     0][-1344 18343]]
[Finished in 0.3s]

  3. numpy.zeros(shape, dtype = np.float, order = ‘C’)

    import numpy as np
x = np.zeros([3,2], dtype = np.int)
print(x)
y = np.zeros([2,3], dtype = [('x','i4'),('y','i4'),('z', 'i4')])
print(y)
#
[[0 0][0 0][0 0]]
[[(0, 0) (0, 0) (0, 0)][(0, 0) (0, 0) (0, 0)]]

  4. numpy.ones(shape, dtype = np.int4)

    import numpy as np
x = np.ones([3,2], dtype = np.int4)
print(x)
#
[[1 1][1 1][1 1]]

NumPy从已有的数组创建数组

numpy.asarray方法

numpy.asarray 类似numpy.array，但是numpy.asarray的参数只有三个。

numpy.asarray(a, dtype = None, order = None)

参数描述
a任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype数据类型，可选
order可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

将数列转换成 ndarray

import numpy as np
x = [1, 2, 3]
a = np.asarray(x)
print(a)
#
[1, 2, 3]

将元组转化为ndarray

import numpy as np
x = (1, 2, 3)
a = np.asarray(x)
print(a)
#
[1, 2, 3]

将元组列表转换成ndarray

import numpy as np
x = [(1, 2, 3), (4, 5, 6)]
a = np.asarray(x)
print(a)
#
[[1,2,3],[4,5,6]]

numpy.frombuffer方法

numpy.frombuffer可以实现动态数组，其接受buffer输入参数，以流的形式读入转化成ndarray对象

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
参数描述
buffer可以是任意对象，会以流的形式读入。
dtype返回数组的数据类型，可选
count读取的数据数量，默认为-1，读取所有数据。
offset读取的起始位置，默认为0。
import numpy as np
s = b'Hellow,world!'
a = np.frombuffer(s,dtype = 'S1')
print(a)
#
[b'H' b'e' b'l' b'l' b'o' b'w' b',' b'w' b'o' b'r' b'l' b'd' b'!']

NumPy.fromiter方法

numpy.fromiter方法可从可迭代对象中建立ndarray 对象，返回一维数组

np.fromer(iterable, dtype, count = -1)

参数描述
iterable可迭代对象
dtype返回数组的数据类型
count读取的数据数量，默认为-1，读取所有数据
import numpy as np 
l = range(9)
i = iter(l)
x = np,fromiter(i, dtype = np.int4)
print(x)
#
[0 1 2 3 4 5 6 7 8]

NumPy从数值范围创建数组

使用numpy.arange方法生成ndarray对象。

numpy.arange(start, stop, step, dtype)

参数描述
start起始值，默认为0
stop终止值（不包含）
step步长，默认为1(step 可以为浮点小数)
dtype返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型

eg:

x = np.arange(5)

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

x = np.arange(5, dtype = float)

print(x)

[0. 1. 2. 3. 4.]

x =np.arange(10, 20, 2)
print(x)
#
[10 12 14 16 18]

numpy.linspace函数用于创建一个一维数组，数组是一个等差数列构成的。

np.linspace(start, stop, num = 50, endpoint = True, retstep = False, dtype = None)

参数描述
start序列起始值
stop序列终止值
num要生成等步长样本的数量，默认值为50
endpointTure代表包含stop,反之不包含。默认为True
retstepTure代表生成的数组会显示间距，反之不显示
dtypendarray的数据类型
import numpy as np
a = np.linsapce(1, 10, 50,retstep = True)
print(a)
#
(array([ 1.        ,  1.59183673,  2.18367347,  2.7755102 ,  3.36734694,3.95918367,  4.55102041,  5.14285714,  5.73469388,  6.32653061,6.91836735,  7.51020408,  8.10204082,  8.69387755,  9.28571429,9.87755102, 10.46938776, 11.06122449, 11.65306122, 12.24489796,12.83673469, 13.42857143, 14.02040816, 14.6122449 , 15.20408163,15.79591837, 16.3877551 , 16.97959184, 17.57142857, 18.16326531,18.75510204, 19.34693878, 19.93877551, 20.53061224, 21.12244898,21.71428571, 22.30612245, 22.89795918, 23.48979592, 24.08163265,24.67346939, 25.26530612, 25.85714286, 26.44897959, 27.04081633,27.63265306, 28.2244898 , 28.81632653, 29.40816327, 30.        ]), 0.5918367346938775)

NumPy.logspace函数用于创建一个一维数组，数组是一个等比数列构成的。

numpy.logspace(star, stop, num = 50, endpoint, base = '10.0', dtype)

start序列的起始值为：base ** start
stop序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num要生成的等步长的样本数量，默认为50
endpoint该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
base对数 log 的底数。
dtypendarray 的数据类型，默认float
import numpy as np
a = np.logspace(1,10,dtype = np.int64)
print(a)
#
[         10          15          23          35          54          82126         193         294         449         686        10481599        2442        3727        5689        8685       1325720235       30888       47148       71968      109854      167683255954      390693      596362      910298     1389495     21209503237457     4941713     7543120    11513953    17575106    2682695740949150    62505519    95409547   145634847   222299648   339322177517947467   790604321  1206792640  1842069969  2811768697  42919342606551285568 10000000000]

import numpy as np
a = np.logspace(1,10,num = 10,base = 2)
print(a)
#
[   2.    4.    8.   16.   32.   64.  128.  256.  512. 1024.]

NumPy 切片和索引

numpy的ndarray 可以像list那样通过切片和索引操作或访问

import numpy as np
a = np.arange(8)
s = slice(0,5,2)
b = a[s]
c = a[:5:2]
print(a,b,c,sep = '\n')
#
[0 1 2 3 4 5 6 7]
[0 2 4]
[0 2 4]

python list多维数组下标访问

a = [[[1,2,4],[4,5,6]],[[7,8,9],[10,11,12]],[[13,14,15],[16,17,18]]
]
print(a[2][1][2])
#
18

numpy ndarray多维数组下标访问

import numpy as np
a = np.arange(64).shape(4,4,4)
b = a[2,2,2]
print(b)

多维数组操作

import numpy as np
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a[:2,:2])
#
[[1 2][4 5]]

用...代替全维度::

import numpy as np
a = np.arange(64)
b = a.reshape(4,4,4)
print(b[...,2,2])
#
[[[ 0  1  2  3][ 4  5  6  7][ 8  9 10 11][12 13 14 15]][[16 17 18 19][20 21 22 23][24 25 26 27][28 29 30 31]][[32 33 34 35][36 37 38 39][40 41 42 43][44 45 46 47]][[48 49 50 51][52 53 54 55][56 57 58 59][60 61 62 63]]][10 26 42 58]

NumPy 高级索引

  • 整数数组索引

    使用二维数组分别表示行列值

    输出矩阵四角元素的值。

    import numpy as np
x = np.arange(12).reshape(4,3)
print(x)
print(x[[0,0,3,3],[0,2,0,2]])
#
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
[0 2 9 11]y = x[0:-2:-1,[0:-2:-1]]rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  
print(y)
#
[[0 2][9 11]

    import numpy as npa = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print(c)
print(d)#
b = [5 6 8 9]
c = [[5 6][8 9]]
d = [[2 3][5 6][8 9]]

  • 布尔索引

    使用布尔切片过滤掉ndarray小于等于5的值

    import numpy as np
x = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print(x[x>5])
#
[ 6  7  8  9 10 11]

    使用布尔切片过滤掉ndarray等于NaN的值

    import numpy as np
a = np.array(np.nan,1,2,np.nan,4)
print(a[~isnan(a)])
[ 1 2 4]

    使用布尔切片保留复数

    import numpy as np
a = np.array([1, 2+6j, 5, 3.5+5j])
print(a[np.iscomplex(a)])
#
[2. +6.j 3.5+5.j]

  • 花式索引

    使用整数数组进行索引

    一维数组为第一维度

    import numpy as np
x = np.arange(32).reshape(8,4)
print(x[[4,2,1,7]])
#
[[16 17 18 19][ 8  9 10 11][ 4  5  6  7][28 29 30 31]]

    传入倒序一维数组

    import numpy as np
x = np.arange(32).reshape(8,4)
print(x)
print(x[[-4,-2,-1,-7]])
#
[[16 17 18 19][24 25 26 27][28 29 30 31][ 4  5  6  7]]

    传入两个索引数组

    import numpy as np
x = np.arange(32).reshape(8,4)
print(x)
print(x[np.ix_([1,5,3,2],[0,3,2])])
#
[[ 4  7  6][20 23 22][12 15 14][ 8 11 10]]

    广播数组（Broadcast）

    ndarray 做算术运算时要求两个ndarray同型即a.shape=b,shape

    但是遇到在末尾维度相同但是前面不相同时即会自动触发广播机制。

    import numpy as np
a = np.arange(12).reshape(4,3)
b = np.arange(12,24).reshape(4,3)
c = np.asarray([10,20,30])
print(a,b,c,sep = '\n')
print(f'a,b同型直接运算："\n"{a+b}')
print(f'a,c不同维度，a自动出发广播然后运算："\n"{a+c}')
#
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
[[12 13 14][15 16 17][18 19 20][21 22 23]]
[10 20 30]
a,b同型直接运算：
[[12 14 16][18 20 22][24 26 28][30 32 34]]
a,c不同维度，a自动出发广播然后运算：
[[10 21 32][13 24 35][16 27 38][19 30 41]]

    广播原理：

    broadcase

    np.tile(x,y,z,…)方法：tile即瓷砖，即将该数组进行横向纵向复制

    import numpy as np
mat = np.tile(np.array([[1,2,3],[4,5,6]]),(2,3))
print(mat)
#
[[1 2 3 1 2 3 1 2 3][4 5 6 4 5 6 4 5 6][1 2 3 1 2 3 1 2 3][4 5 6 4 5 6 4 5 6]]

    即broadcast 执行过程：

    import numpy as np
a = np.array([[0,0,0],[10,10,10],[20,20,20],[30,30,30]])
b = np.array([1,2,3])
c = a+b
d = a+np.tile(b,(4,1))
print(c,d,sep = '\n')
#
[[ 1  2  3][11 12 13][21 22 23][31 32 33]]
[[ 1  2  3][11 12 13][21 22 23][31 32 33]]

    广播的规则:

  • 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。

  • 输出数组的形状是输入数组形状的各个维度上的最大值。

  • 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。

  • 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

    **简单理解：**对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

  • 数组拥有相同形状。

  • 当前维度的值相等。

  • 当前维度的值有一个是 1。

    若条件不满足，抛出 "ValueError: frames are not aligned或者

    ValueError: operands could not be broadcast together with shapes" 异常。

NumPy迭代数组

Numpy提供了numpt.nditer用来灵活访问数组元素

import numpy as npa = np.arange(6).reshape(3,2)print(a)for x in np.nditer(a):print(x,end = ',')
print('\n')
for x in np.nditer(a.T):print(x,end = ',')
print('\n')
for x in np.nditer(a.T.copy(order = 'C')):print(x,end = ',')
print('\n')
for x in np.nditer(a.T,order = 'C'):print(x,end = ',')
print('\n')
for x in np.nditer(a.T,order = 'F'):print(x,end = ',')
print('\n')
#
[[0 1][2 3][4 5]]
0,1,2,3,4,5,0,1,2,3,4,5,0,2,4,1,3,5,0,2,4,1,3,5,0,1,2,3,4,5, #反反得反

ndarray.T表示ndarray的转置

import numpy as npa = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始数组是：') 
print (a) 
print ('\n') 
print ('原始数组的转置是：') 
b = a.T #b是a的转置
print (b) 
print ('\n') 
print ('以 C 风格顺序排序：') 
c = b.copy(order='C')  
print (c)
for x in np.nditer(c):  print (x, end=", " )
print  ('\n') 
print  ('以 F 风格顺序排序：')
c = b.copy(order='F')  
print (c)
for x in np.nditer(c):  print (x, end=", " )
#
原始数组是：
[[ 0  5 10 15][20 25 30 35][40 45 50 55]]原始数组的转置是：
[[ 0 20 40][ 5 25 45][10 30 50][15 35 55]]以 C 风格顺序排序：
[[ 0 20 40][ 5 25 45][10 30 50][15 35 55]]
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, 以 F 风格顺序排序：
[[ 0 20 40][ 5 25 45][10 30 50][15 35 55]]
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,

修改数组中元素的值

op_flags = [‘readwrite’]

import numpy as npa = np.arange(0,60,5).reshape(3,4)
print('原始数据：\n',a)
for x in np.nditer(a, op_flags = ['readwrite']):x[...]*=2
print('现在数据：\n',a)
#
原始数据：[[ 0  5 10 15][20 25 30 35][40 45 50 55]]
现在数据：[[  0  10  20  30][ 40  50  60  70][ 80  90 100 110]]

使用外部循环(不重要)

np.nditer()有很多参数其中flags参数可取下列值

参数描述
c_index可以跟踪 C 顺序的索引
f_index可以跟踪 Fortran 顺序的索引
multi-index每次迭代可以跟踪一种索引类型
external_loop给出的值是具有多个值的一维数组，而不是零维数组
import numpy as np 
a = np.arange(0,60,5) 
a = a.reshape(3,4)  
print ('原始数组是：')
print (a)
print ('\n')
print ('修改后的数组是：')
for x in np.nditer(a, flags =  ['external_loop'], order =  'F'):  print (x, end=", " )

使用广播循环

如果两个数组可以广播，nditer组合对象能够同时迭代它们。（广播条件，见上广播规则)

import numpy as np
a = np.arange(0,60,5).reshape(3,4)
b = np.array([11,22,33,44],dtype = 'int')
for x,y in np.nditer([a,b],order = 'C'):print(f'{x}:{y}',end = ',')
#
0:11,5:22,10:33,15:44,20:11,25:22,30:33,35:44,40:11,45:22,50:33,55:44,

NumPy数组操作

  • 修改数组形状(reshape)

    ndarray.reshape可以重定义数组行列

    ndarray.flat是一个数组元素迭代器，可用for in 访问迭代器内的值

    ndarray.flatten返回一份数组拷贝，对拷贝进行修改并不会改变原始数组

    ndarray.flatten(order = ‘C’)#按照C（即按行）展开

    ndarray.flatten(order = ‘F’)#按照F（即按列）展开

    numpy.ravel(ndarray, order = 'C')展平数组元素，返回引用修改会引起原来的ndarray发生改变

    order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序

  • 翻转数组(transpose)
    numpy.transpose(ndarray, axes)翻转数组（相当于ndarray.T）

    axes：维度

    numpy.rollaxis(ndarray,axis,start)函数向后滚动一个特定的轴到特定的位置

    axis：要向后滚动的轴

    start = 0：默认为0表示完整的滚动

import numpy as npa = np.arange(27).reshape([3,3,3])
print(a)print(np.rollaxis(a,2))print(np.rollaxis(a,2,1))
print(np.rollaxis(a,1,0))
#
[[[ 0  1  2][ 3  4  5][ 6  7  8]][[ 9 10 11][12 13 14][15 16 17]][[18 19 20][21 22 23][24 25 26]]]
yzx
[[[ 0  3  6][ 9 12 15][18 21 24]][[ 1  4  7][10 13 16][19 22 25]][[ 2  5  8][11 14 17][20 23 26]]]
xzy
[[[ 0  3  6][ 1  4  7][ 2  5  8]][[ 9 12 15][10 13 16][11 14 17]][[18 21 24][19 22 25][20 23 26]]]
yxz
[[[ 0  1  2][ 9 10 11][18 19 20]][[ 3  4  5][12 13 14][21 22 23]][[ 6  7  8][15 16 17][24 25 26]]]

​ numpy.swapaxes(ndarray,axis1,axis2)交换数组的两个轴

import numpy as npa = np.arange(27).reshape([3,3,3])
print(a)
print(np.swapaxes(a,2,1))
print(np.swapaxes(a,1,0))
print(np.swapaxes(a,2,0))
#
[[[ 0  1  2][ 3  4  5][ 6  7  8]][[ 9 10 11][12 13 14][15 16 17]][[18 19 20][21 22 23][24 25 26]]]
xzy
[[[ 0  3  6][ 1  4  7][ 2  5  8]][[ 9 12 15][10 13 16][11 14 17]][[18 21 24][19 22 25][20 23 26]]]
yxz
[[[ 0  1  2][ 9 10 11][18 19 20]][[ 3  4  5][12 13 14][21 22 23]][[ 6  7  8][15 16 17][24 25 26]]]zyx
[[[ 0  9 18][ 3 12 21][ 6 15 24]][[ 1 10 19][ 4 13 22][ 7 16 25]][[ 2 11 20][ 5 14 23][ 8 17 26]]]

  • 修改数组维度(broadcast,broadcast_to,expand_dims,squeeze)

    函数描述
    broadcast产生模仿广播的对象
    broadcast_to将数组广播到新形状
    expand_dims扩展数组的形状
    squeeze从数组的形状中删除一维条目

    numpy.broadcast用于模仿广播对象，它返回一个对象（numpy.broadcast object），该对象封装了将一个数组广播到另一个数组的结果。

    numpy.broadcast_to(array, shape, subok) 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError。

    numpy.expand_dims(arr, axis) 函数通过在指定位置插入新的轴来扩展数组形状。

    numpy.squeeze(arr,axis = 0)函数从给定数组的形状中删除一维的条目

  • 连接数组

    函数描述
    concatenate连接沿现有轴的数组序列
    stack沿着新的轴加入一系列数组。
    hstack水平堆叠序列中的数组（列方向）
    vstack竖直堆叠序列中的数组（行方向）

numpy.concatenate((a1, a2, ...), axis = 0)

import numpy as npa = 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]]
[Finished in 0.3s]

numpy.stack(arrays, axis)沿新的轴连接数组，新建一个维度

numpy.hstack(ndarray1,ndarray2)水平堆叠生成数组

numpy.vstack(ndarray1,ndarray2)垂直堆叠生成数组

  • 分割数组
函数数组及操作
split将一个数组分割为多个子数组
hsplit将一个数组水平分割为多个子数组（按列）
vsplit将一个数组垂直分割为多个子数组（按行）

numpy.split(ary, indices_or_sections, axis)沿特定轴将数组分割为子数组

ary：被分割的数组
indices_or_sections：果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分

import numpy as npa = np.arange(9)print ('第一个数组：')
print (a)
print ('\n')print ('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print (b)
print ('\n')
#[array([0,1,2]),array([3,4,5]),array([6,7,8])]print ('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print (b)
#[array([0,1,2,3],array([4,5,6]),array([7,8])]

numpy.hsplit函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组，用法和split类似。

numpy.vsplit 沿着垂直轴分割，其分割方式与split用法相同

  • 数组元素的添加和删除
函数元素及描述
resize返回指定形状的新数组
append将值添加到数组末尾
insert沿指定轴将值插入到指定下标之前
delete删掉某个轴的子数组，并返回删除后的新数组
unique查找数组内的唯一元素

numpy.resize(arr, shape) np.resize(arr,shape)等价于arr.resize(shape)

numpy.append(arr, values, axis=None)函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。

import numpy as npa = np.array([[1,2,3],[4,5,6]])
print (a)
#
[[1 2 3][4 5 6]]print ('向数组添加元素：')
print (np.append(a, [7,8,9]))
#未传递axis数组会展开
[1 2 3 4 5 6 7 8 9]print ('沿轴 0 添加元素：')
print (np.append(a, [[7,8,9]],axis = 0))
#
[[1 2 3][4 5 6][7 8 9]] 
print ('沿轴 1 添加元素：')
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))
#
[[1 2 3 5 5 5][4 5 6 7 8 9]]

numpy.insert(arr, obj, values, axis)函数在给定索引之前，沿给定轴在输入数组中插入值。

import numpy as npa = np.array([[1,2],[3,4],[5,6]])
print (a)
#
[[1 2][3 4][5 6]]
print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.insert(a,3,[11,12]))
#
[1 2 3 11 12 4 5 6]
print ('传递了 Axis 参数。 会广播值数组来配输入数组。')
print ('沿轴 0 广播：')
print (np.insert(a,1,[11],axis = 0))
#自动广播
[[1 2][11 11][3 4][5 6]]
print ('沿轴 1 广播：')
print (np.insert(a,1,11,axis = 1))
[[1 11 2][3 11 4][5 11 6]]

Numpy.delete(arr, obj, axis)函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。

arr：输入数组
obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))
#np.s_[：：]切片

numpy.unique(arr, return_index, return_inverse, return_counts)函数用于去除数组中的重复元素。

arr：输入数组，如果不是一维数组则会展开
return_index：如果为true，返回新列表元素在旧列表中的位置（下标），并以列表形式储
return_inverse：如果为true，返回旧列表元素在新列表中的位置（下标），并以列表形式储
return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

位运算(bitwise按位)

numpy.bitwise_and(a,b)与运算

numpy.bitwise_or(a,b)或运算

numpy.invert()非

left_shift(a,width = 8)按位左移

right_shift(a,width = 8)按位右移

字节转换函数

ndarray.byteswap(True/False)对ndarray中的元素进行大小端字节转换

字符串函数

函数描述
numpy.char.add(['s1'],['s2'])对两个数组的逐个字符串元素进行连接
numpy.char.multiply(['s'],mult)返回按元素多重连接后的字符串
numpy.char.center('str',width = Num,fillchar = '*')居中字符串
numpy.char.capitalize('str')将字符串第一个字母转换为大写
numpy.char.title('str')将字符串的每个单词的第一个字母转换为大写
numpy.char.lower('str')数组元素转换为小写
numpy.char.upper('str')数组元素转换为大写
numpy.char.split('str',sep = '*')指定分隔符对字符串进行分割，并返回数组列表
numpy.char.splitlines('str')返回元素中的行列表，以换行符分割
numpy.char.strip('str','char')移除元素开头或者结尾处的特定字符
numpy.char.join(['char1','char2'],['str1',str2])通过指定分隔符来连接数组中的元素
numpy.char.replace('str','s1',s2)使用新字符串s2替换字符串中的所有子字符串s1
numpy.char.decode()数组元素依次调用str.decode
numpy.char.encode()数组元素依次调用str.encode

数学函数

三角函数

​ NumPy 提供了标准的三角函数：numpy.sin()、numpy.cos()、numpy.tan()

import numpy as npa = 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))

numpy.arcsin，numpy.arccos，和 numpy.arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数

舍入函数

​ numpy.around(a,decimals)四舍五入

>a: 数组
>
>decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置（即 numpy.around(192.586,decimals = -1） 190)

​ numpy.floor()向下舍入

​ numpy.ceil()向上舍入

运算函数

NumPy 算术函数包含简单的加减乘除: numpy.add()，numpy.subtract()，numpy.multiply() 和 numpy.divide()

numpy.reciprocal()函数返回参数逐元素的倒数

import numpy as np a = np.array([0.25,  1.33,  1,  100])  
print ('调用 reciprocal 函数：')
print (np.reciprocal(a))
#
调用 reciprocal 函数：
[4.        0.7518797 1.        0.01     ]

numpy.power()函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。

统计函数

numpy.amin(arr,axis = None)用于计算数组中的元素沿指定轴的最小值。axis 默认为None，即将arr展开。

numpy.amax(arr,axis = None)用于计算数组中的元素沿指定轴的最大值。用法与numpy.amin相似。

numpy.ptp(arr,axis = None)函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。

numpy.percentile(a,q,axis = None，keepdims = False)百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数。

a：数组

q：要计算的百分位数[0-100]

axis：维度

keepdims：保持原数组的dims

numpy.median(arr, axis = None) 函数用于计算数组 a 中元素的中位数（中值）

numpy.mean(arr, axis = None)函数返回数组中元素的算术平均值。 (算术平均值是沿轴的元素的总和除以元素的数量。)

numpy.average(arr, axis = None,weights = wts) 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。不指定权重默认为1，此时和mean结果相同

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))

numpy.std(arr,axis = None)标准差，等价于 sqrt(numpy.mean(arr-numpy.mean(arr,axis = None)**2))

numpy.var(arr,axis = None)方差，等价于numpy.mean(arr-numpy.mean(arr,axis = None)**2)

NumPy排序

numpy.sort(ndarray,axis,kind,order)

axis 默认为None这时数组会展开；kind 可以选quicksort(defult),mergesort,heapsort

order如果数组包含字段则是要排序的字段

import numpy as npdtp = [('name','S10'),('age',np.int8)]
a = np.array([("bob",12),('alis',13),('john',11)],dtype = dtp)
print(a)
print('sort by name:',np.sort(a,order = 'name'))
print('sort by age:',np.sort(a,kind = 'quicksort',order = 'age'))
#
[(b'bob', 12) (b'alis', 13) (b'john', 11)]
sort by name: [(b'alis', 13) (b'bob', 12) (b'john', 11)]
sort by age: [(b'john', 11) (b'bob', 12) (b'alis', 13)]

numpy.argsort(ndarray,axis = -1,kind = 'quicksort',order = None)函数返回排序后的索引值。

numpy.lexsort(tuple) 按照多个序列排序。返回排序后的索引值，可使用 for 遍历。

numpy.msort(ndarray) = numpy.sort(a,axis = 0)按照第一个轴排序

sort_complex(ndarray) 对复数数列按照先实部后虚部进行排序。

partition(ndarray, kth[, axis, kind, order]) 指定一个数对数组进行分区(即快速排序的步骤)

kth接收tuple表示的区间，np.partition(arr,(1,3))即小于1的放最前面，[1,3)放中间，大于3的放最后。

argpartition(ndarray,kth[, axis, kind, order]) 返回partition结果中元素的索引

numpy.argmax()返回给定轴最大元素的索引

numpy.argmin()返回给定轴最小元素的索引

numpy.nonzero()返回数组中非零元素的索引

numpy.where()返回满足条件的元素的索引（参照布尔切片）

numpy.extract()根据条件返回满足条件的元素

import numpy as np
x = np.arange(9).reshape(3,3)
condition = np.mod(x,2) == 0#返回一个bool_numpy.ndarray
print(condition)
print(np.extract(condition,x))#print(x[x%2==0])
#
[[ True False  True][False  True False][ True False  True]]
[0 2 4 6 8]

矩阵库

NumPy 中包含一个矩阵库 numpy.matlib,操作对象和返回对象都是矩阵，而不是ndarray。

numpy.matlib.empty(shape, dtype = np.float, order)返回一个新的矩阵

numpy.matlib.zeros(shape, dtype = np.float, order)返回一个初始值为0的新矩阵

numpy.matlib.ones(shape, dtype = np.float, order)返回一个初始值为1的新矩阵

numpy.matlib.eye(n, M = n, k, dtype = np.float)返回一个主对角线为1的对角矩阵。(k为对角线偏置，为0则为主对角线，小于0向下偏，大于0向上偏)

numpy.matlib.identity()返回给定大小的单位阵。

np.matlib.identity(5, dtype = np.float)等价于numpy.matlib.eye(5,k=0,dtype = np.float)

numpy.matlib.rand(n,M,dtype = np.float)返回一个n维矩阵，数值随机（值小于1大于0）

matlib总是一个二维数组，其本质是ndarray。二者之间可以直接赋值或深拷贝。

线性代数

NumPy内置了线性代数库linalg。

函数描述
dot两个数组的点积，即元素对应相乘。
vdot两个向量的点积，高维数组自动降维
inner两个数组的内积
matmul两个数组的矩阵积
determinant数组的行列式
solve求解线性矩阵方程
inv计算矩阵的乘法逆矩阵

numpy.dot(a, b, out = None)两个向量的矢量积

a : ndarray 数组

b : ndarray 数组

out : ndarray, 可选，用来保存dot()的计算结果

import numpy as np
import numpy.linalg
import numpy.matlib
a = np.arange(1,7).reshape(3,2,order = 'F')
b = np.arange(1,7).reshape(2,3,order = 'C')
print(a,b,sep = '\n')
n = np.dot(a,b)
print(n)
m = np.dot(b,a)
print(m)
#
[[1 4]
[2 5]
[3 6]]
[[1 2 3]
[4 5 6]]
[[17 22 27]
[22 29 36]
[27 36 45]]
[[14 32]
[32 77]]

numpy.vdot(a, b)两个向量的数量积在计算高维数量积时，先把高维降到一维，然后进行数量积运算。

numpy.inner(ndarray)一维ndarray内积运算，高维数组为对应维度上的内积运算。

对于多维数组相当：

import numpy as np 
a = np.arange(1,5).reshape(2,2)
b = np.arange(5,9).reshape(2,2)
print (a,b,np.inner(a,b),sep = '\n')
print(np.dot(a,b))
#
[[1 2][3 4]]
[[5 6][7 8]]
inner()
[[17 23][39 53]]
dot()
[[19 22][43 50]]
inner运算类似于
[a11*b11+a12*b12,a11*b21+a12*b22]
[a21*b11+a22*b12,a21*b21+a22*b22]

numpy.matmul(a, b, out = None)返回矩阵乘积，高于二维视为存在最后两个索引的矩阵的栈，若有一个为一维，则横向广播，然后再进行乘积，最后反横向广播。

import numpy as np 
a = np.array([[1,2],[3,4]])
b = np.array([[2,2],[3,3]])
c = np.array([2,3])
print(np.matmul(a,c))
print(np.matmul(a,b))
#
[ 8 18]
[[ 8  8][18 18]]

numpy.linalg.det(ndarray)计算输入矩阵的行列式的值。

numpy.linalg.solve(ndarray1,ndarray2)计算增广矩阵的解。

import numpy as np 
import numpy.linalga = np.array([2,2,-1,1,-2,4,5,8,-1]).reshape(3,3)
b = np.array([6,3,27])
print(np.linalg.solve(a,b))
#
[1. 3. 2.]

numpy.linalg.inv(ndarray)计算可逆矩阵的逆矩阵。

import numpy as np 
import numpy.linalgprint(np.linalg.inv(np.array([1,2,-1,-3]).reshape(2,2)))
#
[[ 3.  2.][-1. -1.]]

副本和视图

副本即拷贝，在内存中重新划出一块区域把源数据拷贝一份，修改副本内的内容源数据不会同时修改。

视图本身上还是源数据，只是改变了形状(shape)，修改视图会导致源数据发生变化。reshape,ravel,切片返回的都是视图，

视图一般发生在：

  • 1、numpy 的切片操作返回原数据的视图。
  • 2、调用 ndarray 的 view() 函数产生一个视图。

副本一般发生在：

  • Python 序列的切片操作，调用deepCopy()函数。
  • 调用 ndarray 的 copy() 函数产生一个副本。

注意：对于numpy.ndarray对象来说，简单的赋值（a = b）不会引起产生副本。

修改视图的形状不会改变原数组的形状

  1. arange和range ↩︎


http://chatgpt.dhexx.cn/article/nVUalxSo.shtml

相关文章

深度阐述数据建模及可视化系统技术方案

深度阐述数据建模及可视化系统技术方案

1.系统概述 数据建模及可视化系统系统是一站式全链路数据生命周期管家&#xff0c;帮助用户管理数据资产并挖掘价值。平台提供多源异构的数据采集模块、实时/离线计算框架&#xff0c;简洁易用的开发环境和平台接口&#xff0c;为政府机构、企业、科研机构、第三方软件服务商等…
阅读更多...
数据可视化现状调研

数据可视化现状调研

数据可视化现状调研 概述 数据可视&#xff08;Data visualization&#xff09;数据可视化主要旨在借助于图形化手段&#xff0c;清晰有效地传达与沟通信息。但是&#xff0c;这并不就意味着&#xff0c;数据可视化就一定因为要实现其功能用途而令人感到枯燥乏味&#xff0c;…
阅读更多...
数据可视化课程大纲和教学设计及源代码

数据可视化课程大纲和教学设计及源代码

一、课程基本信息 二、课程定位 《数据可视化》课程是面向全校学生的一门公共选修课。本课程包括16学时的理论教学和16学时的实践教学&#xff0c;在校内完成。 《数据可视化》课程是一门理论性和实践性都很强的课程。本课程本着“技能培养为主、理论够用为度”的原则&#x…
阅读更多...
工业数据可视化

工业数据可视化

工业大数据是指在工业领域中&#xff0c;围绕典型智能制造模式&#xff0c;从客户需求到销售、订单、计划、研发、设计、工艺、制造、采购、供应、库存、发货和交付、售后服务、运维、报废或回收再制造等整个产品全生命周期各个环节所产生的各类数据及相关技术和应用的总称。其…
阅读更多...
数据可视化选择题

数据可视化选择题

第一章 打开可视化大门 多选(3分) 可视化的分类包含&#xff1a; A.科学可视化B.信息可视化C.智能可视化D.可视分析学 ABD ‏2. 以下哪张图片为科学可视化结果&#xff1a; A. B. C. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cynHvYcn…
阅读更多...
52个数据可视化图表鉴赏

52个数据可视化图表鉴赏

文章目录 1.弧线图2.面积图3.箭头图4.条形图5.布林线指标6.箱线图7.气泡地图8.子弹图9.凹凸图10.日历图11.烛台图12.卡通图13.弦图14.分级统计图15.组合图表16.连接地图17.控制图18.南丁格尔玫瑰图19.交叉表20.环形图21.漏斗图22.甘特图23.热图24.六边形平铺地图25.直方图26.地…
阅读更多...
解构数据可视化

解构数据可视化

文章目录 什么是数据可视化数据可视化四大过程1. 确定主题2. 提炼数据3. 确认图表4. 可视化设计及布局 可视化映射1. 可视化空间2. 标记3. 视觉通道 什么是数据可视化 数据可视化的目标是透过数据的表象&#xff0c;洞悉其中的规律&#xff0c;指导用户高效、准确地进行决策。 …
阅读更多...
数据可视化学习之大屏学习

数据可视化学习之大屏学习

一 前言 什么是数据可视化大屏&#xff1f;数据可视化大屏是以大屏为主要展示载体的数据可视化设计。可视化大屏就是一种非常有效的数据可视化工具&#xff0c;它可以将业务的关键指标以可视化的方式展示到一个或多个LED屏幕上&#xff0c;不仅使业务人员能够从复杂的业务数据…
阅读更多...
数据可视化学习路线

数据可视化学习路线

写在前面 有幸看到了这篇关于数据可视化学习的指导文章&#xff0c;由于原作链接访问异常&#xff0c;只得从百度快照中看到原文&#xff0c;所以这里搬运过来&#xff0c;特此声明本文系【转载】&#xff0c;在此感谢原作者&#xff0c;以下为原文正文(略有删减)。 原作者: 张…
阅读更多...
数据挖掘——数据可视化

数据挖掘——数据可视化

数据可视化 1.数据可视化第一关 数据可视化的内涵1>数据可视化是什么&#xff1f;2>为什么需要数据可视化&#xff1f;3>历史演变4>习题 第二关 初识数据第三关 柱状图第四关 散点图第五关 直方图 2.数据可视化进阶第一关 热图1>热图的作用&#xff1f;2>习题…
阅读更多...
初识前端数据可视化

初识前端数据可视化

目录 前端数据可视化的开发工具 前端三件套 Echarts.js Highcharts.js D3.js Vue.js python Tableau 编译器 数据可视化的分支 信息可视化 科学可视化 可视分析学 什么是前端&#xff1f;前端&#xff0c;通俗来说就是网页呈现给我们看的那部分。比如hao123这个…
阅读更多...
数据可视化 复习笔记2022

数据可视化 复习笔记2022

1.可视化释义 可视化对应Visualize和Visualization。Visualize是动词&#xff0c;即“生成符合人类感知”的图像&#xff1b;通过可视元素传递信息。Visualization是名词&#xff0c;表达“使某物、某事可见的动作或事实”,对某个原本不可见的事物在人的大脑中形成一幅可感知的…
阅读更多...
前端数据可视化入门

前端数据可视化入门

这是一篇给大家提供数据可视化开发的入门指南&#xff0c;介绍了可视化要解决的问题和可以直接使用的工具&#xff0c;我将从下面几个方面给大家介绍&#xff0c;同时以阿里/蚂蚁的可视化团队和资源举例说明&#xff1a; 什么是数据可视化&#xff1f; 怎样进行数据可视化&…
阅读更多...
关系数据可视化

关系数据可视化

关系数据可视化 本文所做的数据的数据可视化实现基于python 3.9.4&#xff0c;需安装matplotlib、numpy、pyecharts、pandas、plotly等依赖库&#xff0c;可通过下述命令完成。 pip install matplotlib pip install numpy pip install -v pyecharts1.1.0 pip install plotly …
阅读更多...
Echarts数据可视化

Echarts数据可视化

Echarts Echarts 简介Echarts快速上手柱状图柱状图的基本使用其他常见效果 通用配置项titletooltiptoolboxlegend 折线图折线图基本配置其他效果 饼状图 Echarts 简介 Echarts 缩写来自 Enterprise Charts&#xff08;商业级数据图表&#xff09;&#xff0c;是百度的一个开源的…
阅读更多...
实验4 Matplotlib数据可视化

实验4 Matplotlib数据可视化

1. 实验目的 ①掌握Matplotlib绘图基础&#xff1b; ②运用Matplotlib&#xff0c;实现数据集的可视化&#xff1b; ③运用Pandas访问csv数据集。 2. 实验内容 ①绘制散点图、直方图和折线图&#xff0c;对数据进行可视化&#xff1b; ②下载波士顿数房价据集&#xff0c;并…
阅读更多...
数据可视化-期末复习重点笔记

数据可视化-期末复习重点笔记

文章目录 前言一、绘制常见图形。1.1 sinx、cosx曲线图1.2 散点图1.2.1通过matplotlib实现1.2.2通过pyecharts实现 1.3 柱形图1.3.1通过matplotlib实现1.3.2通过pyecharts实现 1.4 柱形堆叠图1.4.1通过matplotlib实现1.4.2通过pyecharts实现 1.5 折线图1.6 拟合曲线1.7 堆叠面积…
阅读更多...
【独家】一文读懂数据可视化

【独家】一文读懂数据可视化

前言 数据可视化，是指将相对晦涩的的数据通过可视的、交互的方式进行展示，从而形象、直观地表达数据蕴含的信息和规律。 早期的数据可视化作为咨询机构、金融企业的专业工具，其应用领域较为单一，应用形态较为保守。步入大数据时代，各行各业对数据的重视程度与日俱增，随之…
阅读更多...
4.2 数据可视化

4.2 数据可视化

一、 数据可视化介绍 1. 概念 数据可视化&#xff1a;是指以 图形、图像、地图、动画 等更为生动、易于理解的方式展现具体数据&#xff0c;诠释数据之间的关系和发展的趋势&#xff0c;以期更好地理解和使用数据。 大数据可视化分析利用支持信息可视化的用户界面以及支持分…
阅读更多...
一图胜千言！这10种可视化技术你必须知道

一图胜千言！这10种可视化技术你必须知道

全文共4549字，预计学习时长9分钟 图片来源：Willian Justen deVasconcellos on Unsplash 相比于浩如烟海的数据表格，大部分人还是更喜欢视觉资料，这一点已不足为奇。也是出于这个原因，人们通常才会在学术论文的前几页加上一张图表，并且清楚地标记上各种注释。 当数据科学家…
阅读更多...
推荐文章

Copyright @ 2022~2023