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 提來个，逐家有興趣會當去參考

Python ê 基礎 -- 名單(Lists)

Python 的變數抑是值，攏有伊家己的型態。有時，咱想欲共一寡物件囥做伙。比如講，平方的數字，囥做一陣，欲按怎做? 這時，咱就愛用名單(Lists)這種資料型態(data type)。

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

佇頂懸的例，squares 是一咧變數，伊的型態是 Lists，內底囥 5 的數字。
Lists 是一種有順序 (sequence) 的型態。也就是講，這 5 的數字是照排隊个，1 是頭一个，4 是第 2 个，25 是第 5 个，嘛是上尾一个。欲按怎提內底的物咧? 就是愛用索引，伊的用法是

>>> squares[0]
1
>>> squares[1]
4
>>> squares[4]
25

squares 這咧名，後壁綴一對方括號 [  ]，內底囥索引。和咱慣勢的無仝，索引 0 是頭一个，1 是第二个，賰个攏是照順序加--起哩。

Lists 閣有一種特別的運算方式，號做切片(Slicing)。你會使共一的 Lists 想做一條si̍ok-pháng(Toast, 華語: 吐司)，你家己手提一支刀去切這條pháng，會使干焦切頭前薄縭絲一細片，嘛會使切頭前厚--厚厚一大片。抑是切後壁面，甚至對中央切一塊，攏會使得。

Slicing 是一種真趣味，閣真有路用的手路，咱愛共伊記牢牢。

>>> squares[-1]
25
>>> squares[-3]
[9]

-1 是對尾溜算--來頭一个，-3 是尾溜算來第三个。所以你知影，索引 負數是對尾仔算來。毋過，無 -0 這款物件。-1 就是上尾个。

>>> squares[0:1]
1
>>> squares[0:2]
[1, 4]
>>> squares[2:4]
[9, 16]

squares[0:1] 哪會共 squares[0] 仝呢? 原來，slice 的規則是 "前關後開"，也就是佇 : 後壁的數字，無算入--來，是予人切掉的部分。所以 [0:1] 就賰 slice[0], [2:4] 就賰 slice[2], slice[3]。

slice 切出來物件的若有超過一个，就變做另一个 Lists。

仝款，負數嘛會使用用佇 Slicing:

>>> squares[-3:]
[9, 16, 25]

: 後壁無寫，表示原來 Lists 有偌長，就共伊攏總囥--入來。

兩的 Lists, 會使用加號 + 共 in 敆--起來。

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

你嘛會使囥新的佇後壁:

>>> squares.append(36)
>>> squares
[1, 4, 9, 16, 25, 36]

抑是換掉內底的值:

>>> squares[2] = 100
>>> squares
[1, 4, 100, 16, 25]
>>> squares[0:3] = [ 33, 44, 55 ]
>>> cubes
[33, 44, 55, 16, 25]

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

Python ê 基礎 - 資料型態

Python 裡的變數，抑是值，攏有伊的型態。無仝的型態袂使濫做伙用。比論講，數字是一種型態，字串是另外一種型態，咱看一的例:

>>> 3 + 5
8
>>> 3 + "1"
Traceback (most recent call last):
  File "", line 1, in
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> 

3 + 5, 兩个攏是數字，Python 就乖乖仔共結果算出來.

3 + "1"，前一咧是數字，後一咧是字串，硬欲濫做伙，Python 就應你講袂使: "+" 這咧運算符號，袂當用佇 'int' and 'str'

型態有濟濟種，有數字 (Numbers), 字串 (Strings), 清單 (Lists, 台羅: lí-su-to)，....。當然，實際上分閣較濟，嘛較幼。親像數字，閣有分整數 (int) 和浮點數 (float)。毋過，有時型態較相倚的值，Python 會自動佮你轉。比如講:

>>> 3 + 7.1

10.1

>>> type(3)

<class 'int'>

>>> type(7.1)
<class 'float'>

>>> type(10.1)
<class 'float'>

頂懸的 type()，是用來檢查一咧值的型態。咱看著 3 是 int，7.1 是 float. 毋過，Python 袂講 3 + 7.1 毋著，伊自動佮 3 轉做 float 算出答案 10.1，嘛是 float
後擺，咱會沓沓仔介紹一寡基礎的資料型態。