列表與元組

標準數據類型--列表

列表是一種有序的可變容器，且可存儲任意類型數據。列表是有序的，列表是序列的一種，每一個元素都對應一個索引值，索引值是從0開始的天然整數。列表中每一個元素之間用"," 分隔。

• 初始化建立
  tmplist = []
  tmplist = ['a',123,[9,8]]
  tmplist = list(iterable)
  例如：

In [1]: a=[]                                                                                                

In [2]: type(a)                                                                                             
Out[2]: list

In [3]: a1=['a','b']

• 增長元素
  append(value)
  extend(iterable)
  insert(index,object)
  列如:

In [6]: a.append('b')                                                                                       

In [7]: a.extend('hello')              \\批量增長                                                                       

In [8]: a                                                                                                   
Out[8]: ['b', 'h', 'e', 'l', 'l', 'o']

In [9]: a.insert(2,'c')                                                                                     

In [10]: a                                                                                                  
Out[10]: ['b', 'h', 'c', 'e', 'l', 'l', 'o']

• 刪除元素

remove(value) 注僅刪除第一次出如今元素
pop([index]) 刪除最後一個列表元素並返回最後一個元素

列如：

In [11]: a                                                                                                  
Out[11]: ['b', 'h', 'c', 'e', 'l', 'l', 'o']

In [12]: a.remove('h')        

In [14]: a.pop(2)                                                                                           
Out[14]: 'e'

In [15]: a                                                                                                  
Out[15]: ['b', 'c', 'l', 'l', 'o']

• 查看元素

[] 使用切片查看
index(value, [start, [stop]]) 查看某一元素索引
count(value) 查看某一元素個數
len(tmplist) 查看列表長度

列如：

In [20]: a[:]                                                                                               
Out[20]: ['b', 'c', 'l', 'l', 'o']

In [21]: a.index('c')                                                                                       
Out[21]: 1
In [24]: a.count('b')                                                                                       
Out[24]: 1

In [25]: len(a)                                                                                             
Out[25]: 5

• 排序
  sort()
  sum
  min
  max
  len
  del
  type
  id

列如：

n [29]: a                                                                                                  
Out[29]: [2, 3, 1, 5, 8, 9]

In [30]: a.sort()                                                                                           

In [31]: a                                                                                                  
Out[31]: [1, 2, 3, 5, 8, 9]

In [33]: type(a)                                                                                            
Out[33]: list

In [34]: sum(a)                                                                                             
Out[34]: 28

In [35]: len(a)                                                                                             
Out[35]: 6

In [36]: min(a)                                                                                             
Out[36]: 1

In [37]: del(a)

• 關係判斷

in
not in

列如:

In [40]: a=[1,2,3,'a']                                                                                                        

In [41]: a                                                                                                                    
Out[41]: [1, 2, 3, 'a']

In [42]: 'a' in a                                                                                                             
Out[42]: True

In [43]: 1 not in a                                                                                                           
Out[43]: False

• 深拷貝淺拷貝

L1 = L 淺拷貝L和L1會互相影響至關於硬連接。
L2 = L[:] 深拷貝L2 會徹底複製一份L,以後兩都毫無關係

列如：

In [44]: a                                                                                                                    
Out[44]: [1, 2, 3, 'a']

In [45]: a1 = a                                                                                                               

In [46]: a1                                                                                                                   
Out[46]: [1, 2, 3, 'a']

In [47]: a.append('b')                                                                                                        

In [48]: a                                                                                                                    
Out[48]: [1, 2, 3, 'a', 'b']

In [50]: a1                                                                                                                   
Out[50]: [1, 2, 3, 'a', 'b']

深拷貝

In [51]: a                                                                                                                    
Out[51]: [1, 2, 3, 'a', 'b']

In [52]: a2=a[:]                                                                                                              

In [53]: a.append('c')                                                                                                        

In [54]: a                                                                                                                    
Out[54]: [1, 2, 3, 'a', 'b', 'c']

In [55]: a2                                                                                                                   
Out[55]: [1, 2, 3, 'a', 'b']

標準數據類型--元組

元組是一種有序的不可變容器，且可存儲任意類型數據。元組是有序的，每一個元素都對應一個索引值，索引值是從0開始的天然整數，元組中每一個元素之間用"," 分隔。元組就是一個只讀的列表。

• 初始化建立

In [56]: a=()                                                                                                                 

In [57]: type(a)                                                                                                              
Out[57]: tuple

In [58]: a=tuple('a')                                                                                                         

In [59]: a                                                                                                                    
Out[59]: ('a',)

count(value) 查看元組只某一元素個數index(value, [start, [stop]]) 查看元組中某一元素索引值