1. 文件處理

1.1 文件處理流程

1.打開文件，得到文件句柄并賦值給一個變量

2.通過句柄對文件進行操作

3.關閉文件

1.2 文件讀取模式r

r文本模式的讀，在文件不存在，不會創建新文件

f = open('a.txt','r',encoding='utf-8')

f.readable()#判讀文件是否可讀

f.writable() #判讀文件是否可寫

f.readline() #一次讀取一行

f.readlines() #一次讀取所有值

f.close()

1.3 文件讀取模式rb

b模式直接從硬盤中讀取bytes，不用指定編碼格式；以什么格式存的文件，以什么格式讀取文件

f = open('a.txt','rb')print(f.read().decode('utf-8'))

f.close()

1.4 文本寫模式 w

w文本模式的寫，文件存在則清空，不存在則創建

f = open('a.txt','w',encoding='utf-8')

f.writable()#判斷是否可寫

f.readable() #判斷是否可讀

f.write('你好') #寫單個值

f.writelines(['aaa\n','bbb\n']) #寫列表

f.writelines(('111\n','222\n')) #寫元組

f.close()

1.5 文件追加模式a

a 文件模式的追加，文件存在、光標跳到文件末尾，文件不存在創建

f = open('a.txt','a',encoding='utf-8')print(f.tell()) #打印文件光標的位置

f.write('3333\n')

f.write('4444\n')

f.close()

1.6 混合模式

"+" 表示可以同時讀寫某個文件

r+???? 可讀寫文件，即可讀、可寫、可追加

w+??? 可寫讀文件，即可寫、可讀、可追加

a+???? 同a

混合模式不常用，了解即可。

1.7 b模式

#rb模式直接從硬盤中讀取bytes

f = open('a.txt','rb')print(f.read())

f.close()#wb模式

f = open('a.txt','wb')

f.write('你好'.encode('utf-8'))

f.close()

1.8 遍歷文件

在內存中，同時只有一條內容，不依賴索引；文件很多，用循環遍歷的方式讀取文件。

with open('a.txt','r',encoding='utf-8') as f:for line inf.read():print(line)

1.9 Copy文件

利用r模式，模擬Copy動作；以b的方式打開文件，不會涉及文件編碼的問題，b是Bytes的格式；利用r進行處理文件路徑，以后經常需要處理文件路徑的問題，也就是右斜杠沒有特殊意義。

importsysif len(sys.argv) < 3:print('Usage:python3 copy.py source.file target.file')

sys.exit()

with open(r'%s' %sys.argv[1],'rb') as f_read,\

open(r'%s' %sys.argv[2],'wb') as f_write:for line inf_read:

f_write.write(line)

1.10 文件其他操作

1.10.1 read

例如：read(3)

1.文件打開方式為文本模式時，代表只讀取3個字符。

f = open('a.txt','r',encoding='utf-8')print(f.read(3))

f.close()

2.文件打開方式為b模式時，代表讀取3個字節。

f = open('a.txt','rb')print(f.read(6).decode('utf-8'))print(f.read(3).decode('utf-8'))

f.close()

1.10.2 seak

以字節為單位，進行移動光標，有三種模式，三種模式默認指定的參照物不同；其中1、2模式必須在b模式下進行。

0模式：默認以文件開頭為光標移動，參照物為文件開頭

1模式：以當前光標所在的位置為參照物

2模式：以文件結尾為參照物，進行文件光標的移動

#seek的0模式 默認為0模式

f = open('a.txt','r')print(f.read(3))print(f.tell())

f.seek(3)print(f.tell())print(f.read())#seek的1模式

f = open('a.txt','rb')print(f.read(3))print(f.tell())

f.seek(3,1)print(f.tell())print(f.read().decode('utf-8'))#seek的2模式

f=open('a.txt','rb')

f.seek(0,2)print(f.tell())print(f.read())

1.10.3 tell

tell是告訴光標的位置，tell編譯器的具體實現：

def tell(self, *args, **kwargs): #real signature unknown

"""Current file position.

Can raise OSError for non seekable files."""

pass

1.10.4 truncate

truncate是截斷文件，所以文件的打開方式必須可寫，但是不能用w、w+等方式打開，因為那樣直接清空文件，所以truncate要在r+、a、a+等模式使用；

with open('a.txt','r+',encoding='utf-8') as f:

f.truncate(2)

1.10.5 類似于tail命令

以rb方式打開文件，光標移動到最后:f.seek(0,2)

#tail.py -f access.log

importtimeimportsys

with open(r'%s' % sys.argv[2], 'rb') as f:

f.seek(0,2)whileTrue:

line=f.readline()ifline:print(line.decode('utf-8'),end='')else:

time.sleep(0.5)

1.11 總結

最常用的模式：r、w、a

rb、wb、ab

文件的其他模式，了解即可

2.函數

2.1 不用函數的問題

復雜度增大

組織結構不清晰

可讀性差

代碼冗余

可擴展性差

如何解決問題：

利用函數進行解決問題。例如修改下水道的問題：需要準備工具；利用工具與函數進行類比：

1.工具就是具備某一種功能的物件，就是程序中的函數的概念

2.事先準備工具的過程稱為函數的定義

3.遇到特定的場景拿來就用稱為函數的調用

2.2 函數的分類

在python中，函數的分類有兩種：

1. 內置函數

2. 自定義函數

例如：python內置的函數(len、print、max)

2.3 原則

函數的使用原則：

1.先定義

2.再調用

2.4 直觀感受使用函數

'''**********************

hello jack

**********************'''

defprint_star():print('*'*20)defprint_msg():print('hello jack')

print_star()

print_msg()

print_star()

2.5 函數使用

函數的定義與變量的定義類似，沒有事先定義變量，而直接引用變量，會報錯

沒有事先定義函數，而直接調用，就相當于在引用一個不存在的變量名

'''函數的使用：

1 先定義

2 再調用'''

#定義階段

deffoo():print('from foo')

bar()defbar():print('from bar')#調用階段

foo()

函數在定義階段發生了什么事情？？

函數在定義階段：只檢測語法，不執行代碼

deffunc():

asdf#asdf=’bbbb’

func()

2.6 函數定義

#函數的定義語法

'''def 函數名(arg1,arg2,arg3):

"注釋"

函數體

return 返回值

函數名一般是動詞

參數

return:函數內部可以有多個return，但只能執行一次，函數就結束調用，

并且會把return后的值作為函數執行的結果返回'''

2.6.1函數定義三種形式

無參：???? 應用場景僅僅只是執行一些操作，比如與用戶交互，打印

有參：???? 需要根據外部傳進來的參數，才能執行相應的邏輯，比如統計長度，求最大值

空函數：設計代碼結構

2.6.2 無參函數

deffoo():print('from foo')

2.6.3 有參函數

#求最大值的函數，類似于python內置函數max

defmy_max(x,y):if x >y:returnxelse:returny

res=my_max(1,2)print(res)

2.6.4 空函數

#sql解析，首先設計sql解析框架

defselect(sql):'''select function'''

print(sql)#sql=['select', '*', 'from', 'mysql.user;']

definsert(sql):'''insert function'''

pass

defupdate(sql):'''update function'''

pass

defdelete(sql):'''delete function'''

pass

#select * from mysql.user;

defmain():whileTrue:

sql=input('>>:').strip()if not sql:continuecmd_info=sql.split()

cmd=cmd_info[0]if cmd == 'select':

select(cmd_info)

main()

2.7 函數return

return，是函數結束的標志

return的返回值沒有類型限制

1. 沒有return：返回None，等同于return None

2. return 一個值：返回該值

3. return val1,val2,val3:返回(val1,val2,val3)

需要返回值：

調用函數，經過一系列的操作，最后得到一個確定的結果，則必須要有返回值

通常有參函數要有返回值，輸入參數，經過計算，得到一個最終結果

不需要返回值：

調用函數，僅僅只是執行一系列的操作，最后不需要得到結果，無序有返回值

通常無參函數不需要有返回值

#函數的返回值，返回多個值

deffunc():print('from func')return [1,2,3],'a',1,{'a':3}

2.8 函數調用

函數的調用，有三種形式：

1.語句形式

2.表達式形式

3.函數調用當做另一個函數的參數

defmy_max(x,y):if x >y:returnxelse:returny

my_max(1,2) #語句形式

res=my_max(1,2)*10 #表達式形式

res2=my_max(my_max(1,2),3) #函數調用可以當做另外一個函數的參數

2.9 函數參數

函數的參數，分兩種

1.形參：在定義函數時，括號內的參數，形參就是變量名

2.實參：在調用函數時，括號內的參數，實參就是變量值

在調用階段實參(變量值)才會綁定形參(變量名)，調用結束，解除綁定

#形參：在定義函數時，括號內的參數成為形參#特點：形參就是變量名

def foo(x,y): #x=1,y=2

print(x)print(y)#實參：在調用函數時，括號內的參數成為實參#特點：實參就是變量值

foo(1,2)#在調用階段實參(變量值)才會綁定形參(變量名)#調用結束后，解除綁定

2.10 參數分類

2.10.1 位置參數

位置參數：按照從左到右的順序依次定義的參數

1.位置形參：必須被傳值，并且多一個不行，少一個也不行

2.位置實參：與形參按照位置一一對應

deffoo(x,y):print(x)print(y)

foo(1,2)defregister(name,age):print(name)print(age)

register('jack',18)

2.10.2 關鍵字參數

關鍵字實參：指的是按照name=value的形式，指名道姓地給name傳值

關鍵字參數需要注意的問題：

問題一:語法規定位置實參必須在關鍵字實參的前面

問題二:一定不要對同一個形參傳多次值

deffoo(name,age):print(name)print(age)

foo(age=18,name='jack')#關鍵字實參需要注意的問題是：

deffoo(name,age,sex):print(name)print(age)print(sex)#正常傳值

foo('jack',18,'male')

foo(sex='male',age=18,name='jack')

foo('jack',sex='male',age=18)#問題一:語法規定位置實參必須在關鍵字實參的前面

foo('jack',sex='male',age=18)#問題二:一定不要對同一個形參傳多次值

foo('jack',sex='male',age=18,name='jack1')

foo('male',age=18,name='jack1')

2.10.3 默認參數

默認參數，即默認形參：在定義階段，就已經為形參賦值，意味在調用階段可以不用傳值

使用默認參數，可以降低函數使用的復雜度。

def foo(x,y=222):print(x)print(y)

foo('jack')

foo(1,'a')def register(name,age,sex='male'):print(name,age,sex)

register('jack',73)

register('tom',38)

register('mary',28,'female')

默認參數需要注意的問題

問題一:默認參數必須放在位置參數之后

def foo(y=1, x):print(x, y)

問題二：默認參數只在定義階段賦值一次，而且僅一次

x=100

def foo(a,b=x):print(a,b)

x=22222foo('jack')

問題三：默認參數的值應該定義成不可變類型

不可變類型：包括字符串、數字、元組

可變類型：???? 列表、字典

2.11 可變長參數

可變長參數指的是實參的個數不固定(個數多了)

實參無非位置實參和關鍵字實參兩種

形參必須要兩種機制分別處理：

按照位置定義的實參溢出的情況???????? *

按照關鍵字定義的實參溢出的情況???? **

2.11.1 位置參數

多出來的位置實參，會交給*處理，保存成元組的形式，*把多出來賦值給args

def foo(x,y,*args): #args=(3,4,5,6,7)

print(x)print(y)print(args)

foo(1,2,3,4,5,6,7) #*

foo(1,2) #*

*args的擴展用法

* 處理的是位置參數

* 可以存在于形參位置，*也可以在于實參位置

碰到*位于實參位置，打回原形，拆成位置參數

例如：foo(1,2,*(3,4,5,6,7))? <====>? foo(1,2,3,4,5,6,7)

def foo(x,y,*args): #*args = *(3,4,5,6,7)

print(x)print(y)print(args)

foo(1,2,3,4,5,6,7) #*

foo(1,2,*(3,4,5,6,7)) #等價于foo(1,2,3,4,5,6,7)

def foo(x,y,*args): # print(x)print(y)print(args)

foo('a','b',*(1,2,3,4,5,6,7)) #等價于foo('a','b',1,2,3,4,5,6,7)

foo('jack',10,2,3,4,5,6,9)

2.11.2 關鍵字參數

多出來的關鍵字實參，會交給**處理，保存成字典形式，**把多出來的參數交給kwargs

def foo(x,y,**kwargs): #kwargs={'z':3,'b':2,'a':1}

print(x)print(y)print(kwargs)

foo(1,2,z=3,a=1,b=2) #**

**kwargs的擴展用法

** 處理的是關鍵字參數

** 可以存在于形參位置，**也可以在于實參位置

碰到**位于實參位置，打回原形，拆成關鍵字參數

例如：foo(1,2,**{'z':3,'b':2,'a':1}) ?<====> ?foo(1,2,a=1,z=3,b=2)

def foo(x,y,**kwargs): #kwargs={'z':3,'b':2,'a':1}

print(x)print(y)print(kwargs)

foo(1,2,**{'z':3,'b':2,'a':1}) #foo(1,2,a=1,z=3,b=2)

deffoo(x, y):print(x)print(y)

foo(**{'y':1,'x':2}) #foo(y=1,x=2)

2.11.3 混合使用

def foo(x,*args,**kwargs): #args=(2,3,4,5) kwargs={'b':1,'a':2}

print(x)print(args)print(kwargs)

foo(1,2,3,4,5,b=1,a=2)

2.11.4 間接調用函數

importtimedef register(name,age,sex='male'):print(name)print(age)print(sex)

time.sleep(3)def wrapper(*args, **kwargs): #args=('egon',) kwargs={'age':18}

start_time=time.time()

register(*args, **kwargs)

stop_time=time.time()print('run time is %s' %(stop_time-start_time))

wrapper('jack',age=26)

register('jack',26)

2.11.5 命名關鍵字參數

命名關鍵字參數，必須是被以關鍵字實參的形式傳值

在*后面定義的形參稱為命名關鍵字參數，必須是被以關鍵字實參的形式傳值；屬于了解內容。

def foo(*args,x):print(x)print(args)

foo(1,2,3,4,x='jack')def foo(name,age,*,sex,group):print(name,age,sex,group)

foo('jack',18,group='group1',sex='male')def foo(name,age,*,sex='male',group):print(name,age,sex,group)

foo('mary',18,group='group1')

2.12 函數對象

函數是第一類對象：指的是函數可以被當做數據傳遞

1 被賦值

deffoo():print('from foo')

f=fooprint(f)

f()

2 可以當做參數傳入

defwrapper(func):#print(func)

func()

wrapper(foo)

3 可以當做函數的返回

defwrapper(func):returnfunc

res=wrapper(foo)print(res)

4 可以當做容器類型的元素

cmd_dic={'func':foo

}print(cmd_dic)

cmd_dic['func']()

總結

以上是生活随笔為你收集整理的python def return 文件_python基础-文件处理与函数的全部內容，希望文章能夠幫你解決所遇到的問題。

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