梳理总结Python开发中需要摒弃的18个坏习惯

废话不多说,我们开始学习吧!

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开发中需要摒弃的18个坏习惯的文章就介绍到这了,更多相关Python 坏习惯内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 给大家整理了19个pythonic的编程习惯(小结)

    Python最大的优点之一就是语法简洁,好的代码就像伪代码一样,干净.整洁.一目了然. 要写出 Pythonic(优雅的.地道的.整洁的)代码,需要多看多学大牛们写的代码,github 上有很多非常优秀的源代码值得阅读,比如:requests.flask.tornado,下面列举一些常见的Pythonic写法. 0. 程序必须先让人读懂,然后才能让计算机执行. "Programs must be written for people to read, and only incidentally

  • 提升Python程序性能的7个习惯

    掌握一些技巧,可尽量提高Python程序性能,也可以避免不必要的资源浪费. 1.使用局部变量 尽量使用局部变量代替全局变量:便于维护,提高性能并节省内存. 使用局部变量替换模块名字空间中的变量,例如 ls = os.linesep.一方面可以提高程序性能,局部变量查找速度更快:另一方面可用简短标识符替代冗长的模块变量,提高可读性. 2.减少函数调用次数 对象类型判断时,采用isinstance()最优,采用对象类型身份(id())次之,采用对象值(type())比较最次. 判断变量num是否为整

  • 符合语言习惯的 Python 优雅编程技巧【推荐】

    Python最大的优点之一就是语法简洁,好的代码就像伪代码一样,干净.整洁.一目了然.要写出 Pythonic(优雅的.地道的.整洁的)代码,需要多看多学大牛们写的代码,github 上有很多非常优秀的源代码值得阅读,比如:requests.flask.tornado,下面列举一些常见的Pythonic写法. 0. 程序必须先让人读懂,然后才能让计算机执行. "Programs must be written for people to read, and only incidentally f

  • Python入门篇之编程习惯与特点

    1.代码风格 在Python中,每行程序以换行符代表结束,如果一行程序太长的话,可以用"\"符号扩展到下一行.在python中以三引号(""")括起来的字符串,列表,元组和字典都能跨行使用.并且以小括号(...).中括号[...]和大括号{...}包围的代码不用加"\"符也可扩展到多行. 在Python中是以缩进来区分程序功能块的,缩进的长度不受限制,但就一个功能块来讲,最好保持一致的缩进量. 如果一行中有多条语句,语句间要以分号(;)

  • 程序员写Python时的5个坏习惯,你有几条?

    很多文章都有介绍怎么写好 Python,我今天呢,相反,说说写代码时的几个坏习惯.有的习惯会让 Bug 变得隐蔽难以追踪,当然,也有的并没有错误,只是个人觉得不够优雅. 注意:示例代码在 Python 3.6 环境下编写 1 用列表作函数的默认参数 看下面这个例子 def func(a, b=[]): b.append(a) print(f'a: {a}') print(f'b: {b}') func(1) func(2) 正常我们期望的结果应该是这样的 a: 1 b: [1] a: 2 b:

  • Python代码风格与编程习惯重要吗?

    Python代码风格 首先我们要以 PEP8 代码规范为标准,但也无需完全遵守.例如:一行不能超过 79 个字符等. Python模块模板 模块开头指定编码格式 模块文档注释,展示模块的信息,信息内容自己决定,如: Author,作者 Desc,模块描述 Date,创建时间 有一个 main() 函数 有一个程序主入口 if __name__ == '__main__': #!/usr/bin/python3 # -*- coding:utf-8 -*- # @Author: Hui # @De

  • 梳理总结Python开发中需要摒弃的18个坏习惯

    废话不多说,我们开始学习吧! 1.拼接字符串用 + 号 坏的做法: def manual_str_formatting(name, subscribers): if subscribers > 100000: print("Wow " + name + "! you have " + str(subscribers) + " subscribers!") else: print("Lol " + name + "

  • python开发中range()函数用法实例分析

    本文实例讲述了python开发中range()函数用法.分享给大家供大家参考,具体如下: python中的range()函数的功能很强大,所以我觉得很有必要和大家分享一下 就好像其API中所描述的: If you do need to iterate over a sequence of numbers, the built-in function range() comes in handy. It generates arithmetic progressions 下面是我做的demo: #

  • python开发中module模块用法实例分析

    本文实例讲述了python开发中module模块用法.分享给大家供大家参考,具体如下: 在python中,我们可以把一些功能模块化,就有一点类似于java中,把一些功能相关或者相同的代码放到一起,这样我们需要用的时候,就可以直接调用了 这样做的好处: 1,只要写好了一个功能模块,就可以在以后调用,代码的重用就可以体现出来了 2,功能写好了以后,不会发生错误.如果一个相同的功能,我们在一个模块中写了一遍,在另外的模块中又写了一遍......这样我们难免保证我们在写的过程中不发生错误. 但是我们如果

  • 分享Python开发中要注意的十个小贴士

    大家请注意:这篇文中假设我们都用的是Python 3 1. 列表推导式 你有一个list:bag = [1, 2, 3, 4, 5] 现在你想让所有元素翻倍,让它看起来是这个样子: [2, 4, 6, 8, 10] 大多初学者,根据之前语言的经验会大概这样来做 bag = [1, 2, 3, 4, 5] for i in range(len(bag)): bag[i] = bag[i] * 2 但是有更好的方法: bag = [elem * 2 for elem in bag] 很简洁对不对?这

  • Python开发中爬虫使用代理proxy抓取网页的方法示例

    本文实例讲述了Python开发中爬虫使用代理proxy抓取网页的方法.分享给大家供大家参考,具体如下: 代理类型(proxy):透明代理 匿名代理 混淆代理和高匿代理. 这里写一些python爬虫使用代理的知识, 还有一个代理池的类. 方便大家应对工作中各种复杂的抓取问题. urllib 模块使用代理 urllib/urllib2使用代理比较麻烦, 需要先构建一个ProxyHandler的类, 随后将该类用于构建网页打开的opener的类,再在request中安装该opener. 代理格式是"h

  • 快速了解Python开发中的cookie及简单代码示例

    cookie :是用户保存在用户浏览器端的一对键值对,是为了解决http的无状态连接.服务端是可以把 cookie写到用户浏览器上,用户每次发请求会携带cookie. 存放位置: 每次发请求cookie是放在请求头里面的. 应用场景: ·登陆用户和密码的记住密码 ·显示每页显示的数据,以后都是按照设定的数目显示 ·投票机制 案例用户登录 创建用户登录的url url(r'^login/', views.login), 创建登录页面 代码为: <!DOCTYPE html> <html l

  • 值得收藏,Python 开发中的高级技巧

    Python 开发中有哪些高级技巧?这是知乎上一个问题,我总结了一些常见的技巧在这里,可能谈不上多高级,但掌握这些至少可以让你的代码看起来 Pythonic 一点.如果你还在按照类C语言的那套风格来写的话,在 code review 恐怕会要被吐槽了. 列表推导式 >>> chars = [ c for c in 'python' ] >>> chars ['p', 'y', 't', 'h', 'o', 'n'] 字典推导式 >>> dict1 =

  • python开发中两个list之间传值示例

    由于改代码因为这个问题卡了半个小时特此记录 首先对于一个单层的列表 赋值如下,可以看见,如果直接使用 = 的话.其中一个变换便会引起另外一个变换,这时因为这两个list被python解释的时候使用的相同的地址,如下面输出的 id()中的内容,所以此时如果想让一个列表接收到另外一个列表的值,并且在接收到值后不会因为其中任意一个值的改变而改变,这时候就需要使用copy方法,这里可以解释成,当使用了copy方法后,python单独创建了找个一个内存区的地址放了新的那个值. a = [ 1,2,3] b

  • Docker容器的应用中,10个要不得的坏习惯

    毋庸置疑,容器已经成为企业IT基础设施中必不可少的部分,它具有许多的优点,比如: 第一:容器是不可变的--操作系统,库版本,配置,文件夹和应用程序都包装在容器内.你保证在质量检查中测试过的同一镜像将以相同的行为到达生产环境. 第二:容器很轻--容器的内存占用量很小.容器将只为主要进程分配内存,而不是数百或数千MB. 第三:容器非常快--可以像启动典型Linux进程一样快地启动容器.你可以在几秒钟内启动一个新容器,而不是几分钟. 但是,许多用户仍然像对待典型虚拟机一样对待容器,而忘记了容器具有重要

  • Docker容器应用中,10个要不得的坏习惯

    毋庸置疑,容器已经成为企业IT基础设施中必不可少的部分,它具有许多的优点,比如: 第一:容器是不可变的--操作系统,库版本,配置,文件夹和应用程序都包装在容器内.你保证在质量检查中测试过的同一镜像将以相同的行为到达生产环境. 第二:容器很轻--容器的内存占用量很小.容器将只为主要进程分配内存,而不是数百或数千MB. 第三:容器非常快--可以像启动典型Linux进程一样快地启动容器.你可以在几秒钟内启动一个新容器,而不是几分钟. 但是,许多用户仍然像对待典型虚拟机一样对待容器,而忘记了容器具有重要

随机推荐