python數組運算

1. python怎麼用數組來降低時間復雜度

1. 使用數組代替循環

在一些需要遍歷多次的操作中，使用數組可以代替循環，從而降低時間復雜度。例如，在計算一個數組中所有元素的和時，可以使用如下代碼：

sum = 0
for i in range(len(arr)):
sum += arr[i]

可以使用sum函數來代替循環：

sum = sum(arr)

2. 使用數組代替遞歸

在一些遞歸操作中，使用數組可以代替遞歸，從而降低時間復雜度。例如，在計算斐波那契數列的第n項時，可以使用如下代碼：

def fib(n):
if n <= 1:
return n
else:
return fib(n-1) + fib(n-2)

可以使用數組來代替遞歸：

def fib(n):
if n <= 1:
return n
arr = [0, 1]
for i in range(2, n+1):
arr.append(arr[i-1] + arr[i-2])
return arr[n]

3. 使用數拆攜櫻組代替字典

在一些需要查找操作的場景中，使用數組可以代替字典，從而降低時間復雜度。例如，在查找一個字元串中出現次數最多的字元時，可以使用如下代碼：

s = 'abcccddddd'
count = {}
for c in s:
if c in count:
count[c] += 1
else:
count[c] = 1
max_char = max(count, key=count.get)

可以使用數組來代替字典：

s = 'abcccddddd'
count = [0] * 26
for c in s:
count[ord(c) - ord('a')] += 1
max_char = chr(ord('a') + count.index(max(count)))

4. 使用數組代替集合

在一些需要判斷元素是否存在的場景中隱孫，使用數組可以代替集合，從而降低時間復雜度。例如，在判斷一個數組中是否存在重復元素時，可以使用如下代碼：

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
if len(set(arr)) == len(arr):
print('No plicates')
else:
print('Duplicates exist')

可以使用數組來旅叢代替集合：

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
count = [0] * 10
for x in arr:
if count[x-1] == 1:
print('Duplicates exist')
break
else:
count[x-1] = 1
else:
print('No plicates')

2. Python中數組的基本操作

先定義一個數組列表：

列表合並也可以用+，但是用+的話，會產生一個新的列表（當然也可以賦值給任何的變數），而extend則只是修改了原來的對象

只讀數組，只能查看不能編輯，列表的切片操作同樣適於元組。

表達方式：tuple=("元素1","元素2","元素3"),中間同樣用，隔開

特殊的元組：tupleZero=（）空元組

                        tupleOne=("元素1"，)  只有一個元素，後面要跟一個，（注意好的習慣的養成）

作用：1.對於一些不想被修改的元素，可以放在元組裡面

        2.元組可以在映射（和集合的成員）中當作鍵使用，而列表不行

        3.元組作為內建函數和方法的返回值

enumerate（列表對象，返回標簽起始值（默認為零））

上面的例子可以看出，返回的i是一個元組，如果不想要元組的話，可以用兩個參數接收：

3. Python里怎麼把數組里的數字用於計算和比較

for i in list: #list--你的array
if i > a: #a--用來比較的數值
print "數組數值大於比較數值"
else:
print "數組數值小於等於比較數值"

4. 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

5. 對Python中數組的幾種使用方法總結

對Python中數組的幾種使用方法總結
今天小編就為大家分享一篇對Python中數組的幾種使用方法總結，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
二維數組的初始化
matirx_done = [[0 for i in range(0, len(matirx))]for j in range(0, len(matirx[0]))]
就將其初始化為一個與matrix相同大小的元素全為 0 的矩陣
數組的多級排序
在數組 idea_collect = [[3, 1, 2], [3, 2, 1], [3, 2, 2], [3, 1, 1]] 中, 先按照第二項排列, 再按照第三項倒序排列 可寫為:
idea_collect.sort(key=lambda x: (x[1], -x[2]))
其中, x[1] 代表第二項正序排列, -x[2] 代表第三項倒序排列
排列結果為 [[3, 1, 2], [3, 1, 1], [3, 2, 2], [3, 2, 1]]
在一個 class 中多個函數不傳參使用同一個數組
如例所示:
class Partition:
def __init__(self):
self.num_complete = []

def partition(self, num, start, end):
self.num_compelete = num

def partition_core(self):
del self.num_compelete[0]
其中,self.num_compelete就是 class 中兩個函數同時可以直接調用的數組, 不過最好先在def __init__中聲明這個數組
以上這篇對Python中數組的幾種使用方法總結就是小編分享給大家的全部內容了

6. python如何計算數組內存

數組定義為存儲在連續內存位置的項目的集合。這是一個可以容納固定數量項目的容器, 這些項目應為同一類型。數組在大多數編程語言(例如C / C ++, JavaScript等)中都很流行。

數組是將多個相同類型的項存儲在一起的想法, 並且只需在基本值上添加一個偏移量, 就可以更輕松地計算每個元素的位置。數組的組合可以通過減少代碼的整體大小來節省大量時間。它用於在單個變數中存儲多個值。如果你有一個存儲在其相應變數中的項目列表, 如下所示：

car1 =」蘭博基尼」

car2 =」布加迪」

car3 =」 Koenigsegg」

如果要遍歷汽車並找到特定的汽車, 可以使用該數組。

數組可以在Python中由名為array的模塊處理。當我們只需要操作特定的數據值時, 這很有用。以下是了解數組概念的術語：

元素-存儲在數組中的每個項目稱為元素。

索引-數組中元素的位置具有數字索引, 該數字索引用於標識元素的位置。

數組表示

數組可以用各種方式和不同的語言聲明。應考慮的重點如下：

索引從0開始。

我們可以通過其索引訪問每個元素。

數組的長度定義了存儲元素的能力。

數組運算

數組支持的一些基本操作如下：

遍歷-逐一列印所有元素。

插入-在給定的索引處添加一個元素。

刪除-刪除給定索引處的元素。

搜索-它使用給定的索引或值搜索元素。

更新-更新給定索引處的元素。

7. 怎樣用python將數組里的數從高到低排序

1、首先我們定義一個列表輸入一串大小不一的數字。

8. 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 table
for d1 in range(6):
for d2 in range(6):
table[d1][d2]= d1+d2+2
print table
123456

程序的輸出結果如下：
[[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 ] += 1
12345

使用下標i選出表格中的行，用下標j從行中選出一列，得到單元格c。然後用fq統計頻率。

這看起來非常的數學和規范。Python提供了另外一種更簡單一些的方式。

使用列表迭代器而非下標

表格是列表的列表，可以採用無下標的for循環遍歷列表元素。
fq= 13 * [0]
print fq
for row in table:
for c in row:
fq[c] += 1
print fq[2:]