Python on Wayne's blog | 偉恩的部落格 | 技術博客

【Pyenv】輕鬆管理 Python 版本的好工具！

Tue, 21 Mar 2023 00:00:00 +0000

Python 近 10 年來一直在演進，因此 Python 專案的開發也需要考慮版本的問題，特別是 Python 2 已經退休了，而現在的 Python 專案都以 Python 3 為主；然而有些公司內部的老舊專案仍以 Python 2 開發，因此開發者必須在 Python 2 與 3 之間進行切換。

如果你有 Python 版本切換上的困擾，那麼 pyenv 會是你的好朋友！

安裝 Pyenv

Mac 安裝 Pyenv

更新 Homebrew，並安裝 Pyenv 的相依套件：

1
2


brew update
brew install openssl readline sqlite3 xz zlib

透過 Homebrew 在 Mac 安裝 pyenv：

1

brew install pyenv

在 ~/.zshrc 加入 PYENV_ROOT 路徑和 pyenv init：

1
2
3


echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc
echo 'eval "$(pyenv init -)"' >> ~/.zshrc

重新啟動 shell，就完成囉！

1

exec "$SHELL"

Windows 安裝 Pyenv

使用 git 下載 pyenv-win：

1

git clone https://github.com/pyenv-win/pyenv-win.git "$HOME/.pyenv"

1-2. 亦可使用 pip 進行下載：

PowerShell：

1

pip install pyenv-win --target $HOME\\.pyenv

cmd：

1

pip install pyenv-win --target %USERPROFILE%\.pyenv

設定環境變數：

1
2
3
4


[System.Environment]::SetEnvironmentVariable('PYENV',$env:USERPROFILE + "\.pyenv\pyenv-win\","User")
[System.Environment]::SetEnvironmentVariable('PYENV_ROOT',$env:USERPROFILE + "\.pyenv\pyenv-win\","User")
[System.Environment]::SetEnvironmentVariable('PYENV_HOME',$env:USERPROFILE + "\.pyenv\pyenv-win\","User")
[System.Environment]::SetEnvironmentVariable('path', $env:USERPROFILE + "\.pyenv\pyenv-win\bin;" + $env:USERPROFILE + "\.pyenv\pyenv-win\shims;" + [System.Environment]::GetEnvironmentVariable('path', "User"),"User")

重新開啟終端機，就完成囉！

Linux 安裝 Pyenv

更新 apt-get 和安裝相依性套件：

1
2


apt-get update
apt-get install make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev xz-utils tk-dev libffi-dev liblzma-dev python-openssl git

利用 git 安裝 pyenv：

1

git clone https://github.com/pyenv/pyenv.git ~/.pyenv

在 ~/.bashrc 加入 PYENV_ROOT 路徑和 pyenv init：

1
2
3


echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n eval "$(pyenv init -)"\nfi' >> ~/.bashrc

關於其他 system 需要安裝的相依套件，可以參考這篇文件。

重新啟動 shell，就完成囉！

1

exec "$SHELL"

驗證 Pyenv 是否安裝成功？

1
2
3


pyenv --version

> pyenv 3.1.1

如何使用 Pyenv 切換 Python 版本？

查看 pyenv 可安裝的 Python 版本

1
2
3
4
5
6
7


pyenv install --list # 或 -l

>>> 3.7.6
>>> 3.7.7
>>> 3.8.0
>>> 3.8.1
>>> 3.8.2

安裝想選擇的 python 版本

1

pyenv install 3.7.7

查看 pyenv 已經安裝過的 python 版本

1
2
3
4


pyenv versions

>>> * system (set by /Users/wayne/.pyenv/version)
>>> 3.7.7

切換 Python 版本，可以選擇用 global、local 或 shell 來執行：

1
2
3


pyenv global 3.7.7
# 或 pyenv local 3.7.7
# 或 pyenv shell 3.7.7

global、local、shell 三者使用方法差異在於：

global：對應於全局。
local：對應於當前資料夾。
shell：對應於當前 shell。

優先順序是 shell ➡️ local ➡️ global。

Pyenv 切換 python 版本成功後，如何查看？

可以使用 python3 --version 來查看目前 python 版本，如果顯示的是你剛設定的版本，就代表成功囉！

1
2
3


python3 --version

> Python 3.10.1

Pyenv 如何切換成原始系統的版本？

可以使用 pyenv {{global}} system，system 代表原本系統的 python 版本，就可以切換回去囉！

1

pyenv global system

更新 Python 環境資訊

如果有使用 pip 安裝或解安裝 library 以及異動特定 version Python 的資料夾內容，必須使用 rehash 通知 pyenv 重新對應相關的使用連結。

1

pyenv rehash

物件導向的 Q&A - 以 Python 舉例

Tue, 21 Mar 2023 00:00:00 +0000

參考網站
 參考網站

物件導向

請問物件導向程式語言有哪些特點，能簡單說明給我聽嗎？

物件導向程式語言 (Object-Oriented Programming，OOP) 的特點有：

物件導向：OOP 程式語言是以物件 (Object) 為基礎建構程式，物件具有狀態 (state) 和行為 (behavior)。
繼承 (Inheritance)：OOP 程式語言允許一個類別 (class) 從另一個類別繼承屬性和行為。
多型 (Polymorphism)：OOP 程式語言允許物件在不同的情況下具有不同的行為。
封裝 (Encapsulation)：OOP 程式語言允許將物件的狀態和行為封裝在一起，保護物件內部狀態不被外界直接存取。
抽象 (Abstraction) ，OOP 程式語言將物件的實作細節與使用者分開，使用者只需要知道物件的公開介面而無需知道其實作。

請問物件具有狀態 (state) 和行為 (behavior)。這句話是什麼意思？能用 python 舉例嗎？

物件具有狀態 (state) 和行為 (behavior) 意思是物件具有兩種不同的特性，狀態代表物件的屬性，行為代表物件的方法。

舉例來說，若我們有一個類別叫做 Car，那麼這個類別可能有一些狀態屬性如 “color”、“speed”、“brand”，而行為可能有 “drive”、“brake”、“turn” 等方法。

用 python 程式碼來實現這個類別可能長得像下面這樣：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


class Car:
 def __init__(self, color, speed, brand):
 self.color = color
 self.speed = speed
 self.brand = brand

 def drive(self):
 self.speed += 10

 def brake(self):
 self.speed -= 10

 def turn(self, direction):
 print(f"The car is turning {direction}")

my_car = Car("red", 0, "Tesla")
my_car.drive()
my_car.turn("left")
print(my_car.speed) # 10

上面這個例子中，類別 Car 有三個狀態屬性 color、speed、brand 以及三個行為方法 drive()、brake()、turn()。

透過創建一個實體物件 my_car = Car("red", 0, "Tesla") 來使用這些方法及屬性。

請問你能用上面的 Car class 寫一個繼承的範例給我看嗎？

當然可以，我們可以創建一個新的類別來繼承 Car 類別，讓新類別繼承 Car 類別的屬性和方法。

例如我們可以創建一個新的類別 ElectricCar 繼承 Car 類別，並且在 ElectricCar 類別中加入新的屬性和方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class ElectricCar(Car):
 def __init__(self, color, speed, brand, battery_size):
 super().__init__(color, speed, brand)
 self.battery_size = battery_size

 def charge(self):
 print("The electric car is charging...")

 def drive(self):
 if self.battery_size > 0:
 self.speed += 20
 self.battery_size -= 10
 else:
 print("The battery is empty, please charge the car.")

my_electric_car = ElectricCar("blue", 0, "Tesla", 100)
my_electric_car.drive()
my_electric_car.drive()
my_electric_car.drive()
print(my_electric_car.speed) # 60
print(my_electric_car.battery_size) # 70

在這個例子中，ElectricCar 類別繼承了 Car 類別的所有屬性和方法，並且定義了新的屬性 battery_size 和方法 charge()。

透過使用 super() 函式可以繼承 Car 類別的 init 方法。

使用 my_electric_car = ElectricCar("blue", 0, "Tesla", 100) 來創建實體物件，可以使用 ElectricCar 類別的新屬性及方法。

請問你能用上面的程式碼繼續舉例多型的用法給我看嗎？

當然可以，多型 (Polymorphism) 是指物件在不同的情況下具有不同的行續。一般來說我們可以使用繼承的類別來實現多型。

以上面程式碼為例，我們可以用 ElectricCar 類別繼承 Car 類別，並重新實現 drive 方法來實現多型的用法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


class ElectricCar(Car):
 def __init__(self, color, speed, brand, battery_size):
 super().__init__(color, speed, brand)
 self.battery_size = battery_size

 def charge(self):
 print("The electric car is charging...")

 def drive(self):
 if self.battery_size > 0:
 self.speed += 20
 self.battery_size -= 10
 else:
 print("The battery is empty, please charge the car.")

class GasCar(Car):
 def __init__(self, color, speed, brand, gas_level):
 super().__init__(color, speed, brand)
 self.gas_level = gas_level

 def fill_gas(self):
 self.gas_level = 100

 def drive(self):
 if self.gas_level > 0:
 self.speed += 15
 self.gas_level -= 10
 else:
 print("The gas is empty, please fill the gas.")

my_electric_car = ElectricCar("blue", 0, "Tesla", 100)
my_gas_car = GasCar("black", 0, "Ford", 60)

def drive_car(car):
 car.drive()

drive_car(my_electric_car)
drive_car(my_gas_car)

print(my_electric_car.speed) # 20
print(my_gas_car.speed) # 15

在這個例子中，我們在 ElectricCar 和 GasCar 類別中都重新實現了 drive 方法，並且在 drive_car 函數中只接受 Car 的類別，可以看到在 drive_car 函數中傳入不同類別的實體物件會執行不同的 drive 行為。

這就是多型的用法，可以讓同一個函數或方法支援多種類別的物件，而不需要為每一種類別都寫一個不同的函數或方法。這樣可以增加程式碼的彈性和可讀性。

我們可以在設計類別時統一實現某些方法，並讓類別可以自行選擇如何實現該方法，這樣就可以讓程式碼更具彈性和靈活性。

請問你能用上面的程式碼繼續舉例封裝的用法給我看嗎？

當然可以，封裝 (Encapsulation) 是指將物件的狀態和行為封裝在一起，保護物件內部狀態不被外界直接存取。

在 Python 中，我們可以使用 _ 或 __ 來表示私有變數和方法，這樣的變數和方法只能在類別內部存取。

例如，我們可以把 ElectricCar 類別中的 battery_size 屬性改成私有變數：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class ElectricCar(Car):
 def __init__(self, color, speed, brand, battery_size):
 super().__init__(color, speed, brand)
 self.__battery_size = battery_size

 def charge(self):
 print("The electric car is charging...")

 def drive(self):
 if self.__battery_size > 0:
 self.speed += 20
 self.__battery_size -= 10
 else:
 print("The battery is empty, please charge the car.")

 def get_battery_size(self):
 return self.__battery_size

my_electric_car = ElectricCar("blue", 0, "Tesla", 100)
print(my_electric_car.get_battery_size()) #100

在這個例子中，ElectricCar 類別的 battery_size 屬性被定義為私有變數，只能在類別內部存取。如果外部直接存取該變數的話會產生錯誤。

而我們可以使用私有變數所對應的公有方法 get_battery_size() 來存取私有變數。這樣可以保護類別內部狀態不被外部直接存取，也可以通過公有方法給外部提供適當的存取權限。

你說在 Python 中，我們可以使用 _ 或 __ 來表示私有變數和方法，請問 _ 跟 __ 差在哪裡？

用一個底線 _ 表示私有變數和方法並不會真正的阻止外部存取，只是約定俗成的寫法。
而使用兩個底線 __ 來表示私有變數和方法會真正的封裝，阻止外部存取，並且子類別也無法存取，更能保證封裝性。

請問你能用上面的程式碼繼續舉例抽象的用法給我看嗎？

可以，以下是之前提到的 Car、ElectricCar、GasCar 程式碼使用抽象類別和抽象方法的寫法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


from abc import ABC, abstractmethod

class Car(ABC):
 def __init__(self):
 self.__year_model = 0
 self.__make = ""
 self.__speed = 0

 @abstractmethod
 def drive(self):
 pass

class ElectricCar(Car):
 def __init__(self):
 super().__init__()
 self.__battery_type = ""

 def set_battery_type(self, battery_type):
 self.__battery_type = battery_type

 def get_battery_type(self):
 return self.__battery_type

 def drive(self):
 print("Electric car is driving.")

class GasCar(Car):
 def __init__(self):
 super().__init__()
 self.__fuel_type = ""

 def set_fuel_type(self, fuel_type):
 self.__fuel_type = fuel_type

 def get_fuel_type(self):
 return self.__fuel_type

 def drive(self):
 print("Gas car is driving.")

#create object
car = ElectricCar()
car.drive()

car = GasCar()
car.drive()

在這個範例中，Car 類別是一個抽象類別，它定義了一個抽象方法 drive()。ElectricCar 和 GasCar 類別都繼承自 Car 類別，並實現了 drive() 方法。

這樣的設計可以達到封裝的目的，同時也可以達到多型的目的。並且因為 Car 類別是抽象類別，所以不能直接建立 Car 類別的物件，只能用它的子類別來建立物件。

有了繼承的特點為何還需要抽象？感覺不出這兩者有何差別？

繼承的作用是讓子類別可以繼承父類別的屬性和方法，使得子類別可以共用父類別的程式碼，達到代碼重用的目的。這樣可以讓程式碼更簡潔，並且可以讓子類別擁有父類別的特徵。

而抽象則是讓類別有共同的特徵和行為，抽象類別不能被實例化，而是用來被其他類別繼承。抽象類別中可以定義抽象方法(abstract method)和普通方法，抽象方法只有定義，沒有實現。在子類別中必須實現抽象方法。這樣可以確保所有子類別都有相同的行為，但實現可能不同。

在車的例子中，我們可以用繼承的方式，讓 ElectricCar 和 GasCar 繼承 Car 的屬性，例如 make、model、year_model。而用抽象的方式，我們可以在父類別 Car 中定義一個 drive 方法，並在子類別中實現 drive 方法，這樣可以確保所有車子都有 drive 這個行為。

實際業務上來說，何時會想用繼承何時會想用抽象？

實際業務上，繼承和抽象會根據實際需求而使用。

繼承：

要繼承另一個類別的特徵和行為時，就可以使用繼承。例如，你有一個車類別，並且你需要創建一個電動車和汽油車類別，這兩個類別都有許多相同的特徵和行為，那麼你可以使用繼承，將車類別的特徵和行為繼承到電動車和汽油車類別中。

抽象：

當你有一些類別需要共用同一個介面或行為時，就可以使用抽象。例如，你有一個車類別，並且你需要創建多種不同類型的車，例如電動車、汽油車、柴油車等，這些車都需要有 drive 這個行為，那麼你可以使用抽象類別來定義一個 drive 方法，並在電動車、汽油車、柴油車等類別中實現 drive 方法，這樣就可以確保所有車都有 drive 這個行為。

總結來說，繼承是用來繼承父類別的特徵和行為，而抽象則是用來確保類別具有共同的特徵和行為。

請問你說的特徵具體來說是指什麼東西？

特徵是指類別所具有的屬性和行為，包括資料和函式。

屬性是指類別中的變數，它們用來儲存類別中的資料。例如在之前的例子中，Car 類別中的屬性有 make、model、year_model。

而行為是指類別中的函式，它們用來定義類別的動作。例如在之前的例子中，Car 類別中的行為有 drive、get_make、get_model 等。

這些屬性和行為就是類別的特徵。

請問物件導向為何叫做物件導向？

物件導向程式語言之所以叫做物件導向是因為它重視物件 (Object) 這個概念。在物件導向程式語言中，程式設計師可以使用類別 (Class) 來定義物件的共性，並使用物件來實例化類別。

物件具有狀態 (state) 和行為 (behavior)，並且可以互相之間進行溝通和互動。透過物件導向程式設計，可以更加形象地模擬實際世界中的事物，並且更加容易維護和擴展程式碼。

【Python】裝飾子 (decorator) 教學

Thu, 16 Mar 2023 00:00:00 +0000

參考網站
 參考網站
 參考網站
 參考網站
 參考網站

Python 的 decorator (或稱: 裝飾子) 是一個非常有用的功能，它的重要程度可以說是沒用過或不會用 decorator 的人就等於沒學過 Python，甚至在一些常見的框架(Framework)，例如 Flask、FastAPI、Django 都提供各種方便的 decorator 供大家使用。

這麼重要的東西，肯定是闖江湖都會用到的金創藥啊！

但如果你剛接觸 Python 就看到類似以下裝飾子的範例，絕對會腦袋打結，為什麼函式前面還要加個 @debug 還有 @cache，而且還很神奇能運作：

1
2
3
4


@debug
@cache
def sum(a, b):
 return a + b

本文就教大家如何理解 Python 的 decorator！

本文 python 環境

Python 3

什麼是 Decorator

簡單來說，Decorator 是程式語言的設計模式，也是一種特殊的 function（把被裝飾函式當做參數傳入裝飾器函式，再把被裝飾函式傳回），透過 Decorator 可以將加上 Decorator 的 function 加上更多能力，重複利用許多程式碼。而在 Python 中我們則是使用 @ 當做 Decorator 使用的語法糖符號（語法糖指的是簡化寫法）。

開始之前

剛學程式的人，如果想要除錯 1 個函式(function)，大多都會選擇在函式內加上 print 吧，通常都會將傳入值與回傳值都列印出來，例如：

1
2
3
4
5


def sum(a, b):
 print('a =', a)
 print('b =', b)
 print('a + b =', a + b)
 return a + b

然而，這樣子只能針對 sum 這個函式除錯，而且每次都要做侵入式的修改，相當不便…。

我們都知道 Python 的傳入與回傳值可以是函式，那麼也許可以做一個函式叫 debug，然後接受任何函式傳入，並且把我們的 debug 功能加在裡面，這樣就能夠針對任何函式進行除錯，例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def sum(a, b):
 return a + b

def debug(func):
 print('接到 func', func.__name__)
 # 我想在這裡 debug
 return func

debug_sum = debug(sum)
debug_sum(1, 2)

p.s. 每個 function 都有 1 個屬性 __name__ 可以取得函式名稱

執行結果：

1

> 接到 func sum

可是上述範例 debug 函式執行過程並沒有辦法呼叫傳入的 func，因為我們無法攔截到未來使用者怎麼呼叫傳進去的 func (也就是 sum 函式），也就是 debug_sum(1, 2) 沒攔截到傳進去的 1、2，所以根本無法完成除錯的目標，但好消息是我們可以攔截到 sum 被傳進去了。

怎麼解決攔截傳入參數的部分？

很簡單！做個中間人！

我們可以把傳進 debug 函式的 func 再用 def 包裝在 1 個新的函式裡面，這個新的函式要負責接受任何參數，然後轉一手再代入先前傳進來的函式，最後我們再將新包裝過的函式回傳回去，於是程式碼會變成這樣：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


def sum(a, b):
 return a + b

def debug(func):
 print('接到 func', func.__name__)
 def wrapper(*args, **kwargs):
 print('幫忙代入 args', args)
 print('幫忙代入 kwargs', kwargs)
 func(*args, **kwargs)
 return wrapper

debug_sum = debug(sum)
debug_sum(1, 2)
print('debug_sum', debug_sum)

執行結果：

1
2
3
4


> 接到 func sum
> 幫忙代入 args (1, 2)
> 幫忙代入 kwargs {}
> debug_sum <function debug.<locals>.wrapper at 0x107966430>

耶！從上面執行結果看到我們透過再包裝 1 層函式，就能攔截傳入參數的部分。從執行結果也可以看到呼叫完 debug 函式，所得到的 debug_sum 其實就是那個新包裝好的函式，因此上述範例的呼叫 debug_sum 的方式可以進一步濃縮為 1 行：

1

debug(sum)(1, 2)

不過上述範例還是沒有列印 sum 執行結果的部分，所以可以再進一步改成：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


def sum(a, b):
 return a + b

def debug(func):
 print('接到 func', func.__name__)
 def wrapper(*args, **kwargs):
 print('幫忙代入 args', args)
 print('幫忙代入 kwargs', kwargs)
 result = func(*args, **kwargs)
 print(func.__name__, '執行結果', result)
 return wrapper

debug_sum = debug(sum)
debug_sum(1, 2)

執行結果：

1
2
3
4


> 接到 func sum
> 幫忙代入 args (1, 2)
> 幫忙代入 kwargs {}
> sum 執行結果 3

耶！完美！

完成 debug 函式之後，你就可以任意 debug 函式，而且不需要做到任何侵入性的修改，例如 debug print 函式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


def debug(func):
 print('接到 func', func.__name__)
 def wrapper(*args, **kwargs):
 print('幫忙代入 args', args)
 print('幫忙代入 kwargs', kwargs)
 result = func(*args, **kwargs)
 print(func.__name__, '執行結果', result)
 return wrapper

debug_print = debug(print)
debug_print(1, 2, '3')

看到這邊，大家應該就會了解 Python decorator 在做什麼 - 接收 1 個函式後加工並包裝成 1 個新的函式！

`@` 語法糖(Syntactic sugar)

也由於這種 decorator 的模式很好用，所以 Python 提供 1 種特殊的語法 @ 可以讓我們將 debug_sum = debug(sum) 簡化為：

1
2
3


@debug
def sum(a, b):
 return a + b

這種語法就被稱為是 1 種語法糖，太好吃了，而且會上癮…。

所以這種接受接一個函式作為參數，然後返回一個新的函式的函式都可以在前面加上 @ 作為裝飾子使用，例如下列範例的 timeit （測量函式執行時間）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


import time

def timeit(func):
 def wrapper():
 s = time.time()
 func()
 print(func.__name__, 'total time', time.time() - s)
 return wrapper

@timeit
def sleep_10s():
 time.sleep(10)

sleep_10s()

執行結果：

1

> sleep_10s total time 10.000677108764648

多個裝飾子的執行順序

由於裝飾子非常好用，所以你很有可能會看到類似的程式碼片段存在專案之中：

1
2
3
4
5
6


@timeit
@api
@auth_required
@cache
def get_profile():
 # ...(略)

這時候頭就大了，到底要怎麼理解多個裝飾子的執行順序？到底是 @timeit 會先執行？還是 @cache 會先執行呢？

為了解答這個問題，我們可以將 decorator 的數量簡化至 2 個，例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


def deco1(func):
 def wrapper():
 print('deco1')
 func()
 print('deco1 end')
 return wrapper

def deco2(func):
 def wrapper():
 print('deco2')
 func()
 print('deco2 end')
 return wrapper

@deco1
@deco2
def main():
 print('main')

main()

上述執行結果如下：

1
2
3
4
5


> deco1
> deco2
> main
> deco2 end
> deco1 end

其實從執行結果可以看出，最外層的 decorator 會最先執行，最晚結束。

但其實也不難理解，因為 decorator 是一層包一層的形式，所以只要把一層包一層的圖畫出來，再畫一條直線從上往下貫穿，我們就可以理解其執行與結束順序了：

functools.wraps

先前章節提到 decorator 會接受接一個函式作為參數，然後返回一個新的函式的函式，這其實會有 1 個小小問題產生，就是被包裝的函式的名字與 doc string 都會消失，例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import time

def timeit(func):
 def wrapper():
 s = time.time()
 func()
 print(func.__name__, 'total time', time.time() - s)
 return wrapper

@timeit
def sleep_10s():
 """sleep 10s"""
 time.sleep(10)

print('func', sleep_10s.__name__)
print('doc', sleep_10s.__doc__)

執行結果：

1
2


> func wrapper
> doc string None

從上述執行結果可以看到 sleep_10s 的名字與 doc string 都不是我們所預期的樣子，原因在於 decorator 其實回傳新的函式，所以這些非預期的值都數於新回傳的函式，這樣就對開發協作者比較不友善了…。

如果要修好這個問題，可以用 functools.wrap 再包裝一次回傳的函式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


import time
from functools import wraps

def timeit(func):
 @wraps(func)
 def wrapper():
 s = time.time()
 func()
 print(func.__name__, 'total time', time.time() - s)
 return wrapper

@timeit
def sleep_10s():
 """sleep 10s"""
 time.sleep(10)

print('func', sleep_10s.__name__)
print('doc', sleep_10s.__doc__)

執行結果如下，可以看到 sleep_10s 的函式名稱與 doc string 又恢復正常了：

1
2


> func sleep_10s
> doc string sleep 10s

實際上 functool.wraps 可以視情況自行決定要不要加，如果是一定要保留 doc string 或原本的函式名稱的話，就可以用 functool.wraps，否則其實不加也不影響日常使用。

類別裝飾子(Class-based decorators)

其實，不只有函式(function)能夠當裝飾子，類別(class)也能改裝成裝飾子。

類別寫成的裝飾子就稱為 class-based decorator。

實作 classed-based decorator 的方法雖然不如以 function 方式實作直覺，但也很簡單，只要實作 __init__() 方法接受傳入函式，並且實作 __call__ 方法呼叫被傳入的函式即可，例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class ClsDeco:
 def __init__(self, func):
 self.func = func

 def __call__(self):
 print("before calling", self.func.__name__)
 self.func()
 print("after calling", self.func.__name__)

@ClsDeco
def say_hello():
 print("Hello!")

say_hello()

執行結果：

1
2
3


> before calling say_hello
> Hello!
> after calling say_hello

前述範例其實等同於下列形式，也就是 ClsDeco(say_hello)() 的部分：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class ClsDeco:
 def __init__(self, func):
 self.func = func

 def __call__(self):
 print("before calling", self.func.__name__)
 self.func()
 print("after calling", self.func.__name__)

def say_hello():
 print("Hello!")

ClsDeco(say_hello)()

這就是關於 classed-based decorator 的簡單介紹。

更複雜的 decorator - 可設定參數的裝飾子

學會 decorator 與 class-based decorator 之後，還可以進一步製造出更複雜的裝飾子，譬如接受參數設定的裝飾子，例如下列範例 @retry 裝飾子接受參數 max=3，改變裝飾子的行為：

1
2
3


@retry(max=3)
def get_stock_price():
 pass

要怎麼解讀 @retry(max=3) 呢？其實就是 1 個函數回傳另 1 個裝飾子：

1
2
3
4
5


r = retry(max=3)

@r
def get_stock_price():
 pass

實作上就類似下列的程式碼：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


def retry(max=1):
 class Wrapper:
 def __init__(self, func):
 self.func = func

 def __call__(self):
 retried = 0
 while retried < max:
 try:
 self.func()
 except Exception:
 retried += 1
 print('Failed. Going to try again (', retried, ')')
 else:
 break
 return Wrapper

@retry(max=3)
def get_stock_price():
 raise ValueError

get_stock_price()

執行結果如下：

1
2
3


> Failed. Going to try again ( 1 )
> Failed. Going to try again ( 2 )
> Failed. Going to try again ( 3 )

從上述結果可以看到，我們藉著 1 個函數回傳另 1 個裝飾子的做法，成功讓裝飾子具有可設定的特性，不過相對也讓程式變了複雜一點。

以上就是關於更複雜的 decorator 的介紹。

總結

Decorator 是一個非常實用的模式/功能，它可以讓我們輕鬆地在既有基礎上疊加額外的功能，除了使程式碼更加簡潔、易讀之外，還可以增加複用性。

不過由於 Decorator 可以不斷疊加的特性，甚至是可以多重包裝一個函式，有時候會適得其反，造成程式碼閱讀困難，使用上還是建議盡量保持單純為佳。

如果你還沒有在 Python 專案中使用 decorator，現在是時候了！

智慧商業Python數據分析與應用班(版本3.*)

Sun, 15 Mar 2020 00:00:00 +0000

指導教師：`李菊權(0921-763623)`

python(版本3.8.2)

安裝至環境變數(Windows10)

Add Python 3.8 to PATH

若沒勾選，需自行到(以下兩種方式進入環境變數設定)

本機 ▸ 內容
控制台 ▸ 系統及安全性 ▸ 系統
進階系統設定 ▸ 系統內容 ▸ 進階 ▸ 環境變數
將python.exe目錄新增至環境變數
(PATH ▸ 編輯 ▸ 新增)

1
2
3
4
5
6
7
8
9


### python.exe預設位置(Windows10)
C:\Users\user\AppData\Local\Programs\Python\Python38-32\

### 找python.exe(Windows10)
where python.exe
> C:\Users\user\AppData\Local\Programs\Python\Python38-32\python.exe

### 將以下此段路徑新增至環境變數
### C:\Users\user\AppData\Local\Programs\Python\Python38-32\

Python介紹

Python 動態型別(強型別)/直譯式語言

動態型別：使用變數時不須預先宣告型別，依照設定之值而變。
強型別：不同型別無法進行運算。
直譯式語言：不須經過編譯即可直接執行。
副檔名：.py

IDLE

python官方提供的IDE

Python Shell (REPL)

Python Shell (REPL) 模式

進入Python Shell (REPL)

1
2


python
>>> # 開頭變成>>>代表進入python shell

離開Python Shell (REPL)

1

quit()

清除當前Python Shell Screen

1

cls

Python Plugin

作業系統模組 - os

載入模組

1

import os # 匯入系統模組

打開系統的指定程式 - os.system(程式名)

1
2


os.system("mspaint") # 打開小畫家
os.system("calc") # 打開計算機

列出目錄中所有檔案 - os.listdir(路徑)

1

os.listdir("./") # 當前目錄

取得當前目錄 - os.getcwd()

1

os.getcwd()

檢查目錄是否存在 - os.path.isdir(目錄路徑)

1
2
3
4
5
6


# 檢查當前位置是否存在export目錄
testDir = os.getcwd() + "\\export"
if os.path.isdir(testDir):
 print("exist")
else:
 print("not exist")

檢查檔案是否存在 - os.path.isfile(檔案路徑)

1
2
3
4
5
6


# 檢查當前位置是否存在text.txt
testFile = os.getcwd() + "\\test.txt"
if os.path.isfile(testFile):
 print("exist")
else:
 print("not exist")

檢查路徑是否存在 - os.path.exists(目錄路徑)

1
2
3
4
5


testPath = "\\etc\\hosts"
if os.path.exists(testPath):
 print("exist")
else:
 print("not exist")

於指定路徑建立目錄 - os.mkdir(路徑+目錄名)

1
2
3
4


# 檢查當前目錄是否存在export目錄，沒有則建立
new_dir = os.getcwd() + "\\export"
if os.path.isdir(new_dir) != True:
 os.mkdir(new_dir)

影像處理模組 - PIL(Pillow)

安裝 PIL 模組

1
2


### 使用 pip 安裝 PIL 模組
pip install PIL

載入模組

1

from PIL import Image

打開圖檔 - .open(圖檔路徑)

1

im = Image.open("test.jpg")

存檔 - .save("檔名", “[格式]”, [quality = 壓縮值(通常設定80或90)], [subsampling = 0])

1
2
3
4
5


im = Image.open("test.jpg") # 打開圖檔
im.save("test1.png") # 轉存成png

# 轉存成png並壓縮品質:80
im.save("test2.png", quality = 80, subsampling = 0)

PIL常用的圖檔格式

格式
`BMP`、`EPS`、`GIF`、`JPEG`、`JPG`、`PNG`、`TIFF`、`PDF`

調整圖片尺寸 - .resize((寬, 高) [, filter(濾波)設定])

不會自動等比例縮放，需等比例縮放得自行計算比例。

1
2
3
4
5
6


im = Image.open("test.jpg") # 載入圖片
width = 400 # 指定寬度為 400px
ratio = float(width)/im.size[0] # 計算長寬比
height = int(im.size[1]*ratio) # 高度依長寬比計算並調整
nim = im.resize((width, height), Image.BILINEAR)
nim.save("test_resized.jpg") # 另存調整尺寸後的圖檔

濾波設定值

filter(濾波)	說明
`NEAREST`	`預設濾波`，從輸入的圖檔中選取最近的像素作為輸出像素。
`BILINEAR`	雙線性內插濾波，再輸入圖像的 `2*2` 矩陣上進行線性插值。
`BICUBIC`	雙立方濾波，再輸入圖像的 `4*4` 矩陣上進行立方插值。
`ANTIALIAS`	平滑濾波，對所有可以影響輸出像素的輸入像素進行高質量的重採樣濾波，以計算輸出像素值。

圖像繪製工具 - turtle

1
2
3
4
5
6
7
8
9


import turtle # 匯入圖像繪製工具turtle
turtle.showturtle() # 打開turtle
turtle.forward(100) # turtle往前100
turtle.left(90) # 左轉90度
turtle.circle(30) # 畫半徑30的圓
turtle.reset() # 重新設定
turtle.goto(30,50) # 移動到指定座標
turtle.penup() # 將筆提起
turtle.pendown() # 將筆放下

數字模組 - math

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import math
print(math.pi) # 取圓周率
>>> 3.141592653589793
print(math.radians(45)) # 取弧度45度
>>> 0.7853981633974483
print(math.sin(math.radians(45))) # 取sin(45度)
>>> 0.7071067811865476
print(math.factorial(5)) # 取階乘(5為1*2*3*4*5)
>>> 120
print(math.gcd(27, 9)) # 取最大公因數
>>> 9

亂數模組 - random

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import random

random.random() # 取0~1的隨機數
>>> 0.5672829418362756

random.randint(1, 10) # 取1~10的隨機數
>>> 4

K = [2,6,9,8,14,20,30] # 先設定一個陣列
random.shuffle(K) # 打亂陣列排列(直接操作該陣列)
print(K)
>>> [30, 9, 2, 6, 14, 20, 8]

浮點數精度模組 - Decimal

1
2
3
4
5
6
7


print(0.1+0.1+0.1)
>>> 0.30000000000000004

# 使用Decimal模組來避免浮點數精度問題
from decimal import Decimal
print(Decimal("0.1")*3)
>>> 0.3

抓DOS模式後方參數的模組 - sys

1
2
3


# sysArgv.py
import sys
print(sys.argv)

1
2
3


# 於DOS模式執行sysArgv.py並於後方帶參數A、B、C
python sysArgv.py A B C
>>> ['sysArgv.py', 'A', 'B', 'C']

資料庫模組 - sqlite3

載入模組

1

import sqlite3

連接資料庫 - .connect()

`資料庫連結`.connect(`資料庫名稱`)

1
2


import sqlite3
conn = sqlite3.connect("test.sqlite")

Cursor指標指到資料庫(以便使用資料庫物件操作資料庫) - .cursor()

`資料庫物件` = `資料庫連結`.cursor()

1
2
3


import sqlite3
conn = sqlite3.connect("test.sqlite")
cursor = conn.cursor()

執行SQL語法 - .execute()

`資料庫物件`.execute(`SQL語法`)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import sqlite3
conn = sqlite3.connect("test.sqlite")
cursor = conn.cursor()

SQL = "CREATE TABLE IF NOT EXISTS UserScore('Name' Text, 'Score' Integer)"
cursor.execute(SQL)

# 使用變數
name = 'Wayne'
Score = 80
SQL = f"INSERT INTO UserScore VALUES('{name}', {Score})"
cursor.execute(SQL)

提交當前的SQL事務(執行完SQL需使用此函式提交) - .commit()

`資料庫連結`.commit()

1
2


conn.commit()
conn.close()

取得所有資料 - .fetchall()

`資料庫物件`.fetchall()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import sqlite3
conn = sqlite3.connect("test042601.sqlite3")
cursor = conn.cursor()

SQL = 'SELECT * FROM UserData;'
cursor.execute(SQL)
rows = cursor.fetchall()
for row in rows:
 # format格式化資料型態
 print("{}\t{}\t{}".format(row[0], row[1], row[2]))

取得單筆資料 - .fetchone()

`資料庫物件`.fetchone()

1
2
3
4
5
6
7
8
9


import sqlite3
conn = sqlite3.connect("test042601.sqlite3")
cursor = conn.cursor()

SQL = 'SELECT * FROM UserData;'
cursor.execute(SQL)
line = cursor.fetchone()
if not line == None:
 print("{}\t{}\t{}".format(line[0], line[1], line[2]))

正規表達式模組 - re

以小寫`r`開頭再接字串，例如：`r"\d"`、`r"0-9"`

規則寫法	說明	範例
`{}`	個數	`\d{4}-\d{6}`：台灣電話號碼格式0000-000000為符合
`{n,}`	至少出現n次	`X{2,}`：X至少出現2次才符合
`	`	或
`\d`	任意數字	`\d`：0-9為符合
`-`	到	`1-5`：1 ~ 5為符合,`a-z`：a ~ z為符合
`^`	否定	`^aeiou`：非`a`,`e`,`i`,`o`,`u`為符合
`.`	字元	`.`：字元皆符合,符號類(例如：`\n`)不符合
`*`	重複前一個字元0~無限多次都符合	`err*`：err、errr、errrr…等都為符合
`?`	前一個字元可有可無皆符合	`colou?r`：color、colour皆為符合
`+`	前一個字元要一次以上才符合	`er+`：er不符合,err、errr…等才符合
`$`	1.位數由後往前匹配 2.為結尾才匹配	`[1-9]\d$`：1 ~ 99皆為符合,100不符合
`()`	1.僅收集括號內的內容 2.分組別以便`.group(組別)`可以直接抓到值	`r'<h3 class="LC20lb DKV0Md">(.*?)</h3>'`：僅回傳<h3>內的文字
`\b`	邊界,為邊界則符合	`dog\b`：‘dog ‘符合,‘dog’不符合
`\數字`	分組向前參考

貪婪/逐步量詞 (*/?)

貪婪量詞 - `*`:0次~無限次皆符合。

1
2
3


re.match(r"<.*>", "<h3>大家好</h3>")

>>> <h3>大家好</h3>

逐步量詞 - `?`:回傳最短的量詞。

1
2
3


re.match(r"<.*?>", "<h3>大家好</h3>")

>>> <h3>

載入模組

1

import re

分割字串 - re.split(正則, 分割的字串)

1
2
3


print(re.split('\d', "Andy1Ben2Cathy"))

>>> ['Andy', 'Ben', 'Cathy']

取代字元 - re.sub(正則, 欲取代的字元, 字串)

1
2
3


re.sub("\d", "-", "Andy1Ben2Cathy")

>>> 'Andy-Ben-Cathy'

匹配字元 - re.match(欲匹配的文字, 字串)

1
2
3


re.match("yahoo", "yahoo.com.tw")

>>> <re.Match object; span=(0, 5), match='yahoo'>

尋找字元(找第一個) - re.search(欲尋找的文字, 字串)

1
2
3


re.search("yahoo", "yahoo.com.tw")

>>> <re.Match object; span=(0, 5), match='yahoo'>

尋找字元(找所有) - re.findall(欲尋找的文字, 字串)

1
2
3


re.findall('\d{4}-\d{6}', "jjladpoiwlkj 0800-123456 hjkpojas 0921-456873")

>>> ['0800-123456', '0921-456873']

抓html模組 - requests

載入模組

1

import requests

GET

抓取檔案 - .get(網址)

1

response = requests.get("https://www.baidu.com/")

GET 可帶的參數(需使用`關鍵字參數`)	說明
headers	請求的headers
params	參數
cookies	client的cookies

抓取標頭(head) - .head(網址)

1
2


# .head() -> 只抓標頭
reshead = requests.head("https://www.baidu.com/")

狀態碼 - status_code

1
2
3


print(response.status_code)

>>> 200 # 200為正常連線

編碼格式 - encoding

1
2
3
4
5


print(response.encoding)
>>> 'ISO-8859-1'

# 轉編碼為utf-8
response.encoding = "utf-8"

html內容 - text

1
2
3


print(response.text)

>>> '<!DOCTYPE html>\r\n<!--STATUS OK--><html>...'

response headers - headers

1
2
3


print(response.headers)

>>> {'Server': 'Baby Web Server', 'Content-Type': 'text/html', 'Content-Length': '467', 'Set-Cookie': 'SESSIONID=00000006; path=/;version=1', 'Date': 'Sun, 03 May 2020 10:41:58 GMT'}

request headers - request.headers

其中的`User-Agent`相當重要，用來判斷使用者的相關資訊用，爬蟲與反爬蟲通常使用此參數。

1
2
3


print(response.request.headers)

>>> {'User-Agent': 'python-requests/2.22.0', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'}

抓圖片檔

開檔格式使用wb:二進位格式寫入

w:寫入 / b:二進位格式

1
2
3
4
5
6
7
8


import requests

res = requests.get("https://www.natgeomedia.com/userfiles/PhotoContest/771/sm1100/2019091450912553.jpg")
photo = res.content

# w:寫入/b:二進位格式 "wb" => 二進位格式寫入
with open("img01.jpg", "wb") as file:
 file.write(photo)

帶request header的請求

先從一般瀏覽器取得header(user-agent)

需使用`關鍵字參數`

1
2
3
4
5


# 從瀏覽器的開發者工具取得正常的request headers資料
headers = {"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.129 Safari/537.36"}

# 在後方帶入關鍵字參數headers
res = requests.get("http://google.com.tw", headers = headers)

POST

POST 可帶的參數(需使用`關鍵字參數`)	說明
data	form data請求的data
headers	請求的headers
cookies	client的cookies

POST存Session - .Session()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


data = {
 "from": "/bbs/Gossiping/index.html",
 "yes": "yes"
 }

headers = {
 "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.129 Safari/537.36"
 }

# 先使用POST取得滿18歲的驗證並存放置session內
rs = requests.Session()
rs.post("https://www.ptt.cc/ask/over18", data = data, headers = headers)

# 過滿18歲的驗證後使用get取得網頁內容
response = rs.get("https://www.ptt.cc/bbs/Gossiping/index.html", headers = headers)

解析&美化HTML模組 - BeautifulSoup4

載入模組

1

from bs4 import BeautifulSoup

BeautifulSoup4的基本元素表

基本元素	說明
`tag`	標籤：最基本的信息組織單位，分別用`<>`和`</>`標明開頭與結尾。
`name`	標籤名稱：`<p>...</p>`的名字是`p`，格式：`<tag>.name`。
`Attributes`	屬性：`<tag>.attrs`，dict型式。
`NavigatString`	內容：`<tag>.string`。
Comment	註釋：標籤內字符串的註釋部分，一種特殊的Comment類型。

解析 - .BeautifulSoup(html, ‘html.parser’)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


demo = """
<html><head><title>This is a python demo page</title></head>
<body>
<p class="title"><b>The demo python introduces several python courses.</b></p>
<p class="course">Python is a wonderful general-purpose programming language. You can learn Python from novice to professional by tracking the following courses:
<a href="http://www.icourse163.org/course/BIT-268001" class="py1" id="link1">Basic Python</a> and <a href="http://www.icourse163.org/course/BIT-1001870001" class="py2" id="link2">Advanced Python</a>.</p>
</body></html>
"""

soup = BeautifulSoup(demo, 'html.parser')

美化 - .prettify()

1

print(soup.prettify())

取得屬性 - .attrs

1
2
3
4
5


print(soup.a.attrs)

>>> {'href': 'http://www.icourse163.org/course/BIT-268001',
 'class': ['py1'],
 'id': 'link1'}

取得tag內容 - .string/.text

1
2
3
4
5


print(soup.a.string)
print(soup.a.text)

>>> 'Basic Python'
>>> 'Basic Python'

找第一個標籤 - .find("標籤")

1
2
3


soup.find("a")

>>> <a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a>

找全部的標籤 - .find_all("標籤", class_="className")

可加上class做篩選條件。

1
2
3
4
5
6
7
8
9


# 寫法1：
soup.find_all("p", class_="title")

>>> [<p class="title"><b>The demo python introduces several python courses.</b></p>]

# 寫法2：
soup.find_all("p", {"class"="title"})

>>> [<p class="title"><b>The demo python introduces several python courses.</b></p>]

透過選擇器篩選標籤 - .select(同CSS選擇器,Class或ID)

若有空格會有問題，`soup.select(."title p")` 會報錯，空格需使用`.find()`、`.findAll()`

1
2
3
4
5
6
7


# 使用Class選擇器
print(soup.select(".title"))
>>> [<p class="title"><b>The demo python introduces several python courses.</b></p>]

# 使用ID選擇器
print(soup.select("#link1"))
>>> [<a class="py1" href="http://www.icourse163.org/course/BIT-268001" id="link1">Basic Python</a>]

`json`模組

載入模組

1

import json

json轉dict - json.loads("字串")

1
2
3
4
5
6
7


import json
txt = '{ "name": "John", "age": "28", "city": "Taiwan" }'
data = json.loads(txt)
print(type(data))

# 字典型態
>>> '<class 'dict'>'

dict轉json string - json.dumps("字典")

1
2
3
4
5
6
7


import json
txt = { "name": "John", "age": "28", "city": "Taiwan" }
jsonData = json.dumps(txt)
print(jsonData)

# 轉換後為json格式的字串
>>> {"name": "John", "age": "28", "city": "Taiwan"}

`csv`模組

載入模組

1

import csv

以_csv.reader型態讀取csv檔 - csv.reader(檔案)

1
2
3
4
5
6


import csv
with open('MI_5MINS_HIST.csv', encoding='big5') as file:
 rows = csv.reader(file)
 # 一筆一筆取出資料
 for row in rows:
 print(row)

以dict型態讀取csv檔 - csv.DictReader(檔案)

1
2
3
4
5
6


import csv
with open('MI_5MINS_HIST.csv', encoding='big5') as file:
 rows = csv.DictReader(file)
 # 一筆一筆取出資料
 for row in rows:
 print(row)

寫入csv檔 - csv.writer(檔案變數)

需先定義一個物件為csv.writer()，在進行寫入。

`writerow()` ：單行寫入

1
2
3
4
5
6


with open('Temp.csv', 'w') as csvfile:
 writer = csv.writer(csvfile)

 writer.writerow(['姓名', '身高', '體重'])
 writer.writerow(['Jessica', 158, 45])
 writer.writerow(['Wayne', 172, 60])

以字典型態寫入csv檔 - csv.DictWriter(檔案變數, fieldnames=欄位變數(列表型態))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


with open('DictTemp.csv', 'w', encoding='big5') as csvfile:

 # 設定欄位變數
 rowNames = ['姓名', '身高', '體重']

 # fieldnames = 指定欄位
 writer = csv.DictWriter(csvfile, fieldnames=rowNames)

 # 寫入欄位名稱
 writer.writeheader()

 #寫入資料
 writer.writerow({'姓名': 'Jessica', '身高': 156, '體重': 45})
 writer.writerow({'姓名': 'Wayne', '身高': 172, '體重': 60})

模擬瀏覽器模組(自動化測試) - `selenium`

安裝 selenium 模組

`Anaconda`編譯器的話，使用`Anaconda Prompt`

1
2


### anaconda 安裝 selenium 模組
conda install selenium

1
2


### 使用 pip 安裝 selenium 模組
pip install selenium

下載瀏覽器驅動(web driver)
先查看chrome瀏覽器的版本，Google：Web driver chrome後下載。
載入模組

1

from selenium import webdriver

實例化一個瀏覽器視窗(Chrome)，並設定一個瀏覽器物件

檔案名稱勿與selenium模組名稱相同以免衝突而無法執行

1
2
3


from selenium import webdriver

driver = webdriver.Chrome()

發送GET請求 - 瀏覽器物件.get(網址)

1

driver.get("http://www.baidu.com")

根據dom元件的id/class定位 - 瀏覽器物件.find_element_by_id(id) 或 瀏覽器物件.find_element_by_class(class)

1
2


# 找到id為"kw"的input，並輸入"python"
driver.find_element_by_id("kw").send_keys("python")

送出表單 - 瀏覽器物件.dom元件.submit()

1
2


# 送出id為"su"的表單
driver.find_element_by_id("su").submit()

點擊事件 - 瀏覽器物件.dom元件.click()

1
2


# 送出id為"btn"的按鈕
driver.find_element_by_id("btn").click()

取得頁面原始碼 - .page_source

1

SourceHtml = driver.page_source

螢幕截圖 - 瀏覽器物件.save_screenshot(截圖的圖檔名稱)

1

driver.save_screenshot("screen.png")

獲取cookies - 瀏覽器物件.get_cookie()

1
2


cookies = driver.get_cookie()
print(cookies)

關閉實例化的瀏覽器視窗 - 瀏覽器物件.close() 或 瀏覽器物件.quit()

1
2


driver.close()
# 或 driver.quit()

資料分析模組 - Pandas

載入模組

1

import pandas

解析list類型 - pandas物件.Series(資料)

1
2
3
4
5
6
7
8
9


import pandas
data = [20, 10, 15]
pds = pandas.Series(data)
print(pds)

>>> 0 20
>>> 1 10
>>> 2 15
>>> dtype: int64

解析Data類型 - pandas物件.DataFrame(字典型態的資料)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


data = pandas.DataFrame({
 "name": ["Amy", "Jack", "Cathy"],
 "salary": [1000, 5000, 2000]
})
print(data)

>>> name salary
>>> 0 Amy 1000
>>> 1 Jack 5000
>>> 2 Cathy 2000

# 取特定欄位
print(data[salary])

>>> 0 1000
>>> 1 5000
>>> 2 2000

可指定x軸或y軸欄位名稱(columns, index)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


import pandas
data = [
 [65,92,78,83,70],
 [62,96,81,63,71],
 [45,58,30,53,75],
 [90,91,70,90,100],
]

index = ["張三", "李四", "王五", "趙雲"]
columns = ["國文", "數學", "英文", "自然", "社會"]
df = pandas.DataFrame(data, columns = columns, index = index)

print(df)

>>> 國文 數學 英文 自然 社會
>>> 張三 65 92 78 83 70
>>> 李四 62 96 81 63 71
>>> 王五 45 58 30 53 75
>>> 趙雲 90 91 70 90 100

回傳最大值 - Data資料.max()

1
2
3
4
5


data = [20, 10, 15]
pds = pandas.Series(data)
print(pds.max())

>>> 20

回傳最小值 - 資料.min()

1
2
3
4
5


data = [20, 10, 15]
pds = pandas.Series(data)
print(pds.min())

>>> 10

取得指定欄位 - Data資料.loc[x][y]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


data = pandas.DataFrame({
 "name": ["Amy", "Jack", "Cathy"],
 "salary": [1000, 5000, 2000]
})
print(data)
print(data.loc[0][1])

>>> name salary
>>> 0 Amy 1000
>>> 1 Jack 5000
>>> 2 Cathy 2000

>>> 1000

輸出成csv(或json)檔案 - Data資料.to_csv("檔名", encoding="編碼") 或 Data資料.to_json("檔名", encoding="編碼")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import pandas
data = [
 [65,92,78,83,70],
 [62,96,81,63,71],
 [45,58,30,53,75],
 [90,91,70,90,100]
]
index = ["張三", "李四", "王五", "趙雲"]
columns = ["國文", "數學", "英文", "自然", "社會"]
df = pandas.DataFrame(data, columns = columns, index = index)
df.to_csv('temp.csv', encoding="utf-8-sig")

繪圖模組 - plot

載入模組

1

import matplotlib.pyplot as plt

畫折線圖 - .plot(X軸資料, Y軸資料)

1
2
3
4
5
6
7


import matplotlib.pyplot as plt

x1 = [1,4,7,9,13,16]
y1 = [15,50,80,40,70,50]

# 畫出折線圖
plt.plot(x1, y1)

顯示Label - .legend()

要顯示label需執行此function

`:`為點線, `--`為虛線, 不指定預設為實線

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import matplotlib.pyplot as plt

x1 = [1,4,7,9,13,16]
y1 = [15,50,80,40,70,50]

# :為點線, --為虛線, 不指定預設為實線
plt.plot(x1, y1, label="food", color="red", linestyle=":")

#要顯示label - 需執行legend()
plt.legend()

指定圖表標題 - .title()

1

plt.title("學生成績")

指定X/Y軸標題 - .xlabel(X軸標題) / .ylabel(Y軸標題)

1
2


plt.xlabel("X軸標題")
plt.ylabel("Y軸標題")

畫長條圖 - .bar(X軸資料, Y軸資料)

1
2
3
4
5
6
7


import matplotlib.pyplot as plt

x1 = [1,4,7,9,13,16]
y1 = [15,50,80,40,70,50]

# 畫出長條圖
plt.bar(x1, y1)

畫圓餅圖 - .pie(資料)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import matplotlib.pyplot as plt
datas = [5,10,20,15]

# 畫出圓餅圖
plt.pie(datas)

# 讓特定區塊凸出(需與資料數量相同)
explode = [0,0,0.05,0]
plt.pie(datas, explode = explode)

# 指定每個區塊的標題
labels = ["東部","南部","西部","北部"]
plt.pie(sizes, labels = labels)

# 顯示百分比
plt.pie(sizes,autopct="%3.1f%%")

繪圖模組2 - plotly

安裝 plotly 模組

`Anaconda`編譯器的話，需使用`Anaconda Prompt`安裝。

使用`Jupyter Notebook`編輯

1
2


### anaconda 安裝 plotly 模組
conda install plotly

載入模組(並指定繪圖模式)

1
2
3
4


import plotly

# 指定繪圖模式：Scatter, Bar, Pie, Box, Scattergeo, Histogram
from plotly.graph_objs import Scatter # 折線散點圖

在線繪圖需收費，需使用離線繪圖

1

plotly.offline.init_notebook_mode(connected=True)

指定X/Y軸資料

1

data = [Scatter(x=["林大名", "陳聰明", "黃美麗"], y=[67,89,72])]

畫出折線圖

1
2


data = [Scatter(x=["林大名", "陳聰明", "黃美麗"], y=[67,89,72])]
plotly.offline.iplot({"data":data})

指定繪圖的mode

1
2
3


# markers：只有點 / lines：只有線 / lines + markers：點 + 線
data = [Scatter(x=["林大名", "陳聰明", "黃美麗"], y=[67,89,72], mode="markers")]
plotly.offline.iplot({"data":data})

指定圖表標題(繪圖模式須import Layout)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import plotly
from plotly.graph_objs import Scatter, Layout

# 離線繪圖模式 

plotly.offline.init_notebook_mode(connected=True)

data = [Scatter(x=["林大名", "陳聰明", "黃美麗"], y=[67,89,72])]

# 指定圖表標題 

plotly.offline.iplot({"data":data, "layout":Layout(title="成績單")})

Excel模組 - openpyxl

載入模組

1

import openpyxl

建立工作簿物件 - openpyxl.Workbook()

1
2


# 工作簿物件
workbook = openpyxl.Workbook()

取得指定工作表

1
2


# 工作表物件
sheet = workbook.worksheets[0]

鍵入值

方法一：行列插入

1
2
3


# sheet：工作表物件
sheet['A1'] = "欄位一"
sheet['B1'] = "欄位二"

方法二：自動換行插入

1
2
3


# sheet：工作表物件
listTitle = ["姓名", "電話"]
sheet.append(listTitle)

取得特定欄位的值 - .value

1

sheet['A1'].value

存檔 - 工作簿物件.save(檔名)

1

workbook.save('test.xlsx')

取檔 - openpyxl.load_workbook(檔名)

1

workbook = openpyxl.load_workbook('test.xlsx')

取得總行數 - 工作表物件.max_row

1

print(sheet.max_row)

取得總列數 - 工作表物件.max_column

1

print(sheet.max_column)

到指定欄位 - 工作表物件.cell(row=指定行數, column=指定列數)

1
2


# 印出第3行第2列的值
print(sheet.cell(row=3, column=2).value)

Python 資料型態

資料型態說明

資料型態	說明
`str`	字串
`int`	整數
`bool`	布林值
`float`	浮點數
`None`	空值
`list []`	列表，同Array
`tuple ()`	不可變更的Array
`dict {}`	字典，同Object
`set ()`	集合，同Object，但key為索引值

Python 運算子

基本運算子

運算子	說明
+	加：數值相加,字串相連接
-	減
*	乘：數值相乘,字串可乘數值(python獨有)
/	浮點數除
**	平方
**0.5	開根號
//	整數除
%	取餘數

指派運算子

運算子	說明
+=	原值等於原值加
-=	原值等於原值減
*=	原值等於原值乘
/=	原值等於原值除

判斷運算子

運算子	說明
>	大於
<	小於
==	等於
!=	不等於
>=	大於等於
<=	小於等於

邏輯運算子

運算子	說明
and	並且
or	或者
not	反向

Python 函式

回傳資料型態 - type()

1
2
3
4
5
6
7
8


type(3)
>>> <class 'int'>
type('a')
>>> <class 'str'>
type(True)
>>> <class 'bool'>
type(None) # Python的空值為None
>>> <class 'NoneType'>

輸入窗 - input()

1
2
3
4


myName = input("請輸入姓名：")
>>> 請輸入姓名：jessica # 輸入名字後
print(myName) # 取輸入的名字
>>> jessica

字串轉數值 - eval()

1
2
3


num = eval("3")
print(type(num))
>>> <class 'int'>

特殊符號轉十進位編號 - ord() / chr()

1
2
3
4
5
6
7


# ord 將特殊符號轉換成十進位編號
ord('⤅')
>>> 10501

# chr 將十進位編號轉換成特殊符號
chr(10501)
>>> ⤅

取最大 / 最小值 - max() / min()

1
2
3
4


min(1, 2, 45, 100)
>>> 1
max(1, 2, 45, 100)
>>> 100

取絕對數值 - abs()

1
2


abs(-3.14)
>>> 3.14

進制字串轉數字 - eval()

1
2


eval("0o101")
>>> 65

數字轉字串 - str()

1
2


str(324)
>>> '324'

字串轉數字或數字轉整數 - int()

1
2
3
4


int("324")
>>> 324
int(3.14)
>>> 3

浮點數字串轉數字 - float()

1
2


float("3.1416")
>>> 3.1416

四捨五入 - round(`數值` `[,位數]`)

1
2
3
4
5
6


round(3.1416)
>>> 3

# 第二個參數可帶位數
round(3.1416, 3)
>>> 3.142

平方 - pow(`數值`, `平方根`)

1
2
3


# 第二個參數為平方根
pow(5, 2)
>>> 25

取得長度 - len()

任何資料型態都通用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# String
strA = "Hello World"
len(strA)
>>> 11

# Array
arrA = [1, 2, 20, 50, 100]
len(arrA)
>>> 5

# Object
objA = {"itemA":"123", "itemB":"456"}
len(objA)
>>> 2

編碼 / 解碼 - encode() / decode()

1
2
3
4
5


"中".encode("utf-8")
>>> b'\xe4\xb8\xad'

b'\xe4\xb8\xad'.decode("utf-8")
>>> "中"

字串轉大小寫 - upper() / lower()

1
2
3
4
5
6
7


StrA = "Hello World!"
# 大寫
StrA.upper()
>>> 'HELLO WORLD!'
# 小寫
StrA.lower()
>>> 'hello world!'

字串取代 - replace(`舊字串`, `新字串`)

1
2
3


StrA = "Hello World!"
StrA.replace("World", "Jessica")
>>> 'Hello Jessica!'

字串判斷的函式

函式	說明
StrA.`isalpha()`	是否為字母
StrA.`isdigit()`	是否為數字
StrA.`isupper()`	是否為大寫
StrA.`islower()`	是否為小寫
StrA.`isidentifer()`	是否為識別字
StrA.`iskeyword()`	是否為關鍵字,需要keyword模組
StrA.`isspace()`	是否為空白
StrA.`istitle()`	是否為標題字(第一個字為大寫則是標題字)

字串搜尋的函式

函式	說明
Str.`count(文字A)`	搜尋`文字A`出現的次數
StrA.`startswith(文字A)`	是否為`文字A`開頭
StrA.`endswith(文字A)`	是否為`文字A`結尾
StrA.`find(文字A)`	搜尋`文字A`的位置
StrA.`rfind(文字A)`	搜尋`文字A`最後出現的位置

印出字串 - print()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# 一般的print(間隔預設自動補空格)
print(1, 2, 3)
>>> 1 2 3

# 間隔不空格
print(1, 2, 3, sep="")
>>> 123

# 指定間隔文字
print(1, 2, 3, sep="@")
>>> 1@2@3

# 指定結尾文字
print(1, 2, 3, sep="@", end="!!!")
>>> 1@2@3!!!

# 格數化輸出字元(開頭帶一個小寫的"f")
print(f'{變數A}*{變數B}={變數A*變數B}')
>>> A * B = AB

字串格式化 - format()

取代字串中`{}`

1
2
3


text = 'world'
print('hello {}'.format(text))
>>> hello world

可帶關鍵字取代

1
2
3
4
5


name = 'Jack'
text = 'world'

print('hello {name}, hello {text}'.format(name=name, text=text))
>>> hello Jack, hello world

從最後面插入 - append()

1
2
3
4


list1 = [2,4,6,8]
list1.append(10)

>>> [2,4,6,8,10]

從指定位置插入 - insert(`位置`, `值`)

1
2
3
4


list1 = [2,4,6,8,10]
list1.insert(0, -1)

>>> [-1,2,4,6,8,10]

條件判斷

條件判斷式 - if… elif… else…

1
2
3
4
5
6
7


# 使用縮排撰寫要做的事
if 條件A:
 ...
elif 條件B:
 ...
else:
 ...

例外判斷 - try… except…

1
2
3
4
5
6
7
8


try:
 # ...
except Exception:
 print("有異常錯誤")
except NameError:
 print("變數有錯誤")
except TypeError:
 print("資料格式錯誤")

except 錯誤分類

錯誤異常判斷	說明
Exception	只要有錯誤
NameError	變數名稱錯誤
ValueError	value值錯誤
ZeroDivisionError	除數/分母不可為零的錯誤
TypeError	資料格式錯誤

迴圈

技術式迴圈 - for

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# 跑range
for i in range(1, 6):
 print(i, end=" ")
>>> 1 2 3 4 5

# 跑在字串
for c in "Mary":
 print(c, end=" ")
>>> "M" "a" "r" "y"

# 跑在陣列
for e in ["a", 3, "Jessica"]
>>> "a"
>>> 3
>>> "Jessica"

條件式迴圈 - while

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# while迴圈
i = 0
while i < 5:
 i += 1
 print(i)

>>> 1
>>> 2
>>> 3
>>> 4
>>> 5

# While判斷(反覆驗證直到ans等於"happy")
ans = input("請輸入快樂的英文：")
while ans != "happy":
 ans = input("拼錯囉，再給你一次機會：")
else:
 print("答對囉，是happy")

break：跳脫迴圈

1
2
3
4
5
6
7
8
9


ans = input("請輸入快樂的英文：")
while ans.lower() != "happy":
 # 當輸入quit時跳出迴圈
 if(ans.lower() == "quit"):
 print("猜不出來了吧，結束")
 break;
 ans = input("拼錯囉，再給你一次機會：")
else:
 print("答對囉，是", ans)

continue：跳過繼續進行下一迴圈

1
2
3
4
5
6
7
8


# i遇4的因數就跳過
i = 0
while i <= 100:
 i += 1
 # continue前要先加1，避免進入無窮迴圈
 if i % 4 == 0:
 continue
 print(i, end=" ")

自訂函式

自定義函式 - def

一般宣告函式

1
2
3
4
5
6
7


def printStar(_n):
 return "*" * _n


# 執行函式
print(printStar(6))
>>> ******

設定參數預設值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


def TeaTime(desserts, drink="咖啡"):
 print(f'下午茶點心為{desserts},飲料為{drink}')


TeaTime('馬卡龍', '紅茶') # 指定實際參數
TeaTime('馬卡龍') # 飲料會顯示預設值:咖啡
TeaTime() # 兩個參數都顯示預設值

>>> 下午茶點心為馬卡龍,飲料為紅茶
>>> 下午茶點心為馬卡龍,飲料為咖啡
>>> 下午茶點心為鬆餅,飲料為咖啡

設定不定個數參數(參數為tuple型態)

`帶入參數`帶星號可將帶入的參數組成一個`tuple`

1
2
3
4
5
6
7
8
9


def add(*numbers):
 total = 0
 for i in numbers:
 total += i
 print(total)

add(1, 2, 4, 6)

>>> 13

`實際參數`帶星號可將原為`tuple`型態的資料拆解開來

1
2
3
4
5
6
7
8
9


def add(*numbers):
 total = 0
 for i in numbers:
 total += i
 print(total)

add(*range(0, 11))

>>> 55

多個回傳值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# 回傳值用逗號隔開
def divmod(x, y):
 div = x // y
 mod = x % y
 return div, mod

# 用{a,b}接多個回傳值
a, b = divmod(100, 7)

print(f'100除以7的商數為{a},餘數為{b}')

>>> 100除以7的商數為14,餘數為2

操作 List(列表)

建立

建立空list

1
2
3
4
5


# 方法1:
list1 = []

# 方法2:
list2 = list()

建立list

1

list1 = [1, "taipei", 2, "tokyo"] # 每個的資料型態不限

從string建立list

1

list1 = list("Hello") # list1為 ["H","e","l","l","o"]

從range建立list

1

list1 = list(5) # list1為 [0,1,2,3,4]

從字串分割建立list

1

list1 = "1 2 3".split() # list1為 ["1","2","3"]

刪除

刪除整個list

1

del list1

刪除list中的某一個(以第一個為例)

1
2
3
4
5
6
7
8


# 方法1
del list1[0]

# 方法2
list.remove(0)

# 方法3
list.pop([0])

清除list元素(等於del list[::])

1
2
3
4


list1 = [2,4,6,8,10]
list1.clear()

>>> []

list新增元素

1
2
3


list.append(x) # 附加元素到最後
list.extend(L)
list.inser(i, x) # 插入元素至指定位置

查詢索引

1

list1.index('a') # 查詢a在list1的索引

統計出現的次數

1

list1.count('a') # 統計a在list1中出現的次數

元素排序

1

list.sort() # 原地操作

元素倒序

1

list1.reverse() # 原地操作

操作 Dict(字典)

查詢

一般查詢

1

dict1[key] # 若key值不在會報錯

以key查詢，使用dict1.get(key, [default]) - (推薦)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 若無key值則顯示default
dict1.get(key, [default])

#example:
fruits = {"apple":"30元", "banana":"10元"}
Quest = input("請輸入要查詢的價格的水果：")

print(fruits.get(Quest, "查無此水果"))

<<< apple
>>> 30元
<<< orange
>>> 查無此水果

查詢所有的key (回傳列表)

1
2
3
4


dict1 = {"user1":"小丸子", "user2":"小玉", "user3":"花輪"}
dict1.keys()

>>> dict_keys(['user1', 'user2', 'user3'])

查詢所有的values (回傳列表)

1
2
3
4


dict1 = {"user1":"小丸子", "user2":"小玉", "user3":"花輪"}
dict1.values()

>>> dict_values(['小丸子', '小玉', '花輪'])

建立

建立空dict

1
2
3
4
5


# 方法1:
dict1 = {}

# 方法2:
dict2 = dict()

建立dict

1

dict1 = {1:"one", 2:"tow", 3:"three"}

新增dict

1

dict1[newKey] = value

更新

更新dict

1

dict1[oldKey] = value

比對更新 - update

update 會比對沒有的key並補上，比對有的key進行value更新。

1
2
3
4
5
6


dict1 = {'user1': '小丸子', 'user2': '小玉', 'user3': '花輪'}
dict2 = {'user1': '大丸子', 'user2': '小玉', 'user3': '花輪', 'user4': '多拉A夢'}

dict1.update(dict2)

>>> {'user1': '大丸子', 'user2': '小玉', 'user3': '花輪', 'user4': '多拉A夢'}

刪除

刪除整個dict

1

del dict1

清空整個dict

1

dict1.clear()

刪除list中的某一個(以第一個為例)

1

del dict1[key]

操作 class (類別/物件導向)

封裝成一個類別 - class `類別名稱`:

python的class會自動執行`init`函式，可自行定義`init`內要做的事。

`init`第一個參數預設為`self`。

1
2
3
4
5
6
7


class GoogleSpyder:
 def __init__(self, keyword):
 self.keyword = keyword
 self.url_tmp = "http://google.com/search?q=" + keyword + "&start={}"
 self.headers = {"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.129 Safari/537.36"}

googleSpyder = GoogleSpyder("python") # 自動執行 __init__

檔案處理

讀寫模式

模式	說明
`r`	`read`：讀取(檔案需存在)
`w`	`write`：新建檔案寫入(檔案可不存在，若存在則清空)
`a`	`append`：資料附加到舊檔案後面(游標指在檔案結尾，檔案可不存在)
`r+`	讀取舊資料並寫入(檔案需存在且游標指在開頭)
`w+`	清空檔案內容，新寫入的東西可再讀出
`a+`	資料附加到舊檔案後面，可讀取資料
`b`	二進位模式

記憶方式：

1
2
3
4


w、w+ # 會清除原檔案內容
r、r+ # 檔案指標指向檔案開頭
a、a+ # 檔案指標指向檔案結尾
+ # 可讀可寫模式

檔案開啟 - open()

操作後需關檔 - close()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


content = """Hello Python
中文測試
abc
123456.321654987
$@^$%^@#$!@#$
"""

file = open("myfile.txt", "w")
...
file.close()

讀取 - read()

myfile.txt

1

testtest123

test.py

1
2
3


file = open(r"myfile.txt", "r")
print(file.read())
file.close()

執行回傳

1

>>> testtest123

寫入 - write()

test.py

1
2
3


file = open(r"myfile.txt", "w")
file.write('testtest123')
file.close()

myfile.txt

1

testtest123

移動讀寫頭 - seek()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


content = """Hello Python"""

file = open(r"myfile.txt", "r")
# file.write(content)
file_content = file.read()
print(file_content)

file.seek(0) # 移動讀寫頭到開頭

file_content = file.read()
print(file_content)
file.close()

執行回傳

1
2


>>> Hello Python
>>> Hello Python

讀出行數 - readline() & readlines()

readline：一行一行讀
readlines：一次讀全部行數

poem.txt

1
2
3
4


松下問童子
言師採藥去
只在此山中
雲深不知處

read.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# readlines() 一次讀出
f = open(r'poem.txt', 'r')
lines = f.readlines()
for line in lines:
 print(line, end='')


f.seek(0) # 讀寫頭回到開頭

# readline() 一行一行讀
line = f.readline()

while line != '':
 print(line, end='')
 line = f.readline()

f.close()

執行回傳：

1
2
3
4


>>> 松下問童子
>>> 言師採藥去
>>> 只在此山中
>>> 雲深不知處

使用 with-open-as 做讀檔案的動作 - (推薦)

1
2


with open(r"poem.txt", "r") as file:
 print(file.read())

執行回傳：

1
2
3
4


>>> 松下問童子
>>> 言師採藥去
>>> 只在此山中
>>> 雲深不知處

刪除檔案 - remove()

使用os模組
使用os.path.exists判斷檔案是否存在

1
2
3
4
5
6
7
8


import os

file = r"poem2.txt"

if os.path.exists(file):
 os.remove(file)
else:
 print('No exists file')

新增目錄 - mkdir()

使用os.path.exists判斷檔案是否存在

1
2
3
4
5
6
7
8


import os

dir = "testDir"

if os.path.exists(dir):
 print("Direct is exists")
else:
 os.mkdir(dir)

刪除空目錄 - rmdir()

使用os.path.exists判斷檔案是否存在
限定空目錄

1
2
3
4
5
6
7
8


import os

dir = "testDir"

if os.path.exists(dir):
 os.rmdir(dir)
else:
 print("Direct is undefine")

刪除目錄與底下全部檔案 - rmtree()

使用shell utility模組 - shutil
需謹慎使用避免刪錯目錄

1
2
3


import shutil

shutil.rmtree("testDir")

Python 語法筆記

兩個變數交換值(Python Only)

1
2
3
4


x = 3
y = 8
x,y = y,x # 交換兩個變數的值
print(x,y)

開頭宣告編碼方式可直接強轉(Python Only)

1
2
3
4


# -*- coding: utf-8 -*-
# 轉utf-8
print("哈囉")
>>> "哈囉"

Python函數帶入參數方式

參數以tuple傳入function。

1
2
3
4
5
6


def func1(*args):
 print(args)

func2(1,3,5,7,9)

>>> (1, 3, 5, 7, 9)

參數以tuple拆解，進function在組合回tuple。

1
2
3
4
5
6


def func2(*args):
 print(args)

func2(*(2,4,6,8,10))

>>> (1, 3, 5, 7, 9)

參數以dict傳入function。

1
2
3
4
5
6


def func3(**kwargs):
 print(kwargs)

func3(even=(2,4,6,8), odd=(1,3,5,7,9))

>>> {'even': (2, 4, 6, 8), 'odd': (1, 3, 5, 7, 9)}

參數以dict拆解，進function在組合回dict(需為參數指定關鍵字)(關鍵字參數)。

1
2
3
4
5
6


def func4(**kwargs):
 print(kwargs)

func4(**{"even":(2,4,6,8), "odd":(1,3,5,7,9)})

>>> {'even': (2, 4, 6, 8), 'odd': (1, 3, 5, 7, 9)}

其他

字串運算(Python Only)

in：是否含有

1
2
3


# in
"or" in "forever"
>>> True

not in：是否不含有

1
2
3


# not in
"abc" not in "forever"
>>> False

取字串的特定位置字元

格式：`開始點`:`結束點`:`間隔`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# 取第1~4個字元(不含第4個)
"abcdefg"[1:4]
>>> 'bcde'

# 取第1~4個字元(每次間隔2個)
"abcdefg"[1:4:2]
>>> 'bd'

# 取最後一個字元
"abcdefg"[-1]
>>> 'g'

# 反轉
"abcdefg"[::-1]
>>> 'gfedcba'

SQLite 關聯式資料庫(版本3.31.1)

系統命令(.開頭)，SQL命令(;結尾)

系統命令

進入資料庫

指令：sqlite3 `資料庫名稱`

1
2
3


sqlite3 test01.sqlite

sqlite>

資料庫 (DB)

sqlite指令新增資料庫

1

.open test01

sqlite指令查詢所有資料庫

1

.databases

資料表 (Table)

欄位設定	說明
NM	(None)可否允許空值
PK	(Primary Key)是否為主鍵
AI	(A.I)是否自動產生值
U	(Unique)不重複鍵

新增資料表

1

create table studen(ID Integer, name String, score Integer);

sqlite指令查詢所有資料表

1

.table

更新資料表

SQL語法：ALTER TABLE 資料庫 ADD COLUMN 欄位名稱 資料型態

1

ALTER TABLE student ADD COLUMN address String;

資料操作 (CRUD:Create/Read/Update/Delete)

插入資料

SQL語法：INSERT INTO 資料表 VALUES(欄位1, 欄位2, 欄位3)

1

INSERT INTO student values(1001, "Ben", 88);

查詢資料

SQL語法：SELECT 欄位 FROM 資料表 [WHERE 條件];

1

SELECT Score from student WHERE ID = 1001;

刪除資料

SQL語法：DELETE FROM 資料表 [WHERE 條件];

1

DELETE from student WHERE ID = 1001;

修改資料

SQL語法：UPDATE 資料表 SET 欄位名稱 = 值 [WHERE 條件];

1

UPDATE student SET Name = "Amanda" WHERE ID = 1001;

Python on Wayne's blog | 偉恩的部落格 | 技術博客

【Pyenv】輕鬆管理 Python 版本的好工具！

安裝 Pyenv

Mac 安裝 Pyenv

Windows 安裝 Pyenv

PowerShell：

cmd：

Linux 安裝 Pyenv

驗證 Pyenv 是否安裝成功？

如何使用 Pyenv 切換 Python 版本？

Pyenv 切換 python 版本成功後，如何查看？

Pyenv 如何切換成原始系統的版本？

更新 Python 環境資訊

物件導向的 Q&A - 以 Python 舉例

物件導向

請問物件導向程式語言有哪些特點，能簡單說明給我聽嗎？

請問物件具有狀態 (state) 和行為 (behavior)。這句話是什麼意思？能用 python 舉例嗎？

請問你能用上面的 Car class 寫一個繼承的範例給我看嗎？

請問你能用上面的程式碼繼續舉例多型的用法給我看嗎？

請問你能用上面的程式碼繼續舉例封裝的用法給我看嗎？

你說在 Python 中，我們可以使用 _ 或 __ 來表示私有變數和方法，請問 _ 跟 __ 差在哪裡？

請問你能用上面的程式碼繼續舉例抽象的用法給我看嗎？

有了繼承的特點為何還需要抽象？感覺不出這兩者有何差別？

實際業務上來說，何時會想用繼承何時會想用抽象？

請問你說的特徵具體來說是指什麼東西？

請問物件導向為何叫做物件導向？

【Python】裝飾子 (decorator) 教學

本文 python 環境

什麼是 Decorator

開始之前

怎麼解決攔截傳入參數的部分？

@ 語法糖(Syntactic sugar)

多個裝飾子的執行順序

functools.wraps

類別裝飾子(Class-based decorators)

更複雜的 decorator - 可設定參數的裝飾子

總結

智慧商業Python數據分析與應用班(版本3.*)

指導教師：李菊權(0921-763623)

python(版本3.8.2)

安裝至環境變數(Windows10)

Python介紹

Python 動態型別(強型別)/直譯式語言

IDLE

推薦開發環境 Anaconda

Python Shell (REPL)

進入Python Shell (REPL)

離開Python Shell (REPL)

清除當前Python Shell Screen

Python Plugin

作業系統模組 - os

影像處理模組 - PIL(Pillow)

圖像繪製工具 - turtle

數字模組 - math

亂數模組 - random

浮點數精度模組 - Decimal

抓DOS模式後方參數的模組 - sys

資料庫模組 - sqlite3

資料庫連結.connect(資料庫名稱)

資料庫物件 = 資料庫連結.cursor()

資料庫物件.execute(SQL語法)

資料庫連結.commit()

資料庫物件.fetchall()

資料庫物件.fetchone()

正規表達式模組 - re

以小寫r開頭再接字串，例如：r"\d"、r"0-9"

貪婪量詞 - *:0次~無限次皆符合。

逐步量詞 - ?:回傳最短的量詞。

抓html模組 - requests

GET

其中的User-Agent相當重要，用來判斷使用者的相關資訊用，爬蟲與反爬蟲通常使用此參數。

開檔格式使用wb:二進位格式寫入

w:寫入 / b:二進位格式

先從一般瀏覽器取得header(user-agent)

需使用關鍵字參數

POST

解析&美化HTML模組 - BeautifulSoup4

可加上class做篩選條件。

若有空格會有問題，soup.select(."title p") 會報錯，空格需使用.find()、.findAll()

json模組

`@` 語法糖(Syntactic sugar)

指導教師：`李菊權(0921-763623)`

`資料庫連結`.connect(`資料庫名稱`)

`資料庫物件` = `資料庫連結`.cursor()

`資料庫物件`.execute(`SQL語法`)

`資料庫連結`.commit()

`資料庫物件`.fetchall()

`資料庫物件`.fetchone()

以小寫`r`開頭再接字串，例如：`r"\d"`、`r"0-9"`

貪婪量詞 - `*`:0次~無限次皆符合。

逐步量詞 - `?`:回傳最短的量詞。

其中的`User-Agent`相當重要，用來判斷使用者的相關資訊用，爬蟲與反爬蟲通常使用此參數。

需使用`關鍵字參數`

若有空格會有問題，`soup.select(."title p")` 會報錯，空格需使用`.find()`、`.findAll()`

`json`模組

`csv`模組

`writerow()` ：單行寫入

模擬瀏覽器模組(自動化測試) - `selenium`

`Anaconda`編譯器的話，使用`Anaconda Prompt`

`:`為點線, `--`為虛線, 不指定預設為實線

`Anaconda`編譯器的話，需使用`Anaconda Prompt`安裝。

使用`Jupyter Notebook`編輯

四捨五入 - round(`數值` `[,位數]`)

平方 - pow(`數值`, `平方根`)

字串取代 - replace(`舊字串`, `新字串`)

取代字串中`{}`

從指定位置插入 - insert(`位置`, `值`)

`帶入參數`帶星號可將帶入的參數組成一個`tuple`

`實際參數`帶星號可將原為`tuple`型態的資料拆解開來