讀文件
打開一個文件用open()方法(open()返回一個文件對象，它是可迭代的)：
>>> f = open('test.txt', 'r')
r表示是文本文件，rb是二進制文件。（這個mode參數默認值就是r）
如果文件不存在，open()函數就會拋出一個IOError的錯誤，並且給出錯誤碼和詳細的信息告訴你文件不存在：
>>> f=open('test.txt', 'r')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'
文件使用完畢后必須關閉，因為文件對象會占用操作系統的資源，並且操作系統同一時間能打開的文件數量也是有限的
>>> f.close()
由於文件讀寫時都有可能產生IOError，一旦出錯，后面的f.close()就不會調用。所以，為了保證無論是否出錯都能正確地關閉文件，我們可以使用try ... finally來實現：
try:
f = open('/path/to/file', 'r')
print(f.read())
finally:
if f:
f.close()
但是每次都這么寫實在太繁瑣，所以，Python引入了with語句來自動幫我們調用close()方法：
with open('/path/to/file', 'r') as f:
print(f.read())
python文件對象提供了三個“讀”方法： read()、readline() 和 readlines()。每種方法可以接受一個變量以限制每次讀取的數據量。
- read() 每次讀取整個文件，它通常用於將文件內容放到一個字符串變量中。如果文件大於可用內存，為了保險起見，可以反復調用
read(size)方法，每次最多讀取size個字節的內容。 - readlines() 之間的差異是后者一次讀取整個文件，象 .read() 一樣。.readlines() 自動將文件內容分析成一個行的列表，該列表可以由 Python 的 for ... in ... 結構進行處理。
- readline() 每次只讀取一行，通常比readlines() 慢得多。僅當沒有足夠內存可以一次讀取整個文件時，才應該使用 readline()。
注意：這三種方法是把每行末尾的'\n'也讀進來了，它並不會默認的把'\n'去掉，需要我們手動去掉。
In[2]: with open('test1.txt', 'r') as f1:
list1 = f1.readlines()
In[3]: list1
Out[3]: ['111\n', '222\n', '333\n', '444\n', '555\n', '666\n']
去掉'\n'
In[4]: with open('test1.txt', 'r') as f1:
list1 = f1.readlines()
for i in range(0, len(list1)):
list1[i] = list1[i].rstrip('\n')
In[5]: list1
Out[5]: ['111', '222', '333', '444', '555', '666']
對於read()和readline()也是把'\n'讀入了，但是print的時候可以正常顯示（因為print里的'\n'被認為是換行的意思）
In[7]: with open('test1.txt', 'r') as f1:
list1 = f1.read()
In[8]: list1
Out[8]: '111\n222\n333\n444\n555\n666\n'
In[9]: print(list1)
111
222
333
444
555
666
In[10]: with open('test1.txt', 'r') as f1:
list1 = f1.readline()
In[11]: list1
Out[11]: '111\n'
In[12]: print(list1)
111
一個python面試題的例子：
有兩個文件，每個都有很多行ip地址，求出兩個文件中相同的ip地址：
# coding:utf-8
import bisect
with open('test1.txt', 'r') as f1:
list1 = f1.readlines()
for i in range(0, len(list1)):
list1[i] = list1[i].strip('\n')
with open('test2.txt', 'r') as f2:
list2 = f2.readlines()
for i in range(0, len(list2)):
list2[i] = list2[i].strip('\n')
list2.sort()
length_2 = len(list2)
same_data = []
for i in list1:
pos = bisect.bisect_left(list2, i)
if pos < len(list2) and list2[pos] == i:
same_data.append(i)
same_data = list(set(same_data))
print(same_data)
要點就是：（1）用with （2）處理行末的'\n' （3）使用二分查找提高算法效率。（4）使用set快速去重。
寫文件
寫文件和讀文件是一樣的，唯一區別是調用open()函數時，傳入標識符'w'或者'wb'表示寫文本文件或寫二進制文件：
>>> f = open('test.txt', 'w') # 若是'wb'就表示寫二進制文件
>>> f.write('Hello, world!')
>>> f.close()
注意：'w'這個模式是醬紫：如果沒有這個文件，就創建一個；如果有，那么就會先把原文件的內容清空再寫入新的東西。所以若不想清空原來的內容而是直接在后面追加新的內容，就用'a'這個模式。
我們可以反復調用write()來寫入文件，但是務必要調用f.close()來關閉文件。當我們寫文件時，操作系統往往不會立刻把數據寫入磁盤，而是放到內存緩存起來，空閑的時候再慢慢寫入。只有調用close()方法時，操作系統才保證把沒有寫入的數據全部寫入磁盤。忘記調用close()的后果是數據可能只寫了一部分到磁盤，剩下的丟失了。所以，還是用with語句來得保險：
with open('test.txt', 'w') as f:
f.write('Hello, world!')
python文件對象提供了兩個“寫”方法： write() 和 writelines()。
- write()方法和read()、readline()方法對應，是將字符串寫入到文件中。
- writelines()方法和readlines()方法對應，也是針對列表的操作。它接收一個字符串列表作為參數，將他們寫入到文件中，換行符不會自動的加入，因此，需要顯式的加入換行符。
f1 = open('test1.txt', 'w')
f1.writelines(["1", "2", "3"])
# 此時test1.txt的內容為:123
f1 = open('test1.txt', 'w')
f1.writelines(["1\n", "2\n", "3\n"])
# 此時test1.txt的內容為:
# 1
# 2
# 3
關於open()的mode參數：
'r'：讀
'w'：寫
'a'：追加
'r+' == r+w（可讀可寫，文件若不存在就報錯(IOError)）
'w+' == w+r（可讀可寫，文件若不存在就創建）
'a+' ==a+r（可追加可寫，文件若不存在就創建）
對應的，如果是二進制文件，就都加一個b就好啦：
'rb' 'wb' 'ab' 'rb+' 'wb+' 'ab+'
JSON
JSON(JavaScript Object Notation, JS 對象標記) 是一種輕量級的數據交換格式。JSON的數據格式其實就是python里面的字典格式，里面可以包含方括號括起來的數組，也就是python里面的列表。
在python中，有專門處理json格式的模塊—— json 和 picle模塊
Json 模塊提供了四個方法： dumps、dump、loads、load
def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None,
default=None, sort_keys=False, **kw):
# Serialize ``obj`` to a JSON formatted ``str``.
# 序列號 “obj” 數據類型 轉換為 JSON格式的字符串
def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
allow_nan=True, cls=None, indent=None, separators=None,
default=None, sort_keys=False, **kw):
"""Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
``.write()``-supporting file-like object).
我理解為兩個動作，一個動作是將”obj“轉換為JSON格式的字符串，還有一個動作是將字符串寫入到文件中，也就是說文件描述符fp是必須要的參數 """
示例代碼：
>>> import json
>>> json.dumps([]) # dumps可以格式化所有的基本數據類型為字符串
'[]'
>>> json.dumps(1) # 數字
'1'
>>> json.dumps('1') # 字符串
'"1"'
>>> dict = {"name":"Tom", "age":23}
>>> json.dumps(dict) # 字典
'{"name": "Tom", "age": 23}'
a = {"name":"Tom", "age":23}
with open("test.json", "w", encoding='utf-8') as f:
# indent 超級好用，格式化保存字典，默認為None，小於0為零個空格
f.write(json.dumps(a, indent=4))
# json.dump(a,f,indent=4) # 和上面的效果一樣
保存的文件效果：
二. loads 和 load
loads和load 反序列化方法
查看源碼：
def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
"""Deserialize ``s`` (a ``str`` instance containing a JSON document) to a Python object.
將包含str類型的JSON文檔反序列化為一個python對象"""
def load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
"""Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object.
將一個包含JSON格式數據的可讀文件飯序列化為一個python對象"""
實例：
>>> json.loads('{"name":"Tom", "age":23}')
{'age': 23, 'name': 'Tom'}
import json
with open("test.json", "r", encoding='utf-8') as f:
aa = json.loads(f.read())
f.seek(0)
bb = json.load(f) # 與 json.loads(f.read())
print(aa)
print(bb)
# 輸出：
{'name': 'Tom', 'age': 23}
{'name': 'Tom', 'age': 23}
三. json 和 picle 模塊
json模塊和picle模塊都有 dumps、dump、loads、load四種方法，而且用法一樣。
不用的是json模塊序列化出來的是通用格式，其它編程語言都認識，就是普通的字符串，
而picle模塊序列化出來的只有python可以認識，其他編程語言不認識的，表現為亂碼
不過picle可以序列化函數，但是其他文件想用該函數，在該文件中需要有該文件的定義（定義和參數必須相同，內容可以不同）
四. python對象（obj） 與json對象的對應關系
+-------------------+---------------+
| Python | JSON |
+===================+===============+
| dict | object |
+-------------------+---------------+
| list, tuple | array |
+-------------------+---------------+
| str | string |
+-------------------+---------------+
| int, float | number |
+-------------------+---------------+
| True | true |
+-------------------+---------------+
| False | false |
+-------------------+---------------+
| None | null |
+-------------------+---------------+
五. 總結
1. json序列化方法：
dumps：無文件操作 dump：序列化+寫入文件
2. json反序列化方法：
loads：無文件操作 load： 讀文件+反序列化
3. json模塊序列化的數據 更通用
picle模塊序列化的數據 僅python可用，但功能強大，可以序列號函數
4. json模塊可以序列化和反序列化的 數據類型 見 python對象（obj） 與json對象的對應關系表
5. 格式化寫入文件利用 indent = 4
OS.PATH
split
分割目錄名，返回由其目錄名和基名給成的元組 Split a pathname. Returns tuple "(head, tail)" where "tail" is everything after the final slash. Either part may be empty.>>> os.path.split("/tmp/f1.txt") ('/tmp', 'f1.txt') >>> os.path.split("/home/test.sh") ('/home', 'test.sh')splitext
分割文件名，返回由文件名和擴展名組成的元組 Split the extension from a pathname. Extension is everything from the last dot to the end, ignoring leading dots. Returns "(root, ext)"; ext may be empty.>>> os.path.splitext("/home/test.sh") ('/home/test', '.sh') >>> os.path.splitext("/tmp/f1.txt") ('/tmp/f1', '.txt')
# 對文件重命名: >>> os.rename('test.txt', 'test.py') # 刪掉文件: >>> os.remove('test.py')
# 查看當前目錄的絕對路徑: >>> os.path.abspath('.') '/Users/michael' # 在某個目錄下創建一個新目錄，首先把新目錄的完整路徑表示出來: >>> os.path.join('/Users/michael', 'testdir') '/Users/michael/testdir' # 然后創建一個目錄: >>> os.mkdir('/Users/michael/testdir') # 刪掉一個目錄: >>> os.rmdir('/Users/michael/testdir')