python的缺陷,python弊端
大家好，今天给大家分享18个计算机编程语言初学者常有的坏习惯，这些坏习惯不仅影响计算机编程语言代码的可读性，而且影响计算机编程语言的运行性能，摒弃这些坏习惯并以预言的的方式编写代码，提高的不仅仅是你的代码质量，也给阅读代码的人留下好印象
废话不多说，我们开始学习吧！
1、拼接字符串用 + 号
坏的做法：
def手动_字符串_格式化(姓名，订户):
如果订户100000:
打印(哇名！您有str(订户) 个订户！)
else:
打印(“Lol”名称"这不是很多的subs”)
好的做法是使用f弦，而且效率会更高：
def手动_字符串_格式化(姓名，订户):
#更好
如果订户100000:
print(fWow {name}！您有{订户}个订户！)
else:
print(fLol {name}那不是很多subs’)
2、使用 finaly 而不是上下文管理器
坏的做法：
def finally _ instead _ of _ context _ manager(主机，端口):
s=socket.socket(socket .AF_INET，插座.袜子_流)
尝试：
连接((主机，端口))
森道尔(b)你好，世界)
最后：
关闭()
好的做法是使用上下文管理器，即使发生异常，也会关闭套接字：
def finally _ instead _ of _ context _ manager(主机，端口):
#即使出现异常也关闭
with socket.socket(套接字AF_INET，socket .袜子_流)作为s:
连接((主机，端口))
森道尔(b)你好，世界)
3、尝试手动关闭文件
坏的做法：
手动定义_调用_关闭_打开_文件（文件名):
f=打开（文件名，“w”)
f。写(你好！\n )
f.close()
好的做法是使用上下文管理器，即使发生异常，也会自动关闭文件，凡是有上下文管理器的，都应该首先采用：
手动定义_调用_关闭_打开_文件（文件名):
打开（文件名)为f:
f。写(你好！\n )
#自动关闭，即使出现异常
4、except 后面什么也不写
坏的做法：
def bare_except():
而True:
尝试：
s=输入("输入一个数字：")
x=int(s)
破裂
例外： #哎呀！不能按CTRL-C退出
打印("不是数字，再试一次")
这样会捕捉所有异常，导致按下CTRL-C程序都不会终止，好的做法是
def bare_except():
虽然真的
e:
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("its a tuple")
else:
print("its 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("its a tuple")
else:
print("its 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 坏习惯内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。