一箩艺、數(shù)據類型

• 整型：計算機由于使用二進制眯分，所以误甚，有時候用十六進制表示整數(shù)比較方便缚甩，十六進制用0x前綴和0-9，a-f表示
• 浮點數(shù)：對于很大或很小的浮點數(shù)窑邦，就必須用科學計數(shù)法表示擅威，把10用e替代啃洋，1.23x10^9就是1.23e9衣洁，或者12.3e8，0.000012可以寫成1.2e-5昆稿，等等瞧筛。
  整數(shù)和浮點數(shù)在計算機內部存儲的方式是不同的厉熟，整數(shù)運算永遠是精確的（除法難道也是精確的？是的＝匣稀）揍瑟，而浮點數(shù)運算則可能會有四舍五入的誤差。
• 字符串：
  字符串是以''或""括起來的任意文本乍炉，比如'abc'绢片，"xyz"等等。請注意岛琼，''或""本身只是一種表示方式底循，不是字符串的一部分，因此衷恭，字符串'abc'只有a此叠，b，c這3個字符。
• 布爾值：布爾值和布爾代數(shù)的表示完全一致灭袁，一個布爾值只有True猬错、False兩種值，要么是True茸歧，要么是False倦炒，在Python中，可以直接用True软瞎、False表示布爾值（請注意大小寫）逢唤，也可以通過布爾運算計算出來。
  布爾值可以用and涤浇、or和not運算鳖藕。
  and運算是與運算，只有所有都為 True只锭，and運算結果才是 True著恩。
  or運算是或運算，只要其中有一個為 True蜻展，or 運算結果就是 True喉誊。
  not運算是非運算，它是一個單目運算符纵顾，把 True 變成 False伍茄，F(xiàn)alse 變成 True。
• 空值：空值是Python里一個特殊的值施逾，用None表示敷矫。None不能理解為0，因為0是有意義的音念，而None是一個特殊的空值沪饺。

二、python之print語句

print語句也可以跟上多個字符串闷愤，用逗號“,”隔開，就可以連成一串輸出：

>>> print 'The quick brown fox', 'jumps over', 'the lazy dog'
The quick brown fox jumps over the lazy dog

print會依次打印每個字符串件余，遇到逗號“,”會輸出一個空格讥脐，因此，輸出的字符串是這樣拼起來的：

image

三啼器、python之變量

• 在Python程序中旬渠，變量是用一個變量名表示，變量名必須是大小寫英文端壳、數(shù)字和下劃線（_）的組合告丢，且不能用數(shù)字開頭。
• 在Python中损谦，等號=是賦值語句岖免，可以把任意數(shù)據類型賦值給變量岳颇，同一個變量可以反復賦值，而且可以是不同類型的變量颅湘。

a = 123    # a是整數(shù)
print a
a = 'imooc'   # a變?yōu)樽址?print a

這種變量本身類型不固定的語言稱之為動態(tài)語言话侧，與之對應的是靜態(tài)語言。

• 理解變量在計算機內存中的表示也非常重要闯参。當我們寫：a = 'ABC'時瞻鹏，Python解釋器干了兩件事情：
  1）在內存中創(chuàng)建了一個'ABC'的字符串；
  2）在內存中創(chuàng)建了一個名為a的變量鹿寨，并把它指向'ABC'新博。
  也可以把一個變量a賦值給另一個變量b，這個操作實際上是把變量b指向變量a所指向的數(shù)據脚草。

四叭披、python之字符串

定義字符串

• 如果字符串本身包含'怎么辦？比如我們要表示字符串 I'm OK 玩讳，這時涩蜘，可以用" "括起來表示：

"I'm OK"

• 類似的，如果字符串包含"熏纯，我們就可以用' '括起來表示：

'Learn "Python" in imooc'

• 如果字符串既包含'又包含"同诫，就需要對字符串的某些特殊字符進行“轉義”，Python字符串用\進行轉義樟澜。

'Bob said \"I\'m OK\".'

由于 ' 和 " 會引起歧義误窖，因此，我們在它前面插入一個\表示這是一個普通字符秩贰，不代表字符串的起始霹俺。
注意：轉義字符\不計入字符串的內容中。

• 常用的轉義字符還有：
  \n 表示換行
  \t 表示一個制表符
  \\ 表示\字符本身

raw字符串與多行字符串

• 如果一個字符串包含很多需要轉義的字符毒费，對每一個字符都進行轉義會很麻煩丙唧。為了避免這種情況，我們可以在字符串前面加個前綴 r 觅玻，表示這是一個raw字符串想际，里面的字符就不需要轉義了。
• 但是r'...'表示法不能表示多行字符串溪厘，也不能表示包含'和"的字符串胡本。
• 如果要表示多行字符串，可以用'''...'''表示：

print '''Line 1
Line 2
Line 3'''

上面這個字符串的表示方法和下面的是完全一樣的：

print 'Line 1\nLine 2\nLine 3'

• 還可以在多行字符串前面添加r畸悬，把這個多行字符串也變成一個raw字符串：

r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''

unicode字符串

• 因為計算機只能處理數(shù)字侧甫，如果要處理文本，就必須先把文本轉換為數(shù)字才能處理。最早的計算機在設計時采用8個比特（bit）作為一個字節(jié)（byte）披粟，所以咒锻，一個字節(jié)能表示的最大的整數(shù)就是255（二進制11111111=十進制255），0 - 255被用來表示大小寫英文字母僻爽、數(shù)字和一些符號虫碉，這個編碼表被稱為ASCII編碼，比如大寫字母A的編碼是65胸梆，小寫字母z的編碼是122敦捧。
• 如果要表示中文，顯然一個字節(jié)是不夠的碰镜，至少需要兩個字節(jié)兢卵，而且還不能和ASCII編碼沖突，所以绪颖，中國制定了GB2312編碼秽荤，用來把中文編進去。
• 類似的柠横，日文和韓文等其他語言也有這個問題窃款。為了統(tǒng)一所有文字的編碼，Unicode應運而生牍氛。Unicode把所有語言都統(tǒng)一到一套編碼里晨继，這樣就不會再有亂碼問題了。
• Unicode通常用兩個字節(jié)表示一個字符搬俊，原有的英文編碼從單字節(jié)變成雙字節(jié)紊扬，只需要把高字節(jié)全部填為0就可以。
• 因為Python的誕生比Unicode標準發(fā)布的時間還要早唉擂，所以最早的Python只支持ASCII編碼餐屎，普通的字符串'ABC'在Python內部都是ASCII編碼的。
• Python在后來添加了對Unicode的支持玩祟，以Unicode表示的字符串用u'...'表示腹缩，比如：

>>>print u'中文'
中文

• raw+多行：

ur'''Python的Unicode字符串支持"中文",
"日文",
"韓文"等多種語言'''

• 如果中文字符串在Python環(huán)境下遇到UnicodeDecodeError，這是因為.py文件保存的格式有問題卵凑∏炱福可以在第一行添加注釋

# -*- coding: utf-8 -*-

目的是告訴Python解釋器，用UTF-8編碼讀取源代碼勺卢。
注意：當有注釋的時候，字符串前就不需要加u了象对。

對字符串切片

• 字符串'xxx'和Unicode字符串u'xxx'也可以看成是一種list黑忱，每個元素就是一個字符。因此，字符串也可以用切片操作甫煞，只是操作結果仍是字符串：

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'

五菇曲、python之list

• Python內置的一種數(shù)據類型是列表：list。list是一種有序的集合抚吠，可以隨時添加和刪除其中的元素常潮。
• 構造list非常簡單，按照上面的代碼楷力，直接用[ ]把list的所有元素都括起來喊式，就是一個list對象。
• 由于Python是動態(tài)語言萧朝，所以list中包含的元素并不要求都必須是同一種數(shù)據類型岔留，我們完全可以在list中包含各種數(shù)據：

>>> L = ['Michael', 100, True]

倒序訪問list

• 可以用-1這個索引來表示最后一個元素：

>>> print L[-1]
Bart

類似的，倒數(shù)第二用-2表示检柬，倒數(shù)第三用-3表示献联，倒數(shù)第四用-4表示

添加新元素

• 第一個辦法是用list的append()方法，把新同學追加到list的末尾：

>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.append('Paul')
>>> print L
['Adam', 'Lisa', 'Bart', 'Paul']

• 添加到其他位置何址，用list的insert()方法里逆，它接受兩個參數(shù)，第一個參數(shù)是索引號用爪，第二個參數(shù)是待添加的新元素：

>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.insert(0, 'Paul')
>>> print L
['Paul', 'Adam', 'Lisa', 'Bart']

刪除元素

• 如果是刪除最后一個元素原押，可以用list的pop()方法刪除：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop()
'Paul'
>>> print L
['Adam', 'Lisa', 'Bart']

pop()方法總是刪掉list的最后一個元素，并且它還返回這個元素项钮，所以我們執(zhí)行L.pop()后班眯，會打印出'Paul'。

• 如果是刪除其他位置的元素烁巫，則在pop()函數(shù)中寫入索引下標：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop(2)
'Bart'
>>> print L
['Adam', 'Lisa', 'Paul']

替換元素

• 直接利用索引下標賦值替換：

>>> L = ['Adam', 'Lisa', 'Bart']
>>> L[2] = 'Paul'
>>> print L
L = ['Adam', 'Lisa', 'Paul']

對list進行切片

• 取前3個元素署隘，用一行代碼就可以完成切片：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L[0:3]
['Adam', 'Lisa', 'Bart']

• L[0:3]表示，從索引0開始取亚隙，直到索引3為止磁餐，但不包括索引3。
• 如果第一個索引是0阿弃，還可以省略：

>>> L[:3]
['Adam', 'Lisa', 'Bart']

• 只用一個:诊霹，表示從頭到尾：

>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']

• L[:]實際上復制出了一個新list。
• 切片操作還可以指定參數(shù)：
  1）第一個參數(shù)表示起始位置
  2）第二個參數(shù)表示終止位置
  3）第三個參數(shù)表示間隔數(shù)或第一個參數(shù)的倍數(shù)
  4）這三個參數(shù)渣淳，彼此之間用:隔開
  5）這些參數(shù)脾还，可以省略

>>> L[::2]
['Adam', 'Bart']

• 表示每N個取一個，上面的L[::2]會每兩個元素取出一個來入愧，也就是隔一個取一個鄙漏。
• 把list換成tuple嗤谚，切片操作完全相同，只是切片的結果也變成了tuple怔蚌。

倒序切片

• Python支持L[-1]取倒數(shù)第一個元素巩步，它同樣支持倒數(shù)切片:

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

>>> L[-2:]
['Bart', 'Paul']

>>> L[:-2]
['Adam', 'Lisa']

>>> L[-3:-1]
['Lisa', 'Bart']

>>> L[-4:-1:2]
['Adam', 'Bart']

• 倒數(shù)第一個元素的索引是-1。倒序切片包含起始索引桦踊，不包含結束索引椅野。
• 可以將索引的順序想像成一個x軸。

六籍胯、python之tuple

• tuple是另一種有序的列表竟闪，中文翻譯為“元組”。tuple和list非常類似芒炼，但是瘫怜，tuple一旦創(chuàng)建完畢，就不能修改了本刽。
• 創(chuàng)建tuple和創(chuàng)建list唯一不同之處是用( )替代了[ ]鲸湃。
• tuple沒有append()方法，也沒有insert()和pop()方法子寓。

創(chuàng)建單元素tuple

>>> t = (1)
>>> print t
1

• 這里的t不是tuple暗挑，而是整數(shù)1。因為()既可以表示tuple斜友，又可以作為括號表示運算時的優(yōu)先級炸裆，結果(1)被Python解釋器計算出結果 1，導致我們得到的不是tuple鲜屏，而是整數(shù) 1烹看。
• 正是因為用()定義單元素的tuple有歧義，所以Python規(guī)定洛史，單元素tuple要多加一個逗號“,”惯殊，這樣就避免了歧義：

>>> t = (1,)
>>> print t
(1,)

Python在打印單元素tuple時，也自動添加了一個“,”也殖，為了更明確地告訴你這是一個tuple土思。
多元素tuple加不加這個額外的“,”效果是一樣的：

>>> t = (1, 2, 3,)
>>> print t
(1, 2, 3)

“可變”的tuple

>>> t = ('a', 'b', ['A', 'B'])

注意到t有3個元素：'a'，'b'和一個list：['A', 'B']忆嗜。list作為一個整體是tuple的第3個元素己儒。list對象可以通過t[2]拿到：

>>> L = t[2]

然后，我們把list的兩個元素改一改：

>>> L[0] = 'X'
>>> L[1] = 'Y'

再看看tuple的內容：

>>> print t
('a', 'b', ['X', 'Y'])

看看定義的時候tuple包含的3個元素：

image.png

image.png

七纠修、python之dict

• 花括號{}表示這是一個dict胳嘲，然后按照key: value,寫出來即可。最后一個key: value的逗號可以省略扣草。
• 由于dict也是集合了牛，len()函數(shù)可以計算任意集合的大小：

>>> len(d)
3

訪問dict
可以簡單地使用d[key]的形式來查找對應的value辰妙，這和list很像鹰祸，不同之處是，list必須使用索引返回對應的元素密浑，而dict使用key：

>>> print d['Adam']
95

注意: 通過key訪問dict的value蛙婴，只要key存在，dict就返回對應的value尔破。如果key不存在街图，會直接報錯：KeyError。
要避免KeyError發(fā)生懒构，有兩個辦法：
1餐济、先判斷一下key是否存在，用in操作符：

if 'Paul' in d:
    print d['Paul']

2痴脾、使用dict本身提供的一個get方法颤介，在Key不存在的時候，返回None:

>>> print d.get('Bart')
59
>>> print d.get('Paul')
None

dict的特點

• dict的第一個特點是查找速度快赞赖，無論dict有10個元素還是10萬個元素滚朵，查找速度都一樣。而list的查找速度隨著元素增加而逐漸下降前域。
  不過dict的查找速度快不是沒有代價的辕近，dict的缺點是占用內存大，還會浪費很多內容匿垄，list正好相反移宅，占用內存小归粉，但是查找速度慢。
• 由于dict是按key查找漏峰，所以糠悼，在一個dict中，key不能重復浅乔。
• dict的第二個特點就是存儲的key-value序對是沒有順序的倔喂！這和list不一樣。
  list打印出來的順序也不一定是我們創(chuàng)建時的順序靖苇，并且不同的機器打印的順序都可能不同席噩，這說明dict內部是無序的，不能用dict存儲有序的集合贤壁。
• dict的第三個特點是作為key的元素必須不可變悼枢，Python的基本類型如字符串、整數(shù)脾拆、浮點數(shù)都是不可變的馒索，都可以作為key。但是list是可變的假丧，就不能作為key双揪。
  不可變這個限制僅作用于key，value是否可變無所謂：

{
    '123': [1, 2, 3],  # key 是 str包帚，value是list
    123: '123',  # key 是 int渔期，value 是 str
    ('a', 'b'): True  # key 是 tuple，并且tuple的每個元素都是不可變對象渴邦，value是 boolean
}

更新dict
dict是可變的疯趟，也就是說，我們可以隨時往dict中添加新的key-value谋梭。比如已有dict：

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}

要把新同學'Paul'的成績 72 加進去信峻，用賦值語句：

>>> d['Paul'] = 72

再看看dict的內容：

>>> print d
{'Lisa': 85, 'Paul': 72, 'Adam': 95, 'Bart': 59}

看打印的結果，可再次證明瓮床，dict是無序的盹舞。

如果key已經存在，則賦值會用新的value替換掉原來的value：

>>> d['Bart'] = 60
>>> print d
{'Lisa': 85, 'Paul': 72, 'Adam': 95, 'Bart': 60}

遍歷dict
由于dict也是一個集合隘庄，所以踢步，遍歷dict和遍歷list類似，都可以通過for循環(huán)實現(xiàn)丑掺。
直接使用for循環(huán)可以遍歷dict的key：

>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> for key in d:
...     print key
... 
Lisa
Adam
Bart

由于通過key可以獲取對應的value获印，因此，在循環(huán)體內街州，可以獲取到value的值兼丰。

迭代dict的value

• dict對象本身就是可迭代對象玻孟，用for循環(huán)直接迭代dict，可以每次拿到dict的一個key鳍征。
• 如果希望迭代dict對象的value黍翎，用dict對象的values()方法，這個方法把dict轉換成一個包含所有value的list蟆技，這樣玩敏，我們迭代的就是dict的每一個 value：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.values():
    print v
# 85
# 95
# 59

dict除了values()方法外，還有一個itervalues()方法质礼，用itervalues()方法替代values()方法，迭代效果完全一樣：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()
# <dictionary-valueiterator object at 0x106adbb50>
for v in d.itervalues():
    print v
# 85
# 95
# 59

• 那這兩個方法有何不同之處呢织阳？
  1）values()方法實際上把一個dict轉換成了包含value的list眶蕉。
  2）itervalues()方法不會轉換，它會在迭代過程中依次從dict中取出value唧躲，所以itervalues()方法比values()方法節(jié)省了生成list所需的內存造挽。
  3）打印itervalues()發(fā)現(xiàn)它返回一個<dictionary-valueiterator>對象，這說明在Python中弄痹，for 循環(huán)可作用的迭代對象遠不止 list饭入，tuple，str肛真，unicode谐丢，dict等，任何可迭代對象都可以作用于for循環(huán)蚓让，而內部如何迭代我們通常并不用關心乾忱。

迭代dict的key和value

• 在一個for循環(huán)中，同時迭代key和value历极。
• 在dict對象的items()方法中窄瘟，返回的值：

>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> print d.items()
[('Lisa', 85), ('Adam', 95), ('Bart', 59)]

可以看到，items()方法把dict對象轉換成了包含tuple的list趟卸，我們對這個list進行迭代蹄葱，可以同時獲得key和value：

>>> for key, value in d.items():
...     print key, ':', value
... 
Lisa : 85
Adam : 95
Bart : 59

和values()有一個itervalues()類似，items()也有一個對應的iteritems()锄列，iteritems()不把dict轉換成list图云，而是在迭代過程中不斷給出tuple，所以右蕊，iteritems()不占用額外的內存琼稻。

八、python之set

• set持有一系列元素饶囚，這一點和list很像帕翻，但是set的元素沒有重復鸠补，而且是無序的，這點和dict的key很像嘀掸。
• 創(chuàng)建set的方式是調用set()并傳入一個list紫岩，list的元素將作為set的元素：

>>> s = set(['A', 'B', 'C'])
>>> print s
set(['A', 'C', 'B'])

請注意，上述打印的形式類似list睬塌，但它不是list泉蝌，仔細看還可以發(fā)現(xiàn)，打印的順序和原始list的順序有可能是不同的揩晴，因為set內部存儲的元素是無序的勋陪。

• set不能包含重復的元素，所以硫兰，當我們傳入包含重復元素的list坟募，set會自動去掉重復的元素：

>>> s = set(['A', 'B', 'C', 'C'])
>>> print s
set(['A', 'C', 'B'])
>>> len(s)
3

訪問set

• 由于set存儲的是無序集合惰赋，所以我們沒法通過索引來訪問垫蛆。
• 訪問set中的某個元素實際上就是判斷一個元素是否在set中府蛇。
  我們可以用in操作符判斷：

>>> 'Bart' in s
True

大小寫很重要，'Bart' 和 'bart'被認為是兩個不同的元素泳赋。

set的特點

• set的內部結構和dict很像雌桑，唯一區(qū)別是不存儲value，因此祖今，判斷一個元素是否在set中速度很快校坑。
• set存儲的元素和dict的key類似，必須是不變對象衅鹿，因此撒踪，任何可變對象是不能放入set中的。
• set存儲的元素也是沒有順序的大渤。

遍歷set

• 由于set也是一個集合制妄，所以，遍歷set和遍歷list類似泵三，都可以通過for循環(huán)實現(xiàn)：

>>> s = set(['Adam', 'Lisa', 'Bart'])
>>> for name in s:
...     print name
... 
Lisa
Adam
Bart

注意: for循環(huán)在遍歷set時耕捞，元素的順序和list的順序很可能是不同的，而且不同的機器上運行的結果也可能不同烫幕。

更新set

• 由于set存儲的是一組不重復的無序元素俺抽，因此，更新set主要做兩件事：
  1）把新的元素添加到set中
  2）把已有元素從set中刪除较曼。
• 添加元素時磷斧，用set的add()方法：

>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])

• 如果添加的元素已經存在于set中，add()不會報錯，但是不會加進去弛饭。
• 刪除set中的元素時冕末，用set的remove()方法：

>>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3])

如果刪除的元素不存在set中，remove()會報錯侣颂。
所以用add()可以直接添加档桃，而remove()前需要判斷。

九憔晒、python之函數(shù)

• 在Python中藻肄，定義一個函數(shù)要使用def語句，依次寫出函數(shù)名拒担、括號嘹屯、括號中的參數(shù)和冒號:，然后澎蛛，在縮進塊中編寫函數(shù)體抚垄，函數(shù)的返回值用return語句返回。
• 如果沒有return語句谋逻，函數(shù)執(zhí)行完畢后也會返回結果，只是結果為None桐经。
• return None可以簡寫為return毁兆。

返回多值

import math
def move(x, y, step, angle):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

 x, y = move(100, 100, 60, math.pi / 6)
print x, y #151.961524227 70.0
r = move(100, 100, 60, math.pi / 6)
print r #(151.96152422706632, 70.0)

用print打印返回結果，可以發(fā)現(xiàn)原來返回值是一個tuple阴挣！
在語法上气堕，返回一個tuple可以省略括號，而多個變量可以同時接收一個tuple畔咧，按位置賦給對應的值茎芭，所以，Python的函數(shù)返回多值其實就是返回一個tuple誓沸。

遞歸函數(shù)
使用遞歸函數(shù)需要注意防止棧溢出梅桩。在計算機中，函數(shù)調用是通過棧（stack）這種數(shù)據結構實現(xiàn)的拜隧，每當進入一個函數(shù)調用宿百，棧就會加一層棧幀，每當函數(shù)返回洪添，棧就會減一層棧幀垦页。由于棧的大小不是無限的，所以干奢，遞歸調用的次數(shù)過多痊焊，會導致棧溢出。

默認參數(shù)
由于函數(shù)的參數(shù)按從左到右的順序匹配，所以默認參數(shù)只能定義在必需參數(shù)的后面：

# OK:
def fn1(a, b=1, c=2):
    pass
# Error:
def fn2(a=1, b):
    pass

可變參數(shù)

• 如果想讓一個函數(shù)能接受任意個參數(shù)薄啥，我們就可以定義一個可變參數(shù)：

def fn(*args):
    print args

• 可變參數(shù)的名字前面有個*號辕羽，我們可以傳入0個、1個或多個參數(shù)給可變參數(shù)：

>>> fn()
()
>>> fn('a')
('a',)
>>> fn('a', 'b')
('a', 'b')
>>> fn('a', 'b', 'c')
('a', 'b', 'c')

• Python解釋器會把傳入的一組參數(shù)組裝成一個tuple傳遞給可變參數(shù)罪佳，因此逛漫，在函數(shù)內部，直接把變量args看成一個tuple赘艳。
• 定義可變參數(shù)的目的也是為了簡化調用酌毡。假設我們要計算任意個數(shù)的平均值，就可以定義一個可變參數(shù)：

def average(*args):
    ...

十蕾管、迭代補充

索引迭代

• Python中枷踏，迭代永遠是取出元素本身，而非元素的索引掰曾。
• 有的時候旭蠕，我們想在for循環(huán)中拿到索引，方法是使用enumerate()函數(shù)：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
...     print index, '-', name
... 
0 - Adam
1 - Lisa
2 - Bart
3 - Paul

• 使用enumerate()函數(shù)旷坦，我們可以在for循環(huán)中同時綁定索引index和元素name掏熬。
• 實際上，enumerate()函數(shù)把：

['Adam', 'Lisa', 'Bart', 'Paul']

變成了

[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]

因此秒梅，迭代的每一個元素實際上是一個tuple旗芬。

十一、生成列表

• 要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]捆蜀，我們可以用range(1, 11)：

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

• 如果要生成[1x1, 2x2, 3x3, ..., 10x10]疮丛，方法一是循環(huán)：

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

• 但是循環(huán)太繁瑣，而列表生成式則可以用一行語句代替循環(huán)生成上面的list：

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

• 這種寫法就是Python特有的列表生成式辆它。利用列表生成式誊薄，可以以非常簡潔的代碼生成list。
• 寫列表生成式時锰茉，把要生成的元素x * x放到前面呢蔫，后面跟for循環(huán)，就可以把list創(chuàng)建出來洞辣，十分有用咐刨，多寫幾次，很快就可以熟悉這種語法扬霜。
• 利用列表生成式生成列表 [1x2, 3x4, 5x6, 7x8, ..., 99x100]:

print [i*(i+1) for i in range(1,100,2)]

提示：range(1, 100, 2)可以生成list[1, 3, 5, 7, 9,...]

條件過濾
列表生成式的for循環(huán)后面還可以加上if判斷定鸟。例如：

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

如果我們只想要偶數(shù)的平方，不改動range()的情況下著瓶，可以加上if來篩選：

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

有了if條件联予，只有if判斷為True的時候，才把循環(huán)的當前元素添加到列表中。

多層表達式
for循環(huán)可以嵌套沸久，因此季眷，在列表生成式中，也可以用多層for循環(huán)來生成列表卷胯。
對于字符串 'ABC' 和 '123'子刮，可以使用兩層循環(huán)，生成全排列：

>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

翻譯成循環(huán)代碼就像下面這樣：

L = []
for m in 'ABC':
    for n in '123':
        L.append(m + n)