切片

取一個list或tuple的部分元素是非常常見的操作

有一個list[0,1,2,3,4,5]如果我們要取前n個元素比如說3個數

一般做法是

>>> L=[]
>>> n=3
>>> for i in range(n):
...  L.append(list[i])
...
>>> L
[0, 1, 2]

對這種經常取指定索引範圍的操作，用迴圈十分繁瑣，因此，Python提供了切片（Slice）操作符，能大大簡化這種操作

得到整個list

>>> list[:]
[0, 1, 2, 3, 4, 5]
 

獲得list中指定位置間元素如下 list[0:1]指從索引0到1 但是不包含1，包頭不包尾，同時如果第一個是0可以省略

>>> list[0:1]
[0]
>>> list[:1]
[0]

Python支援L[-1]取倒數第一個元素，同樣支援倒數切片list[-5:-1] 代表從-5位置到-1位置但是不包含-1，-1的元素就是 list最後一個元素

>>> list[-2:]
[4, 5]
>>> list[-5:]
[1, 2, 3, 4, 5]
>>> list[-5:-1]
[1, 2, 3, 4]
 

間隔取值前5個數，每兩個取一個：

>>> list[:5:2]
[0, 2, 4]

tuple也是一種list，唯一區別是tuple不可變。因此，tuple也可以用切片操作，只是操作的結果仍是tuple

>>> tuple=(1,2,3)
>>> tuple[:]
(1, 2, 3)

Python沒有針對字串的擷取函式，只需要切片一個操作就可以完成，非常簡單

>>> str='HELLO'
>>> str[:]
'HELLO'
>>> str[:3]
'HEL'
>>> str[2:]
'LLO'
 

利用切片操作，實現一個trim()函式，去除字串首尾的空格，注意不要呼叫str的strip()方法：

# -*- coding: utf-8 -*-
def trim(s):
  if s[:1]!=' ' and s[-1:]!=' ':
  return s
 else:
  while s[:1]==' ':
   s=s[1:]
  while s[-1:]==' ':
   s=s[:-1]
  print(s)
  return s

# 測試:
if trim('hello  ') != 'hello':
    print('測試失敗!')
elif trim('  hello') != 'hello':
    print('測試失敗!')
elif trim('  hello  ') != 'hello':
    print('測試失敗!')
elif trim('  hello  world  ') != 'hello  world':
    print('測試失敗!')
elif trim('') != '':
    print('測試失敗!')
elif trim('    ') != '':
    print('測試失敗!')
else:
    print('測試成功!')

hello 
hello 
hello 
hello  world 

測試成功! 

迭代

在Python中，迭代是通過for ... in來完成的 java中迭代list是通過下標完成的

Python的for迴圈抽象程度要高於C的for迴圈，因為Python的for迴圈不僅可以用在list或tuple上，還可以作用在其他可迭代物件上。

list這種資料型別雖然有下標，但很多其他資料型別是沒有下標的，但是，只要是可迭代物件，無論有無下標，都可以迭代，比如dict就可以迭代

>>> map={'key1':1,'key2':2,'key3':3}
>>> for key in map:
...  print(key)
...
key1
key2
key3

同時迭代key和value，可以用for k, v in d.items()

>>> for key , value in map.items():
...  print(key,'---',value)
...
key1 --- 1
key2 --- 2
key3 --- 3

所以，當我們使用for迴圈時，只要作用於一個可迭代物件，for迴圈就可以正常執行，而我們不太關心該物件究竟是list還是其他資料型別。

那麼，如何判斷一個物件是可迭代物件呢？方法是通過collections模組的Iterable型別判斷

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整數是否可迭代
False

最後一個小問題，如果要對list實現類似Java那樣的下標迴圈怎麼辦？Python內建的enumerate函式可以把一個list變成索引-元素對，這樣就可以在for迴圈中同時迭代索引和元素本身：

>>> for i,v in enumerate([1,2,3]):
...  print(i,v)
...
0 1
1 2
2 3
>>>

for迴圈中引用多個變數

>>> for a,b,c in [(1,2,3),(2,3,4),(4,5,6)]:
...  print(a,b,c)
...
1 2 3
2 3 4
4 5 6

練習：用迭代查詢一個list中最小和最大值，並返回一個tuple

# -*- coding: utf-8 -*-
def findMinAndMax(L):
 if len(L)==0:
  return (None,None)   
 elif len(L)==1:
  return (L[0],L[0])
 else:
  min=L[0]
  max=L[0]
  for x in L:
   if min>x:
    min=x
   if max<x:
    max=x
  return (min,max)

# 測試
if findMinAndMax([]) != (None, None):
    print('測試失敗!')
elif findMinAndMax([7]) != (7, 7):
    print('測試失敗!')
elif findMinAndMax([7, 1]) != (1, 7):
    print('測試失敗!')
elif findMinAndMax([7, 1, 3, 9, 5]) != (1, 9):
    print('測試失敗!')
else:
    print('測試成功!')

列表生成式

List Comprehensions，是Python內建的非常簡單卻強大的可以用來建立list的生成式。

舉個例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))：

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎麼做？方法一是迴圈：

>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

而列表生成式則可以用一行語句代替迴圈生成上面的list

>>> [x*x for x in range(1,11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

for迴圈後面還可以加上if判斷，這樣我們就可以篩選出僅偶數的平方：

>>> [x*x for x in range(1,11) if x%2==0]
[4, 16, 36, 64, 100]

還可以使用兩層迴圈，可以生成全排列：

>>> [x+y for x in 'abc' for y in 'xyz']
['ax', 'ay', 'az', 'bx', 'by', 'bz', 'cx', 'cy', 'cz']

當然同樣可以在後面新增if判斷條件

>>> [x+y for x in 'abc' for y in 'xyz' if x+y!='ax']
['ay', 'az', 'bx', 'by', 'bz', 'cx', 'cy', 'cz']

列表生成式也可以使用兩個變數來生成list

>>> map={'key1':1,'key2':2,'key3':3}
>>> [key+':'+str(value) for key,value in map.items()]
['key1:1', 'key2:2', 'key3:3']

把一個list中所有的字串變成小寫

>>> list=['A','B','C']
>>> [s.lower() for s in list]
['a', 'b', 'c']

生成器

通過列表生成式，我們可以直接建立一個列表。但是，受到記憶體限制，列表容量肯定是有限的。而且，建立一個包含100萬個元素的列表，不僅佔用很大的儲存空間，如果我們僅僅需要訪問前面幾個元素，那後面絕大多數元素佔用的空間都白白浪費了

如果列表元素可以按照某種演算法推算出來，那我們是否可以在迴圈的過程中不斷推算出後續的元素呢？這樣就不必建立完整的list，從而節省大量的空間。在Python中，這種一邊迴圈一邊計算的機制，稱為生成器：generator

建立一個generator，有很多種方法。

第一種方法:

只要把一個列表生成式的[]改成()，就建立了一個generator

>>> l=[x for x in range(1,11)]
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> g=(x for x in range(1,11))
>>> g
<generator object <genexpr> at 0x0000000002541750>

建立L和g的區別僅在於最外層的[]和()，L是一個list，而g是一個generator。

我們可以直接打印出list的每一個元素，但我們怎麼打印出generator的每一個元素呢？

如果要一個一個打印出來，可以通過next()函式獲得generator的下一個返回值：

>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
....
>>> next(g)
9
>>> next(g)
10
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

generator儲存的是演算法，每次呼叫next(g)，就計算出g的下一個元素的值，直到計算到最後一個元素，沒有更多的元素時，丟擲StopIteration的錯誤。

一般正確的方法是使用for迴圈，因為generator也是可迭代物件

>>> g=(x for x in range(1,11))
>>> for n in g:
...  print(n)
...
1
2
3
4
5
6
7
8
9
10

第二種方法：

如果推算的演算法比較複雜，用類似列表生成式的for迴圈無法實現的時候，還可以用函式來實現

如果一個函式定義中包含yield關鍵字，那麼這個函式就不再是一個普通函式，而是一個generator：

著名的斐波拉契數列（Fibonacci），除第一個和第二個數外，任意一個數都可由前兩個數相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契數列用列表生成式寫不出來，但是，用函式把它打印出來卻很容易

>>> def fib(max):
...  n,a,b=0,0,1
...  while(n<max):
...   print(b)
...   a,b=b,a+b
...   n=n+1
...
>>> fib(10)
1
1
2
3
5
8
13
21
34
55

其中 a,b=b,a+b 等同於以下

tuple=(b,a+b)
a=tuple[0]
b=tuple[1]

也就是tuple(a,b)=tuple(b,a+b)

要把fib函式變成generator，只需要把print(b)改為yield b就可以了

>>> def fib(max):
...  n,a,b=0,0,1
...  while(n<max):
...   print('start')
...   yield b
...   print('next')
...   a,b=b,a+b
...   n=n+1
...
>>> f=fib(5)
>>> f
<generator object fib at 0x00000234065216D8>
>>> next(f)
start
1
>>> next(f)
next
start
1
>>> next(f)
next
start
2
>>> next(f)
next
start
3
>>> next(f)
next
start
5
>>> next(f)
next
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

函式是順序執行，遇到return語句或者最後一行函式語句就返回。而變成generator的函式，在每次呼叫next()的時候執行，遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。

如上明顯發現第一次的時候只輸出start就返回1 證明執行到yield的時候生成器就返回了，第二次執行首先輸出next再輸出start，說明函式繼續執行了第一次yield後面的程式碼，再執行下一次

直到計算到最後一個元素，沒有更多的元素時，丟擲StopIteration的錯誤。

同樣我們一般會使用迴圈取值

>>> for x in fib(5):
...  print(x)
...
start
1
next
start
1
next
start
2
next
start
3
next
start
5
next

迭代器

我們已經知道，可以直接作用於for迴圈的資料型別有以下幾種：

一類是集合資料型別，如list、tuple、dict、set、str等；

一類是generator，包括生成器和帶yield的generator function。

這些可以直接作用於for迴圈的物件統稱為可迭代物件：Iterable。

可以使用isinstance()判斷一個物件是否是Iterable物件：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但可以作用於for迴圈，還可以被next()函式不斷呼叫並返回下一個值，直到最後丟擲StopIteration錯誤表示無法繼續返回下一個值了。

可以被next()函式呼叫並不斷返回下一個值的物件稱為迭代器：Iterator。

可以使用isinstance()判斷一個物件是否是Iterator物件：

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator物件，但list、dict、str雖然是Iterable，卻不是Iterator。

把list、dict、str等Iterable變成Iterator可以使用iter()函式：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能會問，為什麼list、dict、str等資料型別不是Iterator？

這是因為Python的Iterator物件表示的是一個數據流，Iterator物件可以被next()函式呼叫並不斷返回下一個資料，直到沒有資料時丟擲StopIteration錯誤。可以把這個資料流看做是一個有序序列，但我們卻不能提前知道序列的長度，只能不斷通過next()函式實現按需計算下一個資料，所以Iterator的計算是惰性的，只有在需要返回下一個資料時它才會計算。

Iterator甚至可以表示一個無限大的資料流，例如全體自然數。而使用list是永遠不可能儲存全體自然數的。

小結

凡是可作用於for迴圈的物件都是Iterable型別；

凡是可作用於next()函式的物件都是Iterator型別，它們表示一個惰性計算的序列；

集合資料型別如list、dict、str等是Iterable但不是Iterator，不過可以通過iter()函式獲得一個Iterator物件。

Python的for迴圈本質上就是通過不斷呼叫next()函式實現的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

實際上完全等價於：

# 首先獲得Iterator物件:
it = iter([1, 2, 3, 4, 5])
# 迴圈:
while True:
    try:
        # 獲得下一個值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出迴圈
        break