二維數組求山脊python

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

(1)二維數組求山脊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)。

❷ 快速查找二維數組的所有峰值，c語言實現最好，python也可以，最好能實現濾波。

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
#include<malloc.h>
#definemaxsize6//每個波形數據最大採集個數默認6

typedefstructarray1
{
int*data;
structarray1*next;
}ARR1;
ARR1*addNewArr(ARR1*arrHead,ARR1*arrTail);//插入一組波形數據節點返回尾節點
intfindMaxF(ARR1*arrHead);//查找最大峰值
intremoveMinF(ARR1*arrHead);//移除最小峰值數據組返回最小峰值
voidprintfArr(ARR1*arrHead);//列印數據鏈表

intmain()
{
ARR1*arrHead=(ARR1*)malloc(sizeof(ARR1));
arrHead->next=NULL;
ARR1*arrTail=NULL;

arrTail=addNewArr(arrHead,arrTail);//想插入幾組，就調用幾次我就測試6組
arrTail=addNewArr(arrHead,arrTail);
arrTail=addNewArr(arrHead,arrTail);
arrTail=addNewArr(arrHead,arrTail);
arrTail=addNewArr(arrHead,arrTail);
arrTail=addNewArr(arrHead,arrTail);

printf("採集的原數據組為： ");
printfArr(arrHead);
printf("最大峰值：%d，最小峰值值：%d ",findMaxF(arrHead),removeMinF(arrHead));
printf("刪除最小峰值數據組後的數據為： ");
printfArr(arrHead);
return0;
}


voidprintfArr(ARR1*arrHead)//列印數據鏈表
{
while(arrHead->next!=NULL)
{
printf("%d,%d,%d,%d,%d,%d ",arrHead->next->data[0],arrHead->next->data[1],arrHead->next->data[2],arrHead->next->data[3],arrHead->next->data[4],arrHead->next->data[5]);
arrHead=arrHead->next;
}
}
ARR1*addNewArr(ARR1*arrHead,ARR1*arrTail)//插入一組波形數據返回尾節點
{
int*data=(int*)malloc(sizeof(int)*maxsize),i;
printf("採集一組波形數據（最大採集個數%d）：",maxsize);
for(i=0;i<maxsize;i++)
scanf("%d",&data[i]);

ARR1*arrNew=(ARR1*)malloc(sizeof(ARR1));
arrNew->data=data;
arrNew->next=NULL;

if(arrHead->next==NULL)//插入第一組數組作為首節點
arrHead->next=arrNew;
else
arrTail->next=arrNew;

arrTail=arrNew;
returnarrTail;
}
intfindMaxF(ARR1*arrHead)//查找最大峰值
{
inti,maxNum=0,maxf=0;
while(arrHead->next!=NULL)
{
maxNum=0;
for(i=0;i<maxsize;i++)//獲取每組數據的峰值
{
if(arrHead->next->data[i]>maxNum)
maxNum=arrHead->next->data[i];
}
if(maxNum>maxf)//獲取最大峰值
maxf=maxNum;
arrHead=arrHead->next;
}
returnmaxf;
}
intremoveMinF(ARR1*arrHead)//移除最小峰值數據組返回最小峰值
{
inti,maxNum=0,minf=INT_MAX;
ARR1*minDataSave=NULL,*arrHeadSave=arrHead;
while(arrHead->next!=NULL)
{
maxNum=0;
for(i=0;i<maxsize;i++)//獲取每組數據的峰值
{
if(arrHead->next->data[i]>maxNum)
maxNum=arrHead->next->data[i];
}
if(maxNum<minf)//獲取最小峰值
{
minDataSave=arrHead->next;
minf=maxNum;
}
arrHead=arrHead->next;
}

arrHead=arrHeadSave;
//移除最小峰值數據組
while(arrHead->next!=NULL)
{
if(arrHead->next==minDataSave)//刪除節點重組鏈表
{
arrHead->next=minDataSave->next;
minDataSave->next=NULL;
free(minDataSave->data);//釋放節點內存
free(minDataSave);
break;
}
arrHead=arrHead->next;
}

returnminf;
}

❸ python 如何定義動態二維數組

追加字元串列表主要的二維列表。由於多維名單基本上列出清單，一個兩維的名單將代表一個單一的清單，其中包含其他列表。 .，因為Python列表是動態的，首先你可以使用「追加」功能容易添加和刪除其他列表：

❹ python中如何使用二維數組

在Python中，一個像這樣的多維表格可以通過「序列的序列」實現。一個表格是行的序列。每一行又是獨立單元格的序列。這類似於我們使用的數學記號，在數學里我們用Ai,j，而在Python里我們使用A[i][j]，代表矩陣的第i行第j列。
這看起來非常像「元組的列表」（Lists of Tuples）。
「列表的列表」示例：
我們可以使用嵌套的列表推導式（list comprehension）創建一個表格。 下面的例子創建了一個「序列的序列」構成的表格，並為表格的每一個單元格賦值。
table= [ [ 0 for i in range(6) ] for j in range(6) ]print tablefor d1 in range(6):for d2 in range(6):table[d1][d2]= d1+d2+2print table123456程序的輸出結果如下：
[[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]，
[[2, 3, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9],
[5, 6, 7, 8, 9, 10], [6, 7, 8, 9, 10, 11], [7, 8, 9, 10, 11, 12]]
1234
這個程序做了兩件事：創建了一個6 × 6的全0表格。 然後使用兩枚骰子的可能組合的數值填充表格。 這並非完成此功能最有效的方式，但我們通過這個簡單的例子來演示幾項技術。我們仔細看一下程序的前後兩部分。
程序的第一部分創建並輸出了一個包含6個元素的列表，我們稱之為「表格」；表格中的每一個元素都是一個包含6個0元素的列表。它使用列表推導式，對於范圍從0到6的每一個j都創建對象。每一個對象都是一個0元素列表，由i變數從0到6遍歷產生。初始化完成之後，列印輸出二維全0表格。
推導式可以從里向外閱讀，就像一個普通表達式一樣。內層列表[ 0 for i in range(6) ]創建了一個包含6個0的簡單列表。外層列表[ [...] for j in range(6) ]創建了這些內層列表的6個深拷貝。
程序的第2個部分對2個骰子的每一個組合進行迭代，填充表格的每一個單元格。這由兩層嵌套循環實現，每一個循環迭代一個骰子。外層循環枚舉第一個骰子的所有可能值d1。內層循環枚舉第二個骰子d2。
更新每一個單元格時需要通過table[d1]選擇每一行；這是一個包含6個值的列表。這個列表中選定的單元格通過...[d2]進行選擇。我們將擲骰子的值賦給這個單元格，d1+d2+2。
其他示例：
列印出的列表的列表不太容易閱讀。下面的循環會以一種更加可讀的形式顯示表格。
for row in table:
print row[2, 3, 4, 5, 6, 7]
[3, 4, 5, 6, 7, 8]
[4, 5, 6, 7, 8, 9]
[5, 6, 7, 8, 9, 10]
[6, 7, 8, 9, 10, 11]
[7, 8, 9, 10, 11, 12]
12345678910111213作為練習，讀者可以試著在列印列表內容時，再列印出行和列的表頭。提示一下，使用"%2d" % value字元串運算符可以列印出固定長度的數字格式。顯示索引值（Explicit Index Values）。
我們接下來對骰子表格進行匯總統計，得出累計頻率表。我們使用一個包含13個元素的列表（下標從0到12）表示每一個骰子值的出現頻率。觀察可知骰子值2在矩陣中只出現了一次，因此我們期望fq[2]的值為1。遍歷矩陣中的每一個單元格，得出累計頻率表。
fq= 13 * [0]for i in range(6):for j in range(6):c= table[i][j]fq[ c ] += 112345使用下標i選出表格中的行，用下標j從行中選出一列，得到單元格c。然後用fq統計頻率。
這看起來非常的數學和規范。
Python提供了另外一種更簡單一些的方式。
使用列表迭代器而非下標，表格是列表的列表，可以採用無下標的for循環遍歷列表元素。
fq= 13 * [0]print fqfor row in table:for c in row:fq[c] += 1print fq[2:

❺ python二維數組怎麼求交集

本文實例講述了python獲得兩個數組交集、並集、差集的房部分。分享給大家供大家參考。具體如下：
1. 獲取兩個list 的交集
#方法一:
a=[2,3,4,5]
b=[2,5,8]
tmp = [val for val in a if val in b]
print tmp
#[2, 5]

#方法二
print list(set(a).intersection(set(b)))

2. 獲取兩個list 的並集

print list(set(a).union(set(b)))

3. 獲取兩個 list 的差集

print list(set(b).difference(set(a))) # b中有而a中沒有的

通過以上方法，就能處理python list 的交集，並集，差集了。

❻ python分治法求二維數組局部峰值方法

python分治法求二維數組局部峰值方法
下面小編就為大家分享一篇python分治法求二維數組局部峰值方法，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
題目的意思大致是在一個n*m的二維數組中，找到一個局部峰值。峰值要求大於相鄰的四個元素（數組邊界以外視為負無窮），比如最後我們找到峰值A[j][i]，則有A[j][i] > A[j+1][i] && A[j][i] > A[j-1][i] && A[j][i] > A[j][i+1] && A[j][i] > A[j][i-1]。返回該峰值的坐標和值。
當然，最簡單直接的方法就是遍歷所有數組元素，判斷是否為峰值，時間復雜度為O(n^2)
再優化一點求每一行（列）的最大值，再通過二分法找最大值列的峰值（具體方法可見一維數組求峰值），這種演算法時間復雜度為O(logn)
這里討論的是一種復雜度為O(n)的演算法，演算法思路分為以下幾步：
1、找「田」字。包括外圍的四條邊和中間橫豎兩條邊（圖中綠色部分），比較其大小，找到最大值的位置。（圖中的7）

2、找到田字中最大值後，判斷它是不是局部峰值，如果是返回該坐標，如果不是，記錄找到相鄰四個點中最大值坐標。通過該坐標所在的象限縮小范圍，繼續比較下一個田字

3、當范圍縮小到3*3時必定會找到局部峰值（也可能之前就找到了）
關於為什麼我們選擇的范圍內一定存在峰值，大家可以這樣想，首先我們有一個圈，我們已知有圈內至少有一個元素大於這個圈所有的元素，那麼，是不是這個圈中一定有一個最大值？
可能說得有點繞，但是多想想應該能夠理解，也可以用數學的反證法來證明。
演算法我們理解後接下來就是代碼實現了，這里我用的語言是python（初學python，可能有些用法上不夠簡潔請見諒），先上代碼：
import numpy as np
def max_sit(*n): #返回最大元素的位置
temp = 0
sit = 0
for i in range(len(n)):
if(n[i]>temp):
temp = n[i]
sit = i
return sit
def dp(s1,s2,e1,e2):
m1 = int((e1-s1)/2)+s1 #row
m2 = int((e2-s1)/2)+s2 #col
nub = e1-s1
temp = 0
sit_row = 0
sit_col = 0
for i in range(nub):
t = max_sit(list[s1][s2+i], #第一排
list[m1][s2+i], #中間排
list[e1][s2+i], #最後排
list[s1+i][s2], #第一列
list[s1+i][m2], #中間列
list[s1+i][e2], #最後列
temp)
if(t==6):
pass
elif(t==0):
temp = list[s1][s2+i]
sit_row = s1
sit_col = s2+i
elif(t==1):
temp = list[m1][s2+i]
sit_row = m1
sit_col = s2+i
elif(t==2):
temp = list[e1][s2+i]
sit_row = e1
sit_col = s2+i
elif(t==3):
temp = list[s1+i][s2]
sit_row = s1+i
sit_row = s2
elif(t==4):
temp = list[s1+i][m2]
sit_row = s1+i
sit_col = m2
elif(t==5):
temp = list[s1+i][e2]
sit_row = s1+i
sit_col = m2
t = max_sit(list[sit_row][sit_col], #中
list[sit_row-1][sit_col], #上
list[sit_row+1][sit_col], #下
list[sit_row][sit_col-1], #左
list[sit_row][sit_col+1]) #右
if(t==0):
return [sit_row-1,sit_col-1]
elif(t==1):
sit_row-=1
elif(t==2):
sit_row+=1
elif(t==3):
sit_col-=1
elif(t==4):
sit_col+=1
if(sit_row<m1):
e1 = m1
else:
s1 = m1
if(sit_col<m2):
e2 = m2
else:
s2 = m2
return dp(s1,s2,e1,e2)
f = open("demo.txt","r")
list = f.read()
list = list.split("n") #對行進行切片
list = ["0 "*len(list)]+list+["0 "*len(list)] #加上下的圍牆
for i in range(len(list)): #對列進行切片
list[i] = list[i].split()
list[i] = ["0"]+list[i]+["0"] #加左右的圍牆
list = np.array(list).astype(np.int32)
row_n = len(list)
col_n = len(list[0])
ans_sit = dp(0,0,row_n-1,col_n-1)
print("找到峰值點位於：",ans_sit)
print("該峰值點大小為：",list[ans_sit[0]+1,ans_sit[1]+1])
f.close()

首先我的輸入寫在txt文本文件里，通過字元串轉換變為二維數組，具體轉換過程可以看我上一篇博客——python中字元串轉換為二維數組。（需要注意的是如果在windows環境中split後的列表沒有空尾巴，所以不用加list.pop()這句話）。有的變動是我在二維數組四周加了「0」的圍牆。加圍牆可以再我們判斷峰值的時候不用考慮邊界問題。

max_sit(*n)函數用於找到多個值中最大值的位置，返回其位置，python的內構的max函數只能返回最大值，所以還是需要自己寫，*n表示不定長參數，因為我需要在比較田和十（判斷峰值）都用到這個函數
def max_sit(*n): #返回最大元素的位置
temp = 0
sit = 0
for i in range(len(n)):
if(n[i]>temp):
temp = n[i]
sit = i
return sit
dp(s1,s2,e1,e2)函數中四個參數的分別可看為startx，starty，endx，endy。即我們查找范圍左上角和右下角的坐標值。
m1,m2分別是row 和col的中間值，也就是田字的中間。
def dp(s1,s2,e1,e2):
m1 = int((e1-s1)/2)+s1 #row
m2 = int((e2-s1)/2)+s2 #col

依次比較3行3列中的值找到最大值，注意這里要求二維數組為正方形，如果為矩形需要做調整
for i in range(nub):
t = max_sit(list[s1][s2+i], #第一排
list[m1][s2+i], #中間排
list[e1][s2+i], #最後排
list[s1+i][s2], #第一列
list[s1+i][m2], #中間列
list[s1+i][e2], #最後列
temp)
if(t==6):
pass
elif(t==0):
temp = list[s1][s2+i]
sit_row = s1
sit_col = s2+i
elif(t==1):
temp = list[m1][s2+i]
sit_row = m1
sit_col = s2+i
elif(t==2):
temp = list[e1][s2+i]
sit_row = e1
sit_col = s2+i
elif(t==3):
temp = list[s1+i][s2]
sit_row = s1+i
sit_row = s2
elif(t==4):
temp = list[s1+i][m2]
sit_row = s1+i
sit_row = m2
elif(t==5):
temp = list[s1+i][e2]
sit_row = s1+i
sit_row = m2

判斷田字中最大值是不是峰值，並找不出相鄰最大值
t = max_sit(list[sit_row][sit_col], #中
list[sit_row-1][sit_col], #上
list[sit_row+1][sit_col], #下
list[sit_row][sit_col-1], #左
list[sit_row][sit_col+1]) #右
if(t==0):
return [sit_row-1,sit_col-1]
elif(t==1):
sit_row-=1
elif(t==2):
sit_row+=1
elif(t==3):
sit_col-=1
elif(t==4):
sit_col+=1
縮小范圍，遞歸求解
if(sit_row<m1):
e1 = m1
else:
s1 = m1
if(sit_col<m2):
e2 = m2
else:
s2 = m2

return dp(s1,s2,e1,e2)
好了，到這里代碼基本分析完了。如果還有不清楚的地方歡迎下方留言。
除了這種演算法外，我也寫一種貪心演算法來求解這道題，只可惜最壞的情況下演算法復雜度還是O(n^2),QAQ。
大體的思路就是從中間位置起找相鄰4個點中最大的點，繼續把該點來找相鄰最大點，最後一定會找到一個峰值點，有興趣的可以看一下，上代碼：
#!/usr/bin/python3
def dp(n):
temp = (str[n],str[n-9],str[n-1],str[n+1],str[n+9]) #中 上 左 右 下
sit = temp.index(max(temp))
if(sit==0):
return str[n]
elif(sit==1):
return dp(n-9)
elif(sit==2):
return dp(n-1)
elif(sit==3):
return dp(n+1)
else:
return dp(n+9)
f = open("/home/nancy/桌面/demo.txt","r")
list = f.read()
list = list.replace(" ","").split() #轉換為列表
row = len(list)
col = len(list[0])
str="0"*(col+3)
for x in list: #加圍牆 二維變一維
str+=x+"00"
str+="0"*(col+1)
mid = int(len(str)/2)
print(str,mid)
p = dp(mid)
print (p)
f.close()
以上這篇python分治法求二維數組局部峰值方法就是小編分享給大家的全部內容了，希望能給大家一個參考

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

❽ Python二維數組運算

二維數組示例：
a=[[1,2,3],[4,5,6],[7,8,9]]
print a
print a[0]
print a[1]
print a[2]
print a[0][0],a[0][1],a[0][2]
sum=0
for i in range(0,3):
for j in range(0,3):
sum=sum+a[i][j]
print sum