python二維數組賦值

⑴ python怎麼初始化二維數組

你可以定義一個嵌套的list
表示一個二維數組，並初始化為這樣:

1
2

score = [[0]*3, [0]*3,[0]*3]
print score

這樣在循環外就能方便的訪問每個元素了。

⑵ 在 Python 中使用二維數組

如果你需要使用二維數組，在 Python 中，除了 numpy 這個包之外，最簡單的方式就是使用 list 了。你可能認為可以這樣構建：

但是請你再仔細想一想，這樣做真的沒有問題嗎？
不要忘記了， Python 一切都是對象 這個問題，對象肯定存在引用的問題，尤其是可變對象。我們試著來改變其中一個元素：

很不幸，不是我們想像的那樣，它改變了多個元素。
來看一看 [ [0] * m ] * n 這個表達式，它首先創建 a = [ [0] * 4] ，然後構造 array = [a] * 3 ，這里 array 裡面是 a 的 3 個引用。
正確的構造，應該使用 列表推導式 ，而且非常 Pythonic ：

⑶ 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求解

因為一些事耽擱了回答，看到下邊六個，一個把簡單的差肆問題寫的這么復雜化，剩下的一讓灶堆不知所雲坦慶扮。

定義空的二維數組，然後賦值

java">importrandom
print("輸入n")
n=int(input())
ifn>=10:
n=9

_list=[[0foriinrange(n)]foriinrange(n)]

foriinrange(n):
forjinrange(n):
_list[i][j]=random_number=random.randint(1,100)


foriin_list:
print(i)

⑸ python的數組讓我很疑惑，在python中請教如何定義二維數組a[][3],在a[][1]存儲第一個參數.....

直接用存在list里就可以了吧。

a=[]
...
a.appen(data)

二位數組在python其實也是list，比如s = ['python', 'java', ['asp', 'php'], 'scheme']，s[2]是一個list，你也可以把這個看成是二維數組吧。

⑹ python怎麼把二維數組變成一維度

需要在程序中使蔽拍用二維數組，網上找到一種這樣的用法：

1
2
3
4
5
6

#創建一個寬度為3，高度為4的數組
#[[0,0,0],
# [0,0,0],
# [0,0,0],
# [0,0,0]]
myList = [[0] * 3] * 4

但是當操作myList[0][1] = 1時，發現整個第二列都被檔基賦值，變成
[[0,1,0],
[0,1,0],
[0,1,0],
[0,1,0]]
為什麼...一時宏蠢羨搞不懂,後面翻閱The Python Standard Library 找到答案

⑺ python 查找二維數組的相鄰元素

#coding=utf-8
'''
Createdon2014-3-21

@author:Neo
'''

defPrintList(array):#輸出數組
foriinrange(array.__len__()):
printarray[i]

defSetList(array):#給數組賦值
row=11
col=11
foriinrange(array.__len__()):
forjinrange(array[i].__len__()):
array[i][j]=row
row+=10
col+=1
row=col

print"賦值後的二維數組:"
PrintList(array)

returnarray

defInitList(x,y):
#初始化一個二維數組
array=[([0]*y)foriinrange(x)]

returnarray

defGetListByCoord(array,radius,x,y):
#根據半徑來確定數組的行數和列數
row_col=2*radius+1
#初始化結果數組
result=InitList(row_col,row_col)
#獲取傳入的array的行數和列數
arrayRow,arrayCol=len(array),len(array[0])
#坐標x、y的值即為結果數組的中心，依此為偏移
foriinrange(result.__len__()):
forjinrange(result.__len__()):
if(i+x-radius<0orj+y-radius<0or
i+x-radius>=arrayRoworj+y-radius>=arrayCol):
result[i][j]=0
else:
result[i][j]=array[i+x-radius][j+y-radius]

#列印結果
print"結果為："
PrintList(result)

if__name__=='__main__':
#數組7列6行
array=SetList(InitList(6,7))
GetListByCoord(array,1,3,3)
GetListByCoord(array,2,3,3)
GetListByCoord(array,2,0,0)
GetListByCoord(array,2,0,6)
GetListByCoord(array,2,5,0)
GetListByCoord(array,2,5,6)

運行結果為：

---------------------------------------------------------------------------------------------

賦值後的二維數組:

[11, 21, 31, 41, 51, 61, 71]

[12, 22, 32, 42, 52, 62, 72]

[13, 23, 33, 43, 53, 63, 73]

[14, 24, 34, 44, 54, 64, 74]

[15, 25, 35, 45, 55, 65, 75]

[16, 26, 36, 46, 56, 66, 76]

結果為：

[33, 43, 53]

[34, 44, 54]

[35, 45, 55]

結果為：

[22, 32, 42, 52, 62]

[23, 33, 43, 53, 63]

[24, 34, 44, 54, 64]

[25, 35, 45, 55, 65]

[26, 36, 46, 56, 66]

結果為：

[0, 0, 0, 0, 0]

[0, 0, 0, 0, 0]

[0, 0, 11, 21, 31]

[0, 0, 12, 22, 32]

[0, 0, 13, 23, 33]

結果為：

[0, 0, 0, 0, 0]

[0, 0, 0, 0, 0]

[51, 61, 71, 0, 0]

[52, 62, 72, 0, 0]

[53, 63, 73, 0, 0]

結果為：

[0, 0, 14, 24, 34]

[0, 0, 15, 25, 35]

[0, 0, 16, 26, 36]

[0, 0, 0, 0, 0]

[0, 0, 0, 0, 0]

結果為：

[54, 64, 74, 0, 0]

[55, 65, 75, 0, 0]

[56, 66, 76, 0, 0]

[0, 0, 0, 0, 0]

[0, 0, 0, 0, 0]

⑻ 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字典添加元素

s={}
s['aaaa']=['11111','22222','33333','4444444']
s['bbbb']=['aaaaa']
prints

運行結果：{'aaaa':['11111','22222','33333','4444444'],'bbbb':['aaaaa']}

你想表達的是這意思嗎

⑽ python 多維數組（比如二維數組）能不能在指定位置進行切片修改

python進行切片修改還是很容易的。
In [1]: a = [[1,2,3],[4,5,6]]

In [2]: a

Out[2]: [[1, 2, 3], [4, 5, 6]]

取索引0的 0到2的切片（不包含索引2）
In [3]: a[0][0:2]

Out[3]: [1, 2]

對索引0切片賦值

In [4]: a[0][0:2] = [2,3]

In [5]: a

Out[5]: [[2, 3, 3], [4, 5, 6]]