基礎概念
-
tuple與list
- tuple是引用不可變的有序列表
- list是引用可變的有序列表
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
表面上看，tuple的元素變了，但其實變的不是tuple的元素，而是list的元素。tuple一開始指向的list并沒有改成別的list，所以，tuple所謂的“不變”是說，tuple的每個元素，引用永遠不變。即指向'a'，就不能改成指向'b'，指向一個list，就不能改成指向其他對象，但指向的這個list本身是可變的！
-
if...else
if <條件判斷1>:
<執(zhí)行1>
elif <條件判斷2>:
<執(zhí)行2>
elif <條件判斷3>:
<執(zhí)行3>
else:
<執(zhí)行4>
-
True_False
- 只要x是非零數(shù)值、非空字符串、非空list等，就判斷為True，否則為False：非0為真
-
三種循環(huán)
- for...in...range(100)
sum = 0
for x in range(101):
sum = sum + x
print sum
+ while True:
```
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print sum
-
string_to_int
birth = int(raw_input('birth: '))
-
list_dict
- 異同點
dict特點：
查找和插入的速度極快，不會隨著key的增加而增加；
需要占用大量的內存，內存浪費多。
而list相反：
查找和插入的時間隨著元素的增加而增加；
占用空間小，浪費內存很少。
所以，dict是用空間來換取時間的一種方法。
dict可以用在需要高速查找的很多地方，在Python代碼中幾乎無處不在，正確使用dict非常重要，需要牢記的第一條就是dict的key必須是不可變對象。
這是因為dict根據(jù)key來計算value的存儲位置，如果每次計算相同的key得出的結果不同，那dict內部就完全混亂了。這個通過key計算位置的算法稱為哈希算法（Hash）。
要保證hash的正確性，作為key的對象就不能變。在Python中，字符串、整數(shù)等都是不可變的，因此，可以放心地作為key。而list是可變的，就不能作為key。
- 異同點
-
set
- 初始化set，通過list構造
>>> s = set([1, 2, 3])
>>> s
set([1, 2, 3])
-
set可以看成數(shù)學意義上的無序和無重復元素的集合，因此，兩個set可以做數(shù)學意義上的交集、并集等操作：
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1 & s2
set([2, 3])
s1 | s2
set([1, 2, 3, 4])
8. ##### 函數(shù)
- 函數(shù)名其實就是指向一個**函數(shù)對象的引用**，完全可以把函數(shù)名賦給一個變量，相當于給這個函數(shù)起了一個“別名”：
```
>>> a = abs # 變量a指向abs函數(shù)
>>> a(-1) # 所以也可以通過a調用abs函數(shù)
1
- 返回多個值：返回的是一個tuple(,)
import math
def move(x, y, step, angle=0):
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
- 默認參數(shù)必須指向不變對象
#一是必選參數(shù)在前，默認參數(shù)在后，否則Python的解釋器會報錯（思考一下為什么默認參數(shù)不能放在必選參數(shù)前面）；
#
#二是如何設置默認參數(shù)。
def enroll(name, gender, age=6, city='Beijing'):
print 'name:', name
print 'gender:', gender
print 'age:', age
print 'city:', city
#--------------------------------------------------------------------------
>>> enroll('Bob', 'M', 7)
>>>enroll('Adam', 'M', city='Tianjin')
-
可變參數(shù) ** *args*: 在list或tuple前面加一個號，把list或tuple的元素變成可變參數(shù)傳進去：
nums = [1, 2, 3]
calc(*nums)
14
- 關鍵字參數(shù)** \*\*kw ** ：0個或任意個含參數(shù)名的參數(shù)，這些關鍵字參數(shù)在函數(shù)內部自動組裝為一個dict。
def person(name, age, **kw):
print 'name:', name, 'age:', age, 'other:', kw
-----------------------------------------------------------------------
person('Michael', 30)
name: Michael age: 30 other: {}
person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
- **參數(shù)組合**:參數(shù)定義的順序必須是：必選參數(shù)、默認參數(shù)、可變參數(shù)和關鍵字參數(shù)。
def func(a, b, c=0, *args, **kw):
print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw
-----------------------------------------------------------------------
func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
func(1, 2, 3, 'a', 'b', x=99)
print x, y
151.961524227 70.0
- 默認參數(shù)**必須指向不變對象**
#一是必選參數(shù)在前，默認參數(shù)在后，否則Python的解釋器會報錯（思考一下為什么默認參數(shù)不能放在必選參數(shù)前面）；
#
#二是如何設置默認參數(shù)。
def enroll(name, gender, age=6, city='Beijing'):
print 'name:', name
print 'gender:', gender
print 'age:', age
print 'city:', city
#--------------------------------------------------------------------------
>>> enroll('Bob', 'M', 7)
>>>enroll('Adam', 'M', city='Tianjin')
- 可變參數(shù) ** \*args**: 在list或tuple前面加一個*號，把list或tuple的元素變成可變參數(shù)傳進去：
>>> nums = [1, 2, 3]
>>> calc(*nums)
14
- 關鍵字參數(shù)** \*\*kw ** ：0個或任意個含參數(shù)名的參數(shù)，這些關鍵字參數(shù)在函數(shù)內部自動組裝為一個dict。
def person(name, age, **kw):
print 'name:', name, 'age:', age, 'other:', kw
#-----------------------------------------------------------------------
>>> person('Michael', 30)
name: Michael age: 30 other: {}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
- **參數(shù)組合**:參數(shù)定義的順序必須是：必選參數(shù)、默認參數(shù)、可變參數(shù)和關鍵字參數(shù)。
def func(a, b, c=0, *args, **kw):
print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw
#-----------------------------------------------------------------------
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
-----------------------------------------------------------------------
args = (1, 2, 3, 4)
kw = {'x': 99}
func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}
對于任意函數(shù)，都可以通過類似**func(\*args, \*\*kw)**的形式調用它，無論它的參數(shù)是如何定義的。
9. ##### 遞歸與尾遞歸優(yōu)化：
在函數(shù)返回的時候，調用自身本身，并且，return語句不能包含表達式。這樣，編譯器或者解釋器就可以把尾遞歸做優(yōu)化，使遞歸本身無論調用多少次，都只占用一個棧幀，不會出現(xiàn)棧溢出的情況
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
用函數(shù)的方式表達
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
尾遞歸的優(yōu)化：
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)
上面的fact(n)函數(shù)由于return n * fact(n - 1)引入了乘法表達式，所以就不是尾遞歸了。要改成尾遞歸方式，需要多一點代碼，主要是要把每一步的乘積傳入到遞歸函數(shù)中：`return fact_iter(num - 1, num \* product)`僅返回遞歸函數(shù)本身，`num - 1`和`num\*product`在函數(shù)調用前就會被計算，不影響函數(shù)調用。