flake8-simplify

一个 flake8 插件，帮助您简化代码。

安装

使用 pip 安装

pip install flake8-simplify

支持Python 3.8到3.11。

用法

只需在您的包中调用 flake8 . 或 flake your.py

$ flake8 .
./foo/__init__.py:690:12: SIM101 Multiple isinstance-calls which can be merged into a single call for variable 'other'

规则

Python特定规则

• SIM101：多个isinstance调用可以通过使用元组作为第二个参数合并为一个调用（示例）
• SIM104：使用 'yield from iterable'（自Python 3.3引入，见PEP 380）（示例）
• SIM105：使用 'contextlib.suppress(...)' 代替 try-except-pass（示例）
• SIM107：不要在try/except和finally中使用return（示例）
• SIM108：如果合理，使用三元运算符（示例）
• SIM109：使用元组比较值和多个值（示例）
• SIM110：使用any(...)（示例）
• SIM111：使用all(...)（示例）
• SIM113：使用enumerate代替手动增加计数器（示例）
• SIM114：通过逻辑或合并条件以避免代码重复（示例）
• SIM115：使用上下文管理器打开文件（示例）
• SIM116：使用字典代替多个if/else相等性检查（示例）
• SIM117：合并使用相同作用域的with语句（示例）
• SIM119： 已移至 flake8-scream，因问题63
• SIM120 ：使用'class FooBar:'代替'class FooBar(object):'（示例）
• SIM121：一旦稳定，保留给SIM908
• SIM125：一旦稳定，保留给SIM905
• SIM126：一旦稳定，保留给SIM906
• SIM127：一旦稳定，保留给SIM907

简化比较

• SIM201：使用'a != b'代替'not a == b'（示例）
• SIM202：使用'a == b'代替'not a != b'（示例）
• SIM203：使用'a not in b'代替'not (a in b)'（示例）
• SIM204： 已移至 flake8-scream，因问题116
• SIM205： 已移至 flake8-scream，因问题116
• SIM206： 已移至 flake8-scream，因问题116
• SIM207： 已移至 flake8-scream，因问题116
• SIM208：使用'a'代替'not (not a)'（示例）
• SIM210：使用'bool(a)'代替'True if a else False'（示例）
• SIM211：使用 'not a' 而不是 'False if a else True'（示例）
• SIM212：使用 'a if a else b' 而不是 'b if not a else a'（示例）
• SIM220：使用 'False' 而不是 'a and not a'（示例）
• SIM221：使用 'True' 而不是 'a or not a'（示例）
• SIM222：使用 'True' 而不是 '... or True'（示例）
• SIM223：使用 'False' 而不是 '... and False'（示例）
• SIM224：预留用于 SIM901 一旦稳定
• SIM300：使用 'age == 42' 而不是 '42 == age'（示例）

简化字典的使用

• SIM401：使用 'a_dict.get(key, "default_value")' 而不是 if-块（示例）
• SIM118：使用 'key in dict' 而不是 'key in dict.keys()'（示例）
• SIM119 预留用于 SIM911 一旦稳定

通用代码风格

• SIM102：使用单个 if-语句而不是嵌套 if-语句（示例）
• SIM103：直接返回布尔条件（示例）
• SIM106：先处理错误情况（示例）。由于错误率太高，该规则已被移除。
• SIM112：使用大写环境变量（示例）
• SIM122 / SIM902： 已移至 flake8-scream，由于 问题 125
• SIM123 / SIM902： 已移至 flake8-scream，由于 问题 130
• SIM124：预留用于 SIM909 一旦稳定

实验性规则

为所有可能的情况正确设置规则很难。我不想打扰人们的流程。因此，flake8-simplify 引入了具有 SIM9 前缀的新规则。每个新规则都将从 SIM9 开始，并保持至少 6 个月。在这段时间里，人们可以提供反馈。一旦规则稳定，代码将更改到另一个数字。

当前实验性规则

• SIM901：直接使用比较而不是在 bool(...) 调用中包装它们（示例）
• SIM904：直接在初始化时将值赋给字典（示例）
• SIM905：如果仅使用常量，则直接拆分字符串（示例）
• SIM906：合并嵌套的 os.path.join 调用（示例）
• SIM907：使用 Optional[Type] 而不是 Union[Type, None]（示例）
• SIM908：使用 dict.get(key)（示例）
• SIM909：避免自反赋值（示例）
• SIM910：避免使用 dict.get(key, None)（示例）
• SIM911：避免使用 zip(dict.keys(), dict.values())（示例）

禁用规则

您可能有很好的理由忽略一些 flake8 规则。忽略规则的方法是使用标准的 Flake8 配置。例如，在 setup.cfg 文件中

[flake8]
ignore = SIM106, SIM113, SIM119, SIM9

示例

SIM101

# Bad
isinstance(a, int) or isinstance(a, float)

# Good
isinstance(a, (int, float))

SIM102

# Bad
if a:
    if b:
        c

# Good
if a and b:
    c

SIM105

# Bad
try:
    foo()
except ValueError:
    pass

# Good
from contextlib import suppress

with suppress(ValueError):
    foo()

请注意，contextlib.suppress 大约比 try/except 慢 3 倍（来源）。

SIM107

# Bad: This example returns 3!
def foo():
    try:
        1 / 0
        return "1"
    except:
        return "2"
    finally:
        return "3"


# Good
def foo():
    return_value = None
    try:
        1 / 0
        return_value = "1"
    except:
        return_value = "2"
    finally:
        return_value = "3"  # you might also want to check if "except" happened
    return return_value

SIM108

# Bad
if a:
    b = c
else:
    b = d

# Good
b = c if a else d

SIM109

# Bad
if a == b or a == c:
    d

# Good
if a in (b, c):
    d

SIM110

# Bad
for x in iterable:
    if check(x):
        return True
return False

# Good
return any(check(x) for x in iterable)

SIM111

# Bad
for x in iterable:
    if check(x):
        return False
return True

# Good
return all(not check(x) for x in iterable)

SIM112

# Bad
os.environ["foo"]
os.environ.get("bar")

# Good
os.environ["FOO"]
os.environ.get("BAR")

SIM113

在如下简单的循环中使用 enumerate 可以使代码更容易阅读，因为读者不需要弄清楚循环变量何时/在哪里增加（或者是否在多个地方增加）。

# Bad
idx = 0
for el in iterable:
    ...
    idx += 1

# Good
for idx, el in enumerate(iterable):
    ...

SIM114

# Bad
if a:
    b
elif c:
    b

# Good
if a or c:
    b

SIM115

# Bad
f = open(...)
...  # (do something with f)
f.close()

# Good
with open(...) as f:
    ...  # (do something with f)

SIM116

# Bad
if a == "foo":
    return "bar"
elif a == "bar":
    return "baz"
elif a == "boo":
    return "ooh"
else:
    return 42

# Good
mapping = {"foo": "bar", "bar": "baz", "boo": "ooh"}
return mapping.get(a, 42)

SIM117

# Bad
with A() as a:
    with B() as b:
        print("hello")

# Good
with A() as a, B() as b:
    print("hello")

感谢指出这一点，Aaron Gokaslan！

SIM118

# Bad
key in a_dict.keys()

# Good
key in a_dict

感谢指出这一点，Aaron Gokaslan！

SIM120

# Bad
class FooBar(object):
    ...


# Good
class FooBar:
    ...

在 Python 3 中，两种表示法是等价的，但第二种更短。

SIM201

# Bad
not a == b

# Good
a != b

SIM202

# Bad
not a != b

# Good
a == b

SIM203

# Bad
not a in b

# Good
a not in b

SIM208

# Bad
not (not a)

# Good
a

SIM210

# Bad
True if a else False

# Good
bool(a)

SIM211

# Bad
False if a else True

# Good
not a

SIM212

# Bad
b if not a else a

# Good
a if a else b

SIM220

# Bad
a and not a

# Good
False

SIM221

# Bad
a or not a

# Good
True

SIM222

# Bad
... or True

# Good
True

SIM223

# Bad
... and False

# Good
False

SIM300

# Bad; This is called a "Yoda-Condition"
42 == age

# Good
age == 42

SIM401

# Bad
if key in a_dict:
    value = a_dict[key]
else:
    value = "default_value"

# Good
thing = a_dict.get(key, "default_value")

SIM901

在 6 个月试用期结束后，此规则将被重命名为 SIM224。请报告您遇到此规则的问题！

试用期从 2022 年 1 月 23 日开始，到 2022 年 8 月 23 日结束。

# Bad
bool(a == b)

# Good
a == b

SIM904

在 6 个月试用期结束后，此规则将被重命名为 SIM224。请报告您遇到此规则的问题！

试用期从 2022 年 2 月 12 日开始，到 2022 年 9 月 12 日结束。

# Bad
a = {}
a["b"] = "c"

# Good
a = {"b": "c"}

SIM905

在 6 个月试用期结束后，此规则将被重命名为 SIM225。请报告您遇到此规则的问题！

试用期从 2022 年 2 月 13 日开始，到 2022 年 9 月 13 日结束。

# Bad
domains = "de com net org".split()

# Good
domains = ["de", "com", "net", "org"]

SIM906

在 6 个月试用期结束后，此规则将被重命名为 SIM126。请报告您遇到此规则的问题！

试用期从 2022 年 2 月 20 日开始，到 2022 年 9 月 20 日结束。

# Bad
os.path.join(a, os.path.join(b, c))

# Good
os.path.join(a, b, c)

SIM907

在 6 个月试用期结束后，此规则将被重命名为 SIM127。请报告您遇到此规则的问题！

试用期从 2022 年 3 月 28 日开始，到 2022 年 9 月 28 日结束。

# Bad
def foo(a: Union[int, None]) -> Union[int, None]:
    return a


# Good
def foo(a: Optional[int]) -> Optional[int]:
    return a

SIM908

在 6 个月试用期结束后，此规则将被重命名为 SIM121。请报告您遇到此规则的问题！

试用期从 2022 年 3 月 28 日开始，到 2022 年 9 月 28 日结束。

# Bad
name = "some_default"
if "some_key" in some_dict:
    name = some_dict["some_key"]

# Good
name = some_dict.get("some_key", "some_default")

SIM909

感谢 Ryan Delaney 的想法！

在 6 个月试用期结束后，此规则将被重命名为 SIM124。请报告您遇到此规则的问题！

试用期从 2022 年 3 月 28 日开始，到 2022 年 9 月 28 日结束。

# Bad
foo = foo

# Good: Nothing. Reflexive assignments have no purpose.

或

# Bad
foo = foo = 42

# Good
foo = 42

SIM910

# Bad
dict.get(key, None)

# Good
dict.get(key)