為了照顧有基礎的人，我這裡将本文分為了6個階段，如果你是這個階段的

可以點選下面跳過已經看過的部分，畢竟不是所有人都有耐心重新看一遍已經會的東西的~~

階段性:

第一階段：

零基礎第二階段：基本文法第三階段：分支語句第四階段：函數式程式設計第五階段：面向對象程式設計第六階段： numpy 第七階段： matplotlib 第八階段：數學基礎點選直接檢視粉絲福利：點我領取粉絲福利

人工智能入門四件套

人工智能現在有多火我就不用說了吧，想學人工智，你需要這四個東西：

Python語言基礎

numpy——矩陣工具

matplotlib——資料可視化工具

當然還需要數學基礎

一、 Python語言基礎

第一階段

先看看我嘔心瀝血做的這個Python基礎文法的思維導圖吧

不過這是全棧Python需要學習的東西，學習人工智能并不需要這麼多，來跟我一起看看吧

1.1 Python介紹

現在不是一直都在吹Python嗎，說什麼國小都要出Python的教材了，搞得好像這年頭不會個Python還不如國小生一樣！

既然如此，那麼？你會Python嗎？

不會？不要緊！一篇文帶你入門Python！一篇文帶你疏通Python基礎文法！

會？行吧，别急着走嘛！看看吧。畢竟，溫故而知新，可以為師矣！

Python作為一門進階程式設計語言嗎，最大的特點就是簡單易學

1.2 Python安裝

注意現在Python分為Python2.x和Python3.x版本，我們這裡介紹的是Python3.x版本，不要下載下傳錯誤

1. 普通版本

可以去官網下載下傳——

官網

下載下傳後傻瓜式安裝，不過有一步需要注意的是：Add to path的地方需要勾一下

不勾選的話需要手動配置環境，異常麻煩

2. Anaconda發行版

Anaconda是一個Python版本，隻不過他內建了關于人工智能相關的必要庫，包括numpy，matplotlib等

下載下傳連結——

點選即可下載下傳64位windows安裝包

然後就是傻瓜式安裝

1.3 pycharm編輯器安裝

下載下傳pycharm專業版，怎麼破解我這裡就不教了，自行百度

是傻瓜式安裝，讓你打鈎的地方全部打鈎，等到安裝成功後，再打開，不注冊，選擇跳過，會讓你試用30day

然後選擇

New Project

，點選建立一個新的項目，資訊填寫好，然後Create

然後經過漫長的等待就行了，注意，真的是漫長的等待，要等好久的

1.4 基礎文法

python身為一個進階語言，也是有自己的文法格式的。

1. 注釋

什麼叫做注釋呢？注釋就是對我們的代碼進行解釋，讓别人能夠看懂我們寫的代碼。但是計算機卻會對我們的注釋熟視無睹，因為他并不需要你的解釋，他能看懂。

單行注釋： # 這是單行注釋

多行注釋：""“這是多行注釋”""

2. 保留字

再别的語言裡也叫做關鍵字，是在python這門語言中另有作用的名字。

而有時，你不需要管這個單詞是什麼意思，隻需要知道他的作用是什麼，不過程式設計語言中講究見名知意，是以英語好一點是有優勢的。不過也不能全靠翻譯意思。

python的保留字相對來說較少，有33個

3. 辨別符

辨別符，這個東西是我們自己命名的東西，但是呢，我們又不能随意的命名，因為不知定格規範的話，有的人寫這種，有的人寫那種，計算機又會看不懂了。

辨別符的規範：可以包含數字，字母，下劃線，但是又不能以數字開頭，并且辨別符對大小寫敏感。

而現在，我們學的python3，有個中國人的福音：那就是，*我們可以使用中文作為我們的辨別符！*是的沒錯，中文作為辨別符。當然，同樣不可以數字開頭。

辨別符的作用下一篇會提到。

小練習

判斷以下辨別符是否正确

1smly

smly

_smly

smly_

sm_ly

判斷下列辨別符是否相同

smly Smly

smly sMly

SMLy smLY

smly1 Smly1

4. 縮進

縮進在python中是及其重要的，就好像我們說話時的标點符号但又不完全一樣，因為在python中縮進是必須的，縮進是讓計算機知道我們的代碼是從哪裡分段的，而如果沒有縮進，計算機就不認識你的代碼，就會報錯。

那麼什麼是報錯呢，就好像你朋友對你胡言亂語的一頓輸出，你卻聽不懂，這時候你就會說，我聽不懂，你說聽不懂，就是報錯，給你朋友看的，他知道你聽不懂，就會重新組織語言，直到讓你聽懂。

那麼計算機也是同樣的道理，你不縮進的代碼，計算機就不懂，就會給你報錯，讓你明白，他不懂，這樣你就會修改你的代碼，讓計算機明白你的意思。

而這個過程也是我們調試我們的代碼的過程。

不同的代碼組合在一起，就像不同的漢字組合在一樣，分隔開不同的段，就有不同的意思。

而縮進也有包含的意思，相同層次的代碼縮進相同，層次靠下的縮進依次減少。（這個暫時不了解也是沒事的，後面就會了解了）

# 1. 判斷以下代碼能否運作
print("Hello")
 print("World")
print("!")

5. 輸入

輸出我們已經知道了，使用print()，那麼輸入呢？

input()

input()
print()

運作試試：

會提示你在這輸入東西，那麼我們如果想要一個提示的話，怎麼辦呢？

input("請輸入：1/2,按回車結束")
print("輸入正确")

結果：

6. 輸出

print()是個輸出函數（暫時先不去管什麼是函數，後面會講解的），可以把括号裡面的内容輸出到控制台顯示

當然，括号裡面是你想顯示的内容是需要加雙引号，單引号（這裡一定要注意單雙引号都是英文符号，也就是切換到英文輸入的單雙引号）

比如說你要顯示你好呀，就應該這麼寫

print ('你好呀')

這就是print ()函數輸出字元串

什麼是字元串呢？字元串就是這裡面英文單雙引号裡面的内容

就像

"Hello World"
"你好呀"
"你好，初學者"

這些都是字元串

計算機裡面的字元串就相當于我們人和人之間平時說的話，字元串是計算機與計算機之間，或者是會程式設計語言的人與計算機之間交流的東西

7. 變量

什麼是變量。顧名思義，就是可變的量。

而之前所學的字元串，就是不可變的，這個不可變的意思是，儲存在記憶體裡面的不會改變，并不是内容。

因為你可以對字元串進行各種操作，但是，其在記憶體中的位址确實不變的，你所修改，隻是将原來的copy一份，再修改。

就相當于我說了一句話，你可以拿去用，自己修改修改，但是那已經不是我所說過的話了，已經被你複制了過去。

那麼變量有什麼用呢？變量可以接收我們的資料，進行連續，重複的調用，比如我們的"Hello World！"這個字元串很長，我們如果想在很多地方都使用的話，就需要重複寫這麼多，那樣是不是很麻煩，是以就有了變量，定義一個變量去接收這個字元串，以後再使用，可以直接通過這個變量名去調用。

而這個變量名，就是我們上節所學到的辨別符。

簡單使用：

a = "Hello World"
print(a)

第二階段

1.5 資料類型

資料類型，就是我們存儲資料的東西。什麼是資料類型？就是資料的類型！沒别的意思。

那麼為什麼需要資料類型呢？

如果我們需要進行數學運算，比如說1+1,1乘1,1除以1,等等等

我們就需要用到數字，而數字有小數，整數，複數（暫時不知道沒關系，用的不多）對吧

資料類型分為基本資料類型和進階資料類型。

基本資料類型包括：整型（int），浮點型（float），複數（complex），布爾型

進階資料類型包括：字元串（str），清單（list），集合（set），字典（dict），元組（tuple）

那麼進階資料類型為什麼冠以進階之稱呢？因為他們還有别的額外的操作。

比如增删改查之類的操作。

1. 數類型

整數在python中叫做整型用int 表示，小數在python中叫做浮點型，用 float 表示

比如：

int類型 1，10，100，1000，10000

float類型 1.1 1.11 1.1111

看看這個代碼

print(100+0.555)

輸出的結果是100.555

這個100就是整型int，0.555就是浮點型float

2. 布爾型

布爾型呢，隻有兩個值

一個是True表示正确，一個是False表示錯誤

就像我告訴你 1＞2 你就會反駁我，這是錯的一樣

計算機也會思考，你看這兩行代碼

print (1>2)
print (1<2)

運作結果：

3. 字元串

字元串就類似于我們平時說的話，就是字元串在一起，叫做字元串，字元就是一個一個的

首先呢，字元串可以周遊取值，也就是可以利用我們的循環來将其中的所有元素，一個一個的展現出來，拿出來，可以進行各種操作

當然别的進階資料類型也都可以周遊，隻不過字典會有所差別

代碼展示:

str_ = "Hello World!"
for i in str_:
    print(i)

可以看到，循環将我們的字元串拆開一個一個的拿了出來，并且輸出

然後呢就是字元串格式化

什麼是格式化字元串？就是可以讓我們的代碼更加簡單

以問題了解

怎麼輸出一句話，包含變量

例子：給出一個變量a = 1 怎麼讓輸出的結果為：“a的值為：1”

第一個方法：print(“a的值為：”, a)
第二個方法：print(“a的值為：{}”.format(a))
第三個方法：print(“a的值為：%d”%a)
第四個方法：print(f"a的值為：{a}")

其實就是讓我們的字元串中可以添加變量，而第一種的方法在處理一個字元串中的多個變量時是較為麻煩的，這時候就需要用到下面三個，比較簡單，我最喜歡的是第四個方法。因為寫出來簡單

原生字元串就是隻含字元串，和格式化不同，原生字元串引号裡面的所有都是字元串，不會被機器認識成别的

比如我們的轉義符\

\t 表示我們的tab \n表示換行

那麼怎麼定義呢？隻需要在字元串前面的括号前加上r就可以了

我們來看看這個代碼，結果會是如何

print(r"你好\t世界")
print(r"你好\n世界")

可以看到，我們的轉義符并沒有什麼作用，他被原原本本的表現了出來，這就是我們的原生字元串的作用

關于轉義符，我就不多說了，像了解的可以去搜尋一下

關于字元串呢，還有更多的操作，比如什麼判斷是否是數字，判斷大小寫，轉大小寫什麼的，想了解可以去搜尋一下字元串的所有操作，本篇作為入門篇，就不多說那麼多了。

4. 清單

基礎了解

list 清單

清單是用中括号括起來的以一組資料

比如說這個 [1, 2, 3, 4, 5,] 就是一個清單

這個就是儲存了1-5 五個整型資料的一個清單

用變量接受一個清單：li = []

作為進階資料類型，清單可以增删改查。

至于周遊，就不說了和字元串是一樣的

你也不需要深刻了解，你隻需要知道，清單是個袋子，他可以幫助我們存儲更多的東西。

而我們也可以通過這個袋子去操作裡面的東西，比如上述的增删改查，不就是往袋子裡放東西，把袋子裡的東西拿出來，把袋子裡的東西拿出來換個東西，看看袋子裡的東西

增加資料：

往清單增加元素：

li.append()

舉例:

li = [1, 2, 3, 4]
li.append(5)
print(li)

結果：[1, 2, 3, 4, 5]

而作為進階資料類型，你可以往清單裡面添加一切資料類型

删除資料：

删除清單指定元素：

li.remove()

舉例：

li = [1, 2, 3, 4]
li.remove(1)
print(li)

結果為：[2, 3, 4]

就是把袋子裡的1拿了出來，至于放在哪，那肯定是扔了啊。

查找元素：

清單支援查找元素，不過是利用下标查找，python下标從0開始，當然，字元串也支援下标取值

li = [1, 2, 3, 4]
print(li[0])

結果為：1

既然說到了下表取值，那就說一下切片與步長吧

切片：可以限制取哪些下标範圍的資料

步長：幾個元素幾個元素的取

清單[下标:下表:步長] 1表示正值一個一個取，-1表示倒着取，不寫預設為1，2表示隔一個取一次

比如我們隻取1，3(不包含3，這裡指得也是下标)的元素

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

更改資料：

同樣，修改元素需要通過下标來實作

li = [1, 2, 3, 4]
li[0] = 2
print(li)

結果為： [2, 2, 3, 4]

5. 元組

元組與别的不同，他是不可變的，意思就是無法添加，無法修改，無法删除

元組使用小括号定義

tu = (1， 2， 3， 4)

元素之間和清單，集合，字典一樣，每組元素之間通過英文逗号

分隔開

可以參考清單，隻不過元組和集合一樣無法修改，但是并不是因為無序性，元組可以通過下标取值

雖然元組是不可變的，但是我們可以直接把整個元組删除

tu = (1, 2, 3, 4, 5)
del tu
print(tu)

結果為：()

6. 字典

為什麼把字典傳回在最後？因為字典是鍵值對的形式。

格式：

dic = {"key": value}

鍵必須是唯一的，但值則不必。

值可以取任何資料類型，但鍵必須是不可變的，如字元串，數字。

在字典中，通過通路key以得到value

添加元素：

我們可以定義一個空字典，也可以定義一個有元素的

我們會分别舉例

空字典：

di = {}
di["name"] = "Tom"
di["age"] = 18
print(di)

結果：{“name”: “Tom”, “age”: 18}

有元素的字典：

di = {"name": "Tom"}
di["age"] = 18
print(di)

結果為：{“name”: “Tom”, “age”: 18}

之是以能用這樣的方法，是因為我們的鍵是唯一的，是以可以通過這種方法添加元素

删除元素：

還是通過唯一的鍵來确定，然後删除

di = {"name": "Tom", "age": 18}
del di["age"]
print(di)

結果為：{“name”: “Tom”}

修改元素：

通過鍵來重新指派以修改元素，我就不多做解釋和示範了

查找元素就不能通過下标了，需要通過鍵來擷取

di = {"name": "Tom", "age": 18}
print(di["name"])

結果為：“Tom”

7. 集合

集合：set

集合具有無序性，和不可重複性

無序性：沒有順序

當然集合也可以建立一個空集合，但是不能這樣建立

s = {}

因為這樣是定義一個空字典的，我們應該這樣

set(s)

格式（長什麼樣）：

s = {1, 2, 3, 4, 5}

往集合添加元素

s.add()

and

s.update()

s = {1, 2, 3, 4, 5}
s.add(6) 
s.upadte(7)
print(s)

結果為： {1, 2, 3, 4, 5, 6, 7}

s = {1, 2, 3, 4, 5}
s.remove(1)
print(s)

結果為：{2, 3, 4, 5, 6}

全部删除：

s.clear()

沒這個功能，因為元素是無序的，沒法通過下标查找和修改

也沒事，因為你在程式中，用清單和字典比較多

8. 類型轉換

何為類型轉換？就是字面意思，資料的類型發生了改變。

類型轉換分為自動類型轉換和強制類型轉換。

我們上面的例子，100+0.555

一個是整型，一個是浮點型，他們的結果就是浮點型，這時候就發生了類型轉化。

有時候，我們會需要進行類型轉換的操作，因為有的時候某些資料類型無法滿足我們的需求，這時候，我們就需要進行類型轉換。

Python對類型轉換提供了函數（與print()函數一樣）支援強制類型轉換

函數名就是資料類型的名字，隻不過是多了一雙半角括号，将需要轉類型的資料放在括号裡，就可以了

比如：我們要将别的資料轉為字元串（基本上所有資料都可以轉為字元串）

# 類型轉換
a = 1
b = 1.1
c = 1+1j
d = "ss"
print(str(a))
print(str(b))
print(str(c))
print(str(d))

1.6 運算符

當我們使用Python的時候，也需要進行運算，是以就引入了運算符

1. 算術運算符

和數學中的基本相同

符号	作用
+	相加	-	相減
*	相乘	/	相除
%	取餘	**	乘方

舉例

print(1+1-2*5/2%5**2)

不要感覺麻煩，就按照數學中來計算

注意運算順序

答案是：

-3.0

2. 指派運算符

想想剛剛說的變量，就用到了輔助運算符

而與之對應的還有

+= *= /= ....

a += 1

就等價于

a = a+1

别的類比就可以了

3. 位運算符

位運算符，按位運算

位運算符主要針對的是二進制資料，并隻适用于int ，short ，byte，long，char五種類型。

位運算符有，&、|、<<、>>、<<<、^、~

＆如果相對應位都是1，則結果為1，否則為0
| 如果相對應位都是 0，則結果為 0，否則為 1
^ 如果相對應位值相同，則結果為0，否則為1
〜按位取反運算符翻轉操作數的每一位，即0變成1，1變成0
<< 按位左移運算符。左操作數按位左移右操作數指定的位數
>> 按位右移運算符。左操作數按位右移右操作數指定的位數
>>> 按位右移補零操作符。左操作數的值按右操作數指定的位數右移，移動得到的空位以零填充

這個計算是要有二進制來使用，我是沒怎麼用過。。是以了解的不夠深入，盡請諒解

4. 比較運算符

顧名思義，就是計算你們兩個的關系的，關系運算符有：== 、!=、>、<、<=、>= 這裡的都是英文符号，需要注意的是，關系運算符都是二目運算符，傳回的都是布爾類型的資料true/false

==和數學中的=一樣用法，比如，你看到别人這樣寫：1 = 2，你就下意識的知道，這是錯的，同理，你在Java中寫出1 == 2，計算機也是知道這是錯的，他會告訴你：false
!= 不等于，和數學中的 ≠ \neq =是一樣的，比如你看到1 ≠ \neq = 2，你會說，這是對的，同樣的，你給電腦看1!=2，電腦也會告訴你，這是對的，true。

下面的大于小于，大于等于，小于等于，都和數學中的一樣，想必上過國小的人，都不會了解不了吧——笑


==	等于 - 比較對象是否相等
!=	不等于 - 比較兩個對象是否不相等
>	大于 - 傳回x是否大于y
<	小于 - 傳回x是否小于y。所有比較運算符傳回1表示真，傳回0表示假。這分别與特殊的變量True和False等價。注意，這些變量名的大寫。
>=	大于等于 - 傳回x是否大于等于y。
<=	小于等于 - 傳回x是否小于等于y。

輸出結果為布爾型資料，即要麼是True要麼是Flase

5. 邏輯運算符

既然有運算符，那麼怎麼能沒有與或非呢，三種運算符：and、or、！

and，這個就是與，也就是和邏輯，兩個都必須滿足，舉個例子：我有女朋友和你有女朋友，那麼，皆大歡喜。隻要我沒有女朋友或者你沒有女朋友，就不說皆大歡喜，如果我倆都有，那就是皆大歡喜
or，這個是或，通用上面的例子，不過這次是隻要我們倆其中一個有女朋友就是皆大歡喜
!，這個是非，通用上面的例子，這次是我們倆都沒有女朋友，就皆大歡喜（？怎麼哪裡怪怪的）

第三階段

1.7 分支控制語句

那麼什麼叫做分支控制語句呢？相信你們都知道數學中的流程圖吧。

什麼？沒見過？沒關系，我就讓你們見識見識！

數學中的流程圖就長這個樣子

那麼我們的分支控制語句和這玩意有什麼關系呢？

其實差不多就是一個東西。

分支控制語句分為條件控制語句和循環控制語句。

從字面了解，一個是能用沒幾次的，一個是能用好多次的。

如果你還有所疑惑，那麼是肯定的，因為，你現在腦子裡面隻是有了一個概念，卻很模糊。

那麼就跟着我來帶你詳細了解了解！

條件控制語句，就是通過判斷條件來執行我們的代碼，就像數學流程圖裡的是和否。

1. 單支if語句

我們先來看看格式：

if 條件:
    代碼

這個翻譯成漢語就是

如果條件是真的：

執行代碼

結束

如果條件是假的

結束

流程就是這樣的

2. 簡單使用

那麼我們來看一個小小的例子吧

a = int(input("請輸入一個整數"))
b = int(input("請輸入一個整數"))
c = a+b
if c<10:
    print("兩數之和小于10")

來看看運作起來是什麼樣子的吧

懂了沒？是不是很簡單？沒錯，條件控制語句就是做這個的，不過這隻是最簡單的條件控制語句，下面我們來看看稍微複雜一點的。

3. 多支判斷

if 條件:
    代碼
elif 條件:
    代碼
else:
    代碼

使用：

繼續使用上面的例子

a = int(input("請輸入一個整數"))
b = int(input("請輸入一個整數"))
c = a+b
if c<10:
    print("兩數之和小于10")
elif c==10:
    print("兩數之和等于10")
else:
    print("兩數之和大于10")

好的，好的，我們的程式能做的事更多了

這次就輸入一個5一個6吧

歐克，完美的實作了我們的功能

1.8 循環控制語句

循環，循環，何為循環，就是一直進行，不會停止

那麼怎麼停止呢？那也得我們自己設定條件

循環控制語句有兩種，一種是for循環，一種是while循環。

1. for循環

一般來說，for循環使用較多

for 臨時變量 in 循環的條件:
    代碼

我們的for循環需要一個臨時變量，不需要提前定義一個變量去接收循環裡面的值

這樣對于記憶體也是一種釋放，提前定義變量的話，就是一個全局變量，會一直占用記憶體，而這個for循環的臨時變量就在循環結束後銷毀，釋放記憶體。

用白話文講就是，臨時變量隻能在循環開始-循環結束前活着，循環結束的時候就是臨時變量壽終正寝的時候，有點類似于卸磨殺驢（手動狗頭）

而且我們的for并不需要我們手動更新變量

還記不記得上一篇的變量最後面，我們使用了10個print()函數輸出了10次Hello World！

那麼我們也可以用我們的循環，用更少的代碼，實作這個效果

a = "Hello World!"
for i in range(10):
    print(a)

代碼中的i是從0開始的，而這個range()函數裡面的值，就是從i到10（不含10），是以，會循環10次

來運作看看吧

完美，達到了我們的目的

2. while循環

while 條件:
    代碼

還是上面的，輸出10次Hello World！

a = "Hello World!"
i = 0
while i<10:
    print(a)
    i+=1

while循環不僅需要定義全局變量，而且還需要我們自己手動更新變量的值（i）

如果不更新的話，i的值就不會改變，條件就會一直成立，循環就不會停止，是以，使用while的時候，一定不要忘了更新變量

3. 主動循環結束

三種語句：break return continue都可以使循環停止

不過return一般都是用到函數裡面的，都是使用break

而continue 不是用來終止循環的，具體作用看下面代碼示例

break：

看漢語也有個大概思想：打破

它的作用是打破循環，使循環碰到它後終止

break的作用是打破結構體，使程式退出目前代碼塊

下面看這個例子，我們要實作的功能是循環擷取使用者從鍵盤輸入的資料，直到輸入q來推出程式

while True:
    a = input()
    if a == "q":
        break
    else:
        print(a + "  輸入成功，輸入 'q' 退出程式")

此時我們發現，輸入q推出了，但是我們看着并不舒服，我們還可以加個提示，或者讓他再輸入一次“确認”來确認是否要推出

while True:
    a = input()
    if a == "q":
        print("确定要推退出，确定的話，請輸入确定退出來确定")
        if input() == "确定退出":
            print("已退出，程式結束")
        break
    else:
        print(a + "  輸入成功，輸入 'q' 退出程式")

這樣就完美了，我這可不是誰字數啊，我這是強迫症（認真臉）！

continue：

continue是跳出目前循環，執行下一循環，也就是說，他并沒有令循環終止的能力，他隻能令循環少循環一些次數

我們先把上面的代碼裡面的break換成continue試試

while True:
    a = input()
    if a == "q":
        print("确定要推退出，确定的話，請輸入确定退出來确定")
        if input() == "确定退出":
            print("已退出，程式結束")
        
    else:
        print(a + "  輸入成功，輸入 'q' 退出程式")

行不通

退出不了！

果然吧，那麼continue有啥用呢？

我先不說，你先看：

for i in range(10):
    if i % 5 == 0:
        continue
    else:
        print(i)

return：

return意為傳回，是用在函數中的傳回值的，至于函數是什麼，我們會在本專欄中陸續講述，你先看效果就可以了

我們計算當i的值循環到5時，讓a+b，然後計算完終止

當i為5時，不管循環是否進行完，都會強行終止

def sum(a, b):
    for i in range(10):
        if i<a:
            pass
        else:
            a+=b
            return a
print(sum(5, 2))

pass的意思就相當于什麼都不做

運作結果為：7

那麼如果我們把return的位置換一下呢？

def sum(a, b):
    for i in range(10):
        if i<a:
            pass
        else:
            a+=b
        return a
print(sum(5, 2))

我們的循環會在第一次就終止，因為第一次i的值為0，滿足判斷條件，執行return語句，結束循環

那麼如果我們再換一下呢？我們這次放在循環外面，那麼肯定是循環執行完才會結束了，會把a+=b執行一次，還是7

def sum(a, b):
    for i in range(10):
        if i<a:
            pass
        else:
            a+=b
    return a
print(sum(5, 2))

第四階段

1.9 函數式程式設計

注意不要和數學中的函數搞混了

那麼到底什麼是函數呢？

函數其實就是當我們在程式中需要大量重複的代碼塊，我們将其封裝成一個代碼塊，用一個名字來表示，而這個名字是辨別符。需要遵循辨別符的規則。

函數的優點就是避免了代碼重複率，提高開發效率。

舉個例子：我們需要讓電腦給我們表白（騷話），輸出一段情話，就比如這一段

"我愛你"
"我要給你生猴子"
"啊啊啊，好喜歡你"

按照之前所學，一個一個的print()就行了嘛

但是我需要你什麼時候都能給我來一段表白（騷話）呢？

這個時候恐怕用循環就不妥了吧，就用我們的函數了

當然，python自帶的有很多内置函數，而我們自己定義的函數叫做自定義函數。

1. 無參函數：

無參函數是最基本的函數，基本上很少用到，都是拿來練習了解函數的。

def 函數名字():
    代碼

# 定義
def Qinghua():
    print("我愛你")
    print("我要給你生猴子")
    print("啊啊啊，好喜歡你")
# 調用
Qinghua()

好像，并沒有多大作用嗎!

其實不然，看這個

# 定義
def Qinghua():
    print("我愛你")
    print("我要給你生猴子")
    print("啊啊啊，好喜歡你")
# 調用
Qinghua()
for i in range(10):
    print("經過了{}秒".format(i))
    Qinghua()

他可以在你任何想使用的時候，都可以通過調用的形式使用，而不需要你再打了。

就像變量一樣，不過函數要比普通的變量複雜一些

2. 有參函數

函數是可以傳遞參數的，而參數分為形參和實參

形參就是形式上的參數，就像一家公司有員工，清潔工，董事長等職位，但是有些職位卻空着，這些空着的職位，就相當于形參，需要有人去做這個職位，才能發揮作用，而這個能發揮職位作用的人，就叫做實參（實際參數）。

而我們定義有參函數的時候，需要定義形參來表示我們的函數，有這些東西，你想讓我們的函數去發揮作用的話，就需要給我們傳遞實際參數。

有參有參，在哪裡展現的有參呢？

在我們定義的時候，我們需要在括号裡面定義形參，用于接收參數

而在我們調用的時候，也是通過函數名後面的括号傳遞實參的

我們會定義一個有參函數來使兩個參數拼接在一起，并周遊

def PinJie(a, b):
    str_ = str(a)+str(b)
    print(str_)
    for i in str_:
        print(i)

PinJie("sasa", 4564)
#也可以這麼寫
"""
PinJie(a="sasa",b=4564)
這樣寫的好處是
就算你的位置寫錯了
參數傳遞的也還是對的
也就是說，參數傳遞的位置不固定
就像這樣
PinJie (b=4564, a='sasa')
是完全一樣的
"""

運作：

3. return的作用

之前說過，return一般是使用在函數中的，那麼他的作用是什麼呢？

先根據見名知意的規律來解讀：傳回

确實，他的作用就是傳回，傳回值

通過

return xxx

來達到傳回值得目的，這裡是傳回了xxx這個東西，至于xxx 是什麼。。衆所周知，xxx可以什麼都是！

那麼傳回的值到了哪裡呢？到了函數的調用那裡，這個

函數名字(參數)

就是傳回的值

看上面的那個函數，他顯示拼接後的結果，使用了print()函數（内置函數）

那麼我們使用return試試

def PinJie(a, b):
    str_ = str(a)+str(b)
    return str_
    for i in str_:
        print(i)

PinJie("sasa", 4564)

那麼會怎麼樣呢？

答案是，什麼都不會顯示！

為什麼呢？因為我們沒有使用print()函數（瞎說，那不是有！）

為什麼這麼說呢？因為上次講過，return用于結束一段代碼，而我們在中間return，下面的訓話也就不會被執行，就直接結束了。

怎麼顯示循環呢？把return放在函數最下面，我就不展示了，自己去試試，不然優點水字數！（狗頭保命！）

那麼上面說了傳回的值被 **函數名()**接收了，那麼他現在就是一個值了，想要讓它顯示，那麼隻能用print()了啊！

def PinJie(a, b):
    str_ = str(a)+str(b)
    return str_
    for i in str_:
        print(i)

p = PinJie("sasa", 4564)
print(p)

他就顯示了傳回值，也就是函數拼接的結果

1.10 面向對象程式設計

第五階段

1. 了解

程式設計語言有面向對象（Java，Python）和面向過程（C語言）之分，面向對象需要一些抽象的思維才行。

面向過程和面向對象有什麼差別呢？

面向過程注重親力親為，意思也就是自己去幹這件事；而面向對象更傾向于找個人給自己做事。

就拿那個老生常談的例子來說吧——洗衣服：

面向過程：

面向過程的洗衣服是：

把衣服拿到洗衣機旁邊

放進去

等待

撈出來

等下一次洗衣服，你還得重複這些操作

而這就是函數式程式設計

面向對象：

而面向對象則是：

創造一個機器人

教他如何洗衣服

讓他去幹活

等下一次需要洗衣服，就讓機器人去幹就行了

而面向對象繞不開的就是類和對象了，接着往下看吧

2. 類

類是個抽象的東西，比如說人類，動物類，植物類，類是具有某些相同特征的事物的集合

那麼如何定義一個屬于我們的類呢？有三種方法，推薦使用第三種

# 定義一個Xxx類
class Xxx:
    代碼塊
class Xxx():
    代碼塊
class Xxx(object):
    代碼

這就成了

而類需要有屬性，行為（方法）等東西

而屬性就是在類裡面的局部變量

而行為就是定義在類裡面的函數

構造方法：

而每個類都有一些預設的行為（方法），比如這個構造方法

__init__

每個類都預設有這個構造方法，而構造方法裡面的内容是會在執行個體化的時候就運作的，也就是，你執行個體化的時候，就會調用這個

__init__

構造方法。

而對象是什麼呢？

3. 對象

對象是類的執行個體化，拿人類來說，人是一個類，而我們每個人都是人這個類的執行個體化對象。

看代碼：

# 定義一個人類
class Person(object):
    pass

# 執行個體化對象
xiaoming = Person()

很明顯，

xiaoming

是

Person

這個類的執行個體化對象，換句話說，

xiaoming

是個

Person

，在這句話裡，

xiaoming

就是對象，

Person

就是類

4. 代碼實作洗衣機

代碼：

class Robot(object):

    def __init__(self):
        print("把衣服拿到洗衣機旁邊")
        print("把衣服放進洗衣機")
        print("等衣服洗好")
        print("把衣服撈出來")

        
xiaoming = Robot()

5. 封裝

可以将構造方法的參數，進行封裝，讓其在每個方法中都可以調用

想着這樣的代碼就是錯的

class Person(object):

    def __init__(self, name, age):
        pass
    
    def speak(self):
        print(f"{age}歲的{name}會說話")

Menger = Person("布小禅", 20)
name = Menger.name
age = Menger.age
person.speak()
print("姓名：{} \n年齡：{}".format(name, age))

因為speak方法裡面的name和age，計算機不知道是誰，計算機不認識他們兩個，而剛剛那兩行

self.name = name

和

self.age = age

就是相當于告訴計算機name和age是類的參數

class Person(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def speak(self):
        print(f"{age}歲的{name}會說話")

Menger = Person("布小禅", 20)
name = Menger.name
age = Menger.age
Menger.speak()
print("姓名：{} \n年齡：{}".format(name, age))

這樣就對了，輸出為：

姓名：布小禅

年齡：20

6. 繼承

Python的面向對象是可以繼承的，就像你繼承了你爸爸和你媽媽的部分特征，Python中的子類，繼承父類，說起繼承，其實你們也都見過了，就我上一篇說的三種定義類的方法的第三種：

class ClassNmae(object):
    代碼塊

那個

ClassNmae

後面的括号裡的

object

就是父類，而

ClassName

是子類

子類繼承父類的所有東西

7. 私有化

上篇說過封裝，既将我們不想讓别人看到代碼的内容，但是又需要用到的内容，通過類内部調用來實作調用。

說到這裡卻不得不提一下上篇的：

class Person(object):
    def __init__(self, name, age):
        self.xxx = name
        self.xxxx = age

這裡面self後面的名字，是可以自己随意命名的，上一篇和後面一樣隻是為了好記憶罷了

隻要你記得住，便是颠倒也是無事

屬性私有化：

何為屬性私有？

舉個例子便是：你的私房錢，你的手機電腦裡面的小秘密等等這些不想被别人知道的東西

那麼上面就說了，封裝的目的是什麼，不就是隐藏那些不想讓别人知道的代碼嗎

是以有個屬性私有化，可以讓你的類屬性變成私有的，這可和上篇的封裝不一樣，封裝了還能通過執行個體化對象調用；這個屬性一旦變成私有的，你在類外部是無法調用的

那我想用了怎麼辦？在類内部調用嘛！

好，叭叭了這麼多，想必你們也得煩了，上代碼

使用格式：

class Xxx(object):
    age = 20
    _name = "Xxx"

這種前面帶着一個下劃線的就是私有屬性，無法通過類外部執行個體化對象的方法進行調用

具體應用：

"""
定義一個挺人類
含有姓名，年齡，體重，身高
将體重設定私有化
通過類内部調用使得能夠在類外部看到你的體重
"""
class Person(object):
    _weight = 70
    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height
 
    def weightPrint(self):
        print("我的體重是：", self._weight)

person = Person("布小禅", 20, 180)
person.weightPrint()

這個體重就無法通過

person.weight

、

person._weight

這樣調用，因為這個屬性是私有的

方法私有化：

我覺得這個倒是不必多說，隻需要在定義的類方法名字前面也加一個

就可以了

class Person(object):
    def _love(self):
        print("我暗戀Xxx")

這個方法也是無法通過執行個體化對象來調用的，調用需要這樣：

class Person(object):
    def _love(self):
        print("我暗戀Xxx")
    
    def speakLove(self):
        self._love()

二、 numpy快速入門

第六階段

numpy是什麼？

擴充庫numpy是Python支援科學計算的重要擴充庫，是資料分析和科學計算領域如scipy、pandas、sklearn 等衆多擴充庫中的必備擴充庫之一，提供了強大的N維數組及其相關運算、複雜的廣播函數、C/C++和Fortran代碼內建工具以及線性代數、傅裡葉變換和随機數生成等功能。本章童點介紹數組與矩陣及其相關運算，為學習和了解後面章節中的資料分析、機器學習打下良好的基礎。

簡單來說就是你用來為人工智能領域打基礎的東西，私話說得好，基礎不牢，地動山搖嘛~

是以這個地方可要好好學習哦~~

2.1 簡單使用

在numpy中使用的不是自帶的資料類型

list

，而是numpy中的

ndarray

那為什麼使用

ndarray

而不是使用

list

呢？

因為ndarray是由c/c++寫出來的，占用記憶體更小，使用速度更快

建立一個ndarray的方法有很多，這裡說下使用array方法轉化的

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author： Smly
# @datetime： 2021/9/26 22:22 
# @Version： 1.0

import numpy as np

li = [1, 2, 3]
tp = (1, 2, 3)

nday1 = np.array(li)
nday2 = np.array(tp)

print("*****類型*****")
print(type(nday1))
print(type(nday2))

print("*****數組*****")
print(nday1)
print(nday2)

輸出結果：

*****類型*****
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>
*****數組*****
[1 2 3]
[1 2 3]

2.2 數組使用

如果元素相同的話，可以進行加減乘除

在元素個數相同的情況下，可以進行數組間的加減

在元素個數相同的情況下，可以進行數組間的乘除

對某個數進行的乘除，可以自動進行到所有元素

看例子了解：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author： Smly
# @datetime： 2021/9/26 22:22 
# @Version： 1.0

import numpy as np
    
li = [1, 2, 3]  # 清單
tp = (1, 2, 3)  # 元組

nday1 = np.array(li)    # 内置方法将清單轉為ndarray
nday2 = np.array(tp)    # 内置方法将元組轉為ndarray
nday3 = np.array(range(5)) # 使用range内置函數方法生成ndarray連續數組
nday4 = np.array(range(5, 10))  # 使用range内置函數方法生成ndarray連續數組

print("*****類型*****")
print(type(nday1))
print(type(nday2))
print(type(nday3))
print(type(nday4))

print("*****數組*****")
print(nday1)
print(nday2)
print(nday3)
print(nday4)

print("*****數組加減*****")
print(nday2 + nday1)
print(nday2 - nday1)
print(nday4 - nday3)
print(nday3 + nday4)
# 在元素個數相同的情況下，可以進行數組間的加減

print("*****數組乘除*****")
print(nday2 * nday1)
print(nday2 // nday1)
print(nday4 * nday3)
print(nday4 // nday3)
# 在元素個數相同的情況下，可以進行數組間的乘除

print(nday1 * 3)
print(nday2 // 2)
print(nday3 * 2)
print(nday4 // 2)
# 對某個數進行的乘除，可以自動進行到所有元素

*****類型*****
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>
*****數組*****
[1 2 3]
[1 2 3]
[0 1 2 3 4]
[5 6 7 8 9]
*****數組加減*****
[2 4 6]
[0 0 0]
[5 5 5 5 5]
[ 5  7  9 11 13]
*****數組乘除*****
[1 4 9]
[1 1 1]
[ 0  6 14 24 36]
[0 0 0 0 0]
[3 6 9]
[0 1 1]
[0 2 4 6 8]
[2 3 3 4 4]

2.2 建立數組

剛剛的

array()

方法是将清單和元組等疊代對象轉為ndarray數組

接下來要說的是自動建立數組

1. 使用empty建立空數組

裡面會有初始值，但是數組初始為None

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author： Smly
# @datetime： 2021/9/28 12:29 
# @Version： 1.0
import numpy as np

em1 = np.empty(5)       # 建立一個長度為5的空數組
em2 = np.empty((2, 2))  # 建立一個2*2的空二維數組


print("一維數組，長度為5", em1)
print("二維數組，長度為2*2", em2)

[9.96754604e-312 9.96754614e-312 2.60799828e-310 9.34609789e-307
 0.00000000e+000]
[[6.95299778e-310 9.96747617e-312]
 [0.00000000e+000 6.95299776e-310]]

2. 使用arange函數建立

arange是numpy自帶的的一個方法，作用與range這個Python内置函數相差無幾，都是生成數組

先導入numpy包

import numpy as np

然後建立數組

print("*****ararge建立數組*****")

aran_arr1 = np.arange(5)
aran_arr2 = np.arange(5, 10)

print("*****類型*****")
print(type(aran_arr1))
print(type(aran_arr2))

print("*****數組*****")
print(aran_arr1)
print(aran_arr2)

3. 使用zeros函數生成數組

zeros函數是numpy自帶的方法，作用是生成指定數量的全0一維數組，全0二維數組等

看下面的例子：

生成一個具有三個元素的一維數組和一個具有五個元素的一維數組：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author： Smly
# @datetime： 2021/9/27 21:31 
# @Version： 1.0

import numpy as np

zero_arr = np.zeros(3)

zrro_arr2 = np.zeros(5)

print(zero_arr)
print(zrro_arr2)

[0. 0. 0.]
[0. 0. 0. 0. 0.]

當然這隻是一位數組，你還可以生成二維數組，也就是矩陣

使用如下代碼可以生成一個三行三列的矩陣

zero_arr3 = np.zeros((3, 3))

輸出看看：

print(zero-arr3)

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

4. ones函數生成數組

使用ones函數生成全1函數，方法同zeros

import numpy as np

ones_arr1 = np.ones(3)

[1. 1. 1.]

生成一個三行三列的矩陣

import numpy as np

ones_arr2 = np.ones((3, 3))

[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

5. diag函數生成對角矩陣

什麼是對角矩陣?你應該聽說過對角線，矩陣就是生成在對角線上的矩陣

函數參數是一個元祖

看代碼和運作結果能夠了解的更深刻

import numpy as np

diag_arr = np.diag((4, 3, 2, 1))

将diag_arr的輸出的結果為：

[[4 0 0 0]
 [0 3 0 0]
 [0 0 2 0]
 [0 0 0 1]]

看，對角線是不是你函數的參數，這下了解了吧

6. N維數組

N維數組就是多元數組，可以了解為數組裡面還是數組，裡面還是數組，可以參照這個形式

[[[1 2]
  [3 4]]
 [[5 6]
  [7 8]]]

這個概念确實有點抽象，有點難了解。這就是一個三維數組，是通過三維清單使用array方法轉換成ndarray的

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author： Smly
# @datetime： 2021/9/27 13:29 
# @Version： 1.0
import numpy as np

li = [
    [[1, 2], [3, 4]],
    [[5, 6], [7, 8]]
]

te1 = np.array(li)

print(te1)

當然，二維數組也算是N維數組

2.3 矩陣

數組是數組，矩陣是矩陣。

數組是一種資料結構，可以存儲多種資料，可以有多元

矩陣是數學中的一個概念，隻能存放數字，并且隻能是二維的形式

生成矩陣的方法就和生成N維數組的方法是一樣的

先使用清單建立二維清單，然後再使用numpy的方法轉成矩陣，當然也有好幾中生成矩陣的方法

import numpy as np


li = [[1, 2, 3, 4], [5, 6, 7, 8]]

j1 = np.matrix(li)

print(j1)
print(type(j1))
print(j1.dtype)

輸出該矩陣：

輸出矩陣： [[1 2 3 4]
 [5 6 7 8]]
矩陣在Python的類型： <class 'numpy.matrix'>
在numpy中的類型： int32

矩陣可以進行各種數學運算，在numpy子女宮都得到了很好的支援，這裡就不細說了

2.4 廣播

何為廣播，廣播就是能将你的東西發送到各個區域，一般在計算機中是将資訊發送到區域網路絡中的每個計算機中。

而在numpy中也有廣播，隻不過他是将元素自動補到數組，矩陣上，就像你在上面看到的，一個數組乘除一個元素，數組中的所有元素都會乘這個數

import numpy as np

li1 = [1, 2, 3, 4]
print(np.array(li1)*10)

[10 20 30 40]

這個就是廣播，就是将數字10播到li轉成的數組中，能夠讓數組所有元素都乘10。

而不同次元的數組也可以這樣

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author： Smly
# @datetime： 2021/9/27 13:40 
# @Version： 1.0

import numpy as np

li = [[1, 2, 3, 4], [5, 6, 7, 8], [2, 4, 6, 8]]

gb1 = np.array(li)

li1 = [1, 2, 3, 4]
gb2 = np.array(li1)

print(gb1*gb2)

将一維數組的每個元素挨個廣播到二維數組，前提是：

二維數組中的一維數組的個數與一維數組的個數是相同的

[[ 1  4  9 16]
 [ 5 12 21 32]
 [ 2  8 18 32]]

2.5 通路數組元素

numpy自帶了一個

insert

函數，可以往數組中插入元素

看執行個體：

li = [[1, 2, 3, 4], [5, 6, 7, 8], [2, 4, 6, 8]]
gb1 = np.array(li)
np.insert(gb1, 1, [1, 2, 3, 4])

[1 1 2 3 4 2 3 4 5 6 7 8 2 4 6 8]

還有一個自帶的add函數，可以進行數組的相加減

數組嘛，可以使用下标來擷取數組元素

import numpy as np

li1 = [1, 2, 3, 4]
gb2 = np.array(li1)
print(gb2[1])

輸出結果為：

當然，它是一個數組，你理所應當的也可以使用循環語句來周遊數組

三、matplotlib快速入門

第七階段

matplotlib是一個将資料可視化的子產品。

什麼你連什麼是資料可視化都不知道是什麼？

高中學的函數（可别跟Python中的函數搞混了）知道吧，把函數的圖像畫出來，就是資料可視化了

matplotlib是一個資料可視化的标準庫，與numpy子產品，pandas子產品都很适用。

它能夠繪制多種形式的圖像，包括：

折線圖 —— plot ()

散點圖 —— scatter ()

餅狀圖 —— pie ()

柱狀圖 —— bar ()

雷達圖 —— polar ()

三維圖 —— mplot3d

3.1 基礎理論

作圖，我們需要有資料，坐标軸标簽，标題，坐标軸刻度等屬性。

資料可以使用numpy生成一維清單，在數學中也叫向量。
坐标軸标簽由xlabel()，ylabel()方法（函數）設定
标題由title()方法（函數）設定
坐标軸刻度可以使用xticks ()，yticks ()方法（函數）設定

3.2 繪制折線圖

導入子產品：

import numpy as np
# numpy用于生成資料
import matplotlib.pyplot as plt 
# 使用matplotlib中的pyplot子產品進行繪圖

生成x軸，y軸資料：

x = np.arange(0,6,0.1) # x軸資料
y = np.sin(x) # y軸資料

繪制圖案：

plt.plot(x,y,label="sin")
# 以x為x軸資料，y為y軸資料，繪制折線圖，并設定線上的标簽為sin

設定标題等屬性：

plt.xlabel("number")  # x軸标簽
plt.ylabel("sin")  # y軸标簽
plt.title("sin fun")   # 圖像标題

使圖像顯示出來：

plt.show()  # 顯示圖像

圖像顯示效果：

3.3 繪制散點圖

将代碼繪制圖像的

plt.plot()

修改成

plt.scatter()

全部代碼：

import numpy as np
# numpy用于生成資料
import matplotlib.pyplot as plt

# 使用matplotlib中的pyplot子產品進行繪圖

x = np.arange(0, 6, 0.1)  # x軸資料
y = np.sin(x)  # y軸資料
plt.scatter(x, y, label="sin")
# 以x為x軸資料，y為y軸資料，繪制折線圖，并設定線上的标簽為sin
plt.xlabel("number")  # x軸标簽
plt.ylabel("sin")  # y軸标簽
plt.title("sin fun")  # 圖像标題
plt.show()  # 顯示圖像

3.4 繪制餅狀圖

繪制一個程式設計語言的餅狀圖，資料随便寫的，不要當真，還有一點，預設不支援中文

先導入子產品

import numpy as np
# numpy用于生成資料
import matplotlib.pyplot as plt
# 使用matplotlib中的pyplot子產品進行繪圖

建立資料：

student_souce = np.array([25, 35, 45, 60])

plt.pie(student_souce, labels=["C", "Python", "Java", "C+++"], autopct='%.2f%%')
# 設定student_souce為資料，每個資料的名字為labels的參數，并格式化輸出各個所占百分比

設定标題與顯示圖像：

plt.title("Test")  # 圖像标題
plt.show()  # 顯示圖像

完整代碼：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author： Smly
# @datetime： 2021/9/28 12:56 
# @Version： 1.0
import numpy as np
# numpy用于生成資料
import matplotlib.pyplot as plt
# 使用matplotlib中的pyplot子產品進行繪圖

student_souce = np.array([25, 35, 45, 60])
plt.pie(student_souce, labels=["C", "Python", "Java", "C+++"], autopct='%.2f%%')
# 設定student_souce為資料，每個資料的名字為labels的參數，并格式化輸出各個所占百分比
plt.title("Test")  # 圖像标題
plt.show()  # 顯示圖像

3.5 繪制柱狀圖

先生成資料，然後再繪制圖像

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author： Smly
# @datetime： 2021/9/28 13:02 
# @Version： 1.0

import numpy as np
# numpy用于生成資料
import matplotlib.pyplot as plt
# 使用matplotlib中的pyplot子產品進行繪圖

x = np.arange(0, 6)  # x軸資料
plt.bar(x, x)
# 以x為x軸資料，x為柱體高度，繪制柱狀圖
plt.xlabel("number")  # x軸标簽
plt.ylabel("sin")  # y軸标簽
plt.title("sin fun")  # 圖像标題
plt.show()  # 顯示圖像

3.6 圖添加網格線

使用

gird()

方法（函數）來設定網格線

函數參數：

b：可選，預設為 None，可以設定布爾值，true 為顯示網格線，false 為不顯示，如果設定 **kwargs 參數，則值為 true。

which：可選，可選值有 ‘major’、‘minor’ 和 ‘both’，預設為 ‘major’，表示應用更改的網格線。

axis：可選，設定顯示哪個方向的網格線，可以是取 ‘both’（預設），‘x’ 或 ‘y’，分别表示兩個方向，x 軸方向或 y 軸方向。

**kwargs：可選，設定網格樣式，可以是 color=‘r’, linestyle=’-’ 和 linewidth=2，分别表示網格線的顔色，樣式和寬度。

具體效果就自己往上面的代碼裡面的

plt.show()

上面添加一個

plt.gird()

四、數學基礎

人工智能需要不少的數學基礎：線性代數，機率學，高數等

人工智能入門四件套，你學人工智能避不開的知識點人工智能入門四件套