# 第十一章 文件和流
> 來源：http://www.cnblogs.com/Marlowes/p/5519591.html
> 作者：Marlowes
到目前為止，本書介紹過的內容都是和解釋器自帶的數據結構打交道。我們的程序與外部的交互只是通過`input`、`raw_input`和`print`函數，與外部的交互很少。本章將更進一步，讓程序能接觸更多領域：文件和流。本章介紹的函數和對象可以讓你在程序調用時存儲數據，并且可以處理來自其他程序的數據。
## 11.1 打開文件
`open`函數用來打開文件，語法如下：
```
open(name[, mode[, buffering]])
```
`open`函數使用一個文件名作為唯一的強制參數，然后返回一個文件對象。模式(`mode`)和緩沖(`buffering`)參數都是可選的，我會在后面的內容中對它們進行解釋。
因此，假設有一個名為`somefile.txt`的文本文件(可能是用文本編輯器創建的)，其存儲路徑是`c:\text`(或者在UNIX下的`~/text`)，那么可以像下面這樣打開文件。
```
>>> f = open(r"C:\text\somefile.txt")
```
如果文件不存在，則會看到一個類似下面這樣的異常回溯：
```
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: [Errno 2] No such file or directory: 'C:\\text\\somefile.txt'
```
稍后會介紹文件對象的用處。在此之前，先來看看`open`函數的其他兩個參數。
### 11.1.1 文件模式
如果`open`函數只帶一個文件名參數，那么我們可以獲得能讀取文件內容的文件對象。如果要向文件內寫入內容，則必須提供一個模式參數(稍后會具體地說明讀和寫方式)來顯式聲明。
`open`函數中的模式參數只有幾個值，如表11-1所示。
明確地指出讀模式和什么模式參數都不用的效果是一樣的。使用寫模式可以向文件寫入內容。
`'+'`參數可以用到其他任何模式中，指明讀和寫都是允許的。比如`'r+'`能在打開一個文本文件用來讀寫時使用(也可以使用seek方法來實現，請參見本章后面的"隨機訪問"部分)。
表11-1 `open`函數中模式參數的常用值
```
'r' 讀模式
'w' 寫模式
'a' 追加模式
'b' 二進制模式(可添加到其他模式中使用)
'+' 讀/寫模式(可添加到其他模式中使用)
```
`'b'`模式改變處理文件的方法。一般來說，Python假定處理的是文本文件(包含字符)。通常這樣做不會有任何問題。但是如果處理的是一些其他類型的文件(二進制文件)，比如聲音剪輯或者圖像，那么應該在模式中增加`'b'`。參數`'rb'`可以用來讀取一個二進制文件。
**為什么使用二進制模式**
如果使用二進制模式來讀取(寫入)文件的話，與使用文本模式不會有很大區別。仍然能讀一定數量的字節(基本上和字符一樣)，并且能執行和文本文件有關的操作。關鍵是，在使用二進制模式時，Python會原樣給出文件中的內容——在文本模式下則不一定。
Python對于文本文件的操作方式令人有些驚訝，但不必擔心。其中唯一要用到的技巧就是標準化換行符。一般來說，在Python中，換行符(`\n`)表示結束一行并另起一行，這也是UNIX系統中的規范。但在Windows中一行結束的標志是`\r\n`。為了在程序中隱藏這些區別(這樣的程序就能跨平臺運行)，Python在這里做了一些自動轉換：當在Windows下用文本模式讀取文件中的文本時，Python將`\r\n`轉換成`\n`。相反地，當在Windows下用文本模式向文件寫文本時，Python會把`\n`轉換成`\r\n`(Macintosh系統上的處理也是如此，只是轉換是在`\r`和`\n`之間進行)。
在使用二進制文件(比如聲音剪輯)時可能會產生問題，因為文件中可能包含能被解釋成前面提及的換行符的字符，而使用文本模式，Python能自動轉換。但是這樣會破壞二進制數據。因此為了避免這樣的事發生，要使用二進制模式，這樣就不會發生轉換了。
需要注意的是，在UNIX這種以換行符為標準行結束標志的平臺上，這個區別不是很重要，因為不會發生任何轉換。
_注：通過在模式參數中使用`U`參數能夠在打開文件時使用通用的換行符支持模式，在這種模式下，所有的換行符/字符串(`\r\n`、`\r`或者是`\n`)都被轉換成`\n`，而不用考慮運行的平臺。_
### 11.1.2 緩沖
`open`函數的第3個參數(可選)控制著文件的緩沖。如果參數是`0`(或者是`False`)，I/O(輸入/輸出)就是無緩沖的(所有的讀寫操作都直接針對硬盤)；如果是1(或者`True`)，I/O就是有緩沖的(意味著Python使用內存來代替硬盤，讓程序更快，只有使用`flush`或者`close`時才會更新硬盤上的數據——參見11.2.4節)。大于1的數字代表緩沖區的大小(單位是字節)，`-1`(或者是任何負數)代表使用默認的緩沖區大小。
## 11.2 基本的文件方法
打開文件的方法已經介紹了，那么下一步就是用它們做些有用的事情。接下來會介紹文件對象(和一些類文件對象，有時稱為*流*)的一些基本方法。
_注：你可能會在Python的職業生涯多次遇到類文件這個術語(我已經使用了好幾次了)。類文件對象是支持一些`file`類方法的對象，最重要的是支持`read`方法或者`write`方法，或者兩者兼有。那些由`urllib.urlopen`(參見第14章)返回的對象是一個很好的例子。它們支持的方法有`read`、`readline`和`readlines`。但(在本書寫作期間)也有一些方法不支持，如`isatty`方法。_
**三種標準的流**
第10章中關于`sys`模塊的部分曾經提到過3種流。它們實際上是文件(或者是類文件對象)：大部分文件對象可用的操作它們也可以使用。
數據輸入的標準源是`sys.stdin`。當程序從標準輸入讀取數據時，你可以通過輸入或者使用管道把它和其他程序的標準輸出鏈接起來提供文本(管道是標準的UNIX概念)。??
要打印的文本保存在`sys.stdout`內。`input`和`raw_input`函數的提示文字也是寫入在`sys.stdout`中的。寫入`sys.stdout`的數據一般是出現在屏幕上，但也能使用管道連接到其他程序的標準輸入。
錯誤信息(如棧追蹤)被寫入`sys.stderr`。它和`sys.stdout`在很多方面都很像。?
### 11.2.1 讀和寫
文件(或流)最重要的能力是提供或者接受數據。如果有一個名為f的類文件對象，那么就可以用`f.write`方法和`f.read`方法(以字符串形式)寫入和讀取數據。
每次調用`f.write(string)`時，所提供的參數`string`會被追加到文件中已存在部分的后面。
```
>>> f = open("somefile.txt", "w")
>>> f.write("Hello, ")
>>> f.write("World!") >>> f.close()
```
在完成了對一個文件的操作時，調用`close`。這個方法會在11.2.4節進行詳細的介紹。
讀取很簡單，只要記得告訴流要讀多少字符(字節)即可。例子(接上例)如下：
```
>>> f = open("somefile.txt", "r")
>>> f.read(4) 'Hell'
>>> f.read()
'o, World!'
```
首先指定了我要讀取的字符數`"4"`，然后(通過不提供要讀取的字符數的方式)讀取了剩下的文件。注意，在調用`open`時可以省略模式，因為`'r'`是默認的。
### 11.2.2 管式輸出
在UNIX的shell(就像GUN bash)中，使用*管道*可以在一個命令后面續寫其他的多個命令，就像下面這個例子(假設是GUN bash)。
```
$ cat somefile.txt | python somescript.py | sort
```
_注：GUN bash在Windows中也是存在的。 http://www.cygwin.com 上面有更多的信息。在Mac OS X中，是通過Terminal程序，可以使用shell文件。_
這個管道由以下三3個命令組成。
? `cat somefile.txt`：只是把`somefile.txt`的內容寫到標準輸出(`sys.stdout`)。
? `python somescript.py`：這個命令運行了Python腳本`somescript`。腳本應該是從標準輸入讀，把結果寫入到標準輸出。
? `sort`：這條命令從標準輸入(`sys.stdin`)讀取所有的文本，按字母排序，然后把結果寫入標準輸出。
但管道符號(`|`)的作用是什么？`somescript.py`的作用又是什么呢？
管道符號講一個命令的標準輸出和下一個命令的標準輸入連接在一起。明白了嗎？這樣，就知道`somescript.py`會從它的`sys.stdin`中讀取數據(`cat somefile.txt`寫入的)，并把結果寫入它的`sys.stdout`(`sort`在此得到數據)中。
使用`sys.stdin`的一個簡單的腳本(`somescript`)如代碼清單11-1所示。`somefile.txt`文件的內容如代碼清單11-2所示。
```
# 代碼清單 11-1 統計`sys.stdin`中單詞數的簡單腳本
# somescript.py
import sys
text = sys.stdin.read()
words = text.split()
wordcount = len(words)
print "Wordcount:", wordcount
# 代碼清單 11-2 包含示例文本的文件
Your mother was a hamster and your father smelled of elderberries.
```
下面是`cat somefile.txt | python somescript.py`的結果。
```
Wordcount: 11
```
**隨機訪問**
本章內的例子把文件都當成流來操作，也就是說只能按照從頭到尾的順序讀數據。實際上，在文件中隨意移動讀取位置也是可以的，可以使用類文件對象的方法`seek`和`tell`來直接訪問感興趣的部分(這種做法稱為隨機訪問)。
```
seek(offset[, whence])
```
這個方法把當前位置(進行讀和寫的位置)移動到由`offset`和`whence`定義的位置。`Offset`類是一個字節(字符)數，表示偏移量。`whence`默認是0，表示偏移量是從文件開頭開始計算的(偏移量必須是非負的)。`whence`可能被設置為1(相對于當前位置的移動，此時偏移量`offset``可以是負的)或者2(相對于文件結尾的移動)。
考慮下面這個例子：
```
>>> f = open(r"c:\text\somefile.txt", "w")
>>> f.write("01234567890123456789")
>>> f.seek(5)
>>> f.write("Hello, World!")
>>> f.close()
>>> f = open(r"c:\text\somefile.txt")
>>> f.read()
>>> '01234Hello, World!89'
# tell方法返回當前文件的位置如下例所示：
>>> f = open(r"c:\text\somefile.txt")
>>> f.read(3)
>>> '012'
>>> f.read(2)
>>> '34'
>>> f.tell()
>>> 5L
```
### 11.2.3 讀寫行
實際上，程序到現在做的工作都是很不實用的。通常來說，逐個字符串讀取文件也是沒問題的，進行逐行的讀取也可以。還可以使用file.readline讀取單獨的一行(從當前位置開始直到一個換行符出現，也讀取這個換行符)。不使用任何參數(這樣，一行就被讀取和返回)或者使用一個非負數的整數作為`readline`可以讀取的字符(或字節)的最大值。因此，如果`someFile.readline()`返回`"Hello, World!\n"`，`someFile.readline(5)`返回`"Hello"`。`readlines`方法可以讀取一個文件中的所有行并將其作為列表返回。????
`writelines`方法和`readlines`相反：傳給它一個字符串的列表(實際上任何序列或者可迭代的對象都行)，它會把所有的字符串寫入文件(或流)。注意，程序不會增加新行，需要自己添加。沒有`writeline`方法，因為能使用`write`。?
_注：在使用其他的符號作為換行符的平臺上，用`\r`(Mac中)和`\r\n`(Windows中)代替`\n`(有`os.linesep`決定)。_
### 11.2.4 關閉文件
應該牢記使用`close`方法關閉文件。通常來說，一個文件對象在退出程序后(也可能在退出前)自動關閉，盡管是否關閉文件不是很重要，但關閉文件是沒有什么害處的，可以避免在某些操作系統或設置中進行無用的修改，這樣做也會避免用完系統中所打開文件的配額。
寫入過的文件總是應該關閉，是因為Python可能會緩存(出于效率的考慮而把數據臨時地存儲在某處)寫入的數據，如果程序因為某些原因崩潰了，那么數據根本就不會被寫入文件。為了安全起見，要在使用完文件后關閉。
如果想確保文件被關閉了，那么應該使用`try/finally`語句，并且在`finally`子句中調用`close`方法。
```
# Open your file here
try:
# Write data to your file
finally:
file.close()
```
事實上，有專門為這種情況設計的語句(在Python2.5中引入)，即`with`語句：
```
with open("somefile.txt") as somefile:
do_something(somefile)
```
`with`語句可以打開文件并且將其賦值到變量上(本例是`somefile`)。之后就可以將數據寫入語句體中的文件(或許執行其他操作)。文件在語句結束后會被自動關閉，即使是處于異常引起的結束也是如此。
在Python2.5中，`with`語句只有在導入如下的模塊后才可以用：
```
from __future__ import with_statement
```
而2.5之后的版本中，`with`語句可以直接使用。
注：在寫入了一些文件的內容后，通常的想法是希望這些改變會立刻體現在文件中，這樣一來其他讀取這個文件的程序也能知道這個改變。哦，難道不是這樣嗎？不一定。數據可能被緩存了(在內存中臨時性地存儲)，直到關閉文件才會被寫入到文件。如果需要繼續使用文件(不關閉文件)，又想將磁盤上的文件進行更新，以反映這些修改，那么就要調用文件對象的`flush`方法(注意，`flush`方法不允許其他程序使用該文件的同時訪問文件，具體的情況依據使用的操作系統和設置而定。不管在什么時候，能關閉文件時最好關閉文件)。
**上下文管理器**
`with`語句實際上是很通用的結構，允許使用所謂的上下文管理器(context manager)。上下文管理器是一種支持`__enter__`和`__exit__`這兩個方法的對象。
`__enter__`方法不帶參數，它在進入`with`語句塊的時候被調用，返回值綁定到在`as`關鍵字之后的變量。
`__exit__`方法帶有3個參數：異常類型、異常對象和異常回溯。在離開方法(通過帶有參數提供的、可引發的異常)時這個函數被調用。如果`__exit__`返回`false`，那么所有的異常都不會被處理。
文件可以被用作上下文管理器。它們的`__enter__`方法返回文件對象本身，`__exit__`方法關閉文件。有關這個強大且高級的特性的更多信息，請參看Python參考手冊中的上下文管理器部分。或者可以在Python庫參考中查看上下文管理器和`contextlib`部分。
### 11.2.5 使用基本文件方法
假設`somefile.txt`包含如代碼清單11-3所示的內容，能對它進行什么操作？
```
# 代碼清單11-3 一個簡單的文本文件
Welcome to this file
There is nothing here except This stupid haiku
```
讓我們試試已經知道的方法，首先是`read(n)`：
```
>>> f = open(r"C:\text\somefile.txt")
>>> f.read(7) 'Welcome'
>>> f.read(4) ' to '
>>> f.close()
```
然后是`read()`：
```
>>> f = open(r"C:\text\somefile.txt")
>>> print f.read()
Welcome to this file
There is nothing here except This stupid haiku
>>> f.close()
```
接著是`readline()`：
```
>>> f = open(r"C:\text\somefile.txt")
>>> for i in range(3):
... print str(i) + ": " + f.readline(),
...
0: Welcome to this file
1: There is nothing here except
2: This stupid haiku
>>> f.close()
```
以及`readlines()`：
```
>>> import pprint
>>> pprint.pprint(open(r"C:\text\somefile.txt").readlines())
['Welcome to this file\n', 'There is nothing here except\n', 'This stupid haiku']
```
注意，本例中我所使用的是文件對象自動關閉的方式。
下面是寫文件，首先是`write(string)`：
```
>>> f = open(r"C:\text\somefile.txt", "w")
>>> f.write("this\nis no\nhaiku")
>>> f.close()
```
在運行這個程序后，文件包含的內容如代碼清單11-4所示。
```
# 代碼清單11-4 修改了的文本文件
this is no
haiku
```
最后是`writelines(list)`：
```
>>> f = open(r"C:\text\somefile.txt")
>>> lines = f.readlines()
>>> f.close()
>>> lines[1] = "isn't a\n"
>>> f = open(r"C:\text\somefile.txt", "w")
>>> f.writelines(lines)
>>> f.close()
```
運行這個程序后，文件包含的文本如代碼清單11-5所示。
```
# 代碼清單11-5 再次修改的文本文件
this
isn't a
haiku
```
## 11.3 對文件內容進行迭代
前面介紹了文件對象提供的一些方法，以及如何獲取這樣的文件對象。對文件內容進行迭代以及重復執行一些操作，是最常見的文件操作之一。盡管有很多方法可以實現這個功能，或者可能有人會偏愛某一種并堅持只使用那種方法，但是還有一些人使用其他的方法，為了能理解他們的程序，你就應該了解所有的基本技術。其中的一些技術是使用曾經見過的方法(如`read`、`readline`和`readlines`)，另一些方法是我即將介紹的(比如`xreadlines`和文件迭代器)。
在這部分的所有例子中都使用了一個名為`process`的函數，用來表示每個字符或每行的處理過程。讀者也可以用你喜歡的方法自行實現這個函數。下面就是一個例子：
```
def process(string):
print "Processing: ", string
```
更有用的實現是在數據結構中存儲數據，計算和值，用`re`模塊來代替模式或者增加行號。
如果要嘗試實現以上功能，則應該把`filename`變量設置為一個實際的文件名。
### 11.3.1 按字節處理
最常見的對文件內容進行迭代的方法是在`while`循環中使用`read`方法。例如，對每個字符(字節)進行循環，可以用代碼清單11-6所示的方法實現。
```
# 代碼清單11-6 用read方法對每個字符進行循環
f = open(filename)
char = f.read(1)
while char:
process(char)
char = f.read(1)
f.close()
```
這個程序可以使用是因為當到達文件的末尾時，`read`方法返回一個空的字符串，但在那之前返回的字符串會包含一個字符(這樣布爾值是真)。如果`char`是真，則表示還沒有到文件末尾。
可以看到，賦值語句`char = f.read(1)`被重復地使用，代碼重復通常被認為是一件壞事。(懶惰是美德，還記得嗎？)為了避免發生這種情況，可以使用在第五章介紹過的`while true/break`語句。最終的代碼如代碼清單11-7所示。
```
# 代碼清單11-7 用不同的方式寫循環
f = open(filename)
while True:
char = f.read()
if not char:
break
process(char)
f.close
```
如在第五章提到的，`break`語句不應該頻繁地使用(因為這樣會讓代碼很難懂)；盡管如此，代碼清單11-7中使用的方法比代碼清單11-6中的方法要好，因為前者避免了重復的代碼。
### 11.3.2? 按行操作
當處理文本文件時，經常會對文件的行進行迭代而不是處理單個字符。處理行使用的方法和處理字符一樣，即使用`readline`方法(先前在11.2.3節介紹過)，如代碼清單11-8所示。
```
# 代碼清單11-8 在while循環中使用readline
f = open(filename)
while True:
line = f.readline()
if not line:
break
process(line)
f.close()
```
### 11.3.3 讀取所有內容
如果文件不是很大，那么可以使用不帶參數的`read`方法一次讀取整個文件(把整個文件當做一個字符串來讀取)，或者使用`readlines`方法(把文件讀入一個字符串列表，在列表中每個字符串就是一行)。代碼清單11-9和代碼清單11-10展示了在讀取這樣的文件時，在字符串和行上進行迭代是多么容易。注意，將文件的內容讀入一個字符串或者是讀入列表在其他時候也很有用。比如在讀取后，就可以對字符串使用正則表達式操作，也可以將行列表存入一些數據結構中，以備將來使用。
```
# 代碼清單11-9 用read迭代每個字符
f = open(filename)
for char in f.read():
process(char)
f.close()
# 代碼清單11-10 用readlines迭代行
f = open(filename)
for line in f.readlines():
process(line)
f.close()
```
### 11.3.4 使用`fileinput`實現懶惰行迭代
在需要對一個非常大的文件進行行迭代的操作時，`readlines`會占用太多的內存。這個時候可以使用`while`循環和`readline`方法來替代。當然，在Python中如果能使用`for`循環，那么它就是首選。本例恰好可以使用`for`循環可以使用一個名為_懶惰行迭代_的方法：說它懶惰是因為它只是讀取實際需要的文件部分。
第十章內已經介紹過`fileinput`，代碼清單11-11演示了它的用法。注意，`fileinput`模塊包含了打開文件的函數，只需要傳一個文件名給它。
```
# 代碼清單11-11 用fileinput來對行進行迭代
import fileinput
for line in fileinput.input(filename):
process(line)
```
_注：在舊式代碼中，可使用`xreadlines`實現懶惰行迭代。它的工作方式和`readlines`很類似，不同點在于，它不是將全部的行讀到列表中而是創建了一個`xreadlines`對象。注意，`xreadlines`是舊式的，在你自己的代碼中最好用`fileinput`或文件迭代器(下面來介紹)。_
### 11.3.5 文件迭代器
現在是展示所有最酷的技術的時候了，在Python中如果一開始就存在這個特性的話，其他很多方法(至少包括`xreadlines`)可能就不會出現了。那么這種技術到底是什么？在Python的近幾個版本中(從2.2開始)，文件對象是_可迭代_的，這就意味著可以直接在`for`循環中使用它們，從而對它們進行迭代。如代碼清單11-12所示，很優雅，不是嗎？
```
# 代碼清單11-12 迭代文件
f = open(filename) for line in f:
process(line)
f.close()
```
在這些迭代的例子中，都沒有顯式的關閉文件的操作，盡管在使用完以后，文件的確應該關閉，但是只要沒有向文件內寫入內容，那么不關閉文件也是可以的。如果希望由Python來負責關閉文件(也就是剛才所做的)，那么例子應該進一步簡化，如代碼清單11-13所示。在那個例子中并沒有把一個打開的文件賦給變量(就像我在其他例子中使用的變量`f`)，因此也就沒辦法顯式地關閉文件。
```
# 代碼清單11-13 對文件進行迭代而不使用變量存儲文件對象
for line in open(filename):
process(line)
```
注意`sys.stdin`是可迭代的，就像其他的文件對象。因此如果想要迭代標準輸入中的所有行，可以按如下形式使用`sys.stdin`。
```
import sys
for line in sys.stdin:
process(line)
```
可以對文件迭代器執行和普通迭代器相同的操作。比如將它們轉換為字符串列表(使用list(open(filename)))，這樣所達到的效果和使用readlines一樣。
考慮下面的例子：
```
>>> f = open("somefile.txt", "w")
>>> f.write("First line\n")
>>> f.write("Second line\n")
>>> f.write("Third line\n")
>>> f.close()
>>> lines = list(open("somefile.txt"))
>>> lines
['First line\n', 'Second line\n', 'Third line\n']
>>> first, second, third = open("somefile.txt")
>>> first 'First line\n'
>>> second 'Second line\n'
>>> third 'Third line\n'
```
在這個例子中，注意下面的幾點很重要。
? 在使用`print`來向文件內寫入內容，這會在提供的字符串后面增加新的行。
? 使用序列來對一個打開的文件進行解包操作，把每行都放入一個單獨的變量中(這么做是很有實用性的，因為一般不知道文件中有多少行，但它演示了文件對象的"迭代性")。
? 在寫文件后關閉了文件，是為了確保數據被更新到硬盤(你也看到了，在讀取文件后沒有關閉文件，或許是太馬虎了，但并沒有錯)。
## 11.4 小結
本章中介紹了如何通過文件對象和類文件對象與環境互動，I/O也是Python中最重要的技術之一。下面是本章的關鍵知識。
? 類文件對象：類文件對象是支持`read`和`readline`方法(可能是`write`和`writelines`)的非正式對象。
? 打開和關閉文件：通過提供一個文件名，使用`open`函數打開一個文件(在新版的Python中實際上是`file`的別名)。如果希望確保文件被正常關閉，即使發生錯誤時也是如此可以使用`with`語句。
? 模式和文件類型：當打開一個文件時，也可以提供一個_模式_，比如`'r'`代表讀模式，`'w'`代表寫模式。還可以將文件作為二進制文件打開(這個只在Python進行換行符轉換的平臺上才需要，比如Windows，或許其他地方也應該如此)。
? 標準流：3個標準文件對象(在`sys`模塊中的`stdin`、`stdout`和`stderr`)是一個類文件對象，該對象實現了UNIX標準的I/O機制(Windows中也能用)。
? 讀和寫：使用`read`或是`write`方法可以對文件對象或類文件對象進行讀寫操作。
? 讀寫行：使用`readline`和`readlines`和(用于有效迭代的)`xreadlines`方法可以從文件中讀取行，使用`writelines`可以寫入數據。
? 迭代文件內容：有很多方法可以迭代文件的內容。一般是迭代文本中的行，通過迭代文件對象本身可以輕松完成，也有其他的方法，就像`readlines`和`xreadlines`這兩個倩兼容Python老版本的方法。
### 11.4.1 本章的新函數
本章涉及的新函數如表11-2所示。
表11-2 本章的新函數
```
file(name[, mode[, buffering]]) 打開一個文件并返回一個文件對象
open(name[, mode[, buffering]]) file的別名；在打開文件時，使用open而不是file
```
### 11.4.2 接下來學什么
現在你已經知道了如何通過文件與環境交互，但怎么和用戶交互呢？到現在為止，程序已經使用的只有`input`、`raw_input`和`print`函數，除非用戶在程序能夠讀取的文件中寫入一些內容，否則沒有任何其他工具能創建用戶界面。下一章會介紹圖形用戶界面(graphical user interface)中的窗口、按鈕等。
