你們的三連(點贊，收藏，評論)是我持續輸出的動力，感謝，
在興趣中學習，效益超乎想象，①有趣的原始碼與學習經驗，②工具安裝包，③專業解答，④學習資料共享

點擊領取福利

一、python基礎知識

1.第一個Python程式

1.1pycharm介紹

PyCharm 是一種 PythonIDE，附帶一輩可以幫助用戶在使用 Python 語言開發時提高其效率的工具，例如除錯、語法高亮、專案管理、代碼跳轉、智能提示、自動完成、單元測驗、版本控制，此外，該IDE提供了一些高級功能，用于支持Django框架下的專業Web開發，

使用pycharm寫出第一個程式

1）打開 Pycharm，選擇Create New Project，創建一個新專案創建專案

2）選擇Pure Python表示創建一個純 Python 程式專案，Location表示該專案保存的路徑，Project Interpreter表示使用的 Python 解釋器版本，最后點擊Create創建專案，創建檔案第二步

3）右擊專案，選擇New，再選擇Python File 創建檔案第三步

4）在OK創建一個文本的文本對話框中輸入的檔案名Hello，點擊，顯示Python程式的文本檔案檔案后綴名默認.py創建檔案第四步

5）輸入以下代碼，并右擊空白處，選擇Run運行，表示列印一個字串“Hello World！”，

print（“Hello World！”）

6）運行成功后，Pycharm Console 視窗將顯示我們的輸出結果，

2.注釋

2.1注釋的作用

通過用自己的語言，在對部分代碼進行認知說明，這就是語音的作用，能夠放大膨脹程式的神話性

2.2注釋的分類

單行注釋：
以#開頭，#右邊的所有東西當做說明，而不是真正要執行的程式，起輔助說明作用

#這是python代碼的注釋
print ( "hello world" )

多行注釋：
以""""""包裹或者’’’’’’'包裹，包裹中的內容就是注釋部分

'''這是多行注釋''' 
"""這也是多行注釋"""

注意

多行對方的符號，必須一樣不能要么都是單引號，要么都是單引號，不能混用

3.變數和資料型別

1）什么是變數？
變數是事件資料值的，程式就是處理資料的，而變數就是存盤資料的

2）資料型別
為了更充分地利用記憶體空間以及不斷的管理記憶體，變數是有不同的型別的，

3）有哪些變數的型別呢？
在python中，只要定義了一個變數，它就有資料，那么它的型別就已經確定了，不需要我們開發者主動去說明它的型別，系統會自動氣泡
可以使用type(變數的名字)，來查看變數的型別

4.Python基本資料型別

在 Python 中的數有四種，分別是整數（int）、長整數（long）、浮點數（float）、復數（complex），

4.1整數

像 6 這樣的數字就是整數，不帶小數點的，而長整數只不過代表的是比較大一點的整數，現在 python3 中的整數（int）已經不限制數的大小限制了，所以整數型別也包括長整數，

我們可以通過 Python 互動式解釋器來運算整數：

這里的 「6+6」沒什么好說的吧，而 「6//2」就是6整除2的意思了，「1%2」的意思是說1除以2的余數，「%」有個專業名詞叫做取余或者取模，而「2**3」就是2的三次方的意思，

4.2浮點數

但是如果你試試 「1/2」，這時候你會發現結果有小數點：

在這里的 「/」是除的意思，但是不會整除，你可以看到每次的結果都會有小數點，而這些像 「0.5」，「1.0」帶有小數點的數我們就叫做浮點數，

4.3復數

Python中的復數由實數部分和虛數部分組成，虛部的后綴為「j」，

例如：4+5j 就是一個復數，實數部分為 4.0，虛數部分為 5.0，

你可以把復數理解成為一個平面的一個點，例如上面這個例子你可以把它理解為平面上的點（4,5），

5.各種符號的意義及用法

我們小時候，老師都教過我們 1+1=2 ，這個 「1+1」 就是運算式， 「+」 就是運算子，

咱們接下來就來了解一下，在 python 中，那些運算子是什么意思，怎么用？ 相信看完，你就能夠明白了，

5.1加減乘除(±/*)

對于 ±*/ 我們都知道它們是什么含義了吧，就算你的數學是體育老師教的，你也會懂加減乘除吧，

不過有兩個小細節值得你去注意，就是字串之間的相加和相乘：

字串之間的相加會被"拼接"起來，而字串和數字相乘就會重復多次相同的字串，

其它的大于、小于、大于等于、小于等于就不說了，因為我們小學老師都跟我們說過了，接下來說幾個比較少見的符號，

5.2冪(**)

冪就是以前我們學數學的時候老師講的什么什么幾次方，別一看到冪就想到楊冪，

用符號 ** 表示， 比如 2**3 = 8，

5.3整除（//）

我們知道 / 是除的意思，你知道 6/3 等于多少么？你可能會覺得在侮辱你的智商對不對，不是 2 么？ 在 python 中得出的結果是 2.0 ， 也就是它回傳的是浮點數， 那么我們只想得到整數部分怎么玩呢？

用 // 這個 ： 6//3 = 2

5.4取模（%）

取模的意思不是讓你去獲取個模特，是得到除法的余數，比如 8%5 = 3 ，因為 8/5 = 1余3，

5.5左移（<<）和右移(>>)

移的意思就是把一個數的二進制移動多少個位，

比如 2 << 2 = 8 ，
首先 2 的 二進制 是 0b00000010 ，然后將它左移2位（虛位補0）就變成這樣： 0b00001000 ，它對應的十進制就是 8 ，

同樣的道理：

8 >> 2 的意思就是將 8 的二進制向右移動2位：

0b00001000 右移動2位：0b00000010 也就是對應十進制的 2，

那么下次有人問你2*8怎么樣寫代碼比較高效，你就直接甩給它： 2<<3 就好了，

5.6（&）

記住一句話：“同真與真”，什么意思呢？ 比如 1&1=1,1&0=0,

1就是真，0就是假，也就是只有 1&1=1，其它的都等于0，

那么 2 & 3 怎么算？

先將它們轉化為二進制：

2對應的二進制 ： 0b00000010

3對應的二進制 ： 0b00000011

那么從右往左： 0&1=0 ，1&1=1，0&0=0，所以結果為

0b00000010，轉化為十進制就是2，所以 2&3=2，

5.7（|）

記住一句話：“同假或假”，什么意思呢？ 比如 1|1=1,0|0=0,

1就是真，0就是假，也就是只有 0|0=0，其它的都等于1，

那么 2 | 3 怎么算？

先將它們轉化為二進制：

2對應的二進制 ： 0b00000010

3對應的二進制 ： 0b00000011

那么從右往左： 0|1=1 ，1&1=1，0&0=0，所以結果為

0b00000011，轉化為十進制就是3，所以 2|3=3，

5.8異或（^）

相同者假，不同者真，什么意思呢？就是 1^1=0, 1^0=1，

那么 2^3 怎么算？

先將它們轉化為二進制：

2對應的二進制 ： 0b00000010

3對應的二進制 ： 0b00000011

那么從右往左： 0^1=1 ，1^1=0，0&0=0，所以結果為

0b00000001，轉化為十進制就是1，所以 2^3=1，

5.9翻轉（~）

x的按位翻轉就是是-(x+1)，

那么 ~2 怎么算？

~2 = -（2+1） ； 所以答案就是-3，

ok，以上，其實沒必要去記住，了解一下就這些符號是什么意思，怎么算的就好了，

二、Python中的回圈陳述句

2.while回圈

 while 活著：

    每天做著一樣的事情，

這樣寫的意思就是，只要你活著，就一直不斷的執行while下面的陳述句，
我們可以來寫一個拋硬幣的 python 程式，我們事先定義好硬幣的正反面，然后讓用戶猜，如果用戶猜對了就獎勵一個吻，猜錯了就繼續猜，直到讓他猜中為止，打開我們的 IDLE，代碼敲起來：

首先定義一個變數，我們的值定義為正面：

coin = "正面"

接著定義一個 flag ：

flag = True

然后我們寫一個回圈：

while flag :

    guess = input("請猜一下是正面還是反面：")

    if(guess == "反面") :
        print("你猜錯了，繼續猜")
    elif(guess == "正面") :
        print("恭喜你猜對了，獎勵你一個吻")
        flag = False

執行：

解釋一下：當 while 發現 flag 為 true 的時候，就會一次又一次的執行執行 while 下面的一句，直到我們猜中之后，我們就將flag 這個變數改為 false ，while 發現為 false 的時候就不往下回圈了，

3.while回圈的應用

1.計算1~100的累積和（包含1和100）

i = 1
sum = 0
while i <= 100:
  sum += i
  i+=1
print(sum)

結果：

5050

4.for回圈

while 可以做到在條件為真的時候反復的執行，不過有時候我們需要在特定范圍回圈，比如說我們要在第一天到第五天每天做運動一次，那么這時候用 for 就再適合不過了：

days = [1,2,3,4,5]

for day in days :
    print("第" + str(day) + "天做運動")

day就是1，第二次day就是2，它就這樣一直回圈下去，沒有一點念想，

5.終止回圈break

有一天你突然發現，我不能再這么下去了，不能再重復的過這樣的日子了，得有點改變，跳出這個重復的怪圈，那么對于 Python 來說，用break：

while 活著：
    重復的過日子，
    if（醒悟）：
    break

通過 break 呢，就可以跳出這個回圈了，

6.break和continue回圈

6.1break

break 會立即終止回圈，跳轉到回圈之后開始執行

結構：

while 條件:
  if 條件:
    break  # 跳出回圈

舉例：

i = 10

while i > 0:
    print("媽，還要我刷啊~~~~~~~~~")
    if i == 5:
        print('好了，不用刷了')
        break

    print("正在刷 %d 個碗" % i)
    i -= 1

print('程式結束')

運行結果：

媽，還要我刷啊~~~~~~~~~
正在刷 10 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 9 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 8 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 7 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 6 個碗
媽，還要我刷啊~~~~~~~~~
好了，不用刷了
程式結束

6.2continue

continue 會立即結束當前這一次回圈，跳轉到下一輪回圈的條件判斷

結構：

i = 10

while i > 0:
    print("媽，還要我刷啊~~~~~~~~~")
    if i == 5:
        print('好了，不用刷了')

        i -= 1  # continue 之前要注意修改 i 的值，否則容易導致死回圈
        continue

    print("正在刷 %d 個碗" % i)
    i -= 1

print('程式結束')

運行結果：

媽，還要我刷啊~~~~~~~~~
正在刷 10 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 9 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 8 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 7 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 6 個碗
媽，還要我刷啊~~~~~~~~~
好了，不用刷了
媽，還要我刷啊~~~~~~~~~
正在刷 4 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 3 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 2 個碗
媽，還要我刷啊~~~~~~~~~
正在刷 1 個碗
程式結束

注意點：

• break/continue只能用在回圈中，除此以外不能單獨使用
• break/continue在嵌套回圈中，只對最近的一層回圈起作用

7.資料型別轉換

7.1常用的資料型別轉換

舉例：

>>> # int(): 將資料轉換為 int 型別
... 
>>> str1 = "10"
>>> # int() 默認按10進制轉換后顯示
... num1 = int(str1)
>>> 
>>> # int() 處理浮點數，只留下整數部分，舍棄小數部分（并不是四舍五入操作）
... num2 = int(3.74)
>>> print(num2)
3
>>> 
>>> """
... num1 = int(str1, 8) # 第二個引數為8，表示按8進制轉換后顯示，結果為 8
... num1 = int(str1, 16) # # 第二個引數為16，表示按16進制轉換后顯示，結果為 16
... #01 02 03 04 05 06 07 10
... #01 02 ... 0B 0C 0D 0E 0F 10
... print(num1)
... """
>>> 
>>> # float() 將資料轉化為浮點數
... str2 = "3.14"
>>> f1 = float(str2)
>>> print(type(f1))
<class 'float'>
>>> 
>>> f2 = float(10)
>>> print(f2)
10.0
>>> 
>>> # complex() 創建復數: 第一個引數是復數的實部，第二個引數是復數的虛部
... c1 = 10 + 4j
>>> c2 = complex(10, 4)
>>> 
>>> print(c1)
(10+4j)
>>> print(c2) # 等同與c1
(10+4j)
>>> 
>>> # str() : 轉換為 字串型別
... num1 = 10
>>> f1 = 3.14
>>> 
>>> print(type(str(num1)))
<class 'str'>
>>> print(type(str(f1)))
<class 'str'>
>>> 
>>> # repr()： 轉換為運算式字串
... num1 = 10
>>> print(type(repr(num1)))
<class 'str'>
>>> 
>>> 
>>> # eval(): 將字串形式的資料，轉換為原本的型別
... str1 = "3.14"
>>> print(type(eval(str1)))
<class 'float'>
>>> 
>>> str2 = "[10, 20, 30]"
>>> l = eval(str2)
>>> print(type(l))
<class 'list'>
>>> 
>>> 
>>> # chr: 將一個整數轉換為對應的 Unicode 字符
... s = chr(1065)
>>> print(s)
Щ
>>> 
>>> # ord ：將一個字符轉換為對應的字符編碼數字
... n = ord("A")
>>> print(n)
65
>>> 
>>> # bin: 將一個整數轉換為二進制
... print(bin(1024)) # 0b 開頭表示二進制數
0b10000000000
>>> 
>>> # oct：將一個整數轉換為八進制
... print(oct(1024)) # 0o 開頭表示八進制數
0o2000
>>> 
>>> # hex: 將一個整數轉換為十六進制
... print(hex(1024)) # 0x 開頭表示十六進制
0x400
>>>

附錄：常用字符與ASCII碼對照表

三、串列

1）什么是串列？
串列是用來存盤大量資料的容器

2）串列的格式

[value1,value2,value3,...]

注意：python串列中存盤的資料可以是不同的資料型別

1.串列的常見操作

1.1增加元素

append

結構：

mylist.append(values)

舉例：

 #定義變數A，默認有3個元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']

    print("-----添加之前，串列A的資料-----")
    for tempName in A:
        print(tempName)

    #提示、并添加元素
    temp = input('請輸入要添加的學生姓名:')
    A.append(temp)

    print("-----添加之后，串列A的資料-----")
    for tempName in A:
        print(tempName)

運行結果

-----添加之前，串列A的資料-----
xiaoWang
xiaoZhang
xiaoHua
請輸入要添加的學生姓名:哈哈
-----添加之后，串列A的資料-----
xiaoWang
xiaoZhang
xiaoHua
哈哈

insert（向串列中指定位置插入資料）

結構：

mylist.insert(index, object) 在指定位置index前插入元素object

舉例：

>>> a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a
[0, 3, 1, 2]

extend（通過extend可以將另一個集合中的元素逐一添加到串列中）

結構：

myslist.extend(index,list)在指定位置index前插入串列

舉例：

>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]

1.2洗掉元素

del(根據下標進行洗掉)

結構：

del mylist(index)  # 洗掉mylist中index位置的元素

舉例：

movieName = ['加勒比海盜','駭客帝國','第一滴血','指環王','霍位元人','速度與激情']

print('------洗掉之前------')
for tempName in movieName:
    print(tempName)

del movieName[2]

print('------洗掉之后------')
for tempName in movieName:
    print(tempName)

運行結果：

------洗掉之前------
加勒比海盜
駭客帝國
第一滴血
指環王
霍位元人
速度與激情
------洗掉之后------
加勒比海盜
駭客帝國
指環王
霍位元人
速度與激情

pop(洗掉最后一個元素)

結構：

list.pop()

舉例：

movieName = ['加勒比海盜','駭客帝國','第一滴血','指環王','霍位元人','速度與激情']

print('------洗掉之前------')
for tempName in movieName:
    print(tempName)

movieName.pop()

print('------洗掉之后------')
for tempName in movieName:
    print(tempName)

運行結果：

------洗掉之前------
加勒比海盜
駭客帝國
第一滴血
指環王
霍位元人
速度與激情
------洗掉之后------
加勒比海盜
駭客帝國
第一滴血
指環王
霍位元人

remove(根據元素的值進行洗掉)

結構：

mylist.remove(value)  # value 是mylist中的值

舉例：

movieName = ['加勒比海盜','駭客帝國','第一滴血','指環王','霍位元人','速度與激情']

print('------洗掉之前------')
for tempName in movieName:
    print(tempName)

movieName.remove('指環王')

print('------洗掉之后------')
for tempName in movieName:
    print(tempName)

運行結果：

------洗掉之前------
加勒比海盜
駭客帝國
第一滴血
指環王
霍位元人
速度與激情
------洗掉之后------
加勒比海盜
駭客帝國
第一滴血
霍位元人
速度與激情

1.3修改元素

修改元素的時候，要通過下標來確定要修改的是哪個元素，然后才能進行修改

結構：

mylist[index] = newValue

舉例：

# 定義變數A，默認有3個元素
A = ['xiaoWang', 'xiaoZhang', 'xiaoHua']

print("-----修改之前，串列A的資料-----")
for tempName in A:
    print(tempName)

# 修改元素
A[1] = 'xiaoLu'

print("-----修改之后，串列A的資料-----")
for tempName in A:
    print(tempName)

運行結果：

-----修改之前，串列A的資料-----
xiaoWang
xiaoZhang
xiaoHua
-----修改之后，串列A的資料-----
xiaoWang
xiaoLu
xiaoHua

1.4查看元素

in, not in

python中查找的常用方法為：

1. in（存在）,如果存在那么結果為true，否則為false
2. not in（不存在），如果不存在那么結果為true，否則false

例如：

#待查找的串列
nameList = ['xiaoWang','xiaoZhang','xiaoHua']

#獲取用戶要查找的名字
findName = input('請輸入要查找的姓名:')

#查找是否存在
if findName in nameList:
    print('在字典中找到了相同的名字')
else:
    print('沒有找到')

運行結果1：(找到)

請輸入要查找的姓名:xiaoWang
在字典中找到了相同的名字

運行結果2：(沒有找到)

請輸入要查找的姓名:xiaoli
沒有找到

說明：

in的方法只要會用了，那么not in也是同樣的用法，只不過not in判斷的是不存在

index, count

index和count與字串中的用法相同

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左閉右開區間
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

2.元組

其實元組和串列是差不多的，不過它們有一點區別就是：元組是不可變的資料型別，也就是說元組里面的內容是不能進行修改，洗掉，添加等操作的，

元組使用圓括號來表示，例如：avlist = （'亞洲無碼原創區' ,'亞洲有碼原創區' ,'歐美原創區' ,'動漫原創區' ）
元組通常被用來列印陳述句：

2.1查看元組元素

舉例：

mylist = ('123',1,"hhh")
print(mylist[0])

運行結果：

'123'

2.2修改元組中的元素

例如：

mylist = ('123',1,"hhh")
mylist[0] = "lisi" 
print(mylist)

運行結果：

('lisi',1,'hhh')

2.3count, index

index和count與字串和串列中的用法相同

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左閉右開區間
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

3.字串

1）字串介紹
被一對雙引號或者單引號包裹的資料就是字串

2）字串輸入
之前在學習input的時候，通過它能夠完成從鍵盤獲取資料，然后保存到指定的變數中；

注意：input獲取的資料，都以字串的方式進行保存，即使輸入的是數字，那么也是以字串方式保存

3.1下標和切片

下標/索引
“下標”又叫“索引”，就是編號，

字串中"下標"的使用
如果有字串:name = 'abcdef'，在記憶體中的實際存盤如下:

如果想取出部分字符，那么可以通過下標的方法，（注意python中下標從 0 開始）

   name = 'abcdef'

   print(name[0])
   print(name[1])
   print(name[2])

運行結果:

a
b
c

3.2切片

切片是指對操作的物件截取其中一部分的操作，字串、串列、元組都支持切片操作，

切片的語法：[起始:結束:步長]
注意：選取的區間從"起始"位開始，到"結束"位的前一位結束（不包含結束位本身)，步長表示選取間隔，

我們以字串為例講解，

如果取出一部分，則可以在中括號[]中，使用:

name = 'abcdef'

 print(name[0:3]) # 取 下標0~2 的字符

abc

4.字典

4.1什么是字典？

由鍵-值對組成的資料

結構：

{key:value}

說明：

1. 字典和串列一樣，也能夠存盤多個資料
2. 串列中找某個元素時，是根據下標進行的
3. 字典中找某個元素時，是根據key
4. 字典的每個元素由2部分組成，鍵:值，
5. 字典中若訪問不存在的鍵，則會報錯
6. 使用字典名.get(key)若訪問不存在的鍵不會報錯會回傳none

4.2字典中的常見操作

增

如果在使用 變數名[‘鍵’] = 資料 時，這個“鍵”在字典中，不存在，那么就會新增這個元素

舉例：

info = {'name':'班長', 'sex':'f', 'address':'地球亞洲中國北京'}

# print('id為:%d'%info['id'])#程式會終端運行，因為訪問了不存在的鍵

newId = int(input('請輸入新的學號'))

info['id'] = newId

print('添加之后的id為:%d'%info['id'])

運行結果:

  請輸入新的學號188
    添加之后的id為: 188

刪

del 洗掉指定的元素

結構：

del mydic[key]

例子：

info = {'name':'班長', 'sex':'f', 'address':'地球亞洲中國北京'}
print('洗掉前,%s'%info['name'])
del info['name']
print('洗掉后,%s'%info['name'])  ## 洗掉后不能訪問會報錯

運行結果：

KeyError: 'name' 
洗掉前,班長

clear() 清空整個字典

結構：

mydic.clear()
demo:

info = {'name':'monitor', 'sex':'f', 'address':'China'}

print('清空前,%s'%info)

info.clear()

print('清空后,%s'%info)

運行結果：

{}

改

字典的每個元素中的資料是可以修改的，只要通過key找到，即可修改

例子：

info = {'name':'班長', 'id':100, 'sex':'f', 'address':'地球亞洲中國北京'}

newId = input('請輸入新的學號')

info['id'] = int(newId)

print('修改之后的id為:%d'%info['id'])

運行結果：

請輸入新的學號12
修改之后的id為:12

查

除了使用key查找資料，還可以使用get來獲取資料

結構

mydict[key]  # 方法一
mydict.get(key)

例子：

info = {'name':'吳彥祖','age':18}

print(info['age']) # 獲取年齡

# print(info['sex']) # 獲取不存在的key，會發生例外

print(info.get('sex')) # 獲取不存在的key，獲取到空的內容，不會出現例外

運行結果：

18
None

四、函式

1.函式介紹

1.1什么是函式？

如果在開發程式時，需要某塊代碼多次，但是為了提高撰寫的效率以及代碼的重用，所以把具有獨立功能的代碼塊組織為一個小模塊，這就是函式

1.2函式定義和呼叫

函式定義
定義函式的結構：

def 函式名:
    代碼

舉例：

# 定義一個函式，能夠完成列印資訊的功能
def printInfo():
    print('------------------------------------')
    print('         人生苦短，我用Python')
    print('------------------------------------')

呼叫函式
定義了函式之后，就相當于有了一個具有某些功能的代碼，想要讓這些代碼能夠執行，

呼叫函式的結構

函式名()

舉例：

# 定義完函式后，函式是不會自動執行的，需要呼叫它才可以
printInfo()

1.3函式的檔案說明

>>> def test(a,b):
...     "用來完成對2個數求和"
...     print("%d"%(a+b))
... 
>>> 
>>> test(11,22)
33

如果執行，以下代碼

>>> help(test)

能夠看到test函式的相關說明

Help on function test in module __main__:

test(a, b)
    用來完成對2個數求和
(END)

小結：

在函式定義之后在函式定義后的那行添加上對函式的注釋，使用help函式就可以直接列印函式的注釋和函式名

2.函式的引數

2.1什么是函式的引數？

所謂函式的引數就是在定義函式的時候可以讓函式接收資料

2.2帶引數函式的定義

結構：

def 函式名(引數名):
    代碼（代碼中可以使用引數）

舉例：

def add2num(a, b):
    c = a+b
    print(c)

2.3帶引數函式的呼叫

結構1：

函式名(引數名=資料)

結構2:

函式名(資料)  # 必須是引數名有幾個資料就有幾個，且位置對應

舉例：

add2num(a=1,b=2)
# add2num(1,2)

2.4呼叫函式的順序

>>> def test(a,b):
...     print(a,b)
... 
>>> test(1,2)
1 2
>>> test(b=1,a=2)
2 1
>>> 
>>> test(b=1,2)
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument
>>> 
>>>

2.5預設引數

呼叫函式時，預設引數的值如果沒有傳入，則取默認值

def printinfo(name, age=35):
   # 列印任何傳入的字串
   print("name: %s" % name)
   print("age %d" % age)
# 呼叫printinfo函式
printinfo(name="miki")  # 在函式執行程序中 age去默認值35
printinfo(age=9 ,name="miki")

運行結果：

name:miki  age:35
name:miki  age:9

總結：

• 形參中默認有值的引數，稱之為預設引數
• 注意：帶有默認值的引數一定要位于引數串列的最后面

2.6不定長引數

基本語法:

def 函式名(形參，\*形參，\**形參):
    執行功能
    return 回傳值

def fun(a, b, *args, **kwargs):
     """可變引數演示示例"""
    print("a =%d" % a)
    print("b =%d" % b)
    print("args:")
    print(args)
    print("kwargs: ")
		for key, value in kwargs.items(): #遍歷字典
				print("key=%s" % value) #輸出字典

fun(1,2,3,4,5,m=6,n=7,p=8)#呼叫函式

運行結果：

a = 1 b = 2  args = [3,4,5]  kwargs = {"m":6,"n":7,"p":8}

注意：

• 加了星號（*）的形參會存放所有未命名的變數引數，*形參為元組
• **而加*的形參會存放命名引數，即形如key=value的引數，*形參為字典.

2.7小總結

• 定義時小括號中的引數，用來接收引數用的，稱為 “形參”
• 呼叫時小括號中的引數，用來傳遞給函式用的，稱為 “實參”

3.函式的引數（補充）

1）預設引數
結構：

def 函式名(引數名稱=值):  # 引數名稱=值這種就是預設引數
    代碼

• 意義：預設引數就是形參中默認有值的引數
• 注意：帶有默認值的引數一定要位于引數串列的最后面
• 作用：呼叫函式時，預設引數的值如果沒有傳入，則取默認值

舉例：

def printinfo(name, age=35):
   # 列印任何傳入的字串
   print("name: %s" % name)
   print("age %d" % age)

# 呼叫printinfo函式
printinfo(name="miki")  # 在函式執行程序中 age去默認值35
printinfo(age=9 ,name="miki")

運行結果：

name: miki
age: 35
name: miki
age: 9

2)不定長引數
結構：

def 函式名([formal_args,] *args, **kwargs):  # *args, **kwargs就是不定長引數
   """函式_檔案字串"""
   代碼
   return [expression]

意義：有時可能需要一個函式能處理比當初宣告時更多的引數, 這些引數叫做不定長引數，宣告時不會命名，

注意：

• 加了星號（*）的變數args會存放所有未命名的變數引數，args為元組
• 而加的變數kwargs會存放命名引數，即形如key=value的引數， kwargs為字典

作用：可以接受不定的資料

舉例：

def func(a, b, *args, **kwargs):
    """可變引數演示示例"""
    print("a=%s" % a)
    print("b=%s" % b)
    print("args:", end="")
    print(args)
    print("kwargs:", end="")
    for key, value in kwargs.items():
        print("key=%s," % key, end="")
        print("value=%s" % value, end="\n")


# 注意引數對應
func(1, 2, 3, 4, 5, m=6, n=7, p=8)
print("---------------------------")

c = (3, 4, 5)
d = {"m": 6, "n": 7, "p": 8}
# 注意元組和字典的傳參方式
func(1, 2, *c, **d)

print("---------------------------")
# 不加*比較
func(1, 2, c, d)

運行結果：

a=1
b=2
args:(3, 4, 5)
kwargs:key=m,value=6
key=n,value=7
key=p,value=8
---------------------------
a=1
b=2
args:(3, 4, 5)
kwargs:key=m,value=6
key=n,value=7
key=p,value=8
---------------------------
a=1
b=2
args:((3, 4, 5), {'m': 6, 'n': 7, 'p': 8})
kwargs:

3）預設引數在*args后
如果很多個值都是不定長引數，那么這種情況下，可以將預設引數放到 *args的后面， 但如果有**kwargs的話，**kwargs必須是最后的

例子：

def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)


sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)

運行結果：

100
1
2
(200, 300, 400, 500, 600, 700)
{'mm': 800, 'nn': 900}

4.函式的回傳值

4.1什么是函式回傳值？

所謂“回傳值”，就是程式中函式完成一件事情后，最后給呼叫者的結果

**1）**帶有回傳值的函式
結構：

def 函式名(引數名/無引數名):
    “”“注釋”“”
    代碼
    return 回傳值

舉例：

def add2num(a, b):
    c = a+b
    return c

4.2保存函式的回傳值

所謂的保存其實就是將回傳值給予給一個新的變數

舉例：

#定義函式
def add2num(a, b):
    return a+b

#呼叫函式，順便保存函式的回傳值
result = add2num(100,98)

#因為result已經保存了add2num的回傳值，所以接下來就可以使用了
print(result)

結果:

198

4.3回傳多個值

關于return：一個函式中可以有多個return陳述句，但是只要有一個return陳述句被執行到，那么這個函式就會結束了，因此后面的return沒有什么用處

回傳多值的方法：return后面可以是元組，串列、字典等，只要是能夠存盤多個資料的型別，就可以一次性回傳多個資料

注意：

return后面有多個資料，那么默認是元組

例如：

def divid(a, b):
    shang = a//b
    yushu = a%b 
    return shang, yushu  #默認是元組

result = divid(5, 2)
print(result)  # 輸出(2, 1)

5.函式的型別

5.1 4種函式的型別

函式根據有沒有引數，有沒有回傳值，可以相互組合，一共有4種

1. 無引數，無回傳值
2. 無引數，有回傳值
3. 有引數，無回傳值
4. 有引數，有回傳值

5.2無引數，無回傳值的函式

此類函式，不能接收引數，也沒有回傳值，一般情況下，列印提示燈類似的功能，使用這類的函式

def printMenu():
    print('--------------------------')
    print('      xx涮涮鍋 點菜系統')
    print('')
    print('  1.  羊肉涮涮鍋')
    print('  2.  牛肉涮涮鍋')
    print('  3.  豬肉涮涮鍋')
    print('--------------------------')

結果:

--------------------------
      xx涮涮鍋 點菜系統

  1.  羊肉涮涮鍋
  2.  牛肉涮涮鍋
  3.  豬肉涮涮鍋
--------------------------

5.3無引數，有回傳值的函式

此類函式，不能接收引數，但是可以回傳某個資料，一般情況下，像采集資料，用此類函式

# 獲取溫度
def getTemperature():
    # 這里是獲取溫度的一些處理程序
    # 為了簡單起見，先模擬回傳一個資料
    return 24

temperature = getTemperature()
print('當前的溫度為:%d'%temperature)

結果:

當前的溫度為: 24

5.4有引數，無回傳值的函式

此類函式，能接收引數，但不可以回傳資料，一般情況下，對某些變數設定資料而不需結果時，用此類函式

5.5有引數，有回傳值的函式

此類函式，不僅能接收引數，還可以回傳某個資料，一般情況下，像資料處理并需要結果的應用，用此類函式

# 計算1~num的累積和
def calculateNum(num):
    result = 0
    i = 1
    while i<=num:
        result = result + i
        i+=1
    return result

result = calculateNum(100)
print('1~100的累積和為:%d'%result)

結果:

1~100的累積和為: 5050

5.小總結

1. 函式根據有沒有引數，有沒有回傳值可以相互組合
2. 定義函式時，是根據實際的功能需求來設計的，所以不同開發人員撰寫的函式型別各不相同

6.函式的嵌套呼叫

def testB():
    print('---- testB start----')
    print('這里是testB函式執行的代碼...(省略)...')
    print('---- testB end----')

def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')

testA()

結果：

---- testA start----
---- testB start----
這里是testB函式執行的代碼...(省略)...
---- testB end----
---- testA end----

小總結：

• 一個函式里面又呼叫了另外一個函式，這就是所謂的函式嵌套呼叫 函式嵌套呼叫
  

• 如果函式A中，呼叫了另外一個函式B，那么先把函式B中的任務都執行完畢之后才會回到上次 函式A執行的位置

7.函式的變數

7.1什么是作用域

所謂的作用域是指有效的作用空間，在程式中是指某個變數或者資料作用的地方大小

7.2區域變數

結構：

def 函式名(引數):
    變數名稱  # 這個變數就是區域變數

• 意義：就是在函式內部定義的變數，其作用范圍是這個函式內部，即只能在這個函式中使用，在函式的外部是不能使用的
• 作用：區域變數的作用，為了臨時保存資料需要在函式中定義變數來進行存盤
• 有效時間：當函式呼叫時，區域變數被創建，當函式呼叫完成后這個變數就不能夠使用了

7.3全域變數

結構：

變數名稱  # 這個變數就是全域變數
def 函式(引數):
    代碼

• 意義：在函式外邊定義的變數，其作用范圍是所有函式，所有的函式中都可以進行訪問
• 作用：可以作為共享變數來使用
• 有效時間：直到程式結束

7.4區域變數和全域變數名字相同問題

舉例：

# 定義全域變數
a = 100


def test1():
    a = 300  # 定義區域變數
    print('-----test1----修改前---a=%d' % a)
    a = 200
    print('-----test1----修改后---a=%d' % a)


def test2():
    print('-----test2---a=%d' % a)


# 呼叫函式
test1()
test2()

運行結果：

-----test1----修改前---a=300
-----test1----修改后---a=200
-----test2---a=100

總結：

當函式內出現區域變數和全域變數相同名字時，函式內部中的 變數名 = 資料 此時理解為定義了一個區域變數，而不是修改全域變數的值

7.5修改全域變數

結構：

變數名稱  # 定義全域變數
def 函式名(引數):
  global 變數名稱   # 宣告使用的是全域變數 
  代碼

舉例：

# 全域變數和區域變數名稱相同例子
# 定義全域變數
a = 100


def test1():
    global a  # 宣告全域變數
    print('-----test1----修改前---a=%d' % a)
    a = 200
    print('-----test1----修改后---a=%d' % a)


def test2():
    print('-----test2---a=%d' % a)


# 呼叫函式
test1()
test2()

運行結果：

-----test1----修改前---a=100
-----test1----修改后---a=200
-----test2---a=200

總結：

• 如果在函式中出現global 全域變數的名字 那么這個函式中即使出現和全域變數名相同的變數名 = 資料也理解為對全域變數進行修改，而不是定義區域變數
• 如果在一個函式中需要對多個全域變數進行修改，那么可以使用

補充：

# 可以使用一次global對多個全域變數進行宣告
global a, b
# 還可以用多次global宣告都是可以的
# global a
# global b

8.函式的特性

8.1函式之間共享資料

函式之間共享資料的方法如下：

1）使用全域變數

舉例：

g_num = 0


def test1():
    global g_num
    # 將處理結果存盤到全域變數g_num中
    g_num = 100


def test2():
    # 通過獲取全域變數g_num的值，從而獲得test1函式處理之后的結果
    print(g_num)


# 1.先呼叫test1得到資料保存到全域變數中
test1()
# 2.在呼叫test2，處理test1函式執行之后的這個值
test2()

運行結果：

100

函式之間共享變數可以使用全域變數作為媒介來存盤和轉發資料從而達到共享資料的結果

2）使用函式的回傳值、引數

舉例：

def test1():
    # 通過return將一個資料結果回傳
    return 50


def test2(num):
    # 通過形參的方式保存傳遞過來的資料，就可以處理了
    print(num)


# 1. 先呼叫test1得到資料并且存到變數result中
result = test1()

# 2. 呼叫test2時，將result的值傳遞到test2中，從而讓這個函式對其進行處理
test2(result)

運行結果：

50

3）函式嵌套呼叫

舉例：

def test1():
    # 通過return將一個資料結果回傳
    return 20


def test2():
    # 1. 先呼叫test1并且把結果回傳來
    result = test1()
    # 2. 對result進行處理
    print(result)


# 呼叫test2時，完成所有的處理
test2()

運行結果：

20

9.函式特殊化處理

9.1拆包

所謂的拆包就是將python特殊結構的資料直接分開存盤的程序

舉例：

# 直接對函式的回傳值進行拆包
def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age


my_high, my_weight, my_age = get_my_info()
print(my_high)
print(my_weight)
print(my_age)

運行結果：

178
100
18

注意：

• 拆包時要注意，需要拆的資料的個數要與變數的個數相同，否則程式會例外
• 除了對元組拆包之外，還可以對串列、字典等拆包

舉例：

  In [17]: a, b = (11, 22)
  In [18]: a
  Out[18]: 11
  In [19]: b
  Out[19]: 22

  In [20]: a, b = [11, 22]
  In [21]: a
  Out[21]: 11
  In [22]: b
  Out[22]: 22

  In [23]: a, b = {"m":11, "n":22}  # 取出來的是key，而不是鍵值對
  In [24]: a
  Out[24]: 'm'
  In [25]: b
  Out[25]: 'n'

9.2交換變數值

交換變數的方法有很多

方法一：借用第三方幫助

舉例：

a = 4
b = 5
c = 0  # 第三方
# 交換開始
c = a
a = b
b = c

print(a)
print(b)

方法二：計演算法

舉例：

a = 4
b = 5
# 開始計算
a = a+b  # a=9, b=5
b = a-b  # a=9, b=4
a = a-b  # a=5, b=4

print(a)
print(b)

方法三：拆包法

舉例：

a, b = 4, 5
a, b = b, a

print(a)
print(b)

五、面向物件編程介紹

1.什么是面向物件？

生活中我們用洗衣機洗衣服不比考慮洗衣機的構造和制造我們只需要直接把衣服丟進去即可，這種讓其他專業的事物去做的思想就是面向物件，每一步我們都不需要親力親為，只需要關注結果就行，在編程中面向物件編程思想將資料與函式系結到一起，分類進行封裝，每個程式員只要負責分配給自己的分類，這樣能夠更快速的開發程式，減少了重復代碼，

2.面向程序和面向物件對比

面向程序：根據業務邏輯從上到下寫代碼，每一步都是自己做，

面向物件：將資料與函式系結到一起，分類進行封裝，每個程式員只要負責分配給自己的分類，這樣能夠更快速的開發程式，減少了重復代碼，每一步都照專業的人做

面向物件(object-oriented ;簡稱: OO) 至今還沒有統一的概念 我這里把它定義為: 按人們 認識客觀世界的系統思維方式,采用基于物件(物體)的概念建立模型,模擬客觀世界分析、設 計、實作軟體的辦法，

面向物件編程(Object Oriented Programming-OOP) 是一種解決軟體復用的設計和編程方法， 這種方法把軟體系統中相近相似的操作邏輯和操作 應用資料、狀態,以類的型式描述出來,以物件實體的形式在軟體系統中復用,以達到提高軟體開發效率的作用，

3.類和物件

面向物件編程的2個非常重要的概念：類和物件

物件是面向物件編程的核心，在使用物件的程序中，為了將具有共同特征和行為的一組物件抽象定義，提出了另外一個新的概念——類

類就相當于制造飛機時的圖紙，用它來進行創建的飛機就相當于物件

3.1類

概念：

• 具有相似內部狀態和運動規律的物體的集合(或統稱為抽象)，
• 具有相同屬性和行為事物的統稱
  類是抽象的,在使用的時候通常會找到這個類的一個具體的存在,使用這個具體的存在，一個類可以找到多個物件

3.2物件

概念：

• 某一個具體事物的存在 ,在現實世界中可以是看得見摸得著的，
• 可以是直接使用的

3.3類和物件的關系

類和物件的關系好比就是做餅的模子和餅之間的關系，通過模子來制造餅，類就是創建物件的模板

3.4類的構成

類(Class) 由3個部分構成

• 類的名稱:類名
• 類的屬性(就是變數):一組資料
• 類的方法(就是函式):允許對進行操作的方法 (行為)

舉例：

# 貓類
類名:貓(cat)
屬性:品種 、毛色、性別、名字、 腿兒的數量
方法(行為/功能):叫 、跑、吃、搖尾巴

3.5類的抽象

如何把日常生活中的事物抽象成程式中的類?

擁有相同(或者類似)屬性和行為的物件都可以抽像出一個類

方法:一般名詞都是類(名詞提煉法)

Eg:

小明正在使用電腦編程
小明 -->可以抽像成人類
電腦 -->可以抽像成電腦類

4.類的定義和物件的創建

4.1類的定義

格式：

class 類名稱：
    方法串列

舉例:

# class Hero:  # 經典類（舊式類）定義形式

# 定義一個英雄類
class Hero(object):
  def info(self):
      print("英雄莫問出處")

說明：

• 定義類時有2種形式：新式類和經典類，上面代碼中的Hero為新式類，前兩行注釋部分則為經典類；
• object 是Python 里所有類的最頂級父類；
• 類名 的命名規則按照"大駝峰命名法"；
• info 是一個實體方法，第一個引數一般是self，表示實體物件本身，當然了可以將self換為其它的名字，其作用是一個變數這個變數指向了實體物件

詳細格式：

class 類名(object):
    def  方法1（self,引數串列） # 必須是self
        pass
    def 方法2（self,引數串列）
        pass

4.2創建物件

python中，可以根據已經定義的類去創建出一個或多個物件，

格式:

物件名 = 類名()

舉例：

class Hero(object):
    def info(self):
        """info 是一個實體方法，類物件可以呼叫實體方法，實體方法的第一個引數一定是self"""
        print(self)
        """當物件呼叫實體方法時，Python會自動將物件本身的參考做為引數，傳遞到實體方法的第一個引數self里"""
        print("self各不同，物件是出處")


# Hero這個類 實體化了一個物件
super_man = Hero()
# 物件呼叫實體方法info()，執行info()里的代碼
# . 表示選擇屬性或者方法
super_man.info()

print(super_man)  # 列印物件，則默認列印物件在記憶體的地址，結果等同于info里的print(self)
print(id(super_man))  # id(super_man)則是記憶體地址的十進制形式表示

4.3添加和獲取物件的屬性

class Hero(object):
    """定義了一個英雄類，可以移動和攻擊"""
    def move(self):
        """實體方法"""
        print("正在前往事發地點...")

    def attack(self):
        """實體方法"""
        print("發出了一招強力的普通攻擊...")

# 實體化了一個英雄物件 泰達米爾
taidamier = Hero()

# 給物件添加屬性，以及對應的屬性值
taidamier.name = "泰達米爾"  # 姓名
taidamier.hp = 2600  # 生命值
taidamier.atk = 450  # 攻擊力
taidamier.armor = 200  # 護甲值

# 通過.成員選擇運算子，獲取物件的屬性值
print("英雄 %s 的生命值 :%d" % (taidamier.name, taidamier.hp))
print("英雄 %s 的攻擊力 :%d" % (taidamier.name, taidamier.atk))
print("英雄 %s 的護甲值 :%d" % (taidamier.name, taidamier.armor))

# 通過.成員選擇運算子，獲取物件的實體方法
taidamier.move()
taidamier.attack()

4.4在方法內通過self獲取物件屬性

class Hero(object):
    """定義了一個英雄類，可以移動和攻擊"""
    def move(self):
        """實體方法"""
        print("正在前往事發地點...")

    def attack(self):
        """實體方法"""
        print("發出了一招強力的普通攻擊...")

    def info(self):
        """在類的實體方法中，通過self獲取該物件的屬性"""
        print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
        print("英雄 %s 的攻擊力 :%d" % (self.name, self.atk))
        print("英雄 %s 的護甲值 :%d" % (self.name, self.armor))


# 實體化了一個英雄物件 泰達米爾
taidamier = Hero()

# 給物件添加屬性，以及對應的屬性值
taidamier.name = "泰達米爾"  # 姓名
taidamier.hp = 2600  # 生命值
taidamier.atk = 450  # 攻擊力
taidamier.armor = 200  # 護甲值

# 通過.成員選擇運算子，獲取物件的實體方法
taidamier.info()  # 只需要呼叫實體方法info()，即可獲取英雄的屬性
taidamier.move()
taidamier.attack()

5. init()方法

5.1魔法方法

所謂的魔法方法是在python類里提供的，兩個下劃線開始，兩個下劃線結束的方法，

5.2什么是_init_()方法

init()就是一個魔法方法，通常用來做屬性初始化 或 賦值 操作， 如果類面沒有寫__init__方法，Python會自動創建，但是不執行任何操作，如果為了能夠在完成自己想要的功能，可以自己定義__init__方法， 所以一個類里無論自己是否撰寫__init__方法一定有__init__方法，

結構:

class 類名稱(object):
    def __init__(self):
        屬性/賦值

舉例：

class Hero(object):
    """定義了一個英雄類，可以移動和攻擊"""
    def __init__(self):
        """ 方法，用來做變數初始化 或 賦值 操作，在類實體化物件的時候，會被自動呼叫"""
        self.name = "泰達米爾" # 姓名
        self.hp = 2600 # 生命值
        self.atk = 450  # 攻擊力
        self.armor = 200  # 護甲值

    def move(self):
        """實體方法"""
        print("正在前往事發地點...")

    def attack(self):
        """實體方法"""
        print("發出了一招強力的普通攻擊...")


# 實體化了一個英雄物件，并自動呼叫__init__()方法
taidamier = Hero()

# 通過.成員選擇運算子，獲取物件的實體方法
taidamier.info() # 只需要呼叫實體方法info()，即可獲取英雄的屬性
taidamier.move()
taidamier.attack()

說明：

• init()方法，在創建一個物件時默認被呼叫，不需要手動呼叫
• init(self)中的self引數，不需要開發者傳遞，python解釋器會自動把當前的物件參考傳遞過去，

5.3有引數的_init_()方法

結構：

class 類名稱(object):
    def __init__(self):
        屬性/賦值

舉例：

class Hero(object):
    """定義了一個英雄類，可以移動和攻擊"""

    def __init__(self, name, skill, hp, atk, armor):
        """ __init__() 方法，用來做變數初始化 或 賦值 操作"""
        # 英雄名
        self.name = name
        # 技能
        self.skill = skill
        # 生命值：
        self.hp = hp
        # 攻擊力
        self.atk = atk
        # 護甲值
        self.armor = armor

    def move(self):
        """實體方法"""
        print("%s 正在前往事發地點..." % self.name)

    def attack(self):
        """實體方法"""
        print("發出了一招強力的%s..." % self.skill)

    def info(self):
        print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
        print("英雄 %s 的攻擊力 :%d" % (self.name, self.atk))
        print("英雄 %s 的護甲值 :%d" % (self.name, self.armor))


# 實體化英雄物件時，引數會傳遞到物件的__init__()方法里
taidamier = Hero("泰達米爾", "旋風斬", 2600, 450, 200)
gailun = Hero("蓋倫", "大寶劍", 4200, 260, 400)


# print(gailun)
# print(taidamier)

# 不同物件的屬性值的單獨保存
print(id(taidamier.name)) 
print(id(gailun.name))

# 同一個類的不同物件，實體方法共享
print(id(taidamier.move())) 
print(id(gailun.move()))

說明：

• 通過一個類，可以創建多個物件，就好比 通過一個模具創建多個物體一樣
• init(self)中，默認有1個引數名字為self，如果在創建物件時傳遞了2個實參，那么__init__(self)中出了self作為第一個形參外還需要2個形參，例如__init__(self,x,y)

5.4小總結

1.當使用類名()創建物件時，會自動執行以下操作

1. 為物件在記憶體中分配空間–創建物件
2. 為物件的屬性設定初始值–初始化方法（init())
3. init()是物件的內置函式
4. __init__方法時專門來定義一個類具有哪些屬性的方法
5. 使用類名()創建物件時，會自動呼叫初始化方法
6. 在__init__方法內部使用self.屬性=屬性的初始化的方法就會定義屬性
7. 定義屬性后在使用類創建物件都會擁有該屬性

改造初始化方法

在開發中如果希望在創建物件的同時就設定物件的屬性就要對__init__進行改造

1、把希望設定的屬性值，定義成init方法的引數

2、在方法內部使用self.屬性 = 形參接受外部傳遞的引數

3、在創建物件時，使用類名（屬性1，屬性2，，，，）呼叫

注意：

1. 在類內部獲取 屬性 和 實體方法，通過self獲取；
2. 在類外部獲取 屬性 和 實體方法，通過物件名獲取，
3. 如果一個類有多個物件，每個物件的屬性是各自保存的，都有各自獨立的地址；
4. 但是實體方法是所有物件共享的，只占用一份記憶體空間，類會通過self來判斷是哪個物件呼叫了實體方法，

6.__str__方法

6.1 __str__方法作用

這個方法是一個魔法方法 (Magic Method) ，用來顯示資訊 該方法需要 return 一個資料，并且只有self一個引數，當在類的外部 print(物件) 則列印這個資料

如果在開發中，希望輸出物件變數時，能夠列印自定義內容，就可以使用__strl__這個內置方法

注意：str方法必須有一個回傳值

結構：

class 類名稱(object):
    def __init__(self,引數串列):
        屬性/賦值
    def __str__(self):
        return 資訊

舉例：

class Hero(object):
    """定義了一個英雄類，可以移動和攻擊"""

    def __init__(self, name, skill, hp, atk, armor):
        """ __init__() 方法，用來做變數初始化 或 賦值 操作"""
        # 英雄名
        self.name = name  # 實體變數
        # 技能
        self.skill = skill
        # 生命值：
        self.hp = hp  # 實體變數
        # 攻擊力
        self.atk = atk
        # 護甲值
        self.armor = armor

    def move(self):
        """實體方法"""
        print("%s 正在前往事發地點..." % self.name)

    def attack(self):
        """實體方法"""
        print("發出了一招強力的%s..." % self.skill)

    # def info(self):
    #     print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
    #     print("英雄 %s 的攻擊力 :%d" % (self.name, self.atk))
    #     print("英雄 %s 的護甲值 :%d" % (self.name, self.armor))

    def __str__(self):
        """
            這個方法是一個魔法方法 (Magic Method) ，用來顯示資訊
            該方法需要 return 一個資料，并且只有self一個引數，當在類的外部 print(物件) 則列印這個資料
        """
        return "英雄 <%s> 資料： 生命值 %d, 攻擊力 %d, 護甲值 %d" % (self.name, self.hp, self.atk, self.armor)


taidamier = Hero("泰達米爾", "旋風斬", 2600, 450, 200)
gailun = Hero("蓋倫", "大寶劍", 4200, 260, 400)

# 如果沒有__str__ 則默認列印 物件在記憶體的地址，
# 當類的實體化物件 擁有 __str__ 方法后，那么列印物件則列印 __str__ 的回傳值，
print(taidamier)
print(gailun)

# 查看類的檔案說明，也就是類的注釋
print(Hero.__doc__)

運行結果：

英雄 <泰達米爾> 資料： 生命值 2600, 攻擊力 450, 護甲值 200
英雄 <蓋倫> 資料： 生命值 4200, 攻擊力 260, 護甲值 400
定義了一個英雄類，可以移動和攻擊

6.2說明：

• 在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
• 當使用print輸出物件的時候，默認列印物件的記憶體地址，如果類定義了__str__(self)方法，那么就會列印從在這個方法中 return 的資料
• __str__方法通常回傳一個字串，作為這個物件的描述資訊

7. del()方法

7.1 del()方法介紹

• 當使用類名()創建物件時，為物件分配空間后，自動呼叫_init_()方法
• 當一個物件被從記憶體中銷毀時會自動呼叫_init_()方法

結構：

class 類名稱(object):
    def __init__(self,引數串列):
        屬性/賦值
    def __str__(self):
        return 資訊
    def __del__(self,引數串列):
         代碼

舉例：

class Hero(object):

    # 初始化方法
    # 創建完物件后會自動被呼叫
    def __init__(self, name):
        print('__init__方法被呼叫')
        self.name = name

    # 當物件被洗掉時，會自動被呼叫
    def __del__(self):
        print("__del__方法被呼叫")
        print("%s 被 GM 干掉了..." % self.name)


# 創建物件
taidamier = Hero("泰達米爾")

# 洗掉物件
print("%d 被洗掉1次" % id(taidamier))
del(taidamier)


print("--" * 10)


gailun = Hero("蓋倫")
gailun1 = gailun
gailun2 = gailun

print("%d 被洗掉1次" % id(gailun))
del(gailun)

print("%d 被洗掉1次" % id(gailun1))
del(gailun1)

print("%d 被洗掉1次" % id(gailun2))
del(gailun2)

7.2總結

• 當有變數保存了一個物件的參考時，此物件的參考計數就會加1；
• 當使用del() 洗掉變數指向的物件時，則會減少物件的參考計數，如果物件的參考計數不為1，那么會讓這個物件的參考計數減1，當物件的參考計數為0的時候，則物件才會被真正洗掉（記憶體被回收），

應用場景：

• __init__改造初始化方法，可以讓創建物件更加靈活
• del()如果希望在物件被銷毀前，在做一些事情，可以考慮一下__del__()方法

7.3生命周期

1、當一個物件被呼叫類名（）創建，生命周期開始

2、一個物件的__del__方法一旦被呼叫，生命周期結束

3、對面向物件生命周期內，可以訪問物件屬性或者讓物件呼叫方法

8.繼承

8.1什么是繼承？

在生活中繼承的含義一般是子女繼承父輩的財產，而在程式中是指，類繼承另外一個類的屬性和方法，

• 在程式中，繼承描述的是多個類之間的所屬關系，
• 如果一個類A里面的屬性和方法可以復用，則可以通過繼承的方式，傳遞到類B里，
• 那么類A就是基類，也叫做父類；類B就是派生類，也叫做子類，

繼承的概念：子類擁有父類的所有屬性和方法

舉例：

# 父類
class A(object):
    def __init__(self):
        self.num = 10

    def print_num(self):
        print(self.num + 10)
# 子類
class B(A):
    pass


b = B()
print(b.num) 
b.print_num()

運行結果：

10
20

8.2單繼承：子類只繼承一個父類

結構

class 類名稱(父類名):
    方法/屬性

舉例：

# 老貓將自己的一身本領傳給小貓
# 定一個父類
class Cat(object):
    def __init__(self):
        self.kongfu = "厲害的捉魚本領"

    def make_fish(self):
        print("利用%s抓魚" % self.kongfu)


# MinCat，繼承了Cat，Cat是父類，
class MinCat(Cat):
    pass


xiaohua = MinCat()
print(xiaohua.kongfu)
xiaohua.make_fish()

運行結果：

厲害的捉魚本領
利用厲害的捉魚本領抓魚

說明：

• 雖然子類沒有定義__init__方法初始化屬性，也沒有定義實體方法，但是父類有，所以只要創建子類的物件，就默認執行了那個繼承過來的__init__方法

總結：

• 子類在繼承的時候，在定義類時，小括號()中為父類的名字
• 父類的屬性、方法，會被繼承給子類

8.3多繼承：子類只繼承多個父類

結構：

class 類名稱(父類名1,父類名2):
    方法/屬性

舉例：

# 老貓將自己的一身本領傳給小貓,同時狗狗也將自己看家的本事傳給了小貓
# 定一個父類
class Cat(object):
    def __init__(self):
        self.kongfu = "厲害的捉魚本領"

    def make_fish(self):
        print("利用%s抓魚" % self.kongfu)

# 定義第二個父類
class Dog(object):
    def __init__(self):
        self.kongfu = "厲害的看家本領"

    def kanmen(self):
        print("利用%s看家" % self.kongfu)


# MinCat，繼承了Cat、Dog，Cat、Dog是父類，
class MinCat(Cat,Dog):
    pass


xiaohua = MinCat()

print(xiaohua.kongfu)
xiaohua.make_fish()
xiaohua.kanmen()

運行結果：

厲害的捉魚本領
利用厲害的捉魚本領抓魚
利用厲害的捉魚本領看家

說明：

• 多繼承可以繼承多個父類，也繼承了所有父類的屬性和方法
• 注意：如果多個父類中有同名的 屬性和方法，則默認使用第一個父類的屬性和方法
• 多個父類中，不重名的屬性和方法，不會有任何影響，

8.4 __mro__方法

子類的魔法屬性__mro__決定了屬性和方法的查找順序

列子：

# 老貓將自己的一身本領傳給小貓,同時狗狗也將自己看家的本事傳給了小貓
# 定一個父類
class Cat(object):
    def __init__(self):
        self.kongfu = "厲害的捉魚本領"

    def make_fish(self):
        print("利用%s抓魚" % self.kongfu)


# 定義第二個父類
class Dog(object):
    def __init__(self):
        self.kongfu = "厲害的看家本領"

    def kanmen(self):
        print("利用%s看家" % self.kongfu)


# MinCat，繼承了Cat、Dog，Cat、Dog是父類，
class MinCat(Cat, Dog):
    pass


xiaohua = MinCat()
print(MinCat.__mro__)

運行結果：

(<class '__main__.MinCat'>, <class '__main__.Cat'>, <class '__main__.Dog'>, <class 'object'>)

注意：如果多個父類中有同名的 屬性和方法，則默認使用第一個父類的屬性和方法（根據類的魔法屬性mro的順序來查找）