一、列表（List）
1.列表的特點
- 列表是以方括號“[]”包圍的數據集合，不同成員以“，”分隔。如 L = [1,2,3], 列表a有3個成員。
- 列表是可變的數據類型【可進行增刪改查】，列表中可以包含任何數據類型，也可以包含另一個列表。如： L = [1,2,[3,4]]，列表L有3個成員，最后一個成員為一個列表。
- 列表可以通過序號（索引）訪問其中成員，成員序號從0開始，如：a[0]=1。
- 列表沒有shape，計算列表中成員（元素）的個數，成員以最外層的[ ]中的逗號“，”來分隔，計算方式是len(L)=3, L = [1,2,[3,4]] ，沒有數組中的a.shape操作。
- 空列表（0個元素的列表）：L=[], 一個元素的列表：L=[1], 多個元素的列表L=[1,2,3]
2.列表運算符
列表對+ 和 * 的操作符與字符串操作類似 ，列表之間可以使用 + 號和 * 號進行運算。+號用於組合列表，*號用於重復列表，運算之后會生成一個新的列表，如下圖所示：
3.列表內置的函數和方法
列表操作補充：
#列表操作補充--切片操作
# 創建空列表
a = []
# 創建一個非空列表example
example = [0,1,2,3,4,5,6,7,8,9]
#切片打印某一區間 左閉右開（包含左邊開始序號的成員start，不包括結束序號的成員end）
print(example[4:8]) # [4, 5, 6, 7]
#想包含最后一個
print(example[4:]) # [4, 5, 6, 7, 8, 9]
#包含首個
print(example[:8]) # [0, 1, 2, 3, 4, 5, 6, 7]
#所有的
print(example[:])
#第三個參數為步長，左閉右開
print(example[1:8:2]) # [1, 3, 5, 7]
#倒序輸出
print(example[::-1])
#列表合並
a = [1,2,3]
b = [4,5,6]
print(a+b)
#替換
ex = [1,2,3,4,5,6]
ex[4:]=[9,8,7] # 從第四個元素開始將剩余元素替換
print(ex) #將56換為987
# 定義包含不同數據類型的列表
list4=[123,["das","aaa"],234]
# in只能判斷一個層次的元素
"aaa" in list4 # False
# 但是可以選中列表中的列表進行判斷
"aaa" in list4[1] # True
# 獲取列表中的某個元素
print(list4[1][1]) # 'aaa'
二、元組（Tuple）
1.元組的特點
- 元組是以圓括號“()”包圍的數據集合,括號（）可以省略，不同成員（元素）以逗號“,”分隔，如：T=（1，2,3）。
- 元組是不可變序列，即元組一旦創建，元組中的數據一旦確立就不能改變，不能對元組中中的元素進行增刪改操作，因此元組沒有增加元素append、修改元素、刪除元素pop的相關方法，只能通過序號（索引）訪問元組中的成員,元組中的成員的起始序號為0，如：T[0]=1, T=（1,2,3）。
- 元組中可以包含任何數據類型，也可以包含另一個元組，如：T=（1,2,3，('a','b')）
- 空元組（沒有元素的元組）：T=（），含1個元素的元組：T=（1，），注意有逗號,多個元素的元組：T=（1,2,3）
- 任意無符號的對象，以逗號隔開，默認為元組，如下：
2.元組運算符
與字符串和列表一樣，元組之間可以使用+號和*號進行運算，+號用於組合元組，*號用於重復元組，運算之后會生成一個新的元組，如下圖所示：
3.元組內置的函數
4.元組操作補充訪問元組
訪問元組
o =('a','b','c',('d1','d2'))
print o[0] #a
print o[3][0] #d1
# 索引訪問
print(o[0:2]) #
age=22
name='sandra'
print('%s is %d years old'%(name,age)) # sandra is 22 years old
修改元組
元組中的元素值是不允許修改的，但是我們還可以對元組進行拼接
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元組元素操作是非法的。
# tup1[0] = 100
# 創建一個新的元組
tup3 = tup1 + tup2
print tup3;
刪除元組
del tup1
添加元組
#通過切片方法添加
a=(1,2,3,4,5,6)
a=a[:2]+(10,)+a[2:] # 在元組的第2個元素后面添加一個元組（10，）
print(a) # (1, 2, 10, 3, 4, 5, 6)三、數組（Array-numpy）
1.數組（numpy array）的特點
准確來說Python中是沒有數組類型的，只有列表(list)和元組（tuple), 數組是numpy庫中所定義的，所以在使用數組之前必須下載安裝numpy庫。 python中的list是python的內置數據類型，list中的數據類不必相同的，而array的中的類型必須全部相同。在list中的數據類型保存的是數據的存放的地址，簡單的說就是指針，並非數據，這樣保存一個list就太麻煩了，例如list1=[1,2,3,'a']需要4個指針和四個數據，增加了存儲和消耗cpu。numpy中封裝的array有很強大的功能，里面存放的都是相同的數據類型。
- numpy array 是以方括號“[]”包圍的數據集合，不同成員以空格“ ”分隔。如 a=[1 2 3 4]
- numpy array 的數據成員必須是相同數據類型屬性，不同於列表和元組
- numpy array 數組是可以多維的，而列表和元組是一維的，數組的每個維度之間以換行分隔開，單個維度內的數組成員也以換行分隔開,每個並列（單個）維度內的成員個數需要一致，不同維度的成員個數可以不一樣。ru
- numpy array 通過索引號（下標）來訪問數組元素,數組每個維度的元素的起始索引*號為0，如：a[1][1] = 2 , a = [[0 1] ，或者以逗號分隔的整數表示元素的維數和索引,如：arr[1,1]=2
[1 2]]
- numpy array 有很多可以直接使用的函數
- numpy array有形狀大小shape，即維度，獲取的兩種方式np.shape(a) 或者 a.shape，即可得到數組的大小。
2.數組的創建
安裝numpy庫(pip或者conda)
導入numpy庫（通過import關鍵字導入）：import numpy as np
創建數組的幾種方式：
Numpy 用於處理數組，Numpy中的數組對象稱為ndarray，我們使用array()函數創建一個Numpy的ndarray對象，我們可以將列表、元組或者任何類似數組的對象傳遞給array()方法，array方法會將它們轉換為ndarray。
import numpy as np
# 方法一：使用列表創建numpy數組
# 列表轉數組
# 列表中有列表時，轉數組時，首先將逗號“，”全部變為空格“ ”，以最外層[]中的逗號“，”以換行分開成為數組的第一維度的不同成員（元素），其他類推
a =np.array( [[1,2,3],[4,5,6]] )
print(a)
# [[1 2 3]
[4 5 6]]
# 方法二 ：使用元組創建numpy數組
# 元組轉數組
# 元組中有元組時，轉數組時，首先將逗號“，”全部變為空格“ ”，以最外層[]中的逗號“，”以換行分開成為數組的第一維度的不同成員（元素）
arr = ((1,2),(3,4))
arr0 =np.array(arr)
print(arr0)
# [[1 2]
[3 4]]
3.數組中的維
數組中的維是數組深度（嵌套數組）的一個級別，嵌套數組是將數組作為元素的數組，即數組中有數組。
(1)0-D維數組
0維數組，也稱作標量，是指數組中只有一個元素，數組的值只有一個
a= 61
arr = np.array(a)
print(a) # 61
print(type(arr)) # <class 'numpy.ndarray'>
print(arr.shape) # ()
(2)1-D維數組
一維數組，是指元素為0-D數組的數組，也就是由多個元素值構成的數組
a = [61,62,63]
arr = np.array(a)
print(arr) # [61 62 63]
print(arr.type) # (3,)
(3)2-D維數組
二維數組，它的元素為一維數組，它是一維數組的數組，通常用於表示矩陣或者二階張量，在Numpy庫中又一個專門用於矩陣運算的完整子模塊，numpy.mat。
arr = np.array([[1, 2, 3], [4, 5, 6]]) # 列表轉數組，數組的第一維度元素以最外層列表元素以行分隔
print(arr) # [[1 2 3]
[4 5 6]]
(3)3-D維數組
三維數組，它的元素為二維數組，它是二維數組的數組。
# 用兩個二維數組，創建一個三維數組
arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(arr) # [[[ 1 2 3]
[ 4 5 6]]
[[7 8 9]
[10 11 12]]]
print(arr.shape) # (2,2,3) # 數組每個維度的元素個數是shape的由外到內，如：第一維2個元素是：[[ 1 2 3] 和 [[7 8 9]
[ 4 5 6]] [10 11 12]]
（4）如何得到數組的維數？
NumPy 數組提供了 ndim 屬性，該屬性返回一個整數，該整數會告訴我們數組有多 少維，檢查數組有多少維：
a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])
print(a.ndim) # 0
print(b.ndim) # 1
print(c.ndim) # 2
print(d.ndim) # 3
（5）創建更高維的數組
數組可以擁有任意數量的維，在創建數組時，可以使用 ndmin 參數定義維數。
# 創建一個有5個維度的數組，並驗證它擁有5個維度：
arr = np.array([1, 2, 3, 4], ndmin=)
print(arr) # [[[[[1 2 3 4]]]]]
print('number of dimensions :', arr.ndim) # number of dimensions : 5
說明：在這個5維數組中，最里面的一維，也就是第5個維度，有4個元素1234，第四個維度 有1個元素作為向量[1 2 3 4]，第三個維度的元素是矩陣[[1 2 3 4]],也就是元素為2維數組，第2維度有1個元素是3維數組，第一個維度有1個元素，該元素是四維數組。
4.數組中的索引和裁切
(1)訪問數組元素
數組索引等同於訪問數組元素，我們通過引用索引號來訪問數組元素，Numpy中的數組的索引以0開始，即第一個元素的索引為0.第二個元素的索引為1、
# 一維數組
arr = np.array([1, 2, 3, 4])
print(arr[1]) # 2
# 二維數組或者更高維數組
要訪問二維數組或者更高維數組中的元素，我們可以使用逗號分隔的整數表示元素的維數和索引或者用數組的每個維度的索引號。
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print(arr[1, 4]) # 10 表示第一維度中的第2個元素（即[6,7,8,9,10]）的第5個元素
或者
print(arr[1][4]) # 10
更高維類似
# 使用負索引從尾開始訪問數組
arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])
print(arr[1,-1]) # 10
(2)數組的裁切（相當於列表和元組的切片）
Python中的裁切是指將元素從一個給定的索引帶到另一個給定的索引，也就是切片的意思，以冒號“：”來傳遞，包含開始索引start,但是不包含結束索引end。
我們像這樣定義切片而不是索引：[start：end]。
我們還可以定義步長，如下所示：[start：end：step]。
如果我們不設置 start，則將其視為 0,即從索引號為0的元素開始索引。
如果我們不設置 end，則視為該維度內數組的長度，即一直索引到該維度的最后一個元素。
如果我們不設置start和end，則視為從索引號0的元素開始一直到最后一個元素
如果我們不設置 step，則視為 1。
# 從下面的數組中裁切索引 1 到索引 5 的元素
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[1:5]) # [2 3 4 5]
print(arr[:4]) # [1 2 3 4]
# 設置步長剪切
print(arr[1:5:2]) # [2 4]
# 返回數組中相隔的元素
print(arr[::2]) #[1,3,5,7]
# 數組的負裁切
使用減號運算符從末尾開始引用索引：
arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[-3:-1]) # [5 6]
# 二維數組的裁切
# 從第二個元素開始，對從索引 1 到索引 4（不包括）的元素進行切片
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[1, 1:4]) # [7 8 9]，即 第一維度的第二個元素（即[6, 7, 8, 9, 10]）的索引號從1到4（不包括4）的元素
#從兩個元素中返回索引 2：
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[0:2, 2]) # [3 8]，即第一維度的第1個元素和第2個元素的各自的索引號為2的元素
#從兩個元素裁切索引 1 到索引 4（不包括），這將返回一個 2-D 數組：
arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(arr[0:2, 1:4]) # [[2 3 4] ，即維度的索引從0:2(2不包括)的元素 的各自的索引號從1到
[7 8 9]]
4（不包括4）的元素
總結：列表和元組都可以轉換為數組，列表是可變序列，有增加刪除修改元素值的方法，元組是不可序列，列表和元組沒有shape屬性，它的大小是元素的個數，數組有形狀shape,有shape屬性，可以通過array.shape獲取數組的形狀大小shape，不管是列表、元組、數組的索引切片，都是左閉右開形式。我們可以通過print(type(x))來判別X是列表還是元組或者是數組。
附加：
# 1.兩個列表轉數組和數組的轉置
a = [1,2]
print(len(a))
b = [3,4]
print(len([a,b])) # 2 列表元素個數，以最外層的[],中的逗號分開
# 單列表轉數組時，將逗號消除
K = np.array(b)
print(K)
#顯示數組的維度的兩種方法: print(np.shape（h）) 或者print(h.shape)
print(K.shape)
print(np.shape(K))
# 一維數組轉置是其本身
print(np.array(b).T)
# 列表中有列表時，轉數組時，將逗號消除，每個列表以換行分開
c = np.array([a,b])
print(c)
"""
[[1 2]
[3 4]]
"""
# 二維數組轉置行和列交換
d = c.T
"""
[[1 3]
[2 4]]
"""
print(d)
# 2.單個列表轉數組
e = [[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19]]
print(type(e)) # <class 'list'>
f = np.array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19]])
print(type(f)) # <class 'numpy.ndarray'>
print(f)
"""
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
"""
# 數組的轉置 行變成列 列變成行
print(f.T)
"""
[[ 0 5 10 15]
[ 1 6 11 16]
[ 2 7 12 17]
[ 3 8 13 18]
[ 4 9 14 19]]
"""
# 3. 列表轉數組的拼接
g = [[10,20]]
h = [[1,0],[2,0],[3,0],[4,0]]
score = np.array(g)
boundingbbox = np.array(h)
print(score)
print(boundingbbox)
print(np.shape(score))
print(np.shape(boundingbbox))
print("\n")
M = score.T
N = boundingbbox.T
print(np.shape(M))
print(np.shape(N))
print(M)
print(N)
# np.concatenate() 數組拼接
# 進行列堆疊的時候要保證兩個數組的行維度元素個數相同
# 進行行堆疊的時候要保證兩個數組的列維度元素個數相同
rectangles = np.concatenate((N,M), axis=1)
print(rectangles)
更多有關python、深度學習和計算機編程和電腦知識的精彩內容，可以關注微信公眾號：碼農的后花園
