python初識(三)
目錄:
- 字符編碼
- 文件操做
- 循環結構拾遺
- 函數
- 總體介紹
- 函數的參數
- 函數的返回值
- 函數的調用
- 自定義函數
1、字符編碼
一、瞭解字符編碼的知識儲備node
a. 文件編輯存取文件的原理（nodepad++,pycharm,word)python
啓動進程---〉打開文件---〉讀取內容到內存（斷電會丟失）---〉保存（flush刷入硬盤）linux
b. python解釋器執行原理。編程
python解釋器啓動---〉進程打開.py文件---〉讀取文件到內存----〉執行app
ps. 二者區別，在於python解釋器能夠執行python2.7
二、什麼是字符編碼編輯器
a. 衆所周知，計算機通電工做，且只是經過高低電平（二進制，高爲1，低爲2）工做的。ide
b. 這就意味着計算機制認識數字，而人類的語言通過翻譯轉換成數字，驅使計算機幹活這件事爲編程。因此人類的語言通過翻譯轉換成數字，轉化中的語言與數字的對應關係，咱們稱爲字符編碼。函數
字符 ----〉字符編碼表（翻譯過程）---〉數字編碼
三、unicode和utf-8（字符編碼）
uncicode：簡單粗暴，全部字符最少2bytes，優勢爲字符--〉數字的轉換速度快，缺點爲佔用空間大。（內存中使用）
uft-8:精準，可變字符長度，優勢節省空間，缺點轉換過程慢，由於須要計算當前字符的長度。（硬盤中使用）
四、字符編碼的使用：
a. 讀取和保存過程圖
b.不管使用何種編輯器，要防止亂碼，核心法則爲，文件以什麼編碼保存，就應以什麼編碼方式打開。
五、python程序的執行過程。
a. python解釋器啓動---〉進程打開.py文件---〉讀取文件到內存----〉執行
b. 執行步驟細節：
1 # 加載到內存，所佔用的內存爲unicode編碼二進制 2 print('====>') 3 x = 'shuyang' #結果shuyang, 臨時申請內存，unicode編碼二進制，程序結束釋放 4 y = x.encode('utf-8') #結果b'shuyang'，臨時申請內存，unicode編碼二進制，程序結束釋放
c.python2與python3的區別：
-
- 在python2中，str就是編碼後的結果bytes，str=bytes,因此在python2中，unicode字符編碼的結果是str/bytes
- 在python2解釋器執行到產生字符串的代碼時（例如s=u'林'），會申請新的內存地址，而後將'林'以unicode的格式存放到新的內存空間中，因此s只能encode，不能decode
- python3中的字符串與python2中的u'字符串'，都是unicode，因此不管如何打印都不會亂碼
- 示例：
python2.7
1 python2.7 2 #coding:utf-8 3 s=u'林' #當程序執行時，'林'會被以unicode形式保存新的內存空間中 4 5 # s指向的是unicode，於是能夠編碼成任意格式，都不會報encode錯誤 6 # 由於系統默認字符集，輸出顯示爲GBK，pycharm爲UTF-8 7 s1=s.encode('utf-8') 8 s2=s.encode('gbk') 9 print s1 #控制檯打印亂碼，pycharm正常 10 print s2 #控制檯正常，pycharm亂碼 11 12 13 print repr(s) #u'\u6797' 14 print repr(s1) #'\xe6\x9e\x97' 編碼一個漢字utf-8用3Bytes 15 print repr(s2) #'\xc1\xd6' 編碼一個漢字gbk用2Bytes 16 17 print type(s) #<type 'unicode'> 18 print type(s1) #<type 'str'> 19 print type(s2) #<type 'str'> 20 '''
python3.0(str -->unicode, bytes--->bytes)
1 #coding:utf-8 2 s='林' #當程序執行時，無需加u，'林'也會被以unicode形式保存新的內存空間中, 3 4 #s能夠直接encode成任意編碼格式 5 s.encode('utf-8') 6 s.encode('gbk') 7 8 print(type(s)) #<class 'str'>
1 #coding:utf-8 2 s='林' #當程序執行時，無需加u，'林'也會被以unicode形式保存新的內存空間中, 3 4 #s能夠直接encode成任意編碼格式 5 s1=s.encode('utf-8') 6 s2=s.encode('gbk') 7 8 9 10 print(s) #林 11 print(s1) #b'\xe6\x9e\x97' 在python3中，是什麼就打印什麼 12 print(s2) #b'\xc1\xd6' 同上 13 14 print(type(s)) #<class 'str'> 15 print(type(s1)) #<class 'bytes'> 16 print(type(s2)) #<class 'bytes'>
2、文件操做
一、文件處理流程
a.打開文件---〉獲取文件對象---〉關閉文件
b.read.txt內容
1 演員 - 薛之謙 2 詞：薛之謙 3 曲：薛之謙 4 簡單點說話的方式簡單點 5 遞進的情緒請省略 6 你又不是個演員 7 別設計那些情節 8 沒意見我只想看看你怎麼圓 9 你難過的太表面 像沒天賦的演員 10 觀衆一眼能看見 11 該配合你演出的我演視而不見 12 在逼一個最愛你的人即興表演 13 何時咱們開始收起了底線 14 順應時代的改變看那些拙劣的表演 15 可你曾經那麼愛我幹嗎演出細節 16 我該變成什麼樣子才能延緩厭倦 17 原來當愛放下防備後的這些那些 18 纔是考驗 19 沒意見你想怎樣我都隨便 20 你演技也有限 21 又不用說感言 22 分開就平淡些 23 該配合你演出的我演視而不見 24 別逼一個最愛你的人即興表演 25 何時咱們開始沒有了底線 26 順着別人的謊話被動就不顯得可憐 27 可你曾經那麼愛我幹嗎演出細節 28 我該變成什麼樣子才能配合出演 29 原來當愛放下防備後的這些那些 30 都有個期限 31 其實臺下的觀衆就我一個 32 其實我也看出你有點不捨 33 場景也習慣咱們來回拉扯 34 還計較着什麼 35 其實說分不開的也不見得 36 其實感情最怕的就是拖着 37 越演到重場戲越哭不出了 38 是否還值得 39 該配合你演出的我盡力在表演 40 像情感節目裏的嘉賓任人挑選 41 若是還能看出我有愛你的那面 42 請剪掉那些情節讓我看上去體面 43 可你曾經那麼愛我幹嗎演出細節 44 不在乎的樣子是我最後的表演 45 是由於愛你我才選擇表演 這種成全
二、基本操做
f = open('<路徑+文件名>','<模式>'...) # 默認爲r模式只讀(read)
first_line = f.read_line() # 讀取第一行
print(first_line)
f.close() # 關閉文件
1 ''' 2 一、基本操做 3 ''' 4 f = open('read.txt', encoding='utf-8') # 默認爲r模式只讀(read) 5 first_line = f.readline() # 讀取第一行 6 print(first_line) 7 f.close() # 關閉文件
三、文件打開模式
打開文件時，須要指定文件路徑和以何等方式打開文件，打開後，便可獲取該文件句柄，往後經過此文件對象對該文件操做。
a. 打開文件的模式有：
-
-
- r ，只讀模式【默認模式，文件必須存在，不存在則拋出異常】
- w，只寫模式【不可讀；不存在則建立；存在則清空內容】
- x， 只寫模式【不可讀；不存在則建立，存在則報錯】
- a， 追加模式【可讀； 不存在則建立；存在則只再末尾追加內容】
-
b. "+" 表示能夠同時讀寫某個文件
-
-
- r+， 讀寫【可讀，可寫】
- w+，寫讀【可寫，可讀】
- x+ ，寫讀【可讀，可寫】
- a+， 寫讀【可讀，可寫】
-
c. "b"表示以字節的方式操做，須要decode解碼，encode編碼，二進制可編輯圖片，音頻等等
-
-
- rb 或 r+b
- wb 或 w+b
- xb 或 w+b
- ab 或 a+b
-
ps.以b方式打開時，讀取到的內容是字節類型，寫入時也須要提供字節類型，不能指定編碼
四、文件內置函數
1 ''' 2 二、文件的內置函數 3 ''' 4 # 按行讀取 5 # f = open('read.txt', encoding='utf-8') 6 # a = f.readline() # 按行讀取 7 # print(a) 8 # f.close() 9 10 # 按行所有讀取爲list 11 # f = open('read.txt', encoding='utf-8') 12 # a = f.readlines() # 按行所有讀取爲list 13 # print(a) 14 # f.close() # 關閉 15 16 # 默認所有讀取，讀取指定字符數據 17 # f = open('read.txt', encoding='utf-8') 18 # a = f.read() # 默認所有讀取，讀取指定字符數據 19 # print(a) 20 # f.close() # 關閉 21 22 # 返回一個長整型的"文件標籤" 23 # f = open('read.txt', encoding='utf-8') 24 # a = f.fileno() # 返回一個長整型的"文件標籤" 25 # print(a) 26 # f.close() 27 28 # 返回文件名 29 # f = open('read.txt', encoding='utf-8') 30 # a = f.name # 返回文件名 31 # print(a) 32 # f.close() 33 34 # 返回文件編碼 35 # f = open('read.txt', encoding='utf-8') 36 # a = f.encoding # 返回文件編碼 37 # print(a) 38 # f.close() 39 40 # 強制刷新寫入硬盤，不建議頻繁使用 41 # f = open('read.txt', encoding='utf-8') 42 # a = f.flush() # 強制刷新寫入硬盤，不建議頻繁使用 43 # print(a) 44 # f.close() 45 46 # 判斷文件是不是贊成tty設備 47 # f = open('read.txt', encoding='utf-8') 48 # a = f.isatty() # 判斷文件是不是贊成tty設備 49 # print(a) 50 # f.close() 51 52 # 判斷文件是否可讀 53 # f = open('read.txt', encoding='utf-8') 54 # a = f.readable() # 判斷文件是否可讀 55 # print(a) 56 # f.close() 57 58 # 指定文件中指針位置 59 # f = open('read.txt', encoding='utf-8') 60 # a = f.seek(0) # 指定文件中指針位置 0爲文件開始，以字節爲單位 61 # print(a) 62 # f.close() 63 64 # 指針是否可操做 65 # f = open('read.txt', encoding='utf-8') 66 # a = f.seekable() # 指針是否可操做 67 # print(a) 68 # f.close() 69 70 # 獲取指針位置，以字節爲單位 71 # f = open('read.txt', encoding='utf-8') 72 # a = f.tell() # 獲取指針位置，以字節爲單位 73 # print(a) 74 # f.close() 75 76 # 截斷數據，僅保留指定以前數據，以字節爲單位 77 # f = open('read.txt', encoding='utf-8') 78 # a = f.truncate(4) # 截斷數據，僅保留指定以前數據，以字節爲單位 79 # print(a) 80 # f.close() 81 82 # 判斷文件是否可寫 83 # f = open('read.txt','w', encoding='utf-8') 84 # a = f.writable() # 判斷文件是否可寫 85 # print(a) 86 # f.close() 87 88 # 清空文件後，寫入內容 89 # f = open('read.txt','w', encoding='utf-8') 90 # f.write() # 清空文件後，寫入內容 91 # f.close() 92 93 # 清空文件後，寫入多個內容list，dict 94 # f = open('read.txt','w', encoding='utf-8') 95 # f.writelines(['a','b','c']) # 清空文件後，寫入多個內容list，dict 96 # f.close()
ps. read(3)表明讀取3個字符，其他的文件內光標移動都是以字節爲單位如seek，tell，read，truncate
五、文件操做語法
a.open()語法
open(file[, mode[, buffering[, encoding[, errors[, newline[, closefd=True]]]]]])
open函數有不少的參數，經常使用的是file，mode和encoding
file：文件位置，須要加引號
mode：文件打開模式
buffering：的可取值有0，1，>1三個，0表明buffer關閉（只適用於二進制模式），1表明line buffer（只適用於文本模式），>1表示初始化的buffer大小；
encoding：表示的是返回的數據採用何種編碼，通常採用utf8或者gbk；
errors：的取值通常有strict，ignore，當取strict的時候，字符編碼出現問題的時候，會報錯，當取ignore的時候，編碼出現問題，程序會忽略而過，繼續執行下面的程序。
newline：能夠取的值有None, \n, \r, 」, ‘\r\n'，用於區分換行符，可是這個參數只對文本模式有效；
closefd：的取值，是與傳入的文件參數有關，默認狀況下爲True，傳入的file參數爲文件的文件名，取值爲False的時候，file只能是文件描述符，什麼是文件描述符，就是一個非負整數，在Unix內核的系統中，打開一個文件，便會返回一個文件描述符。
b.python2中file() 與open() 的區別
二者都可以打開文件，對文件進行操做，也具備類似的用法和參數，可是，這兩種文件打開方式有本質的區別，file爲文件類，用file()來打開文件，至關於這是在構造文件類，而用open()打開文件，是用python的內建函數來操做，建議使用open
六、上下文管理
1 ''' 2 二、文件的內置函數 3 ''' 4 # 按行讀取 5 # f = open('read.txt', encoding='utf-8') 6 # a = f.readline() # 按行讀取 7 # print(a) 8 # f.close() 9 10 # 按行所有讀取爲list 11 # f = open('read.txt', encoding='utf-8') 12 # a = f.readlines() # 按行所有讀取爲list 13 # print(a) 14 # f.close() # 關閉 15 16 # 默認所有讀取，讀取指定字符數據 17 # f = open('read.txt', encoding='utf-8') 18 # a = f.read() # 默認所有讀取，讀取指定字符數據 19 # print(a) 20 # f.close() # 關閉 21 22 # 返回一個長整型的"文件標籤" 23 # f = open('read.txt', encoding='utf-8') 24 # a = f.fileno() # 返回一個長整型的"文件標籤" 25 # print(a) 26 # f.close() 27 28 # 返回文件名 29 # f = open('read.txt', encoding='utf-8') 30 # a = f.name # 返回文件名 31 # print(a) 32 # f.close() 33 34 # 返回文件編碼 35 # f = open('read.txt', encoding='utf-8') 36 # a = f.encoding # 返回文件編碼 37 # print(a) 38 # f.close() 39 40 # 強制刷新寫入硬盤，不建議頻繁使用 41 # f = open('read.txt', encoding='utf-8') 42 # a = f.flush() # 強制刷新寫入硬盤，不建議頻繁使用 43 # print(a) 44 # f.close() 45 46 # 判斷文件是不是贊成tty設備 47 # f = open('read.txt', encoding='utf-8') 48 # a = f.isatty() # 判斷文件是不是贊成tty設備 49 # print(a) 50 # f.close() 51 52 # 判斷文件是否可讀 53 # f = open('read.txt', encoding='utf-8') 54 # a = f.readable() # 判斷文件是否可讀 55 # print(a) 56 # f.close() 57 58 # 指定文件中指針位置 59 # seek()的三種模式： 60 # （1）f.seek(p,0) 移動當文件第p個字節處，絕對位置 61 # （2）f.seek(p,1) 移動到相對於當前位置以後的p個字節 62 # （3）f.seek(p,2) 移動到相對文章尾以後的p個字節 63 # f = open('read.txt', encoding='utf-8') 64 # a = f.seek(0) # 指定文件中指針位置 0爲文件開始，以字節爲單位 65 # print(a) 66 # f.close() 67 68 # 指針是否可操做 69 # f = open('read.txt', encoding='utf-8') 70 # a = f.seekable() # 指針是否可操做 71 # print(a) 72 # f.close() 73 74 # 獲取指針位置，以字節爲單位 75 # f = open('read.txt', encoding='utf-8') 76 # a = f.tell() # 獲取指針位置，以字節爲單位 77 # print(a) 78 # f.close() 79 80 # 截斷數據，僅保留指定以前數據，以字節爲單位 81 # f = open('read.txt', encoding='utf-8') 82 # a = f.truncate(4) # 截斷數據，僅保留指定以前數據，以字節爲單位 83 # print(a) 84 # f.close() 85 86 # 判斷文件是否可寫 87 # f = open('read.txt','w', encoding='utf-8') 88 # a = f.writable() # 判斷文件是否可寫 89 # print(a) 90 # f.close() 91 92 # 清空文件後，寫入內容 93 # f = open('read.txt','w', encoding='utf-8') 94 # f.write() # 清空文件後，寫入內容 95 # f.close() 96 97 # 清空文件後，寫入多個內容list，dict 98 # f = open('read.txt','w', encoding='utf-8') 99 # f.writelines(['a','b','c']) # 清空文件後，寫入多個內容list，dict 100 # f.close()
七、文件的修改
1 ''' 2 四、 文件修改 3 ''' 4 import os 5 with open('read.txt', 'r', encoding='utf-8') as f, \ 6 open('write.txt', 'w', encoding='utf-8') as f2: 7 for i in f: 8 if i.startswith('什麼'): 9 i = 'li,li,li' 10 f2.write(i) 11 12 # os.remove('read.txt') 13 # os.rename('write.txt', 'read.txt')
八、linux下tail實現原理
1 # tail -f access.log 2 import time 3 with open('access.log','r',encoding='utf-8') as f: 4 f.seek(0,2) 5 while True: 6 line=f.readline().strip() 7 if line: 8 print('新增一行日誌',line) 9 time.sleep(0.5)
3、循環結構拾遺
循環體 ... else... 表示當循環不被break打斷，就會執行else的代碼
一、for...else...使用
1 # for循環 2 # for i in range(3): 3 # print(i) 4 # # continue 5 # if i == 1: 6 # break 7 # else: 8 # print('=============>') #當for循環不被break打斷，就會執行else的代碼 9 10 # 單行讀取文件，寫入到新文件 11 # with open('a.txt','r',encoding='utf-8') as read_f,\ 12 # open('aa.txt','w',encoding='utf-8') as write_f: 13 # 14 # for line in read_f: 15 # write_f.write(line) 16 # else: 17 # print('write successfull')
二、while...else...使用
1 # while循環 2 # i=0 3 # while i< 5: 4 # print(i) 5 # i+=1 6 # if i == 3: 7 # break 8 # else: 9 # print('------>')
4、函數
一、總體介紹
a.數學定義的函數與python中的函數：
初中數學函數定義：通常的，在一個變化過程當中，若是有兩個變量x和y，而且對於x的每個肯定的值，y都有惟一肯定的值與其對應，那麼咱們就把x稱爲自變量，把y稱爲因變量，y是x的函數。自變量x的取值範圍叫作這個函數的定義域。例如y=2*x
python中函數定義：函數是邏輯結構化和過程化的一種編程方法。把一段程序代碼，使用一種方式命名，以方便經過名字的方式調用。格式以下：
def 〈函數名〉（參數1，參數2，...）：
函數體
<return 值>
〈函數名〉（參數1，參數2，...） # 調用模式
ps.當一個函數/過程沒有使用return顯示的定義返回值時，python解釋器會隱式的返回None，因此在python中即使是過程也能夠算做函數。
1 def test01(): 2 msg='hello The little green frog' 3 print msg 4 5 def test02(): 6 msg='hello WuDaLang' 7 print msg 8 return msg 9 10 11 t1=test01() 12 13 t2=test02() 14 15 16 print 'from test01 return is [%s]' %t1 17 print 'from test02 return is [%s]' %t2
b.爲什麼使用函數：函數是程序裏沒有沒有缺點的應用，使用率很高
- 函數的特色（不使用函數會怎樣？）
- 減小重複代碼（無組織無結構，代碼冗餘）
- 是程序變得易維護（沒法統一管理且維護成本高）
- 是程序變得易擴展（可讀性差）
二、函數的分類：
按創建類型分：內置函數，自定義函數
a. 內置函數：系統預先設計好的函數，能夠直接調用，如：sum(), max(),mix(),len()...
b. 自定義函數
1 #自定義函數 2 3 # # ****** 4 # # ****** 5 # # ****** 6 # # hello world 7 # # ****** 8 # # ****** 9 # # ****** 10 # 11 def print_star(): 12 print('#'*6) 13 14 def print_msg(): 15 print('hello world') 16 17 print_star() 18 print_star() 19 print_star() 20 print_msg() 21 print_star() 22 print_star() 23 print_star()
三、函數的參數
a. 從大的角度去看，函數的參數分兩種：形參(變量名)，實參（值）
-
-
- 形參：形參變量只有在被調用時才分配內存單元，在調用結束時，即刻釋放所分配的內存單元。所以，形參只在函數內部有效。函數調用結束返回主調用函數後則不能再使用該形參變量
- 實參：實參能夠是常量、變量、表達式、函數等，不管實參是何種類型的量，在進行函數調用時，它們都必須有肯定的值，以便把這些值傳送給形參。所以應預先用賦值，輸入等辦法使參數得到肯定值
- 示例：
-
1 #定義階段：x,y爲形參 2 # def foo(x,y): #x=1,y=2 3 # print(x) 4 # print(y) 5 6 #調用階段：1，2位實參 7 # foo(1,2)
b.詳細的區分函數的參數分爲五種：位置參數，關鍵字參數，默認參數，可變長參數（*args，**kwargs）,命名關鍵字參數
-
-
- 位置參數:位置形參，必須被傳值的參數。位置實參數：與形參一一對應。
-
1 #位置參數 2 def foo(x,y,z):#位置形參:必須被傳值的參數 3 print(x,y,z) 4 5 # foo(1,2,3) 6 foo(1,2,3) #位置實參數：與形參一一對應
-
-
- 關鍵字參數：key=value
-
1 def foo(x,y,z): 2 print(x,y,z) 3 4 foo(z=3,x=1,y=2)
ps.關鍵字參數須要注意的問題：
1)關鍵字實參必須在位置實參後面。如：foo(1,z=3,y=2) #正確
2)不能重複對一個形參數傳值。如：foo(x=1,2,z=3) #錯誤，foo(1,x=1,2,z=3) #錯誤
-
-
- 默認參數
-
1 def register(name,age,sex='male'): #形參：默認參數 2 print(name,age,sex) 3 4 register('asb',age=40) 5 register('a1sb',39) 6 register('a2sb',30) 7 register('a3sb',29) 8 9 register('鋼蛋',20,'female') 10 register('鋼蛋',sex='female',age=19)
ps.默認參數須要注意的問題：
1)默認參數必須跟在非默認參數後。
1 def register(sex='male',name,age): #在定義階段就會報錯 2 print(name,age,sex)
2)默認參數在定義階段就已經賦值了，並且只在定義階段賦值一次(瞭解)。
1 #（瞭解）二：默認參數在定義階段就已經賦值了，並且只在定義階段賦值一次 2 # a=100000000 3 # def foo(x,y=a): 4 # print(x,y) 5 # a=0 6 # foo(1) 7 # 結果: x = 1 y = 100000000
3)默認參數的值一般定義成不可變類型
-
-
- 可變長參數:*args, **kwargs
- *會把溢出的按位置定義的實參都接收，以元組的形式賦值給args
- **會把溢出的按關鍵字定義的實參都接收，以字典的形式賦值給kwargs
- 示例：
-
1 # *args示例 2 # def foo(x,y,*args): # *會把溢出的按位置定義的實參都接收，以元組的形式賦值給args 3 # print(x,y) 4 # print(args) 5 # 6 # foo(1,2,3,4,5) 7 8 # *args示例2 9 # def add(*args): 10 # res=0 11 # for i in args: 12 # res+=i 13 # return res 14 # print(add(1,2,3,4)) 15 # print(add(1,2)) 16 17 18 # **kwargs示例 19 # def foo(x, y, **kwargs): # **會把溢出的按關鍵字定義的實參都接收，以字典的形式賦值給kwargs 20 # print(x, y) 21 # print(kwargs) 22 # foo(1,2,a=1,name='egon',age=18) 23 24 # **kwargs示例2 25 # def foo(name,age,**kwargs): 26 # print(name,age) 27 # if 'sex' in kwargs: 28 # print(kwargs['sex']) 29 # if 'height' in kwargs: 30 # print(kwargs['height']) 31 # 32 # foo('egon',18,sex='male',height='185') 33 # foo('egon',18,sex='male')
-
-
- 命名關鍵字參數(瞭解)：*後定義的參數爲命名關鍵字參數，這類參數，必須被傳值，並且必須以關鍵字實參的形式去傳值
-
1 # def foo(name,age,*,sex='male',height): 2 # print(name,age) 3 # print(sex) 4 # print(height) 5 # #*後定義的參數爲命名關鍵字參數，這類參數，必須被傳值，並且必須以關鍵字實參的形式去傳值 6 # foo('egon',17,height='185')
c.綜合實例應用：
-
-
- 首先爲參數的應用順序：def foo(name,age=10,*args,sex='male',height,**kwargs): 位置參數，默認參數，*可變長參數，命名參數，關鍵參數，**可變長參數
-
ps.不建議都用，會形成相互串擾
1 # def foo(name,age=10,*args,sex='male',height,**kwargs): 2 # print(name) 3 # print(age) 4 # print(args) 5 # print(sex) 6 # print(height) 7 # print(kwargs) 8 # 9 # foo('alex',1,2,3,4,5,sex='female',height='150',a=1,b=2,c=3)
-
-
- 其餘實例：（*args， **kwargs）
-
1 # *args參數將位置參數轉化過程：轉化爲元祖 2 # def foo(*args): 3 # print(args) 4 5 # foo(1,2,3,4) # 1,2,3,4 <=====>*(1,2,3,4) 6 7 #*['A','B','C','D'],=====>'A','B','C','D' 8 # foo(*['A','B','C','D']) #foo('A','B','C','D') 9 # foo(['A','B','C','D']) # 10 11 # list實參加*回傳 12 # def foo(x,y,z): 13 # print(x,y,z) 14 # 15 # # foo(*[1,2,3]) #foo(1,2,3) 16 # foo(*[1,2]) #foo(1,2) 17 18 # **kwargs將關鍵參數轉換爲字典 19 # def foo(**kwargs): 20 # print(kwargs) 21 # 22 # #x=1,y=2 <====>**{'y': 2, 'x': 1} 23 # # foo(x=1,y=2) 24 # 25 # foo(**{'y': 2, 'x': 1,'a':1}) #foo(a=1,y=2,x=1) 26 27 # dict實參加**回傳 28 # def foo(x,y,z): 29 # print(x,y,z) 30 # 31 # # foo(**{'z':3,'x':1,'y':2}) #foo(x=1,z=3,y=2) 32 # foo(**{'z':3,'x':1}) #foo(x=1,z=3) 33 34 # 綜合1基礎 35 # def foo(x,y,z): 36 # print('from foo',x,y,z) 37 # 38 # def wrapper(*args,**kwargs): 39 # print(args) 40 # print(kwargs) 41 # 42 # 43 # wrapper(1,2,3,a=1,b=2) 44 45 46 # 綜合函數調用 47 # def foo(x,y,z): 48 # print('from foo',x,y,z) 49 # def wrapper(*args,**kwargs): 50 # print(args) #args=(1,2,3) 51 # print(kwargs) #kwargs={'a':1,'b':2} 52 # foo(*args,**kwargs) #foo(*(1,2,3),**{'a':1,'b':2}) #foo(1,2,3,b=2,a=1) 53 # # wrapper(1,2,3,a=1,b=2) 54 # wrapper(1,z=2,y=3) 55 56 57 # 綜合函數調用 -- 錯誤 58 # def foo(x,y,z): 59 # print('from foo',x,y,z) 60 # def wrapper(*args,**kwargs): 61 # # print(args) #args=(1,) 62 # # print(kwargs) #kwargs={'y':3,'z':2} 63 # foo(*args,**kwargs) #foo(*(1,),**{'y':3,'z':2}) #foo(1,z=2,y=3) 64 # # wrapper(1,2,3,a=1,b=2) 65 # wrapper(1,z=2,y=3)
四、函數的返回值
a.返回值爲None
1 # def foo(): 2 # print('from foo') 3 # return None 4 # res=foo() 5 # print(res) 6 7 ''' 8 如下三種狀況返回值都爲None： 9 沒有return 10 return 什麼都不寫 11 return None 12 '''
b.return 一個值 函數調用返回的結果就是這個值
1 # def foo(): 2 # print('from foo') 3 # x=1 4 # return x 5 # res=foo() 6 # print(res) 7 8 #return 一個值 函數調用返回的結果就是這個值
c.return 多個值
1 # def foo(): 2 # print('from foo') 3 # x=1 4 # return 1,[2,3],(4,5),{} 5 # res=foo() 6 # print(res) #打印結果：(1,[2,3],(4,5),{}) 7 # a,b,c,d=foo() 8 # print(d) 9 10 #return 值1,值2，值3,... 返回結果:(值1,值2，值3,...) 11 12 # t=(1,2,3) 13 # a,_,_=t # 不想要後面的值_ 14 # print(a) 15 16 # t=(1,2,3,4,5,6,7,8,9) 17 # a,*_,c=t # 不想要中心的值*_ 18 # print(a) 19 # print(c)
五、函數的調用
按照有參和無參能夠將函數調用分兩種:
a. 定義時無參，調用時也無需傳入參數。b. 定義時有參，調用時也必須有參數。
1 def foo(): 2 print('from foo') 3 4 def bar(name): 5 print('bar===>',name) 6 7 # 按照有參和無參能夠將函數調用分兩種 8 foo() #定義時無參，調用時也無需傳入參數 9 bar('egon') #定義時有參，調用時也必須有參數
按照函數的調用形式和出現的位置，分三種：
a. 調用函數的語句形式。b. 調用函數的表達式形式。c. 把函數調用當中另一個函數的參數。
1 #按照函數的調用形式和出現的位置，分三種 2 3 foo() #調用函數的語句形式 4 5 def my_max(x,y): 6 res=x if x >y else y 7 return res 8 9 # res=my_max(1,2)*10000000 #調用函數的表達式形式 10 # print(res) 11 12 13 res=my_max(my_max(10,20),30) #把函數調用當中另一個函數的參數 14 print(res)
六、自定義函數
a.先定義後使用，若是沒有定義而直接使用，就至關於引用了一個不存在的變量名
1 #錯誤 2 # foo() 3 # def foo(): 4 # print('from foo') 5 # print(foo)
b.定義函數的三種形式：無參數函數，有參函數，空函數
1 #一：無參數函數：若是函數的功能僅僅只是執行一些操做而已，就定義成無參函數，無參函數一般都有返回值 2 # def print_star(): 3 # print('#'*6) 4 5 #二：定義有參函數:函數的功能的執行依賴於外部傳入的參數，有參函數一般都有返回值 6 # def my_max(x,y): 7 # res=x if x >y else y 8 # return res 9 10 #三：空函數：佔位，定程序結構 11 12 # def auth(): 13 # """認證功能""" 14 # pass 15 # auth() 16 # def insert(): 17 # """插入功能""" 18 # pass 19 # def select(): 20 # """查詢功能""" 21 # pass 22 # def delete(): 23 # """刪除功能""" 24 # pass 25 # def update(): 26 # """更新功能""" 27 # pass
ps.三元表達式
1 # x=10 2 # y=2 3 # if x > y: 4 # print(x) 5 # else: 6 # print(y) 7 # 8 # res=x if x > y else y 9 # print(res)
函數待續......
相關文章
- 1. python-初識python
- 2. Python - 初識Python
- 3. Python——初識Python
- 4. Python-初識python
- 5. python初識（二） python初識（一）
- 6. JavaScript初識(三)
- 7. JAVA初識（三）
- 8. ansible初識三
- 9. 初識三層
- 10. 三層--初識
- 更多相關文章...
- • SQLite - Python - SQLite教程
- • Docker 安裝 Python - Docker教程
- • 適用於PHP初學者的學習線路和建議
- • RxJava操作符（三）Filtering
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. python-初識python
- 2. Python - 初識Python
- 3. Python——初識Python
- 4. Python-初識python
- 5. python初識（二） python初識（一）
- 6. JavaScript初識(三)
- 7. JAVA初識（三）
- 8. ansible初識三
- 9. 初識三層
- 10. 三層--初識