python中列表是一種有序的資料結構，可以根據座標取值，用[]表示。內部元素用逗號隔開，裡面可以放大多數的資料結構，比如：字元、數字、列表、元祖、字典等等
列表的增刪改查，以及列表的常用方法必須熟記於心

1. 建立列表

空列表：

非空列表：

2.遍歷列表

兩種方式：基於值遍歷和基於座標遍歷
遍歷值：

基於座標遍歷：

3.訪問列表

通過下標：

程式碼示例：倒序輸出列表元素

>>> a= [-1,2,3,-3,0,-5,5]
>>> for i in range(len(a)-1,-1,-1):
...     print(a[i])
...
 

程式碼示例：正序輸出奇數座標的值

>>> a= [-1,2,3,-3,0,-5,5]
>>> for i in range(1,len(a),2):
...     print(a[i])
...
2
-3
-5

程式碼示例：正序輸出偶數座標的值

>>> a= [-1,2,3,-3,0,-5,5]
>>> for i in range(0,len(a),2):
...     print(a[i])
...
-1
3
0
5

通過切片：正序、倒序、間隔

4.更新列表

索引直接修改

>>> a = [100, 2, 3, -3, 0, -5, 5]
>>> a[0]=1
>>> a
[1, 2, 3, -3, 0, -5, 5]
>>> a[-1]=-1
>>> a
[1, 2, 3, -3, 0, -5, -1]
 

append()：在列表的最後追加元素

>>> a = [1,2,3,4]
>>> a.append(2222)
>>> a
[1, 2, 3, 4, 2222]

insert(index,element):在index指定的位置插入元素element

>>> a = [1,2,3,4]
>>> a.insert(0,0)
>>> a
[0, 1, 2, 3, 4]
>>> a.insert(-1,222)
>>> a
[0, 1, 2, 3, 222, 4]
 

如果insert第一個引數指定的下標越界的話會將第二個元素放在最後

切片賦值：可多可少可正好

a = [[-1, -2], 2, 3, -3, 0, -5, 5]
>>> a
[[-1, -2], 2, 3, -3, 0, -5, 5]
>>> a[0:2]=[1,2,3]
>>> a
[1, 2, 3, 3, -3, 0, -5, 5]
>>> a[0:2]=[-1]
>>> a
[-1, 3, 3, -3, 0, -5, 5] 

5.刪除列表

兩種方法：
1.del刪除列表中元素或者整個列表
2.remove()刪除指定元素

del刪除列表中某個元素

>>> a=[1,2,3,4]
>>> del a[0]
>>> a
[2, 3, 4]

del刪除整個列表

>>> a=[1,2,3,4]
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

remove(element)刪除指定元素

程式碼示例：根據出現次數刪除

>>> a= [1,1,1,1,1,2,3]
>>> for i in range(a.count(1)):
...     a.remove(1)
...
>>> a
[2, 3]

程式碼示例：死迴圈刪除

>>> a= [1,1,1,1,1,2,3]
>>> while 1:
...     try:
...         a.remove(1)
...     except:
...         break
...

6.列表操作函式(僅對列表有用)：

方法	作用
append(obj)	在列表的末尾新增物件obj
insert(index,obj)	在index處插入物件obj,如果index指定的下標越界的話會將obj放在列表的最後
remove(obj)	移除列表中第一次出現的obj，一次只能刪除一個
pop(index)	移除列表中的一個元素並返回該元素的值(預設是最後一個)
index(obj)	從列表中找出obj出現的第一個位置，未找到拋異常
count(obj)	統計元素obj在列表中出現的次數
extend(seq)	在列表的末尾一次性追加另一個序列中的多個值
（用新列表擴充套件原來的列表）
reverse()	對列表元素反轉，是原地操作
sort()	對列表進行原地排序，根據ASCII碼從大到小進行

7.列表複製

引用（變數a=變數b）指的是操作的同一個物件，複製（[:]模式）指完全復
制一個新的物件

引用複製：a和b指向同一記憶體空間

變數a = 變數b

列表的*也是引用複製

>>> a = [[]*3]*3
>>> a
[[], [], []]
>>> a[0].append(1)
>>> a
[[1], [1], [1]]

非引用複製[:]：a和b記憶體空間不一致

8.推導列表

[]中只能是for迴圈，if和表示式

>>> [x for x in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [x for x in range(1,11,2)]
[1, 3, 5, 7, 9]
>>> [x for x in range(0,11,2)]
[0, 2, 4, 6, 8, 10]
>>> [x**2 for x in range(9)]
[0, 1, 4, 9, 16, 25, 36, 49, 64]

程式碼示例：將字典轉換為列表

d = {'x': 'A', 'y': 'B', 'z': 'C' }
print ([k + '=' + v for k, v in d.items()])

程式碼示例：大寫字母轉小寫生成新的列表

L = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s in L])

程式碼示例：二維矩陣的轉置

a=[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]
print([[j[i] for j in a] for i in range(3)])

程式碼示例：刪除二維矩陣的某一列

a=[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]
print ([[i[j] for j in [1,2]] for i in a])

for i in a：遍歷列表的每一行
for j in [1,2]：遍歷列表的第二列和第三列
j分別取1,2代表列表的第二列和第三列
[i[j] for j in [1,2]]：
表示每一行的第二列和第三列元素，存到子列表中

9.sort()函式

定義：

>>> help([1].sort)
Help on built-in function sort:

sort(...) method of builtins.list instance
    L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

作用：對原序列進行排序，也就是直接在原序列上操作，沒有返回值
引數說明：
key：也是一個函式，這個函式會從每個元素中提取一個用於比較的關鍵字。預設值為None。
reverse：接受False或者True，表示是否逆序。如設定為True，表示逆序。

程式碼示例：按序列的個數長度降序排列

list9=[(1,5,3),(1,3,6,3),(1,1,2,4,5,6),(1,9)]
def L(tup):
    return len(tup)

list9.sort(key=L,reverse=True)
print (list9)

程式碼示例：使用元組最後一個元素的大小比較實現list排序

list9=[(1,5,3),(1,3,6,3),(1,1,2,4,5,6),(1,9)]
def L(tup):
    return tup[-1]

list9.sort(key=L,reverse=True)
print (list9)

10.sorted()函式

對列表進行排序，返回一個新的列表，原列表的值不變
定義：sorted(iterable[, cmp[, key[, reverse]]]）
函式引數：
1）iterable：是可迭代型別型別;
2）cmp：用於比較的函式，比較什麼由key決定,有預設值，迭代集合中的
一項;
3）key：用列表元素的某個屬性和函式進行作為關鍵字，有預設值，迭代
集合中的一項;
4）reverse：排序規則. reverse = True 或者 reverse = False，有預設值，
預設為升序排列（False）。
程式碼示例：

>>> a = [3,8,0,6,1,9]
>>> sorted(a)#升序
[0, 1, 3, 6, 8, 9]
>>> a
[3, 8, 0, 6, 1, 9]
>>> sorted(a,reverse = True)#降序
[9, 8, 6, 3, 1, 0]
>>> a
[3, 8, 0, 6, 1, 9]

>>> sorted(a,key=lambda x:len(x))
[(1, 9), (1, 5, 3), (1, 3, 6, 3), (1, 1, 2, 4, 5, 6)]
>>> sorted(a,key=lambda x:x[-1])
[(1, 5, 3), (1, 3, 6, 3), (1, 1, 2, 4, 5, 6), (1, 9)]
>>>

11.迭代器

優點：節省空間，不需要一下取出所有的資料時可以用迭代器。
迭代器最基本的方法：iter()和__next__()方法
➢ 一個用來獲得迭代器物件
➢ 一個用來獲取容器中的下一個元素

使用迭代器的兩種方法：
1.it.next()
2.next(it)

程式碼示例1：d.next()

#encoding=utf-8
a = iter([1,2,3,4])
print(next(a))
print(next(a))

程式碼示例2：next(it)

#encoding=utf-8
li=[5,6,7]
#li=(5,6,7)
it=iter(li)
print (it)
print (it.__next__())#物件的內建方法
print (it.__next__())
print (it.__next__())
print (it.__next__()) 

以上的程式碼也不省空間，因為列表已經生成了

字典的迭代，預設的是迭代的字典的key：
print(type(iter({1:‘1’,2:‘2’,3:‘3’})))
#<dict_keyiterator object at 0x00000235CAC22F98>
print(type(iter({1:‘1’,2:‘2’,3:‘3’}.values())))<class ‘dict_valueiterator’>

自定義的迭代器：

#encoding=utf-8
class MyRange(object):
    def __init__(self, n):
        self.idx = 0
        self.n = n

    def __iter__(self):
        return self#返回自己

    def __next__(self):
        if self.idx < self.n:
            val = self.idx
            self.idx += 1
            return val
        else:
            raise StopIteration()

myRange = MyRange(3)
print (next(myRange))
print (next(myRange))
print (next(myRange))

12.生成器

在Python中，這種一邊迴圈一邊計算的機制，稱為生成器（Generator）
優點：節省空間
兩種方式：（）或yield

程式碼示例1：（）

L= [x*x for x in range(10)]
print(L)
g = (x*x for x in range(10))
print (g)

print (next(g))
print (next(g))
print (next(g))
print (next(g))

for i in g:
      print (i)

程式碼示例：yield

def odd():
    print ('step 1')
    yield 1
    print ('step 2')
    yield 3
    print ('step 3')
    yield 5
o = odd()
print (next(o))
print (next(o))
print (next(o))
print (next(o))

#for i in o:
#    print i 

迭代器和生成器的區別：
1.迭代器需要實現對應的__iter__()和__next__()方法。對於可迭代物件，for語句可以通過iter()方法獲取迭代器，並且通過next方法獲得容器的下一個元素。
2.生成器是一種特殊的迭代器，不需要明確定義__iter__()和__next__()方法
3.生成器通過生成器函式產生，生成器函式可以通過常規的def語句來定義，但是不用return返回，而是用yield一次返回一個結果

13.列舉

同時獲得標號和元素

#encoding=utf-8
for i ,value in enumerate(['A','B','C']):
      print(i,value)

14.深淺拷貝

Python中的物件之間賦值時是按引用傳遞的，如果需要拷貝物件，需要使用標準庫中的copy模組。
淺拷貝（copy.copy()):生成了新的列表，每個元素指向原列表中的地址
深拷貝（copy.deepcopy()):生成了新的列表，每個元素都是新的
程式碼示例：

#encoding = utf-8
import copy
a = [1, 2, 3, 4, 5, ['a', 'b']]  # 原始物件
b = a  # 賦值，傳物件的引用
c = copy.copy(a)  # 物件拷貝，淺拷貝
d = copy.deepcopy(a)  # 物件拷貝，深拷貝
a.append(6)  # 修改物件a
a[5].append('c')  # 修改物件a中的['a', 'b']陣列物件
print ('a = ', a)
print ('b = ', b)
print ('c = ', c)
print ('d = ', d)

15.通過list實現堆疊（後進先出）

通過List實現一個堆疊，堆疊就是儲存資料的一種資料結構，後存入的數
據，會被先取出
程式碼示例：’’‘list實現堆疊：pop()’’’

stack = [3, 4, 5]
stack.append(6)
stack.append(7)
print (stack)
print (stack.pop())
print (stack)
print (stack.pop())
print (stack.pop())
print (stack)

16.通過list實現佇列（先進先出）

程式碼示例：’’‘list實現佇列：pop(0)’’’

stack = [3, 4, 5]
stack.append(6)
stack.append(7)
print (stack.pop(0))
print (stack.pop(0))
print (stack.pop(0))

程式碼示例：deque

#encoding=utf-8
from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")           # Terry arrives
queue.append("Graham")          # Graham arrives
print (queue.popleft())                # The first to arrive now leaves
print (queue.popleft())                # The second to arrive now leaves
print (queue)                    # Remaining queue in order of arrival