Python 文件I/O
讀取鍵盤輸入
raw_input
inputraw_input函數
#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = raw_input("請輸入：");
print "你輸入的內容是: ", str
請輸入：Hello Python！
你輸入的內容是: Hello Python！
- input函數
input 可以接收一個Python表達式作為輸入，并將運算結果返回。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = input("請輸入：");
print "你輸入的內容是: ", str
請輸入：[x*5 for x in range(2,10,2)]
你輸入的內容是: [10, 20, 30, 40]
打開和關閉文件
open 函數
!/usr/bin/python
-- coding: UTF-8 --
打開一個文件
fo = open("foo.txt", "wb")
print "文件名: ", fo.name
print "是否已關閉 : ", fo.closed
print "訪問模式 : ", fo.mode
print "末尾是否強制加空格 : ", fo.softspace
文件名: foo.txt
是否已關閉 : False
訪問模式 : wb
末尾是否強制加空格 : 0
##### close()方法
##### write()方法
- write()方法可將任何字符串寫入一個打開的文件。
- Write()方法不在字符串的結尾添加換行符('\n')：
語法：
fileObject.write(string);
##### read()方法
- read（）方法從一個打開的文件中讀取一個字符串。
fileObject.read([count]);
該方法從文件的開頭開始讀入，如果沒有傳入count，它會嘗試盡可能多地讀取更多的內容，很可能是直到文件的末尾。
##### 文件定位
- tell()方法告訴你文件內的當前位置；換句話說，下一次的讀寫會發生在文件開頭這么多字節之后。
- seek（offset [,from]）方法改變當前文件的位置。Offset變量表示要移動的字節數。From變量指定開始移動字節的參考位置。
如果from被設為0，這意味著將文件的開頭作為移動字節的參考位置。如果設為1，則使用當前的位置作為參考位置。如果它被設為2，那么該文件的末尾將作為參考位置。
!/usr/bin/python
-- coding: UTF-8 --
打開一個文件
fo = open("foo.txt", "r+")
str = fo.read(10);
print "讀取的字符串是 : ", str
查找當前位置
position = fo.tell();
print "當前文件位置 : ", position
把指針再次重新定位到文件開頭
position = fo.seek(0, 0);
str = fo.read(10);
print "重新讀取字符串 : ", str
關閉打開的文件
fo.close()
讀取的字符串是 : www.runoob
當前文件位置 : 10
重新讀取字符串 : www.runoob
##### 重命名和刪除文件
- Python的os模塊提供了幫你執行文件處理操作的方法，比如重命名和刪除文件。
- rename()方法：
rename()方法需要兩個參數，當前的文件名和新文件名。
os.rename(current_file_name, new_file_name)
- remove()方法
你可以用remove()方法刪除文件，需要提供要刪除的文件名作為參數。
os.remove(file_name)
##### Python里的目錄：
- os模塊有許多方法能幫你創建，刪除和更改目錄。
- mkdir()方法
可以使用os模塊的mkdir()方法在當前目錄下創建新的目錄們。
os.mkdir("newdir")
- chdir()方法
可以用chdir()方法來改變當前的目錄。chdir()方法需要的一個參數是你想設成當前目錄的目錄名稱。
os.chdir("newdir")
- getcwd()方法：getcwd()方法顯示當前的工作目錄。
os.getcwd()
- rmdir()方法
rmdir()方法刪除目錄，目錄名稱以參數傳遞。
在刪除這個目錄之前，它的所有內容應該先被清除。
os.rmdir('dirname')
***
## Python 異常處理
- 異常處理
捕捉異常可以使用try/except語句。
try/except語句用來檢測try語句塊中的錯誤，從而讓except語句捕獲異常信息并處理。
- 如果你不想在異常發生時結束你的程序，只需在try里捕獲它。
以下為簡單的*try....except...else*的語法：
try:
<語句> #運行別的代碼
except <名字>：
<語句> #如果在try部份引發了'name'異常
except <名字>，<數據>:
<語句> #如果引發了'name'異常，獲得附加的數據
else:
<語句> #如果沒有異常發生
!/usr/bin/python
try:
fh = open("testfile", "w")
fh.write("This is my test file for exception handling!!")
except IOError:
print "Error: can't find file or read data"
else:
print "Written content in the file successfully"
fh.close()
以上程序輸出結果：
Written content in the file successfully
##### 使用except而不帶任何異常類型
- 這不是一個很好的方式，我們不能通過該程序識別出具體的異常信息。因為它捕獲所有的異常。
##### 使用except而帶多種異常類型
##### try-finally 語句
- try-finally 語句無論是否發生異常都將執行最后的代碼。
try:
<語句>
finally:
<語句> #退出try時總會執行
raise
!/usr/bin/python
try:
fh = open("testfile", "w")
try:
fh.write("This is my test file for exception handling!!")
finally:
print "Going to close the file"
fh.close()
except IOError:
print "Error: can't find file or read data"
當在try塊中拋出一個異常，立即執行finally塊代碼。
finally塊中的所有語句執行后，異常被再次提出，并執行except塊代碼。
##### 異常的參數
以下為單個異常的實例：
!/usr/bin/python
Define a function here.
def temp_convert(var):
try:
return int(var)
except ValueError, Argument:
print "The argument does not contain numbers\n", Argument
Call above function here.
temp_convert("xyz");
以上程序執行結果如下：
The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'
##### 用戶自定義異常
- 異常應該是典型的繼承自Exception類，通過直接或間接的方式。
- 以下為與RuntimeError相關的實例,實例中創建了一個類，基類為RuntimeError，用于在異常觸發時輸出更多的信息。
- 在try語句塊中，用戶自定義的異常后執行except塊語句，變量 e 是用于創建Networkerror類的實例。
class Networkerror(RuntimeError):
def init(self, arg):
self.args = arg
在你定義以上類后，你可以觸發該異常，如下所示：
try:
raise Networkerror("Bad hostname")
except Networkerror,e:
print e.args
***
## Python 面向對象
- 在類的聲明中，屬性是用變量來表示的。這種變量就稱為實例變量，是在類聲明的內部但是在類的其他成員方法之外聲明的。類的每個對象維護它自己的一份實例變量的副本。
- 類變量也叫靜態變量，也就是在變量前加了static 的變量；
- 實例變量也叫對象變量，即沒加static 的變量；
- 區別在于：
類變量和實例變量的區別在于：類變量是所有對象共有，其中一個對象將它值改變，其他對象得到的就是改變后的結果；而實例變量則屬對象私有，某一個對象將其值改變，不影響其他對象
##### 創建類
- 使用class語句來創建一個新類，class之后為類的名稱并以冒號結尾，如下實例:
class ClassName:
'類的幫助信息' #類文檔字符串
class_suite #類體
類的幫助信息可以通過ClassName.__doc__查看。
- 實例
!/usr/bin/python
-- coding: UTF-8 --
class Employee:
'所有員工的基類'
empCount = 0
def init(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print "Total Employee %d" % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
empCount變量是一個類變量，它的值將在這個類的所有實例之間共享。你可以在內部類或外部類使用Employee.empCount訪問。
第一種方法__init__()方法是一種特殊的方法，被稱為類的構造函數或初始化方法，當創建了這個類的實例時就會調用該方法
##### 創建實例對象
- 要創建一個類的實例，你可以使用類的名稱，并通過__init__方法接受參數。
"創建 Employee 類的第一個對象"
emp1 = Employee("Zara", 2000)
"創建 Employee 類的第二個對象"
emp2 = Employee("Manni", 5000)
##### 訪問屬性
- 您可以使用點(.)來訪問對象的屬性。使用如下類的名稱訪問類變量:
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount
hasattr(emp1, 'age') # 如果存在 'age' 屬性返回 True。
getattr(emp1, 'age') # 返回 'age' 屬性的值
setattr(emp1, 'age', 8) # 添加屬性 'age' 值為 8
delattr(empl, 'age') # 刪除屬性 'age'
##### Python內置類屬性
- __dict__ : 類的屬性（包含一個字典，由類的數據屬性組成）
- __doc__ :類的文檔字符串
- __name__: 類名
- __module__: 類定義所在的模塊（類的全名是'__main__.className'，如果類位于一個導入模塊mymod中，那么className.__module__ 等于 mymod）
- __bases__ : 類的所有父類構成元素（包含了以個由所有父類組成的元組）
##### python對象銷毀(垃圾回收)
- 同Java語言一樣，Python使用了引用計數這一簡單技術來追蹤內存中的對象。
在Python內部記錄著所有使用中的對象各有多少引用。
- 一個內部跟蹤變量，稱為一個引用計數器。
- 當對象被創建時， 就創建了一個引用計數， 當這個對象不再需要時， 也就是說， 這個對象的引用計數變為0 時， 它被垃圾回收。但是回收不是"立即"的， 由解釋器在適當的時機，將垃圾對象占用的內存空間回收。
- 垃圾回收機制不僅針對引用計數為0的對象，同樣也可以處理循環引用的情況。循環引用指的是，兩個對象相互引用，但是沒有其他變量引用他們。這種情況下，僅使用引用計數是不夠的。Python 的垃圾收集器實際上是一個引用計數器和一個循環垃圾收集器。作為引用計數的補充， 垃圾收集器也會留心被分配的總量很大（及未通過引用計數銷毀的那些）的對象。 在這種情況下， 解釋器會暫停下來， 試圖清理所有未引用的循環。
- 析構函數 __del__ ，__del__在對象銷毀的時候被調用，當對象不再被使用時，__del__方法運行：
!/usr/bin/python
-- coding: UTF-8 --
class Point:
def init( self, x=0, y=0):
self.x = x
self.y = y
def del(self):
class_name = self.class.name
print class_name, "銷毀"
pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印對象的id
del pt1
del pt2
del pt3
以上實例運行結果如下：
3083401324 3083401324 3083401324
Point 銷毀
## 類的繼承
面向對象的編程帶來的主要好處之一是代碼的重用，實現這種重用的方法之一是通過繼承機制。繼承完全可以理解成類之間的類型和子類型關系。
在python中繼承中的一些特點：
1. 在繼承中基類的構造（__init__()方法）不會被自動調用，它需要在其派生類的構造中親自專門調用。
2. 在調用基類的方法時，需要加上基類的類名前綴，且需要帶上self參數變量。區別于在類中調用普通函數時并不需要帶上self參數
3. Python總是首先查找對應類型的方法，如果它不能在派生類中找到對應的方法，它才開始到基類中逐個查找。（先在本類中查找調用的方法，找不到才去基類中找）。
!/usr/bin/python
-- coding: UTF-8 --
class Parent: # 定義父類
parentAttr = 100
def init(self):
print "調用父類構造函數"
def parentMethod(self):
print '調用父類方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父類屬性 :", Parent.parentAttr
class Child(Parent): # 定義子類
def init(self):
print "調用子類構造方法"
def childMethod(self):
print '調用子類方法 child method'
c = Child() # 實例化子類
c.childMethod() # 調用子類的方法
c.parentMethod() # 調用父類方法
c.setAttr(200) # 再次調用父類的方法
c.getAttr() # 再次調用父類的方法
以上代碼執行結果如下：
調用子類構造方法
調用子類方法 child method
調用父類方法
父類屬性 : 200
issubclass() - 布爾函數判斷一個類是另一個類的子類或者子孫類
issubclass(sub,sup)
isinstance(obj, Class) 布爾函數如果obj是Class類的實例對象
或者是一個Class子類的實例對象則返回true。
##### 方法重寫
- 如果你的父類方法的功能不能滿足你的需求，你可以在子類重寫你父類的方法：
!/usr/bin/python
-- coding: UTF-8 --
class Parent: # 定義父類
def myMethod(self):
print '調用父類方法'
class Child(Parent): # 定義子類
def myMethod(self):
print '調用子類方法'
c = Child() # 子類實例
c.myMethod() # 子類調用重寫方法
##### 運算符重載
!/usr/bin/python
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)
##### 類屬性與方法
1. 類的私有屬性
**__private_attrs**：兩個下劃線開頭，聲明該屬性為私有，不能在類地外部被使用或直接訪問。在類內部的方法中使用時**self.__private_attrs**。
2. 類的方法
在類地內部，使用def關鍵字可以為類定義一個方法，與一般函數定義不同，類方法必須包含參數self,且為第一個參數
3. 類的私有方法
**__private_method**：兩個下劃線開頭，聲明該方法為私有方法，不能在類地外部調用。在類的內部調用 **self.__private_methods**
!/usr/bin/python
-- coding: UTF-8 --
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 # 報錯，實例不能訪問私有變量
.........................
print counter._JustCounter__secretCount
***
## Python正則表達式
- re.match函數
re.match 嘗試從字符串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match()就返回none。
re.match(pattern, string, flags=0)
!/usr/bin/python
-- coding: UTF-8 --
import re
print(re.match('www', 'www.runoob.com').span()) # 在起始位置匹配
print(re.match('com', 'www.runoob.com')) # 不在起始位置匹配
以上實例運行輸出結果為：
(0, 3)
None
- 我們可以使用group(num) 或 groups() 匹配對象函數來獲取匹配表達式。
- re.search方法
re.search 掃描整個字符串并返回第一個成功的匹配。
re.search(pattern, string, flags=0)
!/usr/bin/python
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
flags定義包括：
- re.I：忽略大小寫
- re.L：表示特殊字符集 \w, \W, \b, \B, \s, \S 依賴于當前環境
- re.M：多行模式
- re.S：' . '并且包括換行符在內的任意字符（注意：' . '不包括換行符）
- re.U： 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依賴于 Unicode 字符屬性數據庫
- r'(.*) are (.*?) .*'
首先，這是一個字符串，前面的一個r表示字符串為非轉義的原始字符串，讓編譯器忽略反斜杠，也就是忽略轉義字符。但是這個字符串里沒有反斜杠，所以這個r可有可無。
1. (.**) 第一個匹配分組，.*代表匹配除換行符之外的所有字符.從第一個字符開始，到are的a結束。不錯過一個空格。
2. (.**?)第二個匹配分組，.*?后面多個問號，代表非貪婪模式，也就是說只匹配符合條件的最少字符。非貪婪模式。從s開始，到空格結束。不匹配空格。下一個如果還是非貪婪模式。則依然什么都沒有。因為下一個是空格。
- 后面的一個.* 沒有括號包圍，所以不是分組，匹配效果和第一個一樣，但是不計入匹配結果中。
matchObj.group() 等同于 matchObj.group(0)，表示匹配到的完整文本字符
matchObj.group(1) 得到第一組匹配結果，也就是(.)匹配到的
matchObj.group(2) 得到第二組匹配結果，也就是(.?)匹配到的
因為只有匹配結果中只有兩組，所以填3時會報錯。
- 檢索和替換
re.sub(pattern, repl, string, max=0)
返回的字符串是在字符串中用 RE 最左邊不重復的匹配來替換。如果模式沒有發現，字符將被沒有改變地返回。
可選參數 count 是模式匹配后替換的最大次數；count 必須是非負整數。缺省值是 0 表示替換所有的匹配。
!/usr/bin/python
import rephone = "2004-959-559 # This is Phone Number"
Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num
Remove anything other than digits
num = re.sub(r'\D', "", phone) #匹配所有非數字
print "Phone Num : ", num
Phone Num : 2004-959-559
Phone Num : 2004959559
## Python CGI編程
- 什么是CGI
CGI 目前由NCSA維護，NCSA定義CGI如下：
CGI(Common Gateway Interface),通用網關接口,它是一段程序,運行在服務器上如：HTTP服務器，提供同客戶端HTML頁面的接口。
