python3中转置函数 python求转置
python中transpose是什么意思
我先来一个举例:
站在用户的角度思考问题,与客户深入沟通,找到蟠龙网站设计与蟠龙网站推广的解决方案,凭借多年的经验,让设计与互联网技术结合,创造个性化、用户体验好的作品,建站类型包括:成都网站制作、成都做网站、企业官网、英文网站、手机端网站、网站推广、域名与空间、网络空间、企业邮箱。业务覆盖蟠龙地区。
arr = np.arange(16).reshape((2, 2, 4))
arr的array是这样的
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
我们对arr进行transpose转置,arr2 = arr.transpose((1,0,2)),结果是这样:
array([[[ 0, 1, 2, 3],
[ 8, 9, 10, 11]],
[[ 4, 5, 6, 7],
[12, 13, 14, 15]]])
这是怎么来的呢。
arr.transpose((1,0,2))的1,0,2三个数分别代表shape()的三个数的顺序,初始的shape是(2,2,4),也就是2维的2 x 4矩阵,索引分别是shape的[0],[1],[2],arr.transpose((1,0,2))之后,我们的索引就变成了shape[1][0][2],对应shape值是shape(2,2,4),所以矩阵形状不变。
与此同时,我们矩阵的索引也发生了类似变化,如arr中的4,索引是arr[0,1,0],arr中的5是arr[0,1,1],变成arr2后,4的位置应该是在[1,0,0],5的位置变成[1,0,1],同理8的索引从[1,0,0]变成[0,1,0]。
python里x=randn mat=x.T.dot 是求什么
x=randn这个写法是不对的。
randn是numpy里的一个生成随机array的函数。
比如说要生成一个三行两列的随机array,可以这样写:
import numpy
x = numpy.random.randn(3,2)
像这样:
后面这个mat=x.T.dot(...)是先求这个3*3矩阵的转置(.T),再求与点积(.dot)
点积就是矩阵各个对应元素相乘, 这个时候要求两个矩阵必须同样大小。
其实可以分步来的,就知道做了什么运算了。
像这样:
dot(2)是点乘常数就不说了,
那个x.T.dot([1,2,3])就是x.T的
1*1+2*2+3*3=14
2*1+3*2+4*3=20
懂了木有 =。=
python3的sympy
print(“字符串”),5/2和5//2的结果是不同的5/2为2.5,5//2为2.
python2需要导入from_future_import division执行普通的除法。
1/2和1//2的结果0.5和0.
%号为取模运算。
乘方运算为2**3,-2**3和-(2**3)是等价的。
from sympy import*导入库
x,y,z=symbols('x y z'),定义变量
init_printing(use_unicode=True)设置打印方式。
python的内部常量有pi,
函数simplify,simplify(sin(x)**2 + cos(x)**2)化简结果为1,
simplify((x**3 + x**2 - x - 1)/(x**2 + 2*x + 1))化简结果为x-1。化简伽马函数。simplify(gamma(x)/gamma(x - 2))得(x-2)(x-1)。
expand((x + 1)**2)展开多项式。
expand((x + 1)*(x - 2) - (x - 1)*x)
因式分解。factor(x**2*z + 4*x*y*z + 4*y**2*z)得到z*(x + 2*y)**2
from_future_import division
x,y,z,t=symbols('x y z t')定义变量,
k, m, n = symbols('k m n', integer=True)定义三个整数变量。
f, g, h = symbols('f g h', cls=Function)定义的类型为函数。
factor_list(x**2*z + 4*x*y*z + 4*y**2*z)得到一个列表,表示因式的幂,(1, [(z, 1), (x + 2*y, 2)])
expand((cos(x) + sin(x))**2)展开多项式。
expr = x*y + x - 3 + 2*x**2 - z*x**2 + x**3,collected_expr = collect(expr, x)将x合并。将x元素按阶次整合。
collected_expr.coeff(x, 2)直接取出变量collected_expr的x的二次幂的系数。
cancel()is more efficient thanfactor().
cancel((x**2 + 2*x + 1)/(x**2 + x))
,expr = (x*y**2 - 2*x*y*z + x*z**2 + y**2 - 2*y*z + z**2)/(x**2 - 1),cancel(expr)
expr = (4*x**3 + 21*x**2 + 10*x + 12)/(x**4 + 5*x**3 + 5*x**2 + 4*x),apart(expr)
asin(1)
trigsimp(sin(x)**2 + cos(x)**2)三角函数表达式化简,
trigsimp(sin(x)**4 - 2*cos(x)**2*sin(x)**2 + cos(x)**4)
trigsimp(sin(x)*tan(x)/sec(x))
trigsimp(cosh(x)**2 + sinh(x)**2)双曲函数。
三角函数展开,expand_trig(sin(x + y)),acos(x),cos(acos(x)),expand_trig(tan(2*x))
x, y = symbols('x y', positive=True)正数,a, b = symbols('a b', real=True)实数,z, t, c = symbols('z t c')定义变量的方法。
sqrt(x) == x**Rational(1, 2)判断是否相等。
powsimp(x**a*x**b)幂函数的乘法,不同幂的乘法,必须先定义a和b。powsimp(x**a*y**a)相同幂的乘法。
powsimp(t**c*z**c),注意,powsimp()refuses to do the simplification if it is not valid.
powsimp(t**c*z**c, force=True)这样的话就可以得到化简过的式子。声明强制进行化简。
(z*t)**2,sqrt(x*y)
第一个展开expand_power_exp(x**(a + b)),expand_power_base((x*y)**a)展开,
expand_power_base((z*t)**c, force=True)强制展开。
powdenest((x**a)**b),powdenest((z**a)**b),powdenest((z**a)**b, force=True)
ln(x),x, y ,z= symbols('x y z', positive=True),n = symbols('n', real=True),
expand_log(log(x*y))展开为log(x) + log(y),但是python3没有。这是因为需要将x定义为positive。这是必须的,否则不会被展开。expand_log(log(x/y)),expand_log(log(x**n))
As withpowsimp()andpowdenest(),expand_log()has aforceoption that can be used to ignore assumptions。
expand_log(log(z**2), force=True),强制展开。
logcombine(log(x) + log(y)),logcombine(n*log(x)),logcombine(n*log(z), force=True)。
factorial(n)阶乘,binomial(n, k)等于c(n,k),gamma(z)伽马函数。
hyper([1, 2], [3], z),
tan(x).rewrite(sin)得到用正弦表示的正切。factorial(x).rewrite(gamma)用伽马函数重写阶乘。
expand_func(gamma(x + 3))得到,x*(x + 1)*(x + 2)*gamma(x),
hyperexpand(hyper([1, 1], [2], z)),
combsimp(factorial(n)/factorial(n - 3))化简,combsimp(binomial(n+1, k+1)/binomial(n, k))化简。combsimp(gamma(x)*gamma(1 - x))
自定义函数
def list_to_frac(l):
expr = Integer(0)
for i in reversed(l[1:]):
expr += i
expr = 1/expr
return l[0] + expr
list_to_frac([x, y, z])结果为x + 1/z,这个结果是错误的。
syms = symbols('a0:5'),定义syms,得到的结果为(a0, a1, a2, a3, a4)。
这样也可以a0, a1, a2, a3, a4 = syms, 可能是我的操作错误 。发现python和自动缩进有关,所以一定看好自动缩进的距离。list_to_frac([1, 2, 3, 4])结果为43/30。
使用cancel可以将生成的分式化简,frac = cancel(frac)化简为一个分数线的分式。
(a0*a1*a2*a3*a4 + a0*a1*a2 + a0*a1*a4 + a0*a3*a4 + a0 + a2*a3*a4 + a2 + a4)/(a1*a2*a3*a4 + a1*a2 + a1*a4 + a3*a4 + 1)
a0, a1, a2, a3, a4 = syms定义a0到a4,frac = apart(frac, a0)可将a0提出来。frac=1/(frac-a0)将a0去掉取倒。frac = apart(frac, a1)提出a1。
help("modules"),模块的含义,help("modules yourstr")模块中包含的字符串的意思。,
help("topics"),import os.path + help("os.path"),help("list"),help("open")
# -*- coding: UTF-8 -*-声明之后就可以在ide中使用中文注释。
定义
l = list(symbols('a0:5'))定义列表得到[a0, a1, a2, a3, a4]
fromsympyimport*
x,y,z=symbols('x y z')
init_printing(use_unicode=True)
diff(cos(x),x)求导。diff(exp(x**2), x),diff(x**4, x, x, x)和diff(x**4, x, 3)等价。
diff(expr, x, y, 2, z, 4)求出表达式的y的2阶,z的4阶,x的1阶导数。和diff(expr, x, y, y, z, 4)等价。expr.diff(x, y, y, z, 4)一步到位。deriv = Derivative(expr, x, y, y, z, 4)求偏导。但是不显示。之后用deriv.doit()即可显示
integrate(cos(x), x)积分。定积分integrate(exp(-x), (x, 0, oo))无穷大用2个oo表示。integrate(exp(-x**2-y**2),(x,-oo,oo),(y,-oo,oo))二重积分。print(expr)print的使用。
expr = Integral(log(x)**2, x),expr.doit()积分得到x*log(x)**2 - 2*x*log(x) + 2*x。
integ.doit()和integ = Integral((x**4 + x**2*exp(x) - x**2 - 2*x*exp(x) - 2*x -
exp(x))*exp(x)/((x - 1)**2*(x + 1)**2*(exp(x) + 1)), x)连用。
limit(sin(x)/x,x,0),not-a-number表示nan算不出来,limit(expr, x, oo),,expr = Limit((cos(x) - 1)/x, x, 0),expr.doit()连用。左右极限limit(1/x, x, 0, '+'),limit(1/x, x, 0, '-')。。
Series Expansion级数展开。expr = exp(sin(x)),expr.series(x, 0, 4)得到1 + x + x**2/2 + O(x**4),,x*O(1)得到O(x),,expr.series(x, 0, 4).removeO()将无穷小移除。exp(x-6).series(x,x0=6),,得到
-5 + (x - 6)**2/2 + (x - 6)**3/6 + (x - 6)**4/24 + (x - 6)**5/120 + x + O((x - 6)**6, (x, 6))最高到5阶。
f=Function('f')定义函数变量和h=Symbol('h')和d2fdx2=f(x).diff(x,2)求2阶,,as_finite_diff(dfdx)函数和as_finite_diff(d2fdx2,[-3*h,-h,2*h]),,x_list=[-3,1,2]和y_list=symbols('a b c')和apply_finite_diff(1,x_list,y_list,0)。
Eq(x, y),,solveset(Eq(x**2, 1), x)解出来x,当二式相等。和solveset(Eq(x**2 - 1, 0), x)等价。solveset(x**2 - 1, x)
solveset(x**2 - x, x)解,solveset(x - x, x, domain=S.Reals)解出来定义域。solveset(exp(x), x) # No solution exists解出EmptySet()表示空集。
等式形式linsolve([x + y + z - 1, x + y + 2*z - 3 ], (x, y, z))和矩阵法linsolve(Matrix(([1, 1, 1, 1], [1, 1, 2, 3])), (x, y, z))得到{(-y - 1, y, 2)}
A*x = b 形式,M=Matrix(((1,1,1,1),(1,1,2,3))),system=A,b=M[:,:-1],M[:,-1],linsolve(system,x,y,z),,solveset(x**3 - 6*x**2 + 9*x, x)解多项式。roots(x**3 - 6*x**2 + 9*x, x),得出,{3: 2, 0: 1},有2个3的重根,1个0根。solve([x*y - 1, x - 2], x, y)解出坐标。
f, g = symbols('f g', cls=Function)函数的定义,解微分方程diffeq = Eq(f(x).diff(x, x) - 2*f(x).diff(x) + f(x), sin(x))再和dsolve(diffeq,f(x))结合。得到Eq(f(x), (C1 + C2*x)*exp(x) + cos(x)/2),dsolve(f(x).diff(x)*(1 - sin(f(x))), f(x))解出来Eq(f(x) + cos(f(x)), C1),,
Matrix([[1,-1],[3,4],[0,2]]),,Matrix([1, 2, 3])列表示。M=Matrix([[1,2,3],[3,2,1]])
N=Matrix([0,1,1])
M*N符合矩阵的乘法。M.shape显示矩阵的行列数。
M.row(0)获取M的第0行。M.col(-1)获取倒数第一列。
M.col_del(0)删掉第1列。M.row_del(1)删除第二行,序列是从0开始的。M = M.row_insert(1, Matrix([[0, 4]]))插入第二行,,M = M.col_insert(0, Matrix([1, -2]))插入第一列。
M+N矩阵相加,M*N,3*M,M**2,M**-1,N**-1表示求逆。M.T求转置。
eye(3)单位。zeros(2, 3),0矩阵,ones(3, 2)全1,diag(1, 2, 3)对角矩阵。diag(-1, ones(2, 2), Matrix([5, 7, 5]))生成Matrix([
[-1, 0, 0, 0],
[ 0, 1, 1, 0],
[ 0, 1, 1, 0],
[ 0, 0, 0, 5],
[ 0, 0, 0, 7],
[ 0, 0, 0, 5]])矩阵。
Matrix([[1, 0, 1], [2, -1, 3], [4, 3, 2]])
一行一行显示,,M.det()求行列式。M.rref()矩阵化简。得到结果为Matrix([
[1, 0, 1, 3],
[0, 1, 2/3, 1/3],
[0, 0, 0, 0]]), [0, 1])。
M = Matrix([[1, 2, 3, 0, 0], [4, 10, 0, 0, 1]]),M.nullspace()
Columnspace
M.columnspace()和M = Matrix([[1, 2, 3, 0, 0], [4, 10, 0, 0, 1]])
M = Matrix([[3, -2, 4, -2], [5, 3, -3, -2], [5, -2, 2, -2], [5, -2, -3, 3]])和M.eigenvals()得到{3: 1, -2: 1, 5: 2},,This means thatMhas eigenvalues -2, 3, and 5, and that the eigenvalues -2 and 3 have algebraic multiplicity 1 and that the eigenvalue 5 has algebraic multiplicity 2.
P, D = M.diagonalize(),P得Matrix([
[0, 1, 1, 0],
[1, 1, 1, -1],
[1, 1, 1, 0],
[1, 1, 0, 1]]),,D为Matrix([
[-2, 0, 0, 0],
[ 0, 3, 0, 0],
[ 0, 0, 5, 0],
[ 0, 0, 0, 5]])
P*D*P**-1 == M返回为True。lamda = symbols('lamda')。
lamda = symbols('lamda')定义变量,p = M.charpoly(lamda)和factor(p)
expr = x**2 + x*y,srepr(expr)可以将表达式说明计算法则,"Add(Pow(Symbol('x'), Integer(2)), Mul(Symbol('x'), Symbol('y')))"。。
x = symbols('x')和x = Symbol('x')是一样的。srepr(x**2)得到"Pow(Symbol('x'), Integer(2))"。Pow(x, 2)和Mul(x, y)得到x**2。x*y
type(2)得到class 'int',type(sympify(2))得到class 'sympy.core.numbers.Integer'..srepr(x*y)得到"Mul(Symbol('x'), Symbol('y'))"。。。
Add(Pow(x, 2), Mul(x, y))得到"Add(Mul(Integer(-1), Pow(Symbol('x'), Integer(2))), Mul(Rational(1, 2), sin(Mul(Symbol('x'), Symbol('y')))), Pow(Symbol('y'), Integer(-1)))"。。Pow函数为幂次。
expr = Add(x, x),expr.func。。Integer(2).func,class 'sympy.core.numbers.Integer',,Integer(0).func和Integer(-1).func,,,expr = 3*y**2*x和expr.func得到class 'sympy.core.mul.Mul',,expr.args将表达式分解为得到(3, x, y**2),,expr.func(*expr.args)合并。expr == expr.func(*expr.args)返回True。expr.args[2]得到y**2,expr.args[1]得到x,expr.args[0]得到3.。
expr.args[2].args得到(y, 2)。。y.args得到空括号。Integer(2).args得到空括号。
from sympy import *
E**(I*pi)+1,可以看出,I和E,pi已将在sympy内已定义。
x=Symbol('x'),,expand( E**(I*x) )不能展开,expand(exp(I*x),complex=True)可以展开,得到I*exp(-im(x))*sin(re(x)) + exp(-im(x))*cos(re(x)),,x=Symbol("x",real=True)将x定义为实数。再展开expand(exp(I*x),complex=True)得到。I*sin(x) + cos(x)。。
tmp = series(exp(I*x), x, 0, 10)和pprint(tmp)打印出来可读性好,print(tmp)可读性不好。。pprint将公式用更好看的格式打印出来,,pprint( series( cos(x), x, 0, 10) )
integrate(x*sin(x), x),,定积分integrate(x*sin(x), (x, 0, 2*pi))。。
用双重积分求解球的体积。
x, y, r = symbols('x,y,r')和2 * integrate(sqrt(r*r-x**2), (x, -r, r))计算球的体积。计算不来,是因为sympy不知道r是大于0的。r = symbols('r', positive=True)这样定义r即可。circle_area=2*integrate(sqrt(r**2-x**2),(x,-r,r))得到。circle_area=circle_area.subs(r,sqrt(r**2-x**2))将r替换。
integrate(circle_area,(x,-r,r))再积分即可。
expression.sub([(x,y),(y,x)])又换到原来的状况了。
expression.subs(x, y),,将算式中的x替换成y。。
expression.subs({x:y,u:v}) : 使用字典进行多次替换。。
expression.subs([(x,y),(u,v)]) : 使用列表进行多次替换。。
python中怎样让数据列转置
需求:
你需要转置一个二维数组,将行列互换.
讨论:
你需要确保该数组的行列数都是相同的.比如:
arr = [[1, 2, 3], [4, 5, 6], [7,8, 9], [10, 11, 12]]
列表递推式提供了一个简便的矩阵转置的方法:
print [[r[col] for r in arr] for col in range(len(arr[0]))]
[[1, 4, 7, 10], [2, 5, 8, 11],[3, 6, 9, 12]]
另一个更快和高级一些的方法,可以使用zip函数:
print map(list,
zip(*arr))
本节提供了关于矩阵转置的两个方法,一个比较清晰简单,另一个比较快速但有些隐晦.
有时候,数据到来的时候使用错误的方式,比如,你使用微软的ADO接口访问数据库,由于Python和MS在语言实现上的差别.
Getrows方法在Python中可能返回的是列值,和方法的名称不同.本节给的出的方法就是这个问题常见的解决方案,一个更清晰,一个更快速.
在列表递推式版本中,内层递推式表示选则什么(行),外层递推式表示选择者(列).这个过程完成后就实现了转置.
在zip版本中,我们使用*arr语法将一维数组传递给zip做为参数,接着,zip返回一个元组做为结果.然后我们对每一个元组使用list方法,产生了列表的列表(即矩阵).因为我们没有直接将zip的结果表示为list,
所以我们可以我们可以使用itertools.izip来稍微的提高效率(因为izip并没有将数据在内存中组织为列表).
import itertools
print map(list,
itertools.izip(*arr))
但是,在特定的情况下,上面的方法对效率的微弱提升不能弥补对复杂度的增加.
关于*args和**kwds语法:
*args(实际上,*号后面跟着变量名)语法在Python中表示传递任意的位置变量,当你使用这个语法的时候(比如,你在定义函数时使用),Python将这个变量和一个元组绑定,并保留所有的位置信息,
而不是具体的变量.当你使用这个方法传递参数时,变量可以是任意的可迭代对象(其实可以是任何表达式,只要返回值是迭代器).
**kwds语法在Python中用于接收命名参数.当你用这个方式传递参数时,Python将变量和一个dict绑定,保留所有命名参数,而不是具体的变量值.当你传递参数时,变量必须是dict类型(或者是返回值为dict类型的表达式).
如果你要转置很大的数组,使用Numeric Python或其它第三方包,它们定义了很多方法,足够让你头晕的.
相关说明:
zip(...)
zip(seq1 [,
seq2 [...]]) - [(seq1[0], seq2[0] ...),
(...)]
Return a
list of tuples, where each tuple contains the i-th element
from each of
the argument sequences. The returned list is truncated
in length to
the length of the shortest argument sequence.
Python实现矩阵转置的方法分析
Python实现矩阵转置的方法分析
本文实例讲述了Python实现矩阵转置的方法。分享给大家供大家参考,具体如下:
前几天群里有同学提出了一个问题:手头现在有个列表,列表里面两个元素,比如[1, 2],之后不断的添加新的列表,往原来相应位置添加。例如添加[3, 4]使原列表扩充为[[1, 3], [2, 4]],再添加[5, 6]扩充为[[1, 3, 5], [2, 4, 6]]等等。
其实不动脑筋的话,用个二重循环很容易写出来:
def trans(m):
a = [[] for i in m[0]]
for i in m:
for j in range(len(i)):
a[j].append(i[j])
return a
m = [[1, 2], [3, 4], [5, 6]] # 想象第一个列表是原始的,后面的是往里添加的
print trans(m) # result:[[1, 3, 5], [ 2, 4, 6]]
然而不管怎么看这种代码都很丑。
仔细看了一下m这种结构。等等,这不是字典的iteritems()的结果么?如果dict(m),那么结果——不就是keys()和values()么?
于是利用字典转换一下:
def trans(m):
d = dict(m)
return [d.keys(), d.values()]
可是再仔细想想,这里面有bug。如果添加列表的第一个元素相同,也就是转化之后dict的key相同,那肯定就不行了呀!况且,如果原始列表不是两个,而是多个,肯定不能用字典的呀!于是这种方法作罢,还是好好看看列表的形状。
然后又是一个不小心的发现:
这种转置矩阵的即时感是怎么回事?
没错,这个问题的本质就是求解转置矩阵。于是就简单了,还是用个不动脑筋的办法:
def trans(m):
for i in range(len(m)):
for j in range(i):
m[i][j], m[j][i] = m[j][i], m[i][j]
return m
m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print trans(m)
其实还是有点bug的,看起来是好用的,然而这个矩阵要求行列长度相同才行。
最后,群里某大神说:如果只是转置矩阵的话,直接zip就好了。这才想起来zip的本质就是这样的,取出列表中的对应位置的元素,组成新列表,正是这个题目要做的。
所以最终,这个题目(转置矩阵)的python解法就相当奇妙了:
def trans(m):
return zip(*d)
没错,就这么简单。python的魅力。
python transpose
transpose ,可以对矩阵的维度进行转换,下面看一个例子:
在这里做一个简单的假设:这个操作是把每一个维度都当作一个索引,对应于,
[123]--000
[456]--010 ------ 所以我们对变换首先对一个维度进行固定,对另外两个
[789]--101 维度进行操作
[101112]--111
[[[ 1 4]
[ 2 5]
[ 3 6]]
这说明假设错误。
[[ 7 10]
[ 8 11]
[ 9 12]]]
这说明这个炒作本质是对矩阵进行转置。转置的含义就是沿着数据中心,对数据进行对换。
参考变换方式:
网站名称:python3中转置函数 python求转置
标题来源:http://pwwzsj.com/article/hgoggp.html