Python基礎數據類型
一、 Number（數字）
1.1、數字類型的創建
a = 1
b = a
b = 2
print(a) #1
print(b) #2
#注意：這裏的b = a ,並不是和a指向同一個內存地址，而是把a的值複製給b，
#b = 2是重新給b賦值，會把前面的值覆蓋掉
1.2、Number 類型轉換
var1 = 3.14
var2 = 4
var3 = int(var1) #將浮點型轉換成整型
var4 = float(var2) #將整型轉換成浮點型
print(var3,var4)
1.3、Python內置數學函數
abs(x) #返回數字的絕對值，如abs(-1) 返回 1
ceil(x) #返回數字的上入整數，如math.ceil(4.1) 返回 5
cmp(x, y) #如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
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
二、 字符串類型（string）
字符串是以單引號或雙引號括起來的任意文本，比如’abcdef’，“1234567890”
注意：’’或“”本身只是一種表示方式，不是主非常的一部分，因此，字符串’abc’只有a,b,c這3個字符，如果’本身也是一個字符，那就可以用””括起來，比如“I’m OK”
2.1、創建字符串
var1 = 'Hello World!'
var2 = "I love you"
對應操作
#1、 * 重複輸出字符串
print('hello' * 2)
#2、 [] ,[:] 通過索引獲取字符串中字符,這裏和列表的切片操作是相同的
str = 'luoxiaolong'
print(str) # 輸出字符串
print(str[0:-1]) # 輸出第一個到倒數第二個的所有字符
print(str[0]) # 輸出字符串第一個字符
print(str[2:5]) # 輸出從第三個開始到第五個的字符
print(str[2:]) # 輸出從第三個開始的後的所有字符
#3、 in 成員運算符
print('olo' in 'luoxiaolong') - 如果字符串中包含給定的字符返回 True
print('olo' not in 'luoxiaolong') - 如果字符串中不包含給定的字符返回 True
# 4、 % 格式字符串
print('I love my family')
print('%s love his family' % 'xiaolong')
# 5、 + 字符串拼接
a = '123'
b = 'abc'
c = '789'
d1 = a + b + c
# 此方法效率低
print(d1)
# + 效率低,該用join
d2 = ''.join([a, b, c])
print(d2)
2.2、string的內置方法
#string.capitalize() 把字符串的第一個字符大寫
# string.center(width) 返回一個原字符串居中,並使用空格填充至長度 width 的新字符串
# string.count(str, beg=0, end=len(string)) 返回 str 在 string 裏面出現的次數，如果 beg 或者 end 指定則返回指定範圍內 str 出現的次數
# string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的編碼格式解碼 string，如果出錯默認報一個 ValueError 的 異 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace'
# string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的編碼格式編碼 string，如果出錯默認報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace'
# string.endswith(obj, beg=0, end=len(string)) 檢查字符串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束，如果是，返回 True,否則返回 False.
# string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符號轉爲空格，tab 符號默認的空格數是 8。
# string.find(str, beg=0, end=len(string)) 檢測 str 是否包含在 string 中，如果 beg 和 end 指定範圍，則檢查是否包含在指定範圍內，如果是返回開始的索引值，否則返回-1
# string.index(str, beg=0, end=len(string)) 跟find()方法一樣，只不過如果str不在 string中會報一個異常.
# string.isalnum() 如果 string 至少有一個字符並且所有字符都是字母或數字則返回 True,否則返回 False
# string.isalpha() 如果 string 至少有一個字符並且所有字符都是字母則返回 True,否則返回 False
# string.isdecimal() 如果 string 只包含十進制數字則返回 True 否則返回 False.
# string.isdigit() 如果 string 只包含數字則返回 True 否則返回 False.
# string.islower() 如果 string 中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是小寫，則返回 True，否則返回 False
# string.isnumeric() 如果 string 中只包含數字字符，則返回 True，否則返回 False
# string.isspace() 如果 string 中只包含空格，則返回 True，否則返回 False.
# string.istitle() 如果 string 是標題化的(見 title())則返回 True，否則返回 False
# string.isupper() 如果 string 中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是大寫，則返回 True，否則返回 False
# string.join(seq) 以 string 作爲分隔符，將 seq 中所有的元素(的字符串表示)合併爲一個新的字符串
# string.ljust(width) 返回一個原字符串左對齊,並使用空格填充至長度 width 的新字符串
# string.lower() 轉換 string 中所有大寫字符爲小寫.
# string.lstrip() 截掉 string 左邊的空格
# string.maketrans(intab, outtab]) maketrans() 方法用於創建字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。
# max(str) 返回字符串 str 中最大的字母。
# min(str) 返回字符串 str 中最小的字母。
# string.partition(str) 有點像 find()和 split()的結合體,從 str 出現的第一個位置起,把 字 符 串 string 分 成 一 個 3 元 素 的 元 組 (string_pre_str,str,string_post_str),如果 string 中不包含str 則 string_pre_str == string.
# string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.
# string.rfind(str, beg=0,end=len(string) ) 類似於 find()函數，不過是從右邊開始查找.
# string.rindex( str, beg=0,end=len(string)) 類似於 index()，不過是從右邊開始.
# string.rjust(width) 返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串
# string.rpartition(str) 類似於 partition()函數,不過是從右邊開始查找.
# string.rstrip() 刪除 string 字符串末尾的空格.
# string.split(str="", num=string.count(str)) 以 str 爲分隔符切片 string，如果 num有指定值，則僅分隔 num 個子字符串
# string.splitlines(num=string.count('\n')) 按照行分隔，返回一個包含各行作爲元素的列表，如果 num 指定則僅切片 num 個行.
# string.startswith(obj, beg=0,end=len(string)) 檢查字符串是否是以 obj 開頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定範圍內檢查.
# string.strip([obj]) 在 string 上執行 lstrip()和 rstrip()
# string.swapcase() 翻轉 string 中的大小寫
# string.title() 返回"標題化"的 string,就是說所有單詞都是以大寫開始，其餘字母均爲小寫(見 istitle())
# string.translate(str, del="") 根據 str 給出的表(包含 256 個字符)轉換 string 的字符,要過濾掉的字符放到 del 參數中
# string.upper() 轉換 string 中的小寫字母爲大寫`在這裏插入代碼片`
三、 字節類型（bytes）
a = bytes('中國', 'utf8')
b = bytes('hello', 'gbk')
print(a) # b'\xe4\xb8\xad\xe5\x9b\xbd'
print(ord('h')) # 其十進制 unicode 值爲: 104
print(ord('中')) # 其十進制 unicode 值爲:20013
# h e l l o
# 104 101 108 108 111 編碼後結果:與ASCII表對應
# 中 國
# \xd6\xd0 \xb9\xfa gbk編碼後的字節結果
# \xe4 \xb8 \xad \xe5 \x9b \xbd utf8編碼後的字節結果
# 228 184 173 229 155 189 a[:]切片取
c = a.decode('utf8')
d = b.decode('gbk')
# b=a.decode('gbk') :很明顯報錯
print(c) # 中國
print(d) # hello
#注意：對於 ASCII 字符串，因爲無論哪種編碼對應的結果都是一樣的，所以可以直接使用 b'xxxx' 賦值創建 bytes 實例，但對於非 ASCII 編碼的字符則不能通過這種方式創建bytes實例，需要指明編碼方式。
b1=b'123'
print(type(b1))
# b2=b'中國' #報錯
# 所以得這樣:
b2=bytes('中國','utf8')
print(b2) #b'\xe4\xb8\xad\xe5\x9b\xbd'
四、 布爾值
一個布爾值只有True、False兩種值，要麼是True，要麼是False，在Python中，可以直接用True，False表示布爾值（請注意大小寫），且0代表的是False，1代表的是True
print(True)
print(4>2) #True
print(bool([3,4])) #True
print(True+1) #2
與或非操作：
bool(1 and 0)
bool(1 and 1)
bool(1 or 0)
bool(not 0)
布爾值經常用在條件判斷中：
age=18
if age>18:#bool(age>18)
print('old')
else:
print('young')
五、 List(列表)
什麼是列表：List（列表） 是 Python 中使用最頻繁的數據類型。
列表可以完成大多數集合類的數據結構實現。列表中元素的類型可以不相同，它支持數字，字符串甚至可以包含列表（所謂嵌套）。
列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。
列表是可變的（mutable）——可以改變列表的內容。
a = [1,2,3,a,b,c]
b,*c=[1,2,3,4,5]
d = a*2
print(a)
print(b)
print(*c)
print(d)
對應操作
1、 查( [ ] ) ：切片
names_class2=['張三','李四','王五','趙六']
print(names_class2[2])
print(names_class2[0:3])
print(names_class2[0:7])
print(names_class2[-1])
print(names_class2[2:3])
print(names_class2[0:3:1])
print(names_class2[3:0:-1])
print(names_class2[:])
2、 增( append，insert)
#insert方法用於將對象插入到列表中，append方法則用於在列表末尾追加新的對象
names_class2.append('alex')
names_class2.insert(2,'alvin')
print(names_class2)
3、 改（重新賦值）
names_class2=['張三','李四','王五','趙六']
names_class2[3]='趙七'
names_class2[0:2]=['wusir','alvin']
print(names_class2)
4、 刪（remove,del,pop,clear）
#使用pop()方法刪除元素：pop方法用於移出列表中的一個元素（默認是最後一個元素），也可以指定元素索引，並且返回該元素的值。
#使用del語句刪除元素：如果知道要刪除的元素在列表中的位置，可使用del語句刪除元素，元素一旦被刪除之後就再無法訪問，同時也可以刪除切片
#使用remove()方法刪除元素：當不知道元素索引，只知道元素值的時候，使用remove()方法刪除元素
t = ['a','b','c','d','e']
t.remove('a') #t.remove(a[0])
print(t)
t.pop(1)
print(t)
a = t.pop(0)
print(a)
b = ['a','b','c','d','e']
del b[0]
print(b)
del b #直接把整個列表刪除
print(b)
5、 其他操作
5.1、 count
#count方法統計某個元素在列表中出現的次數
t = ["a","a","b","c","d"]
print(t.count("a"))
5.2、 extend
#extend方法可以在列表的末尾一次性追加另一個序列中的多個值
#extend 方法修改了被擴展的列表，而原始的連接操作（+）則不然，它會返回一個全新的列表。
a = [1,2,3]
b = [4,5,6]
a.extend(b)
print(a)
print(b)
5.3、 index
#index方法用於從列表中找出某個值第一個匹配項的索引位置：
a = [1,2,3,4,5,6,7,8,9]
print(a.index(1))
5.4、reverse
#reverse方法將列表中的元素反向存放。
t = ["a","b","c","d"]
t.reverse()
print(t)
#5.5、sort
#sort()：永久性地修改了列表元素排列順序（按照ASSCII編碼來進行排序的）。再也無法恢復到原來的排列順序，
#也可以使用sort(reverse=True) 對列表進行倒序排序
x = [5,7,3,8,4]
x.sort()
print(x)
x.sort(reverse=True) #使列表從大到小排序
print(x)
5.6、深淺拷貝
names_class = ['張三', '李四', '王五', '趙六', [1, 2, 3]]
names_class_copy = names_class.copy()
names_class[0] = 'zhangsan'
print(names_class)
print(names_class_copy)
names_class[4][2] = 5
print(names_class)
print(names_class_copy)
#從names_class_copy和names_class的結果來看，我們可以斷定,這兩個變量並不是完全獨立的,那他們的關係是什麼呢?爲什麼有的改變,有的不改變呢?
#這裏就涉及到了深淺拷貝了
#注意：不可變數據類型：數字，字符串，元組 可變類型：列表，字典
l=[2,2,3]
print(id(l))
l[0]=5
print(id(l)) # 當你對可變類型進行修改時,比如這個列表對象l,它的內存地址不會變化,注意是這個列表對象l,不是它裏面的元素
s='alex'
print(id(s)) #像字符串,列表,數字這些不可變數據類型,,是不能修改的,比如我想要一個'Alex'的字符串,只能重新創建一個'Alex'的對象,然後讓指針只想這個新對象
# s[0]='e' #報錯
# print(id(s))
# 重點:淺拷貝
a = [[1, 2], 3, 4]
b = a[:] # b=a.copy()
print(a, b)
print(id(a), id(b))
print('*************')
print('a[0]:', id(a[0]), 'b[0]:', id(b[0]))
print('a[0][0]:', id(a[0][0]), 'b[0][0]:', id(b[0][0]))
print('a[0][1]:', id(a[0][1]), 'b[0][1]:', id(b[0][1]))
print('a[1]:', id(a[1]), 'b[1]:', id(b[1]))
print('a[2]:', id(a[2]), 'b[2]:', id(b[2]))
print('___________________________________________')
b[0][0] = 8
print(a, b)
print(id(a), id(b))
print('*************')
print('a[0]:', id(a[0]), 'b[0]:', id(b[0]))
print('a[0][0]:', id(a[0][0]), 'b[0][0]:', id(b[0][0]))
print('a[0][1]:', id(a[0][1]), 'b[0][1]:', id(b[0][1]))
print('a[1]:', id(a[1]), 'b[1]:', id(b[1]))
print('a[2]:', id(a[2]), 'b[2]:', id(b[2])) < br > < br > < br > # outcome
#這個結果自己去執行一下就行了，原理：如下圖
七 Dictionary(字典)
字典是python中唯一的映射類型，採用鍵值對（key-value）的形式存儲數據。python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數字、字符串、元組。
字典(dictionary)是除列表意外python之中最靈活的內置數據結構類型。列表是有序的對象結合，字典是無序的對象集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
創建字典：
dic1={'name':'alex','age':36,'sex':'male'}
dic2=dict((('name','alex'),))
print(dic1)
print(dic2)
對應操作：
1、增
dic3={}
dic3['name']='alex'
dic3['age']=18
print(dic3)#{'name': 'alex', 'age': 18}
a=dic3.setdefault('name','yuan')
b=dic3.setdefault('ages',22)
print(a,b)
print(dic3)
2、查
dic3={'name': 'alex', 'age': 18}
# print(dic3['name'])
# print(dic3['names'])
# print(dic3.get('age',False))
# print(dic3.get('ages',False))
print(dic3.items())
print(dic3.keys())
print(dic3.values())
print('name' in dic3)# py2: dic3.has_key('name')
print(list(dic3.values()))
3、改
dic3={'name': 'alex', 'age': 18}
dic3['name']='alvin'
dic4={'sex':'male','hobby':'girl','age':36}
dic3.update(dic4)
print(dic3)
4、刪
dic4={'name': 'alex', 'age': 18,'class':1}
# dic4.clear()
# print(dic4)
del dic4['name']
print(dic4)
a=dic4.popitem()
print(a,dic4)
# print(dic4.pop('age'))
# print(dic4)
# del dic4
# print(dic4)
5、其他操作以及涉及到的方法
5.1 dict.fromkeys
d1=dict.fromkeys(['host1','host2','host3'],'Mac')
print(d1)
d1['host1']='xiaomi'
print(d1)
#######
d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])
print(d2)
d2['host1'][0]='xiaomi'
print(d2)
5.2 d.copy() 對字典 d 進行淺複製，返回一個和d有相同鍵值對的新字典
5.3 字典的嵌套
company = {
"騰訊":{
"王者榮耀": ["騰訊最火的一款手遊之一","沒錢玩個錘子"],
"和平精英": ["騰訊光子工作室","沒玩過，不知道"],
"微信": ["你說你不用我還真不信","中國主流的信息交流軟件"],
},
"網易":{
"網易雲音樂":["總體來說非常不錯","有些是收費的"]
}
}
company["網易"]["網易雲音樂"][1] += ",在網頁上可以下載一些收費的"
print(company["網易"]["網易雲音樂"])
5.4 sorted(dict) : 返回一個有序的包含字典所有key的列表
dic={5:'555',2:'222',4:'444'}
print(sorted(dic))
5.5 字典的遍歷
dic5={'name': 'alex', 'age': 18}
for i in dic5:
print(i,dic5[i])
for items in dic5.items():
print(items)
for keys,values in dic5.items():
print(keys,values)
# 還用我們上面的例子，存取這個班學生的信息，我們如果通過字典來完成，那：
dic={'zhangsan':{'age':23,'sex':'male'},
'李四':{'age':33,'sex':'male'},
'wangwu':{'age':27,'sex':'women'}
}
八 Set（集合）
集合是一個無序的，不重複的數據組合，它的主要作用如下：
去重，把一個列表變成集合，就自動去重了
關係測試，測試兩組數據之前的交集、差集、並集等關係
集合(set)：把不同的元素組成一起形成集合，是python基本的數據類型。
集合元素(set elements):組成集合的成員(不可重複)
li=[1,2,'a','b']
s =set(li)
print(s) # {1, 2, 'a', 'b'}
li2=[1,2,1,'a','a']
s=set(li2)
print(s) #{1, 2, 'a'}
集合對象是一組無序排列的可哈希的值：集合成員可以做字典的鍵
li=[[1,2],'a','b']
s =set(li) #TypeError: unhashable type: 'list'
print(s)
集合分類：可變集合、不可變集合
可變集合(set)：可添加和刪除元素，非可哈希的，不能用作字典的鍵，也不能做其他集合的元素
不可變集合(frozenset)：與上面恰恰相反
li=[1,'a','b']
s =set(li)
dic={s:'123'} #TypeError: unhashable type: 'set'
集合的相關操作
1、創建集合
由於集合沒有自己的語法格式，只能通過集合的工廠方法set()和frozenset()創建
s1 = set('alvin')
s2= frozenset('yuan')
print(s1,type(s1)) #{'l', 'v', 'i', 'a', 'n'} <class 'set'>
print(s2,type(s2)) #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'
2、訪問集合
由於集合本身是無序的，所以不能爲集合創建索引或切片操作，只能循環遍歷或使用in、not in來訪問或判斷集合元素。
s1 = set('alvin')
print('a' in s1)
print('b' in s1)
#s1[1] #TypeError: 'set' object does not support indexing
for i in s1:
print(i)
# 打印如下
# True
# False
# v
# n
# l
# i
# a
3、更新集合
可使用以下內建方法來更新：
s.add()
s.update()
s.remove()
注意只有可變集合才能更新：
s2=set('alvin')
s2.add('mm')
print(s2) #{'mm', 'l', 'n', 'a', 'i', 'v'}
s2.update('HO')#添加多個元素
print(s2) #{'mm', 'l', 'n', 'a', 'i', 'H', 'O', 'v'}
s2.remove('l')
print(s2) #{'mm', 'n', 'a', 'i', 'H', 'O', 'v'}
4、del：刪除集合本身
四、集合類型操作符
1 in ,not in
2 集合等價與不等價(==, !=)
3 子集、超集
s=set('alvinyuan')
s1=set('alvin')
print('v' in s)
print(s1<s)
4 聯合(|)
聯合(union)操作與集合的or操作其實等價的，聯合符號有個等價的方法，union()。
s1=set('alvin')
s2=set('yuan')
s3=s1|s2
print(s3) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
print(s1.union(s2)) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
5、交集(&)
與集合and等價，交集符號的等價方法是intersection()
s1=set('alvin')
s2=set('yuan')
s3=s1&s2
print(s3) #{'n', 'a'}
print(s1.intersection(s2)) #{'n', 'a'}
6、差集(-) 等價方法是difference()
s1=set('alvin')
s2=set('yuan')
s3=s1-s2
print(s3) #{'v', 'i', 'l'}
print(s1.difference(s2)) #{'v', 'i', 'l'}
7、對稱差集(^)
對稱差分是集合的XOR(‘異或’)，取得的元素屬於s1,s2但不同時屬於s1和s2.其等價方法symmetric_difference()
s1=set('alvin')
s2=set('yuan')
s3=s1^s2
print(s3) #{'l', 'v', 'y', 'u', 'i'}
print(s1.symmetric_difference(s2)) #{'l', 'v', 'y', 'u', 'i'}
8、應用
'''最簡單的去重方式'''
lis = [1,2,3,4,1,2,3,4]
print list(set(lis)) #[1, 2, 3, 4]
九、文件操作
9.1 對文件操作流程
- 打開文件，得到文件句柄並賦值給一個變量
- 通過句柄對文件進行操作
- 關閉文件
現有文件《鬼知道》如下：
海底撈哥
烏鴉坐飛機
腦袋砸核桃
暴龍展翅飛翔
龍捲風摧毀停車場
大象踩老鼠
大象踢腿
f = open('鬼知道','r',encoding='utf8') # 打開文件
data = f.read() # 獲取文件內容
data1 = f.read(5)
print(data)
print(data1)
f.close() # 關閉文件
注意 if in the win，hello文件是utf8保存的，打開文件時open函數是通過操作系統打開的文件，而win操作系統
默認的是gbk編碼，所以直接打開會亂碼，需要f=open(‘hello’,encoding=‘utf8’)，hello文件如果是gbk保存的，則直接打開即可。
9.2 文件打開模式
模式 描述
t 文本模式 (默認)。
x 寫模式，新建一個文件，如果該文件已存在則會報錯。
b 二進制模式。
+ 打開一個文件進行更新(可讀可寫)。
U 通用換行模式（Python 3 不支持）。
r 以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。
rb 以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。一般用於非文本文件如圖片等。
r+ 打開一個文件用於讀寫。文件指針將會放在文件的開頭。
rb+ 以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。一般用於非文本文件如圖片等。
w 打開一個文件只用於寫入。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。
wb 以二進制格式打開一個文件只用於寫入。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。一般用於非文本文件如圖片等。
w+ 打開一個文件用於讀寫。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。
wb+ 以二進制格式打開一個文件用於讀寫。如果該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。如果該文件不存在，創建新文件。一般用於非文本文件如圖片等。
a 打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之後。如果該文件不存在，創建新文件進行寫入。
ab 以二進制格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容之後。如果該文件不存在，創建新文件進行寫入。
a+ 打開一個文件用於讀寫。如果該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。如果該文件不存在，創建新文件用於讀寫。
ab+ 以二進制格式打開一個文件用於追加。如果該文件已存在，文件指針將會放在文件的結尾。如果該文件不存在，創建新文件用於讀寫。
先介紹三種最基本的模式：
f = open('鬼知道2','w',encoding='utf8') #打開文件
f = open('鬼知道2','a',encoding='utf8') #打開文件
f.write('羚羊起跳1\n')
f.write('電眼逼人2\n')
f.write('蠍子掌')
9.3 、文件具體操作
f = open('鬼知道','r',encoding='utf8') #打開文件
data1=f.read()#獲取文件內容
data2=f.read()#獲取文件內容
print(data1)
print('...',data2)
#data=f.readline()
for i in range(5):
print(f.readline())
#data=f.readlines()
for line in f.readlines():
print(line)
# 問題來了:打印所有行,另外第3行後面加上:'end 3'
for index,line in enumerate(f.readlines()):
if index==2:
line=''.join([line.strip(),'end 3'])
print(line.strip())
#切記:以後我們一定都用下面這種
count=0
for line in f:
if count==3:
line=''.join([line.strip(),'end 3'])
print(line.strip())
count+=1
print(f.tell())
print(f.readline())
print(f.tell())#tell對於英文字符就是佔一個,中文字符佔三個,區分與read()的不同.
print(f.read(5))#一箇中文佔三個字符
print(f.tell())
f.seek(0)
print(f.read(6))#read後不管是中文字符還是英文字符,都統一算一個單位,read(6),此刻就讀了6箇中文字符
#terminal上操作:
f = open('鬼知道2','w',encoding='utf8')
f.write('hello \n')
f.flush()
f.write('world')
# 應用:進度條
import time,sys
for i in range(30):
sys.stdout.write("*")
# sys.stdout.flush()
time.sleep(0.1)
#file.truncate([size])：從文件的首行首字符開始截斷，截斷文件爲 size 個字符，無 size 表示從當前位置截斷；截斷之後後面的所有字符被刪除，其中 Widnows 系統下的換行代表2個字符大小。
f = open('鬼知道2','w',encoding='utf8')
f.truncate()#全部截斷
f.truncate(5)
print(f.isatty()) #如果文件連接到一個終端設備返回 True，否則返回 False。
print(f.seekable())
print(f.readable()) #判斷是否可讀
f.close()
#接下來我們繼續擴展文件模式：
f = open('鬼知道2','w',encoding='utf8') #打開文件
f = open('鬼知道2','a',encoding='utf8') #打開文件
f.write('羚羊起跳1\n')
f.write('電眼逼人2\n')
f.write('蠍子掌')
f.close()
#r+,w+模式
f = open('鬼知道2','r+',encoding='utf8') #以讀寫模式打開文件
print(f.read(5))#可讀
f.write('hello')
print('------')
print(f.read())
f = open('鬼知道2','w+',encoding='utf8') #以寫讀模式打開文件
print(f.read(5))#什麼都沒有,因爲先格式化了文本
f.write('hello alex')
print(f.read())#還是read不到
f.seek(0)
print(f.read())
#w+與a+的區別在於是否在開始覆蓋整個文件
# ok,重點來了,我要給文本第三行後面加一行內容:'你好，我是黑虎阿福'
# 有同學說,前面不是做過修改了嗎? 大哥,剛纔是修改內容後print,現在是對文件進行修改!!!
f = open('鬼知道2','r+',encoding='utf8') #以寫讀模式打開文件
f.readline()
f.readline()
f.readline()
print(f.tell())
f.write('你好，我是黑虎阿福')
f.close()
# 和想的不一樣,不管事!那涉及到文件修改怎麼辦呢?
f_read = open('鬼知道','r',encoding='utf8') #以寫讀模式打開文件
f_write = open('鬼知道_back','w',encoding='utf8') #以寫讀模式打開文件
count=0
for line in f_read:
if count==3:
f_write.write('你好，我是黑虎阿福\n')
else:
f_write.write(line)
another way:
if count==3:
line='你好，我是黑虎阿福\n'
f_write.write(line)
count+=1
# #二進制模式
f = open('鬼知道2','wb',encoding='utf8') #以二進制的形式讀文件
# f = open('鬼知道2','wb',encoding='utf8') #以二進制的形式寫文件
f.write('hello alvin!'.encode())#b'hello alvin!'就是一個二進制格式的數據
#注意1: 無論是py2還是py3，在r+模式下都可以等量字節替換，但沒有任何意義的！
#注意2：有同學在這裏會用readlines得到內容列表，再通過索引對相應內容進行修改，最後將列表重新寫會該文件。
#這種思路有一個很大的問題，數據若很大，你的內存會受不了的，而我們的方式則可以通過迭代器來優化這個過程。
補充：rb模式以及seek
在py2中：
test：龍捲風摧毀停車場
f = open('test','r',encoding='utf8') #以寫讀模式打開文件
f.read(3)
f.seek(3)
print f.read(3)
f.seek(3,1)
print f.read(3)
f.seek(-4,2)
print f.read(3)
在py3中：
test： 龍捲風摧毀停車場
f = open('test','rb',encoding='utf8') #以寫讀模式打開文件
f.read(3)
f.seek(3)
print(f.read(3)) # b'\xe5\xa4\x9c'
f.seek(3,1)
print(f.read(3)) # b'\xe5\xaf\x92'
f.seek(-4,2)
print(f.read(3)) # b'\xe9\xb8\xa3'
總結: 在py3中,如果你想要字符數據,即用於觀看的,則用r模式,這樣我f.read到的數據是一個經過decode的
unicode數據; 但是如果這個數據我並不需要看,而只是用於傳輸,比如文件上傳,那麼我並不需要decode
直接傳送bytes就好了,所以這個時候用rb模式.
在py3中,有一條嚴格的線區分着bytes和unicode,比如seek的用法,在py2和py3裏都是一個個字節的seek,
但在py3裏你就必須聲明好了f的類型是rb,不允許再模糊.
建議: 以後再讀寫文件的時候直接用rb模式,需要decode的時候仔顯示地去解碼.
9.4、 with語句
爲了避免打開文件後忘記關閉，可以通過管理上下文，即：
with open('log','r',encoding=’utf8’) as f:
pass
如此方式，當with代碼塊執行完畢時，內部會自動關閉並釋放文件資源。
在Python 2.7 後，with又支持同時對多個文件的上下文進行管理，即：
with open('log1','r',encoding='utf8') as obj1, open('log2','r',encoding='utf8') as obj2:
pass
可能有些地方沒有非常的注意，出了一些錯，或者有些重點沒有寫上去，希望大家多多指點