# 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}')
```
Sign in with Wallet
Connect another wallet