Python開發中需要摒棄的壞習慣有哪些

這篇“Python開發中需要摒棄的壞習慣有哪些”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“Python開發中需要摒棄的壞習慣有哪些”文章吧。

1、拼接字符串用 + 號

壞的做法：

def manual_str_formatting(name, subscribers):
    if subscribers > 100000:
        print("Wow " + name + "! you have " + str(subscribers) + " subscribers!")
    else:
        print("Lol " + name + " that's not many subs")

好的做法是使用 f-string，而且效率會更高：

def manual_str_formatting(name, subscribers):
    # better
    if subscribers > 100000:
        print(f"Wow {name}! you have {subscribers} subscribers!")
    else:
        print(f"Lol {name} that's not many subs")

2、使用 finaly 而不是上下文管理器

壞的做法：

def finally_instead_of_context_manager(host, port):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        s.connect((host, port))
        s.sendall(b'Hello, world')
    finally:
        s.close()

好的做法是使用上下文管理器，即使發生異常，也會關閉 socket：：

def finally_instead_of_context_manager(host, port):
    # close even if exception
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect((host, port))
        s.sendall(b'Hello, world')

3、嘗試手動關閉文件

壞的做法:

def manually_calling_close_on_a_file(filename):
    f = open(filename, "w")
    f.write("hello!\n")
    f.close()

好的做法是使用上下文管理器，即使發生異常，也會自動關閉文件，凡是有上下文管理器的，都應該首先采用：

def manually_calling_close_on_a_file(filename):
    with open(filename) as f:
        f.write("hello!\n")
    # close automatic, even if exception

4、except 后面什么也不寫

壞的做法：

def bare_except():
    while True:
        try:
            s = input("Input a number: ")
            x = int(s)
            break
        except:  # oops! can't CTRL-C to exit
            print("Not a number, try again")

這樣會捕捉所有異常，導致按下 CTRL-C 程序都不會終止，好的做法是

def bare_except():
    while True:
        try:
            s = input("Input a number: ")
            x = int(s)
            break
        except Exception:  # 比這更好的是用 ValueError
            print("Not a number, try again")

5、函數參數使用可變對象

如果函數參數使用可變對象，那么下次調用時可能會產生非預期結果，壞的做法

def mutable_default_arguments():
    def append(n, l=[]):
        l.append(n)
        return l

    l1 = append(0)  # [0]
    l2 = append(1)  # [0, 1]

好的做法:

def mutable_default_arguments():

    def append(n, l=None):
        if l is None:
            l = []
        l.append(n)
        return l

    l1 = append(0)  # [0]
    l2 = append(1)  # [1]

6、從不用推導式

壞的做法

squares = {}
for i in range(10):
    squares[i] = i * i

好的做法

odd_squares = {i: i * i for i in range(10)}

7、推導式用的上癮

推導式雖然好用，但是不可以犧牲可讀性，壞的做法

c = [
    sum(a[n * i + k] * b[n * k + j] for k in range(n))
    for i in range(n)
    for j in range(n)
]

好的做法:

c = []
for i in range(n):
    for j in range(n):
        ij_entry = sum(a[n * i + k] * b[n * k + j] for k in range(n))
        c.append(ij_entry)

8、檢查類型是否一致用 ==

壞的做法

def checking_type_equality():
    Point = namedtuple('Point', ['x', 'y'])
    p = Point(1, 2)

    if type(p) == tuple:
        print("it's a tuple")
    else:
        print("it's not a tuple")

好的做法

def checking_type_equality():
    Point = namedtuple('Point', ['x', 'y'])
    p = Point(1, 2)

    # probably meant to check if is instance of tuple
    if isinstance(p, tuple):
        print("it's a tuple")
    else:
        print("it's not a tuple")

9、用 == 判斷是否單例

壞的做法

def equality_for_singletons(x):
    if x == None:
        pass

    if x == True:
        pass

    if x == False:
        pass

好的做法

def equality_for_singletons(x):
    # better
    if x is None:
        pass

    if x is True:
        pass

    if x is False:
        pass

10、判斷一個變量用 bool(x)

壞的做法

def checking_bool_or_len(x):
    if bool(x):
        pass

    if len(x) != 0:
        pass

好的做法

def checking_bool_or_len(x):
    # usually equivalent to
    if x:
        pass

11、使用類 C 風格的 for 循環

壞的做法

def range_len_pattern():
    a = [1, 2, 3]
    for i in range(len(a)):
        v = a[i]
        ...
    b = [4, 5, 6]
    for i in range(len(b)):
        av = a[i]
        bv = b[i]
        ...

好的做法

def range_len_pattern():
    a = [1, 2, 3]
    # instead
    for v in a:
        ...

    # or if you wanted the index
    for i, v in enumerate(a):
        ...

    # instead use zip
    for av, bv in zip(a, b):
        ...

12、不實用 dict.items

壞的做法

def not_using_dict_items():
    d = {"a": 1, "b": 2, "c": 3}
    for key in d:
        val = d[key]
        ...

好的做法

def not_using_dict_items():
    d = {"a": 1, "b": 2, "c": 3}
    for key, val in d.items():
        ...

13、解包元組使用索引

壞的做法

mytuple = 1, 2
x = mytuple[0]
y = mytuple[1]

好的做法

mytuple = 1, 2
x, y = mytuple

14、使用 time.time() 統計耗時

壞的做法

def timing_with_time():
    start = time.time()
    time.sleep(1)
    end = time.time()
    print(end - start)

好的做法是使用 time.perf_counter()，更精確：

def timing_with_time():
   # more accurate
    start = time.perf_counter()
    time.sleep(1)
    end = time.perf_counter()
    print(end - start)

15、記錄日志使用 print 而不是 logging

壞的做法

def print_vs_logging():
    print("debug info")
    print("just some info")
    print("bad error")

好的做法

def print_vs_logging():
    # versus
    # in main
    level = logging.DEBUG
    fmt = '[%(levelname)s] %(asctime)s - %(message)s'
    logging.basicConfig(level=level, format=fmt)

    # wherever
    logging.debug("debug info")
    logging.info("just some info")
    logging.error("uh oh :(")

16、調用外部命令時使用 shell=True

壞的做法

subprocess.run(["ls -l"], capture_output=True, shell=True)

如果 shell=True，則將 ls -l 傳遞給/bin/sh(shell) 而不是 Unix 上的 ls 程序，會導致 subprocess 產生一個中間 shell 進程， 換句話說，使用中間 shell 意味著在命令運行之前，命令字符串中的變量、glob 模式和其他特殊的 shell 功能都會被預處理。比如，$HOME 會在在執行 echo 命令之前被處理處理。

好的做法是拒絕從 shell 執行：

subprocess.run(["ls", "-l"], capture_output=True)

17、從不嘗試使用 numpy

壞的做法

def not_using_numpy_pandas():
    x = list(range(100))
    y = list(range(100))
    s = [a + b for a, b in zip(x, y)]

好的做法:

import numpy as np
def not_using_numpy_pandas():
    # 性能更快
    x = np.arange(100)
    y = np.arange(100)
    s = x + y

18、喜歡 import *

壞的做法

from itertools import *

count()

這樣的話，沒有人直到這個腳本到底有多數變量， 好的做法：

from mypackage.nearby_module import awesome_function

def main():
    awesome_function()

if __name__ == '__main__':
    main()

以上就是關于“Python開發中需要摒棄的壞習慣有哪些”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。