基礎Python(二) | 神經網絡與深度學習 | Tensorflow 2.0 系列 (3) | AI入門

Python內置數據結構

序列數據結構

在序列數據結構中，成員都是跟順序排列的(sequence)，而每個元素的位置是指標(index)，通過指標，
可以存取或訪問序列中的特定成員，而Python序列的數據類型有字串、串列、元組，而串列和元組可以存放不同類型的數據
串列用中括號 [ ] 表示 e.g. [1,2,3]，而元組使用小括號 ( ) 表示 e.g. (1,2,3)

指標 (index)

通過指標(index)，我們可以訪問序列中指定的位置的元素

#字符串指標
str_py = "Python"
print(str_py[0]) #Output: P
print(str_py[-1]) #Output: n

#串列指標
lst_1 = [1,2,3]
print(lst_1[1]) #Output: 2
print(lst_1[-2]) #Output: 2

切片 (slice)

通過切片 (slice)，我們可以一次過從序列中獲取多個元素：

#字符串切片
str_py = "Python"
print(str_py[1:5]) # Output: ytho
print(str_py[1:]) # Output: ython

1
2
3

#串列切片
list1 = [1,2,3]
print(list1[2:]) # Output: [3]

#混合串列切片
lst_student = [160612,"一心",18,[92,76,85]]
print(lst_student[1:]) # Output: ["一心",18,[92,76,85]]
print(lst_student[:3]) # Output: [160612,"一心",18]

獲取序列的長度

#利用len(串列名稱)來獲取序列的長度
str_py = "Python"
print(len(str_py)) # Output: 6
print(len("hello")) # Output: 5
lst_1 = [1,2,3]
print(len(str_py)) # Output: 3
lst_2 = [[1,2,3],[4,5,6]]
print(len(lst_2)) # Output: 2
lst_mix = [160612,"一心",18,[92,76,85]]
print(len(lst_mix)) # Output: 4
tup_1 = (1,2,3)
print(len(tup_1)) # Output: 3

更新串列

向串列中加入元素：append()、insert()

#在串列的最後位置追加元素
lst_1 = [1,2,3]
lst_1.append(4)
print(lst_1) # Output: [1,2,3,4]

#在串列中加入元素
lst_1 = [1,2,3]
lst_1.insert(1,5)
print(lst_1) # Output: [1,5,2,4]

合並串列：extend()、"+"運算符

lst_1 = [1,2,3]
lst_2 = [4]
lst_1.extend(lst_2)
print(lst_1) # Output: [1,2,3,4]

lst_1 = [1,2,3]
lst_2 = [4]
lst_3 = lst_1 + lst_2
print(lst_3) # Output: [1,2,3,4]

刪除串列中的元素：del語句

1
2
3

lst_1 = [1,2,3，4]
del lst_1[1] # 刪除指標為1的元素
print(lst_1) # Output: [1,3,4]

對串列中的元素進行排序：sort()、reverse()

lst_1 = [2,3,1,4]
lst_1.sort() # 將lst_1中元素以小至大進行排序
print(lst_1) # Output: [1,2,3,4]
lst_1.reverse() # 將lst_1中元素以大至小進行排序
print(lst_1) # Output：[4,3,2,1]

遍歷串列中的元素

1
2
3

lst_1 = [2,3,1,4]
for i in lst_1:
	print(i, end=" ") # Output: 1, 2, 3, 4

字典與集合

字典 (dictionary)

每個字典元素都是一個鍵/值對 (key/value)
鍵：關鍵字
值：關鍵字對應的取值

創建字典

1 2	dic_score = {"中文":;80, "英文":85, "數學":78, "電腦":90} dic_employ = {"name":{"first":"Mary","last":"Smith"},"age":26}

打印字典、訪問字典元素

dic_employ = {"name":"Mary","age":26}
print(dic_employ) # Output: {"name":"Mary","age":26}
print(dic_employ["name"]) # Output: Mary
print(len(dic_employ)) # Output: 2
print('age' in dic_student) # 判斷字典是否存在元素，Output: True

遍歷字典元素的鍵key，當然還有值(value和鍵值對(item)作為返回部分

1
2
3

dic_student = {"name":"John","age":20,"gender":"male","score":98}
for key in dic_student.keys():
	print(key,end=" ") # Output: gender name score age

更新字典

加入、修改指定元素的取值

dic_student = {"name":"John","age":20,"gender":"male"}
dic_student["score"] = 90
print(dic_student) # Output: {"age":20,"gender":"male","name":"John","score":90}
dic_student["score"] = 98
print(dic_student) # Output: {"age":20,"gender":"male","name":"John","score":98}

合並字典

dic_student1 = {"age":20,"gender":"male"}
dic_stuednt2 = {"name":"John","score":90}
dic_student1.update(dic_stuednt2)
print(dic_student1) # Output: {"age":20,"gender":"male","name":"John","score":90}

刪除字典；pop(指定元素的關鍵字)，清空字典中的所有元素clear()

刪除字典中的指定元素

dic_student = {"name":"John","age":20,"gender":"male"}
dic_student.pop("age")
print(dic_student) # Output: {gender":"male","name":"John"}
dic_student.clear()
print(dic_student) # Output: {}

集合 (set)

集合(set)由一組無序；排列的元素組成
- 可變集合(set)：創建後可加入、修改及刪除其中的元素
- 不可變集合(fronzenset)：創建後就不能再改變了

創建集合

Python會自動將集合中重複的元素移除

1
2
3

set1 = {1,2,3,4,5,4,5}
print(set1) # Output: {1,2,3,4,5}
print(len(set1)) # Output: 5

set2 = set("Python")
print(set2) # Output: {'h', 'P', 't', 'o', 'n', 'y'}
set3 = frozenset("Python")
print(set3) # Output: frozenset({'h', 'P', 't', 'o', 'n', 'y'})

集合中的元素是無序的，因此不能通過指標來訪問
打印集合、獲取集合長度、遍歷集合的方法，與其他內置數據類型相似

函數

函數(function)簡介

實現某種特定功能的程式碼塊
程式簡潔，可重覆調用、封裝性好、便於共享
系統函數和用戶自訂函數

Python內置函數：

數學運算函數
輸入輸出函數
類型轉換函數
邏輯判斷函數
序列操作函數
對象操作函數

數學運算函數

>>>abs(-1) # 絕對值
1
>>>pow(2,3) # 次方
8
>>>round(3.1415,2) # 參數指定的小數位數，四捨五入
3.14
divmod(5,3) # 計算a除以b的商和餘數，返回一個元組
(1,2)

常用的Python內置函數

用家自訂函數

# 返回一個值
def add(a,b)
	c = a + b
	return c

# 返回多個值
def add_mul(a,b)
	add = a + b
	mul = a * b
	return add,mul

1
2
3

# 無返回值
def say_hello(your_name):
	print("Hello,%s!" %your_name)

調用(call)函數

def add_mul(a,b): # 定義函數
	add = a + b
	mul = a * b
	return add, mul

x,y = add_mul(1,2) # 調用函數
print("add:",x,"; mul:",y) # Output: add: 3; mul: 2

def say_hello(): # 定義無參數的函數
	print("Hello!")

say_hello() # 調用函數，Output: Hello!

模組、套裝和庫

模組(Module)

模塊是一個python文件(.py)，擁有多個功能相近的函數或類
便於代碼重用，提高編程效率，提高了代碼的可維護性
避免函數名和變量名沖突

套件(Package)

為了避免模塊名沖突，Python引入按目錄來組織模塊的方法
一個套件對應一個資料夾，將功能相近的模塊(Python文件)，放在同一個資料夾下
在作為套件的資料夾下有一個init.py文件
子套件:子目錄中也有init.py文件

庫(Liberay):具有相關功能的模組或套件的集合

套件Package的結構：
這個套件對應資料夾package_a，其中有一個init文件，和兩個模組，還有一個子套件;子套件中也有2個模組

package_a
├─ __init__.py
├─ module_a1.py
├─ module_a2/py
└─ subpack_ab
    ├─ __init__.py
    ├─ module_ab_1.py
    └─ module_ab_2.py

匯入模組、套件和庫

匯入整個套件
1
2
import numpy as np
np.random.random()
匯入套件中指定的模組與子套件
1
2
from numpy import *
random.random()

在匯入語句的作用域(scope)：

在程式頂部匯入模組，作用域是全局的(global)
在函數的內部匯入語句，作用域就是局部的(local)

建議匯入的順序

Python標準庫/模組
Python第三方庫/模組
自訂模組

使用模組/套件/庫中的函數和變量

>>>import math     #匯入math模組
>>>math.pow(2,3)
8.0

>>>from math import sqrt as s     #從math模組中匯入sqrt函數並重新命名為s
>>>s(16)
4.0

模組

# 創建自訂模組: mymodule.py
def print_str(str):  # 打印字符串
	print(str)

def sum(a,b):   #求和
	return a + b

# 調用call自訂模組
>>>import mymodule as mm # 匯入mymodule模組
>>>mm.print_str("Python") # 調用打印函數
Python
>>>mm.sum(2,3) # 調用求和函數
5

Python 標準庫中的模組

sys模組：提供有關Python執行環境的變量和函數，例如：

>>>import sys
>>>sys.platform # 獲得當前作業系統
win32

>>>sys.path # 獲得指定模組的路徑
['',
'F:\\python3.7\\Lib\\idlelib',
			...
			...
]

常用的模組有platform、math、random、decimal、fractions、time、datetime、calender模組等

OOP物件導向編程

OOP(object oriented programming)，又稱物件導向程式設計，是一種程式設計思想和開發方式，較傳統的process-oriented programming更符合真實世界的環境
例如在真實世界中，要形容一個人，我們可以從他的靜態特徵、動態行為作為描述
靜態特徵包括：姓名、年齡、性別，動態特徵包括：說話、吃飯、打招呼
在OOP中，我們將靜態特徵稱為屬性attribute，動態特徵稱為方法method，利用物件(object)將屬性和方法封裝在一起

如果將物件導向的描述轉換成程式碼：

在上面例子中，我們見到Peter和Mary有著同樣的屬性和方法，因為他們都是人類
在OOP中，我們將具有相同屬性和方法的物件集合，名為類別(class)，如人類(person)，而Peter和Mary都是類別中的實例
進一步，我們其實可以將Person劃分為更多的子類別，例如teacher, student, worker
子類別繼承了父類別person的全部屬性和方法，也具備自己獨特的屬性和方法，例如teacher有專業的職稱等

新增物件

class Person():
	money = 10000
	def say_hello(self):
		print("Hello!")

peter = Person()

print(peter.money)
peter.say_hello()

執行結果：

1 2	10000 Hello!

動態新增物件屬性

class Person():
	monry = 10000
	def say_hello(self):
		print("Hello!")

peter = Person()

peter.major = "computer science"
print("peter's major is ", peter.major) # Output: peter's major is computer science

更詳細例子：

class Person(): # 類別屬性，所有的實例共同享有
	money = 10000
	def say_hello(self):
		print("Hello!")

peter = Person()
mary = Person()

print(Person.money) # Output: 10000
print(peter.money) # Output: 10000
print(mary.money) # Output: 10000

Person.money = 9000 # 修改類別屬性，所有實例都會受影響

print(Person.money) # Output: 9000
print(peter.money) # Output: 9000
print(mary.money) # Output: 9000

peter.money = 5000 # peter自己新增了的實例屬性money，他已經不是原來的類別屬性money了

print(Person.money) # Output: 9000
print(peter.money) # Output: 5000
print(mary.money) # Output: 9000

文件

打開文件

1	文件對象 = open(文件名稱,'訪問模式')

絕對路徑：從drive開始的路徑
C:\Program Files\Anaconda3\lib\site-packages\ipykernel_main_.py

相對路徑：從當前目錄下的路徑
例如..\python\file.txt ->完整路徑會根據你的當前路徑：D\jupyter\example\python\file.txt

1
2
3

# 獲得當前路徑
import os
print(os.getcwd())

1
2
3

#打開文件
f = open("c:/myfile") # 成功打開文件後會返回一個文件物件，否則會返回錯誤
f1 = open("mypython.txt",'w') # 訪問模式'w'，如果在目錄中找不到這個文件，就會自動新增一個

關閉文件

1	文件物件.close() 或 f.close() # 在寫入文件後，應該立即關閉文件，避免意外事故(當機)造成的錯誤

讀取文件

在資源管理器重打開mypython.txt文本，寫入”Python3.0”

#讀取文件
>>>f = open("mypython.txt")
>>>f.read()
'Python3.0'

更多操作：

1 2	文件物件.readline() # 每次只讀取文件中的一行文件物件.readline(字節數) # 根據指定字節數讀取文件的內容

寫入內容

1 2	f = open("myfile.txt",'w') f.write("Hello, World")

完整實例：打開文件、讀取文件、寫入文件、關閉文件

>>>f = open("myfile.txt",'w')
>>>f.write("Hello!")
>>>f.close()

>>>f = open("myfile.txt")
>>>f.read()
'Hello!'
>>>f.close()

>>>f = open("myfile.txt",'a')
>>>f.write("World!")
6
>>>f.close()

>>>f = open("myfile.txt")
>>>f.read()
'Hello!World!'
>>>f.close()

>>>f = open("myfile.txt",'w')
>>>f.write("Python3.0")
9
>>>f.close()

>>>f = open("myfile.txt")
>>>f.read()
Python3.0

例外處理(異常處理)

try: # 在程式執行時，解釋器會嘗試執行try語句中的所有程式碼
	程式碼
except 例外1 as 錯誤原因:	 # 如果語句被執行後沒有錯誤/例外發生，就會忽略except後的程式碼
	出現錯誤1後的處理程式碼
except 例外2 as 錯誤原因: # 當某個except所指定的例子發生後，會忽略try子句中剩餘的語句，直接跳轉到對應例外的處理程式碼處執行
	出現錯誤2後的處理程式碼

try:
	aList = [0,1,2]
	print(aList[3])
	print("try語句繼續執行中...")
except IndexError as e:
	print(e)
	print("例外已處理")

print("程式繼續執行中...")

執行結果：

1
2
3

list index out of range
例外已處理
程式繼續執行中...

try:
	aList = [0,1,2]
	print(aList[2])
	print("try語句繼續執行中...")
except IndexError as e:
	print(e)
	print("例外已處理")

print("程式繼續執行中...")

執行結果：

1 2	2 try語句繼續執行中...

Python中常見的例外/錯誤

IOError: 輸入/輸出錯誤(無法打開文件)
ImportError: 無法導入模組或套件(路徑問題或名稱錯誤)
IndentationError: 縮進錯誤(程式碼沒有正確對齊)
NameError: 沒有聲明、或初始化物件
KeyError: 試圖訪問字典里不存在的鍵
AttributeError: 試圖訪問一個物件沒有的屬性
TypeError : 類型不吻合
ValueError: 傳入一個調用者不期望的值，即使值的類型是正確的

例外類別的繼承關係

Exception是所有非系統退出例外類別的基類，在編程時，可以通過處理它來避免程式遇到錯誤而退出，但有可能會隱藏了某些錯誤。

try:
	語句
except exception as e:
	例外處理語句

finally子句

finally: 無論例外是否發生，都會執行，常用於關閉資源等清理工作

try:
	print("try語句開始")
	f = open(‘c:/test.txt’)
	print(f.read())
	print("try語句結束")
except IOError as e:
	print("except子句")
	print(e)
finally:
	print("finally子句")
	f.close()

執行結果：

try語句開始
except子句
[Erro 2] No such file or directory: 'c:/test.txt'
finally子句

上下文管理器

with語句

我們可以使用with語句代替try-finally語句，程式碼將更加簡潔清晰
對於需要對資源進行存取的任務，無論在程式碼執行過程中，是否發生例外/異常，都會執行清理工作，釋放資源
例外處理：

try:
	f = open("mypython.txt")
	print(f.read())
except IOError as e:
	print(e)
finally:
	f.close()

反觀，with語句的程式碼則簡單得多：

1 2	with open("mypython.txt") as f: print(f.read())

在with語句完成時，會自動關閉文件，如果再次讀取這個文件，就會出現文件關閉的錯誤提示信息

實現上下文管理器

上下文管理器是Python中的一種協議，它保證了每次程式碼執行的一致性
一旦進入上下文管理器，就一定會按照規定的步驟退出
如果合理地設計了退出上下文管理器的步驟，就能夠很好的處理例外/異常
上下文管理器被最多用到的場景是資源清理操作
實現上下文管理器，只要在類別定義時，實現enter()方法和exit()方法即可

例子：模擬實現一個文件類別

class File()
	
	def __init__(self, filename, mode:
		self.filename = filename
		self.mode = mode

	def __enter__(self):
		print("執行__enter__()方法")
		self.f = open(self.filename, self.mode)
		return self.f

	def __exit__(self, *args):
		print("執行__exit__方法")
		self.f.close(ß)

以閱讀方式打開當前目錄下的mypython文件，並輸出文件內容

1 2	with File("mypython.txt", 'r') as f: print(f.read())

執行結果：

1
2
3

執行__enter__()方法
Python3.0
執行__exit__方法

在執行with語句塊之前，首先執行了enter()方法，然後再執行with語句塊，最後執行exit()方法
采用這種方式讀取文件時，即使執行過程中出現了異常，exit()方法也會被執行，完成關閉文件的操作