Python ê 基礎 -- 參數

參數(arguments) 是佇咧程式運行的時，順紲 phá-sù (pass) 予程式使用的物件。伊的目的是欲予程式較有通伸勼。舉例來講，咱若寫程式來算檔案--裡有偌濟字，欲按怎寫較好用? 是共伊寫予死佇程式--裡? 抑是另外用 input() 運行到一半才來請使用者回答? 這時，咱用參數上方便:

#!/usr/bin/python3
import sys
fn = sys.argv[1]
fh = open(fn)
all_lines = fh.readlines()
lines = 0
words = 0
for s in all_lines:
    lines = lines + 1
    words = words + len(s)
print("File %s has %d lines, %d words" % (fn, lines, words))

咱用 count-words.py 來共伊囥入去檔案，運行看覓咧:

$ python3 count-words.py 魔神仔.txt
File 魔神仔.txt has 36 lines, 1237 words

佇頂仔 ê 程式中央，咱先使用 import sys，來共 sys 這个 module 掠--入來。因為咱欲使用伊來提著 arguments: sys.argv[1] 是踮程式名後頭一咧字，佇例--裡就是 "魔神仔.txt"。當然，我的電腦--裡有現成的 "魔神仔.txt" 檔案，伊就會共幾逝和幾字攏算好印--出來。

咱若欲換捌的檔案，毋免改程式，換參數就好，凊彩你改，比如: count-words.py my.txt，count-words.py yours.txt。

咱轉來看 sys.argv[1]。1 佇遮代頭一咧參數。咱若有濟濟的參數咧? 就 2, 3, 4,.. 照順序排落去是 sys.argv[2]，sys.argv[3]，sys.argv[4]，...。

sys.argv[0] 是程式伊家己，佇咱的例內底，是 "count-words,py"。

這寡參數，攏是以字串(Strings)的型態讀--入來 Python 个。讀--入來了後，你若是想欲共伊轉做捌个型態，愛家己轉，無 Python 會共你張講你寫毋著--去阿。比如講，你欲用數字，你會使用 int()，float() 來轉:

#!/usr/bin/python3
# Simple sum
import sys

a = float(sys.argv[1])
b = float(sys.argv[2])
c = a + b
print(c)

運行:

$ python3 sum.py 3 5.5

8.5

Python ê 基礎 -- Pu-lian理路運算

咱佇 if-statement 抑是 while-statement 中央有講著，in 需要一咧判斷式來決定欲行抑無愛。這个判斷式的計算結果，愛是 True/False 兩个其中一个。這種運算，號做 Pu-lian 理路 (Boolean Logic，華語:布林)。伊有專用的資料型態: Pu-lian 型態 (Boolean data type)。

Pu-lian 理路是數學的一咧必叉。數學伊的理論檢采真複雜。佇遮，咱先用程式的角度來看:佇啥物狀況，一咧算式會產生 True? 又閣是啥物狀況，會產生 False?

比較運算元(Comparison Operators)

首先，是比較運算元(Comparison Operators)，下跤是比較運算元的表:

運算元	意思
==	相仝
!=	無仝
<	較細
>	較大
<=	較細抑是相仝
>=	較大抑是相仝

咱來寫一咧程式:

#!/bin/bash

x = 5
y = 8

print("x == y:", x == y)
print("x != y:", x != y)
print("x < y:", x < y)
print("x > y:", x > y)
print("x <= y:", x <= y)
print("x >= y:", x >= y)

運行的輸出:

$ python3 boolean.py 
x == y: False
x != y: True
x < y: True
x > y: False
x <= y: True
x >= y: False

uì數字來算，簡單比較 in 事實上是相仝/大/細，和運算元的表示有仝款無? 若有就是 True, 無就是 False。像 x = 5 事實上比 y = 8 較細。所以 ==, >, >= 攏毋著，是 False。!=, <, <= 有合，都是 True。

阿若字串咧? 字串的相仝，就是兩的字串愛規枇一模一樣，連大寫，小寫攏愛仝款。A 和 a 是無仝--ê。有一字無對同(tâng)，就是無仝。字串敢會使比大細? 會用--得。逐个字母攏有伊的 ASCII 值，字串就是一字一字，uì 頭到尾比伊的 ASCII 值的大細:

>>> x='abcz'
>>> y='abdy'
>>> x > y
False
>>> x < y
True
>>> 

x 佮 y，比到第三的，c 的 ASCII code 比 d 細，所以 x 就是比 y 細，後壁的免閣比矣。
好佳哉，a-z 是按照順序若來若大，A-Z 嘛是。毋過，a-z 是比 A-Z 較大。

當然，變數若是承著 True/False，這个變數的型態就自動轉做 Boolean 型態。伊嘛是會使比大細: True 比 False 較大。

>>> x = True
>>> y = False
>>> x > y
True
>>> x < y
False

理路運算元(Logical Operators)

理路運算元是針對 True/False 的運算。伊本底是對數學的原理來--ê。毋過佇 Python，咱干焦了解三的基本的運算元就好:

運算元	意思	生做啥款
and	若兩的攏真，伊就是真	x and y
or	凊彩一个真，伊就是真	x or y
not	倒反，真成做假, 假个變真	not x

舉例來講，and 有四種狀況:

True and True   ==> True
True and False  ==> False
False and True  ==> False
False and False ==> False

干焦 x 和 y 攏是 "真", 伊的結果才是 "真"。仝款, or 是:

True or True   ==> True
True or False  ==> True
False or True  ==> True
False or False ==> False

not 只有兩款:

not True  ==> False
not False ==> True

就是顛倒反的意思，烏个變白，白个變烏。

阿，這有啥乜路用咧? 看這定義，真無聊。毋過，你佮伊敆做伙，就真好用。咱用進前

流程控制 while 的例:

#!/usr/bin/python3
i = 0
while i < 5:
    x = int(input("input an integer:"))

    if x % 2 == 0:
        continue
    if x % 3 == 0:
        continue

    print("This is NOT multiple of 2 or 3")
    i = i + 1

咱小共伊看一咧: x % 2 == 0 和 x %3 == 0 的 '=='，攏是 Pu-lian 運算，若是 True，後壁就躘--過，if-statement 內仝款是 continue。若按呢，敢會使共伊合--起來? 這兩的 if 的關係，是 or 的關係。所以，咱會使改做:

#!/usr/bin/python3
i = 0
while i < 5:
    x = int(input("input an integer:"))

    if x % 2 == 0 or x % 3 == 0:
        continue

    print("This is NOT multiple of 2 or 3")
    i = i + 1

按呢咱的程式，是毋是閣較屧貼咧。用 and, or, not 共你需要的條件，敆--起來，像 x > 100 and x < 1000 來揣出 100 到 1000 中央的數字，你就會使閣較幼路，來予你的程式照你 ê 向望來行。


這篇文章的一寡例，是參考網路頂一篇: "Understanding Boolean Logic in Python3"，逐个若有興趣，會使去遐踅踅咧!

Python ê 基礎 -- for loop

除了 while 圈圈 (while loop)，閣有另外一種 loop, 號做 for 圈圈(for loop)。伊嘛是會使佇仝一段 code 重覆行。毋過，伊有較媠氣的用法佮寫法，彼是 while loop 袂比--得。

for-statements 的用法，上基本是: 佇名單(Lists) 內巡田水，一个一个點名:

>>> animals = ['cat', 'parrot', 'dog']
>>> for w in animals:
...     print(w)
...
cat
parrot
dog

animals 是一个 List, for loop 逐擺 uì animals 中央(tiőng) 提一个出來，囥佇 w 變數--裡，才入去 for-statement 內底共伊印--出來。

這馬，你想欲印數字 1 到 100，你敢欲uì 1 開始，用手指頭仔建立一--咧 [ 1, 2, ..., 100] 的 List? 這个時陣，range() 這的函數就誠好用阿:

#!/usr/bin/python3
for i in range(1,101):
    print(i)

range(1, 101) 會自動產生一咧 1 到 100 的整數名單。愛注意: 101 無佇名單--裡。

range() 和 for 鬥--起來，就成做好用的工具。比如講，你想欲干焦雙數，你會使用

#!/usr/bin/python3
for i in range(2, 101, 2):
    print(i)

伊就會印出 2 到 100 的雙數。

若是 range(1, 101, 3)，就是 1, 4, 7,..,100。
若是 range(0, 101, 5)，就是 0, 5, 10,.., 100。

簡單講，range(start, end, diff) 就是產生數學講个 "算數(sǹg-siàu)數列(sòo-lia̍t)" (華語: 等差級數, 英文:Arithmetic progression)。

若是干焦 range(100)，伊會自動共起頭設做 0，產生 0 到 99 的整數名單。

若講較頂真个，毋是干焦 Lists，所有 "有順序的型態" (Sequence Type)，攏會使囥佇 for loop。Lists 本身嘛是一種 Sequence Type。後擺你會學著閣較濟 Sequence Type 的資料型態。現此時咱除了 Lists, 就干焦知影字串(Strings) 嘛是一款 Sequence Type:

sammy = 'Parrot is the boss of cats'

for letter in sammy:
   print(letter)

你會看著字母，一字一字印--出來。


while loop 和 for loop，理論上會當完全互相取代。所以，while 會使用的 break 來跳出箍輾，用 continue 來躘過紲--落來的 code，直接跳轉去 while 起頭，for loop 嘛仝款會使用 break，continue。

毋過，佇和像 List 這種 "有順序的型態" (Sequence Type) 的物件鬥陣使用時，你會當感受著 for loop 加真屧貼。

Python ê 基礎 - 流程控制 while

佇前一篇 Python ê 基礎 - 流程控制 if 中央, 咱的這的例，揣一咧數字，毋是 2, 嘛毋是 3 的倍數:

#!/usr/bin/python3
x = int(input("input an integer:"))

if x % 2 == 0:
    pass
elif x % 3 == 0:
    pass
else:
    print("This is NOT multiple of 2 or 3")

運行--起來，一擺干焦會使檢查一个數字，下一咧就愛重來。咱若有真濟數字欲處理，有夠麻煩。敢有法度予伊運行起來了後，就踮遐一直等咱問咧? 這時，咱共這的例小改一咧:

#!/usr/bin/python3
while True:
    x = int(input("input an integer:"))

    if x % 2 == 0:
        pass
    elif x % 3 == 0:
        pass
    else:
        print("This is NOT multiple of 2 or 3")

咱運行一咧:

$ python3 judge-non2-3.py 

input an integer:3

input an integer:8

input an integer:443

This is NOT multiple of 2 or 3

。。。

你會當連相紲輸入，你揤 ENTER 了後，伊隨閣問你下一咧數字是啥物? 程式袂煞鼓，伊會永遠問--落去。你若想欲煞戲，揤 Ctrl-C，用強--ê才跳會--離。

這就是 while 的作用: 仝款的 code，予伊跳--轉來，閣走一改。

這種效果，就敢若程式佇遐踅箍輪。所以，嘛有人共伊號做 while 圈 (while loop)。啥物時陣跳--出來? 就看 while 後彼咧判斷式是毋是真个(True)，變做假个 (False)

True 伊本身是保留字，嘛是出奇仔簡單的判斷式。伊永遠是真个，袂改變，就表示 while 內的 code，永遠佇遐輪迴，不得超生。若是想欲愛伊有機會跳--出來，你就愛寫會變化的判斷式，比如講:

#!/usr/bin/python3
i = 0
while i < 5:
    x = int(input("input an integer:"))

    if x % 2 == 0:
        pass
    elif x % 3 == 0:
        pass
    else:
        print("This is NOT multiple of 2 or 3")
    i = i + 1

按呢判斷式 i < 5，i uì 0 開始，一輾加 1。佇咧 i 比 5 較細的時，i < 5 算出來攏是 True。等到 i 成作 5，i < 5 就成做 False，就自動跳--出 while loop。若是無窮無盡的箍輾，干焦會使靠 Ctrl-C 這種共強--的方式跳--出來。


另外一種方式，是用 break共 while loop 拍予破，咱看下跤這的例:

#!/usr/bin/python3
i = 0
while True:
    x = int(input("input an integer:"))

    if x % 2 == 0:
        pass
    elif x % 3 == 0:
        pass
    else:
        print("This is NOT multiple of 2 or 3")
    
    if i > 5:
        break

    i = i + 1

伊的效果佮頂一个仝款，毋過，伊是用 if > 5 來拍破 while 圈。break 嘛是一咧關鍵字，伊的作用就是用來拍破箍輾。


閣有一款變化，是佮 while loop 縮予短，莫行到 while 的尾溜，這愛用保留字 continue。請看這的例:

#!/usr/bin/python3
i = 0
while i < 5:
    x = int(input("input an integer:"))

    if x % 2 == 0:
        continue
    if x % 3 == 0:
        continue

    print("This is NOT multiple of 2 or 3")
    i = i + 1

伊是佮頂个一模一樣的效果，毋過運用 continue 來躘--過後壁的程式。所以，若是 2 抑是 3 的倍數，就隨跳轉去 while 起頭遐重來，袂閣運行下跤的 print()，咱嘛免共 print() 囥佇 if-statement 內囉。


while-statements 是uì while 𤆬頭彼逝開始，一直到上尾溜。因為後壁的逐逝攏向正手爿勼--入來一咧 TAB。


若較斟酌看，你會發現 if-else-statement 裡的 pass 抑是 print()，毋但勼一个 TAB，in 勼兩的 TAB。這表示 pass/print() 是踮佇 while-statement 裡的 if-statement 裡。

遮其實予咱一咧寫程式的觀念，是真重要的觀念: 程式是有層次个。咱佇寫程式的時陣，寫每一逝 code，都愛真清楚伊是佇佗一棧。寫程式干焦佇起樓仔厝，每一棧攏愛清清楚楚，樓仔厝才會勇，才會媠。

就親像露西亞(Russia)尪仔，捘開外口的尪仔，內底是較細身的尪仔，一重閣一重，愈來愈細身。咱會使一咧 statement 內底包 statement，無限制包幾棧，只要你家己會記--得，莫亂--去。

Python ê 基礎 - 流程控制 if

if 是一的保留字爾爾，較十全的講法，愛講做 if statements，Statements 佇電腦科學裡，是表示會使完成一咧動作的上細的單元。你若欲寫 if, 愛共 if statements 攏寫予齊勻，袂使有落勾去，咱先來寫一咧簡單的程式, 先用凊彩一咧文字編輯程式，咱來寫一齣戲文, 我慣勢用 vim, 所以攏用 vi 來代表, 你會使用你家己佮意的。
咱這咧程式的名號做 "judge-even.py"

vi judge-even.py

vim 浮起桌頂了後，揤入下跤的內容:

#!/usr/bin/python3
y = input("input an integer:")
x = int(y)
if x % 2 == 0:
    print("is even")
print("END")

小可仔注意上尾算--來第二逝愛向正爿勼--入來，你會使用 TAB 鍵，抑是 4 的 SPACE 鍵。毋過，你若用 TAB 就固定用 TAB，用 SPACE 就固定用 SPACE，莫變來變去。

寫了後，揤 Save 儉--起來(若是 vim 是 :wq)，紲--落來予伊走看覓:

python3 judge-even.py

$ python3 judge-even.py 
input an integer:1
END
$ python3 judge-even.py
input an integer:2
is even
END
$ python3 judge-even.py
input an integer:4
is even
END

咱看著伊的回答，若是雙數，伊會加印一咧 "is even"。若是奇數就無。伊知影啥物數字是雙數。

佇頂懸的程式中，#!/usr/bin/python3 是一種固定的寫法，共電腦講這咧程式是用 python3 語言寫的程式。y = input("input an integer:") 是小等運行時，會問你問題，而且等你回答。佇遮，就是問你:"input an integer:", 等你揤入數字了後閣揤 ENTER，程式就繼續行。

x = int(y) 這逝小解說一咧。你敢會記个，咱捌講 Python 的值抑是變數攏有型態，input() 會共人的輸入攏當做字串(String)。因此 y 頭一擺出現就去承 input() 的輸入，伊的型態嘛是 String。毋過，咱欲用數字的型態才會做後壁的數學運算 %。int() 就是共字串 y 轉做數字囥入去 x 內底。

紲落來咱的主角 if 出現囉:

if x % 2 == 0:
    print("is even")

這兩逝就拄仔好組成一咧 if statement。佇 Python 的 if statements(其他足濟 statements 嘛仝款):
用 if 開始做頭一逝，紲--落來的每一咧勼入去的逝，攏是 statements 的一部分。佇遮 x % 2 == 0 若成立，伊就去印 "is even"。若無成立，就跳--過。你毋才會看著 2, 4有印，1無印。

if statement，是uì if 𤆬頭彼逝起頭開始算。
if 這逝，用 if 起頭，兩粒胡神屎的 : (colon, 華語:冒號) 囥佇尾溜，中方鋏一咧判斷式。佇遮，就是 x % 2 == 0。

閣紲落來的逝開始向正爿欲勼一咧 TAB! 一直到無閣勼--入來的逝，if statement 才結束。佇遮，干焦一逝勼--入來。所以這咧 if statement 攏總兩逝爾爾。

有時，咱毋是干焦欲印出雙數，嘛想欲印出奇數。一个數字，毋是雙个就是奇个，無彼種又閣雙又閣奇个，這時咱愛用 if-else statement:

#!/usr/bin/python3
y = input("input an integer:")
x = int(y)
if x % 2 == 0:
    print("is even")
else:
    print("is odd")
print("END")

若按呢，伊的輸出就會是:

$ python3 judge-even.py 
input an integer:1
is odd
END
$ python3 judge-even.py
input an integer:2
is even
END

有時，咱的條件毋但一咧，這个時陣，咱愛用 if-elif statements，咱修改抑是另外寫一咧戲文: vi judge-non2-3.py

#!/usr/bin/python3
x = int(input("input an integer:"))

if x % 2 == 0:
    pass
elif x % 3 == 0:
    pass
else:
    print("This is NOT multiple of 2 or 3")

運行:

$ python3 ./judge-non2-3.py 
input an integer:4
$ python3 ./judge-non2-3.py 
input an integer:9
$ python3 ./judge-non2-3.py 
input an integer:139
This is NOT multiple of 2 or 3

咱會當看著: 這咧程式會使予咱真緊就知影一咧數字，伊毋是 2, 抑是 3 的倍數。
頂--仔彼咧程式，若是 2 抑是 3 的 if-elif statment 內底，咱攏 pass，pass 佇 Python 裡，嘛是一咧保留字，伊的意思是:啥物攏莫做。佇遮的作用單純是欲造一咧 if-elif statement 爾爾。若無 pass, 就無勼排，if 抑是 elif statements 就無法度完成。因為咱對 2 抑是 3 的倍數無興趣，所以就予伊 pass。

Python ê 基礎 -- 流程控制 (Flow control)

流程控制 (flow control) 是欲予會當發揮 Python 閣較大力量的基礎。
佇咱學過 Strings，變數，名單(Lists)，算數的方法了後，咱會使開始做一寡較複雜的代誌。

進前咱介紹的程式，攏是一條腸仔直直迵到底，無轉斡，無踅箍輾。毋過，咱若欲應付真實的世界，是蓋複雜。干焦按呢，是無法度佇佇江湖走傱。

有時咱愛按照無仝的狀況來作做無仝的代誌，這時，就愛用 if。
有時，相sia̋ng (華語: 類似) 的代誌，咱干焦改一屑屑仔，其他攏仝款，咱會使用 while, 抑是 for，才免仝款的 code 寫幾若遍。

有流程控制的程式，就毋是像直迵的程式，逐逝你寫的程式碼攏會躘過，有一寡會跳過，有一寡會行幾若遍。親像遮的 if, while, for 等等的詞，是 Python 留--落來做流程控制用个保留字。袂使提來做變數使用，嘛袂使凊彩捎來就亂用。咱愛按照伊的使用方式:按怎開始，按怎結束，按怎寫。
後壁，咱就會分別來介紹 if, while, for 等等這寡流程控制的用法。

Python ê 基礎 -- 字串 (Strings)

字串(Strings)和數字仝款，是 Python 上基礎的資料型態。會使講，踮你頭一工使用 Python, 你就佇使用字串。m̄-koh，你無感覺niâ-niâ。每擺，你使用 print() 來印出結果的時陣，你就愛囥字串做伊的輸入。只是，有時就算你囥數字抑是 Lists，print() 會自動共你轉換做字串。

字串的表示方式有幾落種:單引句點 'xxxxx', 抑是雙引句點 "xxxx" 攏會使得。

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> "doesn't"  # ...or use double quotes instead
"doesn't"

你若用雙引句點，單引句點就hőng當做是普通字元。倒反過來，用單引號，雙引句點就是普通字元。
你若硬欲用單引號來鋏一咧內底有單引句點的字串，抑是雙引句點來鋏有雙引號的字串，就愛用倒斜線(\)。
\ 予人叫做逃走字元(Escape character)，意思是伊會予後壁彼咧字元的意義改變。本底佇引號內的意義，踮頭前加一咧逃走字元了後，意思就無仝。

>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "\"Yes,\" he said."
'"Yes," he said.'

踮頂懸，\ 予後壁的 ' 抑是 "， 失去引號的功能。而且，逃走字元嘛會予普通字元有特別的意思，比如講:

>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), \n is included in the output
'First line.\nSecond line.'
>>> print(s)  # with print(), \n produces a new line
First line.
Second line.

n 本來是普通字元，m̄-koh加上逃走字元，\n 是換逝的意思。這咧轉換，佇 print() 才會作用。

有時，你感覺用 \ 真歹看相，共字串變甲花巴哩貓，看袂清原在的字串生做啥物款，你會使ti̋字串進前加一字 r，意思是: 後壁字串攏是普通字元。

>>> print('C:\some\name')  # here \n means newline!
C:\some
ame
>>> print(r'C:\some\name')  # note the r before the quote
C:\some\name

閣有一種字串的表示，伊是用佇幾落逝的字串:

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

一爿連紲三的 "，就是共後壁的所有字，連換逝嘛囥--裡:

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

你就愛看斟酌:內底的 \ 無印--出來。彼 \ 是紲逝(你聽過啉酒有紲攤無?)，意思是一逝佮下跤彼逝是相連紲的仝一逝。你若無加 \，就會加印一咧換逝 \n 佇頭前。你會使試看覓

咱會使用 + 共字串接--起來。用 * 來予字串重複幾落擺:

>>> 3 * 'dog' + 'cat'
'dogdogdogcat'

若是兩的，抑是濟的字串前後排--咧，嘛是自動共鬥做伙:

>>> 'Py' 'thon'
'Python'

m̄-koh，這步袂使用佇變數共文字的字串:

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

字串嘛會使看做是 "字的 List"。你會使用 List 內底學著的手路，像 索引(Index)  :

>>> word = 'Python'
>>> word[5]
'n'
>>> word[-2]
'o'

抑是切片(Slicing):

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

m̄-koh，有一點佮 Lists 無仝: 字串是 "袂改得"(immutable)，所以下跤的運算是袂用得:

>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
  ...
TypeError: 'str' object does not support item assignment

你若是正經愛改，就是建立一的新的字串:

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

落尾手，有一咧本底就有的函數會使算字串的長度:

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

以上一寡例，是uì Python Tutorial 提來个，逐家有興趣會當去參考