Python資料
今天內容：python3-basic-operators.html
********************************************************php
什麼是運算符？
本章節主要說明Python的運算符。舉個簡單的例子 4 +5 = 9 。 例子中，4 和 5 被稱爲操做數，"+" 稱爲運算符。html
Python語言支持如下類型的運算符:python
算術運算符mysql
比較（關係）運算符linux
賦值運算符git
邏輯運算符程序員
位運算符github
成員運算符web
身份運算符正則表達式
運算符優先級
接下來讓咱們一個個來學習Python的運算符。
Python算術運算符
如下假設變量a爲10，變量b爲21：
| 運算符 | 描述 | 實例 |
|---|---|---|
| + | 加 - 兩個對象相加 | a + b 輸出結果 31 |
| - | 減 - 獲得負數或是一個數減去另外一個數 | a - b 輸出結果 -11 |
| * | 乘 - 兩個數相乘或是返回一個被重複若干次的字符串 | a * b 輸出結果 210 |
| / | 除 - x 除以 y | b / a 輸出結果 2.1 |
| % | 取模 - 返回除法的餘數 | b % a 輸出結果 1 |
| ** | 冪 - 返回x的y次冪 | a**b 爲10的21次方 |
| // | 取整除 - 返回商的整數部分 | 9//2 輸出結果 4 , 9.0//2.0 輸出結果 4.0 |
................................................................................
如下實例演示了Python全部算術運算符的操做：
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值爲：", c)
c = a - b
print ("2 - c 的值爲：", c)
c = a * b
print ("3 - c 的值爲：", c)
c = a / b
print ("4 - c 的值爲：", c)
c = a % b
print ("5 - c 的值爲：", c)
# 修改變量 a 、b 、c
a = 2
b = 3
c = a**b
print ("6 - c 的值爲：", c)
a = 10
b = 5
c = a//b
print ("7 - c 的值爲：", c)
................................................................................
以上實例輸出結果：
1 - c 的值爲： 31 2 - c 的值爲： 11 3 - c 的值爲： 210 4 - c 的值爲： 2.1 5 - c 的值爲： 1 6 - c 的值爲： 8 7 - c 的值爲： 2
................................................................................
Python比較運算符
如下假設變量a爲10，變量b爲20：
| 運算符 | 描述 | 實例 |
|---|---|---|
| == | 等於 - 比較對象是否相等 | (a == b) 返回 False。 |
| != | 不等於 - 比較兩個對象是否不相等 | (a != b) 返回 true. |
| > | 大於 - 返回x是否大於y | (a > b) 返回 False。 |
| < | 小於 - 返回x是否小於y。全部比較運算符返回1表示真，返回0表示假。這分別與特殊的變量True和False等價。注意，這些變量名的大寫。 | (a < b) 返回 true。 |
| >= | 大於等於 - 返回x是否大於等於y。 | (a >= b) 返回 False。 |
| <= | 小於等於 - 返回x是否小於等於y。 | (a <= b) 返回 true。 |
................................................................................
如下實例演示了Python全部比較運算符的操做：
#!/usr/bin/python3
a = 21
b = 10
c = 0
if ( a == b ):
print ("1 - a 等於 b")
else:
print ("1 - a 不等於 b")
if ( a != b ):
print ("2 - a 不等於 b")
else:
print ("2 - a 等於 b")
if ( a < b ):
print ("3 - a 小於 b")
else:
print ("3 - a 大於等於 b")
if ( a > b ):
print ("4 - a 大於 b")
else:
print ("4 - a 小於等於 b")
# 修改變量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
print ("5 - a 小於等於 b")
else:
print ("5 - a 大於 b")
if ( b >= a ):
print ("6 - b 大於等於 b")
else:
print ("6 - b 小於 b")
................................................................................
以上實例輸出結果：
1 - a 不等於 b 2 - a 不等於 b 3 - a 大於等於 b 4 - a 大於 b 5 - a 小於等於 b 6 - b 大於等於 b
................................................................................
Python賦值運算符
如下假設變量a爲10，變量b爲20：
| 運算符 | 描述 | 實例 |
|---|---|---|
| = | 簡單的賦值運算符 | c = a + b 將 a + b 的運算結果賦值爲 c |
| += | 加法賦值運算符 | c += a 等效於 c = c + a |
| -= | 減法賦值運算符 | c -= a 等效於 c = c - a |
| *= | 乘法賦值運算符 | c *= a 等效於 c = c * a |
| /= | 除法賦值運算符 | c /= a 等效於 c = c / a |
| %= | 取模賦值運算符 | c %= a 等效於 c = c % a |
| **= | 冪賦值運算符 | c **= a 等效於 c = c ** a |
| //= | 取整除賦值運算符 | c //= a 等效於 c = c // a |
................................................................................
如下實例演示了Python全部賦值運算符的操做：
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值爲：", c)
c += a
print ("2 - c 的值爲：", c)
c *= a
print ("3 - c 的值爲：", c)
c /= a
print ("4 - c 的值爲：", c)
c = 2
c %= a
print ("5 - c 的值爲：", c)
c **= a
print ("6 - c 的值爲：", c)
c //= a
print ("7 - c 的值爲：", c)
................................................................................
以上實例輸出結果：
1 - c 的值爲： 31 2 - c 的值爲： 52 3 - c 的值爲： 1092 4 - c 的值爲： 52.0 5 - c 的值爲： 2 6 - c 的值爲： 2097152 7 - c 的值爲： 99864
................................................................................
Python位運算符
按位運算符是把數字看做二進制來進行計算的。Python中的按位運算法則以下：
下表中變量 a 爲 60，b 爲 13。
| 運算符 | 描述 | 實例 |
|---|---|---|
| & | 按位與運算符：參與運算的兩個值,若是兩個相應位都爲1,則該位的結果爲1,不然爲0 | (a & b) 輸出結果 12 ，二進制解釋： 0000 1100 |
| | | 按位或運算符：只要對應的二個二進位有一個爲1時，結果位就爲1。 | (a | b) 輸出結果 61 ，二進制解釋： 0011 1101 |
| ^ | 按位異或運算符：當兩對應的二進位相異時，結果爲1 | (a ^ b) 輸出結果 49 ，二進制解釋： 0011 0001 |
| ~ | 按位取反運算符：對數據的每一個二進制位取反,即把1變爲0,把0變爲1 | (~a ) 輸出結果 -61 ，二進制解釋： 1100 0011， 在一個有符號二進制數的補碼形式。 |
| << | 左移動運算符：運算數的各二進位所有左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。 | a << 2 輸出結果 240 ，二進制解釋： 1111 0000 |
| >> | 右移動運算符：把">>"左邊的運算數的各二進位所有右移若干位，">>"右邊的數指定移動的位數 | a >> 2 輸出結果 15 ，二進制解釋： 0000 1111 |
................................................................................
如下實例演示了Python全部位運算符的操做：
#!/usr/bin/python3
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b; # 12 = 0000 1100
print ("1 - c 的值爲：", c)
c = a | b; # 61 = 0011 1101
print ("2 - c 的值爲：", c)
c = a ^ b; # 49 = 0011 0001
print ("3 - c 的值爲：", c)
c = ~a; # -61 = 1100 0011
print ("4 - c 的值爲：", c)
c = a << 2; # 240 = 1111 0000
print ("5 - c 的值爲：", c)
c = a >> 2; # 15 = 0000 1111
print ("6 - c 的值爲：", c)
................................................................................
以上實例輸出結果：
1 - c 的值爲： 12 2 - c 的值爲： 61 3 - c 的值爲： 49 4 - c 的值爲： -61 5 - c 的值爲： 240 6 - c 的值爲： 15
................................................................................
Python邏輯運算符
Python語言支持邏輯運算符，如下假設變量 a 爲 10, b爲 20:
| 運算符 | 邏輯表達式 | 描述 | 實例 |
|---|---|---|---|
| and | x and y | 布爾"與" - 若是 x 爲 False，x and y 返回 False，不然它返回 y 的計算值。 | (a and b) 返回 20。 |
| or | x or y | 布爾"或" - 若是 x 是 True，它返回 True，不然它返回 y 的計算值。 | (a or b) 返回 10。 |
| not | not x | 布爾"非" - 若是 x 爲 True，返回 False 。若是 x 爲 False，它返回 True。 | not(a and b) 返回 False |
................................................................................
以上實例輸出結果：
#!/usr/bin/python3
a = 10
b = 20
if ( a and b ):
print ("1 - 變量 a 和 b 都爲 true")
else:
print ("1 - 變量 a 和 b 有一個不爲 true")
if ( a or b ):
print ("2 - 變量 a 和 b 都爲 true，或其中一個變量爲 true")
else:
print ("2 - 變量 a 和 b 都不爲 true")
# 修改變量 a 的值
a = 0
if ( a and b ):
print ("3 - 變量 a 和 b 都爲 true")
else:
print ("3 - 變量 a 和 b 有一個不爲 true")
if ( a or b ):
print ("4 - 變量 a 和 b 都爲 true，或其中一個變量爲 true")
else:
print ("4 - 變量 a 和 b 都不爲 true")
if not( a and b ):
print ("5 - 變量 a 和 b 都爲 false，或其中一個變量爲 false")
else:
print ("5 - 變量 a 和 b 都爲 true")
................................................................................
以上實例輸出結果：
1 - 變量 a 和 b 都爲 true 2 - 變量 a 和 b 都爲 true，或其中一個變量爲 true 3 - 變量 a 和 b 有一個不爲 true 4 - 變量 a 和 b 都爲 true，或其中一個變量爲 true 5 - 變量 a 和 b 都爲 false，或其中一個變量爲 false
................................................................................
Python成員運算符
除了以上的一些運算符以外，Python還支持成員運算符，測試實例中包含了一系列的成員，包括字符串，列表或元組。
| 運算符 | 描述 | 實例 |
|---|---|---|
| in | 若是在指定的序列中找到值返回 True，不然返回 False。 | x 在 y 序列中 , 若是 x 在 y 序列中返回 True。 |
| not in | 若是在指定的序列中沒有找到值返回 True，不然返回 False。 | x 不在 y 序列中 , 若是 x 不在 y 序列中返回 True。 |
................................................................................
如下實例演示了Python全部成員運算符的操做：
#!/usr/bin/python3
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print ("1 - 變量 a 在給定的列表中 list 中")
else:
print ("1 - 變量 a 不在給定的列表中 list 中")
if ( b not in list ):
print ("2 - 變量 b 不在給定的列表中 list 中")
else:
print ("2 - 變量 b 在給定的列表中 list 中")
# 修改變量 a 的值
a = 2
if ( a in list ):
print ("3 - 變量 a 在給定的列表中 list 中")
else:
print ("3 - 變量 a 不在給定的列表中 list 中")
................................................................................
以上實例輸出結果：
1 - 變量 a 不在給定的列表中 list 中 2 - 變量 b 不在給定的列表中 list 中 3 - 變量 a 在給定的列表中 list 中
................................................................................
Python身份運算符
身份運算符用於比較兩個對象的存儲單元
| 運算符 | 描述 | 實例 |
|---|---|---|
| is | is是判斷兩個標識符是否是引用自一個對象 | x is y, 若是 id(x) 等於 id(y) , is 返回結果 1 |
| is not | is not是判斷兩個標識符是否是引用自不一樣對象 | x is not y, 若是 id(x) 不等於 id(y). is not 返回結果 1 |
................................................................................
如下實例演示了Python全部身份運算符的操做：
#!/usr/bin/python3
a = 20
b = 20
if ( a is b ):
print ("1 - a 和 b 有相同的標識")
else:
print ("1 - a 和 b 沒有相同的標識")
if ( id(a) == id(b) ):
print ("2 - a 和 b 有相同的標識")
else:
print ("2 - a 和 b 沒有相同的標識")
# 修改變量 b 的值
b = 30
if ( a is b ):
print ("3 - a 和 b 有相同的標識")
else:
print ("3 - a 和 b 沒有相同的標識")
if ( a is not b ):
print ("4 - a 和 b 沒有相同的標識")
else:
print ("4 - a 和 b 有相同的標識")
................................................................................
以上實例輸出結果：
1 - a 和 b 有相同的標識 2 - a 和 b 有相同的標識 3 - a 和 b 沒有相同的標識 4 - a 和 b 沒有相同的標識
................................................................................
Python運算符優先級
如下表格列出了從最高到最低優先級的全部運算符：
| 運算符 | 描述 |
|---|---|
| ** | 指數 (最高優先級) |
| ~ + - | 按位翻轉, 一元加號和減號 (最後兩個的方法名爲 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法減法 |
| >> << | 右移，左移運算符 |
| & | 位 'AND' |
| ^ | | 位運算符 |
| <= < > >= | 比較運算符 |
| <> == != | 等於運算符 |
| = %= /= //= -= += *= **= | 賦值運算符 |
| is is not | 身份運算符 |
| in not in | 成員運算符 |
| not or and | 邏輯運算符 |
................................................................................
如下實例演示了Python全部運算符優先級的操做：
#!/usr/bin/python3
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print ("(a + b) * c / d 運算結果爲：", e)
e = ((a + b) * c) / d # (30 * 15 ) / 5
print ("((a + b) * c) / d 運算結果爲：", e)
e = (a + b) * (c / d); # (30) * (15/5)
print ("(a + b) * (c / d) 運算結果爲：", e)
e = a + (b * c) / d; # 20 + (150/5)
print ("a + (b * c) / d 運算結果爲：", e)
................................................................................
以上實例輸出結果：
(a + b) * c / d 運算結果爲： 90.0 ((a + b) * c) / d 運算結果爲： 90.0 (a + b) * (c / d) 運算結果爲： 90.0 a + (b * c) / d 運算結果爲： 50.0
................................................................................
休息一下子……
今天內容：python3-basic-syntax.html
********************************************************
編碼
默認狀況下，Python 3 源碼文件以 UTF-8 編碼，全部字符串都是 unicode 字符串。 固然你也能夠爲源碼文件指定不一樣的編碼：
# -*- coding: cp-1252 -*-
................................................................................
標識符
第一個字符必須是字母表中字母或下劃線'_'。
標識符的其餘的部分有字母、數字和下劃線組成。
標識符對大小寫敏感。
在Python 3中，非-ASCII 標識符也是容許的了。
python保留字
保留字即關鍵字，咱們不能把它們用做任何標識符名稱。Python的標準庫提供了一個keyword module，能夠輸出當前版本的全部關鍵字：
>>> import keyword >>> keyword.kwlist ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
................................................................................
註釋
Python中單行註釋以 # 開頭，實例以下：
#!/usr/bin/python3
# 第一個註釋
print ("Hello, Python!") # 第二個註釋
................................................................................
執行以上代碼，輸出結果爲：
Hello, Python!
................................................................................
多行註釋能夠用多個 # 號：
#!/usr/bin/python3
# 第一個註釋
# 第二個註釋
print ("Hello, Python!")
................................................................................
執行以上代碼，輸出結果爲：
Hello, Python!
................................................................................
行與縮進
python最具特點的就是使用縮進來表示代碼塊，不須要使用大括號({})。
縮進的空格數是可變的，可是同一個代碼塊的語句必須包含相同的縮進空格數。實例以下：
if True:
print ("True")
else:
print ("False")
................................................................................
如下代碼最後一行語句縮進數的空格數不一致，會致使運行錯誤：
if True:
print ("Answer")
print ("True")
else:
print "(Answer")
print ("False") # 縮進不一致，會致使運行錯誤
................................................................................
以上程序因爲縮進不一致，執行後會出現相似如下錯誤：
File "test.py", line 5 print "(Answer") ^ SyntaxError: invalid syntax
................................................................................
多行語句
Python 一般是一行寫完一條語句，但若是語句很長，咱們能夠使用反斜槓(\)來實現多行語句，例如：
total = item_one + \ item_two + \ item_three
................................................................................
在 [], {}, 或 () 中的多行語句，不須要使用反斜槓(\)，例如：
total = ['item_one', 'item_two', 'item_three', 'item_four', 'item_five']
................................................................................
數據類型
python中數有四種類型：整數、長整數、浮點數和複數。
整數， 如 1
長整數 是比較大的整數
浮點數 如 1.2三、3E-2
複數 如 1 + 2j、 1.1 + 2.2j
字符串
python中單引號和雙引號使用徹底相同。
使用三引號('''或""")能夠指定一個多行字符串。
轉義符 '\'
天然字符串， 經過在字符串前加r或R。 如 r"this is a line with \n" 則\n會顯示，並非換行。
python容許處理unicode字符串，加前綴u或U， 如 u"this is an unicode string"。
字符串是不可變的。
按字面意義級聯字符串，如"this " "is " "string"會被自動轉換爲this is string。
word = '字符串' sentence = "這是一個句子。" paragraph = """這是一個段落， 能夠由多行組成"""
................................................................................
空行
函數之間或類的方法之間用空行分隔，表示一段新的代碼的開始。類和函數入口之間也用一行空行分隔，以突出函數入口的開始。
空行與代碼縮進不一樣，空行並非Python語法的一部分。書寫時不插入空行，Python解釋器運行也不會出錯。可是空行的做用在於分隔兩段不一樣功能或含義的代碼，便於往後代碼的維護或重構。
記住：空行也是程序代碼的一部分。
等待用戶輸入
執行下面的程序在按回車鍵後就會等待用戶輸入：
#!/usr/bin/python3
input("\n\n按下 enter 鍵後退出。")
................................................................................
以上代碼中 ，"\n\n"在結果輸出前會輸出兩個新的空行。一旦用戶按下鍵時，程序將退出。
同一行顯示多條語句
#!/usr/bin/python3 import sys; x = 'php'; sys.stdout.write(x + '\n')
................................................................................
執行以上代碼，輸入結果爲：
$ python3 test.py php
................................................................................
多個語句構成代碼組
縮進相同的一組語句構成一個代碼塊，咱們稱之代碼組。
像if、while、def和class這樣的複合語句，首行以關鍵字開始，以冒號( : )結束，該行以後的一行或多行代碼構成代碼組。
咱們將首行及後面的代碼組稱爲一個子句(clause)。
以下實例：
if expression : suite elif expression : suite else : suite
................................................................................
命令行參數
不少程序能夠執行一些操做來查看一些基本信，Python能夠使用-h參數查看各參數幫助信息：
$ python -h usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ... Options and arguments (and corresponding environment variables): -c cmd : program passed in as string (terminates option list) -d : debug output from parser (also PYTHONDEBUG=x) -E : ignore environment variables (such as PYTHONPATH) -h : print this help message and exit [ etc. ]
................................................................................
咱們在使用腳本形式執行 Python 時，能夠接收命令行輸入的參數，具體使用能夠參照 Python 3 命令行參數。
休息一下子……
今天內容：python3-cgi-programming.html
********************************************************
什麼是CGI
CGI 目前由NCSA維護，NCSA定義CGI以下：
CGI(Common Gateway Interface),通用網關接口,它是一段程序,運行在服務器上如：HTTP服務器，提供同客戶端HTML頁面的接口。
網頁瀏覽
爲了更好的瞭解CGI是如何工做的，咱們能夠從在網頁上點擊一個連接或URL的流程：
一、使用你的瀏覽器訪問URL並鏈接到HTTP web 服務器。
二、Web服務器接收到請求信息後會解析URL，並查找訪問的文件在服務器上是否存在，若是存在返回文件的內容，不然返回錯誤信息。
三、瀏覽器從服務器上接收信息，並顯示接收的文件或者錯誤信息。
CGI程序能夠是Python腳本，PERL腳本，SHELL腳本，C或者C++程序等。
CGI架構圖
Web服務器支持及配置
在你進行CGI編程前，確保您的Web服務器支持CGI及已經配置了CGI的處理程序。
Apache 支持CGI 配置：
設置好CGI目錄：
ScriptAlias /cgi-bin/ /var/www/cgi-bin/
................................................................................
全部的HTTP服務器執行CGI程序都保存在一個預先配置的目錄。這個目錄被稱爲CGI目錄，並按照慣例，它被命名爲/var/www/cgi-bin目錄。
CGI文件的擴展名爲.cgi，python也能夠使用.py擴展名。
默認狀況下，Linux服務器配置運行的cgi-bin目錄中爲/var/www。
若是你想指定其餘運行CGI腳本的目錄，能夠修改httpd.conf配置文件，以下所示：
<Directory "/var/www/cgi-bin"> AllowOverride None Options +ExecCGI Order allow,deny Allow from all </Directory>
................................................................................
在 AddHandler 中添加 .py 後綴，這樣咱們就能夠訪問 .py 結尾的 python 腳本文件：
AddHandler cgi-script .cgi .pl .py
................................................................................
第一個CGI程序
咱們使用Python建立第一個CGI程序，文件名爲hello.py，文件位於/var/www/cgi-bin目錄中，內容以下：
#!/usr/bin/python3
print ("Content-type:text/html")
print () # 空行，告訴服務器結束頭部
print ('<html>')
print ('<head>')
print ('<meta charset="utf-8">')
print ('<title>Hello Word - 個人第一個 CGI 程序！</title>')
print ('</head>')
print ('<body>')
print ('<h2>Hello Word! 我是來自php中文網的第一CGI程序</h2>')
print ('</body>')
print ('</html>')
................................................................................
文件保存後修改 hello.py，修改文件權限爲 755：
chmod 755 hello.py
................................................................................
以上程序在瀏覽器訪問顯示結果以下：
這個的hello.py腳本是一個簡單的Python腳本，腳本第一行的輸出內容"Content-type:text/html"發送到瀏覽器並告知瀏覽器顯示的內容類型爲"text/html"。
用 print 輸出一個空行用於告訴服務器結束頭部信息。
HTTP頭部
hello.py文件內容中的" Content-type:text/html"即爲HTTP頭部的一部分，它會發送給瀏覽器告訴瀏覽器文件的內容類型。
HTTP頭部的格式以下：
HTTP 字段名: 字段內容
................................................................................
例如：
Content-type: text/html
................................................................................
如下表格介紹了CGI程序中HTTP頭部常用的信息：
| 頭 | 描述 |
|---|---|
| Content-type: | 請求的與實體對應的MIME信息。例如: Content-type:text/html |
| Expires: Date | 響應過時的日期和時間 |
| Location: URL | 用來重定向接收方到非請求URL的位置來完成請求或標識新的資源 |
| Last-modified: Date | 請求資源的最後修改時間 |
| Content-length: N | 請求的內容長度 |
| Set-Cookie: String | 設置Http Cookie |
................................................................................
CGI環境變量
全部的CGI程序都接收如下的環境變量，這些變量在CGI程序中發揮了重要的做用：
| 變量名 | 描述 |
|---|---|
| CONTENT_TYPE | 這個環境變量的值指示所傳遞來的信息的MIME類型。目前，環境變量CONTENT_TYPE通常都是：application/x-www-form-urlencoded,他表示數據來自於HTML表單。 |
| CONTENT_LENGTH | 若是服務器與CGI程序信息的傳遞方式是POST，這個環境變量即便從標準輸入STDIN中能夠讀到的有效數據的字節數。這個環境變量在讀取所輸入的數據時必須使用。 |
| HTTP_COOKIE | 客戶機內的 COOKIE 內容。 |
| HTTP_USER_AGENT | 提供包含了版本數或其餘專有數據的客戶瀏覽器信息。 |
| PATH_INFO | 這個環境變量的值表示緊接在CGI程序名以後的其餘路徑信息。它經常做爲CGI程序的參數出現。 |
| QUERY_STRING | 若是服務器與CGI程序信息的傳遞方式是GET，這個環境變量的值即便所傳遞的信息。這個信息經跟在CGI程序名的後面，二者中間用一個問號'?'分隔。 |
| REMOTE_ADDR | 這個環境變量的值是發送請求的客戶機的IP地址，例如上面的192.168.1.67。這個值老是存在的。並且它是Web客戶機須要提供給Web服務器的惟一標識，能夠在CGI程序中用它來區分不一樣的Web客戶機。 |
| REMOTE_HOST | 這個環境變量的值包含發送CGI請求的客戶機的主機名。若是不支持你想查詢，則無需定義此環境變量。 |
| REQUEST_METHOD | 提供腳本被調用的方法。對於使用 HTTP/1.0 協議的腳本，僅 GET 和 POST 有意義。 |
| SCRIPT_FILENAME | CGI腳本的完整路徑 |
| SCRIPT_NAME | CGI腳本的的名稱 |
| SERVER_NAME | 這是你的 WEB 服務器的主機名、別名或IP地址。 |
| SERVER_SOFTWARE | 這個環境變量的值包含了調用CGI程序的HTTP服務器的名稱和版本號。例如，上面的值爲Apache/2.2.14(Unix) |
................................................................................
如下是一個簡單的CGI腳本輸出CGI的環境變量：
#!/usr/bin/python3
import os
print ("Content-type: text/html")
print ()
print ("<meta charset=\"utf-8\">")
print ("<b>環境變量</b><br>")
print ("<ul>")
for key in os.environ.keys():
print ("<li><span style='color:green'>%30s </span> : %s </li>" % (key,os.environ[key]))
print ("</ul>")
................................................................................
將以上點保存爲 test.py ,並修改文件權限爲 755，執行結果以下：
GET和POST方法
瀏覽器客戶端經過兩種方法向服務器傳遞信息，這兩種方法就是 GET 方法和 POST 方法。
GET方法發送編碼後的用戶信息到服務端，數據信息包含在請求頁面的URL上，以"?"號分割, 以下所示：
http://www.test.com/cgi-bin/hello.py?key1=value1&key2=value2
................................................................................
GET 請求可被緩存
GET 請求保留在瀏覽器歷史記錄中
GET 請求可被收藏爲書籤
GET 請求不該在處理敏感數據時使用
GET 請求有長度限制
GET 請求只應當用於取回數據
如下是一個簡單的URL，使用GET方法向hello_get.py程序發送兩個參數：
/cgi-bin/test.py?name=php中文網&url=http://www.php.cn
................................................................................
如下爲hello_get.py文件的代碼：
#!/usr/bin/python3
# CGI處理模塊
import cgi, cgitb
# 建立 FieldStorage 的實例化
form = cgi.FieldStorage()
# 獲取數據
site_name = form.getvalue('name')
site_url = form.getvalue('url')
print ("Content-type:text/html")
print ()
print ("<html>")
print ("<head>")
print ("<meta charset=\"utf-8\">")
print ("<title>php中文網 CGI 測試實例</title>")
print ("</head>")
print ("<body>")
print ("<h2>%s官網：%s</h2>" % (site_name, site_url))
print ("</body>")
print ("</html>")
................................................................................
文件保存後修改 hello_get.py，修改文件權限爲 755：
chmod 755 hello_get.py
................................................................................
瀏覽器請求輸出結果：
如下是一個經過HTML的表單使用GET方法向服務器發送兩個數據，提交的服務器腳本一樣是hello_get.py文件，hello_get.html 代碼以下：
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>php中文網(php.cn)</title> </head> <body> <form action="/cgi-bin/hello_get.py" method="get"> 站點名稱: <input type="text" name="name"> <br /> 站點 URL: <input type="text" name="url" /> <input type="submit" value="提交" /> </form> </body> </html>
................................................................................
默認狀況下 cgi-bin 目錄只能存放腳本文件，咱們將 hello_get.html 存儲在 test 目錄下，修改文件權限爲 755：
chmod 755 hello_get.html
................................................................................
Gif 演示以下所示：
使用POST方法向服務器傳遞數據是更安全可靠的，像一些敏感信息如用戶密碼等須要使用POST傳輸數據。
如下一樣是hello_get.py ，它也能夠處理瀏覽器提交的POST表單數據:
#!/usr/bin/python3
# CGI處理模塊
import cgi, cgitb
# 建立 FieldStorage 的實例化
form = cgi.FieldStorage()
# 獲取數據
site_name = form.getvalue('name')
site_url = form.getvalue('url')
print ("Content-type:text/html")
print ()
print ("<html>")
print ("<head>")
print ("<meta charset=\"utf-8\">")
print ("<title>php中文網 CGI 測試實例</title>")
print ("</head>")
print ("<body>")
print ("<h2>%s官網：%s</h2>" % (site_name, site_url))
print ("</body>")
print ("</html>")
................................................................................
如下爲表單經過POST方法（method="post"）向服務器腳本 hello_get.py 提交數據:
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>php中文網(php.cn)</title> </head> <body> <form action="/cgi-bin/hello_get.py" method="post"> 站點名稱: <input type="text" name="name"> <br /> 站點 URL: <input type="text" name="url" /> <input type="submit" value="提交" /> </form> </body> </html> </form>
................................................................................
Gif 演示以下所示：
checkbox用於提交一個或者多個選項數據，HTML代碼以下：
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>php中文網(php.cn)</title> </head> <body> <form action="/cgi-bin/checkbox.py" method="POST" target="_blank"> <input type="checkbox" name="php" value="on" /> php中文網 <input type="checkbox" name="google" value="on" /> Google <input type="submit" value="選擇站點" /> </form> </body> </html>
................................................................................
如下爲 checkbox.py 文件的代碼：
#!/usr/bin/python3
# 引入 CGI 處理模塊
import cgi, cgitb
# 建立 FieldStorage的實例
form = cgi.FieldStorage()
# 接收字段數據
if form.getvalue('google'):
google_flag = "是"
else:
google_flag = "否"
if form.getvalue('php'):
php_flag = "是"
else:
php_flag = "否"
print ("Content-type:text/html")
print ()
print ("<html>")
print ("<head>")
print ("<meta charset=\"utf-8\">")
print ("<title>php中文網 CGI 測試實例</title>")
print ("</head>")
print ("<body>")
print ("<h2> php中文網是否選擇了 : %s</h2>" % php_flag)
print ("<h2> Google 是否選擇了 : %s</h2>" % google_flag)
print ("</body>")
print ("</html>")
................................................................................
修改 checkbox.py 權限：
chmod 755 checkbox.py
................................................................................
瀏覽器訪問 Gif 演示圖：
Radio 只向服務器傳遞一個數據，HTML代碼以下：
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>php中文網(php.cn)</title> </head> <body> <form action="/cgi-bin/radiobutton.py" method="post" target="_blank"> <input type="radio" name="site" value="php" /> php中文網 <input type="radio" name="site" value="google" /> Google <input type="submit" value="提交" /> </form> </body> </html>
................................................................................
radiobutton.py 腳本代碼以下：
#!/usr/bin/python3
# 引入 CGI 處理模塊
import cgi, cgitb
# 建立 FieldStorage的實例
form = cgi.FieldStorage()
# 接收字段數據
if form.getvalue('site'):
site = form.getvalue('site')
else:
site = "提交數據爲空"
print ("Content-type:text/html")
print ()
print ("<html>")
print ("<head>")
print ("<meta charset=\"utf-8\">")
print ("<title>php中文網 CGI 測試實例</title>")
print ("</head>")
print ("<body>")
print ("<h2> 選中的網站是 %s</h2>" % site)
print ("</body>")
print ("</html>")
................................................................................
修改 radiobutton.py 權限：
chmod 755 radiobutton.py
................................................................................
瀏覽器訪問 Gif 演示圖：
Textarea 向服務器傳遞多行數據，HTML代碼以下：
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>php中文網(php.cn)</title> </head> <body> <form action="/cgi-bin/textarea.py" method="post" target="_blank"> <textarea name="textcontent" cols="40" rows="4"> 在這裏輸入內容... </textarea> <input type="submit" value="提交" /> </form> </body> </html>
................................................................................
textarea.py 腳本代碼以下：
#!/usr/bin/python3
# 引入 CGI 處理模塊
import cgi, cgitb
# 建立 FieldStorage的實例
form = cgi.FieldStorage()
# 接收字段數據
if form.getvalue('textcontent'):
text_content = form.getvalue('textcontent')
else:
text_content = "沒有內容"
print ("Content-type:text/html")
print ()
print ("<html>")
print ("<head>")
print ("<meta charset=\"utf-8\">")
print ("<title>php中文網 CGI 測試實例</title>")
print ("</head>")
print ("<body>")
print ("<h2> 輸入的內容是：%s</h2>" % text_content)
print ("</body>")
print ("</html>")
................................................................................
修改 textarea.py 權限：
chmod 755 textarea.py
................................................................................
瀏覽器訪問 Gif 演示圖：
HTML 下拉框代碼以下：
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>php中文網(php.cn)</title> </head> <body> <form action="/cgi-bin/dropdown.py" method="post" target="_blank"> <select name="dropdown"> <option value="php" selected>php中文網</option> <option value="google">Google</option> </select> <input type="submit" value="提交"/> </form> </body> </html>
................................................................................
dropdown.py 腳本代碼以下所示：
#!/usr/bin/python3
# 引入 CGI 處理模塊
import cgi, cgitb
# 建立 FieldStorage的實例
form = cgi.FieldStorage()
# 接收字段數據
if form.getvalue('dropdown'):
dropdown_value = form.getvalue('dropdown')
else:
dropdown_value = "沒有內容"
print ("Content-type:text/html")
print ()
print ("<html>")
print ("<head>")
print ("<meta charset=\"utf-8\">")
print ("<title>php中文網 CGI 測試實例</title>")
print ("</head>")
print ("<body>")
print ("<h2> 選中的選項是：%s</h2>" % dropdown_value)
print ("</body>")
print ("</html>")
................................................................................
修改 dropdown.py 權限：
chmod 755 dropdown.py
................................................................................
瀏覽器訪問 Gif 演示圖：
CGI中使用Cookie
在 http 協議一個很大的缺點就是不對用戶身份的進行判斷，這樣給編程人員帶來很大的不便， 而 cookie 功能的出現彌補了這個不足。
cookie 就是在客戶訪問腳本的同時，經過客戶的瀏覽器，在客戶硬盤上寫入紀錄數據 ，當下次客戶訪問腳本時取回數據信息，從而達到身份判別的功能，cookie 經常使用在身份校驗中。
http cookie的發送是經過http頭部來實現的，他早於文件的傳遞，頭部set-cookie的語法以下：
Set-cookie:name=name;expires=date;path=path;domain=domain;secure
................................................................................
name=name: 須要設置cookie的值(name不能使用";"和","號),有多個name值時用 ";" 分隔，例如：name1=name1;name2=name2;name3=name3。
expires=date: cookie的有效期限,格式： expires="Wdy,DD-Mon-YYYY HH:MM:SS"
path=path: 設置cookie支持的路徑,若是path是一個路徑，則cookie對這個目錄下的全部文件及子目錄生效，例如： path="/cgi-bin/"，若是path是一個文件，則cookie指對這個文件生效，例如：path="/cgi-bin/cookie.cgi"。
domain=domain: 對cookie生效的域名，例如：domain="www.php.cn"
secure: 若是給出此標誌，表示cookie只能經過SSL協議的https服務器來傳遞。
cookie的接收是經過設置環境變量HTTP_COOKIE來實現的，CGI程序能夠經過檢索該變量獲取cookie信息。
Cookie設置
Cookie的設置很是簡單，cookie會在http頭部單獨發送。如下實例在cookie中設置了name 和 expires：
#!/usr/bin/python3
#
print ('Content-Type: text/html')
print ('Set-Cookie: name="php中文網";expires=Wed, 28 Aug 2016 18:30:00 GMT')
print ()
print ("""
<html>
<head>
<meta charset="utf-8">
<title>php中文網(php.cn)</title>
</head>
<body>
<h1>Cookie set OK!</h1>
</body>
</html>
""")
................................................................................
將以上代碼保存到 cookie_set.py，並修改 cookie_set.py 權限：
chmod 755 cookie_set.py
................................................................................
以上實例使用了 Set-Cookie 頭信息來設置Cookie信息，可選項中設置了Cookie的其餘屬性，如過時時間Expires，域名Domain，路徑Path。這些信息設置在 "Content-type:text/html"以前。
檢索Cookie信息
Cookie信息檢索頁很是簡單，Cookie信息存儲在CGI的環境變量HTTP_COOKIE中，存儲格式以下：
key1=value1;key2=value2;key3=value3....
................................................................................
如下是一個簡單的CGI檢索cookie信息的程序：
#!/usr/bin/python3
# 導入模塊
import os
import Cookie
print ("Content-type: text/html")
print ()
print ("""
<html>
<head>
<meta charset="utf-8">
<title>php中文網(php.cn)</title>
</head>
<body>
<h1>讀取cookie信息</h1>
""")
if 'HTTP_COOKIE' in os.environ:
cookie_string=os.environ.get('HTTP_COOKIE')
c=Cookie.SimpleCookie()
c.load(cookie_string)
try:
data=c['name'].value
print ("cookie data: "+data+"<br>")
except KeyError:
print ("cookie 沒有設置或者已過去<br>")
print ("""
</body>
</html>
""")
................................................................................
將以上代碼保存到 cookie_get.py，並修改 cookie_get.py 權限：
chmod 755 cookie_get.py
................................................................................
以上 cookie 設置顏色 Gif 以下所示：
HTML設置上傳文件的表單須要設置 enctype 屬性爲 multipart/form-data，代碼以下所示：
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>php中文網(php.cn)</title> </head> <body> <form enctype="multipart/form-data" action="/cgi-bin/save_file.py" method="post"> <p>選中文件: <input type="file" name="filename" /></p> <p><input type="submit" value="上傳" /></p> </form> </body> </html>
................................................................................
save_file.py腳本文件代碼以下：
#!/usr/bin/python3
import cgi, os
import cgitb; cgitb.enable()
form = cgi.FieldStorage()
# 獲取文件名
fileitem = form['filename']
# 檢測文件是否上傳
if fileitem.filename:
# 設置文件路徑
fn = os.path.basename(fileitem.filename)
open('/tmp/' + fn, 'wb').write(fileitem.file.read())
message = '文件 "' + fn + '" 上傳成功'
else:
message = '文件沒有上傳'
print ("""\
Content-Type: text/html\n
<html>
<head>
<meta charset="utf-8">
<title>php中文網(php.cn)</title>
</head>
<body>
<p>%s</p>
</body>
</html>
""" % (message,))
................................................................................
將以上代碼保存到 save_file.py，並修改 save_file.py 權限：
chmod 755 save_file.py
................................................................................
以上 cookie 設置顏色 Gif 以下所示：
若是你使用的系統是Unix/Linux，你必須替換文件分隔符，在window下只須要使用open()語句便可：
fn = os.path.basename(fileitem.filename.replace("\\", "/" ))
................................................................................
文件下載對話框
咱們先在當前目錄下建立 foo.txt 文件，用於程序的下載。
文件下載經過設置HTTP頭信息來實現，功能代碼以下：
#!/usr/bin/python3
# HTTP 頭部
print ("Content-Disposition: attachment; filename=\"foo.txt\"")
print ()
# 打開文件
fo = open("foo.txt", "rb")
str = fo.read();
print (str)
# 關閉文件
fo.close()
................................................................................
休息一下子……
今天內容：python3-class.html
********************************************************
Python從設計之初就已是一門面向對象的語言，正由於如此，在Python中建立一個類和對象是很容易的。本章節咱們將詳細介紹Python的面向對象編程。
若是你之前沒有接觸過面向對象的編程語言，那你可能須要先了解一些面嚮對象語言的一些基本特徵，在頭腦裏頭造成一個基本的面向對象的概念，這樣有助於你更容易的學習Python的面向對象編程。
接下來咱們先來簡單的瞭解下面向對象的一些基本特徵。
面向對象技術簡介
類(Class): 用來描述具備相同的屬性和方法的對象的集合。它定義了該集合中每一個對象所共有的屬性和方法。對象是類的實例。
類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體以外。類變量一般不做爲實例變量使用。
數據成員：類變量或者實例變量用於處理類及其實例對象的相關的數據。
方法重寫：若是從父類繼承的方法不能知足子類的需求，能夠對其進行改寫，這個過程叫方法的覆蓋（override），也稱爲方法的重寫。
實例變量：定義在方法中的變量，只做用於當前實例的類。
繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也容許把一個派生類的對象做爲一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關係（例圖，Dog是一個Animal）。
實例化：建立一個類的實例，類的具體對象。
方法：類中定義的函數。
對象：經過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。
和其它編程語言相比，Python 在儘量不增長新的語法和語義的狀況下加入了類機制。
Python中的類提供了面向對象編程的全部基本功能：類的繼承機制容許多個基類，派生類能夠覆蓋基類中的任何方法，方法中能夠調用基類中的同名方法。
對象能夠包含任意數量和類型的數據。
類定義
語法格式以下：
class ClassName: <statement-1> . . . <statement-N>
................................................................................
類實例化後，能夠使用其屬性，實際上，建立一個類以後，能夠經過類名訪問其屬性。
類對象
類對象支持兩種操做：屬性引用和實例化。
屬性引用使用和 Python 中全部的屬性引用同樣的標準語法：obj.name。
類對象建立後，類命名空間中全部的命名都是有效屬性名。因此若是類定義是這樣:
#!/usr/bin/python3
class MyClass:
"""一個簡單的類實例"""
i = 12345
def f(self):
return 'hello world'
# 實例化類
x = MyClass()
# 訪問類的屬性和方法
print("MyClass 類的屬性 i 爲：", x.i)
print("MyClass 類的方法 f 輸出爲：", x.f())
................................................................................
實例化類：
# 實例化類 x = MyClass() # 訪問類的屬性和方法
................................................................................
以上建立了一個新的類實例並將該對象賦給局部變量 x，x 爲空的對象。
執行以上程序輸出結果爲：
MyClass 類的屬性 i 爲： 12345 MyClass 類的方法 f 輸出爲： hello world
................................................................................
不少類都傾向於將對象建立爲有初始狀態的。所以類可能會定義一個名爲 __init__() 的特殊方法（構造方法），像下面這樣：
def __init__(self): self.data = []
................................................................................
類定義了 __init__() 方法的話，類的實例化操做會自動調用 __init__() 方法。因此在下例中，能夠這樣建立一個新的實例:
x = MyClass()
................................................................................
固然， __init__() 方法能夠有參數，參數經過 __init__() 傳遞到類的實例化操做上。例如:
>>> class Complex: ... def __init__(self, realpart, imagpart): ... self.r = realpart ... self.i = imagpart ... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)
................................................................................
類的方法
在類地內部，使用def關鍵字能夠爲類定義一個方法，與通常函數定義不一樣，類方法必須包含參數self,且爲第一個參數:
#!/usr/bin/python3
#類定義
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部沒法直接進行訪問
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
# 實例化類
p = people('php',10,30)
p.speak()
................................................................................
執行以上程序輸出結果爲：
php 說: 我 10 歲。
................................................................................
繼承
Python 一樣支持類的繼承，若是一種語言不支持繼承，類就沒有什麼意義。派生類的定義以下所示:
class DerivedClassName(BaseClassName1): <statement-1> . . . <statement-N>
................................................................................
須要注意圓括號中基類的順序，如果基類中有相同的方法名，而在子類使用時未指定，python從左至右搜索 即方法在子類中未找到時，從左到右查找基類中是否包含方法。
BaseClassName（示例中的基類名）必須與派生類定義在一個做用域內。除了類，還能夠用表達式，基類定義在另外一個模塊中時這一點很是有用:
class DerivedClassName(modname.BaseClassName):
................................................................................
#!/usr/bin/python3
#類定義
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部沒法直接進行訪問
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
#單繼承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#調用父類的構函
people.__init__(self,n,a,w)
self.grade = g
#覆寫父類的方法
def speak(self):
print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak()
................................................................................
執行以上程序輸出結果爲：
ken 說: 我 10 歲了，我在讀 3 年級
................................................................................
多繼承
Python一樣有限的支持多繼承形式。多繼承的類定義形以下例:
class DerivedClassName(Base1, Base2, Base3): <statement-1> . . . <statement-N>
................................................................................
須要注意圓括號中父類的順序，如果父類中有相同的方法名，而在子類使用時未指定，python從左至右搜索 即方法在子類中未找到時，從左到右查找父類中是否包含方法。
#!/usr/bin/python3
#類定義
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部沒法直接進行訪問
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
#單繼承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#調用父類的構函
people.__init__(self,n,a,w)
self.grade = g
#覆寫父類的方法
def speak(self):
print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
#另外一個類，多重繼承以前的準備
class speaker():
topic = ''
name = ''
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s，我是一個演說家，我演講的主題是 %s"%(self.name,self.topic))
#多重繼承
class sample(speaker,student):
a =''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，默認調用的是在括號中排前地父類的方法
................................................................................
執行以上程序輸出結果爲：
我叫 Tim，我是一個演說家，我演講的主題是 Python
................................................................................
方法重寫
若是你的父類方法的功能不能知足你的需求，你能夠在子類重寫你父類的方法，實例以下：
#!/usr/bin/python3
class Parent: # 定義父類
def myMethod(self):
print ('調用父類方法')
class Child(Parent): # 定義子類
def myMethod(self):
print ('調用子類方法')
c = Child() # 子類實例
c.myMethod() # 子類調用重寫方法
................................................................................
執行以上程序輸出結果爲：
調用子類方法
................................................................................
類屬性與方法
__private_attrs：兩個下劃線開頭，聲明該屬性爲私有，不能在類地外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs。
在類地內部，使用def關鍵字能夠爲類定義一個方法，與通常函數定義不一樣，類方法必須包含參數self,且爲第一個參數
__private_method：兩個下劃線開頭，聲明該方法爲私有方法，不能在類地外部調用。在類的內部調用 slef.__private_methods。
實例以下：
#!/usr/bin/python3 class JustCounter: __secretCount = 0 # 私有變量 publicCount = 0 # 公開變量 def count(self): self.__secretCount += 1 self.publicCount += 1 print (self.__secretCount) counter = JustCounter() counter.count() counter.count() print (counter.publicCount) print (counter.__secretCount) # 報錯，實例不能訪問私有變量
................................................................................
執行以上程序輸出結果爲：
1 2 2 Traceback (most recent call last): File "test.py", line 16, in <module> print (counter.__secretCount) # 報錯，實例不能訪問私有變量 AttributeError: 'JustCounter' object has no attribute '__secretCount'
................................................................................
__init__ : 構造函數，在生成對象時調用
__del__ : 析構函數，釋放對象時使用
__repr__ : 打印，轉換
__setitem__ : 按照索引賦值
__getitem__: 按照索引獲取值
__len__: 得到長度
__cmp__: 比較運算
__call__: 函數調用
__add__: 加運算
__sub__: 減運算
__mul__: 乘運算
__div__: 除運算
__mod__: 求餘運算
__pow__: 稱方
Python一樣支持運算符重載，我麼能夠對類的專有方法進行重載，實例以下：
#!/usr/bin/python3 class Vector: def __init__(self, a, b): self.a = a self.b = b def __str__(self): return 'Vector (%d, %d)' % (self.a, self.b) def __add__(self,other): return Vector(self.a + other.a, self.b + other.b) v1 = Vector(2,10) v2 = Vector(5,-2) print (v1 + v2)
................................................................................
以上代碼執行結果以下所示:
Vector(7,8)
................................................................................
休息一下子……
今天內容：python3-comment.html
********************************************************
確保對模塊, 函數, 方法和行內註釋使用正確的風格
Python中的註釋有單行註釋和多行註釋：
Python中單行註釋以#開頭，例如：：
# 這是一個註釋
print("Hello, World!")
................................................................................
多行註釋用三個單引號（'''）或者三個雙引號（"""）將註釋括起來，例如:
一、單引號（'''）
#!/usr/bin/python3
'''
這是多行註釋，用三個單引號
這是多行註釋，用三個單引號
這是多行註釋，用三個單引號
'''
print("Hello, World!")
................................................................................
二、雙引號（'''）
#!/usr/bin/python3
"""
這是多行註釋，用三個單引號
這是多行註釋，用三個單引號
這是多行註釋，用三個單引號
"""
print("Hello, World!")
................................................................................
休息一下子……
今天內容：python3-conditional-statements.html
********************************************************
Python條件語句是經過一條或多條語句的執行結果（True或者False）來決定執行的代碼塊。
能夠經過下圖來簡單瞭解條件語句的執行過程:
if 語句
Python中if語句的通常形式以下所示：
if condition_1: statement_block_1 elif condition_2: statement_block_2 else: statement_block_3
................................................................................
若是 "condition_1" 爲 True 將執行 "statement_block_1" 塊語句
若是 "condition_1" 爲False，將判斷 "condition_2"
若是"condition_2" 爲 True 將執行 "statement_block_2" 塊語句
若是 "condition_2" 爲False，將執行"statement_block_3"塊語句
Python 中用 elif 代替了 else if，因此if語句的關鍵字爲：if – elif – else。
注意：
一、每一個條件後面要使用冒號（:），表示接下來是知足條件後要執行的語句塊。
二、使用縮進來劃分語句塊，相同縮進數的語句在一塊兒組成一個語句塊。
三、在Python中沒有switch – case語句。
如下是一個簡單的 if 實例：
#!/usr/bin/python3
var1 = 100
if var1:
print ("1 - if 表達式條件爲 true")
print (var1)
var2 = 0
if var2:
print ("2 - if 表達式條件爲 true")
print (var2)
print ("Good bye!")
................................................................................
執行以上代碼，輸出結果爲：
1 - if 表達式條件爲 true 100 Good bye!
................................................................................
從結果能夠看到因爲變量 var2 爲 0，因此對應的 if 內的語句沒有執行。
如下實例演示了狗的年齡計算判斷：
#!/usr/bin/python3
age = int(input("請輸入你家狗狗的年齡: "))
print("")
if age < 0:
print("你是在逗我吧!")
elif age == 1:
print("至關於 14 歲的人。")
elif age == 2:
print("至關於 22 歲的人。")
elif age > 2:
human = 22 + (age -2)*5
print("對應人類年齡: ", human)
### 退出提示
input('點擊 enter 鍵退出')
................................................................................
將以上腳本保存在dog.py文件中，並執行該腳本：
$ python3 dog.py 請輸入你家狗狗的年齡: 1 至關於 14 歲的人。 點擊 enter 鍵退出
................................................................................
如下爲if中經常使用的操做運算符:
| 操做符 | 描述 |
|---|---|
< |
小於 |
<= |
小於或等於 |
> |
大於 |
>= |
大於或等於 |
== |
等於，比較對象是否相等 |
!= |
不等於 |
................................................................................
#!/usr/bin/python3 # 程序演示了 == 操做符 # 使用數字 print(5 == 6) # 使用變量 x = 5 y = 8 print(x == y)
................................................................................
以上實例輸出結果：
False False
................................................................................
high_low.py文件演示了數字的比較運算：
#!/usr/bin/python3
# 該實例演示了數字猜謎遊戲
number = 7
guess = -1
print("數字猜謎遊戲!")
while guess != number:
guess = int(input("請輸入你猜的數字："))
if guess == number:
print("恭喜，你猜對了！")
elif guess < number:
print("猜的數字小了...")
elif guess > number:
print("猜的數字大了...")
................................................................................
執行以上腳本，實例輸出結果以下：
$ python3 high_low.py 數字猜謎遊戲! 請輸入你猜的數字：1 猜的數字小了... 請輸入你猜的數字：9 猜的數字大了... 請輸入你猜的數字：7 恭喜，你猜對了！
................................................................................
if 嵌套
在嵌套 if 語句中，能夠把 if...elif...else 結構放在另一個 if...elif...else 結構中。
if 表達式1: 語句 if 表達式2: 語句 elif 表達式3: 語句 else 語句 elif 表達式4: 語句 else: 語句
................................................................................
# !/usr/bin/python3
num=int(input("輸入一個數字："))
if num%2==0:
if num%3==0:
print ("你輸入的數字能夠整除 2 和 3")
else:
print ("你輸入的數字能夠整除 2，但不能整除 3")
else:
if num%3==0:
print ("你輸入的數字能夠整除 3，但不能整除 2")
else:
print ("你輸入的數字不能整除 2 和 3")
................................................................................
將以上程序保存到 test_if.py 文件中，執行後輸出結果爲：
$ python3 test.py 輸入一個數字：6 你輸入的數字能夠整除 2 和 3
................................................................................
休息一下子……
今天內容：python3-data-structure.html
********************************************************
本章節咱們主要結合前面所學的知識點來介紹Python數據結構。
列表
Python中列表是可變的，這是它區別於字符串和元組的最重要的特色，一句話歸納即：列表能夠修改，而字符串和元組不能。
如下是 Python 中列表的方法：
| 方法 | 描述 |
|---|---|
| list.append(x) | 把一個元素添加到列表的結尾，至關於 a[len(a):] = [x]。 |
| list.extend(L) | 經過添加指定列表的全部元素來擴充列表，至關於 a[len(a):] = L。 |
| list.insert(i, x) | 在指定位置插入一個元素。第一個參數是準備插入到其前面的那個元素的索引，例如 a.insert(0, x) 會插入到整個列表以前，而 a.insert(len(a), x) 至關於 a.append(x) 。 |
| list.remove(x) | 刪除列表中值爲 x 的第一個元素。若是沒有這樣的元素，就會返回一個錯誤。 |
| list.pop([i]) | 從列表的指定位置刪除元素，並將其返回。若是沒有指定索引，a.pop()返回最後一個元素。元素隨即從列表中被刪除。（方法中 i 兩邊的方括號表示這個參數是可選的，而不是要求你輸入一對方括號，你會常常在 Python 庫參考手冊中遇到這樣的標記。） |
| list.clear() | 移除列表中的全部項，等於del a[:]。 |
| list.index(x) | 返回列表中第一個值爲 x 的元素的索引。若是沒有匹配的元素就會返回一個錯誤。 |
| list.count(x) | 返回 x 在列表中出現的次數。 |
| list.sort() | 對列表中的元素進行排序。 |
| list.reverse() | 倒排列表中的元素。 |
| list.copy() | 返回列表的淺複製，等於a[:]。 |
................................................................................
下面示例演示了列表的大部分方法：
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
................................................................................
注意：相似 insert, remove 或 sort 等修改列表的方法沒有返回值。
將列表當作堆棧使用
列表方法使得列表能夠很方便的做爲一個堆棧來使用，堆棧做爲特定的數據結構，最早進入的元素最後一個被釋放（後進先出）。用 append() 方法能夠把一個元素添加到堆棧頂。用不指定索引的 pop() 方法能夠把一個元素從堆棧頂釋放出來。例如：
>>> stack = [3, 4, 5] >>> stack.append(6) >>> stack.append(7) >>> stack [3, 4, 5, 6, 7] >>> stack.pop() 7 >>> stack [3, 4, 5, 6] >>> stack.pop() 6 >>> stack.pop() 5 >>> stack [3, 4]
................................................................................
將列表看成隊列使用
也能夠把列表當作隊列用，只是在隊列裏第一加入的元素，第一個取出來；可是拿列表用做這樣的目的效率不高。在列表的最後添加或者彈出元素速度快，然而在列表裏插入或者從頭部彈出速度卻不快（由於全部其餘的元素都得一個一個地移動）。
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])
................................................................................
列表推導式
列表推導式提供了從序列建立列表的簡單途徑。一般應用程序將一些操做應用於某個序列的每一個元素，用其得到的結果做爲生成新列表的元素，或者根據肯定的斷定條件建立子序列。
每一個列表推導式都在 for 以後跟一個表達式，而後有零到多個 for 或 if 子句。返回結果是一個根據表達從其後的 for 和 if 上下文環境中生成出來的列表。若是但願表達式推導出一個元組，就必須使用括號。
這裏咱們將列表中每一個數值乘三，得到一個新的列表：
>>> vec = [2, 4, 6] >>> [3*x for x in vec] [6, 12, 18]
................................................................................
如今咱們玩一點小花樣：
>>> [[x, x**2] for x in vec] [[2, 4], [4, 16], [6, 36]]
................................................................................
這裏咱們對序列裏每個元素逐個調用某方法：
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit '] >>> [weapon.strip() for weapon in freshfruit] ['banana', 'loganberry', 'passion fruit']
................................................................................
咱們能夠用 if 子句做爲過濾器：
>>> [3*x for x in vec if x > 3] [12, 18] >>> [3*x for x in vec if x < 2] []
................................................................................
如下是一些關於循環和其它技巧的演示：
>>> vec1 = [2, 4, 6] >>> vec2 = [4, 3, -9] >>> [x*y for x in vec1 for y in vec2] [8, 6, -18, 16, 12, -36, 24, 18, -54] >>> [x+y for x in vec1 for y in vec2] [6, 5, -7, 8, 7, -5, 10, 9, -3] >>> [vec1[i]*vec2[i] for i in range(len(vec1))] [8, 12, -54]
................................................................................
列表推導式能夠使用複雜表達式或嵌套函數：
>>> [str(round(355/113, i)) for i in range(1, 6)] ['3.1', '3.14', '3.142', '3.1416', '3.14159']
................................................................................
嵌套列表解析
Python的列表還能夠嵌套。
如下實例展現了3X4的矩陣列表：
>>> matrix = [ ... [1, 2, 3, 4], ... [5, 6, 7, 8], ... [9, 10, 11, 12], ... ]
................................................................................
如下實例將3X4的矩陣列表轉換爲4X3列表：
>>> [[row[i] for row in matrix] for i in range(4)] [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
................................................................................
如下實例也能夠使用如下方法來實現：
>>> transposed = [] >>> for i in range(4): ... transposed.append([row[i] for row in matrix]) ... >>> transposed [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
................................................................................
另一種實現方法：
>>> transposed = [] >>> for i in range(4): ... # the following 3 lines implement the nested listcomp ... transposed_row = [] ... for row in matrix: ... transposed_row.append(row[i]) ... transposed.append(transposed_row) ... >>> transposed [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
................................................................................
del 語句
使用 del 語句能夠從一個列表中依索引而不是值來刪除一個元素。這與使用 pop() 返回一個值不一樣。能夠用 del 語句從列表中刪除一個切割，或清空整個列表（咱們之前介紹的方法是給該切割賦一個空列表）。例如：
>>> a = [-1, 1, 66.25, 333, 333, 1234.5] >>> del a[0] >>> a [1, 66.25, 333, 333, 1234.5] >>> del a[2:4] >>> a [1, 66.25, 1234.5] >>> del a[:] >>> a []
................................................................................
也能夠用 del 刪除實體變量：
>>> del a
................................................................................
元組和序列
元組由若干逗號分隔的值組成，例如：
>>> t = 12345, 54321, 'hello!' >>> t[0] 12345 >>> t (12345, 54321, 'hello!') >>> # Tuples may be nested: ... u = t, (1, 2, 3, 4, 5) >>> u ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
................................................................................
如你所見，元組在輸出時老是有括號的，以便於正確表達嵌套結構。在輸入時可能有或沒有括號， 不過括號一般是必須的（若是元組是更大的表達式的一部分）。
集合
集合是一個無序不重複元素的集。基本功能包括關係測試和消除重複元素。
能夠用大括號({})建立集合。注意：若是要建立一個空集合，你必須用 set() 而不是 {} ；後者建立一個空的字典，下一節咱們會介紹這個數據結構。
如下是一個簡單的演示：
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in either a or b
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in either a or b
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}
................................................................................
集合也支持推導式：
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
................................................................................
字典
另外一個很是有用的 Python 內建數據類型是字典。
序列是以連續的整數爲索引，與此不一樣的是，字典以關鍵字爲索引，關鍵字能夠是任意不可變類型，一般用字符串或數值。
理解字典的最佳方式是把它看作無序的鍵=>值對集合。在同一個字典以內，關鍵字必須是互不相同。
一對大括號建立一個空的字典：{}。
這是一個字典運用的簡單例子：
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False
................................................................................
構造函數 dict() 直接從鍵值對元組列表中構建字典。若是有固定的模式，列表推導式指定特定的鍵值對：
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
................................................................................
此外，字典推導能夠用來建立任意鍵和值的表達式詞典：
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
................................................................................
若是關鍵字只是簡單的字符串，使用關鍵字參數指定鍵值對有時候更方便：
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
................................................................................
遍歷技巧
在字典中遍歷時，關鍵字和對應的值能夠使用 items() 方法同時解讀出來：
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
................................................................................
在序列中遍歷時，索引位置和對應值能夠使用 enumerate() 函數同時獲得：
>>> for i, v in enumerate(['tic', 'tac', 'toe']): ... print(i, v) ... 0 tic 1 tac 2 toe
................................................................................
同時遍歷兩個或更多的序列，能夠使用 zip() 組合：
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
................................................................................
要反向遍歷一個序列，首先指定這個序列，而後調用 reversesd() 函數：
>>> for i in reversed(range(1, 10, 2)): ... print(i) ... 9 7 5 3 1
................................................................................
要按順序遍歷一個序列，使用 sorted() 函數返回一個已排序的序列，並不修改原值：
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana'] >>> for f in sorted(set(basket)): ... print(f) ... apple banana orange pear
................................................................................
參閱文檔
Python3 列表
Python3 元組
Python3 字典
休息一下子……
今天內容：python3-data-type.html
********************************************************
Python 中的變量不須要聲明。每一個變量在使用前都必須賦值，變量賦值之後該變量纔會被建立。
在 Python 中，變量就是變量，它沒有類型，咱們所說的"類型"是變量所指的內存中對象的類型。
等號（=）用來給變量賦值。
等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。例如：
#!/usr/bin/python3 counter = 100 # 整型變量 miles = 1000.0 # 浮點型變量 name = "php" # 字符串 print (counter) print (miles) print (name)
................................................................................
執行以上程序會輸出以下結果：
100 1000.0 php
................................................................................
Python容許你同時爲多個變量賦值。例如：
a = b = c = 1
................................................................................
以上實例，建立一個整型對象，值爲1，三個變量被分配到相同的內存空間上。
您也能夠爲多個對象指定多個變量。例如：
a, b, c = 1, 2, "php"
................................................................................
以上實例，兩個整型對象 1 和 2 的分配給變量 a 和 b，字符串對象 "php" 分配給變量 c。
標準數據類型
Python3 中有六個標準的數據類型：
Number（數字）
String（字符串）
List（列表）
Tuple（元組）
Sets（集合）
Dictionary（字典）
Number（數字）
Python3 支持 int、float、bool、complex（複數）。
在Python 3裏，只有一種整數類型 int，表示爲長整型，沒有 python2 中的 Long。
像大多數語言同樣，數值類型的賦值和計算都是很直觀的。
內置的type()函數能夠用來查詢變量所指的對象類型。
>>> a, b, c, d = 20, 5.5, True, 4+3j >>> print(type(a), type(b), type(c), type(d)) <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
................................................................................
注意：在Python2中是沒有布爾型的，它用數字0表示False，用1表示True。到Python3中，把True和False定義成關鍵字了，但它們的值仍是1和0，它們能夠和數字相加。
當你指定一個值時，Number 對象就會被建立：
var1 = 1 var2 = 10
................................................................................
您也能夠使用del語句刪除一些對象引用。
del語句的語法是：
del var1[,var2[,var3[....,varN]]]]
................................................................................
您能夠經過使用del語句刪除單個或多個對象。例如：
del var del var_a, var_b
................................................................................
>>> 5 + 4 # 加法 9 >>> 4.3 - 2 # 減法 2.3 >>> 3 * 7 # 乘法 21 >>> 2 / 4 # 除法，獲得一個浮點數 0.5 >>> 2 // 4 # 除法，獲得一個整數 0 >>> 17 % 3 # 取餘 2 >>> 2 ** 5 # 乘方 32
................................................................................
注意：
一、Python能夠同時爲多個變量賦值，如a, b = 1, 2。
二、一個變量能夠經過賦值指向不一樣類型的對象。
三、數值的除法（/）老是返回一個浮點數，要獲取整數使用//操做符。
四、在混合計算時，Python會把整型轉換成爲浮點數。
| int | float | complex |
|---|---|---|
| 10 | 0.0 | 3.14j |
| 100 | 15.20 | 45.j |
| -786 | -21.9 | 9.322e-36j |
| 080 | 32.3+e18 | .876j |
| -0490 | -90. | -.6545+0J |
| -0x260 | -32.54e100 | 3e+26J |
| 0x69 | 70.2-E12 | 4.53e-7j |
................................................................................
Python還支持複數，複數由實數部分和虛數部分構成，能夠用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型
String（字符串）
Python中的字符串用單引號(')或雙引號(")括起來，同時使用反斜槓(\)轉義特殊字符。
字符串的截取的語法格式以下：
變量[頭下標:尾下標]
................................................................................
索引值以 0 爲開始值，-1 爲從末尾的開始位置。
加號 (+) 是字符串的鏈接符， 星號 (*) 表示複製當前字符串，緊跟的數字爲複製的次數。實例以下：
#!/usr/bin/python3 str = 'php' print (str) # 輸出字符串 print (str[0:-1]) # 輸出第一個個到倒數第二個的全部字符 print (str[0]) # 輸出字符串第一個字符 print (str[2:5]) # 輸出從第三個開始到第五個的字符 print (str[2:]) # 輸出從第三個開始的後的全部字符 print (str * 2) # 輸出字符串兩次 print (str + "TEST") # 鏈接字符串
................................................................................
執行以上程序會輸出以下結果：
php Runoo R noo noob phpphp phpTEST
................................................................................
Python 使用反斜槓(\)轉義特殊字符，若是你不想讓反斜槓發生轉義，能夠在字符串前面添加一個 r，表示原始字符串：
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>
................................................................................
另外，反斜槓(\)能夠做爲續行符，表示下一行是上一行的延續。也能夠使用 """...""" 或者 '''...''' 跨越多行。
注意，Python 沒有單獨的字符類型，一個字符就是長度爲1的字符串。
>>> word = 'Python' >>> print(word[0], word[5]) P n >>> print(word[-1], word[-6]) n P
................................................................................
與 C 字符串不一樣的是，Python 字符串不能被改變。向一個索引位置賦值，好比word[0] = 'm'會致使錯誤。
注意：
一、反斜槓能夠用來轉義，使用r可讓反斜槓不發生轉義。
二、字符串能夠用+運算符鏈接在一塊兒，用*運算符重複。
三、Python中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始。
四、Python中的字符串不能改變。
List（列表）
List（列表） 是 Python 中使用最頻繁的數據類型。
列表能夠完成大多數集合類的數據結構實現。列表中元素的類型能夠不相同，它支持數字，字符串甚至能夠包含列表（所謂嵌套）。
列表是寫在方括號([])之間、用逗號分隔開的元素列表。
和字符串同樣，列表一樣能夠被索引和截取，列表被截取後返回一個包含所需元素的新列表。
列表截取的語法格式以下：
變量[頭下標:尾下標]
................................................................................
索引值以 0 爲開始值，-1 爲從末尾的開始位置。
加號（+）是列表鏈接運算符，星號（*）是重複操做。以下實例：
#!/usr/bin/python3 list = [ 'abcd', 786 , 2.23, 'php', 70.2 ] tinylist = [123, 'php'] print (list) # 輸出完整列表 print (list[0]) # 輸出列表第一個元素 print (list[1:3]) # 從第二個開始輸出到第三個元素 print (list[2:]) # 輸出從第三個元素開始的全部元素 print (tinylist * 2) # 輸出兩次列表 print (list + tinylist) # 鏈接列表
................................................................................
以上實例輸出結果：
['abcd', 786, 2.23, 'php', 70.2] abcd [786, 2.23] [2.23, 'php', 70.2] [123, 'php', 123, 'php'] ['abcd', 786, 2.23, 'php', 70.2, 123, 'php']
................................................................................
與Python字符串不同的是，列表中的元素是能夠改變的：
>>> a = [1, 2, 3, 4, 5, 6] >>> a[0] = 9 >>> a[2:5] = [13, 14, 15] >>> a [9, 2, 13, 14, 15, 6] >>> a[2:5] = [] # 刪除 >>> a [9, 2, 6]
................................................................................
List內置了有不少方法，例如append()、pop()等等，這在後面會講到。
注意：
一、List寫在方括號之間，元素用逗號隔開。
二、和字符串同樣，list能夠被索引和切片。
三、List能夠使用+操做符進行拼接。
四、List中的元素是能夠改變的。
Tuple（元組）
元組（tuple）與列表相似，不一樣之處在於元組的元素不能修改。元組寫在小括號(())裏，元素之間用逗號隔開。
元組中的元素類型也能夠不相同：
#!/usr/bin/python3 tuple = ( 'abcd', 786 , 2.23, 'php', 70.2 ) tinytuple = (123, 'php') print (tuple) # 輸出完整元組 print (tuple[0]) # 輸出元組的第一個元素 print (tuple[1:3]) # 輸出從第二個元素開始到第三個元素 print (tuple[2:]) # 輸出從第三個元素開始的全部元素 print (tinytuple * 2) # 輸出兩次元組 print (tuple + tinytuple) # 鏈接元組
................................................................................
以上實例輸出結果：
('abcd', 786, 2.23, 'php', 70.2)
abcd
(786, 2.23)
(2.23, 'php', 70.2)
(123, 'php', 123, 'php')
('abcd', 786, 2.23, 'php', 70.2, 123, 'php')
................................................................................
元組與字符串相似，能夠被索引且下標索引從0開始，-1 爲從末尾開始的位置。也能夠進行截取（看上面，這裏再也不贅述）。
其實，能夠把字符串看做一種特殊的元組。
>>> tup = (1, 2, 3, 4, 5, 6) >>> print(tup[0]) 1 >>> print(tup[1:5]]) (2, 3, 4, 5) >>> tup[0] = 11 # 修改元組元素的操做是非法的 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>>
................................................................................
雖然tuple的元素不可改變，但它能夠包含可變的對象，好比list列表。
構造包含 0 個或 1 個元素的元組比較特殊，因此有一些額外的語法規則：
tup1 = () # 空元組 tup2 = (20,) # 一個元素，須要在元素後添加逗號
................................................................................
string、list和tuple都屬於sequence（序列）。
注意：
一、與字符串同樣，元組的元素不能修改。
二、元組也能夠被索引和切片，方法同樣。
三、注意構造包含0或1個元素的元組的特殊語法規則。
四、元組也能夠使用+操做符進行拼接。
Set（集合）
集合（set）是一個無序不重複元素的序列。
基本功能是進行成員關係測試和刪除重複元素。
能夠使用大括號({})或者 set()函數建立集合，注意：建立一個空集合必須用 set() 而不是 { }，由於 { } 是用來建立一個空字典。
#!/usr/bin/python3
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 輸出集合，重複的元素被自動去掉
# 成員測試
if('Rose' in student) :
print('Rose 在集合中')
else :
print('Rose 不在集合中')
# set能夠進行集合運算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a和b的差集
print(a | b) # a和b的並集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不一樣時存在的元素
................................................................................
以上實例輸出結果：
{'Jack', 'Rose', 'Mary', 'Jim', 'Tom'}
Rose 在集合中
{'r', 'b', 'a', 'c', 'd'}
{'r', 'b', 'd'}
{'a', 'l', 'z', 'b', 'm', 'd', 'r', 'c'}
{'a', 'c'}
{'l', 'z', 'b', 'm', 'd', 'r'}
................................................................................
Dictionary（字典）（字典）
字典（dictionary）是Python中另外一個很是有用的內置數據類型。
列表是有序的對象結合，字典是無序的對象集合。二者之間的區別在於：字典當中的元素是經過鍵來存取的，而不是經過偏移存取。
字典是一種映射類型，字典用"{ }"標識，它是一個無序的鍵(key) : 值(value)對集合。
鍵(key)必須使用不可變類型。
在同一個字典中，鍵(key)必須是惟一的。
#!/usr/bin/python3
dict = {}
dict['one'] = "1 - php中文網"
dict[2] = "2 - php工具"
tinydict = {'name': 'php','code':1, 'site': 'www.php.cn'}
print (dict['one']) # 輸出鍵爲 'one' 的值
print (dict[2]) # 輸出鍵爲 2 的值
print (tinydict) # 輸出完整的字典
print (tinydict.keys()) # 輸出全部鍵
print (tinydict.values()) # 輸出全部值
................................................................................
以上實例輸出結果：
1 - php中文網
2 - php工具
{'name': 'php', 'site': 'www.php.cn', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['php', 'www.php.cn', 1])
................................................................................
構造函數 dict() 能夠直接從鍵值對序列中構建字典以下：
>>> dict([('php', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'php': 1, 'Google': 2}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(php=1, Google=2, Taobao=3)
{'Taobao': 3, 'php': 1, 'Google': 2}
................................................................................
另外，字典類型也有一些內置的函數，例如clear()、keys()、values()等。
注意：
一、字典是一種映射類型，它的元素是鍵值對。
二、字典的關鍵字必須爲不可變類型，且不能重複。
三、建立空字典使用 { }。
Python數據類型轉換
有時候，咱們須要對數據內置的類型進行轉換，數據類型的轉換，你只須要將數據類型做爲函數名便可。
如下幾個內置的函數能夠執行數據類型之間的轉換。這些函數返回一個新的對象，表示轉換的值。
| 函數 | 描述 |
|---|---|
| int(x [,base]) |
將x轉換爲一個整數 |
| float(x) |
將x轉換到一個浮點數 |
| complex(real [,imag]) |
建立一個複數 |
| str(x) |
將對象 x 轉換爲字符串 |
| repr(x) |
將對象 x 轉換爲表達式字符串 |
| eval(str) |
用來計算在字符串中的有效Python表達式,並返回一個對象 |
| tuple(s) |
將序列 s 轉換爲一個元組 |
| list(s) |
將序列 s 轉換爲一個列表 |
| set(s) |
轉換爲可變集合 |
| dict(d) |
建立一個字典。d 必須是一個序列 (key,value)元組。 |
| frozenset(s) |
轉換爲不可變集合 |
| chr(x) |
將一個整數轉換爲一個字符 |
| unichr(x) |
將一個整數轉換爲Unicode字符 |
| ord(x) |
將一個字符轉換爲它的整數值 |
| hex(x) |
將一個整數轉換爲一個十六進制字符串 |
| oct(x) |
將一個整數轉換爲一個八進制字符串 |
................................................................................
int(x [,base])
將x轉換爲一個整數
float(x)
將x轉換到一個浮點數
complex(real [,imag])
建立一個複數
str(x)
將對象 x 轉換爲字符串
repr(x)
將對象 x 轉換爲表達式字符串
eval(str)
用來計算在字符串中的有效Python表達式,並返回一個對象
tuple(s)
將序列 s 轉換爲一個元組
list(s)
將序列 s 轉換爲一個列表
set(s)
轉換爲可變集合
dict(d)
建立一個字典。d 必須是一個序列 (key,value)元組。
frozenset(s)
轉換爲不可變集合
chr(x)
將一個整數轉換爲一個字符
unichr(x)
將一個整數轉換爲Unicode字符
ord(x)
將一個字符轉換爲它的整數值
hex(x)
將一個整數轉換爲一個十六進制字符串
oct(x)
將一個整數轉換爲一個八進制字符串
休息一下子……
今天內容：python3-date-time.html
********************************************************
Python 程序能用不少方式處理日期和時間，轉換日期格式是一個常見的功能。
Python 提供了一個 time 和 calendar 模塊能夠用於格式化日期和時間。
時間間隔是以秒爲單位的浮點小數。
每一個時間戳都以自從1970年1月1日午夜（曆元）通過了多長時間來表示。
Python 的 time 模塊下有不少函數能夠轉換常見日期格式。如函數time.time()用於獲取當前時間戳, 以下實例:
#!/usr/bin/python3
import time; # 引入time模塊
ticks = time.time()
print ("當前時間戳爲:", ticks)
................................................................................
以上實例輸出結果：
當前時間戳爲: 1459996086.7115328
................................................................................
時間戳單位最適於作日期運算。可是1970年以前的日期就沒法以此表示了。太遙遠的日期也不行，UNIX和Windows只支持到2038年。
什麼是時間元組？
不少Python函數用一個元組裝起來的9組數字處理時間:
| 序號 | 字段 | 值 |
|---|---|---|
| 0 | 4位數年 | 2008 |
| 1 | 月 | 1 到 12 |
| 2 | 日 | 1到31 |
| 3 | 小時 | 0到23 |
| 4 | 分鐘 | 0到59 |
| 5 | 秒 | 0到61 (60或61 是閏秒) |
| 6 | 一週的第幾日 | 0到6 (0是週一) |
| 7 | 一年的第幾日 | 1到366 (儒略曆) |
| 8 | 夏令時 | -1, 0, 1, -1是決定是否爲夏令時的旗幟 |
................................................................................
上述也就是struct_time元組。這種結構具備以下屬性：
| 序號 | 屬性 | 值 |
|---|---|---|
| 0 | tm_year | 2008 |
| 1 | tm_mon | 1 到 12 |
| 2 | tm_mday | 1 到 31 |
| 3 | tm_hour | 0 到 23 |
| 4 | tm_min | 0 到 59 |
| 5 | tm_sec | 0 到 61 (60或61 是閏秒) |
| 6 | tm_wday | 0到6 (0是週一) |
| 7 | tm_yday | 1 到 366(儒略曆) |
| 8 | tm_isdst | -1, 0, 1, -1是決定是否爲夏令時的旗幟 |
................................................................................
獲取當前時間
從返回浮點數的時間輟方式向時間元組轉換，只要將浮點數傳遞給如localtime之類的函數。
#!/usr/bin/python3
import time
localtime = time.localtime(time.time())
print ("本地時間爲 :", localtime)
................................................................................
以上實例輸出結果：
本地時間爲 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=28, tm_sec=49, tm_wday=3, tm_yday=98, tm_isdst=0)
................................................................................
獲取格式化的時間
你能夠根據需求選取各類格式，可是最簡單的獲取可讀的時間模式的函數是asctime():
#!/usr/bin/python3
import time
localtime = time.asctime( time.localtime(time.time()) )
print ("本地時間爲 :", localtime)
................................................................................
以上實例輸出結果：
本地時間爲 : Thu Apr 7 10:29:13 2016
................................................................................
格式化日期
咱們能夠使用 time 模塊的 strftime 方法來格式化日期，：
time.strftime(format[, t])
................................................................................
#!/usr/bin/python3
import time
# 格式化成2016-03-20 11:45:39形式
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
# 格式化成Sat Mar 28 22:24:24 2016形式
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
# 將格式字符串轉換爲時間戳
a = "Sat Mar 28 22:24:24 2016"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))
................................................................................
以上實例輸出結果：
2016-04-07 10:29:46 Thu Apr 07 10:29:46 2016 1459175064.0
................................................................................
python中時間日期格式化符號：
%y 兩位數的年份表示（00-99）
%Y 四位數的年份表示（000-9999）
%m 月份（01-12）
%d 月內中的一天（0-31）
%H 24小時制小時數（0-23）
%I 12小時制小時數（01-12）
%M 分鐘數（00=59）
%S 秒（00-59）
%a 本地簡化星期名稱
%A 本地完整星期名稱
%b 本地簡化的月份名稱
%B 本地完整的月份名稱
%c 本地相應的日期表示和時間表示
%j 年內的一天（001-366）
%p 本地A.M.或P.M.的等價符
%U 一年中的星期數（00-53）星期天爲星期的開始
%w 星期（0-6），星期天爲星期的開始
%W 一年中的星期數（00-53）星期一爲星期的開始
%x 本地相應的日期表示
%X 本地相應的時間表示
%Z 當前時區的名稱
%% %號自己
獲取某月日曆
Calendar模塊有很普遍的方法用來處理年曆和月曆，例如打印某月的月曆：
#!/usr/bin/python3
import calendar
cal = calendar.month(2016, 1)
print ("如下輸出2016年1月份的日曆:")
print (cal)
................................................................................
以上實例輸出結果：
如下輸出2016年1月份的日曆: January 2016 Mo Tu We Th Fr Sa Su 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
................................................................................
Time 模塊
Time 模塊包含了如下內置函數，既有時間處理相的，也有轉換時間格式的：
| 序號 | 函數及描述 | 實例 |
|---|---|---|
| 1 | time.altzone 返回格林威治西部的夏令時地區的偏移秒數。若是該地區在格林威治東部會返回負值（如西歐，包括英國）。對夏令時啓用地區才能使用。 |
如下實例展現了 altzone()函數的使用方法： >>> import time
>>> print ("time.altzone %d " % time.altzone)
time.altzone -28800 |
| 2 | time.asctime([tupletime]) 接受時間元組並返回一個可讀的形式爲"Tue Dec 11 18:07:14 2008"（2008年12月11日 週二18時07分14秒）的24個字符的字符串。 |
如下實例展現了 asctime()函數的使用方法： >>> import time
>>> t = time.localtime()
>>> print ("time.asctime(t): %s " % time.asctime(t))
time.asctime(t): Thu Apr 7 10:36:20 2016 |
| 3 | time.clock() 用以浮點數計算的秒數返回當前的CPU時間。用來衡量不一樣程序的耗時，比time.time()更有用。 |
實例 |
| 4 | time.ctime([secs]) 做用至關於asctime(localtime(secs))，未給參數至關於asctime() |
如下實例展現了 ctime()函數的使用方法： >>> import time
>>> print ("time.ctime() : %s" % time.ctime())
time.ctime() : Thu Apr 7 10:51:58 2016 |
| 5 | time.gmtime([secs]) 接收時間輟（1970紀元後通過的浮點秒數）並返回格林威治天文時間下的時間元組t。注：t.tm_isdst始終爲0 |
如下實例展現了 gmtime()函數的使用方法： >>> import time
>>> print ("gmtime :", time.gmtime(1455508609.34375))
gmtime : time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=3, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0) |
| 6 | time.localtime([secs] 接收時間輟（1970紀元後通過的浮點秒數）並返回當地時間下的時間元組t（t.tm_isdst可取0或1，取決於當地當時是否是夏令時）。 |
如下實例展現了 localtime()函數的使用方法： >>> import time
>>> print ("localtime(): ", time.localtime(1455508609.34375))
localtime(): time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=11, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0) |
| 7 | time.mktime(tupletime) 接受時間元組並返回時間輟（1970紀元後通過的浮點秒數）。 |
實例 |
| 8 | time.sleep(secs) 推遲調用線程的運行，secs指秒數。 |
如下實例展現了 sleep()函數的使用方法： #!/usr/bin/python3
import time
print ("Start : %s" % time.ctime())
time.sleep( 5 )
print ("End : %s" % time.ctime()) |
| 9 | time.strftime(fmt[,tupletime]) 接收以時間元組，並返回以可讀字符串表示的當地時間，格式由fmt決定。 |
如下實例展現了 strftime()函數的使用方法： >>> import time
>>> print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
2016-04-07 11:18:05 |
| 10 | time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根據fmt的格式把一個時間字符串解析爲時間元組。 |
如下實例展現了 strftime()函數的使用方法： >>> import time
>>> struct_time = time.strptime("30 Nov 00", "%d %b %y")
>>> print ("返回元組: ", struct_time)
返回元組: time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1) |
| 11 | time.time( ) 返回當前時間的時間戳（1970紀元後通過的浮點秒數）。 |
如下實例展現了 time()函數的使用方法： >>> import time >>> print(time.time()) 1459999336.1963577 |
| 12 | time.tzset() 根據環境變量TZ從新初始化時間相關設置。 |
實例 |
................................................................................
如下實例展現了 altzone()函數的使用方法：
>>> import time
>>> print ("time.altzone %d " % time.altzone)
time.altzone -28800
................................................................................
如下實例展現了 asctime()函數的使用方法：
>>> import time
>>> t = time.localtime()
>>> print ("time.asctime(t): %s " % time.asctime(t))
time.asctime(t): Thu Apr 7 10:36:20 2016
................................................................................
如下實例展現了 ctime()函數的使用方法：
>>> import time
>>> print ("time.ctime() : %s" % time.ctime())
time.ctime() : Thu Apr 7 10:51:58 2016
................................................................................
如下實例展現了 gmtime()函數的使用方法：
>>> import time
>>> print ("gmtime :", time.gmtime(1455508609.34375))
gmtime : time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=3, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0)
................................................................................
如下實例展現了 localtime()函數的使用方法：
>>> import time
>>> print ("localtime(): ", time.localtime(1455508609.34375))
localtime(): time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=11, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0)
................................................................................
如下實例展現了 sleep()函數的使用方法：
#!/usr/bin/python3
import time
print ("Start : %s" % time.ctime())
time.sleep( 5 )
print ("End : %s" % time.ctime())
................................................................................
如下實例展現了 strftime()函數的使用方法：
>>> import time
>>> print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
2016-04-07 11:18:05
................................................................................
如下實例展現了 strftime()函數的使用方法：
>>> import time
>>> struct_time = time.strptime("30 Nov 00", "%d %b %y")
>>> print ("返回元組: ", struct_time)
返回元組: time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)
................................................................................
如下實例展現了 time()函數的使用方法：
>>> import time >>> print(time.time()) 1459999336.1963577
................................................................................
Time模塊包含了如下2個很是重要的屬性：
| 序號 | 屬性及描述 |
|---|---|
| 1 | time.timezone 屬性time.timezone是當地時區（未啓動夏令時）距離格林威治的偏移秒數（>0，美洲;<=0大部分歐洲，亞洲，非洲）。 |
| 2 | time.tzname 屬性time.tzname包含一對根據狀況的不一樣而不一樣的字符串，分別是帶夏令時的本地時區名稱，和不帶的。 |
................................................................................
日曆（Calendar）模塊
此模塊的函數都是日曆相關的，例如打印某月的字符月曆。
星期一是默認的每週第一天，星期天是默認的最後一天。更改設置需調用calendar.setfirstweekday()函數。模塊包含了如下內置函數：
| 序號 | 函數及描述 |
|---|---|
| 1 | calendar.calendar(year,w=2,l=1,c=6) 返回一個多行字符串格式的year年年曆，3個月一行，間隔距離爲c。 每日寬度間隔爲w字符。每行長度爲21* W+18+2* C。l是每星期行數。 |
| 2 | calendar.firstweekday( ) 返回當前每週起始日期的設置。默認狀況下，首次載入caendar模塊時返回0，即星期一。 |
| 3 | calendar.isleap(year) 是閏年返回True，不然爲false。 |
| 4 | calendar.leapdays(y1,y2) 返回在Y1，Y2兩年之間的閏年總數。 |
| 5 | calendar.month(year,month,w=2,l=1) 返回一個多行字符串格式的year年month月日曆，兩行標題，一週一行。每日寬度間隔爲w字符。每行的長度爲7* w+6。l是每星期的行數。 |
| 6 | calendar.monthcalendar(year,month) 返回一個整數的單層嵌套列表。每一個子列表裝載表明一個星期的整數。Year年month月外的日期都設爲0;範圍內的日子都由該月第幾日表示，從1開始。 |
| 7 | calendar.monthrange(year,month) 返回兩個整數。第一個是該月的星期幾的日期碼，第二個是該月的日期碼。日從0（星期一）到6（星期日）;月從1到12。 |
| 8 | calendar.prcal(year,w=2,l=1,c=6) 至關於 print calendar.calendar(year,w,l,c). |
| 9 | calendar.prmonth(year,month,w=2,l=1) 至關於 print calendar.calendar（year，w，l，c）。 |
| 10 | calendar.setfirstweekday(weekday) 設置每週的起始日期碼。0（星期一）到6（星期日）。 |
| 11 | calendar.timegm(tupletime) 和time.gmtime相反：接受一個時間元組形式，返回該時刻的時間輟（1970紀元後通過的浮點秒數）。 |
| 12 | calendar.weekday(year,month,day) 返回給定日期的日期碼。0（星期一）到6（星期日）。月份爲 1（一月） 到 12（12月）。 |
................................................................................
其餘相關模塊和函數
在Python中，其餘處理日期和時間的模塊還有：
time 模塊
datetime模塊
休息一下子……
今天內容：python3-dictionary.html
********************************************************
字典是另外一種可變容器模型，且可存儲任意類型對象。
字典的每一個鍵值(key=>value)對用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式以下所示：
d = {key1 : value1, key2 : value2 }
................................................................................
鍵必須是惟一的，但值則沒必要。
值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
一個簡單的字典實例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
................................................................................
也可如此建立字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
................................................................................
訪問字典裏的值
把相應的鍵放入熟悉的方括弧，以下實例:
#!/usr/bin/python3
dict = {'Name': 'php', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])
................................................................................
以上實例輸出結果：
dict['Name']: php dict['Age']: 7
................................................................................
若是用字典裏沒有的鍵訪問數據，會輸出錯誤以下：
#!/usr/bin/python3
dict = {'Name': 'php', 'Age': 7, 'Class': 'First'};
print ("dict['Alice']: ", dict['Alice'])
................................................................................
以上實例輸出結果：
Traceback (most recent call last):
File "test.py", line 5, in <module>
print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'
................................................................................
修改字典
向字典添加新內容的方法是增長新的鍵/值對，修改或刪除已有鍵/值對以下實例:
#!/usr/bin/python3
dict = {'Name': 'php', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # 更新 Age
dict['School'] = "php中文網" # 添加信息
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
................................................................................
dict['Age']: 8 dict['School']: php中文網
................................................................................
刪除字典元素
能刪單一的元素也能清空字典，清空只需一項操做。
顯示刪除一個字典用del命令，以下實例：
#!/usr/bin/python3
dict = {'Name': 'php', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 刪除鍵 'Name'
dict.clear() # 刪除字典
del dict # 刪除字典
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
................................................................................
但這會引起一個異常，由於用執行 del 操做後字典再也不存在：
Traceback (most recent call last):
File "test.py", line 9, in <module>
print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable
................................................................................
注：del() 方法後面也會討論。
字典值能夠沒有限制地取任何python對象，既能夠是標準的對象，也能夠是用戶定義的，但鍵不行。
兩個重要的點須要記住：
1）不容許同一個鍵出現兩次。建立時若是同一個鍵被賦值兩次，後一個值會被記住，以下實例：
#!/usr/bin/python3
dict = {'Name': 'php', 'Age': 7, 'Name': '小php'}
print ("dict['Name']: ", dict['Name'])
................................................................................
以上實例輸出結果：
dict['Name']: 小php
................................................................................
2）鍵必須不可變，因此能夠用數字，字符串或元組充當，而用列表就不行，以下實例：
#!/usr/bin/python3
dict = {['Name']: 'php', 'Age': 7}
print ("dict['Name']: ", dict['Name'])
................................................................................
以上實例輸出結果：
Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {['Name']: 'php', 'Age': 7}
TypeError: unhashable type: 'list'
................................................................................
字典內置函數&方法
Python字典包含了如下內置函數：
| 序號 | 函數及描述 | 實例 |
|---|---|---|
| 1 | len(dict) 計算字典元素個數，即鍵的總數。 |
>>> dict = {'Name': 'php', 'Age': 7, 'Class': 'First'}
>>> len(dict)
3 |
| 2 | str(dict) 輸出字典以可打印的字符串表示。 |
>>> dict = {'Name': 'php', 'Age': 7, 'Class': 'First'}
>>> str(dict)
"{'Name': 'php', 'Class': 'First', 'Age': 7}" |
| 3 | type(variable) 返回輸入的變量類型，若是變量是字典就返回字典類型。 |
>>> dict = {'Name': 'php', 'Age': 7, 'Class': 'First'}
>>> type(dict)
<class 'dict'> |
................................................................................
>>> dict = {'Name': 'php', 'Age': 7, 'Class': 'First'}
>>> len(dict)
3
................................................................................
>>> dict = {'Name': 'php', 'Age': 7, 'Class': 'First'}
>>> str(dict)
"{'Name': 'php', 'Class': 'First', 'Age': 7}"
................................................................................
>>> dict = {'Name': 'php', 'Age': 7, 'Class': 'First'}
>>> type(dict)
<class 'dict'>
................................................................................
Python字典包含了如下內置方法：
| 序號 | 函數及描述 |
|---|---|
| 1 | radiansdict.clear() 刪除字典內全部元素 |
| 2 | radiansdict.copy() 返回一個字典的淺複製 |
| 3 | radiansdict.fromkeys() 建立一個新字典，以序列seq中元素作字典的鍵，val爲字典全部鍵對應的初始值 |
| 4 | radiansdict.get(key, default=None) 返回指定鍵的值，若是值不在字典中返回default值 |
| 5 | key in dict 若是鍵在字典dict裏返回true，不然返回false |
| 6 | radiansdict.items() 以列表返回可遍歷的(鍵, 值) 元組數組 |
| 7 | radiansdict.keys() 以列表返回一個字典全部的鍵 |
| 8 | radiansdict.setdefault(key, default=None) 和get()相似, 但若是鍵不存在於字典中，將會添加鍵並將值設爲default |
| 9 | radiansdict.update(dict2) 把字典dict2的鍵/值對更新到dict裏 |
| 10 | radiansdict.values() 以列表返回字典中的全部值 |
................................................................................
休息一下子……
今天內容：python3-dictionary-text.html
********************************************************
休息一下子……
今天內容：python3-errors-execptions.html
********************************************************
做爲Python初學者，在剛學習Python編程時，常常會看到一些報錯信息，在前面咱們沒有說起，這章節咱們會專門介紹。
Python有兩種錯誤很容易辨認：語法錯誤和異常。
語法錯誤
Python 的語法錯誤或者稱之爲解析錯，是初學者常常碰到的，以下實例
>>> while True print('Hello world')
File "<stdin>", line 1, in ?
while True print('Hello world')
^
SyntaxError: invalid syntax
................................................................................
這個例子中，函數 print() 被檢查到有錯誤，是它前面缺乏了一個冒號（:）。
語法分析器指出了出錯的一行，而且在最早找到的錯誤的位置標記了一個小小的箭頭。
異常
即使Python程序的語法是正確的，在運行它的時候，也有可能發生錯誤。運行期檢測到的錯誤被稱爲異常。
大多數的異常都不會被程序處理，都以錯誤信息的形式展示在這裏:
>>> 10 * (1/0) Traceback (most recent call last): File "<stdin>", line 1, in ? ZeroDivisionError: division by zero >>> 4 + spam*3 Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'spam' is not defined >>> '2' + 2 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: Can't convert 'int' object to str implicitly
................................................................................
異常以不一樣的類型出現，這些類型都做爲信息的一部分打印出來: 例子中的類型有 ZeroDivisionError，NameError 和 TypeError。
錯誤信息的前面部分顯示了異常發生的上下文，並以調用棧的形式顯示具體信息。
異常處理
如下例子中，讓用戶輸入一個合法的整數，可是容許用戶中斷這個程序（使用 Control-C 或者操做系統提供的方法）。用戶中斷的信息會引起一個 KeyboardInterrupt 異常。
>>> while True:
try:
x = int(input("Please enter a number: "))
break
except ValueError:
print("Oops! That was no valid number. Try again ")
................................................................................
try語句按照以下方式工做；
首先，執行try子句（在關鍵字try和關鍵字except之間的語句）
若是沒有異常發生，忽略except子句，try子句執行後結束。
若是在執行try子句的過程當中發生了異常，那麼try子句餘下的部分將被忽略。若是異常的類型和 except 以後的名稱相符，那麼對應的except子句將被執行。最後執行 try 語句以後的代碼。
若是一個異常沒有與任何的except匹配，那麼這個異常將會傳遞給上層的try中。
一個 try 語句可能包含多個except子句，分別來處理不一樣的特定的異常。最多隻有一個分支會被執行。
處理程序將只針對對應的try子句中的異常進行處理，而不是其餘的 try 的處理程序中的異常。
一個except子句能夠同時處理多個異常，這些異常將被放在一個括號裏成爲一個元組，例如:
except (RuntimeError, TypeError, NameError): pass
................................................................................
最後一個except子句能夠忽略異常的名稱，它將被看成通配符使用。你能夠使用這種方法打印一個錯誤信息，而後再次把異常拋出。
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer.")
except:
print("Unexpected error:", sys.exc_info()[0])
raise
................................................................................
try except 語句還有一個可選的else子句，若是使用這個子句，那麼必須放在全部的except子句以後。這個子句將在try子句沒有發生任何異常的時候執行。例如:
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print('cannot open', arg)
else:
print(arg, 'has', len(f.readlines()), 'lines')
f.close()
................................................................................
使用 else 子句比把全部的語句都放在 try 子句裏面要好，這樣能夠避免一些意想不到的、而except又沒有捕獲的異常。
異常處理並不只僅處理那些直接發生在try子句中的異常，並且還能處理子句中調用的函數（甚至間接調用的函數）裏拋出的異常。例如:
>>> def this_fails():
x = 1/0
>>> try:
this_fails()
except ZeroDivisionError as err:
print('Handling run-time error:', err)
Handling run-time error: int division or modulo by zero
................................................................................
拋出異常
Python 使用 raise 語句拋出一個指定的異常。例如:
>>> raise NameError('HiThere')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: HiThere
................................................................................
raise 惟一的一個參數指定了要被拋出的異常。它必須是一個異常的實例或者是異常的類（也就是 Exception 的子類）。
若是你只想知道這是否拋出了一個異常，並不想去處理它，那麼一個簡單的 raise 語句就能夠再次把它拋出。
>>> try:
raise NameError('HiThere')
except NameError:
print('An exception flew by!')
raise
An exception flew by!
Traceback (most recent call last):
File "<stdin>", line 2, in ?
NameError: HiThere
................................................................................
用戶自定義異常
你能夠經過建立一個新的exception類來擁有本身的異常。異常應該繼承自 Exception 類，或者直接繼承，或者間接繼承，例如:
>>> class MyError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
>>> try:
raise MyError(2*2)
except MyError as e:
print('My exception occurred, value:', e.value)
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'
................................................................................
在這個例子中，類 Exception 默認的 __init__() 被覆蓋。
當建立一個模塊有可能拋出多種不一樣的異常時，一種一般的作法是爲這個包創建一個基礎異常類，而後基於這個基礎類爲不一樣的錯誤狀況建立不一樣的子類:
class Error(Exception): """Base class for exceptions in this module.""" pass class InputError(Error): """Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """ def __init__(self, expression, message): self.expression = expression self.message = message class TransitionError(Error): """Raised when an operation attempts a state transition that's not allowed. Attributes: previous -- state at beginning of transition next -- attempted new state message -- explanation of why the specific transition is not allowed """ def __init__(self, previous, next, message): self.previous = previous self.next = next self.message = message
................................................................................
大多數的異常的名字都以"Error"結尾，就跟標準的異常命名同樣。
定義清理行爲
try 語句還有另一個可選的子句，它定義了不管在任何狀況下都會執行的清理行爲。 例如:
>>> try:
raise KeyboardInterrupt
finally:
print('Goodbye, world!')
Goodbye, world!
KeyboardInterrupt
................................................................................
以上例子無論try子句裏面有沒有發生異常，finally子句都會執行。
若是一個異常在 try 子句裏（或者在 except 和 else 子句裏）被拋出，而又沒有任何的 except 把它截住，那麼這個異常會在 finally 子句執行後再次被拋出。
下面是一個更加複雜的例子（在同一個 try 語句裏包含 except 和 finally 子句）:
>>> def divide(x, y):
try:
result = x / y
except ZeroDivisionError:
print("division by zero!")
else:
print("result is", result)
finally:
print("executing finally clause")
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'
................................................................................
預約義的清理行爲
一些對象定義了標準的清理行爲，不管系統是否成功的使用了它，一旦不須要它了，那麼這個標準的清理行爲就會執行。
這面這個例子展現了嘗試打開一個文件，而後把內容打印到屏幕上:
for line in open("myfile.txt"):
print(line, end="")
................................................................................
以上這段代碼的問題是，當執行完畢後，文件會保持打開狀態，並無被關閉。
關鍵詞 with 語句就能夠保證諸如文件之類的對象在使用完以後必定會正確的執行他的清理方法:
with open("myfile.txt") as f:
for line in f:
print(line, end="")
................................................................................
以上這段代碼執行完畢後，就算在處理過程當中出問題了，文件 f 老是會關閉。
休息一下子……
今天內容：python3-examples.html
********************************************************
如下實例在 Python3.4.3 版本下測試經過：
Python Hello World 實例
Python 數字求和
Python 平方根
Python 二次方程
Python 計算三角形的面積
Python 隨機數生成
Python 攝氏溫度轉華氏溫度
Python 交換變量
Python if 語句
Python 判斷字符串是否爲數字
Python 判斷奇數偶數
Python 判斷閏年
Python 獲取最大值函數
Python 質數判斷
Python 階乘實例
Python 九九乘法表
Python 斐波那契數列
Python 阿姆斯特朗數
Python 十進制轉二進制、八進制、十六進制
Python ASCII碼與字符相互轉換
Python 最大公約數算法
Python 最小公倍數算法
Python 簡單計算器實現
Python 生成日曆
Python 使用遞歸斐波那契數列
Python 文件 IO
Python 字符串判斷
Python 字符串大小寫轉換
Python 計算每月天數
Python 獲取昨天日期
Python list 經常使用操做
休息一下子……
今天內容：python3-file-methods.html
********************************************************
file 對象使用 open 函數來建立，下表列出了 file 對象經常使用的函數：
| 序號 | 方法及描述 |
|---|---|
| 1 | file.close() 關閉文件。關閉後文件不能再進行讀寫操做。 |
| 2 | file.flush() 刷新文件內部緩衝，直接把內部緩衝區的數據馬上寫入文件, 而不是被動的等待輸出緩衝區寫入。 |
| 3 | file.fileno() 返回一個整型的文件描述符(file descriptor FD 整型), 能夠用在如os模塊的read方法等一些底層操做上。 |
| 4 | file.isatty() 若是文件鏈接到一個終端設備返回 True，不然返回 False。 |
| 5 | file.next() 返回文件下一行。 |
| 6 | file.read([size]) 從文件讀取指定的字節數，若是未給定或爲負則讀取全部。 |
| 7 | file.readline([size]) 讀取整行，包括 "\n" 字符。 |
| 8 | file.readlines([sizehint]) 讀取全部行並返回列表，若給定sizeint>0，返回總和大約爲sizeint字節的行, 實際讀取值可能比sizhint較大, 由於須要填充緩衝區。 |
| 9 | file.seek(offset[, whence]) 設置文件當前位置 |
| 10 | file.tell() 返回文件當前位置。 |
| 11 | file.truncate([size]) 截取文件，截取的字節經過size指定，默認爲當前文件位置。 |
| 12 | file.write(str) 將字符串寫入文件，沒有返回值。 |
| 13 | file.writelines(sequence) 向文件寫入一個序列字符串列表，若是須要換行則要本身加入每行的換行符。 |
................................................................................
file.close()
關閉文件。關閉後文件不能再進行讀寫操做。
file.flush()
刷新文件內部緩衝，直接把內部緩衝區的數據馬上寫入文件, 而不是被動的等待輸出緩衝區寫入。
file.fileno()
返回一個整型的文件描述符(file descriptor FD 整型), 能夠用在如os模塊的read方法等一些底層操做上。
file.isatty()
若是文件鏈接到一個終端設備返回 True，不然返回 False。
file.next()
返回文件下一行。
file.read([size])
從文件讀取指定的字節數，若是未給定或爲負則讀取全部。
file.readline([size])
讀取整行，包括 "\n" 字符。
file.readlines([sizehint])
讀取全部行並返回列表，若給定sizeint>0，返回總和大約爲sizeint字節的行, 實際讀取值可能比sizhint較大, 由於須要填充緩衝區。
file.seek(offset[, whence])
設置文件當前位置
file.tell()
返回文件當前位置。
file.truncate([size])
截取文件，截取的字節經過size指定，默認爲當前文件位置。
file.write(str)
將字符串寫入文件，沒有返回值。
file.writelines(sequence)
向文件寫入一個序列字符串列表，若是須要換行則要本身加入每行的換行符。
休息一下子……
今天內容：python3-function.html
********************************************************
函數是組織好的，可重複使用的，用來實現單一，或相關聯功能的代碼段。
函數能提升應用的模塊性，和代碼的重複利用率。你已經知道Python提供了許多內建函數，好比print()。但你也能夠本身建立函數，這被叫作用戶自定義函數。
定義一個函數
你能夠定義一個由本身想要功能的函數，如下是簡單的規則：
函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號 ()。
任何傳入參數和自變量必須放在圓括號中間，圓括號之間能夠用於定義參數。
函數的第一行語句能夠選擇性地使用文檔字符串—用於存放函數說明。
函數內容以冒號起始，而且縮進。
return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return至關於返回 None。
Python 定義函數使用 def 關鍵字，通常格式以下：
def 函數名（參數列表）: 函數體
................................................................................
默認狀況下，參數值和參數名稱是按函數聲明中定義的的順序匹配起來的。
讓咱們使用函數來輸出"Hello World！"：
>>> def hello() :
print("Hello World!")
>>> hello()
Hello World!
>>>
................................................................................
更復雜點的應用，函數中帶上參數變量:
#!/usr/bin/python3
# 計算面積函數
def area(width, height):
return width * height
def print_welcome(name):
print("Welcome", name)
print_welcome("php")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
................................................................................
以上實例輸出結果：
Welcome php width = 4 height = 5 area = 20
................................................................................
函數調用
定義一個函數：給了函數一個名稱，指定了函數裏包含的參數，和代碼塊結構。
這個函數的基本結構完成之後，你能夠經過另外一個函數調用執行，也能夠直接從 Python 命令提示符執行。
以下實例調用了printme（）函數：
#!/usr/bin/python3
# 定義函數
def printme( str ):
"打印任何傳入的字符串"
print (str);
return;
# 調用函數
printme("我要調用用戶自定義函數!");
printme("再次調用同一函數");
................................................................................
以上實例輸出結果：
我要調用用戶自定義函數! 再次調用同一函數
................................................................................
按值傳遞參數和按引用傳遞參數
在 Python 中，全部參數（變量）都是按引用傳遞。若是你在函數裏修改了參數，那麼在調用這個函數的函數裏，原始的參數也被改變了。例如：
#!/usr/bin/python3
# 可寫函數說明
def changeme( mylist ):
"修改傳入的列表"
mylist.append([1,2,3,4]);
print ("函數內取值: ", mylist)
return
# 調用changeme函數
mylist = [10,20,30];
changeme( mylist );
print ("函數外取值: ", mylist)
................................................................................
傳入函數的和在末尾添加新內容的對象用的是同一個引用。故輸出結果以下：
函數內取值: [10, 20, 30, [1, 2, 3, 4]] 函數外取值: [10, 20, 30, [1, 2, 3, 4]]
................................................................................
參數
如下是調用函數時可以使用的正式參數類型：
必需參數
關鍵字參數
默認參數
不定長參數
必需參數須以正確的順序傳入函數。調用時的數量必須和聲明時的同樣。
調用printme()函數，你必須傳入一個參數，否則會出現語法錯誤：
#!/usr/bin/python3 #可寫函數說明 def printme( str ): "打印任何傳入的字符串" print (str); return; #調用printme函數 printme();
................................................................................
以上實例輸出結果：
Traceback (most recent call last): File "test.py", line 10, in <module> printme(); TypeError: printme() missing 1 required positional argument: 'str'
................................................................................
關鍵字參數和函數調用關係緊密，函數調用使用關鍵字參數來肯定傳入的參數值。
使用關鍵字參數容許函數調用時參數的順序與聲明時不一致，由於 Python 解釋器可以用參數名匹配參數值。
如下實例在函數 printme() 調用時使用參數名：
#!/usr/bin/python3 #可寫函數說明 def printme( str ): "打印任何傳入的字符串" print (str); return; #調用printme函數 printme( str = "php中文網");
................................................................................
以上實例輸出結果：
php中文網
................................................................................
如下實例中演示了函數參數的使用不須要使用指定順序：
#!/usr/bin/python3
#可寫函數說明
def printinfo( name, age ):
"打印任何傳入的字符串"
print ("名字: ", name);
print ("年齡: ", age);
return;
#調用printinfo函數
printinfo( age=50, name="php" );
................................................................................
以上實例輸出結果：
名字: php 年齡: 50
................................................................................
調用函數時，若是沒有傳遞參數，則會使用默認參數。如下實例中若是沒有傳入 age 參數，則使用默認值：
#!/usr/bin/python3
#可寫函數說明
def printinfo( name, age = 35 ):
"打印任何傳入的字符串"
print ("名字: ", name);
print ("年齡: ", age);
return;
#調用printinfo函數
printinfo( age=50, name="php" );
print ("------------------------")
printinfo( name="php" );
................................................................................
以上實例輸出結果：
名字: php 年齡: 50 ------------------------ 名字: php 年齡: 35
................................................................................
你可能須要一個函數能處理比當初聲明時更多的參數。這些參數叫作不定長參數，和上述2種參數不一樣，聲明時不會命名。基本語法以下：
def functionname([formal_args,] *var_args_tuple ): "函數_文檔字符串" function_suite return [expression]
................................................................................
加了星號（*）的變量名會存放全部未命名的變量參數。若是在函數調用時沒有指定參數，它就是一個空元組。咱們也能夠不向函數傳遞未命名的變量。以下實例：
#!/usr/bin/python3
# 可寫函數說明
def printinfo( arg1, *vartuple ):
"打印任何傳入的參數"
print ("輸出: ")
print (arg1)
for var in vartuple:
print (var)
return;
# 調用printinfo 函數
printinfo( 10 );
printinfo( 70, 60, 50 );
................................................................................
以上實例輸出結果：
輸出: 10 輸出: 70 60 50
................................................................................
匿名函數
python 使用 lambda 來建立匿名函數。
所謂匿名，意即再也不使用 def 語句這樣標準的形式定義一個函數。
lambda 只是一個表達式，函數體比 def 簡單不少。
lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda 函數擁有本身的命名空間，且不能訪問自有參數列表以外或全局命名空間裏的參數。
雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增長運行效率。
lambda 函數的語法只包含一個語句，以下：
lambda [arg1 [,arg2,.....argn]]:expression
................................................................................
以下實例：
#!/usr/bin/python3
# 可寫函數說明
sum = lambda arg1, arg2: arg1 + arg2;
# 調用sum函數
print ("相加後的值爲 : ", sum( 10, 20 ))
print ("相加後的值爲 : ", sum( 20, 20 ))
................................................................................
以上實例輸出結果：
相加後的值爲 : 30 相加後的值爲 : 40
................................................................................
return語句
return [表達式] 語句用於退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。以前的例子都沒有示範如何返回數值，如下實例演示了 return 語句的用法：
#!/usr/bin/python3
# 可寫函數說明
def sum( arg1, arg2 ):
# 返回2個參數的和."
total = arg1 + arg2
print ("函數內 : ", total)
return total;
# 調用sum函數
total = sum( 10, 20 );
print ("函數外 : ", total)
................................................................................
以上實例輸出結果：
函數內 : 30 函數外 : 30
................................................................................
變量做用域
Pyhton 中，程序的變量並非在哪一個位置均可以訪問的，訪問權限決定於這個變量是在哪裏賦值的。
休息一下子……
今天內容：python3-inputoutput.html
********************************************************
在前面幾個章節中，咱們其實已經接觸了 Python 的輸入輸出的功能。本章節咱們將具體介紹 Python 的輸入輸出。
輸出格式美化
Python兩種輸出值的方式: 表達式語句和 print() 函數。
第三種方式是使用文件對象的 write() 方法，標準輸出文件能夠用 sys.stdout 引用。
若是你但願輸出的形式更加多樣，能夠使用 str.format() 函數來格式化輸出值。
若是你但願將輸出的值轉成字符串，能夠使用 repr() 或 str() 函數來實現。
str()： 函數返回一個用戶易讀的表達形式。
repr()： 產生一個解釋器易讀的表達形式。
>>> s = 'Hello, php'
>>> str(s)
'Hello, php'
>>> repr(s)
"'Hello, php'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'x 的值爲： ' + repr(x) + ', y 的值爲：' + repr(y) + '...'
>>> print(s)
x 的值爲： 32.5, y 的值爲：40000...
>>> # repr() 函數能夠轉義字符串中的特殊字符
... hello = 'hello, php\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, php\n'
>>> # repr() 的參數能夠是 Python 的任何對象
... repr((x, y, ('Google', 'php')))
"(32.5, 40000, ('Google', 'php'))"
................................................................................
這裏有兩種方式輸出一個平方與立方的表:
>>> for x in range(1, 11):
... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... # 注意前一行 'end' 的使用
... print(repr(x*x*x).rjust(4))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> for x in range(1, 11):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
................................................................................
注意：在第一個例子中, 每列間的空格由 print() 添加。
這個例子展現了字符串對象的 rjust() 方法, 它能夠將字符串靠右, 並在左邊填充空格。
還有相似的方法, 如 ljust() 和 center()。 這些方法並不會寫任何東西, 它們僅僅返回新的字符串。
另外一個方法 zfill(), 它會在數字的左邊填充 0，以下所示：
>>> '12'.zfill(5) '00012' >>> '-3.14'.zfill(7) '-003.14' >>> '3.14159265359'.zfill(5) '3.14159265359'
................................................................................
str.format() 的基本使用以下:
>>> print('{}網址： "{}!"'.format('php中文網', 'www.php.cn'))
php中文網網址： "www.php.cn!"
................................................................................
括號及其裏面的字符 (稱做格式化字段) 將會被 format() 中的參數替換。
在括號中的數字用於指向傳入對象在 format() 中的位置，以下所示：
>>> print('{0} 和 {1}'.format('Google', 'php'))
Google 和 php
>>> print('{1} 和 {0}'.format('Google', 'php'))
php 和 Google
................................................................................
若是在 format() 中使用了關鍵字參數, 那麼它們的值會指向使用該名字的參數。
>>> print('{name}網址： {site}'.format(name='php中文網', site='www.php.cn'))
php中文網網址： www.php.cn
................................................................................
位置及關鍵字參數能夠任意的結合:
>>> print('站點列表 {0}, {1}, 和 {other}。'.format('Google', 'php',
other='Taobao'))
站點列表 Google, php, 和 Taobao。
................................................................................
>>> import math
>>> print('常量 PI 的值近似爲： {}。'.format(math.pi))
常量 PI 的值近似爲： 3.141592653589793。
>>> print('常量 PI 的值近似爲： {!r}。'.format(math.pi))
常量 PI 的值近似爲： 3.141592653589793。
................................................................................
可選項 ':' 和格式標識符能夠跟着字段名。 這就容許對值進行更好的格式化。 下面的例子將 Pi 保留到小數點後三位：
>>> import math
>>> print('常量 PI 的值近似爲 {0:.3f}。'.format(math.pi))
常量 PI 的值近似爲 3.142。
................................................................................
在 ':' 後傳入一個整數, 能夠保證該域至少有這麼多的寬度。 用於美化表格時頗有用。
>>> table = {'Google': 1, 'php': 2, 'Taobao': 3}
>>> for name, number in table.items():
... print('{0:10} ==> {1:10d}'.format(name, number))
...
php ==> 2
Taobao ==> 3
Google ==> 1
................................................................................
若是你有一個很長的格式化字符串, 而你不想將它們分開, 那麼在格式化時經過變量名而非位置會是很好的事情。
最簡單的就是傳入一個字典, 而後使用方括號 '[]' 來訪問鍵值 :
>>> table = {'Google': 1, 'php': 2, 'Taobao': 3}
>>> print('php: {0[php]:d}; Google: {0[Google]:d}; '
'Taobao: {0[Taobao]:d}'.format(table))
php: 2; Google: 1; Taobao: 3
................................................................................
也能夠經過在 table 變量前使用 '**' 來實現相同的功能：
>>> table = {'Google': 1, 'php': 2, 'Taobao': 3}
>>> print('php: {php:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
php: 2; Google: 1; Taobao: 3
................................................................................
舊式字符串格式化
% 操做符也能夠實現字符串格式化。 它將左邊的參數做爲相似 sprintf() 式的格式化字符串, 而將右邊的代入, 而後返回格式化後的字符串. 例如:
>>> import math
>>> print('常量 PI 的值近似爲：%5.3f。' % math.pi)
常量 PI 的值近似爲：3.142。
................................................................................
由於 str.format() 比較新的函數， 大多數的 Python 代碼仍然使用 % 操做符。可是由於這種舊式的格式化最終會從該語言中移除, 應該更多的使用 str.format().
讀取鍵盤輸入
Python提供了 input() 置函數從標準輸入讀入一行文本，默認的標準輸入是鍵盤。
input 能夠接收一個Python表達式做爲輸入，並將運算結果返回。
#!/usr/bin/python3
str = input("請輸入：");
print ("你輸入的內容是: ", str)
................................................................................
這會產生以下的對應着輸入的結果：
請輸入：php中文網 你輸入的內容是: php中文網
................................................................................
讀和寫文件
open() 將會返回一個 file 對象，基本語法格式以下:
open(filename, mode)
................................................................................
filename：filename 變量是一個包含了你要訪問的文件名稱的字符串值。
mode：mode決定了打開文件的模式：只讀，寫入，追加等。全部可取值見以下的徹底列表。這個參數是非強制的，默認文件訪問模式爲只讀(r)。
不一樣模式打開文件的徹底列表：
| 模式 | 描述 |
|---|---|
| r | 以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。 |
| rb | 以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。 |
| r+ | 打開一個文件用於讀寫。文件指針將會放在文件的開頭。 |
| rb+ | 以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。 |
| w | 打開一個文件只用於寫入。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。 |
| wb | 以二進制格式打開一個文件只用於寫入。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。 |
| w+ | 打開一個文件用於讀寫。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。 |
| wb+ | 以二進制格式打開一個文件用於讀寫。若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。 |
| a | 打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。 |
| ab | 以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。 |
| a+ | 打開一個文件用於讀寫。若是該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。若是該文件不存在，建立新文件用於讀寫。 |
| ab+ | 以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。若是該文件不存在，建立新文件用於讀寫。 |
................................................................................
如下實例將字符串寫入到文件 foo.txt 中：
#!/usr/bin/python3
# 打開一個文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一個很是好的語言。\n是的，的確很是好!!\n" )
# 關閉打開的文件
f.close()
................................................................................
第一個參數爲要打開的文件名。
第二個參數描述文件如何使用的字符。 mode 能夠是 'r' 若是文件只讀, 'w' 只用於寫 (若是存在同名文件則將被刪除), 和 'a' 用於追加文件內容; 所寫的任何數據都會被自動增長到末尾. 'r+' 同時用於讀寫。 mode 參數是可選的; 'r' 將是默認值。
此時打開文件 foo.txt,顯示以下：
$ cat /tmp/foo.txt Python 是一個很是好的語言。 是的，的確很是好!!
................................................................................
文件對象的方法
本節中剩下的例子假設已經建立了一個稱爲 f 的文件對象。
爲了讀取一個文件的內容，調用 f.read(size), 這將讀取必定數目的數據, 而後做爲字符串或字節對象返回。
size 是一個可選的數字類型的參數。 當 size 被忽略了或者爲負, 那麼該文件的全部內容都將被讀取而且返回。
如下實例假定文件 foo.txt 已存在（上面實例中已建立）：
#!/usr/bin/python3
# 打開一個文件
f = open("/tmp/foo.txt", "r")
str = f.read()
print(str)
# 關閉打開的文件
f.close()
................................................................................
執行以上程序，輸出結果爲：
Python 是一個很是好的語言。 是的，的確很是好!!
................................................................................
f.readline() 會從文件中讀取單獨的一行。換行符爲 '\n'。f.readline() 若是返回一個空字符串, 說明已經已經讀取到最後一行。
#!/usr/bin/python3
# 打開一個文件
f = open("/tmp/foo.txt", "r")
str = f.readline()
print(str)
# 關閉打開的文件
f.close()
................................................................................
執行以上程序，輸出結果爲：
Python 是一個很是好的語言。
................................................................................
f.readlines() 將返回該文件中包含的全部行。
若是設置可選參數 sizehint, 則讀取指定長度的字節, 而且將這些字節按行分割。
#!/usr/bin/python3
# 打開一個文件
f = open("/tmp/foo.txt", "r")
str = f.readlines()
print(str)
# 關閉打開的文件
f.close()
................................................................................
執行以上程序，輸出結果爲：
['Python 是一個很是好的語言。\n', '是的，的確很是好!!\n']
................................................................................
另外一種方式是迭代一個文件對象而後讀取每行:
#!/usr/bin/python3
# 打開一個文件
f = open("/tmp/foo.txt", "r")
for line in f:
print(line, end='')
# 關閉打開的文件
f.close()
................................................................................
執行以上程序，輸出結果爲：
Python 是一個很是好的語言。 是的，的確很是好!!
................................................................................
這個方法很簡單, 可是並無提供一個很好的控制。 由於二者的處理機制不一樣, 最好不要混用。
f.write(string) 將 string 寫入到文件中, 而後返回寫入的字符數。
#!/usr/bin/python3
# 打開一個文件
f = open("/tmp/foo.txt", "w")
num = f.write( "Python 是一個很是好的語言。\n是的，的確很是好!!\n" )
print(num)
# 關閉打開的文件
f.close()
................................................................................
執行以上程序，輸出結果爲：
29
................................................................................
若是要寫入一些不是字符串的東西, 那麼將須要先進行轉換:
#!/usr/bin/python3
# 打開一個文件
f = open("/tmp/foo1.txt", "w")
value = ('www.php.cn', 14)
s = str(value)
f.write(s)
# 關閉打開的文件
f.close()
................................................................................
執行以上程序，打開 foo1.txt 文件：
$ cat /tmp/foo1.txt
('www.php.cn', 14)
................................................................................
f.tell() 返回文件對象當前所處的位置, 它是從文件開頭開始算起的字節數。
若是要改變文件當前的位置, 能夠使用 f.seek(offset, from_what) 函數。
from_what 的值, 若是是 0 表示開頭, 若是是 1 表示當前位置, 2 表示文件的結尾，例如：
seek(x,0) ： 從起始位置即文件首行首字符開始移動 x 個字符
seek(x,1) ： 表示從當前位置日後移動x個字符
seek(-x,2)：表示從文件的結尾往前移動x個字符
from_what 值爲默認爲0，即文件開頭。下面給出一個完整的例子：
>>> f = open('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5) # 移動到文件的第六個字節
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移動到文件的倒數第三字節
13
>>> f.read(1)
b'd'
................................................................................
當你處理完一個文件後, 調用 f.close() 來關閉文件並釋放系統的資源，若是嘗試再調用該文件，則會拋出異常。
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file
<pre>
<p>
當處理一個文件對象時, 使用 with 關鍵字是很是好的方式。在結束後, 它會幫你正確的關閉文件。 並且寫起來也比 try - finally 語句塊要簡短:</p>
<pre>
>>> with open('/tmp/foo.txt', 'r') as f:
... read_data = f.read()
>>> f.closed
True
................................................................................
文件對象還有其餘方法, 如 isatty() 和 trucate(), 但這些一般比較少用。
pickle 模塊
python的pickle模塊實現了基本的數據序列和反序列化。
經過pickle模塊的序列化操做咱們可以將程序中運行的對象信息保存到文件中去，永久存儲。
經過pickle模塊的反序列化操做，咱們可以從文件中建立上一次程序保存的對象。
基本接口：
pickle.dump(obj, file, [,protocol])
................................................................................
有了 pickle 這個對象, 就能對 file 以讀取的形式打開:
x = pickle.load(file)
................................................................................
註解：從 file 中讀取一個字符串，並將它重構爲原來的python對象。
file: 類文件對象，有read()和readline()接口。
實例1：
#!/usr/bin/python3
import pickle
# 使用pickle模塊將數據對象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
'b': ('string', u'Unicode string'),
'c': None}
selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)
output = open('data.pkl', 'wb')
# Pickle dictionary using protocol 0.
pickle.dump(data1, output)
# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)
output.close()
................................................................................
實例2：
#!/usr/bin/python3
import pprint, pickle
#使用pickle模塊從文件中重構python對象
pkl_file = open('data.pkl', 'rb')
data1 = pickle.load(pkl_file)
pprint.pprint(data1)
data2 = pickle.load(pkl_file)
pprint.pprint(data2)
pkl_file.close()
................................................................................
休息一下子……
今天內容：python3-interpreter.html
********************************************************
Linux/Unix的系統上，通常默認的 python 版本爲 2.x，咱們能夠將 python3.x 安裝在 /usr/local/python3 目錄中。
安裝完成後，咱們能夠將路徑 /usr/local/python3/bin 添加到您的 Linux/Unix 操做系統的環境變量中，這樣您就能夠經過 shell 終端輸入下面的命令來啓動 Python3 。
$ PATH=$PATH:/usr/local/python3/bin/python3 # 設置環境變量 $ python3 --version Python 3.4.0
................................................................................
在Window系統下你能夠經過如下命令來設置Python的環境變量，假設你的Python安裝在 C:\Python34 下:
set path=%path%;C:\python34
................................................................................
交互式編程
咱們能夠在命令提示符中輸入"Python"命令來啓動Python解釋器：
$ python3
................................................................................
執行以上命令後，出現以下窗口信息：
$ python3 Python 3.4.0 (default, Apr 11 2014, 13:05:11) [GCC 4.8.2] on linux Type "help", "copyright", "credits" or "license" for more information. >>>
................................................................................
在 python 提示符中輸入如下語句，而後按回車鍵查看運行效果：
print ("Hello, Python!");
................................................................................
以上命令執行結果以下：
Hello, Python!
................................................................................
當鍵入一個多行結構時，續行是必須的。咱們能夠看下以下 if 語句：
>>> flag = True
>>> if flag :
... print("flag 條件爲 True!")
...
flag 條件爲 True!
................................................................................
腳本式編程
將以下代碼拷貝至 hello.py文件中：
print ("Hello, Python!");
................................................................................
經過如下命令執行該腳本：
python3 hello.py
................................................................................
輸出結果爲：
Hello, Python!
................................................................................
在Linux/Unix系統中，你能夠在腳本頂部添加如下命令讓Python腳本能夠像SHELL腳本同樣可直接執行：
#! /usr/bin/env python3
................................................................................
而後修改腳本權限，使其有執行權限，命令以下：
$ chmod +x hello.py
................................................................................
執行如下命令：
./hello.py
................................................................................
輸出結果爲：
Hello, Python!
................................................................................
休息一下子……
今天內容：python3-iterator-generator.html
********************************************************
迭代是Python最強大的功能之一，是訪問集合元素的一種方式。。
迭代器是一個能夠記住遍歷的位置的對象。
迭代器對象從集合的第一個元素開始訪問，直到全部的元素被訪問完結束。迭代器只能往前不會後退。
迭代器有兩個基本的方法：iter() 和 next()。
字符串，列表或元組對象均可用於建立迭代器：
>>> list=[1,2,3,4] >>> it = iter(list) # 建立迭代器對象 >>> print (next(it)) # 輸出迭代器的下一個元素 1 >>> print (next(it)) 2 >>>
................................................................................
迭代器對象能夠使用常規for語句進行遍歷：
#!/usr/bin/python3 list=[1,2,3,4] it = iter(list) # 建立迭代器對象 for x in it: print (x, end=" ")
................................................................................
執行以上程序，輸出結果以下：
1 2 3 4
................................................................................
也能夠使用 next() 函數：
#!/usr/bin/python3 import sys # 引入 sys 模塊 list=[1,2,3,4] it = iter(list) # 建立迭代器對象 while True: try: print (next(it)) except StopIteration: sys.exit()
................................................................................
執行以上程序，輸出結果以下：
1 2 3 4
................................................................................
生成器
在 Python 中，使用了 yield 的函數被稱爲生成器（generator）。
跟普通函數不一樣的是，生成器是一個返回迭代器的函數，只能用於迭代操做，更簡單點理解生成器就是一個迭代器。
在調用生成器運行的過程當中，每次遇到 yield 時函數會暫停並保存當前全部的運行信息，返回yield的值。並在下一次執行 next()方法時從當前位置繼續運行。
如下實例使用 yield 實現斐波那契數列：
#!/usr/bin/python3 import sys def fibonacci(n): # 生成器函數 - 斐波那契 a, b, counter = 0, 1, 0 while True: if (counter > n): return yield a a, b = b, a + b counter += 1 f = fibonacci(10) # f 是一個迭代器，由生成器返回生成 while True: try: print (next(f), end=" ") except StopIteration: sys.exit()
................................................................................
執行以上程序，輸出結果以下：
0 1 1 2 3 5 8 13 21 34 55
................................................................................
休息一下子……
今天內容：python3-json.html
********************************************************
JSON (JavaScript Object Notation) 是一種輕量級的數據交換格式。它基於ECMAScript的一個子集。
Python3 中能夠使用 json 模塊來對 JSON 數據進行編解碼，它包含了兩個函數：
json.dumps(): 對數據進行編碼。
json.loads(): 對數據進行解碼。
在json的編解碼過程當中，python 的原始類型與json類型會相互轉換，具體的轉化對照以下：
| Python | JSON |
|---|---|
| dict | object |
| list, tuple | array |
| str | string |
| int, float, int- & float-derived Enums | number |
| True | true |
| False | false |
| None | null |
................................................................................
| JSON | Python |
|---|---|
| object | dict |
| array | list |
| string | str |
| number (int) | int |
| number (real) | float |
| true | True |
| false | False |
| null | None |
................................................................................
如下實例演示了 Python 數據結構轉換爲JSON：
#!/usr/bin/python3
import json
# Python 字典類型轉換爲 JSON 對象
data = {
'no' : 1,
'name' : 'php',
'url' : 'http://www.php.cn'
}
json_str = json.dumps(data)
print ("Python 原始數據：", repr(data))
print ("JSON 對象：", json_str)
................................................................................
執行以上代碼輸出結果爲：
Python 原始數據： {'url': 'http://www.php.cn', 'no': 1, 'name': 'php'}
JSON 對象： {"url": "http://www.php.cn", "no": 1, "name": "php"}
................................................................................
經過輸出的結果能夠看出，簡單類型經過編碼後跟其原始的repr()輸出結果很是類似。
接着以上實例，咱們能夠將一個JSON編碼的字符串轉換回一個Python數據結構：
#!/usr/bin/python3
import json
# Python 字典類型轉換爲 JSON 對象
data1 = {
'no' : 1,
'name' : 'php',
'url' : 'http://www.php.cn'
}
json_str = json.dumps(data1)
print ("Python 原始數據：", repr(data1))
print ("JSON 對象：", json_str)
# 將 JSON 對象轉換爲 Python 字典
data2 = json.loads(json_str)
print ("data2['name']: ", data2['name'])
print ("data2['url']: ", data2['url'])
................................................................................
執行以上代碼輸出結果爲：
ython 原始數據： {'name': 'php', 'no': 1, 'url': 'http://www.php.cn'}
JSON 對象： {"name": "php", "no": 1, "url": "http://www.php.cn"}
data2['name']: php
data2['url']: http://www.php.cn
................................................................................
若是你要處理的是文件而不是字符串，你能夠使用 json.dump() 和 json.load() 來編碼和解碼JSON數據。例如：
# 寫入 JSON 數據
with open('data.json', 'w') as f:
json.dump(data, f)
# 讀取數據
with open('data.json', 'r') as f:
data = json.load(f)
................................................................................
更多資料請參考：https://docs.python.org/3/library/json.html
休息一下子……
今天內容：python3-list.html
********************************************************
序列是Python中最基本的數據結構。序列中的每一個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
Python有6個序列的內置類型，但最多見的是列表和元組。
序列均可以進行的操做包括索引，切片，加，乘，檢查成員。
此外，Python已經內置肯定序列的長度以及肯定最大和最小的元素的方法。
列表是最經常使用的Python數據類型，它能夠做爲一個方括號內的逗號分隔值出現。
列表的數據項不須要具備相同的類型
建立一個列表，只要把逗號分隔的不一樣的數據項使用方括號括起來便可。以下所示：
list1 = ['Google', 'php', 1997, 2000]; list2 = [1, 2, 3, 4, 5 ]; list3 = ["a", "b", "c", "d"];
................................................................................
與字符串的索引同樣，列表索引從0開始。列表能夠進行截取、組合等。
訪問列表中的值
使用下標索引來訪問列表中的值，一樣你也能夠使用方括號的形式截取字符，以下所示：
#!/usr/bin/python3
list1 = ['Google', 'php', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])
................................................................................
以上實例輸出結果：
list1[0]: Google list2[1:5]: [2, 3, 4, 5]
................................................................................
更新列表
#!/usr/bin/python3
list = ['Google', 'php', 1997, 2000]
print ("第三個元素爲 : ", list[2])
list[2] = 2001
print ("更新後的第三個元素爲 : ", list[2])
................................................................................
注意：咱們會在接下來的章節討論append()方法的使用
以上實例輸出結果：
第三個元素爲 : 1997 更新後的第三個元素爲 : 2001
................................................................................
刪除列表元素
能夠使用 del 語句來刪除列表的的元素，以下實例：
#!/usr/bin/python3
list = ['Google', 'php', 1997, 2000]
print (list)
del list[2]
print ("刪除第三個元素 : ", list)
................................................................................
以上實例輸出結果：
刪除第三個元素 : ['Google', 'php', 2000]
................................................................................
注意：咱們會在接下來的章節討論remove()方法的使用
Python列表腳本操做符
列表對 + 和 * 的操做符與字符串類似。+ 號用於組合列表，* 號用於重複列表。
以下所示：
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 長度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 組合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重複 |
| 3 in [1, 2, 3] | True | 元素是否存在於列表中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |
................................................................................
Python列表截取與拼接
Python的列表截取與字符串操做類型，以下所示：
L=['Google', 'php', 'Taobao']
................................................................................
操做：
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| L[2] | 'Taobao' | 讀取第三個元素 |
| L[-2] | 'php' | 從右側開始讀取倒數第二個元素: count from the right |
| L[1:] | ['php', 'Taobao'] | 輸出從第二個元素開始後的全部元素 |
................................................................................
>>> L=['Google', 'php', 'Taobao'] >>> L[2] 'Taobao' >>> L[-2] 'php' >>> L[1:] ['php', 'Taobao'] >>>
................................................................................
列表還支持拼接操做：
>>> squares = [1, 4, 9, 16, 25] >>> squares + [36, 49, 64, 81, 100] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
................................................................................
嵌套列表
使用嵌套列表即在列表裏建立其它列表，例如：
>>> a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'
................................................................................
Python列表函數&方法
Python包含如下函數:
| 序號 | 函數 |
|---|---|
| 1 | len(list) 列表元素個數 |
| 2 | max(list) 返回列表元素最大值 |
| 3 | min(list) 返回列表元素最小值 |
| 4 | list(seq) 將元組轉換爲列表 |
................................................................................
Python包含如下方法:
| 序號 | 方法 |
|---|---|
| 1 | list.append(obj) 在列表末尾添加新的對象 |
| 2 | list.count(obj) 統計某個元素在列表中出現的次數 |
| 3 | list.extend(seq) 在列表末尾一次性追加另外一個序列中的多個值（用新列表擴展原來的列表） |
| 4 | list.index(obj) 從列表中找出某個值第一個匹配項的索引位置 |
| 5 | list.insert(index, obj) 將對象插入列表 |
| 6 | list.pop(obj=list[-1]) 移除列表中的一個元素（默認最後一個元素），而且返回該元素的值 |
| 7 | list.remove(obj) 移除列表中某個值的第一個匹配項 |
| 8 | list.reverse() 反向列表中元素 |
| 9 | list.sort([func]) 對原列表進行排序 |
| 10 | list.clear() 清空列表 |
| 11 | list.copy() 複製列表 |
................................................................................
休息一下子……
今天內容：python3-loop.html
********************************************************
本章節將爲你們介紹Python循環語句的使用。
Python中的循環語句有 for 和 while。
Python循環語句的控制結構圖以下所示：
while 循環
Python中while語句的通常形式：
while 判斷條件： 語句
................................................................................
一樣須要注意冒號和縮進。另外，在Python中沒有do..while循環。
如下實例使用了 while 來計算 1 到 100 的總和：
#!/usr/bin/env python3
n = 100
sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1
print("1 到 %d 之和爲: %d" % (n,sum))
................................................................................
執行結果以下：
1 到 100 之和爲: 5050
................................................................................
咱們能夠經過設置條件表達式永遠不爲 false 來實現無限循環，實例以下：
#!/usr/bin/python3
var = 1
while var == 1 : # 表達式永遠爲 true
num = int(input("輸入一個數字 :"))
print ("你輸入的數字是: ", num)
print ("Good bye!")
................................................................................
執行以上腳本，輸出結果以下：
輸入一個數字 :5 你輸入的數字是: 5 輸入一個數字 :
................................................................................
你能夠使用 CTRL+C 來退出當前的無限循環。
無限循環在服務器上客戶端的實時請求很是有用。
在 while … else 在條件語句爲 false 時執行 else 的語句塊：
#!/usr/bin/python3 count = 0 while count < 5: print (count, " 小於 5") count = count + 1 else: print (count, " 大於或等於 5")
................................................................................
執行以上腳本，輸出結果以下：
0 小於 5 1 小於 5 2 小於 5 3 小於 5 4 小於 5 5 大於或等於 5
................................................................................
相似if語句的語法，若是你的while循環體中只有一條語句，你能夠將該語句與while寫在同一行中， 以下所示：
#!/usr/bin/python
flag = 1
while (flag): print ('歡迎訪問php中文網!')
print ("Good bye!")
................................................................................
注意：以上的無限循環你能夠使用 CTRL+C 來中斷循環。
執行以上腳本，輸出結果以下：
................................................................................
for 語句
Python for循環能夠遍歷任何序列的項目，如一個列表或者一個字符串。
for循環的通常格式以下：
for <variable> in <sequence>: <statements> else: <statements>
................................................................................
Python loop循環實例：
>>> languages = ["C", "C++", "Perl", "Python"] >>> for x in languages: ... print (x) ... C C++ Perl Python >>>
................................................................................
如下 for 實例中使用了 break 語句，break 語句用於跳出當前循環體：
#!/usr/bin/python3
sites = ["Baidu", "Google","php","Taobao"]
for site in sites:
if site == "php":
print("php中文網!")
break
print("循環數據 " + site)
else:
print("沒有循環數據!")
print("完成循環!")
................................................................................
執行腳本後，在循環到 "php"時會跳出循環體：
循環數據 Baidu 循環數據 Google php中文網! 完成循環!
................................................................................
range()函數
若是你須要遍歷數字序列，能夠使用內置range()函數。它會生成數列，例如:
>>> for i in range(5): ... print(i) ... 0 1 2 3 4
................................................................................
你也能夠使用range指定區間的值：
>>> for i in range(5,9) : print(i) 5 6 7 8 >>>
................................................................................
也能夠使range以指定數字開始並指定不一樣的增量(甚至能夠是負數，有時這也叫作'步長'):
>>> for i in range(0, 10, 3) : print(i) 0 3 6 9 >>>
................................................................................
負數：
>>> for i in range(-10, -100, -30) : print(i) -10 -40 -70 >>>
................................................................................
您能夠結合range()和len()函數以遍歷一個序列的索引,以下所示:
>>> a = ['Google', 'Baidu', 'php', 'Taobao', 'QQ'] >>> for i in range(len(a)): ... print(i, a[i]) ... 0 Google 1 Baidu 2 php 3 Taobao 4 QQ >>>
................................................................................
還能夠使用range()函數來建立一個列表：
>>> list(range(5)) [0, 1, 2, 3, 4] >>>
................................................................................
break和continue語句及循環中的else子句
break 語句能夠跳出 for 和 while 的循環體。若是你從 for 或 while 循環中終止，任何對應的循環 else 塊將不執行。 實例以下：
#!/usr/bin/python3
for letter in 'php': # 第一個實例
if letter == 'b':
break
print ('當前字母爲 :', letter)
var = 10 # 第二個實例
while var > 0:
print ('當期變量值爲 :', var)
var = var -1
if var == 5:
break
print ("Good bye!")
................................................................................
執行以上腳本輸出結果爲：
當前字母爲 : R 當前字母爲 : u 當前字母爲 : n 當前字母爲 : o 當前字母爲 : o 當期變量值爲 : 10 當期變量值爲 : 9 當期變量值爲 : 8 當期變量值爲 : 7 當期變量值爲 : 6 Good bye!
................................................................................
continue語句被用來告訴Python跳過當前循環塊中的剩餘語句，而後繼續進行下一輪循環。
#!/usr/bin/python3
for letter in 'php': # 第一個實例
if letter == 'o': # 字母爲 o 時跳過輸出
continue
print ('當前字母 :', letter)
var = 10 # 第二個實例
while var > 0:
var = var -1
if var == 5: # 變量爲 5 時跳過輸出
continue
print ('當前變量值 :', var)
print ("Good bye!")
................................................................................
執行以上腳本輸出結果爲：
當前字母 : R 當前字母 : u 當前字母 : n 當前字母 : b 當前變量值 : 9 當前變量值 : 8 當前變量值 : 7 當前變量值 : 6 當前變量值 : 4 當前變量值 : 3 當前變量值 : 2 當前變量值 : 1 當前變量值 : 0 Good bye!
................................................................................
循環語句能夠有 else 子句，它在窮盡列表(以for循環)或條件變爲 false (以while循環)致使循環終止時被執行,但循環被break終止時不執行。
以下實例用於查詢質數的循環例子:
#!/usr/bin/python3 for n in range(2, 10): for x in range(2, n): if n % x == 0: print(n, '等於', x, '*', n//x) break else: # 循環中沒有找到元素 print(n, ' 是質數')
................................................................................
執行以上腳本輸出結果爲：
2 是質數 3 是質數 4 等於 2 * 2 5 是質數 6 等於 2 * 3 7 是質數 8 等於 2 * 4 9 等於 3 * 3
................................................................................
pass 語句
Python pass是空語句，是爲了保持程序結構的完整性。
pass 不作任何事情，通常用作佔位語句，以下實例
>>> while True: ... pass # 等待鍵盤中斷 (Ctrl+C)
................................................................................
最小的類:
>>> class MyEmptyClass: ... pass
................................................................................
如下實例在字母爲 o 時 執行 pass 語句塊:
#!/usr/bin/python3
for letter in 'php':
if letter == 'o':
pass
print ('執行 pass 塊')
print ('當前字母 :', letter)
print ("Good bye!")
................................................................................
執行以上腳本輸出結果爲：
當前字母 : R 當前字母 : u 當前字母 : n 執行 pass 塊 當前字母 : o 執行 pass 塊 當前字母 : o 當前字母 : b Good bye!
................................................................................
休息一下子……
今天內容：python3-module.html
********************************************************
在前面的幾個章節中咱們腳本上是用 python 解釋器來編程，若是你從 Python 解釋器退出再進入，那麼你定義的全部的方法和變量就都消失了。
爲此 Python 提供了一個辦法，把這些定義存放在文件中，爲一些腳本或者交互式的解釋器實例使用，這個文件被稱爲模塊。
模塊是一個包含全部你定義的函數和變量的文件，其後綴名是.py。模塊能夠被別的程序引入，以使用該模塊中的函數等功能。這也是使用 python 標準庫的方法。
下面是一個使用 python 標準庫中模塊的例子。
#!/usr/bin/python3
# 文件名: using_sys.py
import sys
print('命令行參數以下:')
for i in sys.argv:
print(i)
print('\n\nPython 路徑爲：', sys.path, '\n')
................................................................................
執行結果以下所示：
$ python using_sys.py 參數1 參數2 命令行參數以下: using_sys.py 參數1 參數2 Python 路徑爲： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
................................................................................
一、import sys 引入 python 標準庫中的 sys.py 模塊；這是引入某一模塊的方法。
二、sys.argv 是一個包含命令行參數的列表。
三、sys.path 包含了一個 Python 解釋器自動查找所需模塊的路徑的列表。
import 語句
想使用 Python 源文件，只需在另外一個源文件裏執行 import 語句，語法以下：
import module1[, module2[,... moduleN]
................................................................................
當解釋器遇到 import 語句，若是模塊在當前的搜索路徑就會被導入。
搜索路徑是一個解釋器會先進行搜索的全部目錄的列表。如想要導入模塊 support，須要把命令放在腳本的頂端：
support.py 文件代碼爲：
#!/usr/bin/python3
# Filename: support.py
def print_func( par ):
print ("Hello : ", par)
return
................................................................................
test.py 引入 support 模塊：
#!/usr/bin/python3
# Filename: test.py
# 導入模塊
import support
# 如今能夠調用模塊裏包含的函數了
support.print_func("php")
................................................................................
以上實例輸出結果：
$ python3 test.py Hello : php
................................................................................
一個模塊只會被導入一次，無論你執行了多少次import。這樣能夠防止導入模塊被一遍又一遍地執行。
當咱們使用import語句的時候，Python解釋器是怎樣找到對應的文件的呢？
這就涉及到Python的搜索路徑，搜索路徑是由一系列目錄名組成的，Python解釋器就依次從這些目錄中去尋找所引入的模塊。
這看起來很像環境變量，事實上，也能夠經過定義環境變量的方式來肯定搜索路徑。
搜索路徑是在Python編譯或安裝的時候肯定的，安裝新的庫應該也會修改。搜索路徑被存儲在sys模塊中的path變量，作一個簡單的實驗，在交互式解釋器中，輸入如下代碼：
>>> import sys >>> sys.path ['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages'] >>>
................................................................................
sys.path 輸出是一個列表，其中第一項是空串''，表明當前目錄（如果從一個腳本中打印出來的話，能夠更清楚地看出是哪一個目錄），亦即咱們執行python解釋器的目錄（對於腳本的話就是運行的腳本所在的目錄）。
所以若像我同樣在當前目錄下存在與要引入模塊同名的文件，就會把要引入的模塊屏蔽掉。
瞭解了搜索路徑的概念，就能夠在腳本中修改sys.path來引入一些不在搜索路徑中的模塊。
如今，在解釋器的當前目錄或者 sys.path 中的一個目錄裏面來建立一個fibo.py的文件，代碼以下：
# 斐波那契(fibonacci)數列模塊 def fib(n): # 定義到 n 的斐波那契數列 a, b = 0, 1 while b < n: print(b, end=' ') a, b = b, a+b print() def fib2(n): # 返回到 n 的斐波那契數列 result = [] a, b = 0, 1 while b < n: result.append(b) a, b = b, a+b return result
................................................................................
而後進入Python解釋器，使用下面的命令導入這個模塊：
>>> import fibo
................................................................................
這樣作並無把直接定義在fibo中的函數名稱寫入到當前符號表裏，只是把模塊fibo的名字寫到了那裏。
能夠使用模塊名稱來訪問函數：
>>> fibo.fib(1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo'
................................................................................
若是你打算常用一個函數，你能夠把它賦給一個本地的名稱：
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
................................................................................
from…import 語句
Python的from語句讓你從模塊中導入一個指定的部分到當前命名空間中，語法以下：
from modname import name1[, name2[, ... nameN]]
................................................................................
例如，要導入模塊 fibo 的 fib 函數，使用以下語句：
from fibo import fib
................................................................................
這個聲明不會把整個fib模塊導入到當前的命名空間中，它只會將fib裏的fibonacci單個引入到執行這個聲明的模塊的全局符號表。
From…import* 語句
把一個模塊的全部內容全都導入到當前的命名空間也是可行的，只需使用以下聲明：
from modname import *
................................................................................
這提供了一個簡單的方法來導入一個模塊中的全部項目。然而這種聲明不應被過多地使用。
深刻模塊
模塊除了方法定義，還能夠包括可執行的代碼。這些代碼通常用來初始化這個模塊。這些代碼只有在第一次被導入時纔會被執行。
每一個模塊有各自獨立的符號表，在模塊內部爲全部的函數看成全局符號表來使用。
因此，模塊的做者能夠放心大膽的在模塊內部使用這些全局變量，而不用擔憂把其餘用戶的全局變量搞花。
從另外一個方面，當你確實知道你在作什麼的話，你也能夠經過 modname.itemname 這樣的表示法來訪問模塊內的函數。
模塊是能夠導入其餘模塊的。在一個模塊（或者腳本，或者其餘地方）的最前面使用 import 來導入一個模塊，固然這只是一個慣例，而不是強制的。被導入的模塊的名稱將被放入當前操做的模塊的符號表中。
還有一種導入的方法，能夠使用 import 直接把模塊內（函數，變量的）名稱導入到當前操做模塊。好比:
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
................................................................................
這種導入的方法不會把被導入的模塊的名稱放在當前的字符表中（因此在這個例子裏面，fibo 這個名稱是沒有定義的）。
這還有一種方法，能夠一次性的把模塊中的全部（函數，變量）名稱都導入到當前模塊的字符表:
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
................................................................................
這將把全部的名字都導入進來，可是那些由單一下劃線（_）開頭的名字不在此例。大多數狀況， Python程序員不使用這種方法，由於引入的其它來源的命名，極可能覆蓋了已有的定義。
__name__屬性
一個模塊被另外一個程序第一次引入時，其主程序將運行。若是咱們想在模塊被引入時，模塊中的某一程序塊不執行，咱們能夠用__name__屬性來使該程序塊僅在該模塊自身運行時執行。
#!/usr/bin/python3
# Filename: using_name.py
if __name__ == '__main__':
print('程序自身在運行')
else:
print('我來自另外一模塊')
................................................................................
運行輸出以下：
$ python using_name.py
................................................................................
程序自身在運行
$ python >>> import using_name 我來自另外一模塊 >>>
................................................................................
說明：每一個模塊都有一個__name__屬性，當其值是'__main__'時，代表該模塊自身在運行，不然是被引入。
dir() 函數
內置的函數 dir() 能夠找到模塊內定義的全部名稱。以一個字符串列表的形式返回: </p> <pre> >>> import fibo, sys >>> dir(fibo) ['__name__', 'fib', 'fib2'] >>> dir(sys) ['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__', '__package__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe', '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount', 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions']
................................................................................
若是沒有給定參數，那麼 dir() 函數會羅列出當前定義的全部名稱:
>>> a = [1, 2, 3, 4, 5] >>> import fibo >>> fib = fibo.fib >>> dir() # 獲得一個當前模塊中定義的屬性列表 ['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys'] >>> a = 5 # 創建一個新的變量 'a' >>> dir() ['__builtins__', '__doc__', '__name__', 'a', 'sys'] >>> >>> del a # 刪除變量名a >>> >>> dir() ['__builtins__', '__doc__', '__name__', 'sys'] >>>
................................................................................
標準模塊
Python 自己帶着一些標準的模塊庫，在 Python 庫參考文檔中將會介紹到（就是後面的"庫參考文檔"）。
有些模塊直接被構建在解析器裏，這些雖然不是一些語言內置的功能，可是他卻能很高效的使用，甚至是系統級調用也沒問題。
這些組件會根據不一樣的操做系統進行不一樣形式的配置，好比 winreg 這個模塊就只會提供給 Windows 系統。
應該注意到這有一個特別的模塊 sys ，它內置在每個 Python 解析器中。變量 sys.ps1 和 sys.ps2 定義了主提示符和副提示符所對應的字符串:
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>
................................................................................
包
包是一種管理 Python 模塊命名空間的形式，採用"點模塊名稱"。
好比一個模塊的名稱是 A.B， 那麼他表示一個包 A中的子模塊 B 。
就好像使用模塊的時候，你不用擔憂不一樣模塊之間的全局變量相互影響同樣，採用點模塊名稱這種形式也不用擔憂不一樣庫之間的模塊重名的狀況。
這樣不一樣的做者均可以提供 NumPy 模塊，或者是 Python 圖形庫。
不妨假設你想設計一套統一處理聲音文件和數據的模塊（或者稱之爲一個"包"）。
現存不少種不一樣的音頻文件格式（基本上都是經過後綴名區分的，例如： .wav，:file:.aiff，:file:.au，），因此你須要有一組不斷增長的模塊，用來在不一樣的格式之間轉換。
而且針對這些音頻數據，還有不少不一樣的操做（好比混音，添加回聲，增長均衡器功能，建立人造立體聲效果），所你還須要一組怎麼也寫不完的模塊來處理這些操做。
這裏給出了一種可能的包結構（在分層的文件系統中）:
sound/ 頂層包 __init__.py 初始化 sound 包 formats/ 文件格式轉換子包 __init__.py wavread.py wavwrite.py aiffread.py aiffwrite.py auread.py auwrite.py ... effects/ 聲音效果子包 __init__.py echo.py surround.py reverse.py ... filters/ filters 子包 __init__.py equalizer.py vocoder.py karaoke.py ...
................................................................................
在導入一個包的時候，Python 會根據 sys.path 中的目錄來尋找這個包中包含的子目錄。
目錄只有包含一個叫作 __init__.py 的文件纔會被認做是一個包，主要是爲了不一些濫俗的名字（好比叫作 string）不當心的影響搜索路徑中的有效模塊。
最簡單的狀況，放一個空的 :file:__init__.py就能夠了。固然這個文件中也能夠包含一些初始化代碼或者爲（將在後面介紹的） __all__變量賦值。
用戶能夠每次只導入一個包裏面的特定模塊，好比:
import sound.effects.echo
................................................................................
這將會導入子模塊:mod:song.effects.echo。 他必須使用全名去訪問:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
................................................................................
還有一種導入子模塊的方法是:
from sound.effects import echo
................................................................................
這一樣會導入子模塊:mod:echo，而且他不須要那些冗長的前綴，因此他能夠這樣使用:
echo.echofilter(input, output, delay=0.7, atten=4)
................................................................................
還有一種變化就是直接導入一個函數或者變量:
from sound.effects.echo import echofilter
................................................................................
一樣的，這種方法會導入子模塊:mod:echo，而且能夠直接使用他的:func:echofilter函數:
echofilter(input, output, delay=0.7, atten=4)
注意當使用from package import item這種形式的時候，對應的item既能夠是包裏面的子模塊（子包），或者包裏面定義的其餘名稱，好比函數，類或者變量。
import語法會首先把item看成一個包定義的名稱，若是沒找到，再試圖按照一個模塊去導入。若是還沒找到，恭喜，一個:exc:ImportError 異常被拋出了。
反之，若是使用形如import item.subitem.subsubitem這種導入形式，除了最後一項，都必須是包，而最後一項則能夠是模塊或者是包，可是不能夠是類，函數或者變量的名字。
從一個包中導入*
設想一下，若是咱們使用 from sound.effects import *會發生什麼？
Python 會進入文件系統，找到這個包裏面全部的子模塊，一個一個的把它們都導入進來。
可是很不幸，這個方法在 Windows平臺上工做的就不是很是好，由於Windows是一個大小寫不區分的系統。
在這類平臺上，沒有人敢擔保一個叫作 ECHO.py 的文件導入爲模塊:mod:echo仍是:mod:Echo甚至:mod:ECHO。
（例如，Windows 95就很討厭的把每個文件的首字母大寫顯示）並且 DOS 的 8+3 命名規則對長模塊名稱的處理會把問題搞得更糾結。
爲了解決這個問題，只能煩勞包做者提供一個精確的包的索引了。
導入語句遵循以下規則：若是包定義文件 __init__.py 存在一個叫作 __all__ 的列表變量，那麼在使用 from package import * 的時候就把這個列表中的全部名字做爲包內容導入。
做爲包的做者，可別忘了在更新包以後保證 __all__ 也更新了啊。你說我就不這麼作，我就不使用導入*這種用法，好吧，沒問題，誰讓你是老闆呢。這裏有一個例子，在:file:sounds/effects/__init__.py中包含以下代碼:
__all__ = ["echo", "surround", "reverse"]
................................................................................
這表示當你使用from sound.effects import *這種用法時，你只會導入包裏面這三個子模塊。
若是__all__真的而沒有定義，那麼使用from sound.effects import *這種語法的時候，就*不會*導入包:mod:sound.effects裏的任何子模塊。他只是把包:mod:sound.effects和它裏面定義的全部內容導入進來（可能運行:file:__init__.py裏定義的初始化代碼）。
這會把 :file:__init__.py裏面定義的全部名字導入進來。而且他不會破壞掉咱們在這句話以前導入的全部明確指定的模塊。看下這部分代碼:
import sound.effects.echo import sound.effects.surround from sound.effects import *
................................................................................
這個例子中，在執行from...import前，包:mod:sound.effects中的echo和surround模塊都被導入到當前的命名空間中了。（固然若是定義了__all__就更沒問題了）
一般咱們並不主張使用*這種方法來導入模塊，由於這種方法常常會致使代碼的可讀性下降。不過這樣倒的確是能夠省去很多敲鍵的功夫，並且一些模塊都設計成了只能經過特定的方法導入。
記住，使用from Package import specific_submodule這種方法永遠不會有錯。事實上，這也是推薦的方法。除非是你要導入的子模塊有可能和其餘包的子模塊重名。
若是在結構中包是一個子包（好比這個例子中對於包:mod:sound來講），而你又想導入兄弟包（同級別的包）你就得使用導入絕對的路徑來導入。好比，若是模塊:mod:sound.filters.vocoder 要使用包:mod:sound.effects中的模塊:mod:echo，你就要寫成 from sound.effects import echo。
from . import echo from .. import formats from ..filters import equalizer
................................................................................
不管是隱式的仍是顯式的相對導入都是從當前模塊開始的。主模塊的名字永遠是"__main__"，一個Python應用程序的主模塊，應當老是使用絕對路徑引用。
包還提供一個額外的屬性，:attr:__path__。這是一個目錄列表，裏面每個包含的目錄都有爲這個包服務的:file:__init__.py，你得在其餘:file:__init__.py被執行前定義哦。能夠修改這個變量，用來影響包含在包裏面的模塊和子包。
這個功能並不經常使用，通常用來擴展包裏面的模塊。
休息一下子……
今天內容：python3-multithreading.html
********************************************************
多線程相似於同時執行多個不一樣程序，多線程運行有以下優勢：
使用線程能夠把佔據長時間的程序中的任務放到後臺去處理。
用戶界面能夠更加吸引人，這樣好比用戶點擊了一個按鈕去觸發某些事件的處理，能夠彈出一個進度條來顯示處理的進度
程序的運行速度可能加快
在一些等待的任務實現上如用戶輸入、文件讀寫和網絡收發數據等，線程就比較有用了。在這種狀況下咱們能夠釋放一些珍貴的資源如內存佔用等等。
線程在執行過程當中與進程仍是有區別的。每一個獨立的線程有一個程序運行的入口、順序執行序列和程序的出口。可是線程不可以獨立執行，必須依存在應用程序中，由應用程序提供多個線程執行控制。
每一個線程都有他本身的一組CPU寄存器，稱爲線程的上下文，該上下文反映了線程上次運行該線程的CPU寄存器的狀態。
指令指針和堆棧指針寄存器是線程上下文中兩個最重要的寄存器，線程老是在進程獲得上下文中運行的，這些地址都用於標誌擁有線程的進程地址空間中的內存。
線程能夠被搶佔（中斷）。
在其餘線程正在運行時，線程能夠暫時擱置（也稱爲睡眠） -- 這就是線程的退讓。
線程能夠分爲:
內核線程：由操做系統內核建立和撤銷。
用戶線程：不須要內核支持而在用戶程序中實現的線程。
Python3 線程中經常使用的兩個模塊爲：
_thread
threading(推薦使用)
thread 模塊已被廢棄。用戶能夠使用 threading 模塊代替。因此，在 Python3 中不能再使用"thread" 模塊。爲了兼容性，Python3 將 thread 重命名爲 "_thread"。
開始學習Python線程
Python中使用線程有兩種方式：函數或者用類來包裝線程對象。
函數式：調用 _thread 模塊中的start_new_thread()函數來產生新線程。語法以下:
_thread.start_new_thread ( function, args[, kwargs] )
................................................................................
參數說明:
function - 線程函數。
args - 傳遞給線程函數的參數,他必須是個tuple類型。
kwargs - 可選參數。
實例：
#!/usr/bin/python3
import _thread
import time
# 爲線程定義一個函數
def print_time( threadName, delay):
count = 0
while count < 5:
time.sleep(delay)
count += 1
print ("%s: %s" % ( threadName, time.ctime(time.time()) ))
# 建立兩個線程
try:
_thread.start_new_thread( print_time, ("Thread-1", 2, ) )
_thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
print ("Error: 沒法啓動線程")
while 1:
pass
................................................................................
執行以上程序輸出結果以下：
Thread-1: Wed Apr 6 11:36:31 2016 Thread-1: Wed Apr 6 11:36:33 2016 Thread-2: Wed Apr 6 11:36:33 2016 Thread-1: Wed Apr 6 11:36:35 2016 Thread-1: Wed Apr 6 11:36:37 2016 Thread-2: Wed Apr 6 11:36:37 2016 Thread-1: Wed Apr 6 11:36:39 2016 Thread-2: Wed Apr 6 11:36:41 2016 Thread-2: Wed Apr 6 11:36:45 2016 Thread-2: Wed Apr 6 11:36:49 2016
................................................................................
執行以上程後能夠按下 ctrl-c to 退出。
線程模塊
Python3 經過兩個標準庫 _thread 和 threading 提供對線程的支持。
_thread 提供了低級別的、原始的線程以及一個簡單的鎖，它相比於 threading 模塊的功能仍是比較有限的。
threading 模塊除了包含 _thread 模塊中的全部方法外，還提供的其餘方法：
threading.currentThread(): 返回當前的線程變量。
threading.enumerate(): 返回一個包含正在運行的線程的list。正在運行指線程啓動後、結束前，不包括啓動前和終止後的線程。
threading.activeCount(): 返回正在運行的線程數量，與len(threading.enumerate())有相同的結果。
除了使用方法外，線程模塊一樣提供了Thread類來處理線程，Thread類提供瞭如下方法:
run(): 用以表示線程活動的方法。
start():啓動線程活動。
join([time]): 等待至線程停止。這阻塞調用線程直至線程的join() 方法被調用停止-正常退出或者拋出未處理的異常-或者是可選的超時發生。
isAlive(): 返回線程是否活動的。
getName(): 返回線程名。
setName(): 設置線程名。
使用 threading 模塊建立線程
咱們能夠經過直接從 threading.Thread 繼承建立一個新的子類，並實例化後調用 start() 方法啓動新線程，即它調用了線程的 run() 方法：
#!/usr/bin/python3
import threading
import time
exitFlag = 0
class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print ("開始線程：" + self.name)
print_time(self.name, self.counter, 5)
print ("退出線程：" + self.name)
def print_time(threadName, delay, counter):
while counter:
if exitFlag:
threadName.exit()
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1
# 建立新線程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# 開啓新線程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主線程")
................................................................................
以上程序執行結果以下；
開始線程：Thread-1 開始線程：Thread-2 Thread-1: Wed Apr 6 11:46:46 2016 Thread-1: Wed Apr 6 11:46:47 2016 Thread-2: Wed Apr 6 11:46:47 2016 Thread-1: Wed Apr 6 11:46:48 2016 Thread-1: Wed Apr 6 11:46:49 2016 Thread-2: Wed Apr 6 11:46:49 2016 Thread-1: Wed Apr 6 11:46:50 2016 退出線程：Thread-1 Thread-2: Wed Apr 6 11:46:51 2016 Thread-2: Wed Apr 6 11:46:53 2016 Thread-2: Wed Apr 6 11:46:55 2016 退出線程：Thread-2 退出主線程
................................................................................
線程同步
若是多個線程共同對某個數據修改，則可能出現不可預料的結果，爲了保證數據的正確性，須要對多個線程進行同步。
使用 Thread 對象的 Lock 和 Rlock 能夠實現簡單的線程同步，這兩個對象都有 acquire 方法和 release 方法，對於那些須要每次只容許一個線程操做的數據，能夠將其操做放到 acquire 和 release 方法之間。以下：
多線程的優點在於能夠同時運行多個任務（至少感受起來是這樣）。可是當線程須要共享數據時，可能存在數據不一樣步的問題。
考慮這樣一種狀況：一個列表裏全部元素都是0，線程"set"從後向前把全部元素改爲1，而線程"print"負責從前日後讀取列表並打印。
那麼，可能線程"set"開始改的時候，線程"print"便來打印列表了，輸出就成了一半0一半1，這就是數據的不一樣步。爲了不這種狀況，引入了鎖的概念。
鎖有兩種狀態——鎖定和未鎖定。每當一個線程好比"set"要訪問共享數據時，必須先得到鎖定；若是已經有別的線程好比"print"得到鎖定了，那麼就讓線程"set"暫停，也就是同步阻塞；等到線程"print"訪問完畢，釋放鎖之後，再讓線程"set"繼續。
通過這樣的處理，打印列表時要麼所有輸出0，要麼所有輸出1，不會再出現一半0一半1的尷尬場面。
實例：
#!/usr/bin/python3
import threading
import time
class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print ("開啓線程： " + self.name)
# 獲取鎖，用於線程同步
threadLock.acquire()
print_time(self.name, self.counter, 3)
# 釋放鎖，開啓下一個線程
threadLock.release()
def print_time(threadName, delay, counter):
while counter:
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1
threadLock = threading.Lock()
threads = []
# 建立新線程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# 開啓新線程
thread1.start()
thread2.start()
# 添加線程到線程列表
threads.append(thread1)
threads.append(thread2)
# 等待全部線程完成
for t in threads:
t.join()
print ("退出主線程")
................................................................................
執行以上程序，輸出結果爲：
開啓線程： Thread-1 開啓線程： Thread-2 Thread-1: Wed Apr 6 11:52:57 2016 Thread-1: Wed Apr 6 11:52:58 2016 Thread-1: Wed Apr 6 11:52:59 2016 Thread-2: Wed Apr 6 11:53:01 2016 Thread-2: Wed Apr 6 11:53:03 2016 Thread-2: Wed Apr 6 11:53:05 2016 退出主線程
................................................................................
線程優先級隊列（ Queue）
Python 的 Queue 模塊中提供了同步的、線程安全的隊列類，包括FIFO（先入先出)隊列Queue，LIFO（後入先出）隊列LifoQueue，和優先級隊列 PriorityQueue。
這些隊列都實現了鎖原語，可以在多線程中直接使用，能夠使用隊列來實現線程間的同步。
Queue 模塊中的經常使用方法:
Queue.qsize() 返回隊列的大小
Queue.empty() 若是隊列爲空，返回True,反之False
Queue.full() 若是隊列滿了，返回True,反之False
Queue.full 與 maxsize 大小對應
Queue.get([block[, timeout]])獲取隊列，timeout等待時間
Queue.get_nowait() 至關Queue.get(False)
Queue.put(item) 寫入隊列，timeout等待時間
Queue.put_nowait(item) 至關Queue.put(item, False)
Queue.task_done() 在完成一項工做以後，Queue.task_done()函數向任務已經完成的隊列發送一個信號
Queue.join() 實際上意味着等到隊列爲空，再執行別的操做
實例:
#!/usr/bin/python3
import queue
import threading
import time
exitFlag = 0
class myThread (threading.Thread):
def __init__(self, threadID, name, q):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.q = q
def run(self):
print ("開啓線程：" + self.name)
process_data(self.name, self.q)
print ("退出線程：" + self.name)
def process_data(threadName, q):
while not exitFlag:
queueLock.acquire()
if not workQueue.empty():
data = q.get()
queueLock.release()
print ("%s processing %s" % (threadName, data))
else:
queueLock.release()
time.sleep(1)
threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1
# 建立新線程
for tName in threadList:
thread = myThread(threadID, tName, workQueue)
thread.start()
threads.append(thread)
threadID += 1
# 填充隊列
queueLock.acquire()
for word in nameList:
workQueue.put(word)
queueLock.release()
# 等待隊列清空
while not workQueue.empty():
pass
# 通知線程是時候退出
exitFlag = 1
# 等待全部線程完成
for t in threads:
t.join()
print ("退出主線程")
................................................................................
以上程序執行結果：
開啓線程：Thread-1 開啓線程：Thread-2 開啓線程：Thread-3 Thread-3 processing One Thread-1 processing Two Thread-2 processing Three Thread-3 processing Four Thread-1 processing Five 退出線程：Thread-3 退出線程：Thread-2 退出線程：Thread-1 退出主線程
................................................................................
休息一下子……
今天內容：python3-mysql.html
********************************************************
本文咱們爲你們介紹 Python3 使用 PyMySQL 鏈接數據庫，並實現簡單的增刪改查。
PyMySQL 是在 Python3.x 版本中用於鏈接 MySQL 服務器的一個庫，Python2中則使用mysqldb。
PyMySQL 遵循 Python 數據庫 API v2.0 規範，幷包含了 pure-Python MySQL 客戶端庫。
PyMySQL 安裝
在使用 PyMySQL 以前，咱們須要確保 PyMySQL 已安裝。
PyMySQL 下載地址：https://github.com/PyMySQL/PyMySQL。
若是還未安裝，咱們能夠使用如下命令安裝最新版的 PyMySQL：
$ pip install PyMySQL
................................................................................
若是你的系統不支持 pip 命令，能夠使用如下方式安裝：
一、使用 git 命令下載安裝包安裝(你也能夠手動下載)：
$ git clone https://github.com/PyMySQL/PyMySQL $ cd PyMySQL/ $ python3 setup.py install
................................................................................
二、若是須要制定版本號，能夠使用 curl 命令來安裝：
$ # X.X 爲 PyMySQL 的版本號 $ curl -L https://github.com/PyMySQL/PyMySQL/tarball/pymysql-X.X | tar xz $ cd PyMySQL* $ python3 setup.py install $ # 如今你能夠刪除 PyMySQL* 目錄
................................................................................
注意：請確保您有root權限來安裝上述模塊。
安裝的過程當中可能會出現"ImportError: No module named setuptools"的錯誤提示，意思是你沒有安裝setuptools，你能夠訪問https://pypi.python.org/pypi/setuptools 找到各個系統的安裝方法。
Linux 系統安裝實例：
$ wget https://bootstrap.pypa.io/ez_setup.py $ python3 ez_setup.py
................................................................................
數據庫鏈接
鏈接數據庫前，請先確認如下事項：
您已經建立了數據庫 TESTDB.
在TESTDB數據庫中您已經建立了表 EMPLOYEE
EMPLOYEE表字段爲 FIRST_NAME, LAST_NAME, AGE, SEX 和 INCOME。
鏈接數據庫TESTDB使用的用戶名爲 "testuser" ，密碼爲 "test123",你能夠能夠本身設定或者直接使用root用戶名及其密碼，Mysql數據庫用戶受權請使用Grant命令。
在你的機子上已經安裝了 Python MySQLdb 模塊。
若是您對sql語句不熟悉，能夠訪問咱們的 SQL基礎教程
如下實例連接Mysql的TESTDB數據庫：
#!/usr/bin/python3
import pymysql
# 打開數據庫鏈接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )
# 使用 cursor() 方法建立一個遊標對象 cursor
cursor = db.cursor()
# 使用 execute() 方法執行 SQL 查詢
cursor.execute("SELECT VERSION()")
# 使用 fetchone() 方法獲取單條數據.
data = cursor.fetchone()
print ("Database version : %s " % data)
# 關閉數據庫鏈接
db.close()
................................................................................
執行以上腳本輸出結果以下：
Database version : 5.5.20-log
................................................................................
建立數據庫表
若是數據庫鏈接存在咱們能夠使用execute()方法來爲數據庫建立表，以下所示建立表EMPLOYEE：
#!/usr/bin/python3
import pymysql
# 打開數據庫鏈接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )
# 使用 cursor() 方法建立一個遊標對象 cursor
cursor = db.cursor()
# 使用 execute() 方法執行 SQL，若是表存在則刪除
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
# 使用預處理語句建立表
sql = """CREATE TABLE EMPLOYEE (
FIRST_NAME CHAR(20) NOT NULL,
LAST_NAME CHAR(20),
AGE INT,
SEX CHAR(1),
INCOME FLOAT )"""
cursor.execute(sql)
# 關閉數據庫鏈接
db.close()
................................................................................
數據庫插入操做
如下實例使用執行 SQL INSERT 語句向表 EMPLOYEE 插入記錄：
#!/usr/bin/python3
import pymysql
# 打開數據庫鏈接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )
# 使用cursor()方法獲取操做遊標
cursor = db.cursor()
# SQL 插入語句
sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
try:
# 執行sql語句
cursor.execute(sql)
# 提交到數據庫執行
db.commit()
except:
# 若是發生錯誤則回滾
db.rollback()
# 關閉數據庫鏈接
db.close()
................................................................................
以上例子也能夠寫成以下形式：
#!/usr/bin/python3
import pymysql
# 打開數據庫鏈接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )
# 使用cursor()方法獲取操做遊標
cursor = db.cursor()
# SQL 插入語句
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
LAST_NAME, AGE, SEX, INCOME) \
VALUES ('%s', '%s', '%d', '%c', '%d' )" % \
('Mac', 'Mohan', 20, 'M', 2000)
try:
# 執行sql語句
cursor.execute(sql)
# 執行sql語句
db.commit()
except:
# 發生錯誤時回滾
db.rollback()
# 關閉數據庫鏈接
db.close()
................................................................................
如下代碼使用變量向SQL語句中傳遞參數:
..................................
user_id = "test123"
password = "password"
con.execute('insert into Login values("%s", "%s")' % \
(user_id, password))
..................................
................................................................................
數據庫查詢操做
Python查詢Mysql使用 fetchone() 方法獲取單條數據, 使用fetchall() 方法獲取多條數據。
fetchone(): 該方法獲取下一個查詢結果集。結果集是一個對象
fetchall(): 接收所有的返回結果行.
rowcount: 這是一個只讀屬性，並返回執行execute()方法後影響的行數。
查詢EMPLOYEE表中salary（工資）字段大於1000的全部數據：
#!/usr/bin/python3
import pymysql
# 打開數據庫鏈接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )
# 使用cursor()方法獲取操做遊標
cursor = db.cursor()
# SQL 查詢語句
sql = "SELECT * FROM EMPLOYEE \
WHERE INCOME > '%d'" % (1000)
try:
# 執行SQL語句
cursor.execute(sql)
# 獲取全部記錄列表
results = cursor.fetchall()
for row in results:
fname = row[0]
lname = row[1]
age = row[2]
sex = row[3]
income = row[4]
# 打印結果
print ("fname=%s,lname=%s,age=%d,sex=%s,income=%d" % \
(fname, lname, age, sex, income ))
except:
print ("Error: unable to fecth data")
# 關閉數據庫鏈接
db.close()
................................................................................
以上腳本執行結果以下：
fname=Mac, lname=Mohan, age=20, sex=M, income=2000
................................................................................
數據庫更新操做
更新操做用於更新數據表的的數據，如下實例將 TESTDB表中的 SEX 字段所有修改成 'M'，AGE 字段遞增1：
#!/usr/bin/python3
import pymysql
# 打開數據庫鏈接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )
# 使用cursor()方法獲取操做遊標
cursor = db.cursor()
# SQL 更新語句
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1
WHERE SEX = '%c'" % ('M')
try:
# 執行SQL語句
cursor.execute(sql)
# 提交到數據庫執行
db.commit()
except:
# 發生錯誤時回滾
db.rollback()
# 關閉數據庫鏈接
db.close()
................................................................................
刪除操做
刪除操做用於刪除數據表中的數據，如下實例演示了刪除數據表 EMPLOYEE 中 AGE 大於 20 的全部數據：
#!/usr/bin/python3
import pymysql
# 打開數據庫鏈接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )
# 使用cursor()方法獲取操做遊標
cursor = db.cursor()
# SQL 刪除語句
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20)
try:
# 執行SQL語句
cursor.execute(sql)
# 提交修改
db.commit()
except:
# 發生錯誤時回滾
db.rollback()
# 關閉鏈接
db.close()
................................................................................
執行事務
事務機制能夠確保數據一致性。
事務應該具備4個屬性：原子性、一致性、隔離性、持久性。這四個屬性一般稱爲ACID特性。
原子性（atomicity）。一個事務是一個不可分割的工做單位，事務中包括的諸操做要麼都作，要麼都不作。
一致性（consistency）。事務必須是使數據庫從一個一致性狀態變到另外一個一致性狀態。一致性與原子性是密切相關的。
隔離性（isolation）。一個事務的執行不能被其餘事務干擾。即一個事務內部的操做及使用的數據對併發的其餘事務是隔離的，併發執行的各個事務之間不能互相干擾。
持久性（durability）。持續性也稱永久性（permanence），指一個事務一旦提交，它對數據庫中數據的改變就應該是永久性的。接下來的其餘操做或故障不該該對其有任何影響。
Python DB API 2.0 的事務提供了兩個方法 commit 或 rollback。
# SQL刪除記錄語句 sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (20) try: # 執行SQL語句 cursor.execute(sql) # 向數據庫提交 db.commit() except: # 發生錯誤時回滾 db.rollback()
................................................................................
對於支持事務的數據庫， 在Python數據庫編程中，當遊標創建之時，就自動開始了一個隱形的數據庫事務。
commit()方法遊標的全部更新操做，rollback（）方法回滾當前遊標的全部操做。每個方法都開始了一個新的事務。
錯誤處理
DB API中定義了一些數據庫操做的錯誤及異常，下表列出了這些錯誤和異常:
| 異常 | 描述 |
|---|---|
| Warning | 當有嚴重警告時觸發，例如插入數據是被截斷等等。必須是 StandardError 的子類。 |
| Error | 警告之外全部其餘錯誤類。必須是 StandardError 的子類。 |
| InterfaceError | 當有數據庫接口模塊自己的錯誤（而不是數據庫的錯誤）發生時觸發。 必須是Error的子類。 |
| DatabaseError | 和數據庫有關的錯誤發生時觸發。 必須是Error的子類。 |
| DataError | 當有數據處理時的錯誤發生時觸發，例如：除零錯誤，數據超範圍等等。 必須是DatabaseError的子類。 |
| OperationalError | 指非用戶控制的，而是操做數據庫時發生的錯誤。例如：鏈接意外斷開、 數據庫名未找到、事務處理失敗、內存分配錯誤等等操做數據庫是發生的錯誤。 必須是DatabaseError的子類。 |
| IntegrityError | 完整性相關的錯誤，例如外鍵檢查失敗等。必須是DatabaseError子類。 |
| InternalError | 數據庫的內部錯誤，例如遊標（cursor）失效了、事務同步失敗等等。 必須是DatabaseError子類。 |
| ProgrammingError | 程序錯誤，例如數據表（table）沒找到或已存在、SQL語句語法錯誤、 參數數量錯誤等等。必須是DatabaseError的子類。 |
| NotSupportedError | 不支持錯誤，指使用了數據庫不支持的函數或API等。例如在鏈接對象上 使用.rollback()函數，然而數據庫並不支持事務或者事務已關閉。 必須是DatabaseError的子類。 |
................................................................................
休息一下子……
今天內容：python3-number.html
********************************************************
Python 數字數據類型用於存儲數值。
數據類型是不容許改變的,這就意味着若是改變數字數據類型得值，將從新分配內存空間。
如下實例在變量賦值時 Number 對象將被建立：
var1 = 1 var2 = 10
................................................................................
您也能夠使用del語句刪除一些數字對象的引用。
del語句的語法是：
del var1[,var2[,var3[....,varN]]]]
................................................................................
您能夠經過使用del語句刪除單個或多個對象的引用，例如：
del var del var_a, var_b
................................................................................
Python 支持三種不一樣的數值類型：
整型(Int) - 一般被稱爲是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，能夠看成 Long 類型使用，因此 Python3 沒有 Python2 的 Long 類型。
浮點型(float) - 浮點型由整數部分與小數部分組成，浮點型也能夠使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）
複數( (complex)) - 複數由實數部分和虛數部分構成，能夠用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型。
咱們能夠使用十六進制和八進制來表明整數：
>>> number = 0xA0F # 十六進制 >>> number 2575 >>> number=0o37 # 八進制 >>> number 31
................................................................................
| int | float | complex |
|---|---|---|
| 10 | 0.0 | 3.14j |
| 100 | 15.20 | 45.j |
| -786 | -21.9 | 9.322e-36j |
| 080 | 32.3+e18 | .876j |
| -0490 | -90. | -.6545+0J |
| -0x260 | -32.54e100 | 3e+26J |
| 0x69 | 70.2-E12 | 4.53e-7j |
................................................................................
Python支持複數，複數由實數部分和虛數部分構成，能夠用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型。
Python 數字類型轉換
有時候，咱們須要對數據內置的類型進行轉換，數據類型的轉換，你只須要將數據類型做爲函數名便可。
int(x) 將x轉換爲一個整數。
float(x) 將x轉換到一個浮點數。
complex(x) 將x轉換到一個複數，實數部分爲 x，虛數部分爲 0。
complex(x, y) 將 x 和 y 轉換到一個複數，實數部分爲 x，虛數部分爲 y。x 和 y 是數字表達式。
如下實例將浮點數變量 a 轉換爲整數：
>>> a = 1.0 >>> int(a) 1
................................................................................
Python 數字運算
Python 解釋器能夠做爲一個簡單的計算器，您能夠在解釋器裏輸入一個表達式，它將輸出表達式的值。
表達式的語法很直白： +, -, * 和 / 和其它語言（如Pascal或C）裏同樣。例如：
>>> 2 + 2 4 >>> 50 - 5*6 20 >>> (50 - 5*6) / 4 5.0 >>> 8 / 5 # 老是返回一個浮點數 1.6
................................................................................
注意：在不一樣的機器上浮點運算的結果可能會不同。
在整數除法中，除法（/）老是返回一個浮點數，若是隻想獲得整數的結果，丟棄可能的分數部分，能夠使用運算符 // ：
>>> 17 / 3 # 整數除法返回浮點型 5.666666666666667 >>> >>> 17 // 3 # 整數除法返回向下取整後的結果 5 >>> 17 % 3 # ％操做符返回除法的餘數 2 >>> 5 * 3 + 2 17
................................................................................
等號（=）用於給變量賦值。賦值以後，除了下一個提示符，解釋器不會顯示任何結果。
>>> width = 20 >>> height = 5*9 >>> width * height 900
................................................................................
Python 能夠使用 ** 操做來進行冪運算：
>>> 5 ** 2 # 5 的平方 25 >>> 2 ** 7 # 2的7次方 128
................................................................................
變量在使用前必須先"定義"（即賦予變量一個值），不然會出現錯誤：
>>> n # 嘗試訪問一個未定義的變量 Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'n' is not defined
................................................................................
不一樣類型的數混合運算時會將整數轉換爲浮點數：
>>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5
................................................................................
在交互模式中，最後被輸出的表達式結果被賦值給變量 _ 。例如：
>>> tax = 12.5 / 100 >>> price = 100.50 >>> price * tax 12.5625 >>> price + _ 113.0625 >>> round(_, 2) 113.06
................................................................................
此處， _ 變量應被用戶視爲只讀變量。
數學函數
| 函數 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回數字的絕對值，如abs(-10) 返回 10 |
| ceil(x) | 返回數字的上入整數，如math.ceil(4.1) 返回 5 |
| cmp(x, y) |
若是 x < y 返回 -1, 若是 x == y 返回 0, 若是 x > y 返回 1。 Python 3 已廢棄 。使用 使用 (x>y)-(x<y) 替換。 |
| exp(x) | 返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回數字的絕對值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回數字的下舍整數，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10爲基數的x的對數，如math.log10(100)返回 2.0 |
| max(x1, x2,...) | 返回給定參數的最大值，參數能夠爲序列。 |
| min(x1, x2,...) | 返回給定參數的最小值，參數能夠爲序列。 |
| modf(x) | 返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。 |
| pow(x, y) | x**y 運算後的值。 |
| round(x [,n]) | 返回浮點數x的四捨五入值，如給出n值，則表明舍入到小數點後的位數。 |
| sqrt(x) | 返回數字x的平方根，數字能夠爲負數，返回類型爲實數，如math.sqrt(4)返回 2+0j |
................................................................................
cmp(x, y)
隨機數函數
隨機數能夠用於數學，遊戲，安全等領域中，還常常被嵌入到算法中，用以提升算法效率，並提升程序的安全性。
Python包含如下經常使用隨機數函數：
| 函數 | 描述 |
|---|---|
| choice(seq) | 從序列的元素中隨機挑選一個元素，好比random.choice(range(10))，從0到9中隨機挑選一個整數。 |
| randrange ([start,] stop [,step]) | 從指定範圍內，按指定基數遞增的集合中獲取一個隨機數，基數缺省值爲1 |
| random() | 隨機生成下一個實數，它在[0,1)範圍內。 |
| seed([x]) | 改變隨機數生成器的種子seed。若是你不瞭解其原理，你沒必要特別去設定seed，Python會幫你選擇seed。 |
| shuffle(lst) | 將序列的全部元素隨機排序 |
| uniform(x, y) | 隨機生成下一個實數，它在[x,y]範圍內。 |
................................................................................
三角函數
Python包括如下三角函數：
| 函數 | 描述 | |
|---|---|---|
| acos(x) | 返回x的反餘弦弧度值。 | |
| asin(x) | 返回x的反正弦弧度值。 | |
| atan(x) | 返回x的反正切弧度值。 | |
| atan2(y, x) | 返回給定的 X 及 Y 座標值的反正切值。 | |
| cos(x) | 返回x的弧度的餘弦值。 | |
| hypot(x, y) | 返回歐幾里德範數 sqrt(x*x + y*y)。 | |
| sin(x) | 返回的x弧度的正弦值。 | |
| tan(x) | 返回x弧度的正切值。 | |
| degrees(x) | 將弧度轉換爲角度,如degrees(math.pi/2) ， 返回90.0 | |
| radians(x) | 將角度轉換爲弧度 |
................................................................................
數學常量
| 常量 | 描述 |
|---|---|
| pi | 數學常量 pi（圓周率，通常以π來表示） |
| e | 數學常量 e，e即天然常數（天然常數）。 |
................................................................................
休息一下子……
今天內容：python3-os-file-methods.html
********************************************************
os 模塊提供了很是豐富的方法用來處理文件和目錄。經常使用的方法以下表所示：
| 序號 | 方法及描述 |
|---|---|
| 1 | os.access(path, mode) 檢驗權限模式 |
| 2 | os.chdir(path) 改變當前工做目錄 |
| 3 | os.chflags(path, flags) 設置路徑的標記爲數字標記。 |
| 4 | os.chmod(path, mode) 更改權限 |
| 5 | os.chown(path, uid, gid) 更改文件全部者 |
| 6 | os.chroot(path) 改變當前進程的根目錄 |
| 7 | os.close(fd) 關閉文件描述符 fd |
| 8 | os.closerange(fd_low, fd_high) 關閉全部文件描述符，從 fd_low (包含) 到 fd_high (不包含), 錯誤會忽略 |
| 9 | os.dup(fd) 複製文件描述符 fd |
| 10 | os.dup2(fd, fd2) 將一個文件描述符 fd 複製到另外一個 fd2 |
| 11 | os.fchdir(fd) 經過文件描述符改變當前工做目錄 |
| 12 | os.fchmod(fd, mode) 改變一個文件的訪問權限，該文件由參數fd指定，參數mode是Unix下的文件訪問權限。 |
| 13 | os.fchown(fd, uid, gid) 修改一個文件的全部權，這個函數修改一個文件的用戶ID和用戶組ID，該文件由文件描述符fd指定。 |
| 14 | os.fdatasync(fd) 強制將文件寫入磁盤，該文件由文件描述符fd指定，可是不強制更新文件的狀態信息。 |
| 15 | os.fdopen(fd[, mode[, bufsize]]) 經過文件描述符 fd 建立一個文件對象，並返回這個文件對象 |
| 16 | os.fpathconf(fd, name) 返回一個打開的文件的系統配置信息。name爲檢索的系統配置的值，它也許是一個定義系統值的字符串，這些名字在不少標準中指定（POSIX.1, Unix 95, Unix 98, 和其它）。 |
| 17 | os.fstat(fd) 返回文件描述符fd的狀態，像stat()。 |
| 18 | os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系統的信息，像 statvfs() |
| 19 | os.fsync(fd) 強制將文件描述符爲fd的文件寫入硬盤。 |
| 20 | os.ftruncate(fd, length) 裁剪文件描述符fd對應的文件, 因此它最大不能超過文件大小。 |
| 21 | os.getcwd() 返回當前工做目錄 |
| 22 | os.getcwdu() 返回一個當前工做目錄的Unicode對象 |
| 23 | os.isatty(fd) 若是文件描述符fd是打開的，同時與tty(-like)設備相連，則返回true, 不然False。 |
| 24 | os.lchflags(path, flags) 設置路徑的標記爲數字標記，相似 chflags()，可是沒有軟連接 |
| 25 | os.lchmod(path, mode) 修改鏈接文件權限 |
| 26 | os.lchown(path, uid, gid) 更改文件全部者，相似 chown，可是不追蹤連接。 |
| 27 | os.link(src, dst) 建立硬連接，名爲參數 dst，指向參數 src |
| 28 | os.listdir(path) 返回path指定的文件夾包含的文件或文件夾的名字的列表。 |
| 29 | os.lseek(fd, pos, how) 設置文件描述符 fd當前位置爲pos, how方式修改: SEEK_SET 或者 0 設置從文件開始的計算的pos; SEEK_CUR或者 1 則從當前位置計算; os.SEEK_END或者2則從文件尾部開始. 在unix，Windows中有效 |
| 30 | os.lstat(path) 像stat(),可是沒有軟連接 |
| 31 | os.major(device) 從原始的設備號中提取設備major號碼 (使用stat中的st_dev或者st_rdev field)。 |
| 32 | os.makedev(major, minor) 以major和minor設備號組成一個原始設備號 |
| 33 | os.makedirs(path[, mode]) 遞歸文件夾建立函數。像mkdir(), 但建立的全部intermediate-level文件夾須要包含子文件夾。 |
| 34 | os.minor(device) 從原始的設備號中提取設備minor號碼 (使用stat中的st_dev或者st_rdev field )。 |
| 35 | os.mkdir(path[, mode]) 以數字mode的mode建立一個名爲path的文件夾.默認的 mode 是 0777 (八進制)。 |
| 36 | os.mkfifo(path[, mode]) 建立命名管道，mode 爲數字，默認爲 0666 (八進制) |
| 37 | os.mknod(filename[, mode=0600, device]) |
| 38 | os.open(file, flags[, mode]) 打開一個文件，而且設置須要的打開選項，mode參數是可選的 |
| 39 | os.openpty() 打開一個新的僞終端對。返回 pty 和 tty的文件描述符。 |
| 40 | os.pathconf(path, name) 返回相關文件的系統配置信息。 |
| 41 | os.pipe() 建立一個管道. 返回一對文件描述符(r, w) 分別爲讀和寫 |
| 42 | os.popen(command[, mode[, bufsize]]) 從一個 command 打開一個管道 |
| 43 | os.read(fd, n) 從文件描述符 fd 中讀取最多 n 個字節，返回包含讀取字節的字符串，文件描述符 fd對應文件已達到結尾, 返回一個空字符串。 |
| 44 | os.readlink(path) 返回軟連接所指向的文件 |
| 45 | os.remove(path) 刪除路徑爲path的文件。若是path 是一個文件夾，將拋出OSError; 查看下面的rmdir()刪除一個 directory。 |
| 46 | os.removedirs(path) 遞歸刪除目錄。 |
| 47 | os.rename(src, dst) 重命名文件或目錄，從 src 到 dst |
| 48 | os.renames(old, new) 遞歸地對目錄進行改名，也能夠對文件進行改名。 |
| 49 | os.rmdir(path) 刪除path指定的空目錄，若是目錄非空，則拋出一個OSError異常。 |
| 50 | os.stat(path) 獲取path指定的路徑的信息，功能等同於C API中的stat()系統調用。 |
| 51 | os.stat_float_times([newvalue]) |
| 52 | os.statvfs(path) 獲取指定路徑的文件系通通計信息 |
| 53 | os.symlink(src, dst) 建立一個軟連接 |
| 54 | os.tcgetpgrp(fd) 返回與終端fd（一個由os.open()返回的打開的文件描述符）關聯的進程組 |
| 55 | os.tcsetpgrp(fd, pg) 設置與終端fd（一個由os.open()返回的打開的文件描述符）關聯的進程組爲pg。 |
| 56 | os.tempnam([dir[, prefix]]) 返回惟一的路徑名用於建立臨時文件。 |
| 57 | os.tmpfile() 返回一個打開的模式爲(w+b)的文件對象 .這文件對象沒有文件夾入口，沒有文件描述符，將會自動刪除。 |
| 58 | os.tmpnam() 爲建立一個臨時文件返回一個惟一的路徑 |
| 59 | os.ttyname(fd) 返回一個字符串，它表示與文件描述符fd 關聯的終端設備。若是fd 沒有與終端設備關聯，則引起一個異常。 |
| 60 | os.unlink(path) 刪除文件路徑 |
| 61 | os.utime(path, times) 返回指定的path文件的訪問和修改的時間。 |
| 62 | os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]]) 輸出在文件夾中的文件名經過在樹中游走，向上或者向下。 |
| 63 | os.write(fd, str) 寫入字符串到文件描述符 fd中. 返回實際寫入的字符串長度 |
................................................................................
os.access(path, mode)
os.chdir(path)
os.chflags(path, flags)
os.chmod(path, mode)
os.chown(path, uid, gid)
os.chroot(path)
os.close(fd)
os.closerange(fd_low, fd_high)
os.dup(fd)
os.dup2(fd, fd2)
os.fchdir(fd)
os.fchmod(fd, mode)
os.fchown(fd, uid, gid)
os.fdatasync(fd)
os.fdopen(fd[, mode[, bufsize]])
os.fpathconf(fd, name)
os.fstat(fd)
os.fstatvfs(fd)
os.fsync(fd)
os.ftruncate(fd, length)
os.getcwd()
os.getcwdu()
os.isatty(fd)
os.lchflags(path, flags)
os.lchmod(path, mode)
os.lchown(path, uid, gid)
os.link(src, dst)
os.listdir(path)
os.lseek(fd, pos, how)
os.lstat(path)
os.major(device)
os.makedev(major, minor)
os.makedirs(path[, mode])
os.minor(device)
os.mkdir(path[, mode])
os.mkfifo(path[, mode])
os.mknod(filename[, mode=0600, device])
建立一個名爲filename文件系統節點（文件，設備特別文件或者命名pipe）。
os.open(file, flags[, mode])
os.openpty()
os.pathconf(path, name)
os.pipe()
os.popen(command[, mode[, bufsize]])
os.read(fd, n)
os.readlink(path)
os.remove(path)
os.removedirs(path)
os.rename(src, dst)
os.renames(old, new)
os.rmdir(path)
os.stat(path)
os.stat_float_times([newvalue])
決定stat_result是否以float對象顯示時間戳
os.statvfs(path)
os.symlink(src, dst)
os.tcgetpgrp(fd)
os.tcsetpgrp(fd, pg)
os.tempnam([dir[, prefix]])
os.tmpfile()
os.tmpnam()
os.ttyname(fd)
os.unlink(path)
os.utime(path, times)
os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
os.write(fd, str)
休息一下子……
今天內容：python3-prime-number-intervals.html
********************************************************
Python3 實例
素數（prime number）又稱質數，有無限個。除了1和它自己之外再也不被其餘的除數整除。
如下實例能夠輸出指定範圍內的素數：
#!/usr/bin/python3
# 輸出指定範圍內的素數
# take input from the user
lower = int(input("輸入區間最小值: "))
upper = int(input("輸入區間最大值: "))
for num in range(lower,upper + 1):
# 素數大於 1
if num > 1:
for i in range(2,num):
if (num % i) == 0:
break
else:
print(num)
................................................................................
執行以上程序，輸出結果爲：
$ python3 test.py 輸入區間最小值: 1 輸入區間最大值: 100 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
................................................................................
Python3 實例
休息一下子……
今天內容：python3-reg-expressions.html
********************************************************
正則表達式是一個特殊的字符序列，它能幫助你方便的檢查一個字符串是否與某種模式匹配。
Python 自1.5版本起增長了re 模塊，它提供 Perl 風格的正則表達式模式。
re 模塊使 Python 語言擁有所有的正則表達式功能。
compile 函數根據一個模式字符串和可選的標誌參數生成一個正則表達式對象。該對象擁有一系列方法用於正則表達式匹配和替換。
re 模塊也提供了與這些方法功能徹底一致的函數，這些函數使用一個模式字符串作爲它們的第一個參數。
本章節主要介紹Python中經常使用的正則表達式處理函數。
re.match函數
re.match 嘗試從字符串的起始位置匹配一個模式，若是不是起始位置匹配成功的話，match()就返回none。
函數語法：
re.match(pattern, string, flags=0)
................................................................................
函數參數說明：
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串。 |
| flags | 標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。 |
................................................................................
匹配成功re.match方法返回一個匹配的對象，不然返回None。
咱們能夠使用group(num) 或 groups() 匹配對象函數來獲取匹配表達式。
| 匹配對象方法 | 描述 |
|---|---|
| group(num=0) | 匹配的整個表達式的字符串，group() 能夠一次輸入多個組號，在這種狀況下它將返回一個包含那些組所對應值的元組。 |
| groups() | 返回一個包含全部小組字符串的元組，從 1 到 所含的小組號。 |
................................................................................
實例 1：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import re
print(re.match('www', 'www.php.cn').span()) # 在起始位置匹配
print(re.match('com', 'www.php.cn')) # 不在起始位置匹配
................................................................................
以上實例運行輸出結果爲：
(0, 3) None
................................................................................
實例 2：
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
print ("matchObj.group() : ", matchObj.group())
print ("matchObj.group(1) : ", matchObj.group(1))
print ("matchObj.group(2) : ", matchObj.group(2))
else:
print ("No match!!")
................................................................................
以上實例執行結果以下：
matchObj.group() : Cats are smarter than dogs matchObj.group(1) : Cats matchObj.group(2) : smarter
................................................................................
re.search方法
re.search 掃描整個字符串並返回第一個成功的匹配。
函數語法：
re.search(pattern, string, flags=0)
................................................................................
函數參數說明：
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串。 |
| flags | 標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。 |
................................................................................
匹配成功re.search方法返回一個匹配的對象，不然返回None。
咱們能夠使用group(num) 或 groups() 匹配對象函數來獲取匹配表達式。
| 匹配對象方法 | 描述 |
|---|---|
| group(num=0) | 匹配的整個表達式的字符串，group() 能夠一次輸入多個組號，在這種狀況下它將返回一個包含那些組所對應值的元組。 |
| groups() | 返回一個包含全部小組字符串的元組，從 1 到 所含的小組號。 |
................................................................................
實例 1：
#!/usr/bin/python3
import re
print(re.search('www', 'www.php.cn').span()) # 在起始位置匹配
print(re.search('com', 'www.php.cn').span()) # 不在起始位置匹配
................................................................................
以上實例運行輸出結果爲：
(0, 3) (11, 14)
................................................................................
實例 2：
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs";
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
if searchObj:
print ("searchObj.group() : ", searchObj.group())
print ("searchObj.group(1) : ", searchObj.group(1))
print ("searchObj.group(2) : ", searchObj.group(2))
else:
print ("Nothing found!!")
................................................................................
searchObj.group() : Cats are smarter than dogs searchObj.group(1) : Cats searchObj.group(2) : smarter
................................................................................
re.match與re.search的區別
re.match只匹配字符串的開始，若是字符串開始不符合正則表達式，則匹配失敗，函數返回None；而re.search匹配整個字符串，直到找到一個匹配。
實例：
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs";
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
print ("match --> matchObj.group() : ", matchObj.group())
else:
print ("No match!!")
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
print ("search --> matchObj.group() : ", matchObj.group())
else:
print ("No match!!")
................................................................................
No match!! search --> matchObj.group() : dogs
................................................................................
檢索和替換
Python 的re模塊提供了re.sub用於替換字符串中的匹配項。
語法：
re.sub(pattern, repl, string, count=0)
................................................................................
返回的字符串是在字符串中用 RE 最左邊不重複的匹配來替換。若是模式沒有發現，字符將被沒有改變地返回。
可選參數 count 是模式匹配後替換的最大次數；count 必須是非負整數。缺省值是 0 表示替換全部的匹配。
實例：
#!/usr/bin/python3
import re
phone = "2004-959-559 # 這是一個電話號碼"
# 刪除註釋
num = re.sub(r'#.*$', "", phone)
print ("電話號碼 : ", num)
# 移除非數字的內容
num = re.sub(r'\D', "", phone)
print ("電話號碼 : ", num)
................................................................................
電話號碼 : 2004-959-559 電話號碼 : 2004959559
................................................................................
正則表達式修飾符 - 可選標誌
正則表達式能夠包含一些可選標誌修飾符來控制匹配的模式。修飾符被指定爲一個可選的標誌。多個標誌能夠經過按位 OR(|) 它們來指定。如 re.I | re.M 被設置成 I 和 M 標誌：
| 修飾符 | 描述 |
|---|---|
| re.I | 使匹配對大小寫不敏感 |
| re.L | 作本地化識別（locale-aware）匹配 |
| re.M | 多行匹配，影響 ^ 和 $ |
| re.S | 使 . 匹配包括換行在內的全部字符 |
| re.U | 根據Unicode字符集解析字符。這個標誌影響 \w, \W, \b, \B. |
| re.X | 該標誌經過給予你更靈活的格式以便你將正則表達式寫得更易於理解。 |
................................................................................
正則表達式模式
模式字符串使用特殊的語法來表示一個正則表達式：
字母和數字表示他們自身。一個正則表達式模式中的字母和數字匹配一樣的字符串。
多數字母和數字前加一個反斜槓時會擁有不一樣的含義。
標點符號只有被轉義時才匹配自身，不然它們表示特殊的含義。
反斜槓自己須要使用反斜槓轉義。
因爲正則表達式一般都包含反斜槓，因此你最好使用原始字符串來表示它們。模式元素(如 r'/t'，等價於'//t')匹配相應的特殊字符。
下表列出了正則表達式模式語法中的特殊元素。若是你使用模式的同時提供了可選的標誌參數，某些模式元素的含義會改變。
| 模式 | 描述 |
|---|---|
| ^ | 匹配字符串的開頭 |
| $ | 匹配字符串的末尾。 |
| . | 匹配任意字符，除了換行符，當re.DOTALL標記被指定時，則能夠匹配包括換行符的任意字符。 |
| [...] | 用來表示一組字符,單獨列出：[amk] 匹配 'a'，'m'或'k' |
| [^...] | 不在[]中的字符：[^abc] 匹配除了a,b,c以外的字符。 |
| re* | 匹配0個或多個的表達式。 |
| re+ | 匹配1個或多個的表達式。 |
| re? | 匹配0個或1個由前面的正則表達式定義的片斷，非貪婪方式 |
| re{ n} | |
| re{ n,} | 精確匹配n個前面表達式。 |
| re{ n, m} | 匹配 n 到 m 次由前面的正則表達式定義的片斷，貪婪方式 |
| a| b | 匹配a或b |
| (re) | G匹配括號內的表達式，也表示一個組 |
| (?imx) | 正則表達式包含三種可選標誌：i, m, 或 x 。隻影響括號中的區域。 |
| (?-imx) | 正則表達式關閉 i, m, 或 x 可選標誌。隻影響括號中的區域。 |
| (?: re) | 相似 (...), 可是不表示一個組 |
| (?imx: re) | 在括號中使用i, m, 或 x 可選標誌 |
| (?-imx: re) | 在括號中不使用i, m, 或 x 可選標誌 |
| (?#...) | 註釋. |
| (?= re) | 前向確定界定符。若是所含正則表達式，以 ... 表示，在當前位置成功匹配時成功，不然失敗。但一旦所含表達式已經嘗試，匹配引擎根本沒有提升；模式的剩餘部分還要嘗試界定符的右邊。 |
| (?! re) | 前向否認界定符。與確定界定符相反；當所含表達式不能在字符串當前位置匹配時成功 |
| (?> re) | 匹配的獨立模式，省去回溯。 |
| \w | 匹配字母數字 |
| \W | 匹配非字母數字 |
| \s | 匹配任意空白字符，等價於 [\t\n\r\f]. |
| \S | 匹配任意非空字符 |
| \d | 匹配任意數字，等價於 [0-9]. |
| \D | 匹配任意非數字 |
| \A | 匹配字符串開始 |
| \Z | 匹配字符串結束，若是是存在換行，只匹配到換行前的結束字符串。c |
| \z | 匹配字符串結束 |
| \G | 匹配最後匹配完成的位置。 |
| \b | 匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， 'er\b' 能夠匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 |
| \B | 匹配非單詞邊界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。 |
| \n, \t, 等. | 匹配一個換行符。匹配一個製表符。等 |
| \1...\9 | 匹配第n個分組的子表達式。 |
| \10 | 匹配第n個分組的子表達式，若是它經匹配。不然指的是八進制字符碼的表達式。 |
................................................................................
正則表達式實例
| 實例 | 描述 |
|---|---|
| python | 匹配 "python". |
................................................................................
| 實例 | 描述 |
|---|---|
| [Pp]ython | 匹配 "Python" 或 "python" |
| rub[ye] | 匹配 "ruby" 或 "rube" |
| [aeiou] | 匹配中括號內的任意一個字母 |
| [0-9] | 匹配任何數字。相似於 [0123456789] |
| [a-z] | 匹配任何小寫字母 |
| [A-Z] | 匹配任何大寫字母 |
| [a-zA-Z0-9] | 匹配任何字母及數字 |
| [^aeiou] | 除了aeiou字母之外的全部字符 |
| [^0-9] | 匹配除了數字外的字符 |
................................................................................
| 實例 | 描述 |
|---|---|
| . | 匹配除 "\n" 以外的任何單個字符。要匹配包括 '\n' 在內的任何字符，請使用象 '[.\n]' 的模式。 |
| \d | 匹配一個數字字符。等價於 [0-9]。 |
| \D | 匹配一個非數字字符。等價於 [^0-9]。 |
| \s | 匹配任何空白字符，包括空格、製表符、換頁符等等。等價於 [ \f\n\r\t\v]。 |
| \S | 匹配任何非空白字符。等價於 [^ \f\n\r\t\v]。 |
| \w | 匹配包括下劃線的任何單詞字符。等價於'[A-Za-z0-9_]'。 |
| \W | 匹配任何非單詞字符。等價於 '[^A-Za-z0-9_]'。 |
................................................................................
休息一下子……
今天內容：python3-smtp.html
********************************************************
SMTP（Simple Mail Transfer Protocol）即簡單郵件傳輸協議,它是一組用於由源地址到目的地址傳送郵件的規則，由它來控制信件的中轉方式。
python的smtplib提供了一種很方便的途徑發送電子郵件。它對smtp協議進行了簡單的封裝。
Python建立 SMTP 對象語法以下：
import smtplib smtpObj = smtplib.SMTP( [host [, port [, local_hostname]]] )
................................................................................
參數說明：
host: SMTP 服務器主機。 你能夠指定主機的ip地址或者域名如:w3cschool.cc，這個是可選參數。
port: 若是你提供了 host 參數, 你須要指定 SMTP 服務使用的端口號，通常狀況下SMTP端口號爲25。
local_hostname: 若是SMTP在你的本機上，你只須要指定服務器地址爲 localhost 便可。
Python SMTP對象使用sendmail方法發送郵件，語法以下：
SMTP.sendmail(from_addr, to_addrs, msg[, mail_options, rcpt_options]
................................................................................
參數說明：
from_addr: 郵件發送者地址。
to_addrs: 字符串列表，郵件發送地址。
msg: 發送消息
這裏要注意一下第三個參數，msg是字符串，表示郵件。咱們知道郵件通常由標題，發信人，收件人，郵件內容，附件等構成，發送郵件的時候，要注意msg的格式。這個格式就是smtp協議中定義的格式。
如下是一個使用Python發送郵件簡單的實例：
#!/usr/bin/python3
import smtplib
from email.mime.text import MIMEText
from email.header import Header
sender = 'from@php.cn'
receivers = ['429240967@qq.com'] # 接收郵件，可設置爲你的QQ郵箱或者其餘郵箱
# 三個參數：第一個爲文本內容，第二個 plain 設置文本格式，第三個 utf-8 設置編碼
message = MIMEText('Python 郵件發送測試...', 'plain', 'utf-8')
message['From'] = Header("php中文網", 'utf-8')
message['To'] = Header("測試", 'utf-8')
subject = 'Python SMTP 郵件測試'
message['Subject'] = Header(subject, 'utf-8')
try:
smtpObj = smtplib.SMTP('localhost')
smtpObj.sendmail(sender, receivers, message.as_string())
print ("郵件發送成功")
except smtplib.SMTPException:
print ("Error: 沒法發送郵件")
................................................................................
咱們使用三個引號來設置郵件信息，標準郵件須要三個頭部信息： From, To, 和 Subject ，每一個信息直接使用空行分割。
咱們經過實例化 smtplib 模塊的 SMTP 對象 smtpObj 來鏈接到 SMTP 訪問，並使用 sendmail 方法來發送信息。
執行以上程序，若是你本機安裝sendmail，就會輸出：
$ python3 test.py 郵件發送成功
................................................................................
查看咱們的收件箱(通常在垃圾箱)，就能夠查看到郵件信息：
若是咱們本機沒有 sendmail 訪問，也能夠使用其餘服務商的 SMTP 訪問（QQ、網易、Google等）。
#!/usr/bin/python3
import smtplib
from email.mime.text import MIMEText
from email.header import Header
# 第三方 SMTP 服務
mail_host="smtp.XXX.com" #設置服務器
mail_user="XXXX" #用戶名
mail_pass="XXXXXX" #口令
sender = 'from@php.cn'
receivers = ['429240967@qq.com'] # 接收郵件，可設置爲你的QQ郵箱或者其餘郵箱
message = MIMEText('Python 郵件發送測試...', 'plain', 'utf-8')
message['From'] = Header("php中文網", 'utf-8')
message['To'] = Header("測試", 'utf-8')
subject = 'Python SMTP 郵件測試'
message['Subject'] = Header(subject, 'utf-8')
try:
smtpObj = smtplib.SMTP()
smtpObj.connect(mail_host, 25) # 25 爲 SMTP 端口號
smtpObj.login(mail_user,mail_pass)
smtpObj.sendmail(sender, receivers, message.as_string())
print ("郵件發送成功")
except smtplib.SMTPException:
print ("Error: 沒法發送郵件")
................................................................................
使用Python發送HTML格式的郵件
Python發送HTML格式的郵件與發送純文本消息的郵件不一樣之處就是將MIMEText中_subtype設置爲html。具體代碼以下：
#!/usr/bin/python3
import smtplib
from email.mime.text import MIMEText
from email.header import Header
sender = 'from@php.cn'
receivers = ['429240967@qq.com'] # 接收郵件，可設置爲你的QQ郵箱或者其餘郵箱
mail_msg = """
<p>Python 郵件發送測試...</p>
<p><a href="http://www.php.cn">這是一個連接</a></p>
"""
message = MIMEText(mail_msg, 'html', 'utf-8')
message['From'] = Header("php中文網", 'utf-8')
message['To'] = Header("測試", 'utf-8')
subject = 'Python SMTP 郵件測試'
message['Subject'] = Header(subject, 'utf-8')
try:
smtpObj = smtplib.SMTP('localhost')
smtpObj.sendmail(sender, receivers, message.as_string())
print ("郵件發送成功")
except smtplib.SMTPException:
print ("Error: 沒法發送郵件")
................................................................................
執行以上程序，若是你本機安裝sendmail，就會輸出：
$ python3 test.py 郵件發送成功
................................................................................
查看咱們的收件箱(通常在垃圾箱)，就能夠查看到郵件信息：
Python 發送帶附件的郵件
發送帶附件的郵件，首先要建立MIMEMultipart()實例，而後構造附件，若是有多個附件，可依次構造，最後利用smtplib.smtp發送。
#!/usr/bin/python3
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.header import Header
sender = 'from@php.cn'
receivers = ['429240967@qq.com'] # 接收郵件，可設置爲你的QQ郵箱或者其餘郵箱
#建立一個帶附件的實例
message = MIMEMultipart()
message['From'] = Header("php中文網", 'utf-8')
message['To'] = Header("測試", 'utf-8')
subject = 'Python SMTP 郵件測試'
message['Subject'] = Header(subject, 'utf-8')
#郵件正文內容
message.attach(MIMEText('這是php中文網Python 郵件發送測試……', 'plain', 'utf-8'))
# 構造附件1，傳送當前目錄下的 test.txt 文件
att1 = MIMEText(open('test.txt', 'rb').read(), 'base64', 'utf-8')
att1["Content-Type"] = 'application/octet-stream'
# 這裏的filename能夠任意寫，寫什麼名字，郵件中顯示什麼名字
att1["Content-Disposition"] = 'attachment; filename="test.txt"'
message.attach(att1)
# 構造附件2，傳送當前目錄下的 php.txt 文件
att2 = MIMEText(open('php.txt', 'rb').read(), 'base64', 'utf-8')
att2["Content-Type"] = 'application/octet-stream'
att2["Content-Disposition"] = 'attachment; filename="php.txt"'
message.attach(att2)
try:
smtpObj = smtplib.SMTP('localhost')
smtpObj.sendmail(sender, receivers, message.as_string())
print ("郵件發送成功")
except smtplib.SMTPException:
print ("Error: 沒法發送郵件")
................................................................................
$ python3 test.py 郵件發送成功
................................................................................
查看咱們的收件箱(通常在垃圾箱)，就能夠查看到郵件信息：
在 HTML 文本中添加圖片
郵件的 HTML 文本中通常郵件服務商添加外鏈是無效的，正確添加突破的實例以下所示：
#!/usr/bin/python3
import smtplib
from email.mime.image import MIMEImage
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.header import Header
sender = 'from@php.cn'
receivers = ['429240967@qq.com'] # 接收郵件，可設置爲你的QQ郵箱或者其餘郵箱
msgRoot = MIMEMultipart('related')
msgRoot['From'] = Header("php中文網", 'utf-8')
msgRoot['To'] = Header("測試", 'utf-8')
subject = 'Python SMTP 郵件測試'
msgRoot['Subject'] = Header(subject, 'utf-8')
msgAlternative = MIMEMultipart('alternative')
msgRoot.attach(msgAlternative)
mail_msg = """
<p>Python 郵件發送測試...</p>
<p><a href="http://www.php.cn">php中文網連接</a></p>
<p>圖片演示：</p>
<p><img src="cid:image1"></p>
"""
msgAlternative.attach(MIMEText(mail_msg, 'html', 'utf-8'))
# 指定圖片爲當前目錄
fp = open('test.png', 'rb')
msgImage = MIMEImage(fp.read())
fp.close()
# 定義圖片 ID，在 HTML 文本中引用
msgImage.add_header('Content-ID', '<image1>')
msgRoot.attach(msgImage)
try:
smtpObj = smtplib.SMTP('localhost')
smtpObj.sendmail(sender, receivers, msgRoot.as_string())
print ("郵件發送成功")
except smtplib.SMTPException:
print ("Error: 沒法發送郵件")
................................................................................
$ python3 test.py 郵件發送成功
................................................................................
查看咱們的收件箱(若是在垃圾箱可能須要移動到收件箱纔可正常顯示)，就能夠查看到郵件信息：
更多內容請參閱：https://docs.python.org/3/library/email-examples.html。
休息一下子……
今天內容：python3-socket.html
********************************************************
Python 提供了兩個級別訪問的網絡服務。：
低級別的網絡服務支持基本的 Socket，它提供了標準的 BSD Sockets API，能夠訪問底層操做系統Socket接口的所有方法。
高級別的網絡服務模塊 SocketServer， 它提供了服務器中心類，能夠簡化網絡服務器的開發。
什麼是 Socket?
Socket又稱"套接字"，應用程序一般經過"套接字"向網絡發出請求或者應答網絡請求，使主機間或者一臺計算機上的進程間能夠通信。
socket()函數
Python 中，咱們用 socket（）函數來建立套接字，語法格式以下：
socket.socket([family[, type[, proto]]])
................................................................................
family: 套接字家族能夠使AF_UNIX或者AF_INET
type: 套接字類型能夠根據是面向鏈接的仍是非鏈接分爲SOCK_STREAM或SOCK_DGRAM
protocol: 通常不填默認爲0.
| 函數 | 描述 |
|---|---|
| 服務器端套接字 | |
| s.bind() | 綁定地址（host,port）到套接字， 在AF_INET下,以元組（host,port）的形式表示地址。 |
| s.listen() | 開始TCP監聽。backlog指定在拒絕鏈接以前，操做系統能夠掛起的最大鏈接數量。該值至少爲1，大部分應用程序設爲5就能夠了。 |
| s.accept() | 被動接受TCP客戶端鏈接,(阻塞式)等待鏈接的到來 |
| 客戶端套接字 | |
| s.connect() | 主動初始化TCP服務器鏈接，。通常address的格式爲元組（hostname,port），若是鏈接出錯，返回socket.error錯誤。 |
| s.connect_ex() | connect()函數的擴展版本,出錯時返回出錯碼,而不是拋出異常 |
| 公共用途的套接字函數 | |
| s.recv() | 接收TCP數據，數據以字符串形式返回，bufsize指定要接收的最大數據量。flag提供有關消息的其餘信息，一般能夠忽略。 |
| s.send() | 發送TCP數據，將string中的數據發送到鏈接的套接字。返回值是要發送的字節數量，該數量可能小於string的字節大小。 |
| s.sendall() | 完整發送TCP數據，完整發送TCP數據。將string中的數據發送到鏈接的套接字，但在返回以前會嘗試發送全部數據。成功返回None，失敗則拋出異常。 |
| s.recvform() | 接收UDP數據，與recv()相似，但返回值是（data,address）。其中data是包含接收數據的字符串，address是發送數據的套接字地址。 |
| s.sendto() | 發送UDP數據，將數據發送到套接字，address是形式爲（ipaddr，port）的元組，指定遠程地址。返回值是發送的字節數。 |
| s.close() | 關閉套接字 |
| s.getpeername() | 返回鏈接套接字的遠程地址。返回值一般是元組（ipaddr,port）。 |
| s.getsockname() | 返回套接字本身的地址。一般是一個元組(ipaddr,port) |
| s.setsockopt(level,optname,value) | 設置給定套接字選項的值。 |
| s.getsockopt(level,optname[.buflen]) | 返回套接字選項的值。 |
| s.settimeout(timeout) | 設置套接字操做的超時期，timeout是一個浮點數，單位是秒。值爲None表示沒有超時期。通常，超時期應該在剛建立套接字時設置，由於它們可能用於鏈接的操做（如connect()） |
| s.gettimeout() | 返回當前超時期的值，單位是秒，若是沒有設置超時期，則返回None。 |
| s.fileno() | 返回套接字的文件描述符。 |
| s.setblocking(flag) | 若是flag爲0，則將套接字設爲非阻塞模式，不然將套接字設爲阻塞模式（默認值）。非阻塞模式下，若是調用recv()沒有發現任何數據，或send()調用沒法當即發送數據，那麼將引發socket.error異常。 |
| s.makefile() | 建立一個與該套接字相關連的文件 |
................................................................................
簡單實例
咱們使用 socket 模塊的 socket 函數來建立一個 socket 對象。socket 對象能夠經過調用其餘函數來設置一個 socket 服務。
如今咱們能夠經過調用 bind(hostname, port) 函數來指定服務的 port(端口)。
接着，咱們調用 socket 對象的 accept 方法。該方法等待客戶端的鏈接，並返回 connection 對象，表示已鏈接到客戶端。
完整代碼以下：
#!/usr/bin/python3
# 文件名：server.py
# 導入 socket、sys 模塊
import socket
import sys
# 建立 socket 對象
serversocket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
# 獲取本地主機名
host = socket.gethostname()
port = 9999
# 綁定端口
serversocket.bind((host, port))
# 設置最大鏈接數，超事後排隊
serversocket.listen(5)
while True:
# 創建客戶端鏈接
clientsocket,addr = serversocket.accept()
print("鏈接地址: %s" % str(addr))
msg='歡迎訪問php中文網！'+ "\r\n"
clientsocket.send(msg.encode('utf-8'))
clientsocket.close()
................................................................................
接下來咱們寫一個簡單的客戶端實例鏈接到以上建立的服務。端口號爲 12345。
socket.connect(hosname, port ) 方法打開一個 TCP 鏈接到主機爲 hostname 端口爲 port 的服務商。鏈接後咱們就能夠從服務端後期數據，記住，操做完成後須要關閉鏈接。
完整代碼以下：
#!/usr/bin/python3
# 文件名：client.py
# 導入 socket、sys 模塊
import socket
import sys
# 建立 socket 對象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 獲取本地主機名
host = socket.gethostname()
# 設置端口好
port = 9999
# 鏈接服務，指定主機和端口
s.connect((host, port))
# 接收小於 1024 字節的數據
msg = s.recv(1024)
s.close()
print (msg.decode('utf-8'))
................................................................................
如今咱們打開連個終端，第一個終端執行 server.py 文件：
$ python3 server.py
................................................................................
第二個終端執行 client.py 文件：
$ python3 client.py 歡迎訪問php中文網！
................................................................................
這是咱們再打開第一個終端，就會看到有如下信息輸出：
鏈接地址： ('192.168.0.118', 33397)
................................................................................
Python Internet 模塊
如下列出了 Python 網絡編程的一些重要模塊：
| 協議 | 功能用處 | 端口號 | Python 模塊 |
|---|---|---|---|
| HTTP | 網頁訪問 | 80 | httplib, urllib, xmlrpclib |
| NNTP | 閱讀和張貼新聞文章，俗稱爲"帖子" | 119 | nntplib |
| FTP | 文件傳輸 | 20 | ftplib, urllib |
| SMTP | 發送郵件 | 25 | smtplib |
| POP3 | 接收郵件 | 110 | poplib |
| IMAP4 | 獲取郵件 | 143 | imaplib |
| Telnet | 命令行 | 23 | telnetlib |
| Gopher | 信息查找 | 70 | gopherlib, urllib |
................................................................................
更多內容能夠參閱官網的 Python Socket Library and Modules。
休息一下子……
今天內容：python3-stdlib.html
********************************************************
操做系統接口
os模塊提供了很多與操做系統相關聯的函數。
>>> import os
>>> os.getcwd() # 返回當前的工做目錄
'C:\\Python34'
>>> os.chdir('/server/accesslogs') # 修改當前的工做目錄
>>> os.system('mkdir today') # 執行系統命令 mkdir
0
................................................................................
建議使用 "import os" 風格而非 "from os import *"。這樣能夠保證隨操做系統不一樣而有所變化的 os.open() 不會覆蓋內置函數 open()。
在使用 os 這樣的大型模塊時內置的 dir() 和 help() 函數很是有用:
>>> import os >>> dir(os) <returns a list of all module functions> >>> help(os) <returns an extensive manual page created from the module's docstrings>
................................................................................
針對平常的文件和目錄管理任務，:mod:shutil 模塊提供了一個易於使用的高級接口:
>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
>>> shutil.move('/build/executables', 'installdir')
................................................................................
文件通配符
glob模塊提供了一個函數用於從目錄通配符搜索中生成文件列表:
>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']
................................................................................
命令行參數
通用工具腳本常常調用命令行參數。這些命令行參數以鏈表形式存儲於 sys 模塊的 argv 變量。例如在命令行中執行 "python demo.py one two three" 後能夠獲得如下輸出結果:
>>> import sys >>> print(sys.argv) ['demo.py', 'one', 'two', 'three']
................................................................................
錯誤輸出重定向和程序終止
sys 還有 stdin，stdout 和 stderr 屬性，即便在 stdout 被重定向時，後者也能夠用於顯示警告和錯誤信息。
>>> sys.stderr.write('Warning, log file not found starting a new one\n')
Warning, log file not found starting a new one
................................................................................
大多腳本的定向終止都使用 "sys.exit()"。
字符串正則匹配
re模塊爲高級字符串處理提供了正則表達式工具。對於複雜的匹配和處理，正則表達式提供了簡潔、優化的解決方案:
>>> import re >>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest') ['foot', 'fell', 'fastest'] >>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat') 'cat in the hat'
................................................................................
若是隻須要簡單的功能，應該首先考慮字符串方法，由於它們很是簡單，易於閱讀和調試:
>>> 'tea for too'.replace('too', 'two')
'tea for two'
................................................................................
數學
math模塊爲浮點運算提供了對底層C函數庫的訪問:
>>> import math >>> math.cos(math.pi / 4) 0.70710678118654757 >>> math.log(1024, 2) 10.0
................................................................................
random提供了生成隨機數的工具。
>>> import random >>> random.choice(['apple', 'pear', 'banana']) 'apple' >>> random.sample(range(100), 10) # sampling without replacement [30, 83, 16, 4, 8, 81, 41, 50, 18, 33] >>> random.random() # random float 0.17970987693706186 >>> random.randrange(6) # random integer chosen from range(6) 4
................................................................................
訪問 互聯網
有幾個模塊用於訪問互聯網以及處理網絡通訊協議。其中最簡單的兩個是用於處理從 urls 接收的數據的 urllib.request 以及用於發送電子郵件的 smtplib:
>>> from urllib.request import urlopen
>>> for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
... line = line.decode('utf-8') # Decoding the binary data to text.
... if 'EST' in line or 'EDT' in line: # look for Eastern Time
... print(line)
<BR>Nov. 25, 09:43:32 PM EST
>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
... """To: jcaesar@example.org
... From: soothsayer@example.org
...
... Beware the Ides of March.
... """)
>>> server.quit()
................................................................................
注意第二個例子須要本地有一個在運行的郵件服務器。
日期和時間
datetime模塊爲日期和時間處理同時提供了簡單和複雜的方法。
支持日期和時間算法的同時，實現的重點放在更有效的處理和格式化輸出。
該模塊還支持時區處理:
>>> # dates are easily constructed and formatted
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'
>>> # dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368
................................................................................
數據壓縮
如下模塊直接支持通用的數據打包和壓縮格式：zlib，gzip，bz2，zipfile，以及 tarfile。
>>> import zlib >>> s = b'witch which has which witches wrist watch' >>> len(s) 41 >>> t = zlib.compress(s) >>> len(t) 37 >>> zlib.decompress(t) b'witch which has which witches wrist watch' >>> zlib.crc32(s) 226805979
................................................................................
性能度量
有些用戶對了解解決同一問題的不一樣方法之間的性能差別很感興趣。Python 提供了一個度量工具，爲這些問題提供了直接答案。
例如，使用元組封裝和拆封來交換元素看起來要比使用傳統的方法要誘人的多,timeit 證實了現代的方法更快一些。
>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791
................................................................................
相對於 timeit 的細粒度，:mod:profile 和 pstats 模塊提供了針對更大代碼塊的時間度量工具。
測試模塊
開發高質量軟件的方法之一是爲每個函數開發測試代碼，而且在開發過程當中常常進行測試
doctest模塊提供了一個工具，掃描模塊並根據程序中內嵌的文檔字符串執行測試。
測試構造如同簡單的將它的輸出結果剪切並粘貼到文檔字符串中。
經過用戶提供的例子，它強化了文檔，容許 doctest 模塊確認代碼的結果是否與文檔一致:
def average(values): """Computes the arithmetic mean of a list of numbers. >>> print(average([20, 30, 70])) 40.0 """ return sum(values) / len(values) import doctest doctest.testmod() # 自動驗證嵌入測試
................................................................................
unittest模塊不像 doctest模塊那麼容易使用，不過它能夠在一個獨立的文件裏提供一個更全面的測試集:
import unittest class TestStatisticalFunctions(unittest.TestCase): def test_average(self): self.assertEqual(average([20, 30, 70]), 40.0) self.assertEqual(round(average([1, 5, 7]), 1), 4.3) self.assertRaises(ZeroDivisionError, average, []) self.assertRaises(TypeError, average, 20, 30, 70) unittest.main() # Calling from the command line invokes all tests
................................................................................
休息一下子……
今天內容：python3-step1.html
********************************************************
在前面的教程中咱們已經學習了一些 Python3 的基本語法知識，下面咱們嘗試來寫一個斐波納契數列。
實例以下：
#!/usr/bin/python3 # Fibonacci series: 斐波納契數列 # 兩個元素的總和肯定了下一個數 a, b = 0, 1 while b < 10: print(b) a, b = b, a+b
................................................................................
執行以上程序，輸出結果爲：
1 1 2 3 5 8
................................................................................
這個例子介紹了幾個新特徵。
第一行包含了一個複合賦值：變量 a 和 b 同時獲得新值 0 和 1。最後一行再次使用了一樣的方法，能夠看到，右邊的表達式會在賦值變更以前執行。右邊表達式的執行順序是從左往右的。
>>> i = 256*256
>>> print('i 的值爲：', i)
i 的值爲： 65536
................................................................................
關鍵字end能夠用於將結果輸出到同一行，或者在輸出的末尾添加不一樣的字符，實例以下：
#!/usr/bin/python3 # Fibonacci series: 斐波納契數列 # 兩個元素的總和肯定了下一個數 a, b = 0, 1 while b < 1000: print(b, end=',') a, b = b, a+b
................................................................................
執行以上程序，輸出結果爲：
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
................................................................................
休息一下子……
今天內容：python3-string.html
********************************************************
字符串是 Python 中最經常使用的數據類型。咱們能夠使用引號('或")來建立字符串。
建立字符串很簡單，只要爲變量分配一個值便可。例如：
var1 = 'Hello World!' var2 = "php"
................................................................................
Python 訪問字符串中的值
Python 不支持單字符類型，單字符也在Python也是做爲一個字符串使用。
Python 訪問子字符串，能夠使用方括號來截取字符串，以下實例：
#!/usr/bin/python3
var1 = 'Hello World!'
var2 = "php"
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])
................................................................................
以上實例執行結果：
var1[0]: H var2[1:5]: unoo
................................................................................
Python字符串更新
你能夠對已存在的字符串進行修改，並賦值給另外一個變量，以下實例：
#!/usr/bin/python3
var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'php!')
................................................................................
以上實例執行結果
已更新字符串 : Hello php!
................................................................................
Python轉義字符
在須要在字符中使用特殊字符時，python用反斜槓(\)轉義字符。以下表：
| 轉義字符 | 描述 |
|---|---|
| \(在行尾時) | 續行符 |
| \\ | 反斜槓符號 |
| \' | 單引號 |
| \" | 雙引號 |
| \a | 響鈴 |
| \b | 退格(Backspace) |
| \e | 轉義 |
| \000 | 空 |
| \n | 換行 |
| \v | 縱向製表符 |
| \t | 橫向製表符 |
| \r | 回車 |
| \f | 換頁 |
| \oyy | 八進制數，yy表明的字符，例如：\o12表明換行 |
| \xyy | 十六進制數，yy表明的字符，例如：\x0a表明換行 |
| \other | 其它的字符以普通格式輸出 |
................................................................................
Python字符串運算符
下表實例變量a值爲字符串 "Hello"，b變量值爲 "Python"：
| 操做符 | 描述 | 實例 |
|---|---|---|
| + | 字符串鏈接 | a + b 輸出結果： HelloPython |
| * | 重複輸出字符串 | a*2 輸出結果：HelloHello |
| [] | 經過索引獲取字符串中字符 | a[1] 輸出結果 e |
| [ : ] | 截取字符串中的一部分 | a[1:4] 輸出結果 ell |
| in | 成員運算符 - 若是字符串中包含給定的字符返回 True | H in a 輸出結果 1 |
| not in | 成員運算符 - 若是字符串中不包含給定的字符返回 True | M not in a 輸出結果 1 |
| r/R | 原始字符串 - 原始字符串：全部的字符串都是直接按照字面的意思來使用，沒有轉義特殊或不能打印的字符。 原始字符串除在字符串的第一個引號前加上字母"r"（能夠大小寫）之外，與普通字符串有着幾乎徹底相同的語法。 | print r'\n' prints \n 和 print R'\n' prints \n |
| % | 格式字符串 | 請看下一節內容。 |
................................................................................
#!/usr/bin/python3
a = "Hello"
b = "Python"
print("a + b 輸出結果：", a + b)
print("a * 2 輸出結果：", a * 2)
print("a[1] 輸出結果：", a[1])
print("a[1:4] 輸出結果：", a[1:4])
if( "H" in a) :
print("H 在變量 a 中")
else :
print("H 不在變量 a 中")
if( "M" not in a) :
print("M 不在變量 a 中")
else :
print("M 在變量 a 中")
print (r'\n')
print (R'\n')
................................................................................
以上實例輸出結果爲：
a + b 輸出結果： HelloPython a * 2 輸出結果： HelloHello a[1] 輸出結果： e a[1:4] 輸出結果： ell H 在變量 a 中 M 不在變量 a 中 \n \n
................................................................................
Python字符串格式化
Python 支持格式化字符串的輸出 。儘管這樣可能會用到很是複雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用與 C 中 sprintf 函數同樣的語法。
以下實例：
#!/usr/bin/python3
print ("我叫 %s 今年 %d 歲!" % ('小明', 10))
................................................................................
以上實例輸出結果：
我叫 小明 今年 10 歲!
................................................................................
python字符串格式化符號:
| 符 號 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII碼 |
| %s | 格式化字符串 |
| %d | 格式化整數 |
| %u | 格式化無符號整型 |
| %o | 格式化無符號八進制數 |
| %x | 格式化無符號十六進制數 |
| %X | 格式化無符號十六進制數（大寫） |
| %f | 格式化浮點數字，可指定小數點後的精度 |
| %e | 用科學計數法格式化浮點數 |
| %E | 做用同%e，用科學計數法格式化浮點數 |
| %g | %f和%e的簡寫 |
| %G | %f 和 %E 的簡寫 |
| %p | 用十六進制數格式化變量的地址 |
................................................................................
格式化操做符輔助指令:
| 符號 | 功能 |
|---|---|
| * | 定義寬度或者小數點精度 |
| - | 用作左對齊 |
| + | 在正數前面顯示加號( + ) |
| <sp> | 在正數前面顯示空格 |
| # | 在八進制數前面顯示零('0')，在十六進制前面顯示'0x'或者'0X'(取決於用的是'x'仍是'X') |
| 0 | 顯示的數字前面填充'0'而不是默認的空格 |
| % | '%%'輸出一個單一的'%' |
| (var) | 映射變量(字典參數) |
| m.n. | m 是顯示的最小總寬度,n 是小數點後的位數(若是可用的話) |
................................................................................
Python三引號
python三引號容許一個字符串跨多行，字符串中能夠包含換行符、製表符以及其餘特殊字符。實例以下
#!/usr/bin/python3 para_str = """這是一個多行字符串的實例 多行字符串能夠使用製表符 TAB ( \t )。 也能夠使用換行符 [ \n ]。 """ print (para_str)
................................................................................
以上實例執行結果爲：
這是一個多行字符串的實例 多行字符串能夠使用製表符 TAB ( )。 也能夠使用換行符 [ ]。
................................................................................
三引號讓程序員從引號和特殊字符串的泥潭裏面解脫出來，自始至終保持一小塊字符串的格式是所謂的WYSIWYG（所見即所得）格式的。
一個典型的用例是，當你須要一塊HTML或者SQL時，這時用字符串組合，特殊字符串轉義將會很是的繁瑣。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')
................................................................................
Unicode 字符串
在Python2中，普通字符串是以8位ASCII碼進行存儲的，而Unicode字符串則存儲爲16位unicode字符串，這樣可以表示更多的字符集。使用的語法是在字符串前面加上前綴 u。
在Python3中，全部的字符串都是Unicode字符串。
Python 的字符串內建函數
Python 的字符串經常使用內建函數以下：
| 序號 | 方法及描述 |
|---|---|
| 1 | capitalize() |
| 2 | center(width, fillchar) 返回一個指定的寬度 width 居中的字符串，fillchar 爲填充的字符，默認爲空格。 |
| 3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 裏面出現的次數，若是 beg 或者 end 指定則返回指定範圍內 str 出現的次數 |
| 4 | decode(encoding='UTF-8',errors='strict') 使用指定編碼來解碼字符串。默認編碼爲字符串編碼。 |
| 5 | encode(encoding='UTF-8',errors='strict') 以 encoding 指定的編碼格式編碼字符串，若是出錯默認報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace' |
| 6 | endswith(suffix, beg=0, end=len(string)) |
| 7 | expandtabs(tabsize=8) 把字符串 string 中的 tab 符號轉爲空格，tab 符號默認的空格數是 8 。 |
| 8 | find(str, beg=0 end=len(string)) 檢測 str 是否包含在字符串中 中，若是 beg 和 end 指定範圍，則檢查是否包含在指定範圍內，若是是返回開始的索引值，不然返回-1 |
| 9 | index(str, beg=0, end=len(string)) 跟find()方法同樣，只不過若是str不在字符串中會報一個異常. |
| 10 | isalnum() 若是字符串至少有一個字符而且全部字符都是字母或數字則返 回 True,不然返回 False |
| 11 | isalpha() 若是字符串至少有一個字符而且全部字符都是字母則返回 True, 不然返回 False |
| 12 | isdigit() 若是字符串只包含數字則返回 True 不然返回 False.. |
| 13 | islower() 若是字符串中包含至少一個區分大小寫的字符，而且全部這些(區分大小寫的)字符都是小寫，則返回 True，不然返回 False |
| 14 | isnumeric() 若是字符串中只包含數字字符，則返回 True，不然返回 False |
| 15 | isspace() 若是字符串中只包含空格，則返回 True，不然返回 False. |
| 16 | istitle() 若是字符串是標題化的(見 title())則返回 True，不然返回 False |
| 17 | isupper() 若是字符串中包含至少一個區分大小寫的字符，而且全部這些(區分大小寫的)字符都是大寫，則返回 True，不然返回 False |
| 18 | join(seq) 以指定字符串做爲分隔符，將 seq 中全部的元素(的字符串表示)合併爲一個新的字符串 |
| 19 | len(string) 返回字符串長度 |
| 20 | ljust(width[, fillchar]) 返回一個原字符串左對齊,並使用 fillchar 填充至長度 width 的新字符串，fillchar 默認爲空格。 |
| 21 | lower() 轉換字符串中全部大寫字符爲小寫. |
| 22 | lstrip() 截掉字符串左邊的空格 |
| 23 | maketrans() 建立字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示須要轉換的字符，第二個參數也是字符串表示轉換的目標。 |
| 24 | max(str) 返回字符串 str 中最大的字母。 |
| 25 | min(str) 返回字符串 str 中最小的字母。 |
| 26 | replace(old, new [, max]) 把 將字符串中的 str1 替換成 str2,若是 max 指定，則替換不超過 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) 相似於 find()函數，不過是從右邊開始查找. |
| 28 | rindex( str, beg=0, end=len(string)) 相似於 index()，不過是從右邊開始. |
| 29 | rjust(width,[, fillchar]) 返回一個原字符串右對齊,並使用fillchar(默認空格）填充至長度 width 的新字符串 |
| 30 | rstrip() 刪除字符串字符串末尾的空格. |
| 31 | split(str="", num=string.count(str)) num=string.count(str)) 以 str 爲分隔符截取字符串，若是 num 有指定值，則僅截取 num 個子字符串 |
| 32 | splitlines( num=string.count('\n')) 按照行分隔，返回一個包含各行做爲元素的列表，若是 num 指定則僅切片 num 個行. |
| 33 | startswith(str, beg=0,end=len(string)) 檢查字符串是不是以 obj 開頭，是則返回 True，不然返回 False。若是beg 和 end 指定值，則在指定範圍內檢查。 |
| 34 | strip([chars]) 在字符串上執行 lstrip()和 rstrip() |
| 35 | swapcase() 將字符串中大寫轉換爲小寫，小寫轉換爲大寫 |
| 36 | title() 返回"標題化"的字符串,就是說全部單詞都是以大寫開始，其他字母均爲小寫(見 istitle()) |
| 37 | translate(table, deletechars="") 根據 str 給出的表(包含 256 個字符)轉換 string 的字符, 要過濾掉的字符放到 deletechars 參數中 |
| 38 | upper() 轉換字符串中的小寫字母爲大寫 |
| 39 | zfill (width) 返回長度爲 width 的字符串，原字符串右對齊，前面填充0 |
| 40 | isdecimal() 檢查字符串是否只包含十進制字符，若是是返回 true，不然返回 false。 |
................................................................................
capitalize()
將字符串的第一個字符轉換爲大寫
center(width, fillchar)
count(str, beg= 0,end=len(string))
decode(encoding='UTF-8',errors='strict')
encode(encoding='UTF-8',errors='strict')
endswith(suffix, beg=0, end=len(string))
檢查字符串是否以 obj 結束，若是beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束，若是是，返回 True,不然返回 False.
expandtabs(tabsize=8)
find(str, beg=0 end=len(string))
index(str, beg=0, end=len(string))
isalnum()
isalpha()
isdigit()
islower()
isnumeric()
isspace()
istitle()
isupper()
join(seq)
len(string)
ljust(width[, fillchar])
lower()
lstrip()
maketrans()
max(str)
min(str)
replace(old, new [, max])
rfind(str, beg=0,end=len(string))
rindex( str, beg=0, end=len(string))
rjust(width,[, fillchar])
rstrip()
split(str="", num=string.count(str))
splitlines( num=string.count('\n'))
startswith(str, beg=0,end=len(string))
strip([chars])
swapcase()
title()
translate(table, deletechars="")
upper()
zfill (width)
isdecimal()
休息一下子……
今天內容：python3-tuple.html
********************************************************
Python 的元組與列表相似，不一樣之處在於元組的元素不能修改。
元組使用小括號，列表使用方括號。
元組建立很簡單，只須要在括號中添加元素，並使用逗號隔開便可。
以下實例：
tup1 = ('Google', 'php', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";
................................................................................
建立空元組
tup1 = ();
................................................................................
元組中只包含一個元素時，須要在元素後面添加逗號
tup1 = (50,);
................................................................................
元組與字符串相似，下標索引從0開始，能夠進行截取，組合等。
訪問元組
元組能夠使用下標索引來訪問元組中的值，以下實例:
#!/usr/bin/python3
tup1 = ('Google', 'php', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
................................................................................
以上實例輸出結果：
tup1[0]: Google tup2[1:5]: (2, 3, 4, 5)
................................................................................
修改元組
元組中的元素值是不容許修改的，但咱們能夠對元組進行鏈接組合，以下實例:
#!/usr/bin/python3
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
# 如下修改元組元素操做是非法的。
# tup1[0] = 100
# 建立一個新的元組
tup3 = tup1 + tup2;
print (tup3)
................................................................................
以上實例輸出結果：
(12, 34.56, 'abc', 'xyz')
................................................................................
刪除元組
元組中的元素值是不容許刪除的，但咱們能夠使用del語句來刪除整個元組，以下實例:
#!/usr/bin/python3
tup = ('Google', 'php', 1997, 2000)
print (tup)
del tup;
print ("刪除後的元組 tup : ")
print (tup)
................................................................................
以上實例元組被刪除後，輸出變量會有異常信息，輸出以下所示：
刪除後的元組 tup : Traceback (most recent call last): File "test.py", line 8, in <module> print (tup) NameError: name 'tup' is not defined
................................................................................
元組運算符
與字符串同樣，元組之間能夠使用 + 號和 * 號進行運算。這就意味着他們能夠組合和複製，運算後會生成一個新的元組。
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| len((1, 2, 3)) | 3 | 計算元素個數 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 鏈接 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 複製 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print x, | 1 2 3 | 迭代 |
................................................................................
元組索引，截取
由於元組也是一個序列，因此咱們能夠訪問元組中的指定位置的元素，也能夠截取索引中的一段元素，以下所示：
元組：
L = ('Google', 'Taobao', 'php')
................................................................................
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| L[2] | 'php!' | 讀取第三個元素 |
| L[-2] | 'Taobao' | 反向讀取；讀取倒數第二個元素 |
| L[1:] | ('Taobao', 'php!') | 截取元素，從第二個開始後的全部元素。 |
................................................................................
運行實例以下：
>>> L = ('Google', 'Taobao', 'php')
>>> L[2]
'php'
>>> L[-2]
'Taobao'
>>> L[1:]
('Taobao', 'php')
................................................................................
元組內置函數
Python元組包含了如下內置函數
| 序號 | 方法及描述 | 實例 |
|---|---|---|
| 1 | len(tuple) 計算元組元素個數。 |
>>> tuple1 = ('Google', 'php', 'Taobao')
>>> len(tuple1)
3
>>> |
| 2 | max(tuple) 返回元組中元素最大值。 |
>>> tuple2 = ('5', '4', '8')
>>> max(tuple2)
'8'
>>> |
| 3 | min(tuple) 返回元組中元素最小值。 |
>>> tuple2 = ('5', '4', '8')
>>> min(tuple2)
'4'
>>> |
| 4 | tuple(seq) 將列表轉換爲元組。 |
>>> list1= ['Google', 'Taobao', 'php', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'php', 'Baidu') |
................................................................................
>>> tuple1 = ('Google', 'php', 'Taobao')
>>> len(tuple1)
3
>>>
................................................................................
>>> tuple2 = ('5', '4', '8')
>>> max(tuple2)
'8'
>>>
................................................................................
>>> tuple2 = ('5', '4', '8')
>>> min(tuple2)
'4'
>>>
................................................................................
>>> list1= ['Google', 'Taobao', 'php', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'php', 'Baidu')
................................................................................
休息一下子……
今天內容：python3-tutorial.html
********************************************************
Python的3.0版本，常被稱爲Python 3000，或簡稱Py3k。相對於Python的早期版本，這是一個較大的升級。爲了避免帶入過多的累贅，Python 3.0在設計的時候沒有考慮向下兼容。
Python 介紹及安裝教程咱們在Python 2.X版本的教程中已有介紹，這裏就再也不贅述。
你也能夠點擊 Python2.x與3.x版本區別 來查看二者的不一樣。
本教程主要針對Python 3.x版本的學習，若是你使用的是Python 2.x版本請移步至Python 2.X版本的教程。
查看python版本
咱們能夠使用如下命令來查看咱們使用的Python版本：
python -V
................................................................................
以上命令執行結果以下：
Python 3.3.2
................................................................................
你也能夠進入Python的交互式編程模式，查看版本：
Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32 Type "copyright", "credits" or "license()" for more information. >>>
................................................................................
第一個Python3.x程序
對於大多數程序語言，第一個入門編程代碼即是"Hello World！"，如下代碼爲使用Python輸出"Hello World！"：
實例
................................................................................
#!/usr/bin/python
print("Hello, World!");
................................................................................
點擊 "運行實例" 按鈕查看在線實例
你能夠將以上代碼保存在hello.py文件中並使用python命令執行該腳本文件。
python hello.py
................................................................................
以上命令輸出結果爲：
Hello, World!
................................................................................
休息一下子……
今天內容：python3-xml-processing.html
********************************************************
什麼是XML？
XML 指可擴展標記語言（eXtensible Markup Language），標準通用標記語言的子集，是一種用於標記電子文件使其具備結構性的標記語言。 你能夠經過本站學習XML教程
XML 被設計用來傳輸和存儲數據。
XML是一套定義語義標記的規則，這些標記將文檔分紅許多部件並對這些部件加以標識。
它也是元標記語言，即定義了用於定義其餘與特定領域有關的、語義的、結構化的標記語言的句法語言。
python對XML的解析
常見的XML編程接口有DOM和SAX，這兩種接口處理XML文件的方式不一樣，固然使用場合也不一樣。
python有三種方法解析XML，SAX，DOM，以及ElementTree:
python 標準庫包含SAX解析器，SAX用事件驅動模型，經過在解析XML的過程當中觸發一個個的事件並調用用戶定義的回調函數來處理XML文件。
將XML數據在內存中解析成一個樹，經過對樹的操做來操做XML。
本章節使用到的XML實例文件movies.xml內容以下：
<collection shelf="New Arrivals"> <movie title="Enemy Behind"> <type>War, Thriller</type> <format>DVD</format> <year>2003</year> <rating>PG</rating> <stars>10</stars> <description>Talk about a US-Japan war</description> </movie> <movie title="Transformers"> <type>Anime, Science Fiction</type> <format>DVD</format> <year>1989</year> <rating>R</rating> <stars>8</stars> <description>A schientific fiction</description> </movie> <movie title="Trigun"> <type>Anime, Action</type> <format>DVD</format> <episodes>4</episodes> <rating>PG</rating> <stars>10</stars> <description>Vash the Stampede!</description> </movie> <movie title="Ishtar"> <type>Comedy</type> <format>VHS</format> <rating>PG</rating> <stars>2</stars> <description>Viewable boredom</description> </movie> </collection>
................................................................................
python使用SAX解析xml
SAX是一種基於事件驅動的API。
利用SAX解析XML文檔牽涉到兩個部分:解析器和事件處理器。
解析器負責讀取XML文檔,並向事件處理器發送事件,如元素開始跟元素結束事件;
而事件處理器則負責對事件做出相應,對傳遞的XML數據進行處理。
一、對大型文件進行處理；
二、只須要文件的部份內容，或者只需從文件中獲得特定信息。
三、想創建本身的對象模型的時候。
在python中使用sax方式處理xml要先引入xml.sax中的parse函數，還有xml.sax.handler中的ContentHandler。
characters(content)方法
調用時機：
從行開始，遇到標籤以前，存在字符，content的值爲這些字符串。
從一個標籤，遇到下一個標籤以前， 存在字符，content的值爲這些字符串。
從一個標籤，遇到行結束符以前，存在字符，content的值爲這些字符串。
標籤能夠是開始標籤，也能夠是結束標籤。
startDocument()方法
文檔啓動的時候調用。
endDocument()方法
解析器到達文檔結尾時調用。
startElement(name, attrs)方法
遇到XML開始標籤時調用，name是標籤的名字，attrs是標籤的屬性值字典。
endElement(name)方法
遇到XML結束標籤時調用。
make_parser方法
如下方法建立一個新的解析器對象並返回。
xml.sax.make_parser( [parser_list] )
................................................................................
參數說明:
parser_list - 可選參數，解析器列表
parser方法
如下方法建立一個 SAX 解析器並解析xml文檔：
xml.sax.parse( xmlfile, contenthandler[, errorhandler])
................................................................................
參數說明:
xmlfile - xml文件名
contenthandler - 必須是一個ContentHandler的對象
errorhandler - 若是指定該參數，errorhandler必須是一個SAX ErrorHandler對象
parseString方法
parseString方法建立一個XML解析器並解析xml字符串：
xml.sax.parseString(xmlstring, contenthandler[, errorhandler])
................................................................................
參數說明:
xmlstring - xml字符串
contenthandler - 必須是一個ContentHandler的對象
errorhandler - 若是指定該參數，errorhandler必須是一個SAX ErrorHandler對象
Python 解析XML實例
#!/usr/bin/python3
import xml.sax
class MovieHandler( xml.sax.ContentHandler ):
def __init__(self):
self.CurrentData = ""
self.type = ""
self.format = ""
self.year = ""
self.rating = ""
self.stars = ""
self.description = ""
# 元素開始調用
def startElement(self, tag, attributes):
self.CurrentData = tag
if tag == "movie":
print ("*****Movie*****")
title = attributes["title"]
print ("Title:", title)
# 元素結束調用
def endElement(self, tag):
if self.CurrentData == "type":
print ("Type:", self.type)
elif self.CurrentData == "format":
print ("Format:", self.format)
elif self.CurrentData == "year":
print ("Year:", self.year)
elif self.CurrentData == "rating":
print ("Rating:", self.rating)
elif self.CurrentData == "stars":
print ("Stars:", self.stars)
elif self.CurrentData == "description":
print ("Description:", self.description)
self.CurrentData = ""
# 讀取字符時調用
def characters(self, content):
if self.CurrentData == "type":
self.type = content
elif self.CurrentData == "format":
self.format = content
elif self.CurrentData == "year":
self.year = content
elif self.CurrentData == "rating":
self.rating = content
elif self.CurrentData == "stars":
self.stars = content
elif self.CurrentData == "description":
self.description = content
if ( __name__ == "__main__"):
# 建立一個 XMLReader
parser = xml.sax.make_parser()
# turn off namepsaces
parser.setFeature(xml.sax.handler.feature_namespaces, 0)
# 重寫 ContextHandler
Handler = MovieHandler()
parser.setContentHandler( Handler )
parser.parse("movies.xml")
................................................................................
以上代碼執行結果以下：
*****Movie***** Title: Enemy Behind Type: War, Thriller Format: DVD Year: 2003 Rating: PG Stars: 10 Description: Talk about a US-Japan war *****Movie***** Title: Transformers Type: Anime, Science Fiction Format: DVD Year: 1989 Rating: R Stars: 8 Description: A schientific fiction *****Movie***** Title: Trigun Type: Anime, Action Format: DVD Rating: PG Stars: 10 Description: Vash the Stampede! *****Movie***** Title: Ishtar Type: Comedy Format: VHS Rating: PG Stars: 2 Description: Viewable boredom
................................................................................
完整的 SAX API 文檔請查閱Python SAX APIs
使用xml.dom解析xml
文件對象模型（Document Object Model，簡稱DOM），是W3C組織推薦的處理可擴展置標語言的標準編程接口。
一個 DOM 的解析器在解析一個 XML 文檔時，一次性讀取整個文檔，把文檔中全部元素保存在內存中的一個樹結構裏，以後你能夠利用DOM 提供的不一樣的函數來讀取或修改文檔的內容和結構，也能夠把修改過的內容寫入xml文件。
python中用xml.dom.minidom來解析xml文件，實例以下：
#!/usr/bin/python3
from xml.dom.minidom import parse
import xml.dom.minidom
# 使用minidom解析器打開 XML 文檔
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
print ("Root element : %s" % collection.getAttribute("shelf"))
# 在集合中獲取全部電影
movies = collection.getElementsByTagName("movie")
# 打印每部電影的詳細信息
for movie in movies:
print ("*****Movie*****")
if movie.hasAttribute("title"):
print ("Title: %s" % movie.getAttribute("title"))
type = movie.getElementsByTagName('type')[0]
print ("Type: %s" % type.childNodes[0].data)
format = movie.getElementsByTagName('format')[0]
print ("Format: %s" % format.childNodes[0].data)
rating = movie.getElementsByTagName('rating')[0]
print ("Rating: %s" % rating.childNodes[0].data)
description = movie.getElementsByTagName('description')[0]
print ("Description: %s" % description.childNodes[0].data)
................................................................................
以上程序執行結果以下：
Root element : New Arrivals *****Movie***** Title: Enemy Behind Type: War, Thriller Format: DVD Rating: PG Description: Talk about a US-Japan war *****Movie***** Title: Transformers Type: Anime, Science Fiction Format: DVD Rating: R Description: A schientific fiction *****Movie***** Title: Trigun Type: Anime, Action Format: DVD Rating: PG Description: Vash the Stampede! *****Movie***** Title: Ishtar Type: Comedy Format: VHS Rating: PG Description: Viewable boredom
................................................................................
完整的 DOM API 文檔請查閱Python DOM APIs。
休息一下子……
- 1. python資料-大牛分享python資料
- 2. Python資料
- 3. Python 編程資料
- 4. Python 學習資料
- 5. 【Python】—{參考資料}
- 6. python自學資料
- 7. python資料彙總
- 8. python-----學習資料
- 9. Python編程資料
- 10. python資料參考
- 更多相關文章...
- • SQLite - Python - SQLite教程
- • Docker 安裝 Python - Docker教程
- • 使用阿里雲OSS+CDN部署前端頁面與加速靜態資源
- • YAML 入門教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. python資料-大牛分享python資料
- 2. Python資料
- 3. Python 編程資料
- 4. Python 學習資料
- 5. 【Python】—{參考資料}
- 6. python自學資料
- 7. python資料彙總
- 8. python-----學習資料
- 9. Python編程資料
- 10. python資料參考