hiskio

    Effective Python中文版 第三版｜寫出良好Python程式的125個具體做法

    延續前兩版好評，集結125個實戰驗證技巧，全面涵蓋Python 3.11最新語法。不只告訴你「怎麼寫」，更說明「為什麼這樣寫比較好」，帶你從語言使用者晉升為真正精通Python的開發者。

    收集中
    US$30.56

    內容簡介


    Python被譽為最易上手的程式語言，但你真的是用Python的腦袋寫Python嗎？
    身為Python的開發者，想要「寫得更好」，還想知道「為什麼這樣寫比較好？」

    《Effective Python 第三版》延續前兩版廣受好評的風格，集結125個經過實戰驗證的開發技巧，全面涵蓋Python 3.11最新語法與標準函式庫。從基礎語言機制、函式與類別設計，到協同程式、型別提示與效能優化，每一項建議都清楚說明「為什麼這樣寫比較好」，幫助你避開常見雷區、寫出更簡潔、可維護、具備Python風格的程式碼。

    條目式設計，查找方便、精練實用
    專為Python 3.11打造，掌握語言最新演進
    每個條目皆含範例、反例與最佳實踐
    作者為Google資深工程師，實戰經驗豐富

    不僅告訴你「怎麼寫」，更像是經驗豐富的前輩手把手教你「為什麼這樣寫更好」，帶你從語言使用者晉升為真正精通Python的開發者！

    -----------------------------------------------------------------------

    精通Python程式設計技術，掌握125個具體可行的最佳實務做法，寫出更加高效、易讀、易維護的程式碼

    Python是一門功能多元且強大的語言，但想真正發揮它的潛力，光是熟悉語法還不夠。Effective Python中文版 第三版，是你掌握Python獨特優勢、避開隱藏陷阱的全方位指南。本書奠基於廣受好評的第二版，將最佳實務做法從90項擴增至125項，這些都是撰寫高品質 Python 程式碼的關鍵基石。

    作者Brett Slatkin汲取其多年在Google的深厚實務經驗，為初階與資深的Python開發者提供了清晰、簡潔且實用的建議。書中每一個做法都深入剖析了「Pythonic」的程式設計之道，幫助你理解如何寫出不僅正確、有效，更能兼具優雅與易維護性的程式碼。無論你是在建構Web應用程式、分析資料、撰寫自動化指令稿，或是訓練AI模型，本書都將賦予你必要的技能，讓你能運用Python創造非凡的影響力。

    主要特點包括
    ■ 內容升級：新增35個全新做法，擴增至125條具體可行的準則。
    ■ 對應新版：涵蓋至Python3.13新版功能的語法與實務趨勢。
    ■ 新增章節：剖析如何建置兼具穩健性與高效能的程式。
    ■ 進階主題：深入探討如何建立C擴充模組，以及與原生共享程式庫的介接。
    ■ 實際範例：切合真實情境的程式碼範例，清楚對照每一項建議背後的最佳實務做法。

    Brett Slatkin 是Google CTO辦公室的首席軟體工程師，專注於新興技術領域。他是Google Surveys的共同創辦人，也是Google Cloud第一款產品（App Engine）的主要推手，並共同創建了PubSubHubbub協定——這些專案全都使用Python完成。他投入專業Python開發逾19年，擁有哥倫比亞大學電腦工程學士學位。

    作者介紹


    Brett Slatkin 是Google CTO辦公室的首席軟體工程師，專注於新興技術領域。他是Google Surveys的共同創辦人，也是Google Cloud第一款產品（App Engine）的主要推手，並共同創建了PubSubHubbub協定——這些專案全都使用Python完成。他投入專業Python開發逾19年，擁有哥倫比亞大學電腦工程學士學位。

    目錄


    第1章　Pythonic 思維
    做法 01 了解你使用的是哪個版本的 Python
    做法 02 遵循 PEP 8 風格指南
    做法 03 永遠不要預期 Python 會在編譯時期偵測錯誤
    做法 04 撰寫輔助函式而非複雜的運算式
    做法 05 比起透過索引，請優先選用多重指定的拆分
    做法 06 始終用括弧圍住單元素的元組
    做法 07 考慮使用條件運算式來處理簡單的行內邏輯
    做法 08 使用指定運算式來防止重複
    做法 09 考慮在流程控制中使用 match 進行解構；如果 if 述句就足夠，則避免使用

    第2章　字串和切片
    做法 10 了解 bytes 與 str 之間的差異
    做法 11 優先選用內插的 F-String，而非 C 式格式字串和 str.format
    做法 12 列印物件時，要知道 repr 和 str 之間的差異
    做法 13 偏好明確的字串串接，而非隱含的串接，特別是在串列中
    做法 14 知道如何切割序列
    做法 15 避免在單一運算式中同時使用跨步（Striding）和切片
    做法 16 優先選用捕捉全部的拆分，而非切片

    第3章　迴圈與迭代器
    做法 17 優先選用 enumerate，而不是 range
    做法 18 使用 zip 平行處理迭代器
    做法 19 避免 for 和 while 迴圈之後的 else 區塊
    做法 20 永遠別在迴圈結束後使用 for 的迴圈變數
    做法 21 迭代引數時要做好防禦
    做法 22 絕對不要在迭代容器時修改它們；改用複本或快取
    做法 23 將迭代器傳遞給 any 和 all，以實現有效率的短路邏輯
    做法 24 考慮使用 itertools 來處理迭代器和產生器

    第4章　字典
    做法 25 依賴字典插入順序時，請務必謹慎
    做法 26 優先選用 get 而非 in 和 KeyError 來處理缺少的字典鍵值
    做法 27 偏好使用 defaultdict 而非 setdefault 來處理內部狀態中缺少的項目
    做法 28 了解如何使用 __missing__ 建構依存於鍵值的預設值
    做法 29 使用類別取代深層內嵌的字典、串列和元組

    第5章　函式
    做法 30 知道函式引數是可以變動的
    做法 31 回傳專用的結果物件，而非要求函式呼叫者拆分三個以上的變數
    做法 32 偏好提出例外，而非回傳 None
    做法 33 了解 Closure 如何與變數範疇和 nonlocal 互動
    做法 34 使用數目可變的位置引數減少視覺雜訊
    做法 35 藉由關鍵字引數提供可選行為
    做法 36 使用 None 和 Docstring 來指定動態預設引數
    做法 37 使用僅限關鍵字引數和僅限位置引數來確保程式碼清楚易懂
    做法 38 使用 functools.wraps 定義函式裝飾器
    做法 39 對於黏合用的函式，請優先選用 functools.partial 而非 lambda 運算式

    第6章　概括式和產生器
    做法 40 使用概括式取代 map 和 filter
    做法 41 避免在概括式中使用超過兩個控制子運算式
    做法 42 利用指定運算式減少概括式中的重複
    做法 43 考慮使用產生器而非回傳串列
    做法 44 考慮使用產生器運算式來處理大型串列概括式
    做法 45 用 yield from 組合多個產生器
    做法 46 將迭代器作為引數傳遞給產生器，而非呼叫 send 方法
    做法 47 使用類別管理迭代式狀態變遷，而非產生器的 throw 方法

    第7章　類別與介面
    做法 48 對於簡單的介面，請接受函式而非類別
    做法 49 優先採用物件導向的多型機制，而非帶有 isinstance 檢查的函式
    做法 50 考慮使用 functools.singledispatch 進行函式型風格的程式設計，取代物件導向的多型
    做法 51 定義輕量化類別時，請優先選用 dataclasses
    做法 52 使用 @classmethod 的多型機制以泛型的方式建構物件
    做法 53 使用 super 初始化父類別
    做法 54 考慮使用 Mix-in 類別來組合功能
    做法 55 優先選用公開屬性而非私有屬性
    做法 56 偏好使用 dataclasses 來建立不可變的物件
    做法 57 繼承 collections.abc 的類別以建立自訂的容器型別

    第8章　元類別與屬性
    做法 58 使用普通的屬性，而非設值器和取值器方法
    做法 59 考慮使用 @property，而非重構屬性
    做法 60 使用描述器來實現可重複使用的 @property 方法
    做法 61 使用 __getattr__、__getattribute__ 和 __setattr__ 實現惰性屬性
    做法 62 使用 __init_subclass__ 驗證子類別
    做法 63 使用 __init_subclass__ 註冊類別的存在
    做法 64 使用 __set_name__ 來注釋類別屬性
    做法 65 考慮以類別主體定義順序來確立屬性之間的關係
    做法 66 對於可組合的類別擴充，請優先選用類別裝飾器而非元類別

    第9章　共時性和平行處理
    做法 67 使用 subprocess 來管理子行程
    做法 68 針對會造成阻斷的 I/O 使用執行緒；避免用於平行處理
    做法 69 使用 Lock 來預防執行緒之間的資料競態
    做法 70 使用 Queue 來協調執行緒之間的工作
    做法 71 知道何時需要共時性
    做法 72 避免為視需要增加的扇出創建新的 Thread 實體
    做法 73 了解將 Queue 用於共時性會需要怎樣的重構
    做法 74 非得將執行緒用於共時性時，考慮使用 ThreadPoolExecutor
    做法 75 藉由協程實現高度共時的 I/O
    做法 76 知道如何將分緒的 I/O（Threaded I/O）移植到 asyncio
    做法 77 混合執行緒與協程，以簡化轉換至 asyncio 的工作
    做法 78 利用對 async 友善的工作者執行緒最大化 asyncio 事件迴圈的回應性
    做法 79 考慮使用 concurrent.futures 實現真正的平行處理

    第10章　穩健性
    做法 80 善用 try/except/else/finally 中的每個區塊
    做法 81 使用 assert 斷言內部假設並以 raise 提出未符合預期之處
    做法 82 考慮使用 contextlib 與 with 述句以達成可重複使用的 try/finally 行為
    做法 83 務必讓 try 區塊盡可能簡短
    做法 84 小心會消失的例外變數
    做法 85 捕捉 Exception 類別時務必小心
    做法 86 了解 Exception 和 BaseException 之間的差異
    做法 87 使用 traceback 強化例外回報
    做法 88 考慮明確地鏈串例外以釐清回溯追蹤
    做法 89 始終將資源（Resources）傳入產生器中，並讓呼叫者在外部清理它們
    做法 90 絕不要將 __debug__ 設為 False
    做法 91 除非你正在建置開發人員工具，否則應避免使用 exec 和 eval

    第11章　效能
    做法 92 最佳化前，請先進行效能評測
    做法 93 使用 timeit 微型基準化分析來最佳化關鍵效能程式碼
    做法 94 了解何時應改用其他程式語言來取代 Python，並知道該怎麼做
    做法 95 考慮使用 ctypes 與原生程式庫快速整合
    做法 96 考慮使用擴充模組來最佳化效能和開發者體驗
    做法 97 仰賴預先編譯的位元組碼與檔案系統快取來改善啟動時間
    做法 98 使用動態匯入來惰性載入模組以減少啟動時間
    做法 99 考慮透過 memoryview 和 bytearray 與 bytes 進行零拷貝互動

    第12章　資料結構與演算法
    做法 100 使用 key 參數來以複雜的條件進行排序
    做法 101 了解 sort 與 sorted 之間的差異
    做法 102 考慮使用 bisect 搜尋排序好的序列
    做法 103 優先選用 deque 作為 Producer–Consumer 佇列
    做法 104 知道如何使用 heapq 建立優先序佇列
    做法 105 針對本地時間，請使用 datetime 而非 time
    做法 106 當精確度至關重要時，請使用 decimal
    做法 107 透過 copyreg 讓 pickle 序列化保有可維護性

    第13章　測試與除錯
    做法 108 在 TestCase 的子類別中驗證相關行為
    做法 109 偏好整合測試而非單元測試
    做法 110 使用 setUp、tearDown、setUpModule 和 tearDownModule 將測試彼此隔離
    做法 111 使用模擬功能來測試具有複雜依存關係的程式碼
    做法 112 將依存關係封裝起來以利模擬與測試
    做法 113 使用 assertAlmostEqual 控制浮點測試中的精確度
    做法 114 考慮使用 pdb 進行互動式除錯
    做法 115 使用 tracemalloc 來了解記憶體用量（Memory Usage）與洩漏（Leaks）情況

    第14章　協作
    做法 116 知道在哪裡可以找到社群建置的模組
    做法 117 使用虛擬環境以達成獨立且可重現的依存關係
    做法 118 為每個函式、類別和模組撰寫 Docstring
    做法 119 使用套件來組織模組並提供穩定的 API
    做法 120 考慮使用模組範疇程式碼來設定部署環境
    做法 121 定義一個根例外以隔離呼叫端與 API
    做法 122 知道如何打破循環依存關係
    做法 123 考慮使用 warnings 來重構及遷移用法
    做法 124 考慮透過 typing 進行靜態分析以消除臭蟲
    做法 125 捆裝 Python 程式時，優先選擇開源專案而非 zipimport 與 zipapp

    章節目錄

    • 1-1
      封面頁
    • 1-2
      書名頁
    • 1-3
      目錄
    • 1-4
      前言
    • 1-5
      致謝
    • 1-6
      關於作者
    • 1-7
      Ch01 Pythonic 思維
    • 1-8
      01 了解你使用的是哪個版本的 Python
    • 1-9
      02 遵循 PEP 8 風格指南
    • 1-10
      03 永遠不要預期 Python 會在編譯時期偵測錯誤
    • 1-11
      04 撰寫輔助函式而非複雜的運算式
    • 1-12
      05 比起透過索引，請優先選用多重指定的拆分
    • 1-13
      06 始終用括弧圍住單元素的元組
    • 1-14
      07 考慮使用條件運算式來處理簡單的行內邏輯
    • 1-15
      08 使用指定運算式來防止重複
    • 1-16
      09 考慮在流程控制中使用 match 進行解構；如果 if 述句就足夠，則避免使用
    • 1-17
      Ch02 字串和切片
    • 1-18
      10 了解 bytes 與 str 之間的差異
    • 1-19
      11 優先選用內插的 F-String，而非 C 式格式字串和 str.format
    • 1-20
      12 列印物件時，要知道 repr 和 str 之間的差異
    • 1-21
      13 偏好明確的字串串接，而非隱含的串接，特別是在串列中
    • 1-22
      14 知道如何切割序列
    • 1-23
      15 避免在單一運算式中同時使用跨步（Striding）和切片
    • 1-24
      16 優先選用捕捉全部的拆分，而非切片
    • 1-25
      Ch03 迴圈與迭代器
    • 1-26
      17 優先選用 enumerate，而不是 range
    • 1-27
      18 使用 zip 平行處理迭代器
    • 1-28
      19 避免 for 和 while 迴圈之後的 else 區塊
    • 1-29
      20 永遠別在迴圈結束後使用 for 的迴圈變數
    • 1-30
      21 迭代引數時要做好防禦
    • 1-31
      22 絕對不要在迭代容器時修改它們；改用複本或快取
    • 1-32
      23 將迭代器傳遞給 any 和 all，以實現有效率的短路邏輯
    • 1-33
      24 考慮使用 itertools 來處理迭代器和產生器
    • 1-34
      Ch04 字典
    • 1-35
      25 依賴字典插入順序時，請務必謹慎
    • 1-36
      26 優先選用 get 而非 in 和 KeyError 來處理缺少的字典鍵值
    • 1-37
      27 偏好使用 defaultdict 而非 setdefault來處理內部狀態中缺少的項目
    • 1-38
      28 了解如何使用 __missing__ 建構依存於鍵值的預設值
    • 1-39
      29 使用類別取代深層內嵌的字典、串列和元組
    • 1-40
      Ch05 函式
    • 1-41
      30 知道函式引數是可以變動的
    • 1-42
      31 回傳專用的結果物件，而非要求函式呼叫者拆分三個以上的變數
    • 1-43
      32 偏好提出例外，而非回傳 None
    • 1-44
      33 了解 Closure 如何與變數範疇和 nonlocal互動
    • 1-45
      34 使用數目可變的位置引數減少視覺雜訊
    • 1-46
      35 藉由關鍵字引數提供可選行為
    • 1-47
      36 使用 None 和 Docstring 來指定動態預設引數
    • 1-48
      37 使用僅限關鍵字引數和僅限位置引數來確保程式碼清楚易懂
    • 1-49
      38 使用 functools.wraps 定義函式裝飾器
    • 1-50
      39 對於黏合用的函式，請優先選用functools.partial 而非 lambda 運算式
    • 1-51
      Ch06 概括式和產生器
    • 1-52
      40 使用概括式取代 map 和 filter
    • 1-53
      41 避免在概括式中使用超過兩個控制子運算式
    • 1-54
      42 利用指定運算式減少概括式中的重複
    • 1-55
      43 考慮使用產生器而非回傳串列
    • 1-56
      44 考慮使用產生器運算式來處理大型串列概括式
    • 1-57
      45 用 yield from 組合多個產生器
    • 1-58
      46 將迭代器作為引數傳遞給產生器，而非呼叫send 方法
    • 1-59
      47 使用類別管理迭代式狀態變遷，而非產生器的 throw 方法
    • 1-60
      Ch07 類別和介面
    • 1-61
      48 對於簡單的介面，請接受函式而非類別
    • 1-62
      49 優先採用物件導向的多型機制，而非帶有isinstance 檢查的函式
    • 1-63
      50 考慮使用 functools.singledispatch 進行函式型風格的程式設計，取代物件導向的多型
    • 1-64
      51 定義輕量化類別時，請優先選用 dataclasses
    • 1-65
      52 使用@classmethod 的多型機制以泛型的方式建構物件
    • 1-66
      53 使用 super 初始化父類別
    • 1-67
      54 考慮使用 Mix-in 類別來組合功能
    • 1-68
      55 優先選用公開屬性而非私有屬性
    • 1-69
      56 偏好使用 dataclasses 來建立不可變的物件
    • 1-70
      57 繼承 collections.abc 的類別以建立自訂的容器型別
    • 1-71
      Ch08 元類別和屬性
    • 1-72
      58 使用普通的屬性，而非設值器和取值器方法
    • 1-73
      59 考慮使用 @property，而非重構屬性
    • 1-74
      60 使用描述器來實現可重複使用的 @property方法
    • 1-75
      61 使用 __getattr__、__getattribute__和 __setattr__ 實現惰性屬性
    • 1-76
      62 使用 __init_subclass__ 驗證子類別
    • 1-77
      63 使用 __init_subclass__ 註冊類別的存在
    • 1-78
      64 使用 __set_name__ 來注釋類別屬性
    • 1-79
      65 考慮以類別主體定義順序來確立屬性之間的關係
    • 1-80
      66 對於可組合的類別擴充，請優先選用類別裝飾器而非元類別
    • 1-81
      Ch09 共時性和平行處理
    • 1-82
      67 使用 subprocess 來管理子行程
    • 1-83
      68 針對會造成阻斷的 I/O 使用執行緒；避免用於平行處理
    • 1-84
      69 使用 Lock 來預防執行緒之間的資料競態
    • 1-85
      70 使用 Queue 來協調執行緒之間的工作
    • 1-86
      71 知道何時需要共時性
    • 1-87
      72 避免為視需要增加的扇出創建新的 Thread實體
    • 1-88
      73 了解將 Queue 用於共時性會需要怎樣的重構
    • 1-89
      74 非得將執行緒用於共時性時，考慮使用 ThreadPoolExecutor
    • 1-90
      75 藉由協程實現高度共時的 I/O
    • 1-91
      76 知道如何將分緒的 I/O（Threaded I/O）移植到 asyncio
    • 1-92
      77 混合執行緒與協程，以簡化轉換至 asyncio的工作
    • 1-93
      78 利用對 async 友善的工作者執行緒最大化asyncio 事件迴圈的回應性
    • 1-94
      79 考慮使用 concurrent.futures 實現真正的平行處理撰寫 Python 程式的過程中，
    • 1-95
      Ch10 穩健性
    • 1-96
      80 善用 try/except/else/finally 中的每個區塊
    • 1-97
      81 使用 assert 斷言內部假設並以 raise 提出未符合預期之處
    • 1-98
      82 考慮使用 contextlib 與 with 述句以達成可重複使用的 try/finally 行為
    • 1-99
      83 務必讓 try 區塊盡可能簡短
    • 1-100
      84 小心會消失的例外變數
    • 1-101
      85 捕捉 Exception 類別時務必小心
    • 1-102
      86 了解 Exception 和 BaseException 之間的差異
    • 1-103
      87 使用 traceback 強化例外回報
    • 1-104
      88 考慮明確地鏈串例外以釐清回溯追蹤
    • 1-105
      89 始終將資源（Resources）傳入產生器中，並讓呼叫者在外部清理它們
    • 1-106
      90 絕不要將 __debug__ 設為 False
    • 1-107
      91 除非你正在建置開發人員工具，否則應避免使用 exec 和 eval
    • 1-108
      Ch11 效能
    • 1-109
      92 最佳化前，請先進行效能評測
    • 1-110
      93 使用 timeit 微型基準化分析來最佳化關鍵效能程式碼
    • 1-111
      94 了解何時應改用其他程式語言來取代Python，並知道該怎麼做
    • 1-112
      95 考慮使用 ctypes 與原生程式庫快速整合
    • 1-113
      96 考慮使用擴充模組來最佳化效能和開發者體驗
    • 1-114
      97 仰賴預先編譯的位元組碼與檔案系統快取來改善啟動時間
    • 1-115
      98 使用動態匯入來惰性載入模組以減少啟動時間
    • 1-116
      99 考慮透過 memoryview 和 bytearray與 bytes 進行零拷貝互動
    • 1-117
      Ch12 資料結構與演算法
    • 1-118
      100 使用 key 參數來以複雜的條件進行排序
    • 1-119
      101 了解 sort 與 sorted 之間的差異
    • 1-120
      102 考慮使用 bisect 搜尋排序好的序列
    • 1-121
      103 優先選用 deque 作為 Producer–Consumer佇列
    • 1-122
      104 知道如何使用 heapq 建立優先序佇列
    • 1-123
      105 針對本地時間，請使用 datetime 而非 time
    • 1-124
      106 當精確度至關重要時，請使用 decimal
    • 1-125
      107 透過 copyreg 讓 pickle 序列化保有可維護性
    • 1-126
      Ch13 測試與除錯
    • 1-127
      108 在 TestCase 的子類別中驗證相關行為
    • 1-128
      109 偏好整合測試而非單元測試
    • 1-129
      110 使用 setUp、tearDown、setUpModule 和tearDownModule 將測試彼此隔離
    • 1-130
      111 使用模擬功能來測試具有複雜依存關係的程式碼
    • 1-131
      112 將依存關係封裝起來以利模擬與測試
    • 1-132
      113 使用 assertAlmostEqual 控制浮點測試中的精確度
    • 1-133
      114 考慮使用 pdb 進行互動式除錯
    • 1-134
      115 使用 tracemalloc 來了解記憶體用量（Memory Usage）與洩漏（Leaks）情況
    • 1-135
      Ch14 協作
    • 1-136
      116 知道在哪裡可以找到社群建置的模組
    • 1-137
      117 使用虛擬環境以達成獨立且可重現的依存關係
    • 1-138
      118 為每個函式、類別和模組撰寫 Docstring
    • 1-139
      119 使用套件來組織模組並提供穩定的 API
    • 1-140
      120 考慮使用模組範疇程式碼來設定部署環境
    • 1-141
      121 定義一個根例外以隔離呼叫端與 API
    • 1-142
      122 知道如何打破循環依存關係
    • 1-143
      123 考慮使用 warnings 來重構及遷移用法
    • 1-144
      124 考慮透過 typing 進行靜態分析以消除臭蟲
    • 1-145
      125 捆裝 Python 程式時，優先選擇開源專案而非 zipimport 與 zipapp
    • 1-146
      索引
    • 1-147
      版權頁
    • 1-148
      封底頁

    常見問答

    您可以透過手機、平板或是電腦登入 HiSKIO 平台，在【我的學習】＞【我的書籍】頁面，選擇想看的電子書。

    猜你喜歡

    | 尚無內容

    用戶評價

    | 收集中

    銷售方案