day3----編碼-集合-深淺copy-文件操作-函數初識

本文檔主要內容：

一 編碼

二 集合

三 深淺copy

四 文件操作

五 函數初識

首先，我們來看看兩個字符串的比較

打開cmd，進入dos界面>>>a='xingchen@'>>>b='xingchen@'>>>print(a==b)    結果為 True>>>print(a is b)    結果為 False上面的兩種結果不一樣為什么?

View Code

這里我們引入id命令，用來測試內存地址

>>> print(id(a))
2138501550128
>>> print(id(b))
2138501550184 #可以看出內存地址不一樣

View Code

自此：== 比較的是值，而is比較的是內存地址

進行第二個實驗讓 a='xingchen' ?b也是b='xingchen' ?結果兩個都是True

為什么？

小數據池：在str和int中存在這樣一個東西，它叫小數據池，即使存在100個這樣的變量，在一定范圍內，他們都指向同一個內存地址

　　　　　存在的意義：節省內存

什么樣的范圍：對于int ?-5 ---- 256?

　　　　　　　對于 str：1 不能含有特殊字符，2 單個元素*int 不能超過21

　　　　　　　　例如：>>> i='a'* 20>>> i1='a' * 20>>> print(id(i),id(i1))2138501554296 2138501554296 #這里是一樣的又如：>>> i='a'* 21>>> i1='a' * 21>>> print(id(i),id(i1))2138501554368 2138501554440 #這里就不一樣了

View Code

First -------編碼

1.1 ?ascii：

包含數字，字母，特殊字符，它只有兩種表示形式0和1，八個這樣的二進制被稱為一個字節（byte），ascii一共規定了128個字符的編碼，這128個字符只占了這個字節的后七位，最前面的一位為0

View Code

1.2 unicode：

萬國碼，unicode字符集被簡成為ucs。unicode起初是用兩個字節表示一個字符，后來規定一個字符使用的3個或四個字節表示，這里就產生了問題：無論是簡單的英文字符還是復雜的其他字符都用三或四個字節表示，對于存儲來說造成了極大浪費，（一個中文使用四個字節表示）。

View Code

1.3 utf-8:

utf-8是unicode的一種實現方式，其他還有utf-16和utf-32;它采用變長的編碼格式，根據情況，可以使用1-4個字節表示，一般英文字符就用一個字節表示，歐洲語言使用兩個字節表示，（中文使用三個字節表示）。

View Code

1.4 gbk:?

中國大陸制訂的，等同于ucs的新的中文編碼擴展國家標準，可以表示簡體字和繁體字，兼容gb2312

View Code?

**下面：Unicode，utf-8，gbk，每個編碼英文，中文，分別用幾個字節表示。

　　　　　　英文              中文unicode: 　　4 　　　　　　4utf-8: 　　　　1 　　　　　　3gbk: 　　　　1 　　　　　　2

View Code

其他：

1 不同編碼之間的二進制是不能互相識別的
2 對于文件的存儲以及傳輸，不能是unicode的編碼（占內存多）。

1.5 bytes和str

在python3.x版本中，有兩種類型的字符比較類似

bytes：str擁有的功能，它也有，內部編碼方式可以設定，非unicode，可能是utf-8,可能是gbk,可能是gb2312
str（字符串）:內部編碼方式是unicode，所以不能直接用于文件的存儲和傳輸
str如果要存儲： str 轉化成--->bytes ---->用于存儲和傳輸
為什么要存在str---因為bytes顯示出來的中文沒辦法識別，只有英文可以，bytes的類型前面有個b，例如b'abcd'

str ---> bytes 使用encode 編碼

例如：    s1='xingchen's2='中文'
b1=s1.encode('utf-8')
b2=s1.encode('gbk')
b3=s2.encode('utf-8')
b4=s2.encode('gbk')
print(b1,b2) --->結果為：b'xingchen'    b'xingchen'   b1和b2看著結果一樣卻是不同的編碼
print(b3,b4) ----》結果為：b'\xe4\xb8\xad\xe6\x96\x87'      b'\xd6\xd0\xce\xc4' 中文就看出區別了

View Code

bytes --->str 使用decode 解碼
例如：b1.decode('utf-8') ? ? ?b2.decode('gbk')

utf-8要向轉化成gbk的編碼格式：utf-8首先轉化成utf-8的bytes類型，再轉化成gdk的bytes類型，如果想轉化成str的gdk再使用decode

例如：

例子1：
s='中國' #utf-8的str類型
b=s.encode('gbk') #gbk的bytes類型
c=b.decode('gbk') #轉化成str的gbk unicode
print(b) #結果為 b'\xd6\xd0\xb9\xfa'
print(c) #結果為 中國例子2：
s2='中文'
d=s2.encode('gbk').decode('gbk')
d1=d.encode('gbk') #轉化成gbk的bytes類型，查看編碼格式
e=s2.encode('utf-8').decode('utf-8')
e1=e.encode('utf-8') #轉化成utf-8的bytes類型，查看編碼格式
print(d,d1)
print(e,e1)

View Code

pycharm上面使用的是str類型也即是unicode編碼，如果從其他地方傳過來的文件是utf-8的話，先encode為utf-8的unicode類型，轉化成gbk的話再decode('gbk')就好了

?pycharm上面的字符串本身就是unicode編碼，因此可以直接轉化其他編碼的bytes類型，例如：str.encode('utf-8') ? 又如： str.encode('gbk')

********************************所以utf-8的bytes類型轉化成gbk的bytes類型 s.encode('utf-8').decode('gbk') 。反之亦然************************************回到頁頭************************************************

Second ----集合

set1={}
1要求它里面的元素，是可哈希的，str tuple int bool，元素不重復，無序
集合本身是不可哈希的
2 功能：關系測試，去重
例如：
　　set1={'a','b','c','d','a'}
　　print(set1) #結果為{'b', 'c', 'a', 'd'}，再刷新就變成{'a', 'b', 'c', 'd'} #表明是無序的

#將一個列表去重

　　l=[1,2,1,3,3,4,5,4]print(set(l)) ---》{1, 2, 3, 4, 5}print(list(set(l))) --》[1, 2, 3, 4, 5]

View Code

集合的--增

　　set={'a','b','c'}set.add('d')print(set)

View Code

集合的--刪

　　set1={1,2,3}set.update(set1)print(set) #結果為 {1, 'c', 'd', 2, 3, 'b', 'a'}set.pop() #隨機刪除因為無序性print(set)set.remove('a') #按照元素刪除，不存在會報錯print(set)set.clear()print(set) # 結果 set()del set 只能刪除整個集合，del不能切片刪除

View Code

#沒有改，下面是查
集合的---查
# 使用for循環
　　for i in set:
　　print(i)
不能使用in查

集合的一些用法：
#交集

　　set1={1,2,3,4,5}set2={4,5,6,7,8}print(set1 & set2)print(set1.intersection(set2))

View Code

#并集
　　print(set1 | set2)
　　print(set1.union(set2))
#差集,前面獨有的元素

　　print(set1 - set2)print(set2-set1)print(set1.difference(set2))

View Code

#反交集
　　print(set1 ^ set2)
　　print(set1.symmetric_difference(set2))
#子集
　　set1={1,2,3}
　　set2={1,2,3,4,5}
　　print(set1 < set2)
　　print(set1.issubset(set2))
#超集
　　print(set2>set1)
　　print(set2.issuperset(set1))
#不可變的集合
　　print(frozenset(set1)) ---》frozenset({1, 2, 3})

Third ---深淺copy ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 回到頁頭

s1=[1,2,3]
s2=s1 #賦值，共用一個空間，無論多少層是一樣的，一個改變，另外一個也會改變
s1.append(666)
print(s1,s2) ----》[1, 2, 3, 666] [1, 2, 3, 666]s1=[1,2,3]
s2=s1.copy() #淺copy
s1.append(666)
print(s1,s2) ---》[1, 2, 3, 666] [1, 2, 3]s1=[1,2,3,[11,22]]
s2=s1.copy()
s1[-1].append(666)
print(s1,s2) ---》[1, 2, 3, [11, 22, 666]] [1, 2, 3, [11, 22, 666]]

View Code

*******所以淺copy第一層各自獨立，從第二層開始，共用一個內存地址*****

import copy
s1=[1,2,3,[11,22]]
s2=copy.deepcopy(s1)
s1[-1].append(666)
print(s1,s2) --》[1, 2, 3, [11, 22], 666] [1, 2, 3, [11, 22]]

View Code

深copy無論多少層，都是相互獨立的

#切片：淺copy

　　s1=[1,2,3,[11,22]]s2=s1[:]# s1.append(666) #結果為 [1, 2, 3, [11, 22], 666] [1, 2, 3, [11, 22]]s1[-1].append(666) #結果為[1, 2, 3, [11, 22, 666]] [1, 2, 3, [11, 22, 666]]print(s1,s2)

View Code

模擬tail -f命令

#tail -f access.log
# import time
# with open(r'xxxxx','rb') as f:
#     f.seek(0,2)
#     while True:
#         line=f.readline()
#         # print('===>',line)
#         if line:
#             print(line.decode(),end='')
#         else:
#             time.sleep(0.05)

tail -f

Fourth---文件操作

文件路徑：path
編碼方式：encoding
操作方式：mode: 讀，寫，讀寫，寫讀，追加，改。。。
執行流程：1打開文件，產生文件句柄 2 對文件句柄進行操作 3關閉文件句柄

f1=open(r'b.txt',encoding='utf-8',mode='r')
print(f1.read())
f1.close()

f1文件句柄，open()調用的內置函數，內置函數調用的系統內部open
r'b.txt' 表示文件路徑轉義，一般加r，或者加一個/轉義路徑碰到的問題
mode='r' 其中r的模式是默認的

read() 讀取文件中的全部內容
read(n)讀取一部分內容

對于mode模式，有兩種情況

mode='r'

r模式：read(n) 按照字符讀取n個字符

rb模式：以bytes方式讀取，read(n)按照字節讀取n個字節，一個中文一般要讀取三個字節，要不然解碼的時候會報錯

readline() 每次讀取一行
readlines() 讀取全部內容，但是處在一行，放在一個列表中，以回車（\n）為分隔
for循環讀取：每次讀取一行

下面是舉例說明

寫：w
沒有文件，新建文件寫入內容，
有文件的話--》先清空內容，再寫入新內容

f1=open('c.txt',encoding='utf-8',mode='w')
f1.write('呵呵 kjdf')
f1.close()

View Code

圖片的讀取與寫入，實現了新復制的圖片2 #圖片必須使用bytes的類型讀取

　　f1=open('1.jpg',mode='rb')content=f1.read()f2=open('2.jpg',mode='wb')f2.write(content)f1.close()f2.close()

View Code

追加 a
沒有文件，創建文件，類似于w
有文件，在最后追加內容

r+ 讀寫模式，先讀后寫，如果先寫后讀的話，將寫的內容覆蓋原文件一部分內容，按照字節替換，如果寫的內容不是中文字節的3倍將報錯，這里指utf-8編碼

f1=open('b.txt',encoding='utf-8',mode='r+')
print(f1.read())
f1.write('666') #里面只能加入字符串類型的字符
f1.close()f1=open('b.txt',encoding='utf-8',mode='r+')
# print(f1.read())
# f1.write('666') #里面只能加入字符串類型的字符
f1.write('a') #報錯
print(f1.read())
f1.close()

View Code

w+先寫后讀，有文件將清空內容，再寫入，此時光標在最后，讀的是空內容

a+ 先追加再讀

操作方法：read readline readlines write
其他操作方法：readable是否可讀 writable是否可寫
print(f1.tell()) 打印出光標的位置，按照字節顯示數字
f1.seek(12) 任意調整光標的位置 --》按照字節移動
f1.seek(0,2) 光標調整到最后
f1.seek(0) 光標調整到開頭

f1=open('b.txt',encoding='utf-8',mode='r')
f1.read(3) #按照字符讀取
print(f1.tell()) #打印光標的位置是按照字節
f1.close()

f1.truncate(n) 按照字節對源文件進行截取，必須是在 a或 a+，或者r+模式，清空文件內容再將截取的內容放入文件

　　f1=open('b.txt',encoding='utf-8',mode='a+')f1.truncate(3) #截取了三個字節f1.close()

View Code

with open('文件路徑'，encoding='模式') as f1 不用主動關閉文件句柄，可以打開多個文件
with open('c.txt',encoding='utf-8') as f1,\
open('b.txt',encoding='utf-8',mode='w') as f2:
content=f1.read()
f2.write(content)
清空b.txt中的內容，并將c.txt的內容復制到b.txt中

文件的修改：
1 以讀的模式打開原文件，以寫的模式打開一個新文件（這個文件可以事先不存在）
2 將原文件讀出，并按要求修改，并將修改后的內容寫入新文件
3 刪除原文件
4 將新文件重命名為原文件
例如：

　　import oswith open('b.txt',encoding='utf-8') as f1,\open('b.bak',encoding='utf-8',mode='w')as f2:for line in f1:new_line=line.replace('xingchen','AA')f2.write(new_line)os.remove('b.txt')os.rename('b.bak','b.txt')

View Code

?

Fifth-----函數初識

def 函數名():
函數體
出現return的話，return后面的內容不會執行
**return 等同于 return None 一般None省略

return的返回值有兩種：
1 return 可以返回單個值
2 return 可以返回多個值多個值，會將多個值放入一個元組中，將元組返回給函數的執行者
例如：

　　def func1():print(111)print(2222)return 666 ,'xingchen',[1,2,3]ret=func1()print(ret)

View Code

實參角度：
位置參數: 必須一一對應
　　def func1(a,b,c):
　　　　print(a,b,c)
func1(1,2,'xingchen')

def max(a,b): return a if a>b else b #比較大小的函數

關鍵字傳參：必須一一對應
　　def func2(a,b):
　　　　print(a,b)
func2(b=2,a=3)

混合參數：（位置參數和關鍵字參數）關鍵字參數必須在位置參數后
　　def func2(a,b,c,d):
　　　　print(a,b,c,d)
func2(1,2,d=3,c=5)

形參角度：
位置參數。按順序一一對應

默認參數。默認參數在位置參數的后面

def login(name,sex='男'):with open('register',encoding='utf-8',mode='a') as f1:f1.write('{}，{}\n'.format(name,sex))while True:
name=input('姓名： ').strip()
if '1' in name:login(name)else:sex=input('性別: ').strip()
login(name,sex)

View Code

動態參數，*args, **kwargs #函數定義的時候，*代表聚合，**表示關鍵字參數放入一個字典
args:所有的位置參數，放在一個元組中
kwargs：所有的關鍵字參數，放在一個字典中

　　def func3(*args,**kwargs):print(args)print(kwargs)
func3(1,2,3,'alex',c=6,name='wu',age='21')結果為：
(1, 2, 3, 'alex')
{'c': 6, 'name': 'wu', 'age': '21'}def func3(*args,**kwargs): #函數定義的時候*代表聚合print(args)print(kwargs)func3(*[1,2,3],*(22,33)) #函數執行的時候，*代表打散，也即是將列表或者列表亦或元組打散為單個的元素
結果為：(1, 2, 3, 22, 33)
{}func3(**{'name':'xingchen'},**{'age':23})
結果為
()
{'name': 'xingchen', 'age': 23}

View Code

形參的順序：位置參數 *args，默認參數，**kwargs
def func5(a,b,*args,sex='男',**kwargs):
　　print(a,b)
　　print(args)
　　print(sex)
　　print(kwargs)

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　回到頁首

?

posted on 2018-05-24 17:58 dawn-liu 閱讀(...) 評論(...) 編輯 收藏

轉載于:https://www.cnblogs.com/mmyy-blog/p/9084256.html

總結

以上是生活随笔為你收集整理的day3----编码-集合-深浅copy-文件操作-函数初识的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。