Python 簡介¶
Python 是當前最流行的程式語言之一。由 Guido van Rossum 創建，並於1991年發布。Python 擁有動態型別系統和垃圾回收功能，能夠自動管理記憶體，並且支援包括物件導向、命令式、函數式和程序式程式，其本身擁有廣泛的標準庫，並可以在大部分的作業系統中執行。
Python可用於：
- Web開發（伺服端）。
- 軟體開發。
- 數學。
- 系統腳本。
Python 的用途：
- 可以在伺服端上創建Web應用程序。
- 可以連接資料庫系統，還可以讀取和修改文件，以及在網路上爬取資料。
- 可以用來處理大數據並進行複雜的數學運算。
- 可以用於快速原型，或用於套件型軟件的開發。
Python 執行環境¶
搭積木學 Python¶
桌機執行環境¶
Anaconda
Anaconda 為目前最受歡迎的 Python 平台，擁有超過1400個適用於不同作業系統環境下的軟件包和虛擬環境管理器，對於 Python 的安裝、執行及升級都變得簡單快速。Miniconda
Miniconda 則是精簡版的 Anaconda，可以讓使用者自行加裝所需的軟件包，避免占用過大的硬碟空間，但只適合有經驗的使用者，初學者仍建議安裝 Anaconda。
手機執行環境¶
- Pydroid 3
Pydroid 3是一套在 Android 上執行，易於使用且功能强大的 Python 編輯軟體。
線上執行環境¶
Google Colaboratory
Google Colaboratory (簡稱為「Colab」) 可在瀏覽器上,不必進行任何設定即可撰寫及執行 Python。Jupyter Notebook
Jupter Notebook 是一個方便同時用來編輯 Markdown及HTML文件的編輯器，同時又具有Python等程式語言的編輯及執行環境，可充分利用其直譯式的特性編寫程式，並達到高互動執行結果，且容易呈現視覺化的執行結果。Microsoft Azure Notebooks
Microsoft Azure Notebooks 則是 Jupter Notebook 加上雲端硬碟的功能，讓使用者可以隨時隨地的編輯 Python 程式，Microsoft Azure Notebooks的操作流程如下：- 登入 Microsoft 帳號 (若無帳號則新增帳號)
- 點選 My Project
- 點選 + New Project，在Project Name中輸入專案名稱
- 點選專案名稱
- 點選 + 中的 Notebook
新增 Python 3.6 Notebook - 點選新增的 .ipynb 檔案，開啓Python 線上執行環境
- 鍵入
print('Hello')，按 Ctrl-Enter 開始執行
Jupter Notebook簡介¶
Jupyter Notebook是一個以Web為基礎的交互式計算環境，可用於創建Jupyter Notebook文檔，該文檔可以轉換為許多的開源標準輸出格式，如HTML、演示幻燈片、PDF、Markdown、Python等。
在Jupyter Notebook裡面，程式是以區塊去執行，程式碼會分成好幾個區塊，每個區塊可以各自去執行，也可以一次執行多個區塊來看執行結果，每個執行區塊可以設定四種狀態：
| 狀態 | 説明 |
|---|---|
| Code | 用於編輯程式碼，如 Python 等 |
| Markdown | 用於編輯 Markdown1 文件 |
| Raw NBConvert | 可用於轉換成另一種格式(如 HTML2) 的命令列工具 |
| Heading | 建議使用Markdown的標題功能取代 |
Jupter Notebook快捷鍵¶
Jupyter Notebook 的模式分爲命令、編輯及執行等模式：
- 命令模式：區塊會以藍色框線包圍，為預設模式，可以用來操作區塊，包含移動區塊、增刪區塊等。
- 編輯模式：區塊會以綠色框線包圍，可以在區塊中編輯 Markdown 文件或程式碼。
- 執行模式：按 Ctrl-Enter 鍵可以顯示執行結果。
使用鍵盤切換模式小技巧(→代表切換模式)
- → 編輯模式：按 Enter 鍵
- → 執行模式：按 Ctrl-Enter 鍵
- 編輯模式 → 命令模式：按 Esc 鍵
使用滑鼠切換模式小技巧
- → 編輯模式：點選右邊區塊
- → 命令模式：點選左邊空白區塊
Markdown 執行模式要快點二次 - → 執行模式：點選選單[Cell]→[Run Cells]
一般快捷鍵¶
| 快捷鍵 | 作用 |
|---|---|
| Ctrl-Enter | 執行區塊 |
| Shift-Enter | 執行區塊，並移到下個區塊 |
| Alt-Enter | 執行區塊，並插入新區塊 |
| Ctrl-S | 存檔 |
命令模式快捷鍵Y¶
| 快捷鍵 | 作用 |
|---|---|
| Y | 區塊切換為 Code 狀態 |
| M | 區塊切換為 Markdown 狀態 |
| R | 區塊切換為 Raw NBConvert 狀態 |
| A | 在上方插入新區塊 |
| B | 在下方插入新區塊 |
| DD | 刪除選中的區塊 |
| X | 剪下選中的區塊 |
| C | 複製選中的區塊 |
| V | 貼到下方區塊 |
| Z | 恢復最後一個刪除的區塊 |
| Shift-M | 合併選中的區塊 |
| Up ↑ | 選中上方區塊 |
| Down ↓ | 選中下方區塊 |
編輯模式快捷鍵¶
| 快捷鍵 | 作用 |
|---|---|
| Esc | 切換到命令模式 |
| Tab | 縮排 |
| Shift-Tab | 反縮排 |
| Ctrl-Z | 復原 |
| Ctrl-Shift-Z | 重做 |
| Ctrl-Left | 跳到左邊一個字首 |
| Ctrl-Right | 跳到右邊一個字首 |
| Ctrl-Backspace | 刪除前面一個字 |
| Ctrl-Delete | 刪除後面一個字 |
| Ctrl-Shift - | 分割區塊 |
搭積木學邏輯¶
In [32]:
print('你好!')
In [ ]:
x = input('請輸入成績')
if (x >= 60):
print('及格')
else:
print('不及格')
In [ ]:
while True:
x = input('請輸入成績')
if (x < 0):
break
if (x >= 60):
print('及格')
else:
print('不及格')
集合（陣列）¶
In [ ]:
List = ['香蕉', '蘋果', '鳳梨']
print(List)
print(List[0:2])
In [ ]:
List = ['香蕉', '蘋果', '鳳梨']
List.append('test')
print(List)
In [ ]:
List = ['香蕉', '蘋果', '鳳梨']
List.append('test')
for i in List:
print(i)
In [ ]:
List = ['香蕉', '蘋果', '鳳梨']
if ('香蕉' in List):
print('Yes')
else:
print('No')
In [ ]:
List = ['香蕉', '蘋果', '鳳梨']
List.reverse()
print(List)
數學函數¶
In [ ]:
# 絕對值
x=abs(-5.5)
print('Abs:', x)
# 最大值
x=max([1, 2, 3])
print('Max:', x)
# 四捨五入到整數
x=round(6.8)
print('Round:', x)
# 2的 10次方
x=pow(2, 10)
print('Pow:', x)
In [ ]:
import math
x = 100
y=math.sqrt(x)
print(y)
a = 3
b = 4
x=math.sqrt(a**2 + b**2)
print(x)
x = 10
y=math.sin(x)**2 + math.cos(x)**2
print(y)
In [ ]:
C=float(input("攝氏溫度:"))
F=C*9 / 5 + 32
print('華氏溫度=', F)
亂數¶
In [ ]:
import random
#語法：random.randint(開始,結束)
#顯示 0 到 9 之間的隨機整數
print(random.randint(0, 9))
#語法：
#random.randrange(開始,結束,間距)
#顯示 0 到 9 之間的隨機數偶數
print(random.randrange(0, 9, 2))
#顯示 0 到 1 間的隨機數浮點數
print(random.random())
In [ ]:
import random
x=random.choice(['小明', '小王', '小陳', '小黃', '小珍'])
print(x)
In [ ]:
import random
L = range(0, 10)
x = random.choice(L)
print(x)
In [ ]:
import random
L = range(0, 10)
for i in range(5):
x = random.choice(L)
print(x)
In [ ]:
import random
H = []
L = range(0, 10)
while (len(H) < 5):
x = random.choice(L)
if (x not in H):
H.append(x)
print(sorted(H))
In [ ]:
import random
N = random.randint(1, 10)
guess = int(input('猜一個1到10的數字: '))
while (guess != N):
if (guess > N):
print('太大了！')
else:
print('太小了！')
guess = int(input('再來一次：'))
print('恭喜猜對了！')
海龜繪圖¶
In [ ]:
import turtle
Pen = turtle.Pen()
for i in range(4):
Pen.circle(50)
Pen.right(90)
In [ ]:
import turtle
Pen = turtle.Pen()
for i in range(4):
Pen.circle(50)
Pen.forward(100)
Pen.right(90)
In [ ]:
import turtle
Pen = turtle.Turtle()
for i in range(5):
Pen.forward(50)
Pen.right(144)
turtle.done()
In [ ]:
import turtle
turtle.speed(2)
for i in range(100):
turtle.circle((5 * i))
turtle.circle((-5 * i))
turtle.left(i)
In [ ]:
import turtle
colors = ['red', 'purple', 'blue', 'green', 'orange', 'yellow']
t = turtle.Pen()
turtle.bgcolor('black')
for x in range(360):
t.pencolor(colors[x%6])
t.width(x/100 + 1)
t.forward(x)
t.left(59)
In [ ]:
import turtle
myTurtle = turtle.Turtle()
myWin = turtle.Screen()
def drawSpiral(myTurtle, lineLen):
if lineLen > 0:
myTurtle.forward(lineLen)
myTurtle.right(90)
drawSpiral(myTurtle,lineLen-5)
drawSpiral(myTurtle,100)
myWin.exitonclick()
In [ ]:
# See https://www.coder.work/article/2417280
import turtle
import math
t = turtle.Turtle()
t.shape("turtle")
t.lt(90)
lv = 11
l = 100
s = 17
t.penup()
t.bk(l)
t.pendown()
t.fd(l)
def draw_tree(l, level):
l = 3.0/4.0*l
t.lt(s)
t.fd(l)
level +=1
if level<lv:
draw_tree(l, level)
t.bk(l)
t.rt(2*s)
t.fd(l)
if level<=lv:
draw_tree(l, level)
t.bk(l)
t.lt(s)
level -=1
t.speed(100)
draw_tree(l, 2)
重複的字串¶
重複的字串可以使用 * 號，例如：
In [53]:
print("重複" * 3)
Python 基本語法¶
Python 可以在服務器上創建 python(.py)文件，然後在命令行中執行。或直接在命令行中編寫程式碼來執行Python：
In [32]:
print('你好!')
print 輸出¶
print()常用於輸出字串或變數，預設會在末尾補上換行符號：
In [2]:
print('你好!')
print('你好!')
如果不想要換行，可以使用參數end:
In [34]:
print('你好!', end=' ') #改爲空格
print('你好!')
print()裡若放多個字串，預設會使用空白來串接，使用 sep 參數可以變更分隔符號。
In [35]:
print('How','are','you')
print('How','are','you',sep='_')
input 輸入¶
In [36]:
num = input("請輸入一的幸運數字:")
print("您的幸運數字是: " + num)
指派運算子¶
指派運算子(=)用於為變數設值，例如下列程式宣告了變數x，並將x設定為5，然後顯示其内容：
In [37]:
x = 5
print(x)
Python 縮排¶
Python中的縮排非常重要，Python使用縮排來分辨程式區塊，一般建議使用4個空格作為縮排，例如：
In [38]:
if 10 > 5:
print("10 大於 5!")
不正確的縮排，會造成語法的錯誤：
if 10 > 5:
print("10 大於 5!")
print("10 大於 5!")
^
IndentationError: expected an indented block
縮排錯誤：預期縮排的區塊
不正確的縮排，也會造成邏輯上的錯誤，例如以下範例中的 print("End")，會因縮排而成爲if控制的區塊，因而不會執行：
In [39]:
x = 10
if x < 5:
print("小於 5!")
print("End")
In [40]:
x = 10
if x < 5:
print("小於 5!")
print("End")
單行註解功能¶
Python 註解以 # 開頭，Python 執行時，註解列會被忽略：
In [41]:
# 這是單行註解
print("Hi!")
print("Hi!") #這是單行註解
In [42]:
# 這是註解I
# 這是註解II
Python會忽略未指派給變數的字串，因此也可以把多行字串(三引號)當作註解：
In [43]:
'''
這是多行字串
也是多行註解
'''
print("你好！")
變數¶
變數是儲存資料的容器，與其他程式語言不同，Python 變數不需經過宣告，而是於第一次設定值時創建。
In [44]:
x = 5 # x 變數創建於第一次設定值
print(x)
變數不需聲明任何特定類型，甚至可以在設置變數後更改其類型
In [45]:
x = 5 # x 目前是整數
print(type(x))
x = '你好' # x 已變為字串
print(type(x))
變數及函數命名¶
變數可以具有短名稱（如 x 和 y）或更具描述性的名稱（如 Year，carName，total_volume）。
Python 變數及函數命名規則：
- 名稱必須以字母或底線字元開頭，例如：
A4 - 名稱也可以是中文，例如：
面積 - 名稱不能以數字開頭，例如：不可以是
4A - 名稱只能包含字母、數字、底線或中文（A-z，0-9和_）
- 名稱區分大小寫
- 不能使用保留字及關鍵字
- 當名稱是由二個或多個單字連結在一起時，建議利用「駝峰式大小寫」來表示，可以增加可讀性：
- 小駝峰式命名法：例如：
carName、totalVolume。 - 大駝峰式命名法：例如：
CarName、TotalVolume。
- 小駝峰式命名法：例如：
變量的輸出¶
要顯示變數内容，只要在最後打上變數名稱即可(限單一變數及程式最後一行)，例如：
In [46]:
x = 5
x #顯示變數内容
Out[46]:
In [47]:
x = 5
y = 10
z = x + y #數值相加
z
Out[47]:
In [48]:
x = 'Python '
y = '你好'
z = x + y #字串的串接
z
Out[48]:
複雜的變數輸出可以採用 print 語句，透過逗號將多個變數或常數串接，例如：
In [49]:
x = 'Python'
y = '你好'
print(x, y, '這是輸出')
常數¶
常數是指固定不變的數值，Python内建的常數有：
- True、False：布林(bool)資料類型的值。
- None：空值，變數若設爲空值，表示沒有值。
Python語言並沒有自訂常數的機制，習慣上可以把變數名稱設爲全部用大寫英文字母當作常數，並養成習慣不變更用英文大寫命名的變數內容，不過無法保證變數的內容不會被修改。
In [50]:
PI = 3.1416
PI
Out[50]:
Python 資料類型¶
變數可以儲存不同類型的資料，Python 變數具有以下的資料類型：
字串： str
數值： int、float、complex
布林： bool
序列： list、tuple、range
字典： dict
集合： set、frozenset
二進制：bytes、bytearray、memoryview
In [51]:
print("Hello")
print('Hello')
字串的串接¶
字串的串接可以使用 + 號，例如：
In [52]:
x = 'Python '
y = '你好'
z = x + y #字串串接
z
Out[52]:
但 + 符號，不可以混合不同形態的資料運算，例如：
x = 'Python'
y = 10
z = x + y #字串+整數
print(z)
1 x = 'Python'
2 y = 10
----> 3 z = x + y
4 print(z)
TypeError: can only concatenate str (not "int") to str
類型錯誤：只能連接字串（不是“整數”）到字串
重複的字串¶
重複的字串可以使用 * 號，例如：
In [53]:
print("重複" * 3)
print(3 * "重複")
多行字串¶
可以使用三個引號將多行字串分配給變數:
In [54]:
a = '''多行字串
多行字串
多行字串'''
print(a)
跳脫字元¶
要在字串中插入特殊字元或已被語法使用的符號，須使用跳脫字元。跳脫字元是以反斜線\ 加上要插入的字元構成。例如要在雙引號包圍的字串中使用雙引號，則會出現錯誤，要解決此問題，須使用跳脫字元 \"
常用的跳脫字元列表如下：
| 程式碼 | 結果 | 説明 |
|---|---|---|
| \' | ' | 單引號 |
| \" | " | 雙引號 |
| \\ | \ | 反斜線 |
常用的跳脫字元(控制字元)列表如下：
| 程式碼 | 結果 | ASCII縮寫 |
|---|---|---|
| \n | 換行 | LF |
| \r | 歸位 | CR |
| \t | 水平Tab | HT |
| \v | 垂直Tab | VT |
| \f | 跳頁 | FF |
| \b | 退格鍵 | BS |
要在字串中使用引號會出現錯誤，須使用跳脫字元\"或\'
In [55]:
print("這是要用\"引號\"的内容")
print('這是要用\'引號\'的内容')
如要顯示多行文字，不可以使用Enter鍵
print("這是第一行
這是第二行")
SyntaxError: EOL while scanning string literal
必須透過跳脫字元\n，或是使用三個引號```
In [56]:
print("這是第一行\n這是第二行")
print('''這是第一行
這是第二行''')
訪問字串的字元¶
透過方括號可用於訪問字串中的字元：
In [1]:
# 獲取位置 1 的字元
# 請注意第一個字元的位置為 0
a = "快樂學程式語言"
print(a[1])
切片語法¶
切片語法用在返回一定範圍的字串，指定開始索引和結束索引，並以冒號分隔，可取得指定範圍的字串。
In [58]:
#截取從位置 2 到位置 5（不包括 5 在內）的字串：
a = "快樂學程式語言"
print(a[2:5])
負索引¶
使用負索引從字串末尾開始切片：
In [59]:
#從倒數位置 5 到 3（不含2）截取字串：
a = "快樂學程式語言"
print(a[-5:-2])
In [60]:
#截取末尾 2 位字串(:後留空白)
a = "快樂學程式語言"
print(a[-2:])
字串方法¶
In [61]:
# len():獲取字串的長度
a = "Hello, World!"
len(a)
Out[61]:
In [62]:
# 空字串的長度=0
a = ''
len(a)
Out[62]:
In [63]:
# strip():刪除開頭或結尾所有空格
a = " Hello, World! "
a.strip()
Out[63]:
In [64]:
# upper():返回字串的大寫形式
# lower():返回字串的小寫形式
a = "Hello, World!"
a.lower()
Out[64]:
In [65]:
# replace():將字串替換為另一組字串
a = "Hello, World!"
a.replace("He", "Ja")
Out[65]:
In [66]:
#split(分隔符):透過分隔符將字串分割為清單
a = "Hello, World!"
# 透過分隔符 "," 分割為清單
a.split(",")
Out[66]:
In [67]:
#in：檢查字串中是否存在特定的子字串
#not in：檢查是否不存在特定的子字串
txt = "快樂學程式語言"
x = "程式" in txt
print(x)
x = "Python" not in txt
print(x)
In [68]:
x = 1 # 整數 int
y = 1.68 # 浮點數 float
z = 1j # 複數 complex
Int 整數是一個無限制長度的正整數或負整數(無小數)：
x = 1
y = 3567891023456789
z = -3215566
浮點數是一個正數或負數，並包含一個或多個小數的數值：
x = 1.10
y = 1.0
z = -3.1416
浮點數也可以是帶有 “e” 的科學數字，以表示10的次方：
x = 35e2
y = 12E4
z = -87.8e100
In [1]:
水果清單 = ["香蕉", "蘋果", "鳳梨"]
print(水果清單)
In [2]:
#通過索引號來訪問清單項目
水果清單=["香蕉","蘋果","鳳梨"]
print(水果清單[0])
#清單項目數 len()
print(len(水果清單))
In [3]:
#通過索引號來訪問清單項目
水果清單=["香蕉","蘋果","鳳梨"]
#更改特定清單項目的值
水果清單[2]="xxx"
#負索引, -1指的是最後一項，-2指的是倒數第二項，依此類推
print(水果清單[-1])
指定索引範圍：通過指定範圍的起點和終點來指定索引範圍。指定範圍時，返回值將是包含指定項目的新清單
In [4]:
水果清單=["香蕉","蘋果","鳳梨"]
# 從索引 1 到索引 3（不包括 3）
# 第一項的 "香蕉" 的索引為 0
print(水果清單[1:3])
# 省略起始值，範圍將從第一項開始
print(水果清單[:2])
# 負指數範圍, 從清單末尾開始搜索
print(水果清單[-2:-1])
# 從清單末尾開始搜索
print(水果清單[-2:])
遍歷清單：透過 for 迴圈指令來遍歷清單所有項目
In [5]:
水果清單=["香蕉","蘋果","鳳梨"]
for 水果 in 水果清單:
print(水果, end=' ')
組合清單：透過 join 指令來組合所有項目成單一字串
In [6]:
水果清單=["香蕉","蘋果","鳳梨"]
print(' '.join(水果清單))
print(','.join(水果清單))
檢查項目是否存在：透過 in 指令來確任列表中是否存在指定的項目
In [7]:
水果清單=["香蕉","蘋果","鳳梨"]
if '香蕉' in 水果清單:
print("Yes")
else:
print("No")
清單項目編輯¶
清單項目的新增、刪除、清空
In [9]:
水果清單=["香蕉", "蘋果"]
# append():將項目添加到列表的末尾
水果清單.append("芒果")
print(水果清單)
# insert():添加項目到指定的索引處
水果清單.insert(1, "奇異果")
print(水果清單)
In [10]:
水果清單=["香蕉","蘋果","鳳梨"]
# remove():刪除特定項目
水果清單.remove("蘋果")
print(水果清單)
# del:刪除索引指定的項目
del 水果清單[1]
print(水果清單)
In [11]:
水果清單=["香蕉","蘋果","鳳梨"]
# pop(索引):刪除索引指定的項目
水果清單.pop(0)
print(水果清單)
# pop():如果索引空白，則刪除最後一項
水果清單.pop()
print(水果清單)
In [12]:
水果清單 = ["香蕉", "蘋果", "鳳梨"]
# clear()：清空列表
水果清單.clear()
print(水果清單)
# del：完全刪除列表
del 水果清單
# mylist已不存在，下列程式會引發錯誤
# print(水果清單)
複製清單：製作清單副本
In [89]:
清單A=["香蕉","蘋果","鳳梨"]
# 清單A,清單B會參考到同一份清單
清單B = 清單A
清單B[0]="xxx"
print(清單A)
print(清單B)
In [88]:
清單A=["香蕉","蘋果","鳳梨"]
# 清單A,清單B會參考到同一份清單
清單B = 清單A.copy()
清單B[0]="xxx"
print(清單A)
print(清單B)
合併清單：連接兩個或多個清單，最簡單的方法是使用 + 運算子或 .extend()
In [15]:
清單A = ["a", "b", "c"]
清單B = [1, 2, 3]
清單C = 清單A + 清單B
print(清單C)
In [16]:
清單A = ["a", "b", "c"]
清單B = [1, 2, 3]
清單A.extend(清單B)
print(清單A)
清單索引值：返回指定項目的索引值（index()）
In [17]:
水果清單 = ["香蕉","蘋果","鳳梨"]
print(水果清單.index("鳳梨"))
反轉清單：返回反轉的清單
In [18]:
清單 = [1, 2, 3, 4]
清單.reverse()
print(清單)
轉置矩陣：返回轉置的矩陣 zip() 函數可以把多個list的相對應位置鏈結起來，其結果也剛好是轉置矩陣。
In [86]:
好友 = ["千千", "恩恩", "萱萱", "帆帆"]
喜好 = ["餅乾", "巧克力", "草莓", "蛋糕"]
zipped = list(zip(好友, 喜好))
zipped
Out[86]:
A=$\left[ \begin{array}{cccc} 1 & 2 & 3 & 4 \\ 1 & 2 & 3 & 4 \end{array} \right]$ $A^T$= $\left[ \begin{array}{cc} 1 & 1 \\ 2 & 2 \\ 3 & 3 \\ 4 & 4 \end{array} \right]$
In [19]:
A = [[1, 2, 3, 4], [1, 2, 3, 4]]
T=list(zip(*A))
T
Out[19]:
序對（Tuple）¶
Tuple 簡單來説就是唯讀的List清單，不允許更改内容。
In [88]:
mytuple = ("香蕉", "蘋果", "鳳梨")
print(mytuple)
# 存取清單項目
print(mytuple[1])
負索引及範圍：
- 負索引是指從頭開始，-1指的是最後一項，-2指的是倒數第二項， 依此類推。
- 通過指定範圍的起點和終點來指定索引範圍，返回值將是帶有指定項目的新清單。
In [89]:
mytuple=("香蕉","蘋果","鳳梨")
# 存取最後一項清單項目
print(mytuple[-1])
# 存取範圍清單項目
print(mytuple[2:3])
In [90]:
mytuple=("香蕉","蘋果","鳳梨")
# 負索引範圍（不包括 -1）
print(mytuple[-2:-1])
# 負索引範圍（包括 -1）
print(mytuple[-2:])
唯讀的清單（Tuple）轉爲 清單（List）
In [20]:
mytuple=("香蕉","蘋果","鳳梨")
清單 = list(mytuple)
清單[1] = "xxx"
print(清單)
Tuple下列的方法同 List 清單：
- 遍歷清單（for）
- 檢查項目是否存在（in）
- 確定項目數量（len()）
- 刪除整個清單（del）
- 連接兩個或多個清單（+）
- 返回指定值的清單索引值（index()）
Tuple不可改變清單内容，所以不具有下列的方法：
- pop()、append()、insert()、remove()
- 刪除項目（del item）
集合（Set）¶
集合具有下列特性：
- 集合是無序且無索引，在Python中以大括號括起來
- 因為是無序、無索引，所以無法透過索引來訪問集合中的項目
- 無法更改其項目，但可以添加新項目
- 重複項目會被踢除
- 集合是無序的，因此不能確定項目將以什麼順序出現
In [92]:
水果集合={"香蕉","蘋果","鳳梨"}
print(水果集合)
In [22]:
水果集合={"香蕉","蘋果","鳳梨","鳳梨"}
print(水果集合)
詢問（in）及遍歷清單（for in）
In [23]:
水果集合={"香蕉","蘋果","鳳梨"}
# 使用in指令來詢問集合中"蘋果"是否存在
print("蘋果" in 水果集合)
# 使用迴圈 for 指令來遍歷所有項目
for 水果 in 水果集合:
print(水果, end=' ')
新增集合項目
In [25]:
水果集合 = {"香蕉", "鳳梨"}
#新增單一項目
水果集合.add("奇異果")
print(水果集合)
#新增多個項目（重複項目會被踢除）
水果集合.update(["奇異果","芒果","鳳梨"])
print(水果集合)
集合（Set）的下列的方法同清單：
- 遍歷清單（for）
- 檢查項目是否存在（in）
- 確定項目數量（len()）
- 刪除整個清單（del）
集合的下列的方法使用上有差異：
- 要刪除集合中的項目，請使用 remove()、discard()或pop()
- 連接兩個或多個集合，需使用 union() 或 update()
In [26]:
水果集合={"香蕉","蘋果","鳳梨"}
# 刪除項目
水果集合.discard("蘋果")
print(水果集合)
# 刪除項目，如果項目不存在：
# remove()將引發錯誤
# discard()則不會
水果集合.remove("鳳梨")
print(水果集合)
In [31]:
# 集合是無序的
# 因此 pop()刪除的項目並不確定
水果集合 = {"鳳梨","蘋果","香蕉"}
x = 水果集合.pop()
print("刪除了:" + x)
In [32]:
集合A = {"a","b","c"}
集合B = {1, 2, 3}
# 連接兩個集合中所有項目，並產生新集合
集合C = 集合A.union(集合B)
print(集合C)
# 將 集合B 中的項目插入 集合A 中
集合A.update(集合B)
print(集合A)
字典（Dict）¶
字典是無序，可變和具有索引的集合，以大括號括起來，具有鍵（Key）和值（Value）。
In [33]:
個人資料 = {
"名字": "强森",
"電話": "03-543210",
"出生年": 1964
}
print(個人資料)
# 異動項目
個人資料["名字"]="xxx"
print(個人資料)
# 訪問單一項目
print(個人資料["名字"])
遍歷字典項目（for in）
In [35]:
個人資料 = {
"名字": "强森",
"電話": "03-543210",
"出生年": 1964
}
# 印出的所有值 (兩種語法)
for 索引 in 個人資料:
print(個人資料[索引], end=' ')
print("\n----")
for 值 in 個人資料.values():
print(值, end=' ')
In [40]:
個人資料 = {
"名字": "强森",
"電話": "03-543210",
"出生年": 1964
}
#印出所有的索引
for 索引 in 個人資料:
print(索引)
In [39]:
個人資料 = {
"名字": "强森",
"電話": "03-543210",
"出生年": 1964
}
#印出的所有 索引:值
for 索引, 值 in 個人資料.items():
print(索引, ':', 值)
檢查鍵（Key）是否存在
In [41]:
個人資料 = {
"名字": "强森",
"電話": "03-543210",
"出生年": 1964
}
if "名字" in 個人資料:
print("Yes")
字典的下列的方法類似清單：
- 遍歷字典鍵名（for）
- 檢查鍵名是否存在（in）
- 確定項目數量（len()）
- 刪除整個字典（del）
- 清空字典（clear()）
- 複製字典（copy()）
字典的下列的方法使用上有差異：
- 新增項目，通過使用新的索引鍵並為其分配值
- 要刪除項目，請使用 del 或 pop()
- 連接兩個或多個集合，須使用 update()
In [42]:
個人資料 = {
"名字": "强森",
"電話": "03-543210",
"出生年": 1964
}
個人資料["郵遞區號"]="300"
print(個人資料)
In [43]:
個人資料 = {
"名字": "强森",
"電話": "03-543210",
"出生年": 1964
}
#刪除具有指定鍵名的項目
個人資料.pop("電話")
print(個人資料)
In [44]:
個人資料 = {
"名字": "强森",
"電話": "03-543210",
"出生年": 1964
}
del 個人資料["出生年"]
print(個人資料)
# 清空項目
個人資料.clear()
print(個人資料)
In [45]:
個人資料 = {
"名字": "强森",
"電話": "03-543210",
"出生年": 1964
}
# 製作副本
個人資料副本=個人資料.copy()
個人資料副本["名字"]="xxx"
print(個人資料)
print(個人資料副本)
内建數學函數¶
In [112]:
# 絕對值
abs(-5.5)
Out[112]:
In [113]:
# 最大值
max([1, 2, 3])
Out[113]:
In [114]:
# 最小值
max([1,2,3])
Out[114]:
In [115]:
# 傳回整數
int(6.8)
Out[115]:
In [116]:
# 四捨五入到整數
round(6.8)
Out[116]:
In [117]:
# 四捨五入到小數2位
round(3.1416, 2)
Out[117]:
In [118]:
# 2的 10次方
pow(2, 10)
Out[118]:
數學函數模組¶
Python 内建有許多模組，其中 math 模組内建許多數學常數及函數：
| 常數 | 説明 |
|---|---|
| math.pi | 圓周率 |
| math.e | 自然對數e |
| math.nan | Not a Number (非數值) |
|math.inf|無限大|
最大公因數
In [119]:
import math
math.gcd(25, 225)
Out[119]:
自然對數 $y = \ln{x}$
In [120]:
import math
x = 2
math.log(x)
Out[120]:
對數 $y = \log_a{b}$
In [121]:
import math
b = 100
math.log(b, 10)
Out[121]:
平方根 $y = \sqrt{x}$
In [122]:
import math
x = 100
math.sqrt(x)
Out[122]:
$y = \sqrt{a^2 + b^2}$
In [123]:
import math
a = 3
b = 4
math.sqrt(a**2 + b**2)
Out[123]:
$(\sin x)^2 + (\cos x)^2$
In [124]:
import math
x = 10
math.sin(x)**2 + math.cos(x)**2
Out[124]:
$ x = {-b + \sqrt{b^2-4ac} \over 2a}. $
In [125]:
import math
a=float(input("a="))
b=float(input("b="))
c=float(input("c="))
if b**2 < 4*a*c:
print("輸入數值錯誤")
else:
x=(-b+math.sqrt(b**2 - 4*a*c)) / (2*a)
print("x=", x)
資料類型轉換¶
將變數或資料從一種類型轉換為另一類型：
- int()：由整數，浮點數或字串等文字轉換為一個整數
- float()：由整數，浮點數或字串等文字轉換一個浮點數
- str()：由各種數據類型轉換為字串
In [126]:
#由整數文字轉換一個浮點數:
x = "1"
float(x)
Out[126]:
In [127]:
#由浮點數文字轉換為整數
#必須先將文字轉爲浮點數，再轉爲整數
y = "2.8"
int(float(y))
Out[127]:
In [128]:
#數值轉換為字串
x = 10
str(x)
Out[128]:
溫度換算¶
攝氏換算華氏：$^\circ F=^\circ C \times {9 \over 5}+32$
In [129]:
攝氏=float(input("攝氏溫度:"))
華氏=攝氏*9 / 5 + 32
print('華氏溫度=', 華氏)
In [80]:
# 輸入體重及身高
體重=float(input("體重(公斤):"))
身高=float(input("身高(公分):"))
# 將公分轉爲公尺
身高 /= 100
# 計算BMI
BMI=體重 / pow(身高, 2)
print('BMI=', BMI)
#顯示判斷結果
if(BMI < 18.5):
print("體重過輕")
elif(BMI > 24):
print("體重過重")
else:
print("體重正常")
整存整付 (年)¶
試算公式： $\displaystyle 本利和 = 本金\times(1+年利率)^{期數}$
In [ ]:
本金=float(input("請輸入本金"))
利率=float(input("請輸入年利率"))
期數=int(input("請輸入期數(年)"))
本利和=本金*(1+利率/100)**期數
print(round(本利和))
零存整付¶
試算公式： $\displaystyle 本利和 = 月存本金\times(1+月利率)\times((1+月利率)^{期數}-1) \div 月利率$
In [82]:
月存本金=float(input("請輸入每月存入的本金"))
利率=float(input("請輸入年利率"))
期數=int(input("請輸入期數"))
月利率=利率/12/100
本利和=月存本金*(1+月利率)*((1+月利率)**期數-1)/月利率
print("本利和=", round(本利和))
終身壽險保費預估¶
由 $本金 = {本利和 \over (1+利率)^{期數}}$ 來反推終身壽險保費估算公式為：
$\displaystyle 躉繳保費 = {保額 \over (1+預定利率)^{幾年後理賠}}$
假設保額100萬，30歲投保，計算到100歲的終身壽險，預定利率2%及3%的計算結果如下：
In [84]:
# 預定利率 2%
保額=1000000
預定利率=2/100
幾年後理賠=100-30
保費=保額/(1+預定利率)**幾年後理賠
print("保費", round(保費))
In [83]:
# 預定利率 2%
保額=1000000
預定利率=3/100
幾年後理賠=100-30
保費=保額/(1+預定利率)**幾年後理賠
print("保費", round(保費))
以上可以看出，預定利率2%的保費比3%的保費足足多了近1倍，所以終身壽險應當在預定利率高的時候投保較爲划算。
布林值¶
- 布林值只有兩個值： True 或 False
- 比較運算式運算結果會返回布林值
In [131]:
#比較運算式
print(10 > 9)
print(10 == 9)
print(10 < 9)
- 在 if 語句中運行的比較運算式，當結果為 True 或 False，分別會執行 if 及 else 後面的程式區塊
- 程式區塊是以縮排來展現，不正確的縮排會造成語法或邏輯的錯誤
In [132]:
a = 200
b = 33
if a > b:
print("a > b")
else:
print("a <= b")
In [133]:
x = 3
y = 2
print(x + y)
print(x - y)
print(x * y)
print(x / y)
In [134]:
x = 3
y = 2
print(x % y) #求餘數
print(x // y) #求商數
print(2 ** y) #次方
指派運算子¶
指派運算子包含
| 運算子 | 範例 | 説明 |
|---|---|---|
| = | x = 2 | x 填入 2 |
| += | x += 2 | x值加2 |
| -= | x -= 2 | x值減2 |
| *= | x *= 2 | x值變2倍 |
| /= | x /= 2 | x值減半 |
| %= | x %= 2 | x為除以2的餘數 |
| /= | x //= 2 | x為除以2的商數 |
| **= | x **= 2 | x=x2 |
指派運算子用於為變數設定值，例如：
In [135]:
x = 5
x = x + 3
x
Out[135]:
In [136]:
x = 5
x += 3 #相當於 x=x+3
print(x)
x -= 3 #相當於 x=x-3
print(x)
In [137]:
x = 5
x *= 3 #相當於 x=x*3
print(x)
x /= 3 #相當於 x=x/3
print(x)
In [138]:
x = 5
x %= 3 #除以3的餘數
print(x)
In [139]:
x = 5
x //= 3 #除以3的商數
print(x)
比較運算子¶
比較運算子用於比較兩個值，包含 ==(等於) !=（不等於） >（大於） <（小於） >=（大於或等於） <=（小於或等於）
In [140]:
x = 5
y = 3
print(x == y)
print(x != y)
In [141]:
x = 5
y = 3
print(x > y)
print(x >= y)
In [142]:
x = 5
y = 5
print(x < y)
print(x <= y)
In [143]:
print(True and True)
In [144]:
print(True and False, end=' ')
print(False and True, end=' ')
print(False and False)
In [145]:
x = 6
print(x > 3 and x < 10)
or 為任一條件符合，就會是True
In [146]:
print(True or True, end=' ')
print(True or False, end=' ')
print(False or True)
In [147]:
print(False or False)
In [148]:
x = 6
print(x < 3 or x > 10)
- not 為目前結果的反向
In [149]:
print(not True)
print(not False)
In [150]:
x = 6
#下列兩者結果是相同的
print(not(x < 3))
print(x >= 3)
識別運算子¶
識別運算子 is 用於比較對象是不是相同，並且具有相同的記憶體空間
In [86]:
清單A = ["香蕉", "蘋果"]
清單B = ["香蕉", "蘋果"]
清單C = 清單A
# 比較運算子只比較内容是否相同
print(清單A == 清單B)
# 識別運算子比較内容以及記憶體空間是否相同
print(清單A is 清單B)
# x 及 z 指向同一記憶體空間
print(清單C is 清單A)
成員運算子¶
成員運算子 in 用於測試對像中是否存在序列中
In [152]:
水果清單 = ["香蕉", "蘋果"]
print("香蕉" in 水果清單)
print("鳳梨" not in 水果清單)