物聯網技術部培訓——python基本語法及numpy

 
 
 

python - 冉冉升起的高級語言

終於來到激動人心的時刻辣！我們要開始進行對python的學習！
 
python應該是很多小會員的第二門程序設計語言。在開始今天的講學之前，我們先來解決小會員們心中可能存在的疑惑：python是什麼？爲什麼要學python？python和C/C++有什麼區別？
 
對於python，大家應該並不陌生。很多人應該都在大大小小的各種三流網站上看到過“7天學會python“的扯淡廣告，雖然這種捷徑是不存在的，但至少說明了python的易學性和火熱性。（據說，python的發明者因爲不喜歡有大括號的編程，就”隨手“編出了python）
 
python是當下非常常用且熱門的編程語言之一，這張圖是HelloGitHub最新的數據，我們可以看到python的使用率正在不斷地飆升，已經逐漸超過了老牌強勢語言C++，現在排列第三，前兩位是Java和C

python語言在數據處理領域確實非常優秀，加上本身語言的簡單性，使得python非常適合進行海量數據處理和進行人工智能方面的研究。
 
在詳細介紹這門語言之前，我們還要明確一點：python是一門十分高級的語言。何爲高級語言？事實上，我們現階段學習的所有語言都是屬於高級語言的範疇，但相較於C等，python還要更加高級一點。高級就體現在，程序員利用python去編程和實現程序十分的輕便和簡單；同樣，簡單也給python帶來了一個弊病：那就是其運行速度非常慢。具體有多慢呢？C語言1秒就能實現的程序，Java要2秒，而python需要整整十秒。換言之，人看得懂的東西，機器就不容易看懂。
而且，python的簡單性僅僅體現在語法實現的簡單性，高級的python語言並不是簡單的！
 
那麼，相較於我們已經學會的程序設計語言，python和他有什麼區別呢？或者說，我們既然已經能夠利用計算機編程了，爲什麼還要再去學習另外的 程序語言呢？
 
首先，python與C，C++等等其他所有語言之間並沒有特別本質上的區別，都是通過程序設計，使得計算機在代碼的控制下執行一定的指令。絕大多數C，C++能做的（這裏的例外就比如操作系統只能用C來寫，Android只能用Java來寫等等），python一樣可以做，而且可能會更加簡便的實現。
 
當下python的使用非常的廣泛，的確可以說是學了就不用擔心沒有地方用。很多著名網站比如YouTube就是用python寫的，很多遊戲後臺也可以用python來寫。
 
說了這麼多，總之是希望能給大家一個python的輪廓，讓大家覺得學習這門語言有點意思！這門語言之後還會陪伴很多學習機器學習的同學走很遠，這一節課我們首先給大家簡單講解python語法基礎。

 
 
 

python入門篇：基本語法

第一個程序：helloworld！

helloworld幾乎是我們學習所有語言開始的第一個程序。python如何去實現輸出helloworld呢？
 
首先我們打開IDLE。IDLE的主界面是一個簡便的變量查看器，適用於我們簡單的嘗試幾個函數，以及測試寫好的程序的內容，我們一般不用它來編程。點擊左上角的“file”，再點“new file”，我們就建立了一個python文件。按下CTRL+s，保存到指定的路徑：沒錯，簡單的語言就連編譯器都如此簡單（當然不是，我們之後會用到更高級的編譯器…）
 
！！要注意，IDLE不是很聰明，寫的時候一定要注意中英文輸入法的切換，不然一不小心就調出幫助文檔了…！！
！！關於字體的修改：點擊“Options”，“Configure Idle”就可以調整了！我用的是comic Sans MS！！

 

下面就是見證奇蹟的時刻！我們輸入

print("helloworld")

不用printf！不用%s！不用分號！不用頭文件！不用return 0 ！不用大括號！就是這麼任性！
輸入好之後，我們按下F5，就可以運行。在我們的shell裏，已經打印出了我們的內容。
 

python語法 - 基本數據類型

 
既然已經嘗試了輸出，我們當然還希望操作python的數據。下面我們就開始基本數據類型的學習。

1.1 變量的定義

變量的定義不需要聲明，使用的時候直接丟到程序裏面就可以。比如那我們剛剛的程序，我們在helloworld的輸出下面加一行

a = 4

然後我們對他進行輸出（ 不需要%d，不需要分號都可以不需要）

print(a)

就可以看到，程序正確的輸出了4。
此外，在輸出界面，也就是我們的shell裏面，我們直接輸入a，shell會幫我們打印出a的內容。
 
python語言變量不需要提前聲明，也就是說，python語言中變量的類型是沒有規定的。上一秒a還是整形，下一秒可以直接用字符串來賦給他，a就變成了一個字符串類型。

print("helloworld")
a = 4
print(a)
a = "helloworld"
print(a)

輸出爲：
helloworld
4
helloworld

 
但是，這樣方便的python同樣有要求：那就是使用變量之前必須對該變量進行賦值。沒有賦值直接使用是不被允許的。但是沒有賦值，卻用變量直接承接表達式是被允許的。

a = 4
b = 3
c = a + b
# 沒有對c進行初始化的情況下直接進行c = a + b 是允許的
# 井字號是python的單行註釋方法

此外，在今後使用一些庫或者函數的時候，如果你要是用的變量是該庫的特殊變量，則在使用之前也必須進行初始化。比如在tensorflow中，當a，b是張量變量時，不可以直接使用c = a + b

1.2 連續賦值

python可以接受同時多個變量的賦值：

x, y, z = 1, 2, 3
a = b = 123
# 都是python語言允許的定義

1.3 python的基本輸入和輸出

 
python的輸出我們已經見識過了：print即可。
print函數可謂來者不拒，不論要輸出整形浮點型雙精度字符串列表集合等等等等，只要是變量，統統丟到函數當中即可。python的字符串表達也非常簡單，但凡是用引號括起來的內容都是字符串，都可以隨意輸出。
 
python中，爲了方便輸入輸出的內容帶引號，字符串的定義有四種方式：

a = "i love python!"
a = 'really!'
a = '''learning python is good for my hair!''' 
a = """人生苦短，我學python"""

三種定義方式都是允許的。其中，三個連續單引號的定義方式一般用於當作多行註釋

'''
   那是因爲三個連續引號可以裝入回車，
   而其本身是沒有任何意義的變量，程序不會做處理
'''

 
python的輸入同樣非常簡單，只需要input即可。不論輸入符號，數字，字母，都是允許的。

x = input()

但是要特別注意：這裏input的所有內容都是字符串類型。

print(type(x)) # 輸出x的類型。結果爲：<class 'str'>

如果我們想進行“輸入x，計算x的平方”的程序應該怎麼做呢？

這裏提供兩種方法：

# 1.對x進行強制轉換 ： 
x = input()
x = int(x) * int(x)
print(x)

# 2.對輸入的內容進行去引號處理
x = input()
x = eval(x) * eval(x)
print(x)
# 其中，去引號函數在把引號去掉賦給變量之前，還會自動的根據括號的內容對變量的類型進行分配
print(type(eval(x)))
# 如果輸入 5，則會輸出 int；如果輸入 5.5， 則會輸出  float；如果輸入[1， 2， 3]，就會輸出 list，等等
# 然而eval並不能拆字符串

兩種方法都可以使用，但是我們平時使用eval函數更多一點

1.3.1 輸入輸出語句格式拓展

1. python允許在input括號內通過加字符串的格式來對輸入內容進行描述

x = input("please input a integer:")
print(x)

2. python的print輸出函數自動計入回車。取消回車的方式是：

print("I don't want an enter",end='')
# 實際上，end=做的事情是將等號後面的字符串加到每一次輸出的末尾，默認爲回車。

3. 此下，給出了其他可用的輸出格式，大家課後自己學習

print("{} is a sb,{} is niubi".format("mcx","zyc"))  # 這樣輸出時，大括號的順序和format順序一一對應
print("{1} is a sb,{0} is niubi".format("zyc","mcx"))  # 這樣輸出時，大括號順序按照填寫內容進行對應

#1.填充對齊寬度
print("{0:~^20}".format(bstring))
#print("{0:           =        ^      20}".format("bstring"))      ^居中，>右對齊，<左對齊
   #      |           |         |      |       |      |
   #     引導符     填充物      居中   寬度    格式化  目標字符串
print("{0:*>20}".format("bit"))
print("{:20}".format("aa"))  # 將aa放於左邊，自動補齊剩餘空格
# 2.逗號(千分符，用於財務記賬)   點精度(浮點數小數精度或字符串最大輸出長度，{:.2f})
#   類型
print("{:,.2f}".format(12345.6789))    # 1 .整數部分放置千分符分割；2.精度補爲兩位

print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425))  # 用二進制，Unicode編碼，十進制，八進制，大小寫十六進制表示括號內的數值

print("{0:e},{0:E},{0:f},{0:%}".format(3.14))  # 用小寫大寫的科學記數法表示，用通常的浮點數表示，用百分數表示

 

python語法 - 分支語句，循環語句

 

2.1 分支語句

在進行python程序的編寫時，應該格外注意格式的書寫。因爲python是沒有大括號的語言，所以能夠判斷python語段範圍的只有縮進。python的分支表達式爲：

if <語句段>:
	# 必須縮進，否則會報錯。而且只能縮進一次
	<語句段>

我們來小小的實踐一下：

a = eval(input())
if a % 2 == 0 :
	print('ok!')
elif a % 2 == 1:
	print('no!')
# 或者也可以直接else：

 

2.2 循環語句

與分支語句相同，循環語句中的縮進同樣非常重要。python的循環表達式爲：

for <循環判斷>:
	# 必須縮進，否則會報錯。而且只能縮進一次
	<語句段>

其中，循環判斷的格式爲：

	i in <範圍>

這個範圍可以是一個列表：

list = [1, 2, 3]
for i in list:
	print(i)
	# 則i會遍歷整個列表

也可以是一個整數：

for i in range(45):
	print(i,end='  ')
	# 則i會分別被賦值爲0， 1， ...， 44

總之，只要是能夠進行循環遍歷操作的，都用 i in … 來修飾即可
 
 

python語法 - 組合數據類型

 
python的組合數據類型大家完全可以類比C語言中的各種數組。python中，沒有嚴格的數組概念，而是用其他組合數據類型代替。

3.1 集合

python的集合概念與數學概念上的集合非常相像，就是一羣有相同意義的數據的集合,在python中常用於數據去重。python的語法表達中，集合的表達形式爲：

b = 2
a = {1, 'python', b}
# 集合來者不拒，大多數數據類型都可以直接包含到集合當中

同數學的集合相似，集合中不能有相同的元素.如果出現相同的元素，集合會直接將相同的其他項刪除，只保留一項。而且，當集合中包含變量時，集合會直接判斷變量的內容是否與集合內容重複。
 
另外，集合在用戶進行輸入之後會直接自動的對其中所有元素進行排序，但是排序的方法，在不同的操作系統，甚至不同的時刻都有可能不是完全相同。集合的順序本身就是開發者爲了方便查找遍歷和使用的，我們程序員不要利用這個順序。但是基本保持：相同數據類型會被排布在一起，相同數據類型之間會根據大小（或者字符串長短也有可能）來從小到大排序
 
以下給出集合的操作，同學們課後掌握

#-------------------------集合操作符-------------------------#
c = {1,2,3,4,5} ; d = {4,5,6,7,8}
#1.求並集: |
print('1.1 ',c|d)
#2.求集合的差(取前不取後): -
print('1.2 ',c-d)   #輸出包含在c中但不在d中的元素
#3.求交集: &
print('1.3 ',c&d)
#4.求兩集合中不同的元素: ^
print('1.4 ',c^d)
#5.比較兩個元素的包含關係
print('1.5 ',c>=d)
e = {1,2,3}
print('1.6 ',c>=e)


#-------------------------增強操作符-------------------------#
c |= d  #更新集合c，包括c，d中的所有元素
print('2.1 ',c)
c -= d  #同上，講c，d運算過後的結果賦值給c
print('2.2 ',c)


#------------------------集合處理方法------------------------#
c = {1,2,3,4,5}
#1.如果x不在集合中，將x增加到c
c.add(6)
print('3.1 ',c)

c = {1,2,3,4,5}
#2.如果x在集合中，移除x;如果x不在集合中，不報錯
c.discard(5)
print('3.2 ',c)

c = {1,2,3,4,5}
#3.如果x在集合中，移除x;如果x不在集合中，報錯
c.remove(5)
print('3.3 ',c)

c = {1,2,3,4,5}
#4.移除所有元素
c.clear()
print('3.4 ',c)

c = {1,2,3,4,5}
#5.爲用戶隨即返回一個集合中的元素並且在幾何中刪除這個元素。如果集合爲空則報錯
f = c.pop()
print('3.5 ',f,c)

c = {1,2,3,4,5}
#6.返回一個集合的副本
d = c.copy()
print('3.6 ',d)

c = {1,2,3,4,5}
#7.返回集合元素個數
f = len(c)
print('3.7 ',f)

c = {1,2,3,4,5}
#8.判斷x是否在集合中
a = 5 in c
print('3.8 ',a)

c = {1,2,3,4,5}
#9.判斷x是否不在集合中
a = 5 not in c
print('3.9 ',a)

c = (1,2,3,4,5,5,5)
#10.將其他類型轉化爲集合類型
c = set(c)
print('3.10 ',c)

3.2 列表

列表的概念非常接近於我們C/C++中的數組。它的內容可以重複，有固定的順序。列表定義只需要中括號即可，用逗號分隔

a = [1, 2, 'hello!']
# 或者可以用下面的方法快速定義
b = [i for i in range(10)]

對於列表a，我們有可以對其進行遍歷，也可以訪問列表的下標

for i in a:
	print(i)
for i in range(len(a)):
	print(a[i])

這裏給出list的操作。希望大家不要嘗試全部背誦，可以把這篇博客當作百科書，隨用隨查

len(a)  # 返回列表元素個數

a.append('dove')  # append用於單個元素的加入

a.extend(['i','love','dove']) # extend用於整個列表的加入

max(a)  min(a)  # max(a),min(a)返回列表的最大值最小值。在使用時，需要元素可以比較

a.insert(0,'hello')  # insert的兩個參數：要插入的順序，要插入的內容

a.index(123)  # 從第一個元素遍歷，輸出第一次出現123這個元素的位置
a.index(123,1,3)  # 從第一個到第三個元素中，第一次出現123這個元素的位置
a.count(123)  # 序列中出現123的次數

a.sort()  # 排序
a.reverse() # 逆序輸出

a.clear()  # 清空列表

del a[2]  # 指定刪除a下標爲2的元素

3.3 元組

元組就是不能夠修改的list，一般很少使用，下面給出方法

#將一些值用逗號分隔
a=1,2,3
print(a)

#常用做法
a=(1,2,3)

#調用函數tuple:它將一個序列作爲參數，並將其轉換爲元組
a=tuple([1,2,3])
b=tuple("abc")
print(a,b,sep='\n')

#特殊情況：表示只包含一個值的元組
a=42,
b=(42,)
print(a,b,sep='\n')

3.4 字典

字典類型是很特殊的一種類型。它的元素是一對數據，也可以叫一組關係
每一個元素表示爲 <鍵>:<值>
元素之間用逗號隔開。可以認爲，列表是用數字作索引標準，字典用我們自己定義的元素作索引。
字典類型就可以類比我們現實中的字典，我們在知道鍵的情況下，可以通過目錄的索引找到值；python語法中同樣可以這樣理解

zidian = {'outside':'green','inside':'blue'}
print(zidian['outside'])

同樣，在C/C++中對數組的操作，在python中對list的操作同樣可以類比，只不過在表達上有些許區別而已。以下給出字典的操作

#字典類型操作函數和方法
dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('0.最初定義的字典變量',dic)
del  dic[1]
print('1.刪除第一項',dic)

print('2.判斷鍵“1”是否在字典中(已在上一步刪除)',1 in dic)

dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('3.返回所有鍵的信息',dic.keys())
print('4.返回所有值的信息',dic.values())
print('5.返回所有鍵值對的信息',dic.items())
dic = dict(((1,'mcx'),(2,'zyc'),(3,'ch'),(4,'ylx'),(5,'ljw'),(6,'wb'),(7,'dsp')))
print('5+.利用dict創建一個字典',dic)

print('6.若存在該鍵,則返回對應的值，否則返回<default>',dic.get(6,'wb'))
print('7.若存在該鍵,則去除並返回對應的值，否則返回<default>',dic.pop(6,'wb'))
print('8.隨機取出一個鍵值對並以元組形式返回',dic.popitem())
print('9.刪除所有鍵值對',dic.clear())

dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('10.返回字典元素個數',len(dic))

字典類型在進行對應數據處理時非常重要，但對於前期學習的同學們，能夠熟練掌握list就已經足夠，因爲list就是C/C++數組的超級加強版

 
 
 

python語法 - 字符串

考慮到字符串的重要地位，以及python中字符串的特殊形式，我們字符串單獨拿出來講。

4.1 字符串的定義

字符串的定義我們在最上面就已經解釋過，直接利用單引號/雙引號/三連單引號，雙引號括起來，就已經做好了一個字符串。python的字符串非常“寬鬆”，即，基於python的保護機制，在使用字符串時完全不用考慮越界，超範圍等等C語言中很麻煩的問題

a = 'I love esta'
b = ' I love'
print(a + b) # 如果想進行字符串連接的操作，直接 + 就可以

4.2 字符串的各種操作

在C語言中，字符串其實是利用數組去模擬的一種便捷數組表達。而python中，字符串更像一個變量。因此對字符串的操作十分自由。

a = 'I love esta'
b = 'I love'
print(a + b) # 上文已經講過，加法代表兩個字符串連接
c = '人類的本質是復讀機'
print(c*5) # 直接乘法代表字符串重複多少次
d = '人類'
print(d in c) # 利用in判斷d是否是後者的子串

a.upper()  # 將字符串的所有字母改爲大寫
a.lower()  # 將字符串的所有字母改爲小寫 
a.split(' ') # 將字符串根據括號內的內容分隔開，返回保存在列表中
a.count('e')
a.replace('esta','Esta')

除了字符串整體的操作，python還支持字符串的切片。

a = 'I love esta'
print(a[0])  # 返回第一個字符
print(a[-1]) # 返回最後一個字符
print(a[3:6])# 獲取字符串切片，左閉右開
print(a[1:9:2])  #指從第一位開始，到第九位之前，每隔兩個取一個
print(a[::-1])  #字符串的逆序

print(fstring.center(20,"="))  #將目標字符串放在寬度爲20的居中位，其餘用=填充
print("= python= ".strip(" =np"))  #刪掉字符串兩側的“ ”，“=”，“n”，“p”，直到左右不出現這四個字符爲止
print("|".join(estring))  #將目標字符串夾在join括號內字符串的出最後一位的字符後邊

 
 

python語法 - 函數

python的函數定義同樣十分簡單。python定義函數時，不需要考慮參量的類型，返回值類型等等問題。直接使用def就可以定義函數；同樣，函數必須縮進。

def hello():     #參數括號中可以寫入你的參數
    print('hello!')
        
def hello2(a):   #這裏我們想要調入一個列表，但我們不用事先說明他是個列表
    print(a)
    
hello2([1,2,3]) # 當然也是沒有任何問題的
hello2("hi,I'm a string!") #字符串也沒有問題
# 雖然python很好用，但是要注意，你傳入的內容應該符合函數的操作！

此外，python還接受這樣的操作：

def hello(name,greeting='Hello',punctuation='!'):
    print('{},{}{}'.format(greeting,name,punctuation))
hello('python','Hi','^_^')
hello('python',punctuation='^_^')
hello('python',greeting='Glad to see you')


#星號收集餘下的位置參數並存放在一個元組中
def print_params1(title,*params):
    print(title,end=' ')
    print(params)
print_params1('Params:',1,2,3)   

#收集關鍵字參數需要**,得到的爲一個字典
def print_params2(**params):
    print(params)
print_params2(x=1,y=2,z=3)


#1、拆分序列*
def add(x,y):
    return x+y
params=1,2
print(add(*params))

def mutiply(x,y,z):
    return x+y*z
params1=[2,3]
print(mutiply(1,*params1))   #星號部分必須位於參數列表末尾

#2、拆分字典**
def hello(greeting="Hello",name='World'):
    print(greeting+',',name)
dic={'name':'MMS','greeting':'Glad to see you'}
hello(**dic)

 
 

python語法 - 常用庫

如同C/C++允許加入include，python同樣可以使用庫。不如說，python的靈魂就是這些各種各樣的庫，他們極大的豐富了python的功能。後人不用再造輪子，可以方便的實現很多功能。
這節課不會詳細講解每一個庫的作用，大家只需要用的時候來找一找即可。

5.1 庫的調用

#導入一個模塊
import somemodule(模塊)
somemodule.somefunction()   #調用該模塊的某個函數

#從模塊中導入（一些）函數
from somemodule import somefunction[,anotherfunction,...]
somefunction()    

 #給模塊指定別名
import somemodule as m
m.somefunction()

#導入模塊中的一切函數
from somemodule import *
somefunction()

#導入一個函數並指定別名
from somemodule import somefuntion as f
f()

一般，我們用前三種表達方式更多一些
 

5.2 常用庫：time庫

要使用time庫，我們首先應該將time庫導入到我們的程序中

import time

關於time庫，我們首先給出常用方法

#1.0獲得當前時間戳，是從1970年某一個時刻到今天的秒數
print(time.time())
#1.1易於閱讀的時間：(被保存爲字符串形式)
print(time.ctime())
#1.2易於計算機閱讀的時間(保存爲struct結構)
print(time.gmtime())

# 此外，python還提供了時間的標準化輸出。
t = time.gmtime()
strtime = time.strftime("%Y-%m-%d %H:%M:%S",t)

# time庫通過time.perf_counter來獲得當前時間戳，保存爲浮點型
start = time.perf_counter()
# 用這個函數，我們可以計算程序執行的過程中的時間
time.sleep(2)
end = time.perf_counter()
print(end - start)

下面，我們利用已經學過的time庫來看看python運行速度和C的區別

5.3 常用庫：jieba庫

jieba庫是python中非常強的中文分詞庫。但jieba並不是python自帶的庫，我們要通過下載才能使用。
首先按下win+R，在對話框中輸入cmd。
然後將這一段拷貝到命令行中，回車安裝（確保聯網）
pip install jieba -i https://pypi.douban.com/simple/

以下給出jieba庫的用法：

#jieba庫的使用
import jieba
s = '弛弛學長喜歡python'
t = "弛弛學長先吃蘋果然後喝可樂"
print(jieba.lcut(s))    #精確模式：返回一個列表的分詞結果
print(jieba.lcut(t,cut_all=True))    #全模式：返回所有有關聯的分詞結果
print(jieba.lcut_for_search(s))    #搜索模式：更爲智能的分詞結果
jieba.add_word('弛弛學長')  #向搜索模式中添加新詞
print(jieba.lcut(s))    #精確模式：返回一個列表的分詞結果

 
 
課後作業：

我們將給出一段臺本，請根據jieba庫進行分詞，統計文本的詞的頻率，並將出現次數最多的10個詞打印出來。

numpy簡介

NumPy(Numerical Python) 是 Python 語言的一個擴展程序庫，支持大量的維度數組與矩陣運算，此外也針對數組運算提供大量的數學函數庫。
 
NumPy 是一個運行速度非常快的數學庫，主要用於數組計算，包含：
1、一個強大的N維數組對象 ndarray
2、廣播功能函數
3、線性代數、傅里葉變換、隨機數生成等功能

numpy 安裝

使用pip安裝：
在cmd中輸入

pip install numpy

安裝驗證：打開idle，輸入以下代碼，運行不報錯即說明安裝完成。可以通過第二行代碼查看numpy版本，版本號達到1.12以上就不存在兼容性的問題

import numpy
numpy.__version__

由於之後我們會經常使用numpy，爲了使用方便，通常在導入numpy庫的時候，給numpy一個別名np，之後即可直接使用np代表numpy這個庫

import numpy as np
np.__version__

爲什麼使用numpy中的array

python list 的特點

L = [i for i in range(10)]
L

結果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

L[5] #訪問其中元素
L[5] = 100 #爲元素賦值
L[5] = "machine learning"
L

結果：[0, 1, 2, 3, 4, ‘Machine Learning’, 6, 7, 8, 9]
在list類型中，每個數據的類型可以不一樣，既有好處，增強了程序的靈活性，同時也有不可避免的問題，在list類型的底層，有自動檢測類型並轉換的功能，這也就會耗費大量時間。

array類型

import array
arr = array.array('i', [i for i in range(10)])
arr

結果：array(‘i’, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

arr[5] #True
arr[5]=100 #True
arr[5] = 'machine learning'  #False

報錯：TypeError: an integer is required (got type str)
剛剛定義的array類型中，聲明過類型只能是整型，所以將字符串給其中元素賦值將會報錯
array類型沒有list那樣智能，它不會在底層自動檢測數據類型並轉換，但是它的效率很高很快。
 
但是在array中，數據只是以單一的類型存放，但是並沒有將其視爲向量或者矩陣，自身也沒有相應的函數用以處理向量和矩陣。
因此，最終出現了numpy.array進行向量和矩陣的處理，在array的基礎上，添加了許多處理向量和矩陣的方法。

numpy.array

nparr = np.array([i for i in range(10)])
nparr

結果：array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

nparr[5] #True
nparr[5] = 100 #True
nparr[5] = 'machine learning' #False
nparr.dtype #查看你的數據類型

numpy.array的創建方法

整體創建

np.zeros(10)
np.zeros(10).dtype  #默認float
np.zeros(10, dtype=int) #創建整型
np.zeros((3, 5))  #創建3行5列的全部爲0的二維數組（矩陣）
np.zeros(shape=(3, 5), dtype=int) #另一種方式
np.ones(10)
np.ones((3, 5))
np.full((3, 5), 666) 
np.full((3, 5), 666.0) 
np.full(shape=(3, 5), fill_value=666.0)
np.full(fill_value=12, shape=10)

arange

[i for i in range(0, 20, 2)] #創建列表
np.arange(0, 20 ,2) #創建數組
[i for i in range(0, 1, 0.2)] #False
np.arange(0, 1, 0.2)
np.arange(0, 10)
np.arange(10)

linspace

np.linspace(0, 20, 10)
np.linspace(0, 20 ,11)

random

在機器學習算法中，我們常常需要定義一些隨機的向量或者矩陣，但是如果每次創建的都是隨機的，每次隨機的值都不一樣，那會造成每次算法的結果都不一樣，爲我們調試算法帶來麻煩
所有計算機中的隨機數其實都是僞隨機數，其實都是內部的隨機數生成算法來完成的，運行這個算法都是會有一個隨機種子seed，這個seed也就決定了隨機數的值

np.random.randint(0, 10)
np.random.randint(0, 10, 10)
np.random.randint(0, 1, 10)
np.random.randint(4, 8, size=10)
np.random.randint(4, 8, size=(3, 5))
np.random.seed(666)
np.random.random()
np.random.random(10)
np.random.random((3, 5))
np.random.normal()
np.random.normal(10, 100)
np.random.normal(0, 1, (3, 5))

numpy.array 的基本操作

import numpy as np
x = np.arange(10)
X = np.arange(15).reshape(3, 5)

查看基本屬性

x.ndim
X.nidm

x.shape
X,shape

x.size
X.size

數據訪問

x
x[0]
x[-1]

X
X[0][0]
X[(2, 2)]
X[2, 2]

x[0:5]
x[:5]
x[5:]
x[::2]
x[::-1]

X
X[:2. :3]
X[:2][:3]
X[::-1, ::-1]
X[0]
X[0, :]
X[0, :].ndim
X[:, 0]
X[:, 0].ndim


subX = X[:2, :3]
subX
subX[0, 0] = 100
subX
X
X[0, 0] = 0
subX

subX = X[:2, :3].copy()
subX
subX[0, 0] = 100
X

reshape

x.rehsape(2, 5)
x
A = x.reshape(2, 5)
A
B = x.reshape(1, 10)
B.ndim
B.shape
x.shape
x.reshape(10, -1)
x.reshape(-1, 10)
x.reshape(2, -1)
x.reshape(3, -1)

合併操作

x = np.array([1, 2, 3])
y = np.array([3, 2, 1])
z = np.array([666, 666, 666])
np.concatenate([x, y])
np.concatenate([x, y, z])
A = np.array([[1, 2, 3],
			  [4, 5, 6]])
np.concatenate([A, A])
np.concatenate([A, A], axis=1)
np.concatenate([A, z]) #False
np.concatenate([A, z.reshape(1, -1)])

np.vstack([A, z])

B = np.full((2, 2), 100)
np.hstack([A, B])
np.hstack([A, z]) #False

分割操作

劃分特徵和標籤

x = np.arange(10)
x1, x2, x3 = np.split(x, [3, 7])
x1, x2, x3
x1, x2 = np.split(x, [5])
x1, x2

A = np.arange(16).reshape((4, 4))
A
A1, A2 = np.split(A, [2])
A1, A2

A1, A2 = np.split(A, [2], axis=1)
A1, A2

data = np.arange(16).reshape((4, 4))
data
X, y = np.hsplit(data, [-1])
X, y

運算操作

問題：給定一個向量，讓向量中的每一個數乘以2
a = (0, 1, 2)
a*2 = (0, 2, 4)

L1 = [0， 1， 2]
2 * L1
L2 = np.array([0, 1, 2])
2 * L2

Universal Functions

X = np.arange(1, 16).reshape((3,5))
X
X + 1
X - 1
X / 2
X // 2
X * 2
X ** 2
X % 2
1 / X
np.abs(X)
np.sin(X)
np.cos(X)
np.tan(X)
np.power(3, X)
np.log(X)
np.log2(X)

矩陣運算

A = np.arange(4).reshape(2, 2)
A
B = np.full((2, 2), 10)
B
C = np.full((3, 3), 666)

A + B
A - B
A * B
A / B

A.dot(B)
A.T

A + C #False
A.dot(C)#False

向量和矩陣的運算

v = np.array([1, 2])
A
v + A
np.vstack([v] * A.shape[0])
np.vstack([v] * A.shape[0]) + A

np.tile(v, (2, 1))
np.tile(v, (2, 1)) + A

v * A
v.dot(A)
A.dot(v)