python基礎語法學習筆記

一、程式的基本格式

1.1 縮進

1.使用tab制表符或空格表示縮進，默認為一個制表符或4個空格為一個層級，（編輯器可自動調整tab為四個空格）
2.同一程式內縮進數量應保持一致，

age = int(input("請輸入您的年齡："))
if abs(age) >= 18:
    print("您已成年")
else:
    print("您還是未成年")

1.2 大小寫

python區分大小寫，python和Python代表兩個物件，

1.3 注釋

注釋表示該陳述句在程式運行時不被執行，單行注釋使用【# 注釋陳述句】，多行注釋采用【’’'注釋陳述句‘’‘】，

name = "杰尼龜"
name = "水箭龜"
Name = "皮卡丘"
print(name) #結果為水箭龜
print(Name) #結果為水卡丘

'''python里區分大小寫，變
量命名時應注意使用'''

1.4 行連接符及【;】的使用

python中一行代碼過長時可在想換行處使用行連接符【\】，進行換行撰寫，程式還是會認為它在同一行，

print("隨便打一串文\
字做一下測驗")

如果想把幾行代碼寫為一行，可用【；】進行連接，

num = 2 ; result = num + 3 
print(result) 

4.轉義字符

Python 支持的轉義字符

二、程式的構成

2.1 物件

python中一切皆物件

1.每個物件皆有對應的標識（id）、型別（type）、值（value），
2.變數通過存盤物件ID對其進行參考，
3.物件只能進行與其型別對應相關操作，

2.2 識別符號

用于變數、函式、類、模塊等的名稱

命名規則：

a.區分大小寫，如：zxl和Zxl是不同的；
b.第一個字符必須是字母、下劃線，其后字符是字母、下劃線、數字；
c.不能使用關鍵字，如：if、elif、or等；
d.以雙下劃線開頭和結尾的名稱通常由特殊含義，盡量避免此種寫法，如：__init__是類的建構式，

python保留字符（僅包含小寫字母部分）

特殊命名約定

2.3 變數（變數作用域：全域變數、區域變數詳見擴充部分）

程式就是用來處理資料的，而變數就是用來參考資料的；python中的變數不需要指明型別，系統會自動識別，

變數的初始化（賦值）

利用【=】號進行賦值：變數名 = 運算式

a = "杰尼龜" #id = 1612667500272 type:str
print(id(a),type(a))

python執行程式從上往下執行，如果后續代碼中為變數重新指代了值，以前的那個值會被替換，并被python進行垃圾回收，

變數的賦值方式

鏈式賦值：將一個物件同時賦值給多個變數，
變數1 = 變數2 = 物件1

a = b = "杰尼龜"  
print(a,b) #結果為杰尼龜 杰尼龜

解包賦值
解包賦值可使用串列、元組、字典，方便我們對多個變數進行賦值
元組解包

(a , b , c) = (1 , 2 , 3) #等同于 a,b,c = 1,2,3
print(a , b , c) #結果為1 2 3

串列解包

[a,b,c] = [[1,2],3,[4,5]]
print(a) #結果為[1, 2]
print(b) #結果為3
print(c) #結果為[4, 5]

字典解包：字典解包時，默認是對鍵進行操作，如果想對值進行解包賦值，需使用values(),如果是想對鍵值對整體賦值，需使用items()（回傳結果為元組型別），

s = {"name":"杰尼龜","age":18,"color":"yellow"}
a,b,c = s
print(a,b,c) #結果為name age color
a,b,c = s.values()
print(a,b,c) #結果為杰尼龜 18 yellow
a,b,c = s.items()
print(a,b,c) #結果為('name', '杰尼龜') ('age', 18) ('color', 'yellow')

變數值互換

變數1，變數2 = 物件1 ，物件2
變數1，變數2 = 變數2 ， 變數1

a , b = 1 , 2
a , b = b , a
print(a,b) #結果為2 1

洗掉變數

可通過del洗掉不再使用的變數，

a = b = "杰尼龜"
del a
print(b) #結果為杰尼龜
print(a) #拋出例外：name 'a' is not defind

變數洗掉后，變數指代的物件依然存在，但是沒有變數參考的物件會被python垃圾回收器回收，清除記憶體空間

2.5 程式的輸入與輸出

輸入函式

python利用內置函式input()來獲取控制臺鍵盤輸入的內容，并將內容存盤于變數，

【變數 =input(“提示資訊”) 】

age = input("請輸入您的年齡：") 
print(type(age)) #結果為<class 'str'>

獲取到的資料會存盤為字串型別

列印函式

python通過print()函式將程式運行結果輸出值控制端，

【print(想要輸出的結果，end = “任意字串”)】

age = input("請輸入您的年齡：") #輸入25
print(type(age)) #結果為<class 'str'>
print(age) #結果為25

逗號后可不寫，不寫則為默認的end = “\n”

不換行列印

呼叫print()函式時默認結尾為換行符，可調整為其他字串，使函式進行不換行列印，

a , b = 1 , 2
print(a,end="**") #結果為1**2（在同一行，不會換行）
print(b) #如不加end=str，默認為end= "\n"

三、基本資料型別

3.1 布爾型（bool）

1.布林值的創建

布爾型中只有True和False兩個值，表示真和假（注意大小寫）；

2.布林值的運算

a.作為布林值使用時通常搭配邏輯運算子與（and）或（or）非（not）進行使用，
b.也可做為數字1和0使用（True為1，False為0），

#and：一假回傳假，or:一真回傳真,not :回傳相反值
print(True and True) #結果為True
print(True and False) #結果為False
print(False and False) #結果為False
print(True or True) #結果為True
print(True or False) #結果為True
print(False or False) #結果為False
print(not False) #結果為False
print(not True) #結果為False.
print(True + 1) #結果為2
print(False + 1) #結果為1

3.2 數字型

1.整數型（int）

即為數學上的整數，例如：1，2，25，30等，

2.浮點型（float）

即為數學上的小數，包含.0小數，例如1.5，2.83，17.0等，

3.算術運算子

以下假設變數 a=10，b=20：

當整數與浮點數進行運算時，回傳的值默認為浮點數，

a , b = 2 , 2.5
print(type(a * b)) #結果為<class 'float'>

4.數字格式化

下表展示了 str.format() 格式化數字的多種方法：

a = 3.1415926
print("{:.2f}".format(a)) #結果為3.14

'{:b}'.format(11)
'{:d}'.format(11)
'{:o}'.format(11)
'{:x}'.format(11)
'{:#x}'.format(11)
'{:#X}'.format(11)

1011
11
13
b
0xb
0XB

^，<，>分別是居中、左對齊、右對齊，后面帶寬度，: 號后面帶填充的字符，只能是一個字符，不指定則默認是用空格填充，
+表示在正數前顯示+，負數前顯示-，（空格）表示在正數前加空格
b、d、o、x 分別是二進制、十進制、八進制、十六進制，

5.其他操作

divmod()函式：同時得到商和余數，

a = 10
b = 3
print(divmod(a,b)) #結果為元組（3，1）

round()函式：將浮點數四舍五入，

a = 3.678
print(round(a))#結果為4

chr()：用一個范圍在 range（256）內的（就是0～255）整數作引數，回傳一個對應的字符（引數可以是16進制或者10進制），

a = 66 #十進制
b = 0x68 #十六進制
print(chr(a)) #結果為B
print(chr(b)) #結果為B

3.3 字串型（str）

是一種不可變的字符序列：后續所有拼接/修改操作均為形成新的字串資料（標點符號及空格也是字符），

1.字串的創建

利用單引號（‘xxx’）/雙引號（“xxx”）進行創建，

a = '杰尼龜' ; b = "可達鴨"
c = "my name is '杰尼龜'"
print(type(a),type(b)) #結果為<class 'str'>

多行字串（‘’‘xxxxxxx’’’)進行創建，

a = '''杰
尼
龜'''
print(type(a)) #結果為<class 'str'>

2.字串的拼接

使用【+】號進行拼接，生成一個新的拼接后的字串物件，

a ,b , c= '杰尼龜' , "可達鴨" ,111
print(a + str(c) + b)#結果為杰尼龜111可達鴨

直接字串相接也可拼接

c= '杰尼龜' '暴打'"可達鴨"
print(c)#結果為杰尼龜暴打可達鴨

“”.join(list)：將串列中字串用特定字符拼接起來，不指定字符默認為直接拼接，

a = ['我', '叫', '杰', '尼', '龜']
print("".join(a)) #結果為我叫杰尼龜
print("*".join(a)) #結果為我*叫*杰*尼*龜

使用【+】，每【+】一次會形成一個新的物件，使用join在拼接字串之前會計算所有字串的長度，然后逐一拷貝，僅新建一次物件，大型運算時推薦使用join

3.字串的復制

字串可直接使用乘法運算子進行復制

c = '杰尼龜'
print(c * 3)#結果為杰尼龜杰尼龜杰尼龜

4.檢查字串

str.isdigit()：檢查字串內部是否全部是數字，回傳True或False，

c = '123456'
print(c.isdigit())#結果為True
c = '123 456'
print(c.isdigit())#結果為False

str.isalpha()：檢查字串內部是否全是字母，回傳True或False，

c = 'asdfgh'
print(c.isalpha())#結果為True
c = 'asdfgh123'
print(c.isalpha())#結果為False

str.isupper()：檢查字串內部是否全是大寫字母，回傳True或False，

c ='ASDFGH'
print(c.isupper())#結果為True
c =  'asdfgh'
print(c.isupper())#結果為False

str.islower()：檢查字串內部是否全是小寫字母，回傳True或False，

c ='asdfgh'
print(c.islower())#結果為True
c ='ASDFGH'
print(c.islower())#結果為False

str.endswith()：檢查字串內部是否以指定字串結尾，回傳True或False，

c ='asdfgh'
print(c.endswith("gh"))#結果為True

str.startswith()：檢查字串內部是否以指定字串開頭，回傳True或False，

c ='ASDFGH'
print(c.startswith("AS"))#結果為True

str.isspace()：檢查字串內部是否全是空格，回傳True或False，

c =' '
print(c.isspace())#結果為True

5.查找字串

len()：查找字串的長度，回傳長度數值，

c ='123456789'
print(len(c))#結果為9

str.find()：查找指定字符在字串中從左往右第一次出現的位置，有則回傳字符下標（編號），沒有回傳-1，

c ='123456789'
print(c.find("3"))#結果為2
print(c.find("10"))#結果為-1

str.rfind()：查找指定字符在字串中從右往左第一次出現的位置，有則回傳字符下標（編號），沒有回傳-1，

c ='1234567289'
print(c.rfind("2"))#結果為7
print(c.rfind("10"))#結果為-1

str.index()：查找指定字符在字串中第一次出現的位置，有則回傳字符下標（編號），沒有拋出例外，

c ='123456789'
print(c.index("9"))#結果為8
print(c.index("10"))#結果為ValueError: substring not found

str.count()：查找指定字符在字串中總共出現次數，回傳數量，

c ='123456789123465184'
print(c.count("1"))#結果為3
print(c.count("10"))#結果為0

6.“修改”字串

python中字串本身為不可修改型別，所有修改操作均為創建新的物件，原字串不做改變，

str.replace(“old”,“new”)：使用指定字符替換字串中對應字符，

a = "hello world"
print(a.replace("o","0"))#結果為hell0 w0rld

str.upper()：將字串內部字母轉換為大寫字母，

a = "12345asdf"
print(a.upper())#結果為12345ASDF

str.lower() ：將字串內部字母轉換為小寫字母，

a = "12345ASDF"
print(a.lower())#結果為12345asdf

str.capitalize()：將一個字串的第一個字符改為大寫字母，其余字母變小寫，如果第一個字符不是字母，則僅將后續字母改為小寫，

a = "12345ASDF"
print(a.capitalize())#結果為12345asdf
a = "a2345ASDF"
print(a.capitalize())#結果為A2345asdf

str.split()：將字串按照指定字符進行分割為多個字串并存盤在串列中，如不指定字符，默認為空格、換行符、制表符，

a = "我 叫 杰 尼 龜"
b = "我*叫*杰*尼*龜"
print(a.split())#結果為['我', '叫', '杰', '尼', '龜']
print(b.split("*"))#結果為['我', '叫', '杰', '尼', '龜']

str.title()：將字串中每個單詞的首字母大寫，其余改為小寫

a = "my name"
b = "MY NAME"
print(a.title())#結果為My Name
print(b.title())#結果為My Name

str.swpacase()：將字串中所有字母大小寫互換

a = "My Name"
print(a.swapcase())#結果為mY nAME

str.strip()：將字串中首尾的指定字符去除

a = '**杰尼*龜*'
print(a.strip("*")) #結果為杰尼*龜

str.lstrip()：將字串中左側的指定字符去除

a = '**杰尼*龜*'
print(a.lstrip("*")) #結果為杰尼*龜*

str.rstrip()：將字串中左側的指定字符去除

a = '**杰尼*龜*'
print(a.rstrip("*")) #結果為**杰尼*龜

eval()：去除首尾引號，并執行余下陳述句

a = '123'
print(eval(a)+2) #結果為125

ord()：將單字串轉換為對應的Unicode編碼

a = "杰"
print(ord(a)) #結果為26480

7.字串排版

str.center(num,“x”)：填充x字符使字串達到num長度，并將其居中

a = "杰"
print(a.center(5,"*")) #結果為**杰**

str.ljust(num,“x”)：填充x字符使字串達到num長度，并將原字串居左

a = "杰"
print(a.ljust(5,"*")) #結果為杰****

str.rjust(num,“x”)：填充x字符使字串達到num長度，并將原字串居右

a = "杰"
print(a.rjust(5,"*")) #結果為****杰

8.format()函式的應用

使用示例

a = "杰尼龜"
b = "可達鴨"
print("{}暴打{}".format(a,b)) #結果為杰尼龜暴打可達鴨
print("{0}暴打{0}".format(a,b)) #結果為杰尼龜暴打杰尼龜
print("{0}暴打{1}".format(a,b)) #結果為杰尼龜暴打可達鴨
print(f"{a}暴打{b}") #結果為杰尼龜暴打可達鴨

format()函式

print("{0}*{1}={2:*<7}".format(3,2,2*3))

位置索引

關鍵字映射

元素訪問


填充對齊

a , b , c = "杰尼龜" , "可達鴨" , "杰尼龜"
print("{0:*^7}使用火箭頭槌暴打{1:*>7}和{2:*<7}".format(a,b,c)) 
#結果為**杰尼龜**使用火箭頭槌暴打****可達鴨和杰尼龜****

【^，<，>】分別是居中、左對齊、右對齊，后面帶寬度，: 號后面帶填充的字符，只能是一個字符，不指定則默認是用空格填充，

9.字串索引操作

str[num]：找到字串指定位置的字符，

標點符號及空格也是字符

a= "my name is '杰尼龜'"
print(a[3]) #結果為n

10.字串切片操作

str[x:y:±step]：從編號x到編號y之前，從左到右或從右到左以step間隔取值

在切片操作中，起始終止編號不在[0:字串長度-1]這個范圍內也不會報錯，超過0或末端按0和末端截取

3.4型別轉換

在python中可使用內置函式對資料型別進行型別轉換：

① str()：將資料轉換為字串型別；

a , b , c ='123',456,789.5
print(str(b)) ; print(str(c)) #結果為'456' 、 '789.5'

② float()：將純數字字串或整數轉換為浮點數；

a , b , c ='123',456,789.5
print(float(a)) ; print(float(b)) #結果為123.0 、 456.0

③ int()：將純數字字串或浮點數轉換為浮點數，

a , b , c ='123',456,789.5
print(int(a)) ; print(int(c)) #結果為123 、 789

int()函式轉換是直接去掉小數點，而不是四舍五入

四、運算子

1.比較運算子

比較運算符運算結果回傳True和False，

假設:a = 15 ; b = 20

2.邏輯運算子

與（and）、或（or）、非（not）

3.身份運算子

is、not is比較兩個物件的id是否一致

4.成員運算子

in、not in判斷物件是否在物件內部

5.算術運算子

>>> 9//2
4
>>> -9//2
-5

6.賦值運算子

7.位運算子（我也不知道這咋用）

按位運算子是把數字看作二進制來進行計算的，Python中的按位運演算法則如下：
下表中變數 a 為 60，b 為 13，二進制格式如下：

a = 0011 1100
b = 0000 1101

a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011

8.Python運算子優先級

以下表格列出了從最高到最低優先級的所有運算子：

五、串列（list）

串列是一種python內置可變序列，用來存盤不限數量、不限型別的資料集合，

1.串列的創建

方括號創建

方括號內添加資料，使用【，】逗號隔開

l = [1,2,3,"杰尼龜","可達鴨",True,False]
print(type(l)) #結果為<class 'list'>

生成器推導式創建：利用for回圈加條件判斷創建想要的串列

l = [i for i in range(5)]
print(l) #結果為[0, 1, 2, 3, 4]
l = [i+5 for i in range(5) if i <=3]
print(l) #結果為[5, 6, 7, 8]

list()函式創建

使用list函式將可迭代資料轉換為串列

l = list("杰尼龜暴打可達鴨")
print(l) #結果為['杰', '尼', '龜', '暴', '打', '可', '達', '鴨']

使用list函式將range函式轉換為串列：創建整數序列（開始默認為0，步長默認為1），步長正數從小往大數，步長負數從大往小數，開始結束數值應滿足大小關系，否則回傳空串列

l = list(range(5))
print(l) #結果為[0, 1, 2, 3, 4]
l = list(range(3,10,2))
print(l) #結果為[3, 5, 7, 9]
l = list(range(10,3,-2))
print(l) #結果為[10, 8, 6, 4]
l = list(range(3,10,-2))
print(l) #結果為[]

2.增加元素

list.append()：在串列末尾添加單個元素（速度最快，推薦使用），

l = [1]
l.append("10")
print(l) #結果為[1, '10']

list.extend(list1)：將list1添加到list尾部，

l = [1]
l1 = ["10"]
l.extend(l1)
print(l) #結果為[1, '10']

list.extend(list1)：將list1添加到list尾部，

l = [1]
l1 = ["10"]
l.extend(l1)
print(l) #結果為[1, '10']

list.insert()：在串列指定位置添加單個元素，

l = [1,2,3,4,5]
l.insert(3,5)
print(l) #結果為[1, 2, 3, 5, 4, 5]

以上操作均為原地修改，不產生新物件

list1 + list2 ：將串列2添加到串列1尾部（會產生一個新的串列物件，原串列不會改變），

l = [1,2,3,4,5]
l1 = [6,7,8,9,10]
l2 = l + l1
print(l) #結果為[1, 2, 3, 4, 5]
print(l2) #結果為[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list * num ：將原串列復制num份并合并成一個新串列（會產生多個新的串列物件，原串列不會改變），

l = [1,2,3]
l1 = l * 3
print(l) #結果為[1, 2, 3]
print(l1) #結果為[1, 2, 3, 1, 2, 3, 1, 2, 3]

利用切片添加添加成段元素

a = [1,2,3,6]
b = [4,5]
a[2:2] = b
print(a) #結果為[1, 2, 4, 5, 3, 6]

3.洗掉元素

del list[num] ：洗掉串列指定位置的元素，如不指定位置則為洗掉串列本身，

l = [1,2,3]
del l[2]
print(l) #結果為[1, 2]
del l
print(l) #結果為name 'l' is not defined

list.clear() :清除串列中所有元素，不是洗掉串列本身，

l = [1,2,3]
l.clear()
print(l) #結果為[]

list.pop()：提取出串列指定位置的元素，留作他用，

l = [1,2,3]
a = l.pop(1)
print(l) #結果為[1, 3]
print(a) #結果為2

list.remove()：洗掉指定元素在串列中第一次出現的位置，如沒有該元素則拋出例外，

l = [1,2,3,4,3,5]
l.remove(3)
print(l) #結果為[1, 2, 4, 3, 5]

4.查找元素

len(list)：查找串列中元素數量，回傳數量值，

l = [1,2,3,4,3,5]
print(len(l)) #結果為6

sum(list)：純數字串列求和，回傳一個求和的值，

a = [1,2,3,4,5,6,7,8,9]
print(sum(a)) #結果為45

max(list)：查找串列中最大值，回傳最大值元素，

a = [1,2,3,4,5]
print(max(a)) #結果為5

min(list)：查找串列中最小值，回傳最小值元素，

a = [1,2,3,4,5]
print(min(a)) #結果為1

list.index(obj,start,end)：查找指定元素在串列中第一次出現的位置，回傳元素下標，

a = [1,2,3,4,5,6,7,8,9]
print(a.index(5)) #結果為4
a = [1,2,3,4,5,6,7,8,9]
print(a.index(6,0,8)) #結果為5

list.count()：查找指定元素在串列中出現的次數，回傳數量值，

a = [1,2,3,4,5,6,7,8,9,5,7,5]
print(a.count(5)) #結果為3

使用成員運算子（in/not in）對串列內是否有此元素進行判斷，回傳True/False，

a = [1,2,3,4,5]
print(2 in a,2 not in a) 
#結果為True False

5.串列排序

list.sort(reverse = True/False)：將串列中元素進行(降序/升序)排序（默認升序），不回傳值，

a = [1,2,5,4,3]
a.sort()
print(a) #結果為[1, 2, 3, 4, 5]
a = [1,2,5,4,3]
a.sort(reverse=True)
print(a) #結果為[5, 4, 3, 2, 1]

sorted(list)：用法與sort基本一致，但是會生成一個新的串列物件，不對原串列進行更改，

a = [1,2,5,4,3]
b = sorted(a,reverse = True)
print(b) #結果為[5, 4, 3, 2, 1]
print(a) #結果為[1, 2, 5, 4, 3]

random.shuffle()：引入random隨機庫，隨機打亂串列中元素排序，

import random
a = [1,2,3,4,5]
random.shuffle(a)
print(a) #結果為隨機打亂的串列

list.reversed()：原地翻轉串列中元素，生成一個新的一次性的可迭代物件，

一次性物件僅能使用一次

a = [1,2,3,4,5]
print(reversed(a)) #結果為<list_reverseiterator object at 0x000001F563314160>
print(list(reversed(a))) #結果為[5, 4, 3, 2, 1]

6.串列索引操作

list[num]：找到串列中指定位置的元素，多維串列就繼續往下索引即可（list[num][num]）

a = [[1,[2,"杰尼龜"]],[3,4],[5]]
print(a[0][1]) #結果為[2, '杰尼龜']

7.串列切片操作

list[x:y:±step]：從編號x到編號y之前，從左到右或從右到左以step間隔取值

在切片操作中，起始終止編號不在[0:字串長度-1]這個范圍內也不會報錯，超過0或末端按0和末端截取

8.其他操作

list.copy()：生成一個新的串列的淺拷貝物件，

import random
a = [1,2,3,4,5] ; b = a
random.shuffle(b)
print(a) #結果為隨機打亂的串列

copy后修改串列2不會對串列1產生影響

import random
a = [1,2,3,4,5] ; b = a
b = a.copy()
random.shuffle(b)
print(a) #結果為[1, 2, 3, 4, 5]

多維串列：串列中嵌套串列（串列中可保存不限型別、不限數量的資料）

a = [[1,[2,"杰尼龜"]],[3,4],[5]]
print(a[0][1]) #結果為[2, '杰尼龜']

修改元素：串列是一種內置可變序列，可直接對串列中元素進行訪問修改，

a = [1,2,3]
a[0] = 2
print(a) #結果為[2, 2, 3]

六、元組（tuple）

元組屬于不可變序列，元組中沒有增加元素、洗掉元素、修改元素等操作，其余操作與串列基本一致，

t =（‘holberton’，[1，2，3]）
元組t包含不同資料型別的元素，第一個元素是一個不可變的字串，第二個元素是一個可變串列，元組本身不可變，即它沒有任何改變其內容的方法，同樣，字串是不可變的，因為字串沒有任何可變方法，但是串列物件確實有可變方法，所以可以改變它，這是一個微妙的點，但是非常重要：不可變物件的“值” 不能改變，但它的組成物件是能做到改變的，
其實主要原因是元組內保存的是變數（也就是記憶體地址），所以當變數指向物件發生變化時，如果導致變數發生變化（即不可變型別），此時元組保證該不可變型別不能修改，而如果當變數指向物件發生變化時，如果不會導致變數發生變化（即可變型別），此時元組中存盤的該可變型別可以修改（因為變數本身并無變化），

1.元組的創建與洗掉

通過圓括號創建（圓括號可省略），

a = (10,20,"杰尼龜")
b = (10,) 
c = 2,3,"可達鴨"
print(type(a),type(b),type(c),)
#結果為<class 'tuple'> <class 'tuple'> <class 'tuple'>

單元素括號也可省略，但是逗號不能省略，不然會被python識別為其他型別資料

a = (10,)
b = 10,
c = (10)
print(type(a),type(b),type(c),)
#結果為<class 'tuple'> <class 'tuple'> <class 'int'>

通過tuple()函式將可迭代資料轉換為元組物件，

a = tuple([1,2,3,4])
b = tuple(range(5))
c = tuple("12345")
print(a) ; print(b) ; print(c)
#結果為(1, 2, 3, 4) ；(0, 1, 2, 3, 4) ；('1', '2', '3', '4', '5')

通過生成器推導式創建元組

通過生成器推導式，生成一個可迭代的一次性物件，再將此物件通過list()/tuple()方法轉換為想要的串列和元組

a = (i for i in range(5))
print(a) #結果為<generator object <genexpr> at 0x0000025750B1ABA0>
print(tuple(a)) #結果為(0, 1, 2, 3, 4)

通過del 洗掉元組本身

a = (10,20,30)
del a
print(a) #NameError: name 'a' is not defined

2.相關操作

元組為python內置不可變序列物件，除串列中的添加、洗掉、修改等方法不可使用以外，其余操作基本一致，

元組可用操作：切片操作、索引操作、拼接操作、成員運算子、比較運算子、計數方法（len()、max()、min()、sum()）等

與串列操作不同之處

串列排序可用list.sort()方法，對串列本身進行排序，但元組不行，元組物件想要進行排序只能試用sorted(tuple)進行排序并生成一個新的串列物件，不對原物件進行修改，

a = (1,2,3,6,5,4)
b = sorted(a)
print(a) #結果為(1,2,3,6,5,4)
print(b) #結果為[1, 2, 3, 4, 5, 6]

zip()：通過zip方法將多個串列的指定元素組合成一個元組，并回傳這個一次性的zip物件，

一次性物件僅能使用一次

a = [1,2,3]
b = [4,5,6]
c = [7,8,9]
d = zip(a,b,c)
print(d) #結果為<zip object at 0x0000028C7CA43900>
print(tuple(d))  #結果為((1, 4, 7), (2, 5, 8), (3, 6, 9))
print(list(d)) #結果為[]

七、字典（dict）

含義
字典是“鍵值對”的無序可變序列，字典中的每個元素都是一個“鍵值對”，包含：“鍵物件”和“值物件”，可以通過“鍵物件”實作快速獲取、洗掉、替換、添加對應的“值物件”，
串列中我們通過下標找到對應的物件，字典中通過“鍵物件”找到對應的“值物件”，鍵是任意不可變的資料，如：字串、元組、整數、浮點數，但是串列、字典、集合這些可變物件不能作為鍵，并且鍵不可重復，值可以是任意資料且可重復

1.字典的創建

通過花括號【{}】進行創建，

d = {"name":"杰尼龜","age":25,"job":"students"}
print(type(d)) #結果為<class 'dict'>

通過dict()創建，

dict()里面加入賦值運算進行創建

d = dict(name="杰尼龜",age = 18)
print(d) #結果為{'name': '杰尼龜', 'age': 18}

dict()括號里面加入特定串列【[(1,2)]型別】進行創建

d = dict([("name","杰尼龜"),("age",18)])
print(d) #結果為{'name': '杰尼龜', 'age': 18}

dict()括號里面加入zip()函式進行創建

a = ["name","age"]
b = ["杰尼龜",18]
d = dict(zip(a,b))
print(d) #結果為{'name': '杰尼龜', 'age': 18}

通過dict.fromkeys()方法創建值為None的字典

d = dict.fromkeys(["name","age","job"])
print(d) #結果為{'name': None, 'age': None, 'job': None}

2.字典值的訪問

通過鍵訪問對應的值，如不存在此鍵則拋出例外

d = {"name":"杰尼龜","age":18}
print(d["name"],d["age"]) #結果為杰尼龜 18

通過dict.get()方法使用鍵來進行值的獲取，區別在于，不存在此鍵時會回傳None，而不會報錯，get方法也可在鍵不存在時指定回傳的值，

d = {"name":"杰尼龜","age":18}
print(d.get("name")) #結果為杰尼龜
print(d.get("age")) #結果為18
print(d.get("job")) #結果為None
print(d.get("job","student")) #結果為student
print(d.get("age","student")) #結果為18

3.字典鍵值的訪問

dict.keys()：列出所有的鍵，

d = {"name":"杰尼龜","age":18}
print(d.keys()) #結果為dict_keys(['name', 'age'])

dict.values()：列出所有的值，

d = {"name":"杰尼龜","age":18}
print(d.keys()) #結果為dict_keys(['name', 'age'])

len(dict)：查詢字典的鍵值對的數量，

d = {"name":"杰尼龜","age":18}
print(len(d)) #結果為2

使用成員判斷符（in/not in）判斷鍵是否在字典內（僅判斷鍵，不能判斷值），

d = {"name":"杰尼龜","age":18}
print("杰尼龜" in d) #結果為False
print("name" in d) #結果為True

4.字典鍵值對的添加

dict[key] = vlaue ：更新字典中鍵的值，如果沒有此鍵則添加至字典末尾，

d = {"name":"杰尼龜","age":18}
d["name"] = "可達鴨"
d["color"] = "yellow"
print(d) #結果為{'name': '可達鴨', 'age': 18, 'color': 'yellow'}

dict1.update(dict2)：將字典2中的鍵值對添加到字典1中，如果key有重復則替換對應的值，如無重復，則添加到末尾，

d = {"name":"杰尼龜","age":18}
a = {"name":"可達鴨","color":"yellow"}
d.update(a)
print(d) #結果為{'name': '可達鴨', 'age': 18, 'color': 'yellow'}

5.字典中鍵值對的洗掉

del 洗掉字典本身或洗掉字典中指定的鍵，

a = {"name":"可達鴨","age":18,"color":"yellow"}
del a["color"]
print(a) #結果為{'name': '可達鴨', 'age': 18}
del a
print(a) #NameError: name 'a' is not defined

dict.clear()：清空字典內部所有鍵值對，

a = {"name":"可達鴨","age":18,"color":"yellow"}
a.clear()
print(a) #結果為{}

dict.pop()：洗掉字典內指定鍵，并將對應的值提取出來留作他用

a = {"name":"可達鴨","age":18,"color":"yellow"}
b = a.pop("color")
print(a) #結果為{'name': '可達鴨', 'age': 18}
print(b) #結果為yellow

dict.popitem：字典本身是無序可變序列，沒有首位元素和尾位元素之說，popitem方法會隨機回傳并洗掉一個鍵值對，回傳一個(key,value)形式，按照 LIFO（Last In First Out 后進先出法） 順序規則，即最末尾的鍵值對，

a = {"name":"可達鴨","age":18,"color":"yellow",1:2,3:4,5:6}
b = a.popitem()
print(a) ; print(b) 
#結果為{'name': '可達鴨', 'age': 18, 'color': 'yellow', 1: 2, 3: 4}、(5, 6)
b = a.popitem()
print(a) ; print(b)
#結果為{'name': '可達鴨', 'age': 18, 'color': 'yellow', 1: 2}、(3, 4)
b = a.popitem()
print(a) ; print(b)
#結果為{'name': '可達鴨', 'age': 18, 'color': 'yellow'}、(1, 2)

5.字典使用小試

通過串列和字典來存盤表格資料

d1 = {"name":"杰尼龜","age":18,"salary":8000,"city":"成都"}
d2 = {"name":"可達鴨","age":19,"salary":9000,"city":"上海"}
d3 = {"name":"皮卡丘","age":20,"salary":10000,"city":"北京"}
l = [d1,d2,d3]
for i in range(len(l)):
    print(l[i]["name"],l[i]["age"],l[i]["salary"],l[i]["city"])

八、集合（set）

集合是一種無序可變序列，集合的底層實作是字典，只不過只包含了字典的鍵，所以集合中的元素不能重復

1.集合的創建

使用花括號創建【{}】

```python
s = {1,2,3,"杰尼龜",True,False}
print(type(s)) #結果為set

使用set()將串列、元組等可迭代物件轉換為集合，集合中元素不重復，所以有重復元素只保留一個，

l = [1,2,3,"杰尼龜"]
t = (10,20,30,"可達鴨")
s1 = set(l)
s2 = set(t)
print(s1) #結果為{1, 2, 3, '杰尼龜'}
print(s2) #結果為{'可達鴨', 10, 20, 30}
a = "杰尼龜"
s1 = set(a)
print(s1) #結果為{'尼', '龜', '杰'}

2.添加集合中的元素

使用set.add()函式在集合中添加元素，重復元素不會添加

a ={10, 20 , 30}
a.add(40)
print(a) #結果為{40, 10, 20, 30}

3.洗掉集合中的元素

使用remove()函式洗掉指定元素

a ={10, 20 , 30}
a.remove(10)
print(a) #結果為{20, 30}

使用clear()函式清空集合中所有元素

a ={10, 20 , 30}
a.clear()
print(a) #結果為set()

使用del 洗掉集合本身，集合不支持使用del洗掉指定項

a ={10, 20 , 30}
del a
print(a) #結果為NameError: name 'a' is not defined

4.集合相關操作

并集將兩個集合中重合部分保留一個，然后生成一個合并后的新集合物件，

a ={10, 20 , 30}
b = {30,40,50}
c = a | b
print(c) #結果為{50, 20, 40, 10, 30}

交集取出兩個集合中重合部分，然后生成一個新的集合物件，

a ={10, 20 , 30}
b = {30,40,50}
c = a & b
print(c) #結果為{30}

差集去除集合1在集合2中也存在的元素，生成一個新的串列物件，

a ={10, 20 , 30}
b = {30,40,50}
c = a - b
d = b -a
print(c) #結果為{10, 20}
print(d) #結果為{40, 50}

九、分支陳述句

通過判斷條件是否成立，來選擇執行對應分支，選擇結構有多種形式，分為：單分支、雙分支、多分支，流程圖如下：

單分支陳述句

雙分支陳述句

多分支結構

1.條件運算式解釋

在選擇和回圈陳述句中，條件運算式的值為false時不會執行，具體情況如下：

False、0、0.0、空值None、空的序列物件（空串列、空字串、空元組、空字典、空集合）、空range物件、空迭代物件，

其余情況值均為true，

if 0 :
    print("值為假")
if [] :
    print("值為假")
if [1] :
    print("值為假")

注意：條件運算式中不能出現賦值陳述句【a=b】

1.單分支陳述句

if條件判斷陳述句：
?? ? 執行陳述句

a = int(input("請輸入一個整數"))
if a < 10 :
    print("比十小")

①條件判斷陳述句后面必須接冒號
②執行陳述句注意縮進
③執行陳述句可以是一條也可以是多條，多條縮進注意保持一致

2.雙分支陳述句

if條件判斷陳述句：
?? ? 執行陳述句
else：
?? ? 執行陳述句*

a = int(input("請輸入一個整數："))
if a<=10:
    print(f"您輸入的是{a}")
else: #表示與前面條件互斥 a>10
    print("您輸入的不在范圍內")

三元條件運算子

在雙分支條件判斷中可使用print(條件為真時候的值 if （條件運算式） else 條件為假時候的值)來更加簡潔的輸出自己想要的結果，

a = int(input("請輸入一個整數："))
print("輸入的是一個偶數" if a%2==0 else "輸入的是一個奇數")

3.多分支陳述句

if 條件運算式
?? ? 執行陳述句
elif 條件運算式
?? ? 執行陳述句
.
.
.
elif 條件運算式
?? ? 執行陳述句
else:
?? ? 執行陳述句

多分支陳述句有邏輯順序，不可隨意調換撰寫順序，如下列實體，調換順序后就不能用此寫法

a = int(input("請輸入你的分數："))
if 0<=a<=100:
    if  a >=90 : # 等同于 90<=a<=100
        print(f"您的分數是{a},評分為S")
    elif a >= 80:  # 等同于 80<=a<90
        print(f"您的分數是{a},評分為A")
    elif a >= 70:  # 等同于 70<=a<=80
        print(f"您的分數是{a},評分為B")
    elif a >= 60:  # 等同于 60<=a<=70
        print(f"您的分數是{a},評分為C")
    elif a < 60:
        print(f"您的分數是{a},評分為D")
else:
    print("輸入有誤")

4.條件判斷嵌套

注意不同層級的縮進量

a = int(input("請輸入你的分數："))
if 0<=a<=100:
    if  a >=90 : # 等同于 90<=a<=100
        print(f"您的分數是{a},評分為S")
    elif a >= 80:  # 等同于 80<=a<90
        print(f"您的分數是{a},評分為A")
    elif a >= 70:  # 等同于 70<=a<=80
        print(f"您的分數是{a},評分為B")
    elif a >= 60:  # 等同于 60<=a<=70
        print(f"您的分數是{a},評分為C")
    elif a < 60:
        print(f"您的分數是{a},評分為D")
else:
    print("輸入有誤")

十、回圈陳述句

回圈陳述句用來幫我們重復得執行多條陳述句，每次執行都會判斷回傳的結果是否為true，是則繼續回圈，不是則結束回圈，

回圈陳述句中至少應該包含用來改變判斷條件的陳述句使回圈終結，不然會變成死回圈，

1.while 回圈

while回圈陳述句格式
while 條件判斷
?? ? 回圈陳述句*

n = 0 ; l = []
while n <= 10: #條件判斷，開始回圈
    n += 1  #控制條件判斷結果
    l.append(n) 
print(l) #結果為[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

while 回圈例題

列印1~100之間整數的累加和

n = 0 ; l = 0
while n <= 100: #條件判斷，開始回圈
    l = l + n
    n += 1  #控制條件判斷結果
print(l) #結果為5050

2.for回圈

for回圈通常用于可迭代物件的遍歷，語法格式如下：
for 變數 in 可迭代物件:
?? ? 回圈陳述句

可迭代物件：①序列：元組、串列、字串、②字典、③迭代器函式（iterator）、④生成器函式（generator）

遍歷串列

for i in [1,2,3]:
    print(i) #結果為1 2 3

遍歷元組

for i in （1,2,3）:
    print(i) #結果為1 2 3

遍歷字串

for i in "123":
    print(i) #結果為1 2 3

遍歷字典

d = {"name":"杰尼龜","age":18,"color":"blue"}
for i in d: #遍歷鍵
    print(i) #結果為name age color
for i in d.values(): #遍歷值
    print(i) #結果為杰尼龜 18 blue
for i in d.items(): #遍歷鍵值對
    print(i) #結果為('name', '杰尼龜') ('age', 18) ('color', 'blue')

遍歷range函式（range(start,end,step)）

for i in range(5):
    print(i) #結果為0 1 2 3 4 
for i in range(1,5):
    print(i) #結果為 1 2 3 4 
for i in range(-5,5,2):
    print(i) #結果為 -5 -3 -1 1  3

配合zip()函式進行并行遍歷

a = ["杰尼龜","可達鴨","皮卡丘"]
b = [19,20,25,30]

for name,age in zip(a,b):
    print(f"{name}--{age}")

等同于以下寫法，且回圈次數由最短那個物件決定，

a = ["杰尼龜","可達鴨","皮卡丘"]
b = [19,20,25,30]

for i in range(3):
    print(f"{a[i]}--{b[i]}")

for回圈練習

輸出1~100之間的整數累加和

sum_all = 0
for i in range(101):
    sum_all =sum_all + i
print(sum_all)

輸出1~100之間的奇數累加和

sum_all = 0
for i in range(101):
    if i%2 >0:
        sum_all =sum_all + i
print(sum_all)

for回圈搭配推導式生成序列

相較于正常寫法，推導式寫法更為簡潔

使用推導式生成串列[運算式 for 變數 in 可迭代物件 if 條件判斷]

集合使用方法一致，只是外部為花括號{}

a = [x for x in range(5)]
print(a) #結果為[0, 1, 2, 3, 4]
b = [x*2 for x in range(5) if x%2==0]
print(b) #結果為[0, 4, 8]
b = [i for i in "杰尼龜"]
print(b) #結果為['杰', '尼', '龜']

for回圈可以多個

b = [(i,j) for i in range(5) for j in range(3) if j >=1]
print(b) #結果為[(0, 1), (0, 2), (1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (4, 1), (4, 2)]

使用推導式創建字典

#普通寫法(列出物件中每個元素出現的次數)
a= "hello python!"
b = {}
for i in a :
    b[i] = a.count(i)
print(b)
#推導式
a= "hello python!"
b = {i:a.count(i) for i in a}
print(b)

使用推導式創建元組

元組也有推導式，使用圓括號創建，但是創建的是一個一次性的生成器物件，

a = (i for i in "杰尼龜")
print(a) #結果為<generator object <genexpr> at 0x000002B0A8B3FBA0>
b = tuple(a)
print(b) #結果為('杰', '尼', '龜')
c = tuple(a)
print(c) #結果為()

3.嵌套回圈

一個回圈體內可加入其他回圈體
回圈條件判斷:
?? ? 回圈陳述句
?? ? 回圈條件判斷:
?? ? ?? ?回圈陳述句

使用實體

for i in range(5):
    for j in range(5):
        print(i,end="\t")
    print()
'''結果為
0	0	0	0	0	
1	1	1	1	1	
2	2	2	2	2	
3	3	3	3	3	
4	4	4	4	4	
'''

列印九九乘法表

for i in range(1,10):
    for j in range(1,i+1):
            print(f"{i}*{j}={i*j}",end=" ")
    print()
'''結果為
1*1=1 
2*1=2 2*2=4 
3*1=3 3*2=6 3*3=9 
4*1=4 4*2=8 4*3=12 4*4=16 
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 
'''

使用串列+字典儲存表格，再列印工資高于15000的員工資訊

d1 = {"name":"杰尼龜","age":18,"salary":10000,"city":"成都"}
d2 = {"name":"皮卡丘","age":20,"salary":20000,"city":"上海"}
d3 = {"name":"小火龍","age":25,"salary":30000,"city":"北京"}
l = [d1,d2,d3]
for i in l:
    if i.get("salary") >= 15000:
        print(i)

4.break陳述句

結束整個回圈，嵌套回圈時結束最近層級的回圈，

while True:
    a = input("請輸入一個0~10數字之間的數字：")
    if int(a) == 8:
        break
        
for i in range(5):
    for j in range(5):
        if i*j >= 6:
            break
        print(i, j)
    print()

5.continue陳述句

執行到該陳述句時跳過本次回圈，余下陳述句不執行，直接開始下一輪回圈，嵌套回圈時跳過最近層級的回圈，

for i in range(5):
    if i == 3:
        continue
    print(i) #結果為0，1，2，4

for i in range(3):
    for j in range(3):
        if j == 2:
            continue
        print(i,j)

6.else:陳述句

while回圈和for回圈可再后面接一個else陳述句（可選），如果回圈沒有被break陳述句中斷，那么再回圈完以后就會執行else，否則不會執行，

回圈條件判斷:
?? ? 回圈陳述句
else:
?? ? 執行陳述句

7.回圈陳述句代碼優化

①區域變數查詢快，優先選擇區域變數
②盡量減少回圈中的計算次數
③嵌套回圈中，盡量減少內部回圈的計算次數，能往外提的全放外部
④串列元素添加洗掉優先選擇在尾部進行操作
⑤字串拼接采用join()

測驗

import time
a = time.time()
for i in range(1000):
    l = []
    for j in range(10000):
        l.append(i*100+j*1000)
b = time.time()
print(b-a) #結果為1.49

a = time.time()
for i in range(1000):
    l = []
    c = i*100
    for j in range(10000):
        l.append(c+j*1000)
b = time.time()
print(b-a) #結果為1.19

運行效果一致時，下半運行速度優于上半，數值越大差異越明顯

十一、函式

函式本質上就是代碼塊，函式不僅能實作代碼的復用，更能使代碼產生一致性（修改函式，后續所有使用的地方都會跟著改變）

1.函式的定義和呼叫

定義

def+空格+函式名+圓括號+冒號
?? ? 函式陳述句

def say_hi():
	name = input("請輸入您的姓名：")
	print(f"{name},你好！")

呼叫

定義完成后，與內置函式使用方法一致

def say_hi():
	name = input("請輸入您的姓名：")
	print(f"{name},你好！")

say_hi()

2.形參與實參（引數的傳遞詳見擴充部分）

形參：即形式引數，定義函式時設定的引數
實參：即實際引數，呼叫函式時填入的引數

def print_circle(n):
    print("?"*n)
print_circle(3)

def num(a,b):
	if a>b:
		print(a,"是較大值")
	else:
		print(b,"是較大值")
num(10,20)
num(30,20)

要點：
①括號內形參串列，多個引數使用逗號隔開
②括號內沒有引數也要保留括號
③形參和實參必須一一對應

3.函式的注釋

函式創建陳述句
?? ? ‘’‘注釋陳述句’‘’
?? ? 函式陳述句

def num(a,b):
	'''用來比較兩個數的大小，并列印最大值'''
	if a>b:
		print(a,"是較大值")
	else:
		print(b,"是較大值")
num(10,20)
num(30,20)

注釋的呼叫

help(函式名._doc_)

def num(a,b):
	'''用來比較兩個數的大小，并列印最大值'''
	if a>b:
		print(a,"是較大值")
	else:
		print(b,"是較大值")
num(10,20)
num(30,20)

print(help(num.__doc__))

4.函式回傳值

return回傳值

①如果函式中有return陳述句則回傳該陳述句所指向的值，并結束函式，不執行余下函式，

def num(a,b):
    c = (a+b)/2
    return c
    print("杰尼龜")
    
print(num(20,40))

②如果函式中沒有return陳述句則回傳None，

def num(a,b):
    c = (a+b)/2
    print("杰尼龜") 
print(num(20,40))

def num(a,b):
    c = (a+b)/2
    return 
    print("杰尼龜")   
print(num(20,40))

③如果需要回傳多個值使用串列、元組、字典、集合等多個值存起來，

def triangle(a,b,c):
    return[a**2,b**2,c**2]

print(triangle(3,4,5))

5.函式運行邏輯

def name():
	print("杰尼龜")

name()
a = name
a()

當我們使用def進行函式創建時，電腦會在記憶體中創建一個【print(“杰尼龜”)】的函式物件并通過變數【name】對其進行參考，所以后續使用時可以使用【a = name】來使變數【a】也能呼叫函式，

十二、類的創建與使用

1.面向程序與面向物件

面向程序
面向程序主要是注重于程式的運行邏輯，在遇到一些小專案時，我們去思考怎么讓程式按步驟的去完成此專案，再將這些步驟轉換為實質性的代碼，這就是面向程序的編程方式，

例如：如何啟動一臺電腦
①連接電源
②按開機鍵
③輸入密碼

面向物件
python中一切皆物件（資料型別、序列、函式、類等皆為物件），在面向物件的編程中我們更注重各個物件之間的邏輯關系，在大型專案中我們首先去思考專案是由哪些物件組成的，再分別創造出所需要的各個物件，最后再組裝到一起形成一個完整的專案，

例如：如何造一臺電腦
①設計電腦的組成部分
②創造對應零件（物件）：作業系統、顯卡、記憶體、硬碟、主板、CPU、電源、機箱等
③組裝各部分零件
④亮機測驗

宏觀上由面向物件把握，微觀上還是面向程序進行執行，

2.類的定義

類的創建辦法（類名要滿足識別符號規則，通常采用駝峰原則，多個單詞首字母均大寫，用下劃線連接）

class 類名
?? ? 類體

類體中我們可以定義屬性和方法（即函式），
屬性用來描述資料，方法就是屬性的相關操作函式，

class Students: #首字母大寫，多個單詞采用駝峰原則

    def __init__(self, name, color): #建構式第一個實體必須為self
        self.name = name #self.name：實體屬性，name：形參
        self.color = color

    def check_results(self): #實體方法
        print(f"{self.name}的顏色是{self.color}")

s01 = Students("杰尼龜", "blue") #自動呼叫建構式
s01.check_results() #呼叫實體相關操作函式

3.構造方法

構造方法__init__()：我們在創建物件時，需要使用構造方法__init__()對實體物件進行屬性的初始化，即物件創建后初始化其屬性（將其賦值給變數），無回傳值，

建構式使用

①名稱固定為__init__()，缺一不可（下劃線為英文狀態下左右各兩個）
②方法中第一個實體必須為self，名稱可變，但按照一般慣例均使用self
③構造方法通常用來對實體屬性進行初始化（賦值），比如：

    def __init__(self, name, color): #self:實體物件形參，name:形參，color：形參
        self.name = name #self.name：實體屬性，name：初始值
        self.color = color

④通過【類名(引數串列)】來呼叫建構式__init__()，將創建好的物件賦值給對應的變數，比如：

s01 = Students("杰尼龜", "blue") #呼叫建構式

⑤__init__()：對創建好的物件進行初始化，即賦值，
⑥__new__()：用于創建新物件，我們一般無需重定義該方法，

4.實體屬性

實體屬性時從屬于實體物件的屬性，也稱為實體變數（self.實體屬性名）

實體屬性使用
①實體屬性一般在__init__()方法中進行定義，

class 類名:
?? ? def init(self,形參1，形參2):
?? ? ?? ? self.實體屬性名 = 形參1
?? ? ?? ? self.實體屬性名 = 形參2

②在本類的其他實體方法中，也是通過self進行呼叫，

class 類名:
?? ? def init(self,形參1，形參2):
?? ? ?? ? self.實體屬性名 = 形參1
?? ? ?? ? self.實體屬性名 = 形參2
def 實體方法名（函式名）:
?? ? ?? ? self.實體屬性名+相關操作

③創建實體物件后使用實體物件進行呼叫，

實體物件名 = 類名(實參1，實參2)
實體物件名.實體方法名（函式）
實體物件名.實體屬性名 = 值 #給實體屬性更改值，或者新增屬性

class Students:

    def __init__(self, name, color): #建構式第一個實體必須為self
        self.name = name #實體屬性
        self.color = color

    def check_results(self): #實體方法
        print(f"{self.name}的顏色是{self.color},年齡是{self.age}")

s01 = Students("杰尼龜", "blue") #自動呼叫建構式

s01.age = 18
s01.check_results() #呼叫實體相關操作函式

5.實體方法

實體方法從屬于實力物件，本質上也是實體屬性，
實體方法的創建

def 實體方法名(self,形參1，形參2):
?? ? 函式體

    def check_results(self): #實體方法
        print(f"{self.name}的顏色是{self.color},年齡是{self.age}")

實體方法的呼叫

實體名.實體方法名(形參1，形參2)

s01.check_results() #呼叫實體相關操作函式

①創建實體方法時，第一個引數必須為實體引數，按慣例使用self，
②呼叫實體方法無需也不能給實體引數傳參，應由解釋器自動傳入引數，

實體物件的判斷

isinstance()：判斷實體是否在類之中，回傳True、False，

class Students:

    pass

class Num:

    pass

s01 = Students()
s02 = Num()
print(isinstance(s01,Students))
print(isinstance(s02,Students))

實體方法與函式的區別

實體方法從屬于特定的實體物件，呼叫必須通過實體物件進行呼叫，而普通函式沒有此要求，本質上兩者都是用來完成對應功能的陳述句塊，沒有區別，

6.類物件

python中一切皆物件，類在定義時（class 類名：），解釋器會自動創建一個類物件，

class Students:
    pass

print(id(Students))
print(type(Students))

s01 = Students
s = s01()
print(s)

當執行class Students時，解釋器創建了一個類的物件，并將物件的id指向了students這個變數，所以后面我們可以使用s01 = Students來讓s01也指向這個物件，

7.類屬性

類屬性從屬于類物件，也稱為類變數，可以被所有的實體的物件共享，定義方法如下：
class 類名：
?? ? 變數名 = 初始值

class Students:
    classes = "6班"
    grade = "4年級"

    def __init__(self,name,score):
        self.score = score
        self.name = name
    def check_results(self):
        print(f"{self.grade}{self.classes}{self.name}同學的成績是{self.score}")
		#可直接使用self對類變數進行呼叫
lilei = Students("李磊",98)
lilei.check_results()

也可進行下列呼叫

class Students:
    classes = "6班"
    grade = "4年級"

    def __init__(self,name,score):
        self.score = score
        self.name = name
    def check_results(self):
        print(f"{Students.grade}{Students.classes}{self.name}同學的成績是{self.score}")

lilei = Students("李磊",98)
hanmeimei = Students("韓梅梅",95)

lilei.check_results()
hanmeimei.check_results()

記憶體示意圖

8.類方法、靜態方法

類方法
類方法從屬于類物件，類方法一般通過裝飾器（@classmethod）進行定義，可以使用類物件和實體物件進行呼叫

class Students:
    classes = "6班"
    grade = "4年級"

    def __init__(self,name,score):
        self.name = name
        self.score = score

    def check_results(self):
        print(f"{self.name}的成績是{self.score}分")
    @classmethod
    def print_infor(cls):
        print(f"我們是{Students.grade}{Students.classes}")

lilei = Students("李磊",98)
Students.print_infor()
lilei.print_infor()

要點：
①類方法中第一個引數必須為【cls】，表示類物件本身，
②在呼叫類方法時無需也不能給cls傳入引數
③@classmethoed必須位于方法的上面一行
④類方法中訪問實體屬性、實體方法會報錯

靜態方法（轉載于博客園）

靜態方法是類中的函式，不需要實體，靜態方法主要是用來存放邏輯性的代碼，邏輯上屬于類，但是和類本身沒有關系，也就是說在靜態方法中，不會涉及到類中的屬性和方法的操作， 可以理解為，靜態方法是個獨立的、單純的函式，它僅僅托管于某個類的名稱空間中，便于使用和維護，

譬如，我想定義一個關于時間操作的類，其中有一個獲取當前時間的函式，

import time

class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())


print(TimeTest.showTime())
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print(nowTime)

如上，使用了靜態方法（函式），然而方法體中并沒使用（也不能使用）類或實體的屬性（或方法），若要獲得當前時間的字串時，并不一定需要實體化物件，此時對于靜態方法而言，所在類更像是一種名稱空間，

9.類方法、實體方法、靜態方法的區別

實體方法：只能由實體物件進行呼叫，類物件無法呼叫，
類方法：實體物件和類物件均可呼叫
靜態方法：實體物件和類物件均可呼叫，靜態方法僅托管于類中，和類本身沒有關系，

十三、花里胡哨的擴充(遇到什么些什么)

1.變數的作用域

變數起作用的范圍稱為變數的作用域，即全域變數與區域變數，不同作用域內同名變數不相互影響，

a = 3 #全域變數
def num():
	b = 4 #區域變數
	print(b)
print(a)
num()

全域變數

①當全域變數與區域變數同名時，則在函式內隱藏全域變數，只使用區域變數，

a = 3
def num():
	print(a)
print(a)
num()

a = 3 #全域變數
def num():
	a = 4 #區域變數
	print(a)

num()
print(a)

②想在函式內更改全域變數，需在函式內使用global進行宣告，

a = 3 #全域變數
def num():
	global a
	a = 4 #區域變數

num()
print(a)

2.引數的傳遞

引數的傳遞本質上就是實參到形參的傳遞，python中一切皆物件，所有賦值操作都是”參考“，所以引數的傳遞都是”參考傳遞“，引數的傳遞分為兩類：可變物件的傳遞、不可變物件的傳遞，

可變物件的傳遞：串列、字典、集合、自定義的物件等，可變物件的傳遞直接作用于物件本身，

l = [1,2]

print(id(l))
print(l)

def add(a):
    a.append(3)
    print(id(a))
    print(a)

add(l)

不可變物件的傳遞：數字、字串、元組、function等，不可變物件的傳遞會產生一個新的物件空間并使用新的值進行物件填充，

a = 1
print(id(a))
def sum(m):
    print(id(m))
    n = m+2
    print(id(n))
    print(n)
sum(a)