矩陣求和python

① python兩個矩陣的i，j部分相同，i，j相同的部分的ij相加，然後得到相加之後的i，j，ij，程序怎麼優化

lim(x->∝) x^2ln(1+1/x) -x
=lim(x->∝) [xln(1+1/x)-1]/[(1/x)]
=lim(x->∝)[xln(1+1/x)-1]'/(1/x)'
=lim(x->∝)[ln(1+1/x)+x*(-1/x^2)/(1+1/x)]/(-1/x^2)
=lim(x->∝)-x^2ln(1+1/x)+x^2/(1+x)
=lim(x->∝)-x^2ln(1+1/x)+x -x/(1+x)
2lim(x->∝)x^2ln(1+1/x)-x =lim(x->∝)-x/(1+x)=lim(x->∝)-1/(1/x+1)=-1
lim(x->∝)x^2ln(1+1/x)-x=-1/2

② python中怎樣對多維數組的某一維求和，放在新的數組中

在Python中，一個像這樣的多維表格可以通過「序列的序列」實現。一個表格是行的序列。每一行又是獨立單元格的序列。這類似於我們使用的數學記號，在數學里我們用Ai,j，而在Python里我們使用A[i][j]，代表矩陣的第i行第j列。 這看起來非常像「元組的...

③ python把矩陣中的每個元素平方

numpy有broadcasting，直接平方numpy的數組就能一步到位。

④ python 怎麼算矩陣每列的和

output=[]
nrow=len(mat)
ncol=len(mat[0])
foriinrange(ncol):
output.append(sum([mat[x][i]forxinrange(nrow)]))
printoutput

⑤ 如何用 Python 科學計算中的矩陣替代循環

因為在Mathematica中使用循環確實是低效的。。。。。。
深層次的原因涉及到Mathematica的底層實現所以我不太懂，但是至少從下面幾個例子可以看出Mathematica里確實有很多比循環更好的方法

求和
首先舉一個最簡單的求和例子，求的值。為了測試運行時間取n=10^6
一個剛接觸Mathematica的同學多半會這樣寫

sum = 0;
For[i = 1, i <= 10^6, i++,
sum += Sin[N@i]];
(*其中N@i的作用是把整數i轉化為浮點數，類似於C里的double*)
sum

為了便於計時用Mole封裝一下，運行時間是2.13秒，如下圖

然後一個有一定Mathematica經驗的同學多半會知道同樣作為循環的Do速度比For快，於是他可能會這么寫
然後一個有一定Mathematica經驗的同學多半會知道同樣作為循環的Do速度比For快，於是他可能會這么寫

sum = 0;
Do[sum += Sin[N@i], {i, 1, 10^6}];
sum

如下圖，用時1.37秒，比For快了不少

當然了知道Do速度比For快的同學不太可能不知道Sum函數，所以上面其實是我口胡的，他應該會這么寫

Sum[Sin[N@i], {i, 1, 10^6}]

如下圖，同樣的結果，只用了不到0.06秒

如果這位同學還知道Listable屬性並且電腦內存不算太小的話，他也可能會這么寫

Tr@Sin[N@Range[10^6]]

如下圖，只用了不到0.02秒，速度超過For循環的100倍

當然了這只是一個最簡單的例子，而且如果數據量更大的話最後一種方法就不能用了。但是這也足以說明在求和時用循環是低效的，無論是內置的Sum函數還是向量化運算，在效率上都遠遠高於循環
（這部分模仿了不同程序員如何編寫階乘函數這篇文章，強烈推薦對Mathematica有興趣的同學去看看）

迭代
接下來舉一個迭代的例子，（即Logistic map），取，為了測試運行時間同樣取n=10^6
還是先用For循環的做法

x = 0.5;
For[i = 1, i <= 10^6, i++,
x = 3.5 x (1 - x);
];
x

如下圖，運行時間2.06秒

（Do循環和For類似，篇幅所限這里就不寫了，有興趣的同學可以自行嘗試）
（Do循環和For類似，篇幅所限這里就不寫了，有興趣的同學可以自行嘗試）
然後看看內置的Nest函數

Nest[3.5 # (1 - #) &, 0.5, 10^6]

如下圖，用時0.02秒，又是將近兩個數量級的效率差異

當然了Nest的使用涉及到純函數，對於Mathematica初學者來說可能有些難以理解，而且一些比較復雜的迭代不太容易寫成Nest的形式，但是在迭代時Nest（還包括Fold）的效率確實要好於循環
當然了Nest的使用涉及到純函數，對於Mathematica初學者來說可能有些難以理解，而且一些比較復雜的迭代不太容易寫成Nest的形式，但是在迭代時Nest（還包括Fold）的效率確實要好於循環
遍歷列表
依然舉一個簡單的例子：求一個列表中偶數的個數。為測試生成10^6個1到10之間的隨機整數

list = RandomInteger[{1, 10}, 10^6];
(*生成10^6個隨機整數*)

如果用For循環的話代碼是這樣的

num = 0；
For[i = 1, i <= 10^6, i++,
If[EvenQ@list[[i]], num++]
];
num

如下圖，用時1.73秒

保留上面的思路，單純的將For循環改為Scan （相當於沒有返回結果的Map），代碼如下

num = 0；
Scan[If[EvenQ@#, num++] &, list];
num

如下圖，用時0.91 秒

（Do循環用時1.00秒左右，篇幅所限就不傳圖了）

摒棄循環的思路，用其他內置函數寫

Count[list, _?EvenQ] // AbsoluteTiming
(*直接用Count數出list中偶數的個數*)
Count[EvenQ /@ list, True] // AbsoluteTiming
(*用Map對list中的每個數判斷是否偶數，然後用Count數出結果中True的個數*)
Select[list, EvenQ] // Length // AbsoluteTiming
(*選取list中的所有偶數，然後求結果列表長度*)
Count[EvenQ@list, True] // AbsoluteTiming
(*利用EvenQ的Listable屬性直接判斷list的每個數是否偶數，然後數出結果中True的個數*)
Sum[Boole[EvenQ@i], {i, list}]
(*對list中的每個元素判斷是否偶數，將結果相加*)

結果如下圖

這個遍歷的例子舉得不算特別恰當，但也能說明一些問題了：Mathematica中內置了許多神奇的函數，其中大部分只要使用得當效率都比循環高（而且不是一點半點）。就算非要用循環，也要記得（任何能用Do代替For的時候）
這個遍歷的例子舉得不算特別恰當，但也能說明一些問題了：Mathematica中內置了許多神奇的函數，其中大部分只要使用得當效率都比循環高（而且不是一點半點）。就算非要用循環，也要記得（任何能用Do代替For的時候）
Do比For快
，（遍歷列表時）
Scan比Do快
用向量(矩陣)運算代替循環
這個例子來自如何用 Python 科學計算中的矩陣替代循環？ - Kaiser 的回答，我只是把代碼從Python翻譯成了Mathematica而已。選這個例子是因為它有比較明確的物理意義，而且效率對比非常明顯
代碼如下

AbsoluteTiming[
n = 100;
u = unew = SparseArray[{{1, _} -> 1}, {n, n}] // N // Normal;
For[k = 1, k <= 3000, k++,
For[i = 2, i < n, i++,
For[j = 2, j < n, j++,
unew[[i, j]] =
0.25 (u[[i + 1, j]] + u[[i - 1, j]] + u[[i, j + 1]] +
u[[i, j - 1]])
]
];
u = unew;
];
u1 = u;
]
(*用三重循環，迭代3000次*)
ArrayPlot[u1, DataReversed -> True, ColorFunction -> "TemperatureMap"]
(*用ArrayPlot繪圖*)

AbsoluteTiming[
n = 100;
u = SparseArray[{{1, _} -> 1}, {n, n}] // N // Normal;
Do[
u[[2 ;; -2, 2 ;; -2]] =
0.25 (u[[3 ;; -1, 2 ;; -2]] + u[[1 ;; -3, 2 ;; -2]] +
u[[2 ;; -2, 3 ;; -1]] + u[[2 ;; -2, 1 ;; -3]]),
{k, 1, 3000}];
u2 = u;
]
(*用矩陣運算，迭代3000次*)
ArrayPlot[u2, DataReversed -> True, ColorFunction -> "TemperatureMap"]
(*用ArrayPlot繪圖*)

運行結果For循環用時136秒，矩陣運算用時不足0.5秒，且兩者答案完全一樣。在演算法完全相同的情況下兩種寫法有著超過200倍的效率差距
（圖片太長了這里就不直接顯示了，鏈接放在下面）
http://pic4.mg.com/_b.png

===========================我是結尾的分隔線===============================
這個答案其實從一開始就跑題了，還寫了這么長的目的就在於希望讓大家切實地感受到循環的低效並安利一下Mathematica中其它高效的方法。正如wolray的答案中說的，既然選擇了使用Mathematica就應該多利用些MMA獨有的美妙函數，畢竟如果只是用循環的話C和Fortran之類的語言效率比MMA不知高到哪裡去了。。。。。。
當
然我也不是讓大家就不用循環了，畢竟很多時候循環的直觀性和易讀性帶來的便利遠遠比那點效率重要。只是希望大家在循環之前能稍稍想一下，自己的目的是不是
一定要用循環？可不可以用內置函數代替循環？就像上面的幾個例子，將循環換成內置函數程序的簡潔性和效率都大幅提高，長此以往相信你一定會愛上MMA的~

題外話——關於用編譯提速循環
在
MMA中如果一定要使用循環又對效率有一定要求的話，可以選擇使用編譯，效率能有極大的提高。比如上面的第4個例子使用Complie編譯過後的Do循環
用時只有1.86秒，速度提升了將近100倍。如果電腦中有C編譯器的話還可以在Compile中加入CompilationTarget ->
"C"選項，速度還能有所提升。編譯過後的代碼如下：

In[10]:= cf = Compile[{{n, _Integer}, {times, _Integer}},
Mole[{u},
u = ConstantArray[0., {n, n}];
u[[1]] = ConstantArray[1., n];
Do[
Do[u[[i, j]] =
0.25 (u[[i + 1, j]] + u[[i - 1, j]] + u[[i, j + 1]] +
u[[i, j - 1]]),
{i, 2, n - 1}, {j, 2, n - 1}
], {k, 1, times}];
u
]
];
u3 = cf[100, 3000]; // AbsoluteTiming
ArrayPlot[u3, DataReversed -> True, ColorFunction -> "TemperatureMap"]

Out[11]= {1.86055, Null}

前3個例子也都可以通過編譯提速很多，這里就不放代碼了，有興趣的同學可以自己動手試一試，如果遇到問題歡迎在評論中與我交流。
需要注意的是編譯有很多注意事項，這里推薦一篇寫的很好的教程，編譯中常見的問題裡面都有很好的講解：怎樣編譯（Compile）/編譯的通用規則/學會這6條，你也會編譯
但是一般來講編譯很麻煩，而且再怎麼編譯效率也很難趕上直接用C，所以個人並不特別建議MMA初學者學習編譯。

⑥ python怎麼實現矩陣的除法

1、首先打開pycharm軟體，新建一個python文件並導入numpy庫。

⑦ python對矩陣求行列式的值

相當不錯的IDE，語法高亮、代碼折疊、智能感知、自動語法檢查等功能一應俱全，集成wxGlade。可惜沒有自動補全功能。
開源，可以用svn下載到最新的源代碼，依賴wxPython。但久未更新(最後一次更新是在2008年2月)，逆水行舟，不進則退，功能上比其它IDE已經沒有什麼優勢了。

⑧ python 怎麼實現矩陣運算

1.numpy的導入和使用

data1=mat(zeros((
)))
#創建一個3*3的零矩陣，矩陣這里zeros函數的參數是一個tuple類型(3,3)
data2=mat(ones((
)))
#創建一個2*4的1矩陣，默認是浮點型的數據，如果需要時int類型，可以使用dtype=int
data3=mat(random.rand(
))
#這里的random模塊使用的是numpy中的random模塊，random.rand(2,2)創建的是一個二維數組，需要將其轉換成#matrix
data4=mat(random.randint(
10
,size=(
)))
#生成一個3*3的0-10之間的隨機整數矩陣，如果需要指定下界則可以多加一個參數
data5=mat(random.randint(
,size=(
))
#產生一個2-8之間的隨機整數矩陣
data6=mat(eye(
,dtype=
int
))
#產生一個2*2的對角矩陣
a1=[
]; a2=mat(diag(a1))
#生成一個對角線為1、2、3的對角矩陣

⑨ 問一下，python里用for循環去寫兩個矩陣的加法和乘法怎麼寫（不用np的那種方法）

您好，您提問的問題有些模糊，如果問的是一維數組所有元素的成績是這樣的：

a=[1,2,3,4,5,6]#Python中數組存放在list中
result=1#result存放結果
foriina:
result=i*result#a中每個元素都乘進result中
printresult

如果不是這個問題，請你將問題描述完善一些。

⑩ 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核心基礎(尚矽谷)