Python 寫程式的「底線」：7 種使用技巧

# 這樣寫一個常數
# 你能一眼看出來它是百萬、千萬、還是億嗎？
>>> num = 30000000.0
>>> num
30000000.0

# 常數加上底線，意思不會變
# 既然不能加上逗點、就把底線當成千位符號使用
# 一看就知道是三千萬、可讀性大提升！
>>> num = 30_000_000.0
>>> num
30000000.0

# 二進位 Bit 資料用半位元組（Nibble）表示
>>> bin_data = 0b_1000_1110_0110_1111
>>> bin_data
36463

# 用字組（Word）表示記憶體位置
>>> addr = 0x_ABCD_F90C
>>> addr
2882402572

>>> (1+2+3)*100
600
>>> _
600
>>> 594_0009_527
5940009527
>>> _
5940009527

# 注意，如果數值已指定給某變數，就不會儲存在單底線了
>>> tmp = [i*2 for i in range(5)]
>>> _
5940009527
>>> tmp
[0, 2, 4, 6, 8]
>>> _
[0, 2, 4, 6, 8]

# 我自己覺得打開 Python 當計算機按的時候
# 單底線還不錯用啦 (˚∀˚) 
>>> 350+128
478
>>> _ * 3
1434
>>> _ - 1200
234
>>> _ ** 3
12812904

# 迴圈內有用到 i
>>> for i in range(3):
...     print(f"第 {i} 行")
...
第 0 行
第 1 行
第 2 行

# 每個迴圈內容都一樣，表示 i 存了什麼根本不重要！
>>> for i in range(3):
...     print(f"你好 ʕ •ᴥ•ʔ")
...
你好 ʕ •ᴥ•ʔ
你好 ʕ •ᴥ•ʔ
你好 ʕ •ᴥ•ʔ

# 所以乾脆用單底線改寫
# 讓其他程式碼閱讀者知道：「第幾個迴圈」是不重要的資訊
>>> for _ in range(3):
...     print(f"你好 ʕ •ᴥ•ʔ")
...
你好 ʕ •ᴥ•ʔ
你好 ʕ •ᴥ•ʔ
你好 ʕ •ᴥ•ʔ

# 範例：
# tuple 格式的國小資料 
# (姓名, 性別, 入學年份, 國小名稱, 年級)
# 我們可以用解包技巧（Unpacking）把多個元素分別儲存在各個變數
>>> name, gender, year, school, gradelevel = ('豪豪', '男', 2001, '西松國小', 3)
>>> name
'豪豪'
>>> gradelevel
3

# 如果我們操作資料只需要用到「姓名」與「年級」兩項資訊
# 中間的其他資料我們可以用單底線來暫時存放，也就是，刻意地忽略
>>> name, _, _, _, gradelevel = ('曼玉', '女', 2010, '健康國小', 6)
>>> name
'曼玉'
>>> gradelevel
6

# 更酷的是，單底線再加上 Extended Iterable Unpacking (PEP 3132) 技巧
# 程式碼會再更簡短
>>> name, *_, gradelevel = ('朝偉', '男', 1998, '敦化國小', 5)
>>> name
'朝偉'
>>> gradelevel
5

>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
>>> X, y = np.arange(10).reshape((5, 2)), range(5)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])

# 隨機抽樣出三分之二的資料
>>> X_sample, _, y_sample, _ = train_test_split(
...     X, y, test_size=0.33, random_state=42)
...
>>> X_sample
array([[4, 5],
       [0, 1],
       [6, 7]])
>>> y_sample
[2, 0, 3]
# 至於 _ 內究竟存了什麼
# 就不管了 ¯\_(ツ)_/¯

class Employee:
    """Class that contains basic information about an employee."""
    def __init__(self, name: str, job: str, salary: int = 0) -> None:
        self.name = name
        self.job = job
        self.salary = salary
        self._title = f"{self.job} - {self.name}"

    def get_name(self):
        return self.name

    def _print_employee_info(self):
        print(f"月薪 ${self.salary} 的 {self._title}")
        return None

>>> hao = Employee("好豪", "資料科學家", 22_000)

# 一般命名方法的變數可以取用
>>> hao.name
'好豪'

# 前單底線命名的變數代表「內部使用」或「不建議使用」
# 但其實還是可以取得
>>> hao._title
'資料科學家 - 好豪'

# 同樣地，一般命名方法的函式當然可以用
>>> hao.get_name()
'好豪'

# 前單底線命名的函式代表「內部使用」或「不建議使用」
# 但你還是可以呼叫得到 (˚∀˚) 
>>> hao._print_employee_info()
月薪 $22000 的 資料科學家 - 好豪

# 範例模組：my_module.py

def function_a():
    print('一般命名的函式')

def _function_b():
    print('前單底線命名的函式')

>>> from my_module import *
>>> function_a()
一般命名的函式
>>> _function_b()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name '_function_b' is not defined

# 如果你刻意要使用前單底線命名的內容
# 需要明確寫出你要 import 它 
>>> from my_module import _function_b
>>> _function_b()
前單底線命名的函式

# 相信大家都知道，dict 是 Python 內建類別
>>> dict
<class 'dict'>
>>> dict()
{}
>>> d = dict()
>>> d['a'] = 123
>>> d
{'a': 123}

# 如果你真的把一個「字典」功能的變數用 'dict' 命名
>>> dict = {'apple': '蘋果', 'banana': '香蕉', 'grava': '拔辣'}
>>> dict
{'apple': '蘋果', 'banana': '香蕉', 'grava': '拔辣'}

# 你會發現你不能再正常使用 Python 的 dict()！
# 因為 dict 被你「覆蓋」掉了
>>> d = dict()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'dict' object is not callable

# 你如果堅持要用 'dict' 來命名
# 通融一下加上底線改成 'dict_'
# 就能跟 Python 和平共處了！
>>> dict_ = {'apple': '蘋果', 'banana': '香蕉', 'grava': '拔辣'}
>>> dict_
{'apple': '蘋果', 'banana': '香蕉', 'grava': '拔辣'}

>>> d = dict()
>>> d
{}

# 函式參數用 'class' 命名會直接出錯
>>> def my_function(class): print(class)
  File "<stdin>", line 1
    def my_function(class): print(class)
                    ^
SyntaxError: invalid syntax
# 真要用的話就加個底線吧
>>> def my_function(class_): print(class_)
>>> my_function(class_="hello world")
hello world

# BeautifulSoup 的 find_all() 函式節錄範例
>>> soup.find_all("a", class_="sister")
[<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

class MyClass:
    def __init__(self):
        self.bar = 0
        self.foo = 1
        self._foo = 2
        self.foo_ = 3
        self.__foo = 4

>>> my_class = MyClass()
>>> my_class.bar
0
>>> my_class.foo
1
>>> my_class._foo
2
>>> my_class.foo_
3

>>> my_class.__foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute '__foo'

>>> dir(my_class)
['_MyClass__foo', '__class__', ... （中間省略） ... , '__weakref__', '_foo', 'bar', 'foo', 'foo_']

>>> my_class._MyClass__foo
4

# 注意：
# 1. 此類別繼承自 MyClass
# 2. 此類別內「沒有」宣告類別變數 bar

class MyChildClass(MyClass):
    def __init__(self):
        super().__init__()
        self.foo = 11111
        self._foo = 22222
        self.foo_ = 33333
        self.__foo = 44444

>>> my_child_class = MyChildClass()
# 從 MyClass 繼承來的
>>> my_child_class.bar  
0

# 以下三個變數都被子類別覆蓋了
>>> my_child_class.foo
11111
>>> my_child_class._foo
22222
>>> my_child_class.foo_
33333

# __foo 依然不能直接取得
>>> my_child_class.__foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyChildClass' object has no attribute '__foo'

# 需要利用我們剛剛學的名字修飾來取得 __foo
>>> my_child_class._MyChildClass__foo
44444

# 使用正確的名字修飾
# 就可以取得父類別（MyClass）的 __foo 變數資料
# 最重要的是：父類別的這個前雙底線命名變數 *沒有* 被子類別覆蓋！
>>> my_child_class._MyClass__foo
4

class MyHahaClass:
    def __laugh(self):
        print("哈哈 ^_^")

    def call_laugh_method(self):
        return self.__laugh()    # 特別注意函式主體的此處還沒有發生名字修飾

>>> my_haha_class = MyHahaClass()

# 同樣地，函式命名如果是前雙底線，不能直接用該命名呼叫
>>> my_haha_class.__laugh()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyHahaClass' object has no attribute '__laugh'

# 用經過名字修飾的函式命名就可以了
>>> my_haha_class._MyHahaClass__laugh()
哈哈 ^_^

# 或是，在函式主體內的另個函式可以用 self.__laugh() 來呼叫它
>>> my_haha_class.call_laugh_method()
哈哈 ^_^

_MangledGlobal__mangled = 23

class MangledGlobal:
    def test(self):
        return __mangled

>>> MangledGlobal().test()
23

_MangledGlobal__mangled = 23

class MangledGlobal:
    def __init__(self):
        self.__mangled = 9527

    def test(self):
        return __mangled

    def test2(self):
        return self.__mangled

>>> MangledGlobal().test()
23

>>> MangledGlobal().test2()
9527

class MyLessClass:
    def __lt__(self, another):
        print('hello world')

>>> my_less_class1 = MyLessClass()
>>> my_less_class2 = MyLessClass()
>>> my_less_class1.__lt__(my_less_class2)
hello world

>>> my_less_class1 < my_less_class2
hello world
# 目前這個「小於」只是被實作
# 邏輯上根本沒做到比大小