1。文章內容：
筆記1 內容：基礎資料和語法：字串、數字、判斷、迴圈
筆記2 內容：資料容器：列表、元組、集合、字典
筆記4 內容：資料結構、檔案輸入和輸出
2。使用書籍、教程：《父與子的變成之旅》、《菜鳥教程》此文為學習筆記直接引用部分不另做標註；
3。本文大綱：本文完整網路圖請戳：Python學習網路圖
Python3 函式 | 菜鳥教程
▌含義
函式把程式分解成較小的、可以重複使用的部分；
函式就是可以完成某個工作的程式碼塊。
▌把程式分解成較小部分的三種方法對比
函式（function）：程式碼塊類似積木可反覆使用
物件（object）：把程式中各部分描述成自包含的單元
模組（module）：包含程式各個部分的單獨檔案
1。1 建立函式
① 主函式開始
② 呼叫函式時會跳到函式中的第一行程式碼
③ 執行函式中的每一行程式碼
④ 函式完成時回到離開主程式的位置繼續執行
1。2 呼叫函式
即執行函數里的程式碼；
呼叫格式是： functionname（），括號中可以有引數。
1。3 向函式傳遞引數
引數就是你交給函式的一條資訊
1。3。1 使用方法
定義函式時在括號（）內定義引數（變數）的數量
def
printMyAddress
（
myName
）
呼叫函式時（）內填寫的引數的
值
會賦給myName
def
printMyAddress
（
myName
）：
#向函式傳遞引數myName
（
myName
）
（
“123 Main Street”
）
#空格標誌函式程式碼塊結束，方便後續維護程式碼
printMyAddress
（
“Carter Sande”
）
#將字串“Carter Sander”作為引數傳遞給函式
輸出結果
Carter
Sande
123
Main
Street
1。3。2 引數型別
▌不可變物件：數字numbers 、字串strings、元組 tuples
#例子：傳遞不可變引數（數字）
def
ChangeInt
（
a
）：
#把b的值2賦給a（2現在有兩個“標籤”a和b）
a
=
10
#重新給a賦值10
#空行標誌一段程式碼的結束，便於程式碼維護，空行是程式碼的一部分
b
=
2
#給b賦值為數字2（不可變物件數字）
ChangeInt
（
b
）
#把值2傳遞給函式內參數a
（
b
）
輸出結果
2
▌可變物件：列表list、字典
dict
# 例子：傳遞可變引數（列表）
def
changeme
（
mylist
）：
“修改傳入的列表”
#第一行可以選擇性的使用字串新增對函式的說明
mylist
。
append
（［
1
，
2
，
3
，
4
］）
（
“函式內取值：”
，
mylist
）
#空行標誌一段程式碼的結束，便於程式碼維護，空行是程式碼的一部分
mylist
=
［
10
，
20
，
30
］
changeme
（
mylist
）
#呼叫函式changeme
（
“函式外取值：”
，
mylist
）
輸出結果
函式內取值
：［
10
，
20
，
30
，
［
1
，
2
，
3
，
4
］］
函式外取值
：［
10
，
20
，
30
，
［
1
，
2
，
3
，
4
］］
1。4 有多個引數的函式
函式可以有多個引數，但一般超過5、6 個就要考慮其他方法比如吧引數收集到列表中
1。4。1 必須引數
定義函式時設定幾個引數，呼叫函式時就要有傳遞幾個引數，引數的數量不能少順序不能變
def
printMyAddress
（
someName
，
houseNum
）：
#函式有兩個引數
（
“name：”
，
someName
）
（
“house number：”
，
houseNum
）
printMyAddress
（
“Carter Sande”
，
“45”
）
#向函式傳遞兩個引數
輸出結果
name
：
Carter
Sande
house
number
：
45
1。4。2 關鍵字引數
允許
函式呼叫
時引數的順序與宣告時不一致
def
printMyAddress
（
someName
，
houseNum
）：
（
“name：”
，
someName
）
（
“house number：”
，
houseNum
）
printMyAddress
（
houseNum
=
“45”
，
someName
=
“Carter Sande”
）
#引數順序與宣告時不一樣
輸出結果
name
：
Carter
Sande
house
number
：
45
1。4。3 預設引數
呼叫函式時，如果沒有傳遞引數，則會使用預設引數，預設引數需要在定義函式時設定好
def
printinfo
（
name
，
age
=
35
）：
#定義函式時設定age預設值為35
“列印任何傳入的字串”
（
“名字： ”
，
name
）
（
“年齡： ”
，
age
）
return
printinfo
（
age
=
50
，
name
=
“runoob”
）
#傳遞age、name兩個引數
（
“————————————”
）
printinfo
（
name
=
“runoob”
）；
#只傳遞name一個引數，age將使用預設值
輸出結果
名字
：
runoob
年齡
：
50
————————————
名字
：
runoob
年齡
：
35
1。4。4 不定長引數
希望呼叫函式時需要傳遞
引數的具體數量不受限制
時設定不定長引數，將不確定數量的引數設定為一個
元組
，傳遞引數時將引數存放在元組中
#格式
def
functionname
（［
fomal_args
，］
*
var_args_tuple
）：
“函式_文件字串”
function_suite
return
［
expression
］
加*號的變數名會存放所有未命名的變數引數，沒有指定引數時就是一個空元組
可向函式傳遞未命名變數也可不向函式傳送未命名變數
def
printinfo
（
arg1
，
*
vartuple
）：
“列印任何傳入的引數”
#函式程式碼塊第一行允許有一行字串作為說明
（
“輸出：”
）
（
arg1
）
for
var
in
vartuple
：
#var表示數字資料型別
（
var
）
return
printinfo
（
10
）
printinfo
（
70
，
60
，
50
）
輸出結果
輸出
：
10
輸出
：
70
60
50
1。5 返回值的函式
含義：
函式可以向呼叫者發回資訊，返回的值稱為結果或返回值
返回值就是函式返回給呼叫者的東西
def
calculateTax
（
price
，
tax_rate
）：
taxTotal
=
price
+
（
price
*
tax_rate
）
return
taxTotal
（
calculateTax
（
7。99
，
0。06
））
輸出結果
8。4694
1。6
變數作用域
1。6。1 區域性變數
函式內部的變數在函式執行時才會被建立，執行前不存在，執行後會被刪除
1。6。2 全域性變數
函式外部主程式中的變數，在主程式中可以用，在函式中也可以用但不能改變它，如果在函式內部直接給全域性變數賦新值，會重新建立一個與全域性變數同名的區域性變數，全域性變數的值不會被改變。
1。6。3 global，在函式內修改全域性變數
global+函式名，可在函式內修改全域性變數，如果沒有該全域性變數就會建立一個。
num
=
1
def
fun1
（）：
global
num
#修改全域性變數的關鍵字
（
num
）
num
=
123
（
num
）
fun1
（）
輸出結果
1
123
1。6。4 nonlocal，修改巢狀作用域外層的非全域性作用域中的變數
def
outer
（）：
num
=
10
#num在函式outer中是區域性變數
def
inner
（）：
nonlocal
num
#修改outer函式作用域中的變數num
num
=
100
（
“內層函式num值為：”
，
num
）
inner
（）
（
“外層函式num值為：”
，
num
）
outer
（）
輸出結果
內層函式num值為
：
100
外層函式num值為
：
100
1。7 匿名函式
格式：
lambda
［
arg1
［，
arg2
，
。。。
argn
］］：
expression
使用方法：
lambda只是一個表示式，只能寫一行，擁有自己的名稱空間，不能訪問自己引數列表之外或全域性命名空間裡的引數
sum
=
lambda
arg1
，
arg2
：
arg1
+
arg2
（
“相加後的值為：”
，
sum
（
10
，
20
））
（
“相加後的值為：”
，
sum
（
20
，
20
））
輸出結果
相加後的值為
：
30
相加後的值為
：
40
Python3 面向物件 | 菜鳥教程
前面討論過的幾種組織資料和程式的方法
列表：收集變數（資料）
函式：可以把一些程式碼收集到能夠反覆使用的單元中
物件：可以把函式和資料收集在一起
我們成為Python是面向物件的，Python中的一切幾乎都是物件
2。1 什麼是物件
物件=屬性+方法
可以利用物件把一個東西的屬性和方法收集起來，屬性是資訊，方法是動作
2。1。1 屬性
一個物件的特徵，就是你所知道（或可以得出）的關於一個物件的所有方面，物件的屬性就是一些資訊（數字、字串等），其實就是包含在物件中的變數。
這些屬性可以顯示，可以為它們賦值，可以把它們賦值給常規不是變數的物件，可以把它們賦值給其他物件的屬性。
2。1。2 方法
動作或能夠對物件做的操作，它們是一些程式碼塊，可以呼叫這些程式碼塊來完成某個工作，方法就是包含在物件中的函式。
函式能做到的方法都能做到，包括傳遞引數和返回值。
2。1。3 使用
物件屬性
和方法一種記法
object。attribute
object。method（）
2。2 建立物件
分為兩步
2。2。1 定義一個類（class）
類好比蓋房子用的藍圖，它告訴你房子看上去怎麼樣，但藍圖本身並不是一個房子
同樣類描述了物件的屬性和方法，但這個描述並不會真正建立一個物件
建立一個球的Python版本，先定義一個Ball類，類名約定俗成首字母大寫：
class
Ball
：
def
bounce
（
self
）：
if
self
。
direction
==
“down”
self
。
direction
=
“up”
這裡類只建立了方法，因為屬性屬於各個例項，而不屬於類
但可以在建立類的時候設定屬性，稱為初始化物件，使用_
_init__()
，只要建立建立這個類的新例項就會執行這個方法，可以向_
_init__()
方法傳遞引數，這樣建立例項時就會把屬性設定為你希望的值，__init__（）
左右兩邊的下劃線都是兩根
class
Ball
：
def
_int_
（
self
，
color
，
size
，
direction
）：
self
。
color
=
color
self
。
size
=
size
self
。
direction
=
direction
def
bounce
（
self
）：
#建立一個方法
if
self
。
direction
==
“down”
self
。
direction
=
“up”
2。2。2 建立類的例項
使用類建立一個真正的物件
對於沒有初始化的物件需要建立屬性
myBall
=
Ball
（）
myBall
。
direction
=
“down”
myBall
。
color
=
“green”
myBall
。
size
=
“small”
對於已經初始化的物件可以把屬性作為引數
class
Ball
：
def
__init__
（
self
，
color
，
size
，
direction
）：
#初始化屬性
self
。
color
=
color
self
。
size
=
size
self
。
direction
=
direction
def
bounce
（
self
）：
#建立一個方法
if
self
。
direction
==
“down”
：
self
。
direction
=
“up”
myBall
=
Ball
（
“rea”
，
“small”
，
“down”
）
#建立一個例項
（
“I just created a ball。”
）
（
“My ball is ：”
，
myBall
。
size
）
（
“My ball is ：”
，
myBall
。
color
）
（
“My ball‘s direction is ：”
，
myBall
。
direction
）
（
“Now I’m going to bounce the ball”
）
（）
myBall
。
bounce
（）
（
“Now the ball‘s directon is ：”
，
myBall
。
direction
）
輸出結果
I
just
created
a
ball
。
My
ball
is
：
small
My
ball
is
：
rea
My
ball
’s direction is ： down
Now
I
‘m going to bounce the ball
Now
the
ball
’s directon is ： up
2。2。3 例項引用
建立一個類以後，可以建立多個物件例項，呼叫其中一個時，方法必須知道是哪個例項呼叫了它，這需要使用一個引數，約定俗稱的我們把它寫作
self
在定義方法時我們這樣寫：
def
bounce
（
self
）：
在呼叫方法時我們通常寫成：
myBall
。
bounce
（）
實際上相當於寫成：
Ball
。
bounce
（
myBall
）
這樣方法就知道是myBall這個例項在呼叫它，這稱為例項引用，self 稱為例項引用名，它並不是一個關鍵字，只是約定俗成的寫法，這樣能使你的程式碼方便他人閱讀使用。
2。3 定義列印內容
想要列印一個物件如使用print（object）Python會預設以下內容：
例項在哪裡定義
類名
儲存例項的記憶體位置
如果希望列印你想要的內容，需要使用
__str__()
，這個方法會告訴Python列印一個物件時具體列印什麼內容
class
Ball
：
def
__init__
（
self
，
color
，
size
，
direction
）
self
。
color
=
color
self
。
size
=
size
self
。
direction
=
direction
def
__str__
（
self
）：
mag
=
“Hi，I‘m a ”
+
self
。
size
+
“ ”
+
self
。
color
+
“ ball！”
return
mag
myBall
=
Ball
（
“rad”
，
“small”
，
“down”
）
（
myBall
）
輸出結果
Hi
，
I
’m a small rad ball！
2。4 多型和繼承
2。4。1 多型
同一個方法，不同的行為
對於不同的類，可以有同名的兩個（或多個）方法，取決於這些方法分別應用到哪個類，它們可以有不同的行為。
2。4。2 繼承
向父母學習
從其他類繼承屬性或方法的類稱為
派生類
或子類
class
Parent
（）：
#建立父類
def
__init__
（
self
，
last_name
，
eye_color
）：
（
“parent Constructor Called”
）
#打印表示父類被呼叫
self
。
last_name
=
last_name
#建立父類屬性
self
。
eye_color
=
eye_color
class
Child
（
Parent
）：
#定義子類
def
__init__
（
self
，
last_name
，
eye_color
，
number_of_toys
）：
（
“Child Constructor Called”
）
#打印表示子類被呼叫
Parent
。
__init__
（
self
，
last_name
，
eye_color
）
#繼承父類的屬性
self
。
number_of_toys
=
number_of_toys
#建立子類的新屬性
miley_cyrus
=
Child
（
“Cyrus”
，
“blue”
，
5
）
（
miley_cyrus
。
last_name
）
（
miley_cyrus
。
number_of_toys
）
輸出結果
Child
Constructor
Called
#首先建立子類例項，子類被呼叫
parent
Constructor
Called
#需要列印從父類繼承的屬性 last_name，父類被呼叫
Cyrus
#列印繼承來的屬性 last_name
5
#列印子類屬性 number_of_toys
2。5 佔位符
有時我們向定義一個方法，但還沒有完全想好，於是會用到
pass
關鍵字，作為一個佔位符，因為函式不能為空
class
Parent
（）：
def
pickup
（
self
）：
pass
#目前只有一些想法，回頭補上
Python3 模組 | 菜鳥教程
3。1 什麼是模組
模組是包含在一個更大程式中的類似的一部分，每個模組或部分都是硬碟上的一個單獨的檔案。
函式類似於積木，模組就是裝積木的桶，可以把類似的函式收集在一起，或者把一個專案需要的函式收集在一起
3。2 為什麼使用模組
使檔案變得更小，方便查詢程式碼
可以重複使用
並不是所有模組都要使用
3。3 如何創
建模
塊
#this is the file “my_module。py”
#we‘er going to use it in another program
def
c_to_f
（
celsius
）：
fahrenheit
=
celsius
*
0。9
/
5
+
32
return
fahrenheit
在一個檔案中定義函式 c_to_f（），將檔案另存為（在
jupyter notebook
中點選File→Download as→Python（。py））。py檔案
3。4 如何使用模組
在主程式中，使用關鍵字
import
匯入模組，呼叫my_module 模組中的函式，因為想要呼叫的函式和主程式不在同一個檔案中所以要用import，把模組包含到程式中
3。4。1 名稱空間
區域性名稱空間 較小的名稱空間如函式中
全域性名稱空間 較大的名稱空間如模組中，主程式中
匯入模組就是匯入一個名稱空間
在網上看到一篇專門講名稱空間的文章，可以作為參考：Python名稱空間的本質
3。4。2 匯入模組的兩種方式
▌使用
import
匯入的模組仍然是一個單獨的名稱空間，所以在呼叫模組中函式的時候需要在函式名前指出模組名
import
my_module
celsius
=
float
（
input
（
“Enter a temperature in Celsius”
））
fahrenheit
=
my_module
。
c_to_f
（
celsius
）
（
“That’s ”
，
fahrenheit
，
“degrees Fahrenheit”
）
輸出結果
Enter
a
temperature
in
Celsius40
That
‘s 104。0 degrees Fahrenheit
▌用
from
匯入會把模組中的函式包含到主程式的名稱空間中，就可以直接在主程式中使用函式名呼叫函式
from
my_module
import
c_to_f
celsius
=
float
（
input
（
“Enter a temperature in Celsius”
））
fahrenheit
=
c_to_f
（
celsius
）
（
“That’s ”
，
fahrenheit
，
“degrees Fahrenheit”
）
輸出結果
Enter
a
temperature
in
Celsius40
That
‘s 104。0 degrees Fahrenheit
如果想要把模組裡的所有函式都包含到主程式中可以用
*
表示全部函式
from
my_module
import
*
3。5 標準模組
Python提供了大量標準模組，可以完成很多工作，如查詢檔案、報時、生成
隨機數
等等，一些標準模組需要單獨下載。
—完—
筆記4 內容：資料結構、檔案輸入和輸出
