python03-break、continue、for循環、數據bytes類型、字符串與字節的關係、變量指向與深淺拷貝、set集合、文件操做
目錄：python
2.for循環app
5.變量指向與深淺拷貝spa
6.set集合指針
7.文件操做code
break 語句，break 語句用於跳出當前循環體blog
continue語句，跳過當前循環塊中的剩餘語句，而後繼續進行下一輪循環
pass 語句是空語句，是爲了保持程序結構的完整性，pass 不作任何事情，通常用作佔位語句
Python for循環能夠遍歷任何序列的項目，如一個列表或者一個字符串。
for循環的通常格式以下：
for 變量接收名 in 對象 :
代碼示例：
1 list1 = ["one","two","three",4] 2 for i in list1: 3 print(i)
輸出結果：
one
two
three
4
For循環時加上序號enumerate：
1 list1 = ["手機","電腦","ipad"] 2 for i,v in enumerate(list1,1): #表示遍歷list1這個列表，序號從1開始。
3 print(i,v)
輸出結果：
1 手機
2 電腦
3 ipad
循環語句能夠有 else 子句，它在窮盡列表(以for循環)或條件變爲 false (以while循環)致使循環終止時被執行,但循環被break終止時不執行，簡而言之就是break後不會執行下級的else（注意break的級別）
range()函數
若是你須要遍歷數字序列，可使用內置range()函數，它會生成數列。
range(起始值,終止值，步長)這裏是左閉右開區間，能夠取到起始值，可是取不到終止值，只能取到終止值的前一個，步長就是遍歷時的距離，默認是。
代碼示例：
1 for i in range(5,1,-1): 2 print(i)
輸出結果：
5
4
3
2
range的組和用法：
能夠結合range()和len()函數以遍歷一個序列的索引：
1 list1 = ["手機","電腦","ipad"] 2 for i in range(len(list1)): #len是從1開始，range沒寫參數是從0開始
3 print(i,list1[i])
輸出結果：
0 手機
1 電腦
2 ipad
表現形式：name = b」baby」
內部原理
Utf-8編碼下：
01100010 b
01100001 a
01111001 y
若是是字符串類型的baby，那默認是Unicode，一字符佔4個字節
若是有中文：
表現形式：b'\xe5\xa4\xa9\xe4\xb8\x8b'（「天下「的表現形式）
\x表示16進制
Utf-8編碼下：
例如：\xe5表示00100101，其中e前四位，5後四位
由於是前四位，一共16中變換形式，因此用16進制恰好能夠表現（\x）
因此\xe5 正確的表現形式是 1110 0101（就是十六進制和二進制的轉換）
內存：
00000000 00000000 00000000 01010100 unicode A
01010100 utf-8 A
01010100 01010100 gbk A
01010000 00000100 gb2312 A
... …
硬盤：
01010100 utf-8 A
01010100 utf-8 A
01010100 gbk A
01010100 gb2312 A
... ...
本質上，內存中都是010101，具體是什麼樣子的010101，須要根據編碼來決定。不一樣編碼的010101，互相不認識。
在python3裏:
默認解釋器的編碼：utf-8 -> 010101010101
特殊的：
字符串（str）：
表現： a = "alex"
本質： 01010101，unicode
字節（bytes）：
表現： a = b"alex"
本質： 01010101，某種編碼： utf-8,gbk,.....
總結：
python3：
str --> uniocde
bytes --> gbk,utf-8.....
字符串類型的表現形式是 name = 「baby」 默認是用Unicode編碼的，當字符串須要網絡傳輸或者硬盤儲存時，須要將Unicode編碼的str準換爲其餘編碼的bytes，以節省空間。
5.1變量指向：
1 1 name = "zrh"
2 2 name1 = name 3 3 print(name,name1) 4 4 name = "zrh1"
5 5 print(name,name1) 6 #輸出結果
7 #zrh zrh
8 #zrh1 zrh
內部原理：
name1經過name指向zrh，此時name1的值就是zrh後面即便name改變爲zrh1，name1的值也不會改變。
5.2列表指向：
1 list1 = [1,2,3] 2 list2 = list1 3 list1.append(4) 4 print(list1,list2) 5 #輸出結果：[1, 2, 3, 4] [1, 2, 3, 4]
內部原理：
list2經過list1指向【1，2，3】，此時list2的值就是【1，2，3】，append直接改變的是值，因此list1和list2都改變了。
5.3深淺拷貝
淺拷貝：只拷貝第一層，其餘都指向同一數據
深拷貝：無論裏面有多少嵌套，都會拷貝下來
深淺拷貝只有存在嵌套時纔會有異同
內存原理：
公式格式：
1 list1 = [1,[2,3],4] 2 #淺拷貝
3 list2 = list1.copy() 4 #深拷貝
5 import copy 6 list3 = copy.deepcopy(list1)
注意：
list3最後一層是python爲了節省內存才直接指向list1的數據，因此list1改變數據，是重新開闢出一塊新的內存讓list1指向，list3不變。
1 list1 = [1,[2,3],4] 2 #深拷貝
3 import copy 4 list3 = copy.deepcopy(list1) 5 list1[0] = 0 6 print(list3[0]) 7 #輸出結果： 1
集合（set）是一個無序的不重複元素序列。
可使用大括號 { } 或者 set() 函數建立集合，注意：建立一個空集合必須用 set() 而不是 { }，由於 { } 是用來建立一個空字典。
1 list1 = [] #等價於list1 = list()
2 tuple1 = () #等價於tuple1 = tuple()
3 dict1 = {} #等價於dict1 = dict()
4 #s因此建立集合是 set()
集合裏的元素必須是不可變的
set1 = {「1」，「zrh」,[1,2,3]}這樣就會報錯，由於列表是可變的
不可變類型：整型、字符串、元組
可變類型：字典、列表
集合也能夠for循環，集合不能夠經過索引來取值，由於集合無序。
建立格式：
1 parame1 = {"one","two","three"} #建立方法1
2 a = set("apple") #建立方法2
3 print(parame1,a) 4 #打印結果{'two', 'three', 'one'}集合無序的；
5 #{'l', 'p', 'a', 'e'}由於是不能重複的，因此只有一個a
Set內置方法：
| 方法 |
描述 |
| add() |
爲集合添加元素（無返回值） |
| clear() |
移除集合中的全部元素（無返回值） |
| copy() |
拷貝一個集合（無返回值） |
| difference() |
返回多個集合的差集（返回一個新的集合） |
| difference_update() |
方法用於移除兩個集合中都存在的元素（無返回值） |
| discard() |
刪除集合中指定的元素（無返回值）刪除元素不存在不會報錯 |
| intersection() |
返回集合的交集（返回一個新的集合） |
| intersection_update() |
更新指定集合爲指定集合和參數集合的交集（無返回值） |
| isdisjoint() |
判斷兩個集合是否無交集，若是沒有返回 True，不然返回 False（返回布爾值 ） |
| issubset() |
判斷指定集合是否爲該方法參數集合的子集（返回布爾值 ） |
| issuperset() |
判斷該方法的參數集合是否爲指定集合的子集（返回布爾值 ） |
| pop() |
隨機移除元素（返回移除的元素） |
| remove() |
移除指定元素（返回移除的元素）刪除的元素不存在會報錯 |
| symmetric_difference() |
返回兩個集合中不重複的元素集合（返回一個新的集合） |
| symmetric_difference_update() |
移除當前集合中在另一個指定集合相同的元素，並將另一個指定集合中不一樣的元素插入到當前集合中（無返回值） |
| union() |
返回兩個集合的並集（返回一個新的集合） |
| update() |
給集合添加元素（無返回值） |
Set內置方法部分應用舉例：
1 #1.add() 添加 參數必須是字符串
2 name = {'one','two','three','four','five'} 3 a = name.add('six') #括號內的元素只能填一個，而且要維護集合元素永不重複
4 print(a) #輸出結果：None 說明add不可返回值，直接修改的是集合
5 print(name) #輸出結果：{'four', 'five', 'three', 'six', 'one', 'two'}
6 #2.update() 添加更新 參數能夠是列表，元組，字典，集合等
7 name = {'one','two','three','four','five'} 8 a = name.update(['six','seven']) 9 print(a) #輸出結果：None 說明update不可返回值，直接修改的是集合
10 print(name) #輸出結果：{'three', 'seven', 'four', 'six', 'one', 'two', 'five'}
11 #3. difference() 用於計算差集
12 #difference() 方法用於返回集合的差集，即返回的集合元素包含在第一個集合中，但不包含在第二個#集合(方法的參數)中。
13 name = {'one','two','three','four','five'} 14 name1 = {'five','six','seven'} 15 a = name.difference(name1) #name中存在，name1中不存在，建立新變量，name name1值不變
16 print(a) #輸出結果：{'three', 'four', 'one', 'two'}
17 #4. difference_update() 方法用於移除兩個集合中都存在的元素。
18 #difference_update() 方法與 difference() 方法的區別在於 difference() 方法返回一個移除相同元素的新集合，
而 difference_update() 方法是直接在原來的集合中移除元素，沒有返回值。
19 name = {'one','two','three','four','five'} 20 name1 = {'five','six','seven'} 21 a = name.difference_update(name1) #在name中刪除name1中存在的值
22 print(a) #輸出結果：None 沒有返回值
23 print(name) #輸出結果：{'four', 'two', 'three', 'one'}
24 快速去重：利用集合元素不重複的方法 25 name = ['one','two','five','three','four','five'] 26 val = set(name) #將列表轉換爲集合格式
27 print(val) #{'four', 'two', 'five', 'one', 'three'}
文件操做三要素：
1. 路徑：D:\\name.txt
2. 編碼：utf-8或gbk等
3. 模式：
| x |
寫模式，新建一個文件，若是該文件已存在則會報錯。 |
| b |
二進制模式。即bytes |
| + |
打開一個文件進行更新(可讀可寫)。 |
| r |
以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。 |
| rb |
以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。通常用於非文本文件如圖片等。 |
| r+ |
打開一個文件用於讀寫。文件指針將會放在文件的開頭。經常使用 |
| rb+ |
以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。通常用於非文本文件如圖片等。 |
| w |
打開一個文件只用於寫入。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。 |
| wb |
以二進制格式打開一個文件只用於寫入。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。通常用於非文本文件如圖片等。 |
| w+ |
打開一個文件用於讀寫。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。 |
| wb+ |
以二進制格式打開一個文件用於讀寫。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。通常用於非文本文件如圖片等。 |
| a |
打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。 |
| ab |
以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。 |
| a+ |
打開一個文件用於讀寫。若是該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。若是該文件不存在，建立新文件用於讀寫。 |
| ab+ |
以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。若是該文件不存在，建立新文件用於讀寫。 |
只讀模式r：
1.
1 obj = open('D:\\name.txt',encoding='utf-8',mode='r') #\\中的第一個\表示轉義符
2 # 文件路徑 編碼格式 模式
3 content = obj.read() #此時的content是str類型，str在內存上又是Unicode類型
4 # 因此mode = 'r' python內部會把utf-8數據轉換成Unicode類型
5 obj.close()
2.
1 obj = open('D:\\name.txt',mode='rb') 2 # 文件路徑 模式
3 content = obj.read() #此時的content是bytes類型，打印出來是bytes的表現形式
4 obj.close()
總結：
1.文件在硬盤上存儲必定是UTF-8或者GBK等編碼的01
2.rb=原封不動的拿數據，數據此時是某種編碼的01，爲了顯示方便，便會顯示bytes的表現形式
3.r=內部會有轉換，可是必須記住要加編碼格式encoding = ‘utf-8’等
4.encoding是文件以前用什麼編碼保存，就用什麼編碼打開
5.通常狀況下mode = ‘rb’，用bytes的不多，通常用於上傳，下載文件時纔用到
只寫模式w：
寫以前會清空裏面的內容再寫
1.open(文件路徑,mode='wb')
1 count = open('name.txt',mode='wb') 2 count.write("dooble".encode('utf-8')) 3 #wb模式下，往裏存的必須是utf-8等編碼格式，字符串默認是Unicode，因此要轉換成utf-8
4 count.close()
2.open(文件路徑,mode='w',encoding='utf-8')
1 count = open('name.txt',encoding='utf-8',mode='w') 2 count.write('123') #會先清空，再寫，只能寫不能讀
3 count.close()
3.writelines() 將列表的內容寫入文件，參數是個列表
只追加模式a：
追加模式不清空原來文件的內容
1.open(文件路徑,mode='ab')
1 count = open('name.txt',mode='a',encoding='utf-8') 2 count.write("name1") 3 count.close()
2.open(文件路徑,mode='a',encoding='utf-8')
1 count = open('name.txt',mode='ab') 2 count.write("name1".encode('utf-8')) 3 #ab模式下，往裏存的必須是utf-8等編碼格式，字符串默認是Unicode，因此要轉換成utf-8
4 count.close()
r+模式：
1 count = open('name.txt',mode='r+',encoding='utf-8') #r+可讀可寫 w+可寫可讀，寫以前會清空原文件內容，讀的是你寫的內容
2 #此時指針在第一個位置，不跳指針繼續寫會從第一個位置覆蓋
3 count.write("name1") #這樣就直接覆蓋了
4 count.read() #讀到最後,指針此時在最後了
5 count.write("name1") #指針在最後，因而就添加到最後了
6 #要想在第二個位置覆蓋，那須要調整指針
7 count.seek(0) #將指針調整到0位置
8 count.write("2") #此時2就覆蓋了原來在0位置的內容
9 count.close() #關閉文件
r+模式注意事項：
file文件內容：
注意事項一：
1 with open("file",'r+',encoding='utf-8') as file_1: #打開文件時候不清空文件
2 file_1.readline() #讀第一行，指針如今在第一行末尾
3 file_1.write("good") #在執行寫操做的時候，是在文件末尾追加
輸出結果：
注意事項二：
當不執行讀操做的時候，再寫的話默認從開始的位置覆蓋
with open("file",'r+',encoding='utf-8') as file_1: #打開文件時候不清空文件
file_1.write("good") #當不執行讀操做的時候，再寫的話默認從開始的位置覆蓋
輸出結果：
因此在之後的操做中，不要同時讀寫操做一個文件，由於會亂，因此不用「R+」，就單獨的用 r、w、a
文件的功能：
read
1 obj = open('美女.txt',mode='r+',encoding='utf-8') 2 data = obj.read() # 讀取全部文件內容
3 data = obj.read(2) # 在r模式中讀取的2是2個字符；在rb模式中讀取的2是2個字節
4 obj.write('字節或字符串')
seek
1 obj = open('美女.txt',mode='r+',encoding='utf-8') #打開文件時注意該文件是否是用utf-8編碼的
2 obj.seek(2) # 參數2永遠是字節，用來指定指針的位置 utf-8一箇中文3個字節
tell等
1 obj.tell() # 讀取當前指針的位置，讀取到的是字節數
2 obj.writable() #是否可寫，r模式下就不可寫，能夠用變量接收返回值
3 obj.readable() #是否可讀，w模式下就不可讀，能夠用變量接收返回值
flush將內存中內容刷到硬盤
1 count = open('name.txt',mode='r+',encoding='utf-8') 2 while True: 3 val = input(">>>") 4 count.write(val) #給文件裏寫內容
5 count.flush() #強行把內容刷到硬盤，否則文件在循環裏永遠關閉不了
6 count.close()
readline
（readlines()表示讀取整個文件，返回的是一個列表）
1 count = open('name.txt',mode='r+',encoding='utf-8') 2 date = count.readline() 3 print(date) 4 date = count.readline() #在讀第二行的時候，第一行內容是zrh\n，\n也會被讀出來，因此打印的時候中間會多一行間隙
5 print(date) 6 count.close()
打印結果：
zrh
zrh1
zrh2
readline經常使用的一種方法：
count = open('name.txt',mode='r+',encoding='utf-8') for line in count: print(line) #即便文件有80個G，for循環的垃圾回收體制會即時節省內存
truncate
obj.truncate() #截取文件內容，根據指針位置，只保留指針以前數據
注意：寫文件的時候必定記着關閉文件，這裏有一種自動關閉的方法：
with open("name.txt",mode="r+",encoding="utf-8") as count: #as 後面是接收打開文件對象的變量名
#在縮進裏寫代碼內容 #等待運行完代碼後會自動跳出縮進，就自動關閉了
總結：
| file.close() |
| 關閉文件。關閉後文件不能再進行讀寫操做。 |
| file.flush() |
| 刷新文件內部緩衝，直接把內部緩衝區的數據馬上寫入文件, 而不是被動的等待輸出緩衝區寫入。 |
| file.fileno() |
| 返回一個整型的文件描述符(file descriptor FD 整型), 能夠用在如os模塊的read方法等一些底層操做上。 |
| file.isatty() |
| 若是文件鏈接到一個終端設備返回 True，不然返回 False。 |
| file.read([size]) |
| 從文件讀取指定的字節數，若是未給定或爲負則讀取全部。 |
| file.readline([size]) |
| 讀取整行，包括 "\n" 字符。 |
| file.readlines([sizeint]) |
| 讀取全部行並返回列表，若給定sizeint>0，返回總和大約爲sizeint字節的行, 實際讀取值可能比 sizeint 較大, 由於須要填充緩衝區。 |
| file.seek(offset[, whence]) |
| 移動文件讀取指針到指定位置 |
| file.tell() |
| 返回文件指標當前位置。 |
| file.truncate([size]) |
| 從文件的首行首字符開始截斷，截斷文件爲 size 個字符，無 size 表示從當前位置截斷；截斷以後後面的全部字符被刪除，其中 Widnows 系統下的換行表明2個字符大小。 |
| file.write(str) |
| 將字符串寫入文件，返回的是寫入的字符長度。 |
| file.writelines(sequence) |
| 向文件寫入一個序列字符串列表，若是須要換行則要本身加入每行的換行符。 |
文件的刪除和重命名：
import os with open("file",'r+',encoding='utf-8') as file_1: #打開文件時候不清空文件
pass os.remove('file') #刪除file的文件
os.rename('file','file_new') #將文件名file修改成file_new
文件內容的修改：
步驟：
1.先遍歷文件
2.str.replace或者str.split
3.將修改後的全部文件從新寫入一個新文件
4.刪除原來文件
5.將新文件重命名爲原來文件的名字
舉例：
file文件的內容：
需求1：給每一項的第一個 | 前的字母加上 _good
1 import os #導入os模塊
2 file_2 = open("file_new",'w',encoding='utf-8') #以寫模式打開file_new文件，打開以前會清空原文件內容
3 with open("file",'r',encoding='utf-8') as file_1: #以讀模式打開file文件
4 for line in file_1: 5 list_1 = line.split("|") 6 list_1[0] = list_1[0]+"_good"
7 content = '|'.join(list_1) 8 file_2.write(content) #每遍歷一個內容，修改後就寫到file_new裏面
9 file_2.close() 10 os.remove('file') #刪除原來的file文件
11 os.rename('file_new','file') #將file_new文件重命名爲file
輸出結果：
需求2：給zcx後面加上 _good ，其餘保持不變
1 import os #導入os模塊
2 file_2 = open("file_new",'w',encoding='utf-8') #以寫模式打開file_new文件，打開以前會清空原文件內容
3 with open("file",'r',encoding='utf-8') as file_1: #以讀模式打開file文件
4 for line in file_1: 5 list_1 = line.split("|") 6 if list_1[0] == 'zcx': #判斷是否是zcx
7 list_1[0] = list_1[0]+"_good"
8 content = '|'.join(list_1) 9 file_2.write(content) #每遍歷一個內容，修改後就寫到file_new裏面
10 file_2.close() 11 os.remove('file') #刪除原來的file文件
12 os.rename('file_new','file') #將file_new文件重命名爲file
輸出結果：
- 1. Python基礎-字符串、集合類型、判斷、深拷貝與淺拷貝、文件讀寫
- 2. 深淺拷貝 set集合
- 3. 基本數據類型補充 set集合 深淺拷貝
- 4. JS引用類型數據的淺拷貝與深拷貝
- 5. scala_變量、字符串、數據類型
- 6. 循環刪除與深淺拷貝
- 7. 字符串指針和指向字符串的指針變量
- 8. Python中的變量與字符串數據類型
- 9. JavaScript（數據類型、字符串操做）
- 10. 拷貝字符串
- 更多相關文章...
- • Rust 集合與字符串 - RUST 教程
- • PHP 字符串變量 - PHP教程
- • Docker容器實戰(七) - 容器眼光下的文件系統
- • Kotlin學習（二）基本類型
-
每一个你不满意的现在，都有一个你没有努力的曾经。