python數據類型之列表

1.創建列表

2.列表基礎操作

常用操作

對列表元素順序隨機打亂

列表下標和切片

字符串分割為列表

列表位移

列表切片替換

3.列表內置方法

4.列表排序

簡單排序

使用key參數按指定規則排序

二維列表排序

自定義排序規則函數

5.列表排序算法

選擇排序

柱狀圖動畫展示插入排序

插入排序

柱狀圖動畫展示插入排序

6.列表查找算法

線性查找

二分查找

7.引用、淺拷貝和深拷貝

引用（地址相同）

淺拷貝和深拷貝

列表作為函數參數注意事項

注意列表作為實參傳遞給函數形參是引用

用深淺拷貝處理列表參數

8.多維列表

二維列表：矩陣

三維列表

1.創建列表

用list方法創建

list1 = list()  # 創建一個空列表
list2 = list([2, 3, 4])
list3 = list(["red", "green", "blue"])
list4 = list(range(3, 6))
list5 = list("abcd")

使用更簡潔的方法來創建列表

list1 = []
list2 = [2, 3, 4]
list3 = ["red", "green"]
list4 = [2, "red", 4]  # 列表中可以包含不同類型的元素

進階創建方法："列表構造表達式"

list5 = [x for x in range(5)]
list6 = list3 = [x**2 for x in list2 if x < 3]
list6 = [[x, x+1, x**2] for x in list2 if x % 2 == 1]
mylist = [[x, y] for x in range(0, 10, 2) for y in range(1, 10, 2)]  # 生成矩陣
mylist = [[2*x, y+1] for x in range(0, 10, 2) for y in range(1, 10, 2) if x % 2 == 0and y % 2 != 0]

2.列表基礎操作

常用操作

對列表元素順序隨機打亂

import randomlist1 = [1, 2, 3, 4, 5]
random.shuffle(list1)
print(list1)  # [4, 5, 2, 1, 3]

列表下標和切片

和字符串類似

myList[-1] = myList[-1 + len(myList)]

注意避免因 < 和 <= 的使用不當造成列表的“越級訪問”，就是超過列表長度的訪問，它會出現一個運行時的“IndexError”

示例代碼

lst = [1, 2, 3, 4, 5]
print(lst[10])

結果報錯

IndexError: list index out of range

考慮對“IndexError”異常的處理

lst = [1, 2, 3, 4, 5]
try:print(lst[10])
except IndexError:print("索引越界")

字符串分割為列表

string = "name xxx ttt" 
list1 = string.split()  # 默認用空格分隔
print(list1)  # ['name', 'xxx', 'ttt']items = "09/17/2020".split("/")  # 用/分割
print(items)  # ['09', '17', '2020']s1 = "welcome" 
list2 = s1.split("o")  # 用o分割
print(list2)  # ['welc', 'me']

列表位移

左移

def left_shift(lst):temp = lst[0]for i in range(1, len(lst), 1):lst[i - 1] = lst[i]lst[len(lst) - 1] = tempdata = [1, 2, 3, 4]
left_shift(data)
print(data)   # [2, 3, 4, 1]

右移

def right_shift(lst):temp = lst[len(lst) - 1]for i in range(len(lst) - 1, 0, -1):lst[i] = lst[i - 1]lst[0] = tempdata = [1, 2, 3, 4]
right_shift(data)
print(data)   # [4, 1, 2, 3]

或者這樣

data = [1, 2, 3, 4]# 左移
num = 1
lst = data[num:] + data[:num]
print(lst)   # [2, 3, 4, 1]# 右移
num = 1
lst = data[-num:] + data[:-num]
print(lst)   # [4, 1, 2, 3]

列表切片替換

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst[0:2] = [0, 0]
print(lst)  # [0, 0, 3, 4, 5, 6, 7, 8, 9]

替換注意事項：多增少減

# 多增例子
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst[0:2] = [0, 0, 0, 0, 0]
print(lst)  # [0, 0, 0, 0, 0, 3, 4, 5, 6, 7, 8, 9]# 少減例子
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst[0:7] = [0, 0, 0]
print(lst)  # [0, 0, 0, 8, 9]

但 lst[i:j:k] = newList 個數不同時會報錯

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst[0:7:2] = [0, 0, 0]   # 0:7:2為0 2 4 6共4個數，[0, 0, 0]為3個數
"""
會報錯
ValueError: attempt to assign sequence of size 3 to extended slice of size 4
"""

3.列表內置方法

方法	作用
append(x: object): None	將元素添加到列表結尾
count(x: object): int	返回元素x在列表中的出現次數
extend(lst: list):?None	將lst中的所有元素追加到列表中
insert(index: int, x:object): None	將元素x插入列表中指定下標處。注意列表第一個元素的下標是0
pop(index): object	刪除給定位置處的元素并返回它。參數index是可選的，如果沒有指定它那么list.pop()將刪除列表最后一個元素并返回它
remove(x: object): None	刪除列表中第一次出現的x
reverse(): None	將列表中的所有元素倒序
sort(): None	以升序對列表中的元素排序

示例代碼

data = [x for x in range(5)]
print(data)  # [0, 1, 2, 3, 4]# append方法
data.append(100)
print(data)  # [0, 1, 2, 3, 4, 100]# count方法
data.append(100)
print(data)  # [0, 1, 2, 3, 4, 100, 100]
print(data.count(100))  # 2
print(data.count(99))   # 0# extend方法
data.extend([10, 20, 30])
print(data)  # [0, 1, 2, 3, 4, 100, 100, 10, 20, 30]# insert方法
data.insert(1, 9999)
print(data)  # [0, 9999, 1, 2, 3, 4, 100, 100, 10, 20, 30]
data.insert(-1, 9999)
print(data)  # [0, 9999, 1, 2, 3, 4, 100, 100, 10, 20, 9999, 30]
data.insert(100, 9999)
print(data)  # [0, 9999, 1, 2, 3, 4, 100, 100, 10, 20, 9999, 30, 9999]# pop方法
ret = data.pop(1)
print(ret)   # 9999
print(data)  # [0, 1, 2, 3, 4, 100, 100, 10, 20, 9999, 30, 9999]
data.pop()
print(data)  # [0, 1, 2, 3, 4, 100, 100, 10, 20, 9999, 30]# data.pop(100)  # IndexError: pop index out of range# remove方法
data.remove(0)
print(data)  # [1, 2, 3, 4, 100, 100, 10, 20, 9999, 30]
# data.remove(666)  # ValueError: list.remove(x): x not in list# reverse方法
data.reverse()
print(data)  # [30, 9999, 20, 10, 100, 100, 4, 3, 2, 1]# sort方法
data.sort()
print(data)  # [1, 2, 3, 4, 10, 20, 30, 100, 100, 9999]data = [30, 9999, 20, 10, 100, 100, 4, 3, 2, 1]
data.sort()
data.reverse()
print(data)  # [9999, 100, 100, 30, 20, 10, 4, 3, 2, 1]

4.列表排序

簡單排序

# 升序
data = [30, 9999, 20, 10, 100, 100, 4, 3, 2, 1]
data.sort()
print(data)  # [1, 2, 3, 4, 10, 20, 30, 100, 100, 9999]# 降序
data = [30, 9999, 20, 10, 100, 100, 4, 3, 2, 1]
data.sort()
data.reverse()
print(data)  # [9999, 100, 100, 30, 20, 10, 4, 3, 2, 1]

使用key參數按指定規則排序

# 按照元素第一個元素排序
data = ['apple', 'watermelon', 'orange', 'lemon']
data.sort(key=lambda x: x[1])  
print(data)  # ['watermelon', 'lemon', 'apple', 'orange'] # 按照元素長度排序
data = ['apple', 'watermelon', 'orange', 'lemon']
data.sort(key=lambda x: len(x))  
print(data)  # ['apple', 'lemon', 'orange', 'watermelon']# 按照元素長度排序的簡潔寫法
data = ['apple', 'watermelon', 'orange', 'lemon']
data.sort(key=len)  
print(data)  # ['apple', 'lemon', 'orange', 'watermelon']# 按照元素第一個元素排序，降序
data = ['apple', 'watermelon', 'orange', 'lemon']
data.sort(key=lambda x: x[1], reverse=True)  
print(data)  # ['orange', 'apple', 'lemon', 'watermelon']

二維列表排序

按照每個子列表的第一個元素升序、第二個元素降序進行排序

# 二維列表
data = [[3, 1, 'apple'],[1, 2, 'orange'],[2, 5, 'banana'],[1, 3, 'grape']
]# 按照每個子列表的第一個元素升序、第二個元素降序進行排序
sorted_list = sorted(data, key=lambda x: (x[0], -x[1]))
# data.sort(key=lambda x: (x[0], -x[1]))# 打印排序后的結果
for item in sorted_list:print(item)# [1, 3, 'grape']
# [1, 2, 'orange']
# [2, 5, 'banana']
# [3, 1, 'apple']

自定義排序規則函數

例子1：按照第一個元素排序，如果第一個元素相同，則按照第二個元素排序

# 定義一個比較函數，用于排序
def custom_sort(item):# 按照第一個元素排序first_element = item[0]# 如果第一個元素相同，則按照第二個元素排序second_element = item[1]return first_element, second_element# 你的二維列表
data = [[3, 'apple', 'a'],[1, 'orange', 'b'],[2, 'banana', 'c'],[1, 'grape', 'd'],[3, 'pear', 'e']
]# 使用sorted函數進行排序，傳遞自定義的比較函數
sorted_list = sorted(data, key=custom_sort)# 輸出排序后的結果
for x in sorted_list:print(x)# [1, 'grape', 'd']
# [1, 'orange', 'b']
# [2, 'banana', 'c']
# [3, 'apple', 'a']
# [3, 'pear', 'e']

例子2：如果第一個元素相同，則按照第二個元素降序排序

# 定義一個比較函數，用于排序
def custom_sort(item):# 按照第一個元素升序排序first_element = item[0]# 按照第二個元素降序排序second_element = item[1]return first_element, -ord(second_element[0])# 你的二維列表
data = [[3, 'apple'],[1, 'orange'],[2, 'banana'],[1, 'grape'],[3, 'pear']
]# 使用sorted函數進行排序，傳遞自定義的比較函數
sorted_list = sorted(data, key=custom_sort)# 輸出排序后的結果
for x in sorted_list:print(x)
"""
[1, 'orange']
[1, 'grape']
[2, 'banana']
[3, 'pear']
[3, 'apple']
"""

5.列表排序算法

排序算法有很多

這里重點介紹兩種簡單、直觀的排序算法：選擇排序和插入排序

選擇排序

該算法的思路是先將第一個元素作為最小元素，然后依次將它后面所有元素與它比較，若比它小，則并將其交換（這樣一來最小的元素將被排在第一個位置）

然后將第二個元素作為最小元素，跟上面一樣，將它后面所有元素與它比較，若比它小，則并將其交換（這樣一來第2小的元素將被排在第二個位置）

循環到只剩一個元素

def selectionSort(lst):for i in range(len(lst) - 1):currentMin = lst[i]currentMinIndex = ifor j in range(i + 1, len(lst)):if currentMin > lst[j]:currentMin = lst[j]currentMinIndex = jif currentMinIndex != i:lst[currentMinIndex] = lst[i]lst[i] = currentMindef main():lst = [1, 9, 4.5, 10.6, 5.7, -4.5]selectionSort(lst)print(lst)main()  # [-4.5, 1, 4.5, 5.7, 9, 10.6]

柱狀圖動畫展示插入排序

# 柱狀圖：選擇排序動畫
from tkinter import *
import tkinter.messagebox
import randomclass StepControl:def __init__(self):self.list = [x for x in range(1, 20 + 1)]self.reset()def reset(self):self.i = -1self.done = Falserandom.shuffle(self.list)self.drawAStep()def step(self):if self.done:tkinter.messagebox.showinfo("showinfo", "列表已經排好升序")return # 沒有這個 return 的話消息框要點兩次才會消失if self.i == -1:self.i += 1self.drawAStep()if self.i >= len(self.list) - 1:self.done = Truetkinter.messagebox.showinfo("showinfo", "列表已經排好升序")else:currentMin = self.list[self.i]currentIndex = self.ifor j in range(self.i + 1, len(self.list)):if self.list[j] < currentMin:currentMin = self.list[j]currentIndex = jif currentIndex != self.i:self.list[currentIndex] = self.list[self.i]self.list[self.i] = currentMinself.i += 1def drawAStep(self):bottomGap = 10canvas.delete("line")canvas.create_line(10, height - bottomGap, width - 10, height - bottomGap, tags = "line")barWidth = (width - 20) / len(self.list)maxCount = int(max(self.list))for i in range(len(self.list)):canvas.create_rectangle(10 + i * barWidth,(height - bottomGap) * (1 - self.list[i] / (maxCount + 4)),10 + (i + 1) * barWidth,height - bottomGap, tags = "line")canvas.create_text(10 + i * barWidth + barWidth / 2,(height - bottomGap) * (1 - self.list[i] / (maxCount + 4)) - 8,text = str(self.list[i]), tags = "line")if self.i >= 0:canvas.create_rectangle(10 + self.i * barWidth,(height - bottomGap) * (1 - self.list[self.i] / (maxCount + 4)),10 + (self.i + 1) * barWidth,height - bottomGap, fill = "red", tags="line")def step():control.step()def reset():control.reset()window = Tk()
window.title("選擇排序動畫")width = 340
height = 150canvas = Canvas(window, width=width, height=height, )
canvas.pack()frame = Frame(window)
frame.pack()Button(frame, text="Step", command=step).pack(side=LEFT)
Button(frame, text="Reset", command=reset).pack(side=LEFT)control = StepControl()
control.drawAStep()window.mainloop()

插入排序

該算法的思路是是重復地將一個新元素插入到一個已排好序的子列表中，直到整個列表排好序

def insertionSort(lst):for i in range(1, len(lst)):currentValue = lst[i]k = i - 1while k >= 0 and lst[k] > currentValue:lst[k + 1] = lst[k]k -= 1lst[k + 1] = currentValuedef main():lst = [1, 9, 4.5, 10.6, 5.7, -4.5]insertionSort(lst)print(lst)  # [-4.5, 1, 4.5, 5.7, 9, 10.6]main()

柱狀圖動畫展示插入排序

# 柱狀圖：插入排序動畫
from tkinter import *
import tkinter.messagebox
import randomclass StepControl:def __init__(self, width, height, canvas):self.width = widthself.height = heightself.canvas = canvasself.list = [x for x in range(1, 20 + 1)]self.reset()def reset(self):self.i = -1self.done = Falserandom.shuffle(self.list)self.drawAStep()def start(self):if self.done:tkinter.messagebox.showinfo("showinfo", "列表已經排好升序")return # 沒有這個 return 的話消息框要點兩次才會消失if self.i == -1:self.i += 1self.drawAStep()if self.i >= len(self.list) - 1:self.done = Truetkinter.messagebox.showinfo("showinfo", "列表已經排好升序")else:self.i += 1currentValue = self.list[self.i]k = self.i - 1while k >= 0 and self.list[k] > currentValue:self.list[k + 1] = self.list[k]k -= 1self.list[k + 1] = currentValuedef drawAStep(self):width = self.widthheight = self.heightcanvas = self.canvasbottomGap = 10barWidth = (width - 20) / len(self.list)maxCount = int(max(self.list))canvas.delete("line")canvas.create_line(10, height - bottomGap, width - 10, height - bottomGap, tags = "line")for i in range(len(self.list)):canvas.create_rectangle(10 + i * barWidth, (height - bottomGap) * (1 - self.list[i] / (maxCount + 4)),10 + (i + 1) * barWidth, (height - bottomGap),tags = "line")canvas.create_text(10 + i * barWidth + barWidth / 2,(height - bottomGap) * (1 - self.list[i] / (maxCount + 4)) - 8,text = str(self.list[i]), tags="line")if self.i >= 0:canvas.create_rectangle(10 + self.i * barWidth,(height - bottomGap) * (1-self.list[self.i]/(maxCount+4)),10 + (self.i + 1) * barWidth,height - bottomGap,fill="red", tags="line")# 定義窗體類：來展示主界面窗口
class Window:def __init__(self):self.window = Tk()self.window.title("插入排序動畫")self.window.geometry("600x400+0+0")self.width = 340self.height = 150self.canvas = Canvas(self.window, width= self.width, height=self.height)self.canvas.pack()#################################self.control = StepControl(self.width, self.height, self.canvas) # 類中創建類#################################self.frame = Frame(self.window)self.frame.pack()Button(self.frame, text="Start", command=self.start).pack(side=LEFT)Button(self.frame, text="Reset", command=self.reset).pack(side=LEFT)self.window.mainloop()def start(self):self.control.start()def reset(self):self.control.reset()Window()

6.列表查找算法

查找最常見的兩種方法是二分查找和線性查找

如果一個列表是排好序的，那么要查找列表中的某個元素，二分查找比線性查找更有效

線性查找

原理是暴力查找，依順序將要查找的那個元素與列表的每一個元素進行比較

# -*- coding: utf-8 -*-def linear_search(lst, key):result = []for i in range(len(lst)):if key == lst[i]:result.append(i)return resultdata = [1, 3, 4, 2, 4, -3, 6, 2]a = linear_search(data, 4)
b = linear_search(data, -4)
c = linear_search(data, 3)print(a)  # [2, 4]
print(b)  # []
print(c)  # [1]

二分查找

對大型列表而言，二分查找法更高效，但是它們需要列表是提前排好序的。

工作原理是，從數組的中間元素開始比較，如果中間元素正好是要查找的元素，則搜索過程結束；如果某一特定元素大于或者小于中間元素，則在數組大于或小于中間元素的那一半中查找，而且跟開始一樣從中間元素開始比較。如果在某一步驟數組為空，則代表找不到該元素。二分查找的每一次比較都使搜索范圍縮小一半，因此其效率較高。

二分查找的時間復雜度是O(log n)，其中n是數組中的元素數量。這意味著在最壞的情況下，需要比較的次數與數組的深度（以2為底數）成對數關系。

# -*- coding: utf-8 -*-def binary_search(lst, key):low = 0high = len(lst) - 1while high >= low:mid = (low + high) // 2if key < lst[mid]:high = mid - 1elif key > lst[mid]:low = mid + 1else:return midreturn -(low + 1)# –(low + 1)中“-”表示查找不到這個元素，“low + 1”表示應該插入的位置，low + 1 = 1 話表示索引為 0 的位置
data = [1, 3, 4, 2, 4, -3, 6, 2]
data.sort()
print(data)  # [-3, 1, 2, 2, 3, 4, 4, 6]i = binary_search(data, 4)
j = binary_search(data, -4)
k = binary_search(data, 3)
print(i)  # 5
print(j)  # -1
print(k)  # 4

7.引用、淺拷貝和深拷貝

引用（地址相同）

引用就是與原來變量為同一個內存地址

在python列表中，用=號復制的列表的 id 與原列表相同

# -*- coding: utf-8 -*-lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
print(id(lst1) == id(lst2))   # False 說明地址不同lst2 = lst1
print(id(lst1) == id(lst2))   # True 現在lst2 和lst1指向同一塊地址
print(lst1)  # [1, 2, 3]
print(lst2)  # [1, 2, 3]# 現在修改lst1，然后查看lst2是否會變化
lst1[0] = 99
print(lst1)  # [99, 2, 3]
print(lst2)  # [99, 2, 3]

淺拷貝和深拷貝

淺拷貝，指的是重新分配一塊內存，創建一個新的對象，但里面的元素是原對象中各個子對象的引用。
深拷貝，是指重新分配一塊內存，創建一個新的對象，并且將原對象中的元素，以遞歸的方式，通過創建新的子對象拷貝到新對象中。因此，新對象和原對象沒有任何關聯。

淺拷貝：只能保證第一層不會被改變

# -*- coding: utf-8 -*-lst = [1, 2, 3, 4, 5]
lst1 = lst  # 引用
lst2 = lst.copy()  # 淺拷貝：保證第一層不會被改變print(id(lst) == id(lst1))   # True
print(id(lst) == id(lst2))   # False
print(id(lst1) == id(lst2))  # Falselst[3] = 10000
print(lst)  # [1, 2, 3, 10000, 5]
print(lst1)  # [1, 2, 3, 10000, 5]
print(lst2)  # [1, 2, 3, 4, 5]

深拷貝：保證內層所有層不會被改變

# -*- coding: utf-8 -*-import copylst = [[1, 2], [3, 4]]
lst1 = lst.copy()    # 淺拷貝
lst2 = copy.deepcopy(lst)  # 深拷貝print(id(lst), id(lst1), id(lst2))  
# 2096876497224 2096876497160 2096876497096lst[0][0] = 100
print(lst)  # [[100, 2], [3, 4]]
print(lst1)  # [[100, 2], [3, 4]]
print(lst2)  # [[1, 2], [3, 4]]

列表作為函數參數注意事項

注意列表作為實參傳遞給函數形參是引用

列表用=賦值是引用。列表作為形參賦值給形參后，在函數內部若對形參進行了值修改，則原實參那個列表內容會發生改變。這一點需要非常注意，避免在調用函數后原列表發生改變，出現意外錯誤。

# -*- coding: utf-8 -*-def m(number, numbers):number = 1001numbers[0] = 5555def main():x = 1y = [1, 2, 3]m(x, y)print("x = ", x)print("y[0] = ", y[0])main()
"""
結果
x = 1
y[0] = 5555
注意 x 未發生改變，而列表發生了改變，這是因為 y 和 numbers 都指向同一個列表對象
"""

用深淺拷貝處理列表參數

# -*- coding: utf-8 -*-import copydef test_list(m_list):# 調用函數時test_list(x)就是做了m_list=x這么一個賦值操作m_list[0] = 99return m_listdef test_list2(m_list):temp_list = m_list.copy()   # 淺拷貝temp_list[0] = 99return temp_listdef test_list3(m_list):temp_list = m_list.copy()  # 淺拷貝print(temp_list)temp_list[1] = [7, 8, 9]   # 改變第一層的值temp_list[0][0] = 88    # 改變第二層的值return temp_listdef test_list4(m_list):temp_list = copy.deepcopy(m_list)  # 深拷貝print(temp_list)temp_list[1] = [7, 8, 9]   # 改變第一層的值temp_list[0][0] = 88    # 改變第二層的值return temp_listif __name__ == "__main__":# 1.列表賦值是引用，與原列表是同一個對象x = [1, 2, 3]y = xx[0] = 100print(y)   # [100, 2, 3]print(id(x) == id(y))  # True # 地址相同說明是同一個對象# 2.函數將實參傳遞給形參時是賦值x = [1, 2, 3]re_list = test_list(x)print(re_list)  # [99, 2, 3]print(x)  # [99, 2, 3]# 3.用淺拷貝解決列表做參數時改變原列表值的問題x = [1, 2, 3]re_list = test_list2(x)print(re_list)  # [99, 2, 3]print(x)  # [1, 2, 3]# 4.淺拷貝的局限：只能保證第一層不會變x = [[1, 2, 3], [4, 5, 6]]re_list = test_list3(x)print(re_list)  # [[88, 2, 3], [7, 8, 9]]print(x)  # [[88, 2, 3], [4, 5, 6]]# 5.用深拷貝保證所有層都不變x = [[1, 2, 3], [4, 5, 6]]re_list = test_list4(x)print(re_list)  # [[88, 2, 3], [7, 8, 9]]print(x)  # [[1, 2, 3], [4, 5, 6]]

8.多維列表

二維列表：矩陣

二維列表是將其他列表作為它元素的列表

二維列表可以用來存儲矩陣中的數據，也就是存儲二維數據

將矩陣數據轉化為列表

# -*- coding: utf-8 -*-from random import randintmatrix = []
number_of_rows = 3
number_of_columns = 3for row in range(number_of_rows):matrix.append([])for column in range(number_of_columns):# value = eval(input("請輸入矩陣第{}行第{}列的值：".format(row, column)))value = randint(0, 99)matrix[row].append(value)print(matrix)

二維列表遍歷

# -*- coding: utf-8 -*-# 可以這樣
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in range(len(matrix)):for column in range(len(matrix[row])):print(matrix[row][column], end=" ")print()# 也可以這樣
for row in matrix:for value in row:print(value, end=" ")print()

二維列表求和

# -*- coding: utf-8 -*-# 對所有元素求和
def sum_matrix(matrix):total = 0for row in matrix:for value in row:total += valuereturn total# 按列求和
def sum_matrix_column(matrix):sum_column_list = []for column in range(len(matrix[0])):sum_column = 0for row in range(len(matrix)):sum_column += matrix[row][column]sum_column_list.append(sum_column)return sum_column_list# 找出和最大的行
def max_sum_row(matrix):max_value = sum(matrix[0])max_index = 0for row in range(1, len(matrix)):if sum(matrix[row]) > max_value:max_value = sum(matrix[row])max_index = rowreturn max_value, max_indexdata = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(sum_matrix(data))  # 45
print(sum_matrix_column(data))  # [12, 15, 18]
print(max_sum_row(data))  # (24, 2)

隨意打亂一個矩陣

# -*- coding: utf-8 -*-from random import randintdef shuffle_matrix(matrix):for row in range(len(matrix)):for column in range(len(matrix[row])):i = randint(0, len(matrix) - 1)j = randint(0, len(matrix[row]) - 1)matrix[row][column], matrix[i][j] = matrix[i][j], matrix[row][column]data = [[1,2,3], [4,5,6], [7,8,9]]
shuffle_matrix(data)
print(data)

排序

直接使用 sort 方法可以對一個二維列表排序

# -*- coding: utf-8 -*-data = [[8, 1, 3], [6, 7, 4], [6, 3, 4], [9, 5, 2]]
data.sort()
print(data)   # [[6, 3, 4], [6, 7, 4], [8, 1, 3], [9, 5, 2]]

可以看到它像一維列表排序一樣，將每個元素(列表)比較大小，比如[8, 1, 3]和[6, 7, 4]，從第一個元素依次比較，直到分出大小。

但是我們有時想按指定規則排序，參考前面的列表排序。

矩陣轉置

grid = [['.', '.', '.', '.', '.', '.'],['.', 'O', 'O', '.', '.', '.'],['O', 'O', 'O', 'O', '.', '.'],['O', 'O', 'O', 'O', 'O', '.'],['.', 'O', 'O', 'O', 'O', 'O'],['O', 'O', 'O', 'O', 'O', '.'],['O', 'O', 'O', 'O', '.', '.'],['.', 'O', 'O', '.', '.', '.'],['.', '.', '.', '.', '.', '.']
]def transpose(matrix):new_matrix = [[0]*len(matrix) for i in range(len(matrix[0]))]# print(new_matrix)for column in range(len(matrix[0])):for row in range(len(matrix)):print(matrix[row][column], end="")new_matrix[column][row] = matrix[row][column]print()return new_matrixnew_grid = transpose(grid)
print("----------------------------")
for item in new_grid:print(item)"""
..OO.OO..
.OOOOOOO.
.OOOOOOO.
..OOOOO..
...OOO...
....O....
----------------------------
['.', '.', 'O', 'O', '.', 'O', 'O', '.', '.']
['.', 'O', 'O', 'O', 'O', 'O', 'O', 'O', '.']
['.', 'O', 'O', 'O', 'O', 'O', 'O', 'O', '.']
['.', '.', 'O', 'O', 'O', 'O', 'O', '.', '.']
['.', '.', '.', 'O', 'O', 'O', '.', '.', '.']
['.', '.', '.', '.', 'O', '.', '.', '.', '.']
"""