---
# System prepended metadata

title: 2022-11-20 第二天 Python網路爬蟲應用實務班上課記錄
tags: [已轉移]

---

# 2022-11-20 第二天 Python網路爬蟲應用實務班上課記錄
###### tags: `python` `爬蟲`

## 判斷式
```python=
# 運算結果為True或False = 條件式
# 比較運算子，邏輯運算子，其他.... in

a = 3
b = 4 
print(a)
print(b)

if b == a:   # b > a 有成立，所以運算結果為True(不成立的話運算結果會是False)
    # 判斷式內的程式碼一定要縮排(PEP 8規格, 縮排建議為四個空白字元)
    print('Hi1')   # 判斷式成立時要執行的程式碼
    print('Hi2')   # 判斷式成立時要執行的程式碼
print('Hi5')

    # 無縮排的程式碼下面，不可以出先沒有意義的縮排程式碼
    # print('Hi3')   # 判斷式成立時要執行的程式碼

# 這行跟判斷式無關，因為他沒有縮排
print('Hi4')   # 判斷式成立時要執行的程式碼
```

#### 今天星期幾
```python=
import datetime  # 引入外部模組(非程式語言的內建功能)


# 0=星期一, 1=星期二 ... 6=星期日
w = datetime.date.today().weekday()  # 有小括號的叫做 函式或方法
print(w)

if w == 0:
    print('今天是星期一')

if w == 1:
    print('今天是星期二')

if w == 2:
    print('今天是星期三')

if w == 3:
    print('今天是星期四')

if w == 4:
    print('今天是星期五')

if w == 5:
    print('今天是星期六')

if w == 6:
    print('今天是星期日')
```

#### 判斷式分支
```python=
score = int(input('請輸入成績:'))

if score >= 90:   # 如果這裡成立, elif的條件式都不會再被判斷, elif是判斷式的分支
    print('優秀')
elif score < 90 and score >= 80: # else if
    print('不錯，再加油')
elif score < 80 and score >= 60:
    print('還可以')
elif score < 60:
    print('不及格')
```

#### else
```python=
num = int(input('請輸入一個整數:'))

if num % 2 == 0:
    print('偶數')
else: # 如果分支全部不成立，else的程式碼就會被執行
    print('奇數')
```

#### 單行if
```python=
num = int(input('請輸入一個整數:'))

# if num % 2 == 0:
#     print('偶數')
# else: # 如果分支全部不成立，else的程式碼就會被執行
#     print('奇數')

print('偶數' if num % 2 == 0 else '奇數')
```

#### 單行if不可以出現指派運算子
```python=
num = int(input('請輸入分數:'))

# if num < 60:
#     num += 10
# else: 
#     num += 0

num += 10 if num < 60 else 0

print('加分後的結果:', num)
```

#### 猜數字小遊戲
```python=
# a = 0

# # 如果迴圈條件式都不會產生False, 則迴圈不會停下，稱為無窮迴圈
# while a < 5:  # <--- 每次while迴圈裡面的程式碼全部執行完後會回到這個地方重新執行條件式，如果成立會再次執行while內程式碼
#     print(a)
#     a += 1   # 迴圈美執行一次, a就會被加1

# print('迴圈結束')


import random  # 引入亂數模組

a = random.randint(1, 5) # 產生1~5之間的隨機整數

print('隨機數:', a)

# 寫一個小遊戲，讓使用者猜1~5之間的數字，然後告知使否有猜對
player = int(input('請猜一個1~5之間的數字:'))

# 遊戲邏輯
if player == a:
    print('猜對了')
else:
    print('猜錯了')

# 單行if寫法
print('猜對了' if player == a else '猜錯了, 答案是:', a)

# f-string寫法
answer = '猜對了' if player == a else '猜錯了'
print(f'{answer}, 答案是:{a}')
```

## 迴圈
```
a = 1

# 如果迴圈條件式都不會產生False, 則迴圈不會停下，稱為無窮迴圈
while a <= 10:  # <--- 每次while迴圈裡面的程式碼全部執行完後會回到這個地方重新執行條件式，如果成立會再次執行while內程式碼
    print(a)
    a += 1   # 迴圈美執行一次, a就會被加1

print('迴圈結束')
```

#### 迴圈取出list資料並加總
```python=
a = [45, 63, 12, 8, 7]

index = 0
total = 0 # 存總和用

while index < len(a):
    print(a[index])
    total += a[index]  # total = total + a[index]
    index += 1

print(f'總和是: {total}')
```
#### 九九乘法表
```python=
# 2 x 1 = 2
# 2 x 2 = 4
# 2 x 3 = 6
# 2 x 4 = 8
# 2 x 5 = 10
# 2 x 6 = 12
# 2 x 7 = 14
# 2 x 8 = 16
# 2 x 9 = 18

index = 1

while index <= 9:
    print(f'2 x {index} = {2 * index}')
    index += 1
```

#### 兩層迴圈
```python=
# 2 x 1 = 2     3 x 1 = 3   ...  9 x 1 = 9
# 2 x 2 = 4     3 x 2 = 6   ...  9 x 2 = 18
# 2 x 3 = 6     3 x 3 = 9   ...  9 x 3 = 27
# 2 x 4 = 8     3 x 4 = 12  ...  9 x 4 = 36
# 2 x 5 = 10    3 x 5 = 15  ...  9 x 5 = 45
# 2 x 6 = 12    3 x 6 = 18  ...  9 x 6 = 54
# 2 x 7 = 14    3 x 7 = 21  ...  9 x 7 = 63
# 2 x 8 = 16    3 x 8 = 24  ...  9 x 8 = 72
# 2 x 9 = 18    3 x 9 = 27  ...  9 x 9 = 81

index1 = 2

while index1 <= 9:
    index2 = 1  # 把index2重設為1, 否則內層迴圈只會跑一次
    while index2 <= 9:  # 外層迴圈次數 x 內層迴圈次數
        print(f'{index1} x {index2} = {index1 * index2}')
        index2 += 1
    
    index1 += 1
```

#### break關鍵字，接受使用者輸入
```python=
# 寫一個程式，接收使用者輸入任意數量的整數，並將這些輸入存放到list
# 當使用者想要結束輸入的時候，可以輸入quit來結束

user_input = []  # 建立一個空的list

while True:
    user = input('請輸入一個整數:')

    if user == 'quit':
        break  # 直接結束迴圈，即使下面還有程式碼
    else:
        user_input.append(      int(user)      )   # 將轉型成數字的資料存到list內

print('輸入結束:', user_input)
```

#### 小小練習
寫一小遊戲，讓使用者猜1~5之間的數字，如果猜錯了，就讓使用者重新猜，一直到猜對了為止，結束後顯示使用者總共猜了幾次才猜對
```python=
# 寫一小遊戲，讓使用者猜1~5之間的數字，如果猜錯了，就讓使用者重新猜，
# 一直到猜對了為止，結束後顯示使用者總共猜了幾次才猜對

import random  # 引入亂數模組

a = random.randint(1, 5) # 產生1~5之間的隨機整數
num=0
while True:
    player = int(input('請猜一個1~5之間的數字:'))
    num+=1  # 次數加一

    if player == a:
        print('猜對了')
        print(f'總共猜了{num}次')
        break
    else:
        print('猜錯了,請再輸入一次')
```

#### continue
```python=
# continue: 當while迴圈內遇到continue指令時，會忽略剩下的程式碼，回到迴圈開頭重新判斷條件式後執行

a = [1, 2, 3, 4, 5]
index = 0

while index < len(a):
    if a[index] == 3:
        index += 1
        continue   # 跳到迴圈開頭，進行下一次的條件式判斷

    print(a[index])

    index += 1 
```
#### 另一個continue的範例
```python=
# 使用者輸入任意數量的整數，然後在畫面上顯示使用者所有輸入小於60的數字

scores = [] 

# 輸入分數的迴圈
while True:
    s = input('請輸入學生分數:')

    if s == 'quit':
        break
    else:
        scores.append( int(s) )
   
print('所有的學生分數: ', scores)

index = 0

while index < len(scores):
    if scores[index] >= 60:
        index += 1
        continue
    
    print(scores[index])
    index += 1
```

## for-in迴圈
```python=
# for-in 迭代迴圈 (從群集資料中一筆一筆取出資料)
a = [3, 4, 7, 9]   # len()
total = 0

for n in a:  # for-in迴圈會從a變數裡面取出每一筆資料，每次取出的資料會放在變數n裡面
    total += n

print('總和:', total)

# 1. 如果迴圈的執行次數可以預測，通常會用for-in迴圈
# 2. 如果迴圈次數無法預測，通常會選用while迴圈
```
#### for-in練習
```python=
# 使用for-in迴圈，將[34, 87, 66, 99, 103, 21, 6, 3]的偶數跟奇數分別加總後顯示出來
a = [34, 87, 66, 99, 103, 21, 6, 3] 
even = 0
odd = 0

for n in a:
    if n % 2 == 0:
        even += n
    else:
        odd += n
    
print(f'偶數總和: {even}')
print(f'奇數總和: {odd}')
```
#### range()方法可以產生連續數字
```python=
# range(start預設為0,end但不包含,step預設為1)  產生連續數字

a = list(   range(5)    ) # end = 5
print(a)

print(     list(      range(1, 6)      )        )

print(     list(      range(1, 6, 2)      )        )

for n in range(0, 10):
    print(n)
```
#### 練習
```python=
# 寫一程式，在畫面上顯示2~10每個數字的平方
for i in range(2, 11):
    print(i * i)
```

#### for comperhension
```python=
# 將 [9, 3, 5, 6, 11, 12] 內資料乘上10倍之後存到一個新的list後，將該list顯示到畫面上
# 例如輸出為: [90, 30, 50, 60, 110, 120]

# new_list = []

# for n in [9, 3, 5, 6, 11, 12]:
#     new_list.append(n * 10)

new_list = [  n * 10 for n in [9, 3, 5, 6, 11, 12]    ]

print(new_list)
```
#### for comperhension + 單行if
```python=
# 將 [9, 3, 5, 6, 11, 12] 內小於10的數字平方後存成新的list

# new_list = []

# for n in [9, 3, 5, 6, 11, 12]:
#     if n < 10:
#         new_list.append(n ** 2)
new_list = [n ** 2 for n in [9, 3, 5, 6, 11, 12] if n < 10]


print(new_list)
```

## 剪刀石頭布
```python=
import random

SCISSORS = 0 # 代表剪刀
STONE = 1    # 石頭
PAPER = 2    # 布

data = {0: '剪刀', 1: '石頭', 2: '布'}
pc = random.randint(0, 2)  # 電腦出拳

print(f'電腦出了: {data[pc]}')
player = int(input('請猜拳(0=剪刀, 1=石頭, 2=布): '))  # 玩家出拳

if pc == SCISSORS and player == STONE:
    print('你贏了')
elif pc == SCISSORS and player == PAPER:
    print('你輸了')
elif pc == STONE and player == SCISSORS:
    print('你輸了')
elif pc == STONE and player == PAPER:
    print('你贏了')
elif pc == PAPER and player == SCISSORS:
    print('你贏了')
elif pc == PAPER and player == STONE:
    print('你輸了')
else:
    print('平手')
```

## 猜數字遊戲
```python=
# 開發一個猜數字遊戲，玩法為:
#  - 從0~9之間隨機四個數字組合成一個四位數的數字(每個數字不會重複)
#  - 讓使用者猜這四個數字，直到猜中為止，並記錄總共猜了幾次
#  - 當使用者猜測時，如果該數字存在答案中，但位置不同，每猜到一個就以1B來告知，例如: 1234(答案), 猜0912的話為: 2B
#  - 當使用者猜測時，如果數字有在答案中，且位置一樣，就提供1A的提示，例如: 1234(答案), 猜1209的話為: 2A

import random

a = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

# 產生答案
random.shuffle(a)
answer = a[0] + a[1] + a[2] + a[3]
print(f'答案:{answer}')

guess_count = 0  # 紀錄猜了幾次

while True:
    player = input('請猜一個四位數的數字，數字不可重複:')
    guess_count += 1  # 次數加一

    # 檢查是否為四個數字
    if len(player) != 4:
        print('數字只能四個，請重新輸入')
        continue

    # 檢查是否為四個不重複的數字
    if len(set(player)) < 4:
        print('數字不可重覆, 請重新輸入')
        continue

    if answer == player:  # 猜對了，結束遊戲
        break

    how_many_A = 0
    how_many_B = 0

    if answer[0] == player[0]:
        how_many_A += 1

    if answer[1] == player[1]:
        how_many_A += 1

    if answer[2] == player[2]:
        how_many_A += 1
    
    if answer[3] == player[3]:
        how_many_A += 1

    if player[0] in answer and player[0] != answer[0]:
        how_many_B += 1

    if player[1] in answer and player[1] != answer[1]:
        how_many_B += 1

    if player[2] in answer and player[2] != answer[2]:
        how_many_B += 1
    
    if player[3] in answer and player[3] != answer[3]:
        how_many_B += 1

    print(f'{how_many_A}A{how_many_B}B, 請繼續猜, 已經猜了{guess_count}次')

print(f'猜對了，總共猜了{guess_count}')
```