最近在慕課網(wǎng)學習廖雪峰老師的Python進階課程蒙畴，做筆記總結一下重點映之。
基本變量及其類型
變量
在Python中桅打，能夠直接處理的數(shù)據(jù)類型有以下幾種：
整數(shù)
如-100,0xdf92
浮點數(shù)
如2.55，1.23e9
字符串
字符串是以 ' '或'' ''括起來的任意文本，如'xyz'尾膊，''lmn''
布爾值
在Python中，可以直接用True荞彼、False
表示布爾值（請注意大小寫）冈敛，也可以通過布爾運算計算出來。
布爾值可以用and鸣皂、or和not運算
空值
空值是Python里一個特殊的值抓谴，用None表示。None不能理解為0寞缝，因為0是有意義的癌压，而None是一個特殊的空值
print語句
打印語句
>>>print 'hello, world'
hello, world```
>打印多個字符串
print 'I','love','Python'
I love Python```
打印運算結果
>>>print 2+3
5```
print '100 + 200 =', 100 + 200
100 + 200 = 300 ```
注釋
Python的注釋以 #開頭，后面的文字直到行尾都算注釋
# 這一行全部都是注釋...
print 'hello' # 這也是注釋```
####什么是變量
在Python中荆陆，變量的概念基本上和初中代數(shù)的方程變量是一致的
在Python程序中滩届，**變量**是用一個**變量名**表示，變量名必須是大小寫英文被啼、數(shù)字和下劃線（_）的組合帜消，且不能用數(shù)字開頭
比如：
`a=1`
變量`a`是一個整數(shù)
`t_007 = 'T007'`
變量```t_007```是一個字符串
在Python中，等號`=`是賦值語句浓体，可以把任意數(shù)據(jù)類型賦值給變量泡挺，同一個變量可以反復賦值，而且可以是不同類型的變量命浴。這種變量本身類型不固定的語言稱之為**動態(tài)語言**粘衬，與之對應的是**靜態(tài)語言**。
####定義字符串
* 如果字符串本身包含'怎么辦咳促？比如我們要表示字符串` I'm OK `稚新，這時，可以用`" "`括起來表示：
`"I'm OK"`
* 類似的跪腹，如果字符串包含`"`褂删，我們就可以用`' '`
括起來表示：
`'Learn "Python" in imooc'`
* 如果字符串既包含`'`又包含`"`怎么辦？
這個時候冲茸，就需要對字符串的某些特殊字符進行“轉義”屯阀，Python字符串用` \ `進行轉義
要表示字符串` Bob said "I'm OK".`
由于` ' `和 `" `會引起歧義缅帘，因此，我們在它前面插入一個`\ `表示這是一個普通字符难衰，不代表字符串的起始钦无，因此，這個字符串又可以表示為：
`'Bob said \"I\'m OK\".'`
**注意：**轉義字符` \ `不計入字符串的內(nèi)容中
常用的轉義字符還有：
\n 表示換行
\t 表示一個制表符
\\ 表示 \ 字符本身
####raw字符串與多行字符串
* 如果一個字符串包含很多需要轉義的字符盖袭，對每一個字符都進行轉義會很麻煩失暂。為了避免這種情況，我們可以在字符串前面加個前綴`r `鳄虱，表示這是一個 raw 字符串弟塞，里面的字符就不需要轉義了。例如：
r'(_)/ (_)/'```
但是r'...'表示法不能表示多行字符串拙已，也不能表示包含'和 "的字符串
- 如果要表示多行字符串决记，可以用
'''...'''表示：
'''Line 1
Line 2
Line 3'''
上面這個字符串的表示方法和下面的是完全一樣的：
'Line 1\nLine 2\nLine 3' - 還可以在多行字符串前面添加
r，把這個多行字符串也變成一個raw字符串：
>>>print r''' "To be, or not to be": that is the question.
Whether it's nobler in the mind to suffer.'''
"To be, or not to be": that is the question.
Whether it's nobler in the mind to suffer.
Unicode字符串
如果中文字符串在Python環(huán)境下遇到 UnicodeDecodeError倍踪，這是因為.py文件保存的格式有問題系宫。可以在第一行添加注釋：
# -*- coding: utf-8 -*-```
如.py文件：
-- coding: utf-8 --
print '''靜夜思
床前明月光建车，
疑是地上霜笙瑟。
舉頭望明月，
低頭思故鄉(xiāng)癞志。
'''```
運行得到：
靜夜思
床前明月光往枷，
疑是地上霜。
舉頭望明月凄杯，
低頭思故鄉(xiāng)错洁。
整數(shù)和浮點數(shù)
Python支持對整數(shù)和浮點數(shù)直接進行四則混合運算，運算規(guī)則和數(shù)學上的四則運算規(guī)則完全一致戒突。
布爾類型
我們已經(jīng)了解了Python支持布爾類型的數(shù)據(jù)屯碴，布爾類型只有True和False兩種值。
Python把0膊存、空字符串' '和None看成 False导而，其他數(shù)值和非空字符串都看成True，如：
True and 'a=T' 計算結果是 'a=T'
繼續(xù)計算 'a=T' or 'a=F' 計算結果還是 'a=T'```
**要解釋上述結果隔崎，又涉及到 and 和 or 運算的一條重要法則：短路計算今艺。**
1. 在計算 `a and b `時，如果 a 是 False爵卒，則根據(jù)與運算法則虚缎，整個結果必定為 False，因此返回 a钓株；如果 a 是 True实牡，則整個計算結果必定取決與 b陌僵，因此返回 b。
2. 在計算 `a or b `時创坞，如果 a 是 True碗短，則根據(jù)或運算法則，整個計算結果必定為 True题涨，因此返回 a偎谁；如果 a 是 False，則整個計算結果必定取決于 b携栋，因此返回 b搭盾。
**所以Python解釋器在做布爾運算時咳秉，只要能提前確定計算結果婉支，它就不會往后算了，直接返回結果澜建。**
運行如下代碼：
a = 'python'
print 'hello,', a or 'world'
b = ''
print 'hello,', b or 'world'```
打印結果為：
hello, python
hello, world```
___
###List和Tuple類型
####創(chuàng)建list
Python內(nèi)置的一種數(shù)據(jù)類型是列表：`list`向挖。`list`是一種有序的集合，可以隨時添加和刪除其中的元素炕舵。
比如何之，列出班里所有同學的名字，就可以用一個list表示：
['Michael', 'Bob', 'Tracy']
['Michael', 'Bob', 'Tracy']```
list是數(shù)學意義上的有序集合咽筋，也就是說溶推，list中的元素是按照順序排列的。
構造list非常簡單奸攻，按照上面的代碼蒜危，直接用 [ ]
把list的所有元素都括起來，就是一個list對象睹耐。通常辐赞，我們會把list賦值給一個變量，這樣硝训，就可以通過變量來引用list：
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates # 打印classmates變量的內(nèi)容
['Michael', 'Bob', 'Tracy']```
由于Python是**動態(tài)語言**响委，所以list中包含的元素并不要求都必須是同一種數(shù)據(jù)類型，我們完全可以在list中包含各種數(shù)據(jù)：
L = ['Michael', 100, True]
一個元素也沒有的list窖梁，就是空list：
empty_list = []```
按照索引訪問list
由于list是一個有序集合赘风，所以，我們可以用一個list按分數(shù)從高到低表示出班里的3個同學：
>>> L = ['Adam', 'Lisa', 'Bart']```
那我們?nèi)绾螐膌ist中獲取指定第 N 名的同學呢纵刘？方法是通過索引來獲取list中的指定元素贝次。
（**需要特別注意的是**，索引從 0 開始彰导，也就是說蛔翅，第一個元素的索引是0敲茄，第二個元素的索引是1，以此類推山析。）
因此堰燎，要打印第一名同學的名字，用 L[0]:
print L[0]
Adam```
要打印第四名同學的名字笋轨，用 L[3]:
>>> print L[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range```
報錯了秆剪！IndexError意思就是索引超出了范圍，因為上面的list只有3個元素爵政，有效的索引是 0仅讽，1，2钾挟。
所以洁灵，使用索引時，**千萬注意不要越界**掺出。
####倒序訪問list
如何得到分數(shù)最低的同學徽千？
* 方法一
我們可以先數(shù)一數(shù)這個 list，發(fā)現(xiàn)它包含3個元素汤锨，因此双抽，最后一個元素的索引是2：
print L[2]
Bart```
- 方法二
Bart同學是最后一名，俗稱倒數(shù)第一闲礼，所以牍汹，我們可以用 -1 這個索引來表示最后一個元素：
>>> print L[-1]
Bart```
（注意：使用倒序索引時，也要注意**不要越界**）
####添加新元素
今天柬泽，班里轉來一名新同學 Paul慎菲，如何把新同學添加到現(xiàn)有的 list 中呢？
* 方法一
用 list 的 `append()` 方法聂抢，把新同學追加到 list 的末尾：
L = ['Adam', 'Lisa', 'Bart']
L.append('Paul')
print L
['Adam', 'Lisa', 'Bart', 'Paul']```
append()總是把新的元素添加到 list 的尾部
如果把Paul 同學添加到第一的位置怎么辦钧嘶？
- 方法二
方法是用list的insert()方法，它接受兩個參數(shù)琳疏，第一個參數(shù)是索引號有决，第二個參數(shù)是待添加的新元素：
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.insert(0, 'Paul')
>>> print L
['Paul', 'Adam', 'Lisa', 'Bart']```
（ 注意**`L.insert(0, 'Paul')`**的意思是，'Paul'將被添加到索引為 0 的位置上（也就是第一個）空盼，而原來索引為 0 的Adam同學书幕，以及后面的所有同學，都自動向后移動一位揽趾。）
####從list刪除元素
Paul同學剛來幾天又要轉走了台汇，那么我們怎么把Paul 從現(xiàn)有的list中刪除呢？
* 如果Paul同學排在最后一個，我們可以用list的`pop()`方法刪除：
L = ['Adam', 'Lisa', 'Bart', 'Paul']
L.pop()
'Paul'
print L
['Adam', 'Lisa', 'Bart']```
注意：pop()方法總是刪掉list的最后一個元素苟呐，并且它還返回這個元素痒芝，所以我們執(zhí)行 L.pop()后，會打印出 'Paul'牵素。
- 如果Paul同學不是排在最后一個怎么辦严衬？比如Paul同學排在第三：
>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']```
要把Paul踢出list，我們就必須**先定位Paul的位置**笆呆。由于Paul的索引是2请琳，因此，用 pop(2)
把Paul刪掉：
L.pop(2)
'Paul'
print L
['Adam', 'Lisa', 'Bart']```
從list替換元素
假設現(xiàn)在班里仍然是3名同學：
>>> L = ['Adam', 'Lisa', 'Bart']```
現(xiàn)在赠幕，Bart同學要轉學走了俄精，碰巧來了一個Paul同學，要更新班級成員名單榕堰。
* 方法一
我們可以先把Bart刪掉（pop）竖慧，再把Paul添加（append或insert）進來。
* 方法二
L[2] = 'Paul'
print L
L = ['Adam', 'Lisa', 'Paul']```
對list中的某一個索引賦值局冰，就可以直接用新的元素替換掉原來的元素测蘑，list包含的元素個數(shù)保持不變灌危。
由于Bart還可以用 -1 做索引康二，因此，下面的代碼也可以完成同樣的替換工作：
>>> L[-1] = 'Paul'```
####創(chuàng)建tuple
tuple是另一種有序的列表勇蝙，中文翻譯為“ 元組 ”沫勿。tuple 和 list 非常類似，但是味混，**tuple一旦創(chuàng)建完畢产雹，就不能修改了!!!**
同樣是表示班里同學的名稱涩嚣，用tuple表示如下：
t = ('Adam', 'Lisa', 'Bart')```
創(chuàng)建tuple和創(chuàng)建list唯一不同之處是用( )替代了[ ]教翩。
現(xiàn)在，這個t就不能改變了埠戳，tuple沒有 append()方法馆衔，也沒有insert()和pop()方法瘟判。所以，新同學沒法直接往 tuple 中添加角溃，老同學想退出 tuple 也不行拷获。
獲取 tuple 元素的方式和 list 是一模一樣的，我們可以正常使用 t[0]减细，t[-1]等索引方式訪問元素匆瓜，但是不能賦值成別的元素!!!
創(chuàng)建單元素tuple
tuple和list一樣，可以包含 0 個、1個和任意多個元素
- 創(chuàng)建包含 0 個元素的 tuple驮吱，也就是空tuple茧妒，直接用 ()表示：
>>> t = ()
>>> print t
()```
* 創(chuàng)建包含1個元素的 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
前面我們看到了tuple一旦創(chuàng)建就不能修改。現(xiàn)在教馆，我們來看一個“可變”的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的內(nèi)容：
>>> print t
('a', 'b', ['X', 'Y'])```
表面上看，tuple的元素確實變了悲敷，但其實變的不是 tuple 的元素究恤，而是list的元素。
tuple一開始指向的list并沒有改成別的list后德，所以部宿，tuple所謂的**“不變”**是說，tuple的每個元素瓢湃，指向永遠不變理张。即**指向'a'，就不能改成指向'b'**箱季，指向一個list涯穷，就不能改成指向其他對象，但指向的這個list本身是可變的藏雏！
理解了**“指向不變”**后拷况，要創(chuàng)建一個內(nèi)容也不變的tuple怎么做作煌？那就必須保證tuple的每一個元素本身也不能變。
例如：
t = ('a', 'b', ('A', 'B'))```
就是不可變的赚瘦。
條件判斷和循環(huán)
if語句
計算機之所以能做很多自動化的任務粟誓，因為它可以自己做條件判斷。
比如起意，輸入用戶年齡鹰服，根據(jù)年齡打印不同的內(nèi)容，在Python程序中揽咕，可以用if語句實現(xiàn)：
age = 20
if age >= 18:
print 'your age is', age
print 'adult'
print 'END'```
**注意: **<font color=#FF4500 >Python代碼的縮進規(guī)則</font>悲酷。具有相同縮進的代碼被視為代碼塊，上面的3亲善，4行 print 語句就構成一個代碼塊（但不包括第5行的print）设易。如果 if 語句判斷為 True，就會執(zhí)行這個代碼塊蛹头。
縮進要嚴格按照Python的習慣寫法：<font color=#FF4500 >4個空格顿肺，不要使用Tab，更不要混合Tab和空格</font>渣蜗，否則很容易造成因為縮進引起的語法錯誤屠尊。
**注意**: if 語句后接表達式，然后用`:`表示代碼塊開始耕拷。
如果在<font color=#FF4500 >Python交互環(huán)境下敲代碼</font>讼昆，還要特別<font color=#FF4500 >留意縮進</font>，并且<font color=#FF4500 >退出縮進需要多敲一行回車</font>：
age = 20
if age >= 18:
... print 'your age is', age
... print 'adult't = (1, 2, 3,)
>>> print t
(1, 2, 3)####“可變”的tuple 前面我們看到了tuple一旦創(chuàng)建就不能修改“呤ぃ現(xiàn)在控淡，我們來看一個“可變”的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的內(nèi)容：
>>> print t
('a', 'b', ['X', 'Y'])表面上看凭戴，tuple的元素確實變了，但其實變的不是 tuple 的元素炕矮，而是list的元素么夫。 tuple一開始指向的list并沒有改成別的list，所以肤视，tuple所謂的**“不變”**是說档痪，tuple的每個元素，指向永遠不變邢滑。即**指向'a'腐螟，就不能改成指向'b'**，指向一個list，就不能改成指向其他對象乐纸，但指向的這個list本身是可變的衬廷！ 理解了**“指向不變”**后，要創(chuàng)建一個內(nèi)容也不變的tuple怎么做汽绢？那就必須保證tuple的每一個元素本身也不能變吗跋。 例如：
t = ('a', 'b', ('A', 'B'))就是不可變的。 ----------------- ###條件判斷和循環(huán) ####if語句 計算機之所以能做很多自動化的任務宁昭，因為它可以自己做條件判斷跌宛。 比如，輸入用戶年齡积仗，根據(jù)年齡打印不同的內(nèi)容秩冈，在Python程序中，可以用if語句實現(xiàn)：
age = 20
if age >= 18:
print 'your age is', age
print 'adult'
print 'END'**注意: **<font color=#FF4500 >Python代碼的縮進規(guī)則</font>斥扛。具有相同縮進的代碼被視為代碼塊入问，上面的3，4行 print 語句就構成一個代碼塊（但不包括第5行的print）稀颁。如果 if 語句判斷為 True芬失，就會執(zhí)行這個代碼塊。 縮進要嚴格按照Python的習慣寫法：<font color=#FF4500 >4個空格匾灶，不要使用Tab棱烂，更不要混合Tab和空格</font>，否則很容易造成因為縮進引起的語法錯誤阶女。 **注意**: if 語句后接表達式颊糜，然后用`:`表示代碼塊開始。 如果在<font color=#FF4500 >Python交互環(huán)境下敲代碼</font>秃踩，還要特別<font color=#FF4500 >留意縮進</font>衬鱼，并且<font color=#FF4500 >退出縮進需要多敲一行回車</font>：
>>> age = 20
>>> if age >= 18:
... print 'your age is', age
... print 'adult'
...
your age is 20
print t
(1, 2, 3)####“可變”的tuple 前面我們看到了tuple一旦創(chuàng)建就不能修改。現(xiàn)在憔杨，我們來看一個“可變”的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的內(nèi)容：
>>> print t
('a', 'b', ['X', 'Y'])表面上看，tuple的元素確實變了寻狂，但其實變的不是 tuple 的元素岁经，而是list的元素。 tuple一開始指向的list并沒有改成別的list蛇券，所以缀壤，tuple所謂的**“不變”**是說朽们，tuple的每個元素，指向永遠不變诉位。即**指向'a'骑脱，就不能改成指向'b'**，指向一個list苍糠，就不能改成指向其他對象叁丧，但指向的這個list本身是可變的！ 理解了**“指向不變”**后岳瞭，要創(chuàng)建一個內(nèi)容也不變的tuple怎么做拥娄？那就必須保證tuple的每一個元素本身也不能變。 例如：
t = ('a', 'b', ('A', 'B'))就是不可變的瞳筏。 ----------------- ###條件判斷和循環(huán) ####if語句 計算機之所以能做很多自動化的任務稚瘾，因為它可以自己做條件判斷。 比如姚炕，輸入用戶年齡摊欠，根據(jù)年齡打印不同的內(nèi)容，在Python程序中柱宦，可以用if語句實現(xiàn)：
age = 20
if age >= 18:
print 'your age is', age
print 'adult'
print 'END'**注意: **<font color=#FF4500 >Python代碼的縮進規(guī)則</font>些椒。具有相同縮進的代碼被視為代碼塊，上面的3掸刊，4行 print 語句就構成一個代碼塊（但不包括第5行的print）免糕。如果 if 語句判斷為 True，就會執(zhí)行這個代碼塊忧侧。 縮進要嚴格按照Python的習慣寫法：<font color=#FF4500 >4個空格石窑，不要使用Tab，更不要混合Tab和空格</font>蚓炬，否則很容易造成因為縮進引起的語法錯誤松逊。 **注意**: if 語句后接表達式，然后用`:`表示代碼塊開始试吁。 如果在<font color=#FF4500 >Python交互環(huán)境下敲代碼</font>棺棵，還要特別<font color=#FF4500 >留意縮進</font>，并且<font color=#FF4500 >退出縮進需要多敲一行回車</font>：
>>> age = 20
>>> if age >= 18:
... print 'your age is', age
... print 'adult'
...
your age is 20
adult```
if-else語句
當 if 語句判斷表達式的結果為 True 時熄捍，就會執(zhí)行 if 包含的代碼塊：
if age >= 18: print 'adult'```
如果我們想判斷年齡在18歲以下時，打印出 'teenager'母怜，怎么辦余耽？
可以用一個 <font color=#FF4500 >if ... else ... </font>語句：
if age >= 18:
print 'adult'
else:
print 'teenager'```
if-elif-else語句
有的時候，一個 if ... else ... 還不夠用苹熏。比如碟贾，根據(jù)年齡的劃分：
條件1：18歲或以上：adult
條件2：6歲或以上：teenager
條件3：6歲以下：kid```
要避免嵌套結構的 if ... else ...币喧，我們可以用 if ... 多個elif ... else ...的結構，一次寫完所有的規(guī)則：
if age >= 18:
print 'adult'
elif age >= 6:
print 'teenager'
elif age >= 3:
print 'kid'
else:
print 'baby'```
elif 意思就是 else if袱耽。這樣一來杀餐，我們就寫出了結構非常清晰的一系列條件判斷。
**特別注意: **這一系列條件判斷會從上到下依次判斷朱巨，如果某個判斷為 True史翘，執(zhí)行完對應的代碼塊，后面的條件判斷就直接忽略冀续，不再執(zhí)行了
for循環(huán)
list或tuple可以表示一個有序集合琼讽。如果我們想依次訪問一個list中的每一個元素呢？比如 list：
L = ['Adam', 'Lisa', 'Bart']```
Python的 for 循環(huán)就可以依次把list或tuple的每個元素迭代出來：
L = ['Adam', 'Lisa', 'Bart']for name in L: print name```
注意: name 這個變量是在 for 循環(huán)中定義的洪唐，意思是钻蹬，依次取出list中的每一個元素，并把元素賦值給 name凭需，然后執(zhí)行for循環(huán)體（就是縮進的代碼塊）问欠。
這樣一來，遍歷一個list或tuple就非常容易了粒蜈。
while循環(huán)
和 for 循環(huán)不同的另一種循環(huán)是 while 循環(huán)溅潜，while 循環(huán)不會迭代 list 或 tuple 的元素，而是根據(jù)表達式判斷循環(huán)是否結束薪伏。
比如要從 0 開始打印不大于 N 的整數(shù)：
N = 10
x = 0
while x < N:
print x
x = x + 1```
while循環(huán)每次先判斷 x < N滚澜，如果為True，則執(zhí)行循環(huán)體的代碼塊嫁怀，否則设捐，退出循環(huán)。
在循環(huán)體內(nèi)塘淑，x = x + 1 會讓 x 不斷增加萝招，最終因為 x < N 不成立而退出循環(huán)。
####break退出循環(huán)
用 for 循環(huán)或者 while 循環(huán)時存捺，如果要在循環(huán)體內(nèi)直接退出循環(huán)槐沼，可以使用 break 語句
比如計算1至100的整數(shù)和，我們用while來實現(xiàn)：
sum = 0
x = 1
while True:
sum = sum + x
x = x + 1
if x > 100:
break
print sum```
咋一看捌治， while True 就是一個死循環(huán)岗钩，但是在循環(huán)體內(nèi)，我們還判斷了 x > 100 條件成立時肖油，用break語句退出循環(huán)兼吓，這樣也可以實現(xiàn)循環(huán)的結束。
continue繼續(xù)循環(huán)
在循環(huán)過程中森枪，可以用break退出當前循環(huán)视搏，還可以用continue跳過后續(xù)循環(huán)代碼审孽，繼續(xù)下一次循環(huán)。
現(xiàn)在老師只想統(tǒng)計及格分數(shù)的平均分浑娜，就要把 x < 60 的分數(shù)剔除掉佑力，這時，利用 continue筋遭，可以做到當 x < 60的時候打颤，不繼續(xù)執(zhí)行循環(huán)體的后續(xù)代碼，直接進入下一次循環(huán)：
L = [75, 98, 59, 81, 66, 43, 69, 85]
sum = 0.0
n = 0
for x in L:
if x < 60:
continue
sum = sum + x
n = n + 1```
####多重循環(huán)
在循環(huán)內(nèi)部宛畦，還可以嵌套循環(huán)瘸洛，我們來看一個例子：
for x in ['A', 'B', 'C']:
for y in ['1', '2', '3']:
print x + y
x 每循環(huán)一次，y 就會循環(huán) 3 次次和，這樣反肋，我們可以打印出一個全排列：
A1
A2
A3
B1
B2
B3
C1
C2
C3
__________
###Dict和Set類型
####什么是dict
我們已經(jīng)知道，list 和 tuple 可以用來表示順序集合踏施，例如石蔗，班里同學的名字：
['Adam', 'Lisa', 'Bart']```
或者考試的成績列表：
[95, 85, 59]```
但是，要根據(jù)名字找到對應的成績畅形，用兩個 list 表示就不方便养距。
如果把名字和分數(shù)關聯(lián)起來，組成類似的查找表：
'Adam' ==> 95
'Lisa' ==> 85
'Bart' ==> 59```
那么給定一個名字日熬，就可以直接查到分數(shù)棍厌。
Python的 dict 就是專門干這件事的。用 dict 表示“名字”-“成績”的查找表如下：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
我們把名字稱為key竖席，對應的成績稱為value耘纱，dict就是通過 key 來查找 value。
花括號 {} 表示這是一個dict毕荐，然后按照** key: value**, 寫出來即可束析。最后一個 key: value 的逗號可以省略。
由于dict也是集合憎亚，len() 函數(shù)可以計算任意集合的大性笨堋：
>>> len(d)
3
注意: 一個 key-value 算一個，因此第美，dict大小為3蝶锋。
訪問dict
我們已經(jīng)能創(chuàng)建一個dict，用于表示名字和成績的對應關系：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}```
那么斋日，如何根據(jù)名字來查找對應的成績呢牲览？
可以簡單地使用 `d[key]` 的形式來查找對應的 value，這和 list 很像恶守，不同之處是第献，**list 必須使用索引返回對應的元素，而dict使用key：**
print d['Adam']
95
print d['Paul']
Traceback (most recent call last):
File "index.py", line 11, in <module>
print d['Paul']
KeyError: 'Paul'
**注意:** 通過 key 訪問 dict 的value兔港，只要 key 存在庸毫，dict就返回對應的value。如果key不存在衫樊，會直接報錯：KeyError飒赃。
要避免 KeyError 發(fā)生，有兩個辦法：
* **一是先判斷一下 key 是否存在科侈，用 in 操作符：**
if 'Paul' in d:
print d['Paul']```
如果 'Paul' 不存在载佳，if語句判斷為False，自然不會執(zhí)行 print d['Paul'] 臀栈，從而避免了錯誤蔫慧。
- 二是使用dict本身提供的一個 get 方法，在Key不存在的時候权薯，返回None：
>>> print d.get('Bart')
59
>>> print d.get('Paul')
None```
####dict的特點
* **dict的第一個特點是<font color=#FF4500 >查找速度快 </font>姑躲，無論dict有10個元素還是10萬個元素，查找速度都一樣**盟蚣。而list的查找速度隨著元素增加而逐漸下降黍析。
不過dict的查找速度快不是沒有代價的，**dict的缺點是占用內(nèi)存大屎开，還會浪費很多內(nèi)容**阐枣，list正好相反，占用內(nèi)存小奄抽，但是查找速度慢蔼两。
由于dict是按 key 查找，所以如孝，在一個dict中宪哩，key不能重復。
* **dict的第二個特點就是存儲的key-value序對是<font color=#FF4500 >沒有順序 </font>的第晰！**這和list不一樣：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
當我們試圖打印這個dict時：
print d
{'Lisa': 85, 'Adam': 95, 'Bart': 59}```
打印的順序不一定是我們創(chuàng)建時的順序锁孟，而且，不同的機器打印的順序都可能不同茁瘦，這說明dict內(nèi)部是無序的品抽，不能用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
}```
最常用的key還是字符串澎嚣，因為用起來最方便。
####什么是set
**dict的作用是建立一組 key 和一組 value 的映射關系瘟芝，dict的key是不能重復的易桃。**
有的時候，我們只想要 dict 的 key锌俱，不關心 key 對應的 value晤郑，目的就是保證這個集合的元素不會重復，這時嚼鹉，set就派上用場了贩汉。
**set 持有一系列元素，這一點和 list 很像锚赤，但是set的元素沒有重復匹舞，而且是無序的，這點和 dict 的 key很像线脚。**
創(chuàng)建 set 的方式是調用 set() 并傳入一個 list赐稽，list的元素將作為set的元素：
s = set(['A', 'B', 'C'])
可以查看 set 的內(nèi)容：
print s
set(['A', 'C', 'B'])```
注意，上述打印的形式類似 list浑侥， 但它不是 list姊舵，仔細看還可以發(fā)現(xiàn)，打印的順序和原始 list 的順序有可能是不同的寓落，因為set內(nèi)部存儲的元素是<font color=#FF4500 >無序</font>的括丁。
因為<font color=#FF4500 >set不能包含重復的元素 </font>，所以伶选，當我們傳入包含重復元素的 list 會怎么樣呢史飞？
>>> s = set(['A', 'B', 'C', 'C'])
>>> print s
set(['A', 'C', 'B'])
>>> len(s)
3
結果顯示，set會自動去掉重復的元素仰税，原來的list有4個元素构资，但set只有3個元素。
訪問set
由于set存儲的是無序集合陨簇，所以我們沒法通過索引來訪問吐绵。
訪問 set中的某個元素實際上就是判斷一個元素是否在set中。
例如，存儲了班里同學名字的set：
>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])```
**我們可以用 in 操作符判斷：**
Bart是該班的同學嗎己单？
'Bart' in s
True```print d
{'Lisa': 85, 'Adam': 95, 'Bart': 59}打印的順序不一定是我們創(chuàng)建時的順序唉窃，而且，不同的機器打印的順序都可能不同荷鼠，這說明dict內(nèi)部是**無序**的句携，不能用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
}最常用的key還是字符串掏导，因為用起來最方便。 ####什么是set **dict的作用是建立一組 key 和一組 value 的映射關系羽峰，dict的key是不能重復的趟咆。** 有的時候，我們只想要 dict 的 key梅屉，不關心 key 對應的 value值纱，目的就是保證這個集合的元素不會重復，這時坯汤，set就派上用場了虐唠。 **set 持有一系列元素，這一點和 list 很像惰聂，但是set的元素沒有重復疆偿，而且是無序的，這點和 dict 的 key很像庶近。** 創(chuàng)建 set 的方式是調用 set() 并傳入一個 list翁脆，list的元素將作為set的元素：
>>> s = set(['A', 'B', 'C'])
可以查看 set 的內(nèi)容：
>>> print s
set(['A', 'C', 'B'])**注意**，上述打印的形式類似 list鼻种， 但它不是 list反番，仔細看還可以發(fā)現(xiàn)，打印的順序和原始 list 的順序有可能是不同的，因為set內(nèi)部存儲的元素是**<font color=#FF4500 >無序</font>**的罢缸。 因為**<font color=#FF4500 >set不能包含重復的元素 </font>**篙贸，所以，當我們傳入包含重復元素的 list 會怎么樣呢枫疆？
>>> s = set(['A', 'B', 'C', 'C'])
>>> print s
set(['A', 'C', 'B'])
>>> len(s)
3
結果顯示爵川，set會自動去掉重復的元素，原來的list有4個元素息楔，但set只有3個元素寝贡。 ####訪問set 由于**set存儲的是無序集合**，所以我們沒法通過索引來訪問值依。 訪問 set中的某個元素實際上就是判斷一個元素是否在set中圃泡。 例如，存儲了班里同學名字的set：
>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])**我們可以用 in 操作符判斷：** Bart是該班的同學嗎愿险？
>>> 'Bart' in s
True```
Bill是該班的同學嗎颇蜡？
>>> 'Bill' in s
False```
bart是該班的同學嗎？
'bart' in s
False```
看來大小寫很重要辆亏，'Bart' 和 'bart'被認為是兩個不同的元素
set的特點
set的內(nèi)部結構和dict很像风秤，唯一區(qū)別是不存儲value，因此扮叨，判斷一個元素是否在set中速度很快缤弦。
set存儲的元素和dict的key類似，必須是不變對象甫匹，因此甸鸟，任何可變對象是不能放入set中的。
最后兵迅，<font color=#FF4500 >set存儲的元素也是沒有順序的 </font>抢韭。
set的這些特點，可以應用在哪些地方呢恍箭？
星期一到星期日可以用字符串'MON', 'TUE', ... 'SUN'表示刻恭。
假設我們讓用戶輸入星期一至星期日的某天，如何判斷用戶的輸入是否是一個有效的星期呢扯夭？
可以用** if 語句**判斷鳍贾，但這樣做非常繁瑣。
如果事先創(chuàng)建好一個set交洗，包含'MON' ~ 'SUN'：
weekdays = set(['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'])```
再判斷輸入是否有效骑科，只需要判斷該字符串是否在set中：
x = '???' # 用戶輸入的字符串
if x in weekdays:
print 'input ok'
else:
print 'input error'```
這樣一來，代碼就簡單多了构拳。
遍歷set
由于 set 也是一個集合咆爽，所以梁棠，遍歷 set 和遍歷 list 類似，都可以通過 for 循環(huán)實現(xiàn)斗埂。
直接使用 for 循環(huán)可以遍歷 set 的元素：
>>> s = set(['Adam', 'Lisa', 'Bart'])
>>> for name in s:
.. print name
...
Lisa
Adam
Bart```
**注意: **觀察 for 循環(huán)在遍歷set時符糊，元素的順序和list的順序很可能是不同的，而且不同的機器上運行的結果也可能不同呛凶。
例：用 for 循環(huán)遍歷如下的set男娄，打印出 name: score 來。
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])```
代碼：
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
print x[0]+':',x[1]```
打印結果：
Lisa: 85
Adam: 95
Bart: 59```
更新set
由于set存儲的是一組不重復的無序元素漾稀，因此模闲，更新set主要做兩件事：
一是把新的元素添加到set中，二是把已有元素從set中刪除县好。
添加元素時围橡，用set的add()方法：
>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])```
如果添加的元素已經(jīng)存在于set中，add()不會報錯缕贡，但是不會加進去了：
s = set([1, 2, 3])
s.add(3)
print s
set([1, 2, 3])```
刪除set中的元素時，用set的<font color=#FF4500 >remove() </font>方法：
>>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3])```
如果刪除的元素不存在set中拣播，remove()會報錯：
s = set([1, 2, 3])
s.remove(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 4```
所以用add()可以直接添加晾咪，而remove()前需要判斷。
函數(shù)
什么是函數(shù)
抽象是數(shù)學中非常常見的概念贮配。
借助抽象谍倦，我們才能不關心底層的具體計算過程，而直接在更高的層次上思考問題泪勒。
寫計算機程序也是一樣昼蛀，函數(shù)就是最基本的一種代碼抽象的方式。
Python不但能非常靈活地定義函數(shù)圆存，而且本身內(nèi)置了很多有用的函數(shù)叼旋，可以直接調用。
調用函數(shù)
Python內(nèi)置了很多有用的函數(shù)沦辙，我們可以直接調用夫植。
要調用一個函數(shù)，需要知道<font color=#FF4500 >函數(shù)的名稱和參數(shù)</font>油讯，比如求絕對值的函數(shù) abs详民，它接收一個參數(shù)。
可以直接從Python的官方網(wǎng)站查看文檔：
http://docs.python.org/2/library/functions.html
#abs
也可以在交互式命令行通過 help(abs)查看abs函數(shù)的幫助信息陌兑。
調用 **abs **函數(shù)：
>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34```
調用函數(shù)的時候沈跨，如果傳入的參數(shù)數(shù)量不對，會報**TypeError**的錯誤兔综，并且Python會明確地告訴你：abs()有且僅有1個參數(shù)饿凛，但給出了兩個：
abs(1, 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)```
如果傳入的參數(shù)數(shù)量是對的隅俘，但參數(shù)類型不能被函數(shù)所接受，也會報TypeError的錯誤笤喳，并且給出錯誤信息：str是錯誤的參數(shù)類型：
>>> abs('a')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'```
而比較函數(shù)**<font color=#FF4500 >cmp(x, y) </font>** 就需要兩個參數(shù)为居，如果 **x<y**，返回** -1**杀狡，如果** x==y**蒙畴，返回 **0**，如果 **x>y**呜象，返回 **1**：
cmp(1, 2)
-1
cmp(2, 1)
1
cmp(3, 3)
0```
Python內(nèi)置的常用函數(shù)還包括數(shù)據(jù)類型轉換函數(shù)膳凝，比如<font color=#FF4500 > int() </font>函數(shù)可以把其他數(shù)據(jù)類型轉換為整數(shù)：
>>> int('123')
123
>>> int(12.34)
12```
**<font color=#FF4500 >str()</font>**函數(shù)把其他類型轉換成 str：
str(123)
'123'
str(1.23)
'1.23'```
例子：
sum()函數(shù)接受一個list作為參數(shù)，并返回list所有元素之和恭陡。請計算 11 + 22 + 33 + ... + 100100
代碼：
L = [ ]
x=1
while x<=100:
L.append(x*x)
x=x+1
print sum(L)```
打印結果：
338350```
編寫函數(shù)
在Python中蹬音，定義一個函數(shù)要使用** def 語句，依次寫出函數(shù)名休玩、括號著淆、括號中的參數(shù)和冒號:**，然后拴疤，在縮進塊中編寫函數(shù)體永部，函數(shù)的返回值用 return語句返回。
例子：定義一個 square_of_sum 函數(shù)呐矾，它接受一個list苔埋，返回list中每個元素平方的和。
代碼：
def square_of_sum(L):
sum=0
for x in L:
sum = sum +x**2
return sum
print square_of_sum([1, 2, 3, 4, 5])
print square_of_sum([-5, 0, 5, 15, 25])```
打印結果：
55
900```
注意蜒犯，函數(shù)體內(nèi)部的語句在執(zhí)行時组橄，一旦執(zhí)行到return時，函數(shù)就執(zhí)行完畢罚随，并將結果返回玉工。因此，函數(shù)內(nèi)部通過條件判斷和循環(huán)可以實現(xiàn)非常復雜的邏輯毫炉。
如果沒有return語句瓮栗，函數(shù)執(zhí)行完畢后也會返回結果，只是結果為 None瞄勾。
<font color=#FF4500 > return None可以簡寫為return费奸。 </font>
返回多值
函數(shù)可以返回多個值嗎？答案是肯定的进陡。
比如在游戲中經(jīng)常需要從一個點移動到另一個點愿阐，給出坐標、位移和角度趾疚，就可以計算出新的坐標：
<font color=#FF4500 >#math</font>包提供了sin()和 cos()函數(shù)缨历，我們先用import引用它：
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
cmp(3, 3)
0Python內(nèi)置的常用函數(shù)還包括數(shù)據(jù)類型轉換函數(shù)以蕴，比如**<font color=#FF4500 > int() </font>**函數(shù)可以把其他數(shù)據(jù)類型轉換為整數(shù)：
>>> int('123')
123
>>> int(12.34)
12**<font color=#FF4500 >str()</font>**函數(shù)把其他類型轉換成 str：
>>> str(123)
'123'
>>> str(1.23)
'1.23'例子： sum()函數(shù)接受一個list作為參數(shù)，并返回list所有元素之和辛孵。請計算 1*1 + 2*2 + 3*3 + ... + 100*100 代碼：
L = [ ]
x=1
while x<=100:
L.append(xx)
x=x+1
print sum(L)打印結果：
338350####編寫函數(shù) 在Python中丛肮，定義一個函數(shù)要使用** def **語句，依次寫出**函數(shù)名**魄缚、**括號**宝与、括號中的**參數(shù)**和**冒號:**，然后冶匹，在縮進塊中編寫函數(shù)體习劫，函數(shù)的返回值用 **return**語句返回。 例子：定義一個 square_of_sum 函數(shù)嚼隘，它接受一個list诽里，返回list中每個元素平方的和。 代碼：
def square_of_sum(L):
sum=0
for x in L:
sum = sum +x*2
return sum
print square_of_sum([1, 2, 3, 4, 5])
print square_of_sum([-5, 0, 5, 15, 25])打印結果：
55
900**注意**飞蛹，函數(shù)體內(nèi)部的語句在執(zhí)行時谤狡，一旦執(zhí)行到return時，函數(shù)就執(zhí)行完畢桩皿，并將結果返回豌汇。因此，函數(shù)內(nèi)部通過條件判斷和循環(huán)可以實現(xiàn)非常復雜的邏輯泄隔。 如果沒有return語句，函數(shù)執(zhí)行完畢后也會返回結果宛徊，只是結果為 None佛嬉。 **<font color=#FF4500 > return None可以簡寫為return。 </font>** ####返回多值 函數(shù)可以返回多個值嗎闸天？答案是肯定的暖呕。 比如在游戲中經(jīng)常需要從一個點移動到另一個點，給出坐標苞氮、位移和角度湾揽，就可以計算出新的坐標： **<font color=#FF4500 >#math</font>**包提供了**sin()**和 **cos()**函數(shù)，我們先用import引用它：
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```
但其實這只是一種假象笼吟，Python函數(shù)返回的仍然是單一值：
>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0)```
用print打印返回結果库物，原來返回值是一個**tuple**！
但是贷帮，在語法上戚揭，返回一個tuple可以省略括號，而多個變量可以同時接收一個tuple撵枢，按位置賦給對應的值民晒，所以精居，**Python的函數(shù)**返回多值其實就是**返回一個tuple**，但寫起來更方便潜必。
例子：
一元二次方程的定義是：ax2 + bx + c = 0
請編寫一個函數(shù)靴姿，返回一元二次方程的兩個解。
**注意：**Python的math包提供了sqrt()函數(shù)用于計算平方根磁滚。
代碼：
import math
def quadratic_equation(a, b, c):
de=b2-4ac
if de>=0:
x1=(-b+math.sqrt(b2-4ac))/(2a)
x2=(-b-math.sqrt(b2-4ac))/(2a)
return x1,x2
else:
return
print quadratic_equation(2, 3, 0)
print quadratic_equation(1, -6, 5)```
打印結果：
(0.0, -1.5)
(5.0, 1.0)```
####遞歸函數(shù)
在函數(shù)內(nèi)部佛吓，可以調用其他函數(shù)。如果一個函數(shù)在內(nèi)部調用自身本身恨旱，這個函數(shù)就是遞歸函數(shù)辈毯。
舉個例子，我們來計算階乘 **n! = 1 * 2 * 3 * ... * n**搜贤，用函數(shù) **fact(n)**表示谆沃，可以看出：
fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n```
所以，fact(n)可以表示為 n * fact(n-1)仪芒，只有n=1時需要特殊處理唁影。
于是，fact(n)用遞歸的方式寫出來就是：
def fact(n):
if n==1:
return 1
return n * fact(n - 1)```
如果我們計算fact(5)掂名，可以根據(jù)函數(shù)定義看到計算過程如下：
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120```
遞歸函數(shù)的優(yōu)點是定義簡單据沈，邏輯清晰。理論上饺蔑，所有的遞歸函數(shù)都可以寫成循環(huán)的方式锌介，但循環(huán)的邏輯不如遞歸清晰。
<font color=#FF4500 >使用遞歸函數(shù)需要注意防止棧溢出猾警。</font>在計算機中孔祸，函數(shù)調用是通過棧（stack）這種數(shù)據(jù)結構實現(xiàn)的，每當進入一個函數(shù)調用发皿，棧就會加一層棧幀崔慧，每當函數(shù)返回，棧就會減一層棧幀穴墅。由于棧的大小不是無限的惶室，所以，遞歸調用的次數(shù)過多玄货，會導致棧溢出皇钞。
例子：
漢諾(http://baike.baidu.com/view/191666.htm) 的移動也可以看做是遞歸函數(shù)。
我們對柱子編號為a, b, c誉结，將所有圓盤從a移到c可以描述為：
如果a只有一個圓盤鹅士，可以直接移動到c；
如果a有N個圓盤惩坑，可以看成a有1個圓盤（底盤） + (N-1)個圓盤掉盅，首先需要把 (N-1) 個圓盤移動到 b也拜，然后，將 a的最后一個圓盤移動到c趾痘，再將b的(N-1)個圓盤移動到c慢哈。
請編寫一個函數(shù)，給定輸入 n, a, b, c永票，打印出移動的步驟：
move(n, a, b, c)
例如卵贱，輸入 move(2, 'A', 'B', 'C')，打印出：
A --> B
A --> C
B --> C
代碼：
#-*- coding:utf-8 -*-
# move(n, a, b, c)表示的是有n個盤子在a柱子上侣集，將要移到c柱子上面去
def move(n, a, b, c):
# 如果a柱子上面只有一個盤子键俱，則直接移到c柱子上面去并輸出路徑，結束遞歸
if n == 1:
print a, '-->', c
return
# 表示的是將n-1的盤子從a柱子上面移到b柱子上面去
move(n-1, a, c, b)
# 輸出最下面?zhèn)€盤子移從a移到c的路徑
print a, '-->', c
# 將b柱子上面的n-1個盤子移動到c柱子上面
move(n-1, b, a, c)
move(4, 'A', 'B', 'C')```
打印結果：
A --> B
A --> C
B --> C
A --> B
C --> A
C --> B
A --> B
A --> C
B --> C
B --> A
C --> A
B --> C
A --> B
A --> C
B --> C```
定義默認參數(shù)
定義函數(shù)的時候世分，還可以有默認參數(shù)编振。
例如Python自帶的 int() 函數(shù)，其實就有兩個參數(shù)臭埋，我們既可以傳一個參數(shù)踪央，又可以傳兩個參數(shù)：
>>> int('123')
123
>>> int('123', 8)
83```
int()函數(shù)的第二個參數(shù)是轉換進制，如果不傳瓢阴，默認是十進制 (base=10)畅蹂，如果傳了，就用傳入的參數(shù)荣恐。
可見液斜，**函數(shù)的默認參數(shù)的作用是簡化調用**，你只需要把必須的參數(shù)傳進去叠穆。但是在需要的時候旗唁，又可以傳入額外的參數(shù)來覆蓋默認參數(shù)值。
我們來定義一個計算 x 的N次方的函數(shù):
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s```
假設計算平方的次數(shù)最多痹束，我們就可以把 n 的默認值設定為 2：
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s```
這樣一來，計算平方就不需要傳入兩個參數(shù)了：
power(5)
25
由于函數(shù)的參數(shù)按從左到右的順序匹配讶请，所以**默認參數(shù)只能定義在必需參數(shù)的后面：**
OK:
def fn1(a, b=1, c=2):
pass
Error:
def fn2(a=1, b):
pass```
例子：
定義一個 greet() 函數(shù)祷嘶，它包含一個默認參數(shù)，如果沒有傳入夺溢，打印 'Hello, world.'论巍，如果傳入，打印 'Hello, xxx.'默認參數(shù)的默認值可以設定為'world'
代碼：
def greet(name='world'):
print 'Hello, ' + name + '.'
greet()
greet('Bart')```
打印結果：
Hello,world.
Hello,Bart.```
定義可變參數(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')```
可變參數(shù)也不是很神秘锭沟，Python解釋器會把傳入的一組參數(shù)組裝成一個tuple傳遞給可變參數(shù)渡八，因此，在函數(shù)內(nèi)部吉殃，直接把變量** args** 看成一個 tuple 就好了密似。
定義可變參數(shù)的目的也是為了簡化調用焙矛。假設我們要計算任意個數(shù)的平均值，就可以定義一個可變參數(shù)：
def average(*args):
...```
這樣残腌，在調用的時候村斟，可以這樣寫：
average()
0
average(1, 2)
1.5
average(1, 2, 2, 3, 4)
2.4```
例子：
編寫接受可變參數(shù)的 average() 函數(shù)。
可變參數(shù) args 是一個tuple抛猫，當0個參數(shù)傳入時蟆盹，args是一個空tuple。
代碼：
def average(*args):
sum = 0.0
if len(args) == 0:
return sum
for x in args:
sum = sum + x
return sum / len(args)
print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)```
打印結果：
0.0
1.5
2.4```
切片
對list進行切片
取一個list的部分元素是非常常見的操作闺金。比如逾滥，一個list如下：
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']```
取前N個元素，也就是索引為0-(N-1)的元素掖看，可以用循環(huán)匣距，對這種經(jīng)常取指定索引范圍的操作，用循環(huán)十分繁瑣哎壳，因此毅待，Python提供了切片（Slice）操作符，能大大簡化這種操作归榕。
對應上面的問題尸红，取前3個元素，用一行代碼就可以完成切片：
L[0:3]
['Adam', 'Lisa', 'Bart']```
L[0:3]表示刹泄，從索引0開始取外里，直到索引3為止，但不包括索引3特石。即索引0盅蝗，1，2姆蘸，正好是3個元素墩莫。
如果第一個索引是0，還可以省略：
>>> L[:3]
['Adam', 'Lisa', 'Bart']```
也可以從索引1開始逞敷，取出2個元素出來：
L[1:3]
['Lisa', 'Bart']```
只用一個** : **狂秦，表示從頭到尾：
>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']```
**因此，L[:]實際上復制出了一個新list推捐。**
切片操作還可以指定第三個參數(shù)：
L[::2]
['Adam', 'Bart']```
第三個參數(shù)表示每N個取一個裂问，上面的 L[::2] 會每兩個元素取出一個來，也就是隔一個取一個。
把list換成tuple堪簿，切片操作完全相同痊乾，只是切片的結果也變成了tuple。
例子：
range()函數(shù)可以創(chuàng)建一個數(shù)列：
>>> range(1, 101)
[1, 2, 3, ..., 100]```
請利用切片戴甩，取出：
1. 前10個數(shù)符喝；
2. 3的倍數(shù)；
3. 不大于50的5的倍數(shù)甜孤。
代碼：
L = range(1, 101)
print L[0:10]
print L[2::3]
print L[4:50:5]
打印結果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]
[5, 10, 15, 20, 25, 30, 35, 40, 45, 50]```
倒序切片
對于list协饲，既然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茉稠。
**倒序切片包含起始索引，不包含結束索引把夸。**
####對字符串切片
字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一種**list**而线，每個元素就是一個字符。因此恋日，字符串也可以用切片操作膀篮，只是操作結果仍是字符串：
'ABCDEFG'[:3]
'ABC'
'ABCDEFG'[-3:]
'EFG'
'ABCDEFG'[::2]
'ACEG'```
在很多編程語言中，針對字符串提供了很多各種截取函數(shù)岂膳，其實目的就是對字符串切片誓竿。Python沒有針對字符串的截取函數(shù)，只需要切片一個操作就可以完成谈截，非常簡單筷屡。
例子：
字符串有個方法 upper() 可以把字符變成大寫字母：
>>> 'abc'.upper()
'ABC'```
但它會把所有字母都變成大寫。請設計一個函數(shù)簸喂，它接受一個字符串毙死，然后返回一個僅首字母變成大寫的字符串。
**提示：**利用切片操作簡化字符串操作喻鳄。
代碼：
def firstCharUpper(s):
return s[0].upper()+s[1:]
print firstCharUpper('hello')
print firstCharUpper('sunday')
print firstCharUpper('september')```
打印結果：
Hello
Sunday
September```
###迭代
####什么是迭代
在Python中扼倘，如果給定一個**list**或**tuple**，我們可以通過for循環(huán)來遍歷這個list或tuple除呵，這種遍歷我們成為迭代（Iteration）唉锌。
在Python中，迭代是通過 for ... in 來完成的竿奏，而很多語言比如C或者Java，迭代list是通過下標完成的腥放，比如Java代碼：
for (i=0; i<list.length; i++) {
n = list[i];
}
可以看出泛啸，Python的for循環(huán)抽象程度要高于Java的for循環(huán)。
**因為 Python 的 for循環(huán)不僅可以用在list或tuple上秃症，還可以作用在其他任何可迭代對象上候址。**
因此吕粹，迭代操作就是對于一個集合，無論該集合是有序還是無序岗仑，我們用 for 循環(huán)總是可以依次取出集合的每一個元素匹耕。
注意: 集合是指包含一組元素的數(shù)據(jù)結構，我們已經(jīng)介紹的包括：
- 有序集合：list荠雕，tuple稳其，str和unicode；
- 無序集合：set
- 無序集合并且具有 key-value 對：dict```
而迭代是一個動詞炸卑，它指的是一種操作既鞠，在Python中，就是 for 循環(huán)盖文。
迭代與按下標訪問數(shù)組最大的不同是嘱蛋，后者是一種具體的迭代實現(xiàn)方式，而前者只關心迭代結果五续，根本不關心迭代內(nèi)部是如何實現(xiàn)的洒敏。
例子：
用for循環(huán)迭代數(shù)列 1-100 并打印出7的倍數(shù)
代碼：
for i in range(1,101):
if i %7 == 0:
print i```
打印結果：
7
14
21
28
35
42
49
56
63
70
77
84
91
98```
索引迭代
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
4 - Paul```
使用 enumerate() 函數(shù)偏竟，我們可以在for循環(huán)中同時綁定索引index和元素name。但是敞峭，這不是 enumerate() 的特殊語法踊谋。實際上，enumerate() 函數(shù)把：
['Adam', 'Lisa', 'Bart', 'Paul']```
變成了類似：
**[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]**```
因此旋讹，迭代的每一個元素實際上是一個tuple：
for t in enumerate(L):
index = t[0]
name = t[1]
print index, '-', name```
如果我們知道每個tuple元素都包含兩個元素殖蚕，for循環(huán)又可以進一步簡寫為：
for index, name in enumerate(L):
print index, '-', name```
這樣不但代碼更簡單，而且還少了兩條賦值語句沉迹。
可見睦疫，索引迭代也不是真的按索引訪問，而是由 enumerate() 函數(shù)自動把每個元素變成 (index, element) 這樣的tuple鞭呕，再迭代蛤育，就同時獲得了索引和元素本身。
例子：
zip()函數(shù)可以把兩個 list 變成一個 list：
zip([10, 20, 30], ['A', 'B', 'C'])[(10, 'A'), (20, 'B'), (30, 'C')]```
在迭代 ['Adam', 'Lisa', 'Bart', 'Paul'] 時，如果我們想打印出名次 - 名字（名次從1開始)瓦糕，請考慮如何在迭代中打印出來底洗。
提示：考慮使用zip()函數(shù)和range()函數(shù)
代碼：
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for index, name in zip(range(1,len(L)+1),L):
print index,'-',name```
打印結果：
1 - Adam
2 - Lisa
3 - Bart
4 - Paul```
迭代dict的value
我們已經(jīng)了解了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
如果仔細閱讀Python的文檔胡控，還可以發(fā)現(xiàn)，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 所需的內(nèi)存凡傅。
3. 打印 itervalues() 發(fā)現(xiàn)它返回一個 <dictionary-valueiterator> 對象，這說明在Python中肠缔，**for 循環(huán)可作用的迭代對象遠不止 list夏跷，tuple，str明未，unicode槽华，dict等**，任何可迭代對象都可以作用于for循環(huán)趟妥，而內(nèi)部如何迭代我們通常并不用關心猫态。
**如果一個對象說自己可迭代，那我們就直接用 for 循環(huán)去迭代它披摄，可見亲雪，迭代是一種抽象的數(shù)據(jù)操作，它不對迭代對象內(nèi)部的數(shù)據(jù)有任何要求疚膊。**
####迭代dict的key和value
我們了解了如何**迭代 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() 不占用額外的內(nèi)存舅桩。
###列表生成式
####生成列表
要生成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)建出來杰捂，十分有用，多寫幾次棋蚌，很快就可以熟悉這種語法嫁佳。
注意：range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]
復雜表達式
使用for循環(huán)的迭代不僅可以迭代普通的list，還可以迭代dict谷暮。
假設有如下的dict：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }```
完全可以通過一個復雜的列表生成式把它變成一個 HTML 表格：
tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]
print '<table>'
print '<tr><th>Name</th><th>Score</th><tr>'
print '\n'.join(tds)
print '</table>'```
注：字符串可以通過 % 進行格式化蒿往，用指定的參數(shù)替代** **%s。字符串的join()方法可以把一個 list 拼接成一個字符串坷备。
把打印出來的結果保存為一個html文件熄浓，就可以在瀏覽器中看到效果了：
<table border="1">
<tr><th>Name</th><th>Score</th><tr>
<tr><td>Lisa</td><td>85</td></tr>
<tr><td>Adam</td><td>95</td></tr>
<tr><td>Bart</td><td>59</td></tr>
</table>```
[](http://img.mukewang.com/540fcd2a0001ff4600940104.jpg)
####條件過濾
列表生成式的 **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)的當前元素添加到列表中娃惯。
例子：
編寫一個函數(shù)，它接受一個 list肥败，然后把list中所有字符串變成大寫后返回趾浅，非字符串元素將被忽略愕提。
**提示：**
1. **isinstance(x, str)** 可以判斷變量 x 是否是字符串；
2. 字符串的 **upper()** 方法可以返回大寫的字母
代碼：
def toUppers(L):
return[x.upper()for x in L if isinstance(x,str)]
print toUppers(['Hello', 'world', 101])
打印結果：
['HELLO', 'WORLD']```
多層表達式
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)```
例子：
利用 3 層for循環(huán)的列表生成式央勒，找出對稱的 3 位數(shù)不见。例如，121 就是對稱數(shù)崔步，因為從右到左倒過來還是 121稳吮。
代碼：
print [100 * n1 + 10 * n2 + n3 for n1 in range(1, 10) for n2 in range(10) for n3 in range(10) if n1==n3]```
打印結果：
[101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292, 303, 313, 323,
333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444, 454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555,
565, 575, 585, 595, 606, 616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767, 777, 787,
797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 929, 939, 949, 959, 969, 979, 989, 999]```
