[Python] 簡介

1. 運行Python

Python程序是由解釋器來執行的。解釋器啟動后將出現一個命令提示，在此可以開始輸入程序。在交互式shell中，可以輸入任意合法的語句或語句序列，然后立即查看結果。例如：

print("Hello World")

以交互式方式使用Python時，特殊變量_用于保存最后一次運算結果。但要強調的是，此變量只有在交互式工作時才有定義。如果要創建可以重復運行的程序，可以將語句放到一個文件中：

#helloworld.py
print("Hello World")

Python源文件是普通的文本文件，后綴通常是.py。#字符表示整行都是注釋。
?

2. 變量和算數表達式

以下程序簡要說明變量和表達式的用法：

principal = 1000 # 初始金額
rate = 0.05 # 利率
numyears = 5 # 年數
year = 1
while year <= numyears:
    principal = principal * ( 1 + rate )
    print(year, principal)
    year += 1

Python是一種動態類型的語言，在程序執行過程中，可將變更是名綁定到不同的值，而且這些值可以屬于不同的類型。換行代表一條語句的結束。然而，也可以在同一行上使用分號來隔開多條語句，例如：

principal = 1000; rate = 0.05; numyears = 5;
While語句對隨后的條件表達式進行測試。因為循環主體是由縮進表示的，Python不會指定所需縮進的量，只要在一個代碼塊中保持一致即可。
?

3. 條件語句

if與else語句可執行簡單的測試，例如：

if a < b:
    print("Yes")
else:
    print("No")

if和else子句的主體是用縮進表示的，else子句可選。要創造一條空子句，可以使用pass語句，例如：

if a < b:
    pass # do nothing
else:
    print("No")

使用and、or和not關鍵字可以建立布爾類型的表達式：

if product == "game" and not (age < 4 or age > 8):
    print("OK")

Python沒有專門的switch或case語句用于測試多個值，要處理多個分支，可以使用elif，例如：

if suffix == ".htm":
    content = "text/html"
elif suffix == ".jpg":
    content = "image/jpeg"
else:
    raise RuntimeError("Unknown Content Type")

要表示真值，可使用True和False。
?

4. 文件輸入和輸出

以下程序可找開一個文件并逐行讀取內容：

f = open("test.txt")
line = f.readline()
while line:
    print(line, end='')
    line = f.readline()
f.close()

open()函數返回一個新的文件對象。readline()方法讀取一行內容，包括結尾的換行符。如果程序在像這樣的數據集上進行循環，那么通常就稱為迭代。因為迭代是一種很常見的操作，所以Python為其提供了一條專用語句for，例如：

for line in open("test.txt"):
    print(line, end='')

要將輸出送到一個文件中，可以指定一個文件，例如：

for line in open("test.txt"):
    print(line, file=open("test2.txt", "w"))

同樣的技術也適用于標準的輸出流和輸入流。例如，想用交互方式讀取用戶輸入，可以從文件sys.stdin中讀取。如果要將數據輸出到屏幕上，可以寫入文件sys.stdout中，例如：

import sys
sys.stdout.write("Enter Your Name :")
sys.stdout.flush()
name = sys.stdin.readline()

?

5. 字符串

要創建一個字符串字面量，將字符串放在單引號、雙引號、三引號中即可，例如：

a = "Hello World"
b = 'Hello World'
c = """Hello World"""

字符串前后使用的引號必須是對應匹配的。當字符串字面量的內容需要放在多個文件行上時，三此號字符就很有用，例如：

print('''
Hello World
Content
''')

字符串存儲在一個以0開始、使用整數索引的字符序列中，可以提取其中一個字符，例如：

a = "Hello World"
b = a[4]

要提取子字符串，可以使用切片運算符s[i:j]，提取索引k的范圍是i <= k < j，如果省略i，則假定使用字符串的起始位置，如果省略j，則假定使用字符串的結尾位置，例如：

c = a[:5]
d = a[6:]
e = a[3:8]

可以使用"+"運算符連接兩個字符串，例如：

g = a + "This is a test"

?

6. 列表

列表是任意對象的序列，把值放入方括號中就可以創建列表，例如：

names = ["Dave", "Mark", "Ann"]

列表使用從0開始的整數索引，使用索引運算符可以訪問并修改列表中的項，例如：

a = names[2]
names[0] = "Jeff"

要將新項追加到列表末尾，可使用append()方法，要將一項插入到列表中，可使用insert()方法，例如：

names.append("Paula")
names.insert(2, "Thomas")

使用切片運算符可以對子列表重新賦值，例如：

names[0:2] = ["Dave", "Mark", "Jeff"]

使用"+"運算符可以連接列表，例如：

a = [1, 2, 3] + [4, 5]

創建空列表有兩種方式：

names = []
names = list()

列表可以包含任意種類的Python對象，包括其他列表，嵌套列表中包含的項需要使用多次索引才能訪問，例如：

a = [1, "Dave", 3.14, ["Mark", 7, 9]]
print(a[3][1])

?

7. 元組

要創建簡單的數據結構，可以使用元組，在圓括號中放入一組值即可創建元組，例如：

stock = ("GOOG", 100, 490.10)
address = ("www.python.org", 80)
person = (first_name, last_name, phone)

即使沒有圓括號，Python通常也能識別出元組。可以定義0個和1個元素的元組，例如：

a = ()
b = (item, ) # 注意逗號
c = item, # 注意逗號

和列表一樣，也可以使用數字索引來提取元組中的值，更常見的做法是將元組解包為一組變量，例如：

name, shares, price = stock
host, port = address
first_name, last_name, phone = person

盡管元組支持的大部分操作與旬表的相同，但創建元組后不能修改它的內容。程序元往往忽略了元組，而只用列表，但如果程序要創建大量的小列表，就會造成內存浪費。元組是不可變的，所以它們的表示更為緊湊，不會占據額外的內存空間。
?

8. 集合

集合用于包含一組無序的對象。要創建集合，可使用set()函數并如下所示提供一系列的項：

a = set([3, 5, 7, 9])
b = set("Hello")

集合是無序的，也無法通過數字進行索引。此外，集合中的元素不能重復，如果檢查前面代碼b集合的值，結果會是(['H', 'e', 'l', 'o'])。集合支持一系列標準操作，包括并集、交集、差集和對稱差集，例如：

c = a | b # a和b的并集
d = a & b # a和b的交集
c = t - s # 差集（項在a中，但不在s中）
d = t ^ s # 對稱差集（項在a或b中，但不同時出現）

使用add()和update()可以在集合中添加新項，例如：

a.add('x') # 添加一項
b.update([10, 20, 30]) # 添加多項

?

9. 字典

字典就是一個關聯數組或散列表，其中包含通過關鍵字索引的對象。在大括號中放入值即可創建字典，例如：

stock = {
    "name" : "GOOG",
    "shares" : 100,
    "price" : 490.10
}

要訪問字典成員，可使用關鍵字索引運算符，例如：

name = stock["name"]

插入或修改對象，則例如：

stock["shares"] = 75
stock["date"] = "June 7, 2007"

在定義一個可包含多個命名字段的對象時，字典是一種很有用的方式。然而，字典也可用作快速查找無序數據的一個容器。創建一個空字典的方式如下：

prices = {}
prices = dict()

使用in運算符可以測試某個內容項是不是字典成員，例如：

if "SCOX" in prices:
    p = prices["SCOX"]
else:
    p = 0.0

還可以把這樣的步驟寫成更簡潔的形式，例如：

p = prices.get("SCOX", 0.0)

要獲得字典關鍵字的列表，直接轉換即可，例如：

syms = list(prices) # 注意是關鍵字的列表，不是值

使用del語句可以刪除字典的元素：

del prices["MSFT"]

?

10. 迭代與循環

最常用的循環結構是用于迭代多個項的for語句。例如：

for n in [1, 2, 3, 4, 5]:
    print(n)

range(i, j[, 步進值])函數創建i到j-1的整數，如果起始值被省略，則認為是0，例如：

a = range(5)
b = range(1, 9)
c = range(8, 1, -1)

for語句還可用于迭代多種對象，包括字符串、列表、字典和文件，例如：

a = "Hello World"
for c in a:
    print(c)
b = ["Dave", "Mark", "Ann"]
for name in b:
    print(name)
c= {
    "GOOG": 490.10,
    "IBM": 91.50,
    "AAPL": 123.15
}
for key in c:
    print(key, c[key])

?

11. 函數

使用def語句可以創建函數，例如：

def remainder(a, b):
    q = a * b
    return q

要調用函數，只要使用函數名加上用圓括號括起來的參數即可，例如：

result = remainder(10, 20.5)

要給函數參數提供默認值，可使用如下方式：

def connect(hostname, port, timeout=300)

還可以使用關鍵字參數調用函數，但需要你知道函數定義中的參數名稱，例如：

connect(port=80, hostname="www.test.com")

在函數中創建變量或給變量賦值時，變量的作用域是局部的，要在函數內修改某個全局變量的值，可以使用global語句，例如：

count  = 0
def foo():
    global count
    count += 1

?

12. 生成器

如果使用yield語句，可以讓函數生成一個結果序列，而不僅僅是一個值，例如：

def countdown(n):
    print("Counting down!")
    while n > 0:
        yield n
        n -= 1

任何使用yield的函數都稱為生成器，調用生成器函數將創建一個對象，該對象通過連續調用__next__()生成結果序列，例如：

c = countdown(5)
c.__next__() # Counting down! 5
c.__next__() # 4
c.__next__() # 3

__next__()調用使生成器函數一直運行到下一條yield語句為止。此時__next__()將返回值傳遞給yield，而且函數將暫時中止。再次調用__next__()時，函數將繼續執行yield之后的語句。通常不會像上面這樣調用__next__()，而是會使用一個for循環，例如：

for i in countdown(5):
    print(i)

?

13. 協程

通常函數運行時要使用一組輸入參數，但是，也可以把函數編寫為一個任務，從而能處理發送給它的一系列輸入，這類函數稱為協程，例如：

def print_matches(matchtext):
    print("Looking for", matchtext)
    while True:
        line = (yield)
        if matchtext in line:
            print(line)

matcher = print_matches("python")
matcher.__next__()
matcher.send("Hello World")
matcher.send("python is cool")
matcher.close()

使用send()為協程發送某個值之前，協程會暫時中止。這個過程將會繼續，直到協程函數返回或者調用它的close()方法為止。
?

14. 對象與類

程序中使用的所有值都是對象。對象由內部數據和各種方法組成，這些方法會執行與這些數據相關的各種操作。dir()函數可列出對象上的可用方法，是進行交互式試驗的有用工具，例如：

items = [10, 20]
print(dir(items))

在面向對象的編程中，class語句用于定義新的對象類型。例如，下面的類定義了帶有push()、pop()和length()操作的簡單棧：

class Stack(object):
    def __init__(self):
            self.stack = []
    def push(self, object):
        self.stack.append(object)
    def pop(self):
        return self.stack.pop()
    def length(self):
        return len(self.stack)

在類定義第一行中，圓括號是Python指定繼承的方式，在這個例子里，Stack繼承自object,object也是所有Python類型的根類型。類定義中使用def語句定義了方法，每個方未能中的第一個參數始終指向對象本身，根據約定，該參數名稱為self。涉及對象屬性都必須顯示引用self。要使用類，可以使用如下方式：

s = Stack()
s.push("Dave")
x = s.pop()
del s

也可以定義不同種類的方法，比如靜態方法，例如：

class EventHanlder(object)
    @staticmethod
    def dispatcherThread():
        while(1):
            # 方法體

EventHanlder.dispatcherTread()

?

15. 異常

如果程序中出現錯誤，就會引發異常，可以使用try和except語句捕捉并處理異常，例如：

try:
    f = open("test.text", "w")
except IOError as e:
    print(e)

處理完異常后，程序將繼續執行緊跟在最后一個except代碼塊后面的語句。raise語句用于手工引發異常，引發異常時，可以使用任意一個內置異常，例如：

raise RuntimeError("No")

?

16. 模塊

隨著程序越來越大，為了便于維護，需要把它分為多個文件。為此python允許把定義放入一個文件中，然后在其他程序和腳本中將其作為模塊導入。要創建模塊，可將相關的語句和定義放入與模塊同名的文件中（后綴必須是.py），例如：

# file: div.py
def divide(a, b):
    q = a / b
    r = q - q * b
    return (q, r)

要在其他程序中使用該模塊，可以使用import語句，例如：

import div
a, b = div.divide(10, 20)

import語句創建了一個新的命名空間，并在該命名空間中執行與.py文件相關的所有語句。要在導入后訪問命名空間的內容，只要使用該模塊的名稱作為前綴。如果要使用不同的名稱導入模塊，可以加上as限定符，例如：

import div as foo
a, b = foo.divide(10, 20)

要將具體的定義導入到當前的命名空間，可使用from語句，例如：

from div import divide
a, b = divide(10, 20)

要把模塊的所有內容加載到當前的命名空間中，還可以使用以下語句：

form div import *