[Python] 簡介

1. 運(yùn)行Python

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

print("Hello World")

以交互式方式使用Python時(shí)，特殊變量_用于保存最后一次運(yùn)算結(jié)果。但要強(qiáng)調(diào)的是，此變量只有在交互式工作時(shí)才有定義。如果要?jiǎng)?chuàng)建可以重復(fù)運(yùn)行的程序，可以將語句放到一個(gè)文件中：

#helloworld.py
print("Hello World")

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

2. 變量和算數(shù)表達(dá)式

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

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

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

principal = 1000; rate = 0.05; numyears = 5;
While語句對(duì)隨后的條件表達(dá)式進(jìn)行測試。因?yàn)檠h(huán)主體是由縮進(jìn)表示的，Python不會(huì)指定所需縮進(jìn)的量，只要在一個(gè)代碼塊中保持一致即可。
?

3. 條件語句

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

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

if和else子句的主體是用縮進(jìn)表示的，else子句可選。要?jiǎng)?chuàng)造一條空子句，可以使用pass語句，例如：

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

使用and、or和not關(guān)鍵字可以建立布爾類型的表達(dá)式：

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

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

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

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

4. 文件輸入和輸出

以下程序可找開一個(gè)文件并逐行讀取內(nèi)容：

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

open()函數(shù)返回一個(gè)新的文件對(duì)象。readline()方法讀取一行內(nèi)容，包括結(jié)尾的換行符。如果程序在像這樣的數(shù)據(jù)集上進(jìn)行循環(huán)，那么通常就稱為迭代。因?yàn)榈且环N很常見的操作，所以Python為其提供了一條專用語句for，例如：

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

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

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

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

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

?

5. 字符串

要?jiǎng)?chuàng)建一個(gè)字符串字面量，將字符串放在單引號(hào)、雙引號(hào)、三引號(hào)中即可，例如：

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

字符串前后使用的引號(hào)必須是對(duì)應(yīng)匹配的。當(dāng)字符串字面量的內(nèi)容需要放在多個(gè)文件行上時(shí)，三此號(hào)字符就很有用，例如：

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

字符串存儲(chǔ)在一個(gè)以0開始、使用整數(shù)索引的字符序列中，可以提取其中一個(gè)字符，例如：

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

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

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

可以使用"+"運(yùn)算符連接兩個(gè)字符串，例如：

g = a + "This is a test"

?

6. 列表

列表是任意對(duì)象的序列，把值放入方括號(hào)中就可以創(chuàng)建列表，例如：

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

列表使用從0開始的整數(shù)索引，使用索引運(yùn)算符可以訪問并修改列表中的項(xiàng)，例如：

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

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

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

使用切片運(yùn)算符可以對(duì)子列表重新賦值，例如：

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

使用"+"運(yùn)算符可以連接列表，例如：

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

創(chuàng)建空列表有兩種方式：

names = []
names = list()

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

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

?

7. 元組

要?jiǎng)?chuàng)建簡單的數(shù)據(jù)結(jié)構(gòu)，可以使用元組，在圓括號(hào)中放入一組值即可創(chuàng)建元組，例如：

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

即使沒有圓括號(hào)，Python通常也能識(shí)別出元組?？梢远x0個(gè)和1個(gè)元素的元組，例如：

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

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

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

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

8. 集合

集合用于包含一組無序的對(duì)象。要?jiǎng)?chuàng)建集合，可使用set()函數(shù)并如下所示提供一系列的項(xiàng)：

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

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

c = a | b # a和b的并集
d = a & b # a和b的交集
c = t - s # 差集（項(xiàng)在a中，但不在s中）
d = t ^ s # 對(duì)稱差集（項(xiàng)在a或b中，但不同時(shí)出現(xiàn)）

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

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

?

9. 字典

字典就是一個(gè)關(guān)聯(lián)數(shù)組或散列表，其中包含通過關(guān)鍵字索引的對(duì)象。在大括號(hào)中放入值即可創(chuàng)建字典，例如：

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

要訪問字典成員，可使用關(guān)鍵字索引運(yùn)算符，例如：

name = stock["name"]

插入或修改對(duì)象，則例如：

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

在定義一個(gè)可包含多個(gè)命名字段的對(duì)象時(shí)，字典是一種很有用的方式。然而，字典也可用作快速查找無序數(shù)據(jù)的一個(gè)容器。創(chuàng)建一個(gè)空字典的方式如下：

prices = {}
prices = dict()

使用in運(yùn)算符可以測試某個(gè)內(nèi)容項(xiàng)是不是字典成員，例如：

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

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

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

要獲得字典關(guān)鍵字的列表，直接轉(zhuǎn)換即可，例如：

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

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

del prices["MSFT"]

?

10. 迭代與循環(huán)

最常用的循環(huán)結(jié)構(gòu)是用于迭代多個(gè)項(xiàng)的for語句。例如：

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

range(i, j[, 步進(jìn)值])函數(shù)創(chuàng)建i到j(luò)-1的整數(shù)，如果起始值被省略，則認(rèn)為是0，例如：

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

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

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. 函數(shù)

使用def語句可以創(chuàng)建函數(shù)，例如：

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

要調(diào)用函數(shù)，只要使用函數(shù)名加上用圓括號(hào)括起來的參數(shù)即可，例如：

result = remainder(10, 20.5)

要給函數(shù)參數(shù)提供默認(rèn)值，可使用如下方式：

def connect(hostname, port, timeout=300)

還可以使用關(guān)鍵字參數(shù)調(diào)用函數(shù)，但需要你知道函數(shù)定義中的參數(shù)名稱，例如：

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

在函數(shù)中創(chuàng)建變量或給變量賦值時(shí)，變量的作用域是局部的，要在函數(shù)內(nèi)修改某個(gè)全局變量的值，可以使用global語句，例如：

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

?

12. 生成器

如果使用yield語句，可以讓函數(shù)生成一個(gè)結(jié)果序列，而不僅僅是一個(gè)值，例如：

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

任何使用yield的函數(shù)都稱為生成器，調(diào)用生成器函數(shù)將創(chuàng)建一個(gè)對(duì)象，該對(duì)象通過連續(xù)調(diào)用__next__()生成結(jié)果序列，例如：

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

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

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

?

13. 協(xié)程

通常函數(shù)運(yùn)行時(shí)要使用一組輸入?yún)?shù)，但是，也可以把函數(shù)編寫為一個(gè)任務(wù)，從而能處理發(fā)送給它的一系列輸入，這類函數(shù)稱為協(xié)程，例如：

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()為協(xié)程發(fā)送某個(gè)值之前，協(xié)程會(huì)暫時(shí)中止。這個(gè)過程將會(huì)繼續(xù)，直到協(xié)程函數(shù)返回或者調(diào)用它的close()方法為止。
?

14. 對(duì)象與類

程序中使用的所有值都是對(duì)象。對(duì)象由內(nèi)部數(shù)據(jù)和各種方法組成，這些方法會(huì)執(zhí)行與這些數(shù)據(jù)相關(guān)的各種操作。dir()函數(shù)可列出對(duì)象上的可用方法，是進(jìn)行交互式試驗(yàn)的有用工具，例如：

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

在面向?qū)ο蟮木幊讨?，class語句用于定義新的對(duì)象類型。例如，下面的類定義了帶有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)

在類定義第一行中，圓括號(hào)是Python指定繼承的方式，在這個(gè)例子里，Stack繼承自object,object也是所有Python類型的根類型。類定義中使用def語句定義了方法，每個(gè)方未能中的第一個(gè)參數(shù)始終指向?qū)ο蟊旧恚鶕?jù)約定，該參數(shù)名稱為self。涉及對(duì)象屬性都必須顯示引用self。要使用類，可以使用如下方式：

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

也可以定義不同種類的方法，比如靜態(tài)方法，例如：

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

EventHanlder.dispatcherTread()

?

15. 異常

如果程序中出現(xiàn)錯(cuò)誤，就會(huì)引發(fā)異常，可以使用try和except語句捕捉并處理異常，例如：

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

處理完異常后，程序?qū)⒗^續(xù)執(zhí)行緊跟在最后一個(gè)except代碼塊后面的語句。raise語句用于手工引發(fā)異常，引發(fā)異常時(shí)，可以使用任意一個(gè)內(nèi)置異常，例如：

raise RuntimeError("No")

?

16. 模塊

隨著程序越來越大，為了便于維護(hù)，需要把它分為多個(gè)文件。為此python允許把定義放入一個(gè)文件中，然后在其他程序和腳本中將其作為模塊導(dǎo)入。要?jiǎng)?chuàng)建模塊，可將相關(guān)的語句和定義放入與模塊同名的文件中（后綴必須是.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語句創(chuàng)建了一個(gè)新的命名空間，并在該命名空間中執(zhí)行與.py文件相關(guān)的所有語句。要在導(dǎo)入后訪問命名空間的內(nèi)容，只要使用該模塊的名稱作為前綴。如果要使用不同的名稱導(dǎo)入模塊，可以加上as限定符，例如：

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

要將具體的定義導(dǎo)入到當(dāng)前的命名空間，可使用from語句，例如：

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

要把模塊的所有內(nèi)容加載到當(dāng)前的命名空間中，還可以使用以下語句：

form div import *