一、列表（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、深度學習和計算機程式設計和電腦知識的精彩內容，可以關注微信公眾號：碼農的後花園