python数组维数怎么求

A. python关于numpy基础问题

Python发展至今，已经有越来越多的人使用python进行科学技术，NumPY是python中的一款高性能科学计算和数据分析的基础包。
ndarray
ndarray（以下简称数组）是numpy的数组对象，需要注意的是，它是同构的，也就是说其中的所有元素必须是相同的类型。其中每个数组都有一个shape和dtype。
shape既是数组的形状，比如
复制代码
1 import numpy as np
2 from numpy.random import randn
3
4 arr = randn(12).reshape(3, 4)
5
6 arr
7
8 [[ 0.98655235 1.20830283 -0.72135183 0.40292924]
9 [-0.05059849 -0.02714873 -0.62775486 0.83222997]
10 [-0.84826071 -0.29484606 -0.76984902 0.09025059]]
11
12 arr.shape
13 (3, 4)
复制代码
其中(3, 4)即代表arr是3行4列的数组，其中dtype为float64
一下函数可以用来创建数组
array将输入数据转换为ndarray，类型可制定也可默认
asarray将输入转换为ndarray
arange类似内置range
ones、ones_like根据形状创建一个全1的数组、后者可以复制其他数组的形状
zeros、zeros_like类似上面，全0
empty、empty_like创建新数组、只分配空间
eye、identity创建对角线为1的对角矩阵
数组的转置和轴对称
转置是多维数组的基本运算之一。可以使用.T属性或者transpose()来实现。.T就是进行轴对换而transpose则可以接收参数进行更丰富的变换
复制代码
arr = np.arange(6).reshape((2,3))
print arr
[[0 1 2]
[3 4 5]]
print arr.T
[[0 3]
[1 4]
[2 5]]
arr = np.arange(24).reshape((2,3,4))
print arr
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
print arr.transpose((0,1,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]]]
复制代码
数组的运算
大小相等的数组之间做任何算术运算都会将运算应用到元素级别。
复制代码
1 arr = np.arange(9).reshape(3, 3)
2 print arr
3
4 [[0 1 2]
5 [3 4 5]
6 [6 7 8]]
7
8 print arr*arr
9
10 [[ 0 1 4]
11 [ 9 16 25]
12 [36 49 64]]
13
14 print arr+arr
15
16 [[ 0 2 4]
17 [ 6 8 10]
18 [12 14 16]]
19
20 print arr*4
21
22 [[ 0 4 8]
23 [12 16 20]
24 [24 28 32]]
复制代码
numpy的简单计算中，ufunc通用函数是对数组中的数据执行元素级运算的函数。
如：
复制代码
arr = np.arange(6).reshape((2,3))
print arr
[[0 1 2]
[3 4 5]]
print np.square(arr)
[[ 0 1 4]
[ 9 16 25]]
复制代码
类似的有：abs,fabs,sqrt,square,exp,log,sign,ceil,floor,rint,modf,isnan,isfinite,isinf,cos,cosh,sin,sinh,tan,tanh，
add,subtract,multiply,power,mod,equal,等等

B. 什么是数组的维度，python 的ndim的使用

数组的维度就是一个数组中的某个元素，当用数组下标表示的时候，需要用几个数字来表示才能唯一确定这个元素，这个数组就是几维。numpy中直接用 * 即可表示数与向量的乘法，参考python 2.7的一个例子：inport numpy as np a = np.array([1,2,3,4]) # 向量 b = 5 # 数 print a*b ++++++++++++ [5,10,15,20]

C. python 怎么查看一个矩阵的维数

都是复制党，网络知道回答真的质量太低了，真的很心疼，言归正传

利用numpy求矩阵维数：

importnumpy#导入numpy模块，piplist可以查看是否安装了该模块

print("数组的维度数目",a1.ndim)

很多人提到了shape函数，这也加上吧

print("数组的维度",a1.shape)

不过这里打印的不是矩阵维数，而是告诉你矩阵维度元祖

比如(28,28,3)，能够看出这是一个3维矩阵，但返回的不是维度

D. Python怎么生成三维数

1、创建一般的多维数组

importnumpyasnp
a=np.array([1,2,3],dtype=int)#创建1*3维数组array([1,2,3])
type(a)#numpy.ndarray类型
a.shape#维数信息(3L,)
a.dtype.name#'int32'
a.size#元素个数：3
a.itemsize#每个元素所占用的字节数目:4


b=np.array([[1,2,3],[4,5,6]],dtype=int)#创建2*3维数组array([[1,2,3],[4,5,6]])
b.shape#维数信息（2L,3L）
b.size#元素个数：6
b.itemsize#每个元素所占用的字节数目:4


c=np.array([[1,2,3],[4,5,6]],dtype='int16')#创建2*3维数组array([[1,2,3],[4,5,6]],dtype=int16)
c.shape#维数信息（2L,3L）
c.size#元素个数：6
c.itemsize#每个元素所占用的字节数目:2
c.ndim#维数


d=np.array([[1,2,3],[4,5,6]],dtype=complex)#复数二维数组
d.itemsize#每个元素所占用的字节数目：16
d.dtype.name#元素类型：'complex128'

2、创建一般的多维数组

importnumpyasnp
a=np.array([1,2,3],dtype=int)#创建1*3维数组array([1,2,3])
type(a)#numpy.ndarray类型
a.shape#维数信息(3L,)
a.dtype.name#'int32'
a.size#元素个数：3
a.itemsize#每个元素所占用的字节数目:4


b=np.array([[1,2,3],[4,5,6]],dtype=int)#创建2*3维数组array([[1,2,3],[4,5,6]])
b.shape#维数信息（2L,3L）
b.size#元素个数：6
b.itemsize#每个元素所占用的字节数目:4


c=np.array([[1,2,3],[4,5,6]],dtype='int16')#创建2*3维数组array([[1,2,3],[4,5,6]],dtype=int16)
c.shape#维数信息（2L,3L）
c.size#元素个数：6
c.itemsize#每个元素所占用的字节数目:2
c.ndim#维数


d=np.array([[1,2,3],[4,5,6]],dtype=complex)#复数二维数组
d.itemsize#每个元素所占用的字节数目：16
d.dtype.name#元素类型：'complex128'

3、创建特殊类型的多维数组

a1=np.zeros((3,4))#创建3*4全零二维数组
输出：
array([[0.,0.,0.,0.],
[0.,0.,0.,0.],
[0.,0.,0.,0.]])
a1.dtype.name#元素类型：'float64'
a1.size#元素个数：12
a1.itemsize#每个元素所占用的字节个数：8


a2=np.ones((2,3,4),dtype=np.int16)#创建2*3*4全1三维数组
a2=np.ones((2,3,4),dtype='int16')#创建2*3*4全1三维数组
输出：
array([[[1,1,1,1],
[1,1,1,1],
[1,1,1,1]],

[[1,1,1,1],
[1,1,1,1],
[1,1,1,1]]],dtype=int16)


a3=np.empty((2,3))#创建2*3的未初始化二维数组
输出：（mayvary）
array([[1.,2.,3.],
[4.,5.,6.]])


a4=np.arange(10,30,5)#初始值10，结束值：30（不包含），步长：5
输出：array([10,15,20,25])
a5=np.arange(0,2,0.3)#初始值0，结束值：2（不包含），步长：0.2
输出：array([0.,0.3,0.6,0.9,1.2,1.5,1.8])

fromnumpyimportpi
np.linspace(0,2,9)#初始值0，结束值：2（包含），元素个数：9
输出：
array([0.,0.25,0.5,0.75,1.,1.25,1.5,1.75,2.])
x=np.linspace(0,2*pi,9)
输出：
array([0.,0.78539816,1.57079633,2.35619449,3.14159265,
3.92699082,4.71238898,5.49778714,6.28318531])


a=np.arange(6)
输出：
array([0,1,2,3,4,5])
b=np.arange(12).reshape(4,3)
输出：
array([[0,1,2],
[3,4,5],
[6,7,8],
[9,10,11]])
c=np.arange(24).reshape(2,3,4)
输出：
array([[[0,1,2,3],
[4,5,6,7],
[8,9,10,11]],

[[12,13,14,15],
[16,17,18,19],
[20,21,22,23]]])

使用numpy.set_printoptions可以设置numpy变量的打印格式

在ipython环境下，使用help(numpy.set_printoptions)查询使用帮助和示例

4、多维数组的基本操作

加法和减法操作要求操作双方的维数信息一致，均为M*N为数组方可正确执行操作。

a=np.arange(4)
输出：
array([0,1,2,3])
b=a**2
输出：
array([0,1,4,9])
c=10*np.sin(a)
输出：
array([0.,8.41470985,9.09297427,1.41120008])


n<35
输出：
array([True,True,True,True],dtype=bool)

A=np.array([[1,1],[0,1]])
B=np.array([[2,0],[3,4]])
C=A*B#元素点乘
输出：
array([[2,0],
[0,4]])
D=A.dot(B)#矩阵乘法
输出：
array([[5,4],
[3,4]])
E=np.dot(A,B)#矩阵乘法
输出：
array([[5,4],
[3,4]])

多维数组操作过程中的类型转换

When operating with arrays of different types, the type of the
resulting array corresponds to the more general or precise one (a
behavior known as upcasting)

即操作不同类型的多维数组时，结果自动转换为精度更高类型的数组，即upcasting

数组索引、切片和迭代

a=np.ones((2,3),dtype=int)#int32
b=np.random.random((2,3))#float64
b+=a#正确
a+=b#错误

a=np.ones(3,dtype=np.int32)
b=np.linspace(0,pi,3)
c=a+b
d=np.exp(c*1j)
输出：
array([0.54030231+0.84147098j,-0.84147098+0.54030231j,
-0.54030231-0.84147098j])
d.dtype.name
输出：
'complex128'

多维数组的一元操作，如求和、求最小值、最大值等

a=np.random.random((2,3))
a.sum()
a.min()
a.max()


b=np.arange(12).reshape(3,4)
输出：
array([[0,1,2,3],
[4,5,6,7],
[8,9,10,11]])
b.sum(axis=0)#按列求和
输出：
array([12,15,18,21])
b.sum(axis=1)#按行求和
输出：
array([6,22,38])
b.cumsum(axis=0)#按列进行元素累加
输出：
array([[0,1,2,3],
[4,6,8,10],
[12,15,18,21]])
b.cumsum(axis=1)#按行进行元素累加
输出：
array([[0,1,3,6],
[4,9,15,22],
[8,17,27,38]])

universal functions

B=np.arange(3)
np.exp(B)
np.sqrt(B)
C=np.array([2.,-1.,4.])
np.add(B,C)

其他的ufunc函数包括：

all,any,apply_along_axis,argmax,argmin,argsort,average,bincount,ceil,clip,conj,corrcoef,cov,cross,cumprod,cumsum,diff,dot,floor,inner,lexsort,max,maximum,mean,median,min,minimum,nonzero,outer,prod,re,round,sort,std,sum,trace,transpose,var,vdot,vectorize,where

5. 数组索引、切片和迭代

a=np.arange(10)**3
a[2]
a[2:5]
a[::-1]#逆序输出
foriina:
print(i**(1/3.))

deff(x,y):
return10*x+y
b=np.fromfunction(f,(5,4),dtype=int)
b[2,3]
b[0:5,1]
b[:,1]
b[1:3,:]
b[-1]

c=np.array([[[0,1,2],[10,11,12]],[[100,101,102],[110,111,112]]])
输出：
array([[[0,1,2],
[10,11,12]],

[[100,101,102],
[110,111,112]]])
c.shape
输出：
(2L,2L,3L)
c[0,...]
c[0,:,:]
输出：
array([[0,1,2],
[10,11,12]])
c[:,:,2]
c[...,2]
输出：
array([[2,12],
[102,112]])

forrowinc:
print(row)

forelementinc.flat:
print(element)

a=np.floor(10*np.random.random((3,4)))
输出：
array([[3.,9.,8.,4.],
[2.,1.,4.,6.],
[0.,6.,0.,2.]])
a.ravel()
输出：
array([3.,9.,8.,...,6.,0.,2.])
a.reshape(6,2)
输出：
array([[3.,9.],
[8.,4.],
[2.,1.],
[4.,6.],
[0.,6.],
[0.,2.]])
a.T
输出：
array([[3.,2.,0.],
[9.,1.,6.],
[8.,4.,0.],
[4.,6.,2.]])
a.T.shape
输出：
(4L,3L)
a.resize((2,6))
输出：
array([[3.,9.,8.,4.,2.,1.],
[4.,6.,0.,6.,0.,2.]])
a.shape
输出：
(2L,6L)
a.reshape(3,-1)
输出：
array([[3.,9.,8.,4.],
[2.,1.,4.,6.],
[0.,6.,0.,2.]])

详查以下函数：

ndarray.shape,reshape,resize,ravel

6. 组合不同的多维数组

a=np.floor(10*np.random.random((2,2)))
输出：
array([[5.,2.],
[6.,2.]])
b=np.floor(10*np.random.random((2,2)))
输出：
array([[0.,2.],
[4.,1.]])
np.vstack((a,b))
输出：
array([[5.,2.],
[6.,2.],
[0.,2.],
[4.,1.]])
np.hstack((a,b))
输出：
array([[5.,2.,0.,2.],
[6.,2.,4.,1.]])


fromnumpyimportnewaxis
np.column_stack((a,b))
输出：
array([[5.,2.,0.,2.],
[6.,2.,4.,1.]])


a=np.array([4.,2.])
b=np.array([2.,8.])
a[:,newaxis]
输出：
array([[4.],
[2.]])
b[:,newaxis]
输出：
array([[2.],
[8.]])
np.column_stack((a[:,newaxis],b[:,newaxis]))
输出：
array([[4.,2.],
[2.,8.]])
np.vstack((a[:,newaxis],b[:,newaxis]))
输出：
array([[4.],
[2.],
[2.],
[8.]])
np.r_[1:4,0,4]
输出：
array([1,2,3,0,4])
np.c_[np.array([[1,2,3]]),0,0,0,np.array([[4,5,6]])]
输出：
array([[1,2,3,0,0,0,4,5,6]])

详细使用请查询以下函数：

hstack,vstack,column_stack,concatenate,c_,r_

7. 将较大的多维数组分割成较小的多维数组

a=np.floor(10*np.random.random((2,12)))
输出：
array([[9.,7.,9.,...,3.,2.,4.],
[5.,3.,3.,...,9.,7.,7.]])
np.hsplit(a,3)
输出：
[array([[9.,7.,9.,6.],
[5.,3.,3.,1.]]),array([[7.,2.,1.,6.],
[7.,5.,0.,2.]]),array([[9.,3.,2.,4.],
[3.,9.,7.,7.]])]
np.hsplit(a,(3,4))
输出：
[array([[9.,7.,9.],
[5.,3.,3.]]),array([[6.],
[1.]]),array([[7.,2.,1.,...,3.,2.,4.],
[7.,5.,0.,...,9.,7.,7.]])]

实现类似功能的函数包括：

hsplit,vsplit,array_split

8. 多维数组的复制操作

a=np.arange(12)
输出：
array([0,1,2,...,9,10,11])


notatall

b=a
bisa#True
b.shape=3,4
a.shape#(3L,4L)

deff(x)#,sofunctioncallsmakeno.
print(id(x))#id是python对象的唯一标识符

id(a)#111833936L
id(b)#111833936L
f(a)#111833936L


浅复制

c=a.view()
cisa#False
c.baseisa#True
c.flags.owndata#False
c.shape=2,6
a.shape#(3L,4L)
c[0,4]=1234
print(a)
输出：
array([[0,1,2,3],
[1234,5,6,7],
[8,9,10,11]])
s=a[:,1:3]
s[:]=10
print(a)
输出：
array([[0,10,10,3],
[1234,10,10,7],
[8,10,10,11]])


深复制
d=a.()
disa#False
d.baseisa#False
d[0,0]=9999
print(a)
输出：
array([[0,10,10,3],
[1234,10,10,7],
[8,10,10,11]])

numpy基本函数和方法一览

Array Creation

arange,array,,empty,empty_like,eye,fromfile,fromfunction,identity,linspace,logspace,mgrid,ogrid,ones,ones_like,r,zeros,zeros_like

Conversions

ndarray.astype,atleast_1d,atleast_2d,atleast_3d,mat

Manipulations

array_split,column_stack,concatenate,diagonal,dsplit,dstack,hsplit,hstack,ndarray.item,newaxis,ravel,repeat,reshape,resize,squeeze,swapaxes,take,transpose,vsplit,vstack

Questionsall,any,nonzero,where

Ordering

argmax,argmin,argsort,max,min,ptp,searchsorted,sort

Operations

choose,compress,cumprod,cumsum,inner,ndarray.fill,imag,prod,put,putmask,real,sum

Basic Statistics

cov,mean,std,var

Basic Linear Algebra

cross,dot,outer,linalg.svd,vdot

完整的函数和方法一览表链接：

https://docs.scipy.org/doc/numpy-dev/reference/routines.html#routines

E. python中怎么表示多维数组

只有通过遍历得到。这个应该没有直接获取的方式方法。遍历这个数组，当然维数不确定的话你就需要使用递归，然后一一判断它的值是否为你指定的值，然后输出索引。另外，建议不要匿名提问，因为这会让很多高手不屑于回答你的问题。

F. python数组求和

在数组和矩阵中使用sum: 对数组b和矩阵c,代码b.sum()，np.sum(b),c.sum(),np.sum(c)都能将b、c中的所有元素求和并返回单个数值。

但是对于二维数组b，代码b.sum(axis=0)指定对数组b对每列求和，b.sum(axis=1)是对每行求和，返回的都是一维数组（维度降了一维）。

而对应矩阵c，c.sum(axis=0)和c.sum(axis=1)也能实现对列和行的求和，但是返回结果仍是二维矩阵。

# 定义函数，arr 为数组，n 为数组长度，可作为备用参数，这里没有用到。

def_sum(arr,n):

# 使用内置的 sum 函数计算。

return(sum(arr))

# 调用函数

arr=[]

# 数组元素

arr=[12,3,4,15]

# 计算数组元素的长度

n=len(arr)

ans=_sum(arr,n)

# 输出结果

print('数组元素之和为',ans)

(6)python数组维数怎么求扩展阅读：

python数组使用：

python 数组支持所有list操作，包括 .pop、.insert 和 .extend。另外，数组还提供从文件，读取和存入文件的更快的方法，列如如 .frombytes 和 .tofile，如下所示我们定义一个数组。

from array import arrayarr=array('d',(a for a in range(5)))print(arr)。

arr=array('d',(a for a in range(5)))从这个代码中可以看出，一个数组的定义需要传入的不只是值还有类型。

可以是(must be c, b, B, u, h, H, i, I, l, L, f or d)。

G. pyhton中的数组维数问题

python向数组中添加元素步骤如下：
#一个二维数组，元素按照题主的要求有正有负。
list1 = [[1,1],[-2,2],[3,-3],[-4,-4]]
#一个空数组，用于接受需求转换以后的数据。
list2 = []
#for循环，遍历数组中的元素。
for i ,j in list1 :
#按题主要求，负数变成0，非负数保留自身。楼上说条件索引的方法，大概也是在这一步的操作。
但因为是二维数组，所以想来太抽象，不适合大我这样思维能力一般的人。所以我用了绝对值求 平均数的笨方法。
[i,j] = [(i+abs(i))/2,(j+abs(j))/2 ]
#把转换后的数组元素追加到新数组。
list2.append([i,j])
#查看结果，[[1, 1], [0, 2], [3, 0], [0, 0]]，
print list2

H. Python如何对二维数组求和

Python对二维数组求和的方法：首先定义好一个二维数组；然后使用map函数对数组里每一个元素进行sum操作即可对二维数组求和。

关于二维数组求和的几种方法：

a = [[1,2],[3,4],[5,6]]

方法一 sum(map(sum,a))

map(func,a) 函数是对a中的每一个元素进行sum操作

解释一下map函数， map(fund, a) equals [func(i) for i in a] and return a list

方法二 sum(sum(i) for i in a)

方法三 sum(sum(a[i]) for i in range(len(a)))

方法四 rece(lambda x,y:x+y , rece(lambda x,y:x+y, a))

解释一下rece(fun,a),rece返回的是一个结果值而不是一个list，第一步的时候是（［1，2］＋［3，4］） ＋ ［5，6］

得到一个［1，2，3，4，5，6］， 然后进行的运算是（（（（（1+2）＋3）＋4）＋5）＋6） ＝ 21

一般来说最常用的还是1和3这两种方法，不知道map or rece, 一般都会采用3， 而知道的应该会采用1，比较简洁。

推荐课程：Python核心基础(尚硅谷)