關注AI小白入門喲
跟着部落客的腳步，每天進步一點點
Python 是由Guido Van Rossum在 90 年代早期設計，現在是最常用的程式設計語言之一。特别是人工智能的火熱，再加之它的文法簡潔且優美，實乃初學者入門AI必備的程式設計語言。
Python基本文法
辨別符
第一個字元必須是英文字母或下劃線 _ 。辨別符的其他的部分由字母、數字和下劃線組成。辨別符對大小寫敏感。
保留字
保留字即關鍵字，不能用作任何辨別符名稱。 keyword 子產品可以輸出目前版本的所有關鍵字：
import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'] 注釋
單行注釋采用#，注釋是給人看的，可以是任意内容，解釋器會忽略掉注釋。
多行注釋采用'''或"""。
# print("我是注釋，不會執行")
print("正常執行代碼")
'''
這是多行注釋，用三個單引号
這是多行注釋，用三個單引号
'''
print("Hello, World!")
"""
這是多行注釋，用三個雙引号
這是多行注釋，用三個雙引号
"""
print("Hello, World!") 行與縮進
Python 使用縮進來表示代碼塊而不是大括号 {}。 縮進的空格數是可變的，但是同一個代碼塊的語句必須是相同的縮進空格數。建議四個空格數。
注意Tab和四格空格混用會報錯，這個錯誤還不容易被察覺。
輸入輸出
通常是一條語句一行，如果語句很長，我們可以使用反斜杠(\)來實作多行語句。在 [], {}, 或 () 中的多行語句，則不需要反斜杠。
sentence1 = "I love " + \
"python"
sentence2 = ["I", "love",
"python"] 基本資料類型
計算機程式要處理不同的資料，需要定義不同的資料類型。Python 中的變量不需要聲明，每個變量在使用前都必須指派，變量指派以後該變量才會被建立。
Python中變量就是變量，沒有類型，所說的"類型"是變量所指的記憶體中對象的類型。等号（=）用來給變量指派。等号（=）運算符左邊是一個變量名,等号（=）運算符右邊是存儲在變量中的值。
數字類型(Number)
數字類型是不可變資料。Python3 支援 int(整數)、float(浮點數)、bool(布爾)、complex(複數)，數值類型的指派和計算是很直覺的。
# int(整數)
a = 3
# float(浮點數)
b = 3.5
#bool(布爾)
c = True
#complex(複數)
d = 4+3j
print(a, b, c, d)
#内置的 type() 函數可以用來查詢變量所指的對象類型
print(type(a), type(b), type(c), type(d))
#還可以用 isinstance 來判斷
#isinstance 和 type 的差別在于：type()不會認為子類是一種父類類型，isinstance()會認為子類是一種父類類型
print(isinstance(a, int))
print(isinstance(a, float)) 關于數值運算，可以同時為多個變量指派，如a, b = 1, 2。一個變量可以通過指派指向不同類型的對象。
除法包含兩個運算符：/ 傳回一個浮點數，// 傳回一個整數。混合計算時，Python會把整型轉換成為浮點數。
# 加
print("Add operation: 5 + 4 = ",5 + 4)
# 減
print("Sub operation: 5 - 4 = ",5 - 4)
# 乘
print("Mul operation: 5 * 4 = ",5 * 4)
# 除，得到一個浮點數
print("Div operation: 5 / 4 = ",5 / 4)
# 除，得到一個整數
print("Div operation: 5 // 4 = ",5 // 4)
# 取餘
print("Mod operation: 5 % 4 = ",5 % 4)
# 乘方
print("Pow operation: 5 ** 4 = ",5 ** 4) 字元串類型(String)
Python 沒有單獨的字元類型，一個字元就是長度為1的字元串。字元串用單引号 ' 或雙引号 " 括起來。
s1 = "I love python"
s2 = 'I love python'
print(s1)
print(s2)
#索引值以 0 為開始值，-1 為從末尾的開始位置
print("s1首字母字元：", s1[0])
print("s1末尾字母字元：", s1[-1])
print("輸出從第三個開始到第五個的字元:", s1[2:5])
#加号 + 是字元串的連接配接符
#星号 * 表示複制目前字元串，緊跟的數字為複制的次數
str = "I love python "
print("連接配接字元串:", str + "!!!")
print("輸出字元串兩次:", str * 2)
#反斜杠 \ 轉義特殊字元
#若不想讓反斜杠發生轉義，可以在字元串前面添加一個 r
print('I\nlove\npython')
print("反斜杠轉義失效:",r'I\nlove\npython') 清單類型(List)
清單類型是一種有序的集合。清單中元素的類型可以不相同，它支援數字，字元串甚至可以包含清單（所謂嵌套）。清單是寫在方括号 [] 之間、用逗号分隔開的元素清單。
list_a = [1, 2, 3, 4, 5, 6]
list_b = [7, 8, 9]
print(list_a)
print(list_b)
#清單可以被索引和截取，清單被截取後傳回一個包含所需元素的新清單
print ("輸出完整清單: ", list_a)
print ("輸出清單第一個元素:", list_a[0])
print ("從第二個開始輸出到第三個元素:", list_a[1:3])
print ("輸出從第三個元素開始的所有元素:", list_a[2:])
print ("連接配接兩次清單:", list_a * 2)
print ("連接配接清單:", list_a + list_b)
#清單中的元素是可以改變的
list_a = [1, 2, 3, 4, 5, 6]
print("變化前：", list_a)
list_a[0] = 0
list_a[2:5] = [7, 8, 9]
print("變化後：", list_a)
#append()方法：在清單末尾添加新的對象
list_a = [1, 2, 3, 4, 5, 6]
print("添加前：", list_a)
list_a.append(7)
list_a.append(8)
print("添加後：", list_a)
#del語句：删除清單元素
list_a = [1, 2, 3, 4, 5, 6]
print("删除前：", list_a)
del list_a[0]
print("删除後：", list_a)
#len()方法：計算清單長度
list_a = [1, 2, 3, 4, 5, 6]
print("清單長度：", len(list_a))
#max()方法：傳回清單元素最大值。min()方法：傳回清單元素最小值
list_a = [1, 2, 3, 4, 5, 6]
print("清單最小值：", min(list_a))
print("清單最大值：", max(list_a))
#list()方法：将字元串轉換為清單
str = '123456'
print("轉換後：", list(str))
#count()方法：統計某個元素在清單中出現的次數
list_a = [1, 1, 2, 3, 4, 5, 6]
print("1在list_a中出現的次數：", list_a.count(1))
#index()方法：從清單中找出某個值第一次出現的索引位置
list_a = [1, 2, 3, 4, 5, 6]
print("3第一次出現的位置：", list_a.index(3))
#insert()方法：将對象插入清單指定位置
list_a = [1, 2, 3, 4, 5, 6]
print("插入前：", list_a)
list_a.insert(0 ,7)
print("插入後：", list_a)
#pop()方法：移除清單中的一個元素（預設最後一個元素），并且傳回該元素的值
list_a = [1, 2, 3, 4, 5, 6]
print("預設移除最後一個元素：", list_a.pop())
print("指定移除第一個元素：", list_a.pop(0))
#reverse()方法：翻轉清單中元素
list_a = [1, 2, 3, 4, 5, 6]
print("翻轉前：", list_a)
list_a.reverse()
print("翻轉後：", list_a)
#sort()方法：該方法沒有傳回值，但是對原清單進行排序
list_a = [1, 3, 2, 5, 4, 6]
print("排序前：", list_a)
list_a.sort()
print("升序排序：", list_a)
list_a.sort(reverse = True)
print("降序排序：", list_a) 元組類型(Tuple)
元組類型是不可變類型，元組使用小括号()。
tup1 = (1, 2, 3, 4, 5 )
# 元組中隻包含一個元素時，需要在元素後面添加逗号,否則括号會被當作運算符使用
tup2 = (50,)
tup3 = (50)
print(type(tup2))
print(type(tup3))
#通路元組:使用下标索引來通路元組中的值
tup1 = (1, 2, 3, 4, 5 )
print ("tup1[0]: ", tup1[0])
print ("tup1[1:3]: ", tup1[1:3])
#修改元組:元組中的元素值是不允許修改的，但可以對元組進行連接配接組合
tup1 = (1, 2)
tup2 = ('a', 'b')
# 建立一個新的元組
tup3 = tup1 + tup2
print(tup3)
#删除元組：元素值是不允許删除，但可以使用del語句來删除整個元組
tup1 = (1, 2, 3, 4, 5 )
print(tup1)
del tup1
print("删除後的元組 tup1: ")
print(tup1)
#元組運算符：如 + 号和 * 号
tup1 = (1, 2)
tup2 = ('a', 'b')
print("連接配接：", tup1 + tup2)
print("複制3次：", tup1 * 3)
#len()：計算元組元素個數
tup1 = (1, 2)
print("元組長度：", len(tup1))
#max()方法: 傳回元組中元素最大值。min()方法: 傳回元組中元素最小值
tup1 = (1, 2)
print("元組最大值：", min(tup1))
print("元組最大值：", max(tup1))
#tuple()方法：将清單轉換為元組
list1= ['1', '2']
print("轉換前：", list1)
tup1 = tuple(list1)
print("轉換後：", tup1) 集合類型(Set)
集合類型是無序的不重複元素序列。使用大括号 {} 或者 set() 函數建立集合。
注意：建立一個空集合必須用 set() 而不是 {}，因為 {} 是用來建立一個空字典。
a={'a','b','c'}
b=set('abc')
c=set()
d={}
print(a)
print(b)
print(type(a), type(b), type(c), type(d))
#無序性
a = set('python')
print(a)
#互異性
a = set('good')
print(a)
#add()方法：為集合添加元素
a = set('good')
a.add('p')
print(a)
#update()方法：給集合添加元素
a = set('good')
a.update('p')
print("添加一個元素", a)
a.update(['a', 'b', 'c'])
print("添加多個元素", a)
a.update(['H', 'e'], {'l', 'l', 'o'})
print('添加清單和集合', a)
#remove()方法：移除指定元素
s = {'P', 'y', 't', 'h', 'o', 'n'}
s.remove('t')
print("去掉t", s)
#pop()方法：随機移除元素
s = {'P', 'y', 't', 'h', 'o', 'n'}
print("随機删除元素：", s.pop())
#clear()方法：移除集合中的所有元素
s = {'P', 'y', 't', 'h', 'o', 'n'}
s.clear()
print("清空集合：", s, len(s))
#issubset()方法：判斷指定集合是否為該方法參數集合的子集
A = set('abcd')
B = set('cdef')
C = set('ab')
print("C是否A子集：", C.issubset(A))
#union()方法：傳回兩個集合的并集，也可以用 |
print("A和B并集:", A|B)
print("A和B并集:",A.union(B))
#interp()方法：傳回集合的交集，也可以用&
print("A和B交集:", A&B)
print("A和B交集:",A.interp(B))
#difference()方法：差集，也可以用-
print("A和B差集:", A-B)
print("A和B差集:",A.difference(B)) 字典類型(Dictionary)
字典類型是可變類型。在同一個字典中，鍵(key)必須是唯一的。
字典的每個鍵值(key=>value)對用冒号(:)分割，每個對之間用逗号(,)分割，整個字典包括在花括号({})中。
# 用{}建立字典
dict1 = {"a":"1", "b":"2"}
print(dict1)
# 用内置函數dict()
dict2 = dict(a="1", b="2")
print(dict2)
#通路字典裡的值
dict1 = {"a":"1", "b":"2"}
print ("dict1['a']: ", dict1['a']) #如果沒有會報錯
print ("dict1.get('a'): ", dict1.get('a')) #如果沒有傳回None
print("擷取所有的key值：", dict1.keys())
print("擷取所有的value值：", dict1.values())
#增加新的鍵/值對
dict1 = {"a":"1", "b":"2"}
print ("增加前：", dict1)
dict1['c'] = 3
print ("增加後：", dict1)
#删除字典指定元素
dict1 = {"a":"1", "b":"2"}
print ("删除前：", dict1)
del dict1['a']
print ("删除後：", dict1)
#清空字典
dict1 = {"a":"1", "b":"2"}
print ("清空前：", dict1)
dict1.clear()
print ("清空後：", dict1)
#dir()方法：檢視dict所有方法
print(dir(dict)) 條件判斷和循環
條件控制：通過一條或多條語句的執行結果（True或者False）來決定執行的代碼塊。
每個條件後面要使用冒号:，表示接下來是滿足條件後要執行的語句塊。使用縮進來劃分語句塊，相同縮進數的語句在一起組成一個語句塊。在Python中沒有switch–case語句。
#if操作
x = 5
if x > 3:
print("yes")
#if嵌套:if...elif...else
#也可以把 if...elif...else 結構放在另外一個 if...elif...else 結構中
x = 99
if x<60:
print("不及格")
elif x<80:
print("良好")
else:
print("優秀")
#while循環
sum = 0
counter = 1
while counter <= 10:
sum = sum + counter
counter += 1
print("1 到 10 之和為: %d" % sum)
#while 循環使用 else 語句
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")
#for 語句：for循環可以周遊任何序列(清單、字元串等)
str = 'python'
list1 = ['I', 'love', 'python']
print("周遊字元串")
for i in str:
print(i)
print("周遊清單")
for i in list1:
print(i)
#range()函數：周遊數字序列，可以使用内置range()函數生成數列
for i in range(5):
print(i)
#也可以使用range指定區間的值
for i in range(2,6):
print(i)
#也可以使range以指定數字開始并指定不同的增量(步長),可以是負數
for i in range(0, 10, 3):
print(i)
for i in range(-10, -100, -30):
print(i)
#可以結合range()和len()函數以周遊一個序列的索引
list1 = ['I', 'love', 'Python']
for i in range(len(list1)):
print(list1[i])
#break語句：跳出 for 和 while 的循環體
list1 = ['I', 'love', 'Python']
for i in list1:
if i == 'love':
break
print('目前為 :', i)
#continue語句:跳過目前循環塊中的剩餘語句，然後繼續進行下一輪循環
var = 10
while var > 0:
var = var -1
# 變量為 5 時跳過輸出
if var == 5:
continue
print ('目前值 :', var)
print ("hello world!")
#pass 語句：pass是空語句，是為了保持程式結構的完整性，pass 不做任何事情，一般用做占位語句
while True:
pass # 等待鍵盤中斷 (Ctrl+C) 函數
函數是組織好的，可重複使用的，用來實作單一，或相關聯功能的代碼段。函數能提高應用的子產品性，和代碼的重複使用率。
Python提供了許多内建函數，比如“print()”，也可以自己建立函數，這被叫做使用者自定義函數。
# 1.無參函數
# 用def定義新函數
def my_func():
print("test...")
return 1
# 調用函數
my_func()
# 2.有參函數
# 關鍵字參數、預設參數、可變參數。
# 關鍵字參數: 調用時指定參數的名稱，且與函數聲明時的參數名稱一緻。使用關鍵字參數允許函數調用時參數的順序與聲明時不一緻。
def my_func1(x, y):
print(x)
print(y)
# 标準調用
my_func1(1, 2)
# 關鍵字調用
def my_func1(y = 1, x = 2)
# 預設參數：在函數聲明時，指定形參的預設值，調用時可不傳入參數（使用預設值）。
def my_func2(x, y=1):
print(x+y)
my_func2(2)
#可變參數:變參數就是傳入的參數個數是可變的，可以是1個、2個到任意個。
#在參數前面加了一個*号。在函數内部，參數numbers接收到的是一個tuple。
def my_func3(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
# 函數調用
my_func3() #傳回結果0
my_func3(1,2) #傳回結果5
# 關鍵字參數：可變參數允許你傳入0個或任意個參數，這些可變參數在函數調用時自動組裝為一個tuple。而關鍵字參數允許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數内部自動組裝為一個dict。
def my_func4(x, **kw):
print ('x:', x, 'other:', kw)
#除了必選參數x外，還接受關鍵字參數kw。在調用該函數時，可以隻傳入必選參數。
my_func4(8)
#也可以傳入任意個數的關鍵字參數
my_func4(8, z="66") 類
類(Class):用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的執行個體。
類變量：類變量在整個執行個體化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作為執行個體變量使用。
資料成員：類變量或者執行個體變量, 用于處理類及其執行個體對象的相關的資料。
#建立類Student
class Student(object):
"學生成績"
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print('%s: %s' % (self.name, self.score))
#建立Student類的對象bart
jack = Student('Bart Simpson', 59)
#建立Student類的對象lisa
bob = Student('Lisa Simpson', 87)
#通路類的屬性
jack.print_score()
bob.print_score()
# 添加一個 'age' 屬性
jack.age = 7
print("添加一個 'age' 屬性：",hasattr(jack, 'age'))
# 修改 'age' 屬性
jack.age = 8
print("修改 'age' 屬性：",getattr(jack, 'age'))
# 删除 'age' 屬性
del jack.age
print("删除 'age' 屬性：",hasattr(jack, 'age')) 類的繼承
面向對象的程式設計帶來的主要好處之一是代碼的重用，實作這種重用的方法之一是通過繼承機制。
通過繼承建立的新類稱為子類或派生類，被繼承的類稱為基類、父類或超類。
#編寫一個名為Fruit的class，執行run()方法可以直接列印
#編寫Apple和Orange類時，就可以直接從Fruit類繼承
class Fruit(object):
'父類Animal'
def run_father(self):
print('調用父類方法...')
class Apple(Fruit):
'子類1 Apple'
def run_son(self):
print('調用子類方法...')
class Orange(Fruit):
'子類2 Orange'
def run_son(self):
print('調用子類方法...')
#執行個體化子類
apple = Apple()
orange = Orange()
#調用父類方法
apple.run_father()
orange.run_father()
#調用子類方法
apple.run_son()
orange.run_son() 方法重寫
如果父類方法的功能不能滿足你的需求，你可以在子類重寫你父類的方法
class Fruit(object):
'父類Animal'
def run(self):
print('調用父類方法...')
class Apple(Fruit):
'子類1 Apple'
def run(self):
print('子類1 Apple 重寫父類方法...')
class Orange(Fruit):
'子類2 Orange'
def run(self):
print('子類2 Orange 重寫父類方法...')
#執行個體化子類
apple = Apple()
orange = Orange()
#調用父類方法
apple.run()
orange.run() 子產品
Python 子產品(Module)，是一個 Python 檔案，以 .py 結尾，包含了 Python 對象定義和Python語句。子產品讓你能夠有邏輯地組織你的 Python 代碼段。
把相關的代碼配置設定到一個子產品裡能讓你的代碼更好用，更易懂。子產品能定義函數，類和變量，子產品裡也能包含可執行的代碼。
# 導入子產品
import math
# 現在可以調用子產品裡包含的函數了
print("求e的n次幂：",math.exp(1))
# from…import 語句：從子產品中導入一個指定的部分到目前命名空間中
# 導入子產品中的特定函數
from math import exp
# 現在可以直接使用該函數了
print("求e的n次幂：",exp(1))
# from…import* 語句：導入一個子產品中的所有項目。然而這種聲明不該被過多地使用
from math import * The End