序言

這是 “Python 工匠”系列的第 3 篇文章。
數(shù)字是幾乎所有編程語言里最基本的數(shù)據(jù)類型，它是我們通過代碼連接現(xiàn)實世界的基礎(chǔ)。在 Python 里有三種數(shù)值類型：整型（int）、浮點型（float）和復(fù)數(shù)（complex）。絕大多數(shù)情況下，我們只需要和前兩種打交道。

站在用戶的角度思考問題，與客戶深入溝通，找到和田網(wǎng)站設(shè)計與和田網(wǎng)站推廣的解決方案，憑借多年的經(jīng)驗，讓設(shè)計與互聯(lián)網(wǎng)技術(shù)結(jié)合，創(chuàng)造個性化、用戶體驗好的作品，建站類型包括：網(wǎng)站設(shè)計制作、成都網(wǎng)站建設(shè)、企業(yè)官網(wǎng)、英文網(wǎng)站、手機端網(wǎng)站、網(wǎng)站推廣、主機域名、網(wǎng)絡(luò)空間、企業(yè)郵箱。業(yè)務(wù)覆蓋和田地區(qū)。

整型在 Python 中比較讓人省心，因為它不區(qū)分有無符號并且永不溢出。但浮點型仍和絕大多數(shù)其他編程語言一樣，依然有著精度問題，經(jīng)常讓很多剛進入編程世界大門的新人們感到困惑："Why Are Floating Point Numbers Inaccurate?"。

相比數(shù)字，Python 里的字符串要復(fù)雜的多。要掌握它，你得先弄清楚 bytes 和 str 的區(qū)別。如果更不巧，你還是位 Python2 用戶的話，就夠你喝上好幾壺了光 unicode 和字符編碼問題（趕快遷移到 Python3 吧，就在今天！）。

不過，上面提到的這些都不是這篇文章的主題，如果感興趣，你可以在網(wǎng)上找到成堆的相關(guān)資料。在這篇文章里，我們將討論一些 更細微、更不常見 的編程實踐。來幫助你寫出更好的 Python 代碼。

---

內(nèi)容目錄

• 最佳實踐
  1 少寫數(shù)字字面量，使用 enum 枚舉類型改善代碼
  2 別在裸字符串處理上走太遠
  3 不必預(yù)計算字面量表達式
• 實用技巧
  1 當多級縮進里出現(xiàn)多行字符串時
  2 布爾值其實也是“數(shù)字”
  3 改善超長字符串的可讀性
  4 別忘了那些 “r” 開頭的內(nèi)建字符串函數(shù)
  5 使用“無窮大” float("inf")
• 常見誤區(qū)
  1 “value = 1” 并非線程安全
  2 字符串拼接并不慢

---

最佳實踐

1. 少寫數(shù)字字面量

“數(shù)字字面量（integer literal）” 是指那些直接出現(xiàn)在代碼里的數(shù)字。它們分布在代碼里的各個角落，比如代碼 del users[0] 里的 0 就是一個數(shù)字字面量。它們簡單、實用，每個人每天都在寫。但是，當你的代碼里不斷重復(fù)出現(xiàn)一些特定字面量時，你的“代碼質(zhì)量告警燈”就應(yīng)該亮起黃燈了。

舉個例子，假如你剛加入一家心儀已久的新公司，同事轉(zhuǎn)交給你的項目里有這么一個函數(shù)：

def mark_trip_as_featured(trip):
    """將某個旅程添加到推薦欄目
    """
    if trip.source == 11:
        do_some_thing(trip)
    elif trip.source == 12:
        do_some_other_thing(trip)
    ... ...
    return

這個函數(shù)做了什么事？你努力想搞懂它的意思，不過 trip.source == 11 是什么情況？那 == 12 呢？這兩行代碼很簡單，沒有用到任何魔法特性。但初次接觸代碼的你可能需要花費一整個下午，才能弄懂它們的含義。
問題就出在那幾個數(shù)字字面量上。 最初寫下這個函數(shù)的人，可能是在公司成立之初加入的那位元老程序員。而他對那幾個數(shù)字的含義非常清楚。但如果你是一位剛接觸這段代碼的新人，就完全是另外一碼事了。

使用 enum 枚舉類型改善代碼

那么，怎么改善這段代碼？最直接的方式，就是為這兩個條件分支添加注釋。不過在這里，“添加注釋”顯然不是提升代碼可讀性的最佳辦法（其實在絕大多數(shù)其他情況下都不是）。我們需要用有意義的名稱來代替這些字面量，而 枚舉類型（enum）用在這里最合適不過了。

enum 是 Python 自 3.4 版本引入的內(nèi)置模塊，如果你使用的是更早的版本，可以通過 pip install enum34 來安裝它。下面是使用 enum 的樣例代碼：

# -*- coding: utf-8 -*-
from enum import IntEnum

class TripSource(IntEnum):
    FROM_WEBSITE = 11
    FROM_IOS_CLIENT = 12


def mark_trip_as_featured(trip):
    if trip.source == TripSource.FROM_WEBSITE:
        do_some_thing(trip)
    elif trip.source == TripSource.FROM_IOS_CLIENT:
        do_some_other_thing(trip)
    ... ...
    return

將重復(fù)出現(xiàn)的數(shù)字字面量定義成枚舉類型，不光可以改善代碼的可讀性，代碼出現(xiàn) Bug 的幾率也會降低。
試想一下，如果你在某個分支判斷時將 11 錯打成了 111 會怎么樣？我們時常會犯這種錯，而這類錯誤在早期特別難被發(fā)現(xiàn)。將這些數(shù)字字面量全部放入枚舉類型中可以比較好的規(guī)避這類問題。類似的，將字符串字面量改寫成枚舉也可以獲得同樣的好處。

使用枚舉類型代替字面量的好處：

• 提升代碼可讀性：所有人都不需要記憶某個神奇的數(shù)字代表什么
• 提升代碼正確性：減少打錯數(shù)字或字母產(chǎn)生 bug 的可能性

當然，你完全沒有必要把代碼里的所有字面量都改成枚舉類型。 代碼里出現(xiàn)的字面量，只要在它所處的上下文里面容易理解，就可以使用它。 比如那些經(jīng)常作為數(shù)字下標出現(xiàn)的 0 和 -1 就完全沒有問題，因為所有人都知道它們的意思。

2. 別在裸字符串處理上走太遠

什么是“裸字符串處理”？在這篇文章里，它指只使用基本的加減乘除和循環(huán)、配合內(nèi)置函數(shù)/方法來操作字符串，獲得我們需要的結(jié)果。

所有人都寫過這樣的代碼。有時候我們需要拼接一大段發(fā)給用戶的告警信息，有時我們需要構(gòu)造一大段發(fā)送給數(shù)據(jù)庫的 SQL 查詢語句，就像下面這樣：

def fetch_users(conn, min_level=None, gender=None, has_membership=False, sort_field="created"):
    """獲取用戶列表

    :param int min_level: 要求的最低用戶級別，默認為所有級別
    :param int gender: 篩選用戶性別，默認為所有性別
    :param int has_membership: 篩選所有會員/非會員用戶，默認非會員
    :param str sort_field: 排序字段，默認為按 created "用戶創(chuàng)建日期"
    :returns: 列表：[(User ID, User Name), ...]
    """
    # 一種古老的 SQL 拼接技巧，使用 "WHERE 1=1" 來簡化字符串拼接操作
    # 區(qū)分查詢 params 來避免 SQL 注入問題
    statement = "SELECT id, name FROM users WHERE 1=1"
    params = []
    if min_level is not None:
        statement += " AND level >= ?"
        params.append(min_level)
    if gender is not None:
        statement += " AND gender >= ?"
        params.append(gender)
    if has_membership:
        statement += " AND has_membership == true"
    else:
        statement += " AND has_membership == false"
    
    statement += " ORDER BY ?"
    params.append(sort_field)
    return list(conn.execute(statement, params))

我們之所以用這種方式拼接出需要的字符串 - 在這里是 SQL 語句 - 是因為這樣做簡單、直接，符合直覺。但是這樣做最大的問題在于：隨著函數(shù)邏輯變得更復(fù)雜，這段拼接代碼會變得容易出錯、難以擴展。事實上，上面這段 Demo 代碼也只是僅僅做到看上去沒有明顯的 bug 而已 （誰知道有沒有其他隱藏問題）。

其實，對于 SQL 語句這種結(jié)構(gòu)化、有規(guī)則的字符串，用對象化的方式構(gòu)建和編輯它才是更好的做法。下面這段代碼用SQLAlchemy 模塊完成了同樣的功能：

def fetch_users_v2(conn, min_level=None, gender=None, has_membership=False, sort_field="created"):
    """獲取用戶列表
    """
    query = select([users.c.id, users.c.name])
    if min_level is not None:
        query = query.where(users.c.level >= min_level)
    if gender is not None:
        query = query.where(users.c.gender == gender)
    query = query.where(users.c.has_membership == has_membership).order_by(users.c[sort_field])
    return list(conn.execute(query))

上面的 fetch_users_v2 函數(shù)更短也更好維護，而且根本不需要擔(dān)心 SQL 注入問題。所以，當你的代碼中出現(xiàn)復(fù)雜的裸字符串處理邏輯時，請試著用下面的方式替代它：

Q: 目標/源字符串是結(jié)構(gòu)化的，遵循某種格式嗎？

是：找找是否已經(jīng)有開源的對象化模塊操作它們，或是自己寫一個
SQL：SQLAlchemy
XML：lxml
JSON、YAML ...

否：嘗試使用模板引擎而不是復(fù)雜字符串處理邏輯來達到目的
Jinja2
mako
Mustache

3. 不必預(yù)計算字面量表達式

我們的代碼里偶爾會出現(xiàn)一些比較復(fù)雜的數(shù)字，就像下面這樣

def f1(delta_seconds):
    # 如果時間已經(jīng)過去了超過 11 天，不做任何事
    if delta_seconds > :
        return 
    ...

話說在前頭，上面的代碼沒有任何毛病。

首先，我們在小本子（當然，和我一樣的聰明人會用 IPython）上算了算：11天一共包含多少秒？。然后再把結(jié)果 這個神奇的數(shù)字填進我們的代碼里，最后心滿意足的在上面補上一行注釋：告訴所有人這個神奇的數(shù)字是怎么來的。

我想問的是：“為什么我們不直接把代碼寫成 if delta_seconds < 11 * 24 * 3600: 呢？”

“性能”，答案一定會是“性能”。我們都知道 Python 是一門（速度欠佳的）解釋型語言，所以預(yù)先計算出 正是因為我們不想讓每次對函數(shù) f1 的調(diào)用都帶上這部分的計算開銷。不過事實是：即使我們把代碼改成 if delta_seconds < 11 * 24 * 3600:，函數(shù)也不會多出任何額外的開銷。
Python 代碼在執(zhí)行時會被解釋器編譯成字節(jié)碼，而真相就藏在字節(jié)碼里。讓我們用 dis 模塊看看：

def f1(delta_seconds):
    if delta_seconds < 11 * 24 * 3600:
        return

import dis
dis.dis(f1)

# dis 執(zhí)行結(jié)果
  5           0 LOAD_FAST                0 (delta_seconds)
              2 LOAD_CONST               1 ()
              4 COMPARE_OP               0 (<)
              6 POP_JUMP_IF_FALSE       12

  6           8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
        >>   12 LOAD_CONST               0 (None)
             14 RETURN_VALU

看見上面的 2 LOAD_CONST 1 () 了嗎？這表示 Python 解釋器在將源碼編譯成成字節(jié)碼時，會計算 11 * 24 * 3600 這段整表達式，并用 替換它。

所以，當我們的代碼中需要出現(xiàn)復(fù)雜計算的字面量時，請保留整個算式吧。它對性能沒有任何影響，而且會增加代碼的可讀性。

Hint：Python 解釋器除了會預(yù)計算數(shù)值字面量表達式以外，還會對字符串、列表做類似的操作。一切都是為了性能。誰讓你們老吐槽 Python 慢呢？

---

實用技巧

1. 布爾值其實也是“數(shù)字”

Python 里的兩個布爾值 True 和 False 在絕大多數(shù)情況下都可以直接等價于 1 和 0 兩個整數(shù)來使用，就像這樣：

>>> True + 1
2
>>> 1 / False
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

那么記住這點有什么用呢？首先，它們可以配合 sum 函數(shù)在需要計算總數(shù)時簡化操作：

>>> l = [1, 2, 4, 5, 7]
>>> sum(i % 2 == 0 for i in l)
2

此外，如果將某個布爾值表達式作為列表的下標使用，可以實現(xiàn)類似三元表達式的目的：

# 類似的三元表達式："Javascript" if 2 > 1 else "Python"
>>> ["Python", "Javascript"][2 > 1]
'Javascript'

2. 改善超長字符串的可讀性

單行代碼的長度不宜太長。比如 PEP8 里就建議每行字符數(shù)不得超過 79?，F(xiàn)實世界里，大部分人遵循的單行最大字符數(shù)在 79 到 119 之間。如果只是代碼，這樣的要求是比較容易達到的，但假設(shè)代碼里需要
出現(xiàn)一段超長的字符串呢？

這時，除了使用斜杠 \ 和加號 + 將長字符串拆分為好幾段以外，還有一種更簡單的辦法：使用括號將長字符串包起來，然后就可以隨意折行了：

def main():
    logger.info(("There is something really bad happened during the process. "
                 "Please contact your administrator."))

當多級縮進里出現(xiàn)多行字符串時

日常編碼時，還有一種比較麻煩的情況。就是需要在已經(jīng)有縮進層級的代碼里，插入多行字符串字面量。因為多行字符串不能包含當前的縮進空格，所以，我們需要把代碼寫成這樣：

def main():
    if user.is_active:
        message = """Welcome, today's movie list:
- Jaw (1975)
- The Shining (1980)
- Saw (2004)""

但是這樣寫會破壞整段代碼的縮進視覺效果，顯得非常突兀。要改善它有很多種辦法，比如我們可以把這段多行字符串作為變量提取到模塊的最外層。不過，如果在你的代碼邏輯里更適合用字面量的話，你也可以用標準庫 textwrap 來解決這個問題：

from textwrap import dedent

def main():
    if user.is_active:
        # dedent 將會縮進掉整段文字最左邊的空字符串
        message = dedent("""\
            Welcome, today's movie list:
            - Jaw (1975)
            - The Shining (1980)
            - Saw (2004)""")

3. 別忘了那些 “r” 開頭的內(nèi)建字符串函數(shù)

Python 的字符串有著非常多實用的內(nèi)建方法，最常用的有 .strip()、.split() 等。這些內(nèi)建方法里的大多數(shù)，處理起來的順序都是從左往右。但是其中也包含了部分以 r 打頭的從右至左處理的鏡像方法。在處理特定邏輯時，使用它們可以讓你事半功倍。

假設(shè)我們需要解析一些訪問日志，日志格式為："{user_agent}" {content_length}

>>> log_line = '"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36" '

如果使用 .split() 將日志拆分為 (user_agent, content_length) ，我們需要這么寫：

>>> l = log_line.split()
>>> " ".join(l[:-1]), l[-1]
('"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36"', '')

但是如果使用 .rsplit() 的話，處理邏輯就更直接了：

>>> log_line.rsplit(None, 1)
['"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36"', '']

4. 使用“無窮大” float("inf")

如果有人問你：“Python 里什么數(shù)字最大/最?。俊?。你應(yīng)該怎么回答？有這樣的東西存在嗎？

答案是：“有的，它們就是：float("inf") 和 float("-inf")”。它們倆分別對應(yīng)著數(shù)學(xué)世界里的正負無窮大。當它們和任意數(shù)值進行比較時，滿足這樣的規(guī)律：float("-inf") < 任意數(shù)值 < float("inf")。

因為它們有著這樣的特點，我們可以在某些場景用上它們：

# A. 根據(jù)年齡升序排序，沒有提供年齡放在最后邊
>>> users = {"tom": 19, "jenny": 13, "jack": None, "andrew": 43}
>>> sorted(users.keys(), key=lambda user: users.get(user) or float('inf'))
['jenny', 'tom', 'andrew', 'jack']

# B. 作為循環(huán)初始值，簡化第一次判斷邏輯
>>> max_num = float('-inf')
>>> # 找到列表中最大的數(shù)字
>>> for i in [23, 71, 3, 21, 8]:
...:    if i > max_num:
...:         max_num = i
...:
>>> max_num
71

---

常見誤區(qū)

1. “value += 1” 并非線程安全

當我們編寫多線程程序時，經(jīng)常需要處理復(fù)雜的共享變量和競態(tài)等問題。

“線程安全”，通常被用來形容 某個行為或者某類數(shù)據(jù)結(jié)構(gòu)，可以在多線程環(huán)境下被共享使用并產(chǎn)生預(yù)期內(nèi)的結(jié)果。一個典型的滿足“線程安全”的模塊就是 queue 隊列模塊。

而我們常做的 value += 1 操作，很容易被想當然的認為是“線程安全”的。因為它看上去就是一個原子操作 （指一個最小的操作單位，執(zhí)行途中不會插入任何其他操作）。然而真相并非如此，雖然從 Python 代碼上來看，value += 1 這個操作像是原子的。但它最終被 Python 解釋器執(zhí)行的時候，早就不再 “原子” 了。

我們可以用前面提到的 dis 模塊來驗證一下：

def incr(value):
    value += 1


# 使用 dis 模塊查看字節(jié)碼
import dis

dis.dis(incr)
      0 LOAD_FAST                0 (value)
      2 LOAD_CONST               1 (1)
      4 INPLACE_ADD
      6 STORE_FAST               0 (value)
      8 LOAD_CONST               0 (None)
     10 RETURN_VALUE

在上面輸出結(jié)果中，可以看到這個簡單的累加語句，會被編譯成包括取值和保存在內(nèi)的好幾個不同步驟，而在多線程環(huán)境下，任意一個其他線程都有可能在其中某個步驟切入進來，阻礙你獲得正確的結(jié)果。

因此，請不要憑借自己的直覺來判斷某個行為是否“線程安全”，不然等程序在高并發(fā)環(huán)境下出現(xiàn)奇怪的 bug 時，你將為自己的直覺付出慘痛的代價。

2. 字符串拼接并不慢

我剛接觸 Python 不久時，在某個網(wǎng)站看到這樣一個說法： “Python 里的字符串是不可變的，所以每一次對字符串進行拼接都會生成一個新對象，導(dǎo)致新的內(nèi)存分配，效率非常低”。 我對此深信不疑。
所以，一直以來，我盡量都在避免使用 += 的方式去拼接字符串，而是用 "".join(str_list) 之類的方式來替代。

但是，在某個偶然的機會下，我對 Python 的字符串拼接做了一次簡單的性能測試后發(fā)現(xiàn)： Python 的字符串拼接根本就不慢！ 在查閱了一些資料后，最終發(fā)現(xiàn)了真相。

Python 的字符串拼接在 2.2 以及之前的版本確實很慢，和我最早看到的說法行為一致。但是因為這個操作太常用了，所以之后的版本里專門針對它做了性能優(yōu)化。大大提升了執(zhí)行效率。

如今使用 += 的方式來拼接字符串，效率已經(jīng)非常接近 "".join(str_list) 了。所以，該拼接時就拼接吧，不必擔(dān)心任何性能問題。

Hint: 如果你想了解更詳細的相關(guān)內(nèi)容，可以讀一下這篇文章：Python - Efficient String Concatenation in Python (2016 edition) - smcl

---

結(jié)語

以上就是『Python 工匠』系列文章的第三篇，內(nèi)容比較零碎。由于篇幅原因，一些常用的操作比如字符串格式化等，文章里并沒有涵蓋到。以后有機會再寫吧。

讓我們最后再總結(jié)一下要點：

• 編寫代碼時，請考慮閱讀者的感受，不要出現(xiàn)太多神奇的字面量
• 當操作結(jié)構(gòu)化字符串時，使用對象化模塊比直接處理更有優(yōu)勢
• dis 模塊非常有用，請多多使用它驗證你的猜測
• 多線程環(huán)境下的編碼非常復(fù)雜，要足夠謹慎，不要相信自己的直覺
• Python 語言的更新非常快，不要被別人的經(jīng)驗所左右

看完文章的你，有沒有什么想吐槽的？請留言或者在 項目 Github Issues 告訴我吧。

---

往期推薦

Python 工匠：善用變量來改善代碼質(zhì)量
Python 工匠：編寫條件分支代碼的技巧

---

藍鯨智云簡介

騰訊藍鯨智云（簡稱藍鯨）軟件體系是一套基于PaaS的技術(shù)解決方案，致力于打造行業(yè)領(lǐng)先的一站式自動化運維平臺。目前已經(jīng)推出社區(qū)版、企業(yè)版，歡迎體驗。
請點擊訪問藍鯨官網(wǎng)：http://bk.tencent.com

本文名稱：Python 工匠：使用數(shù)字與字符串的技巧
網(wǎng)頁地址：http://chinadenli.net/article8/dsogpip.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供網(wǎng)站收錄、全網(wǎng)營銷推廣、網(wǎng)站改版、網(wǎng)站排名、Google、電子商務(wù)

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)