簡學Python第二章__巧學數據結構文件操做

Python第二章__巧學數據結構文件操做

歡迎加入Linux_Python學習羣

  羣號：478616847

 

目錄：

• 列表
• 元祖
• 索引
• 字典
• 序列
• 文件操做
• 編碼與文件方法
  

 

本站開始將引入一個新的概念：數據結構，簡答的說數據結構就是將數據元素或者其餘數據結構集合到一塊兒稱之爲數據結構，

常見的數據結構有 列表，元祖，字典，集合，它們有個別名叫作序列，序列是Python中最基本的數據結構，下面咱們一一揭祕這些數據結構。

 

1、索引

　　什麼是索引？

　　索引的意思很簡單，在字符串或者序列中每個元素Python都給了它們一個編號，那麼經過這個編號能夠取到對應的元素，咱們把這個編號叫作索引，請看下面實例　

　　Pythron中索引的規則是從0開始的，也就是序列或者字符串中第一個元素的下標是0，第二個是1，第三個是2，最後一個能夠用-1表示

1 >>> strs = "abcdefg"
2 >>> strs[0]
3 'a'
4 >>> strs[1]
5 'b'
6 >>> strs[-1]
7 'g'

索引

　　分片

　　分片的意思就是經過索引下標取得一段元素，其中在第一個分片的例子中能夠看出，分片取得是0下標位到3下標位的數據但不包括3下標位，因此由於這種特性咱們取出的數據就是三個

　　既012下標位的數據也就是123，第二個例子和第三個例子表示了想要從開頭或者結尾分片的時候，開頭或者結尾能夠不寫。

1 >>> a = "12345678"
2 >>> a[0:3]
3 '123'
4 >>> a[:3]
5 '123'
6 >>> a[6:]
7 '78'
8 >>> a[6:-1]
9 '7'

分片

　　其中分片咱們也能夠跳着取數據，這裏咱們稱之爲步長，當步長爲1的時候其實沒有實際意義，由於取出的值仍是原來的，當步長等於2的時取得就是奇數位的數據了，當步長爲負數的時候則是從後往前

1 >>> a[0::1]
2 '1'
3 >>> a[0::2]
4 '1357'
5 >>> a[::-1]
6 '87654321'
7 >>> a[::-2]
8 '8642'

步長

 

2、列表（List）

　　列表是最經常使用的Python數據類型，它能夠存儲不少元素，每一個元素以逗號進行分割，而且每一個元素咱們均可以進行更改，也能夠添加刪除數據。

　　list函數

　　list函數能夠把字符串或者其餘序列轉換成列表

1 >>> a = "abcd"
2 >>> list(a)
3 ['a', 'b', 'c', 'd']

List函數

 　　基本的列表操做

　　想要訪問列表中的元素咱們能夠經過索引取出，也能夠經過for循環遍歷列表中全部的元素

 1 >>> a = ["a","b","c","d"]
 2 >>> a[1]
 3 'b'
 4 >>> for i in a:
 5 ...     print(i)
 6 ...
 7 a
 8 b
 9 c
10 d

訪問列表中的元素

　　經常使用的內置函數方法

 1 lists = ["a","b","c","d","e",]
 2 
 3 #添加
 4 lists.append("f")
 5 print(lists)
 6 
 7 #刪除列表中的元素
 8 del(lists[0])#等於lists.__delitem__(1)
 9 del(lists[2:4])#刪除序列片斷
10 lists.remove("b")
11 print(lists)
12 
13 #更改列表中的元素
14 lists = ["a","b","c","d","e",]
15 lists[2] = "C"
16 print(lists)
17 
18 #判斷序列的長度
19 print(len(lists))
20 
21 #獲取元素大小，單位字節
22 print(lists.__sizeof__())
23 
24 #搜索列表中某個元素出現的次數
25 lists = ["a","b","c","d","c",]
26 print(lists.count("c"))
27 
28 #查找某個元素第一次出現的下標
29 print(lists.index("c"))
30 
31 #把元素插入到指定下標位置
32 print(lists[2])
33 lists[2] = "C"
34 print(lists[2])
35 
36 #刪除指定下標位的元素，並返回元素，若是不指定下標默認刪除最後一個，並返回元素
37 print(lists)
38 c = lists.pop()
39 print(c)
40 c = lists.pop(1)
41 print(c)
42 print(lists)
43 
44 #列表倒敘
45 lists = ["a","b","c","d"]
46 lists.reverse()
47 print(lists)
48 
49 #按照大小排序，字符串比較unicode值
50 lists = ["c","b","a","d","2","1"]
51 lists.sort()
52 print(lists)
53 
54 #__add__加
55 lists = ["a","b","c"]
56 test = ["d"]
57 lists = lists+test#其中的+號就是調用的__add__因此這樣寫也是能夠的lists = lists.__add__(test)
58 print(lists)
59 
60 #包含，查看列表是否包含某個元素,返回布爾值
61 print(lists.__contains__("a"))#同等於lists in "a"
62 
63 #合併列表
64 lists = ["a","b"]
65 test = ["c","d"]
66 lists.extend(test)
67 print(lists)
68 
69 #將列表中的元素以指定分隔符拼接成字符串
70 print("_".join(lists))

列表的經常使用方法

　　深淺copy

　　咱們知道在列表中能夠把其它序列做爲元素，看下面代碼咱們能夠發先 list1等於一個列表，list2等於list1那麼list1中的任何改變list2也會改變

 1 >>> list1 = ["1","2",["a","b","c"],"3"]
 2 >>> list2 = list1
 3 >>> print("list1:",list1)
 4 list1: ['1', '2', ['a', 'b', 'c'], '3']
 5 >>> print("list2:",list2)
 6 list2: ['1', '2', ['a', 'b', 'c'], '3']
 7 >>> list1[0] = "11"
 8 >>> print("list1:",list1)
 9 list1: ['11', '2', ['a', 'b', 'c'], '3']
10 >>> print("list2:",list2)
11 list2: ['11', '2', ['a', 'b', 'c'], '3']
12 >>> list1[2][0] = "A"
13 >>> print("list1:",list1)
14 list1: ['11', '2', ['A', 'b', 'c'], '3']
15 >>> print("list2:",list2)
16 list2: ['11', '2', ['A', 'b', 'c'], '3']

內存地址的那點事

 　　經過id()咱們能夠獲得變量的內存地址，咱們發現list1和list2的內存地址是同樣的，包括其中的列表的那個元素也是同樣的，因此修改list1的數據list2也會更改

 　　

　　淺拷貝

　　下面的代碼咱們發現，淺拷貝的時候，list1和list2的內存地址是不一樣的，可是更改list1中的列表元素，list2列表也跟着改變，這說明了，淺拷貝沒法拷貝列表中的列表或序列元素

 1 >>> import copy
 2 >>>
 3 >>> list1 = ["1","2",["a","b","c"],"3"]
 4 >>> list2 = copy.copy(list1)
 5 >>> print(id(list1),id(list2))
 6 8996584 7019896
 7 >>> print(id(list1[2]),id(list2[2]))
 8 8997184 8997184
 9 >>> list1[2][0] = "A"
10 >>> print(list1)
11 ['1', '2', ['A', 'b', 'c'], '3']
12 >>> print(list2)
13 ['1', '2', ['A', 'b', 'c'], '3']
14 >>> list1[1] = "5"
15 >>> print(list1)
16 ['1', '5', ['A', 'b', 'c'], '3']
17 >>> print(list2)
18 ['1', '2', ['A', 'b', 'c'], '3']

淺拷貝

 　　

　　深拷貝

　  深拷貝就是把全部的元素都複製了一份，因此對於list1和list2都是獨立的，因此它們的內存地址都是不一樣的

 1 >>> import copy
 2 >>>
 3 >>> list1 = ["1","2",["a","b","c"],"3"]
 4 >>> list2 = copy.deepcopy(list1)
 5 >>> print(id(list1),id(list2))
 6 6414784 8996584
 7 >>> print(id(list1[2]),id(list2[2]))
 8 7019256 8997224
 9 >>> list1[2][0] = "A"
10 >>> print(list1)
11 ['1', '2', ['A', 'b', 'c'], '3']
12 >>> print(list2)
13 ['1', '2', ['a', 'b', 'c'], '3']
14 >>> list1[1] = "5"
15 >>> print(list1)
16 ['1', '5', ['A', 'b', 'c'], '3']
17 >>> print(list2)
18 ['1', '2', ['a', 'b', 'c'], '3']

深拷貝

 　　

 

3、元祖（tuple）

　   什麼是元祖？元祖跟列表的區別就是元祖沒法作任何的修改，因此元祖所保存的數據都是不可更改的

　　元祖的經常使用操做

　　元祖的基本操做除了建立元組和訪問元組元素以外，也沒有太多其餘操做，在下面能夠看出元祖中的序列元素是能夠修改的，除此以外元祖也支持，索引、切片、循環、長度、包含的操做

 1 tuples = ("a","b","c","d","e")
 2 print(tuples[0])
 3 print(tuples[2:])
 4 #某個元素出現的次數
 5 tuples.count("a")
 6 #找到指定元素的下標
 7 tuples.index("d")
 8 #轉換成列表
 9 list(tuples)
10 #字典中的系列不繼承元祖不可修改的特色
11 tuples = ("a",[1,2,3])
12 tuples[1][1] = "a"
13 print(tuples)

元祖基本操做

 

4、字典（dict）

 　　字典這種數據類型就相似於咱們上學時候用的字典，經過目錄查到對應內容的頁數

 　　字典的語法：  變量名 = {key：value} 其中的key必須是惟一的

　　 字典由多個鍵及與其對應的值構成的對組成(咱們也把鍵/值對稱爲項)每一個鍵和它的值之間用冒號<:)隔開，項之間用逗號(，)隔開， 而整個字典是由一對大括號括起來。

　　 fdict = dict((['x', 1], ['y', 2])) 經過這樣的方法能夠把列表轉換成字典

1 dicts = {
2     "1":"a",
3     "2":"b",
4     "3":"c",
5     "4":"d",
6 }

字典

　　字典的無序

　　咱們能夠發現，無論是元祖仍是列表，咱們在打印它的時候能夠發現，它們元素的順序是建立時的順序，然而字典則是沒有順序的

　　內部緣由：

　　在python中字典是惟一的映射類型，在python內部中將字典的Key計算成哈希值來進行存儲，那麼存儲衆多哈希值的表叫作哈希表，這也是爲何字典中的key是惟一的，

　　哈希表主要是對鍵執行一個叫作哈希函數的操做，並根據計算的結果，選擇在數據結構的某個地址中來存儲你的值。任何一個值存儲的地址皆取決於它的鍵。正由於這種隨意性，

　　哈希表中的值是沒有順序的.

　　在這種映射關係中咱們就不會用到序列化排序，不會用到排序意味着針對字典python無序維護相似列表元祖的位置表

1 >>> dicts = {"aa":"a","11":"1","bb":"b","22":"2",}
2 >>> print(dicts)
3 {'22': '2', '11': '1', 'aa': 'a', 'bb': 'b'}

字典的無序

　　字典的經常使用操做

 1 #字典的無序
 2 dicts = {"a":"1","b":"2","c":"3","d":"4","e":"5",}
 3 print(dicts)
 4 
 5 #取出key對應的值(value)
 6 print(dicts["a"])
 7 
 8 #返回key的值，若是存在則返回值，不然返回None
 9 print(dicts.get("s"))
10 
11 #setdefault具備與get方法相似的行爲,若是傳入的key存在則返回對應的value，若是不存在則會在字典中，將會添加鍵並將值設爲默認值（None）
12 print(dicts.setdefault("2"))
13 print(dicts)
14 
15 #取出字典中全部的key
16 print(dicts.keys())
17 
18 #取出字典中全部的值(value)
19 print(dicts.values())
20 
21 #向字典添加鍵值對
22 dicts["f"] = "6"
23 print(dicts)
24 
25 #更改對應key的value值
26 dicts["f"] = "f"
27 print(dicts)
28 
29 #更新，將傳入的字典添加到原字典中，若是有重名將會被覆蓋
30 b = {"1":1}
31 dicts.update(b)
32 print(dicts)
33 
34 #刪除鍵值對
35 del dicts["f"]
36 print(dicts)
37 
38 #刪除鍵值對
39 dicts.pop("d")
40 print(dicts)
41 
42 #任意刪除一個鍵值對，並把刪除的鍵值對返回一個元祖如字典爲空，則返回KeyError異常
43 rm_data = dicts.popitem()
44 print(dicts)
45 print(rm_data)
46 
47 #返回一個由元組構成的列表，每一個元組包含一對鍵-值對
48 print(dicts.items())
49 
50 #建立並返回字典的淺拷貝
51 new_dict = dicts.copy()
52 print(new_dict)
53 
54 #從字典刪除全部項
55 new_dict.clear()
56 print(new_dict)
57 
58 #經過一個列表生成默認dict
59 test = {}
60 print(test.fromkeys([1,2,3],'test'))

字典的經常使用操做

 　  循環字典　　

1 #方法1
2 dicts = {"a":"1","b":"2","c":"3","d":"4","e":"5",}
3 for key in dicts:
4     print(key,dicts[key])
5 
6 #方法2
7 for k,v in dicts.items(): #會先把dict轉成list,數據裏大時莫用
8     print(k,v)

循環字典

 

5、集合（set）

　　把由不一樣的元素組成的類型叫作集合，集合是一個無序的，不重複的數據組合，和其餘容器類型同樣，集合支持用 in 和 not in 操做符檢查成員,也指出長度的操做，但不支持索引！

　　它的主要做用有兩點一、去重，把一個列表變成集合，就自動去重了，二、關係測試，測試兩組數據以前的交集、差集、並集等關係

　　python中幾個的表現形式 sets = {1,2,3,4}

　　集合的經常使用操做

 1 #建立一個數值集合
 2 s = set([3,5,9,10])
 3 #建立一個惟一字符的集合
 4 t = set("Hello")
 5 # t 和 s的並集
 6 a = t | s 
 7 # t 和 s的交集
 8 b = t & s
 9 # 求差集（項在t中，但不在s中）
10 c = t – s 
11 # 對稱差集（項在t或s中，但不會同時出如今兩者中）
12 d = t ^ s          
13 
14 基本操做：
15 
16 # 添加一項
17 t.add('x')            
18 # 在s中添加多項
19 s.update([10,37,42]) 
20 
21 #使用remove()能夠刪除一項：
22 t.remove('H')
23 
24 #set 的長度
25 len(s)
26 
27 #測試 x 是不是 s 的成員
28 x in s
29 
30 #測試 x 是否不是 s 的成員
31 x not in s
32 
33 #測試是否 s 中的每個元素都在 t 中
34 s.issubset(t)
35 s <= t
36 
37 #測試是否 t 中的每個元素都在 s 中
38 s.issuperset(t)
39 s >= t
40 
41 #返回一個新的 set 包含 s 和 t 中的每個元素
42 s.union(t)
43 s | t
44 
45 #返回一個新的 set 包含 s 和 t 中的公共元素
46 s.intersection(t)
47 s & t
48 
49 #返回一個新的 set 包含 s 中有可是 t 中沒有的元素
50 s.difference(t)
51 s - t
52 
53 #返回一個新的 set 包含 s 和 t 中不重複的元素
54 s.symmetric_difference(t)
55 s ^ t
56 
57 #返回 set 「s」的一個淺複製
58 s.copy()

集合的經常使用操做

 

6、文件操做

　　打開文件

　　你必須先用Python內置的open()函數打開一個文件，建立一個file對象，相關的方法才能夠調用它進行讀寫。

　　語法：object = open(file_name [, access_mode][, buffering])

　　例子：

　　咱們發現，當咱們想print出foo時返回的並非文件中的數據，咱們把foo的值稱之爲文件句柄，咱們對文件的操做都是經過文件句柄來實現的。

1 #foo是建立的對象，userdata.txt是要打開的文件名，"r"是打開文件的方法，打開文件有多種方法，詳見下面表格
2 
3 >>> foo = open(r」data\userdata.txt','r')
4 >>> print(foo)
5 <_io.TextIOWrapper name='data\\userdata.txt' mode='r' encoding='cp936'>

打開文件

　　文件操做的模式

 　  

　　"+" 表示能夠同時讀寫某個文件，"U"表示在讀取時，能夠將 \r \n \r\n自動轉換成 \n （與 r 或 r+ 模式同使用 rU,r+U）,"b"表示處理二進制文件(如：FTP發送上傳ISO鏡像文件)

　   文件讀寫操做

　  文件讀操做

　  在讀操做的時候有三個方法來進行讀取，分別是read(),readline(),readlines(),

　   read方法將讀取文件的因此內容，readlines()讀取文件因此內容，並處理成列表，readline()讀取一行內容，在效率方面readlines，和read是速度快的，readline由於是一行一行

　   讀取文件內容因此速度較慢，可是節省內存！咱們能夠看到一般狀況下用readline進行文件操做都是用while循環進行的，而readlines和read，用for循環便可

　　其中咱們發現fo.seek(0, 0)它的做用是把文件指針定位到開頭，更多知識點請看文件指針

 1 foo = open('userdata.txt','r',encoding="utf-8")
 2 #讀取一行，每次只讀取一行
 3 print(foo.readline())
 4 
 5 使用readline()對文件操做
 6 # while True:
 7 #     line = foo.readline()
 8 #     if not line: break
 9 #     if 條件 in line:
10 #         xxx操做
11 # foo.close()
12 
13 #自動將文件內容分析成一個行的列表
14 print(foo.readlines())
15 #將指針從新定位到文件開頭
16 foo.seek(0, 0)
17 #讀取剩下的全部內容,文件大時不要用
18 print(foo.read())
19 #關閉文件
20 foo.close()

文件讀操做

　   咱們提到，當遇到大文件的時候建議使用readline，可是須要經過while循環，這時咱們能夠經過內置模塊fileinput來進行for循環，這種方法稱之爲懶惰行選代

　　默認格式：fileinput.input (files=None, inplace=False, backup='', bufsize=0, mode='r', openhook=None)

files: #文件的路徑列表，默認是stdin方式，多文件['1.txt','2.txt',...]
inplace: #是否將標準輸出的結果寫回文件，默認不取代
backup: #備份文件的擴展名，只指定擴展名，如.bak。若是該文件的備份文件已存在，則會自動覆蓋。
bufsize: #緩衝區大小，默認爲0，若是文件很大，能夠修改此參數，通常默認便可
mode: #讀寫模式，默認爲只讀
openhook: #該鉤子用於控制打開的全部文件，好比說編碼方式等;

fileinput參數含義

　  在下面例子中openhook=fileinput.hook_encoded("utf-8")是爲了解決編碼問題告訴fileinput個人文件是utf-8的編碼格式，更多知識點請看編碼與解碼

 1 import fileinput
 2 
 3 for line in fileinput.input(r'userdata.txt',openhook=fileinput.hook_encoded("utf-8")):
 4     print(line)
 5 
 6 
 7 經常使用方法：
 8 fileinput.input()       #返回可以用於for循環遍歷的對象
 9 fileinput.filename()    #返回當前文件的名稱
10 fileinput.lineno()      #返回當前已經讀取的行的數量（或者序號）
11 fileinput.filelineno()  #返回當前讀取的行的行號
12 fileinput.isfirstline() #檢查當前行是不是文件的第一行
13 fileinput.isstdin()     #判斷最後一行是否從stdin中讀取
14 fileinput.close()       #關閉隊列

fileinput操做

　　文件寫操做

　　咱們發如今write操做的時候字符串後面都加了一個\n，其中的緣由是咱們在寫的時候python不會分辨哪些內容是一行的，因此咱們須要加\n進行換行

 1 #w,與w+方法會覆蓋原文件的內容，他倆的區別是w+能夠讀
 2 foo = open('userdata.txt','w',encoding="utf-8")
 3 foo.write("Helloworld\n")
 4 foo.close()
 5 
 6 #a,與a+都是用於追加的
 7 foo = open('userdata.txt','a+',encoding="utf-8")
 8 foo.write("Helloworld\n")
 9 foo.close()
10 
11 #r+默認的指針會放在文件開始位置全部會替換掉第一行
12 foo = open('userdata.txt','r+',encoding="utf-8")
13 foo.write("aaaaaaaa")
14 foo.close()

文件寫操做

 　  文件更改思路

 　  在平常中對文件進行的操做有不少，而且咱們也常常涉及更改文件內容，那麼在python中沒有那麼智能，因此更文件就比較麻煩主要思路有兩種

　　一、將文件加載到內存，並在內存中更改完成後，所有寫入原文件

　　二、建立臨時文件，經過readline處理文件，並寫入臨時文件，當所有處理完成後，將臨時文件替換成原文件

　　顯然當咱們操做多個文件的時候咱們用以前的方式不太理想，咱們能夠使用 with 語句操做文件對象（）

　　語法：with open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True) as  xxx: 

 1 ########文件內容########
 2 breathe again
 3 Have you wounder how it feels when it's all over.
 4 你是否想過一切結束時會是怎樣的感受?
 5 Wound how it feels when you just have to start?a new.
 6 想過要從新開始又會是怎樣的感受?
 7 Never knowing?where you're going.
 8 從不知道你往哪裏去?
 9 ####################
10 
11 #其思路是，把原文件加載到內存，而後處理並保存到變量，而後在寫入原文件
12 with open("test","r",encoding="utf-8") as file :
13     content = []
14     for lien in file.readlines():
15         if "Wound" in lien:
16             lien = "我是被替換的內容\n"
17         content.append(lien)
18     with open("test","w",encoding="utf-8") as file_w:
19         for i in content:
20             file_w.write(i)

文件改(加載到內存)

　　

 1 #方法一，將文件按行讀取，並進行判斷，寫入臨時文件而後進行替換，文件替換須要藉助 os模塊 中的功能
 2 import os
 3 file_name = "test"
 4 new_filename = file_name+".bk"
 5 with open(file_name,"r",encoding="utf-8") as file, open(new_filename,"w",encoding="utf-8") as file_w:
 6     while True:
 7         line = file.readline()
 8         if not line: break
 9         if "Wound" in line:
10             line = "我是被替換的內容\n"
11         file_w.write(line)
12 os.remove(file_name)
13 os.rename(new_filename,file_name)
14 
15 
16 #方法二 藉助咱們以前學習的 fileinput 模塊
17 import fileinput
18 file_name = "test"
19 for line in fileinput.input(file_name,inplace=1):
20     line = line.replace("Wound","我是被替換的內容")
21     print(line.strip("\n"))
22 fileinput.close()

文件修改(建立臨時文件)

　　注意！ 第二種方法中用到了fileinput模塊中的處理原文件的功能，這個功能沒法使用openhook（稱之爲鉤子），也就沒法指定打開和寫入操做時原文件的編碼格式

　　報錯提示：ValueError: FileInput cannot use an opening hook in inplace mode

　　然而Python3中默認的文件解碼格式是gbk，因此在打開文件的時候會提示如下錯誤

　　錯誤提示：UnicodeDecodeError: 'gbk' codec can't decode byte 0x89 in position 116: illegal multibyte sequence

　　有兩種解決方法：

　　一、將要處理的文件的編碼格式變成「gbk」，在pycharm中更改文件的格式很簡單，在右下角有一個編碼格式,直接選擇gbk便可

　　

　　二、修改fileinput原碼,在33六、340、34七、360行代碼中加入encoding="utf-8"告訴python個人文件是utf-8的格式，那麼在操做的時候python就會以utf-8處理

　　

 

7、編碼與文件方法（os模塊對文件目錄的操做）

　　編碼與轉碼

　  在第一章中咱們瞭解到了編碼的發展，也接觸到了 unicode，utf-8和GBK，在python2中默認編碼是ASCII, python3裏默認是unicode，因此這就形成了

　　咱們在操做文件時python默認會用GBK解碼方式將內容解碼成unicode，那爲何python3要默認Unicode編碼呢？

　　咱們知道全球的語言有不少，那麼爲了規範這些國家有統一的規範進行約束，改變以往字符集編碼不兼容的狀況，Unicode誕生了，可是在Unicode推廣中出

　　現不少問題，最主要的緣由是原來歐美用戶的編碼都是單字節的，而Unicode編碼是雙字節，這樣大大增長了文本數據佔用的空間，要知道在原來磁盤空間遠

　　遠沒有如今這麼大，在這個背景下Utf-8誕生了

　　那麼咱們知道了python3裏默認是unicode，而咱們的文件是UTF-8的編碼，想要把UTF-8變成Unicode就須要進行轉碼

　　

      更多內容請點擊

　　

　   Python3 File(文件) 方法

　　在文件操做中除了讀寫還有其餘的方法例如file.tell()返回文件當前位置等

 1 file = open("test","r",encoding="utf-8")
 2 
 3 # 1    關閉文件。關閉後文件不能再進行讀寫操做。
 4 file.close()
 5 
 6 # 2    刷新文件內部緩衝，直接把內部緩衝區的數據馬上寫入文件, 而不是被動的等待輸出緩衝區寫入。
 7 #通常狀況下，文件關閉後會自動刷新緩衝區，但有時你須要在關閉前刷新它，這時就可使用 flush() 方法。
 8 file.flush()
 9 
10 # 3    返回一個整型的文件描述符(file descriptor FD 整型), 可用於底層操做系統的 I/O 操做
11 file.fileno()
12 
13 # 4    若是文件鏈接到一個終端設備返回 True，不然返回 False。
14 file.isatty()
15 
16 # 5    返回文件下一行。
17 next(file)
18 
19 # 6    從文件讀取指定的字節數，若是未給定或爲負則讀取全部。size是字節的意思
20 file.read([size])
21 
22 # 7    從文件讀取指定的字節數，若是未給定或爲負則讀取全部。
23 file.readline([size])
24 
25 # 8    讀取全部行並返回列表，若給定sizeint>0，返回總和大約爲sizeint字節的行, 實際讀取值可能比sizhint較大, 由於須要填充緩衝區。
26 file.readlines([sizehint])
27 
28 # 9    讀取全部行並返回列表，若給定sizeint>0，返回總和大約爲sizeint字節的行, 實際讀取值可能比sizhint較大, 由於須要填充緩衝區。
29 file.seek(offset[, whence])
30 
31 # 10 返回文件當前位置。
32 file.tell()
33 
34 # 11 截取文件，截取的字節經過size指定，默認爲當前文件位置。
35 file.truncate([size])
36 
37 # 12 將字符串寫入文件，沒有返回值。
38 file.write(str)
39 
40 # 13 向文件寫入一個序列字符串列表，若是須要換行則要本身加入每行的換行符。
41 file.writelines(sequence)

File 方法

 　  

　　OS模塊操做文件和目錄的方法

　　指針：

　　什麼是指針？我麼知道數據存儲是按照字節的，那麼指針就表示在一串數據中位於第幾個字節。在open的時候文件指針在第一位，

　　當讀取完成後文件指針在最後，這也就是爲何在上面 文件讀操做的時候加入了fo.seek(0, 0)把文件指針定位到開頭,

　　下圖假如四個字節是一行的話那麼readline讀取一行後的位置就是在4的位置

　　指針操做不外乎這兩個 file.tell() 獲取當前指針位置 file.seek() 將指針重定位

　　

　　內置模塊OS:

　　模塊是什麼？在這裏咱們簡單理解一下，模塊就是python中準備好的各類功能，就相似於工具盒，工具盒裏面的鉗子有鉗子的用處，錘子有錘子的用處，

　　python也同樣os這個內置模塊擁有操做文件和目錄的功能，更多模塊內容請參考簡學Python第三章

 1 os.getcwd() 獲取當前工做目錄，即當前python腳本工做的目錄路徑
 2 os.chdir("dirname")  改變當前腳本工做目錄；至關於shell下cd
 3 os.curdir  返回當前目錄: ('.')
 4 os.pardir  獲取當前目錄的父目錄字符串名：('..')
 5 os.makedirs('dirname1/dirname2')    可生成多層遞歸目錄
 6 os.removedirs('dirname1')    若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
 7 os.mkdir('dirname')    生成單級目錄；至關於shell中mkdir dirname
 8 os.rmdir('dirname')    刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
 9 os.unlink(path) 刪除文件路徑
10 os.utime(path, times)返回指定的path文件的訪問和修改的時間。
11 os.listdir('dirname')    列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
12 os.remove()  刪除一個文件
13 os.rename("oldname","newname")  重命名文件/目錄
14 os.stat('path/filename')  獲取文件/目錄信息
15 os.sep    輸出操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
16 os.linesep    輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
17 os.pathsep    輸出用於分割文件路徑的字符串
18 os.name    輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
19 os.path.abspath(path)  返回path規範化的絕對路徑
20 os.path.split(path)  將path分割成目錄和文件名二元組返回
21 os.path.dirname(path)  返回path的目錄。其實就是os.path.split(path)的第一個元素
22 os.path.basename(path)  返回path最後的文件名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
23 os.path.exists(path)  若是path存在，返回True；若是path不存在，返回False
24 os.path.isabs(path)  若是path是絕對路徑，返回True
25 os.path.isfile(path)  若是path是一個存在的文件，返回True。不然返回False
26 os.path.isdir(path)  若是path是一個存在的目錄，則返回True。不然返回False
27 os.path.join(path1[, path2[, ...]])  將多個路徑組合後返回，第一個絕對路徑以前的參數將被忽略
28 os.path.getatime(path)  返回path所指向的文件或者目錄的最後存取時間
29 os.path.getmtime(path)  返回path所指向的文件或者目錄的最後修改時間

os文件和目錄操做

 　  由於OS針對文件和目錄的操做衆多，更多方法請點擊這裏,官方介紹

做者：北京小遠
出處：http://www.cnblogs.com/bj-xy/ 本文版權歸做者和博客園共有，歡迎轉載，但未經做者贊成必須在文章頁面明顯位置給出原文鏈接，不然保留追究法律責任的權利。