前言：
python編寫非常簡潔
 

第一行註釋是為了告訴Linux/OS X系統，這是一個Python可執行程式，Windows系統會忽略這個註釋；

CPython用>>>作為提示符，而IPython用In [序號]:作為提示符。

print()函式也可以接受多個字串，用逗號“,”隔開，就可以連成一串輸出 輸入：

/除法計算結果是浮點數，即使是兩個整數恰好整除，結果也是浮點數，

還有一種除法是//，稱為地板除，兩個整數的除法仍然是整數

轉義字元\可以轉義很多字元，比如\n表示換行，\t表示製表符，字元\本身也要轉義，所以\\表示的字元就是\，

統一成Unicode編碼，亂碼問題從此消失了，本著節約的精神，又出現了把Unicode編碼轉化為“可變長編碼”的UTF-8

編碼。UTF-8編碼把一個Unicode字元根據不同的數字大小編碼成1-6個位元組，常用的英文字母被編碼成1個位元組，漢字通常是3個位元組，只有很生僻的字元才會被編碼成4-6個位元組。如果你要傳輸的文字包含大量英文字元，用UTF-8編碼就能節省空間

字元	ASCII	Unicode	UTF-8
A	01000001	00000000 01000001	01000001
中	x	01001110 00101101	11100100 10111000 10101101

由於Python的字串型別是str，在記憶體中以Unicode表示，一個字元對應若干個位元組。如果要在網路上傳輸，或者儲存到磁碟上，就需要把str變為以位元組為單位的

bytes。浮點數也就是小數 
用\n寫在一行裡不好閱讀，為了簡化，Python允許用'''...'''的格式表示多行內容
 

因為tuple不可變，所以程式碼更安全。如果可能，能用tuple代替list就儘量用tuple。

Python提供一個range()函式，可以生成一個整數序列，再通過list()函式可以轉換為list。比如range(5)生成的序列是從0開始小於5的整數
列表 list=['a','b','e']   用len()函式可以獲得list元素的個數
元祖 class=('a','b','e') 不能更改

input()返回的資料型別是str，str不能直接和整數比較，必須先把str轉換成整數。Python提供了int()函式來完成這件事情

要特別注意，不要濫用break和continue語句。break和continue會造成程式碼執行邏輯分叉過多，容易出錯。大多數迴圈並不需要用到break和continue語句，上面的兩個例子，都可以通過改寫迴圈條件或者修改迴圈邏輯，去掉break和continue語句。

list或tuple的部分元素是非常常見的操作 切片

給定一個list或tuple，我們可以通過for迴圈來遍歷這個list或tuple，這種遍歷我們稱為迭代（Iteration）

我們建立了一個generator後，基本上永遠不會呼叫next()，而是通過for迴圈來迭代它

生成器：generator

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

[x * x for x in range(1, 11) if x % 2 == 0]  條件過濾

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

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

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

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

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

和list比較，dict有以下幾個特點：

1. 查詢和插入的速度極快，不會隨著key的增加而變慢；
2. 需要佔用大量的記憶體，記憶體浪費多。

所以，dict是用空間來換取時間的一種方法。

函式分為內建函式和自定義的函式（函式使用的原則：先定義，再呼叫）

預設引數可以簡化函式的呼叫。設定預設引數時，有幾點要注意：

一是必選引數在前，預設引數在後，否則Python的直譯器會報錯（思考一下為什麼預設引數不能放在必選引數前面）；

二是如何設定預設引數。

我們可以把年齡和城市設為預設引數：

def enroll(name, gender, age=6, city='Chongqing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)

這樣，大多數學生註冊時不需要提供年齡和城市，只提供必須的兩個引數：

Python函式在定義的時候，預設引數L的值就被計算出來了，即[]，因為預設引數L也是一個變數，它指向物件[]，每次呼叫該函式，如果改變了L的內容，則下次呼叫時，預設引數的內容就變了，不再是函式定義時的[]了。

 定義預設引數要牢記一點：預設引數必須指向不變物件！

要修改上面的例子，我們可以用None這個不變物件來實現：

def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L

現在，無論呼叫多少次，都不會有問題：

生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))

[x * x for x in range(1, 11)]

在Python中，這種一邊迴圈一邊計算的機制，稱為生成器：generator。

 g = (x * x for x in range(10))

一個最簡單的高階函式：

def add(x, y, f):
    return f(x) + f(y)

print(add(-5, 6, abs))

把函式作為引數傳入，這樣的函式稱為高階函式，函數語言程式設計就是指這種高度抽象的程式設計正規化。

Python內建了map()和reduce()函式。

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

Python內建的filter()函式用於過濾序列。

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

函式物件有一個__name__屬性，可以拿到函式的名字：

在函式呼叫前後自動列印日誌，但又不希望修改now()函式的定義，這種在程式碼執行期間動態增加功能的方式，稱之為“裝飾器”（Decorator）。

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

現在，假設我們的abc和xyz這兩個模組名字與其他模組衝突了，於是我們可以通過包來組織模組，避免衝突。方法是選擇一個頂層包名，比如mycompany，按照如下目錄存放：

mycompany
├─ __init__.py
├─ abc.py
└─ xyz.py

引入了包以後，只要頂層的包名不與別人衝突，那所有模組都不會與別人衝突。現在，abc.py模組的名字就變成了mycompany.abc，類似的，xyz.py的模組名變成了mycompany.xyz。

請注意，每一個包目錄下面都會有一個__init__.py的檔案，這個檔案是必須存在的，否則，Python就把這個目錄當成普通目錄，而不是一個包。__init__.py可以是空檔案，也可以有Python程式碼，因為__init__.py本身就是一個模組，而它的模組名就是mycompany。

建立自己的模組時，要注意：

• 模組名要遵循Python變數命名規範，不要使用中文、特殊字元；
• 模組名不要和系統模組名衝突，最好先檢視系統是否已存在該模組，檢查方法是在Python互動環境執行import abc，若成功則說明系統存在此模組。

面向物件

一個例子來說明面向過程和麵向物件在程式流程上的不同之處。

假設我們要處理學生的成績表，為了表示一個學生的成績，面向過程的程式可以用一個dict表示：

std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }

而處理學生成績可以通過函式實現，比如列印學生的成績：

def print_score(std):
    print('%s: %s' % (std['name'], std['score']))

如果採用面向物件的程式設計思想，我們首選思考的不是程式的執行流程，而是Student這種資料型別應該被視為一個物件，這個物件擁有name和score這兩個屬性（Property）。如果要列印一個學生的成績，首先必須創建出這個學生對應的物件，然後，給物件發一個print_score訊息，讓物件自己把自己的資料打印出來。

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print('%s: %s' % (self.name, self.score))

給物件發訊息實際上就是呼叫物件對應的關聯函式，我們稱之為物件的方法（Method）。面向物件的程式寫出來就像這樣：

bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()

所以，面向物件的設計思想是抽象出Class，根據Class建立Instance。

 注意：特殊方法“__init__”前後分別有兩個下劃線！！！

我們來判斷物件型別，使用type()函式：基本型別都可以用type()判斷：

為了限制score的範圍，可以通過一個set_score()方法來設定成績，再通過一個get_score()來獲取成績，這樣，在set_score()方法裡，就可以檢查引數：

錯誤處理:

try:
    print('try...')
    r = 10 / int('2')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')
print('END')

SQLite是一種嵌入式資料庫，它的資料庫就是一個檔案。由於SQLite本身是C寫的，而且體積很小，所以，經常被整合到各種應用程式中，甚至在iOS和Android的App中都可以整合。

在處理一些不規範的第三方網頁的時候。雖然Python提供了Unicode表示的str和bytes兩種資料型別，並且可以通過encode()和decode()方法轉換，但是，在不知道編碼的情況下，對bytes做decode()不好做。

使用chardet檢測編碼非常容易，chardet支援檢測中文、日文、韓文等多種語言。

virtualenv為應用提供了隔離的Python執行環境，解決了不同應用間多版本的衝突問題。

什麼是閉包？

def foo():
    m=3
    n=5
    def bar():
        a=4
        return m+n+a #引用外部變數
    return bar
 
>>>bar =  foo() #外部呼叫
>>>bar() #接著內部呼叫
12
---------------------------------------
說明：
bar在foo函式的程式碼塊中定義。我們稱bar是foo的內部函式。

在bar的區域性作用域中可以直接訪問foo區域性作用域中定義的m、n變數。
簡單的說，這種內部函式可以使用外部函式變數的行為，就叫閉包。

裝飾器

裝飾器就是閉包函式的一種應用場景

1、為何要用裝飾器

開放封閉原則：對修改封閉，對擴充套件開放

2、什麼是裝飾器

就是裝飾其他函式。

強調裝飾器的原則：

1. 不修改被裝飾物件的原始碼
2. 不修改被裝飾物件的呼叫方式

裝飾器的目標：在遵循1和2的前提下，為被裝飾物件新增上新功能

4、裝飾器語法

#被裝飾函式的正上方，單獨一行，就是先執行裝飾器的，再執行自己的
        @deco1
        @deco2
        @deco3
        def foo():
            pass
 
        foo=deco1(deco2(deco3(foo)))