---
source: crates/ruff_linter/src/rules/flake8_simplify/mod.rs
---
SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:6:1
   |
 5 |   # positives
 6 | / """
 7 | |     itemA
 8 | |     itemB
 9 | |     itemC
10 | | """.split()
   | |___________^
11 |
12 |   "a,b,c,d".split(",")
   |
help: Replace with list literal
  |
5 | # positives
  - """
  - 	itemA
  - 	itemB
  - 	itemC
  - """.split()
6 + ["itemA", "itemB", "itemC"]
7 |
  |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:12:1
   |
10 | """.split()
11 |
12 | "a,b,c,d".split(",")
   | ^^^^^^^^^^^^^^^^^^^^
13 | "a,b,c,d".split(None)
14 | "a,b,c,d".split(",", 1)
   |
help: Replace with list literal
   |
11 |
   - "a,b,c,d".split(",")
12 + ["a", "b", "c", "d"]
13 | "a,b,c,d".split(None)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:13:1
   |
12 | "a,b,c,d".split(",")
13 | "a,b,c,d".split(None)
   | ^^^^^^^^^^^^^^^^^^^^^
14 | "a,b,c,d".split(",", 1)
15 | "a,b,c,d".split(None, 1)
   |
help: Replace with list literal
   |
12 | "a,b,c,d".split(",")
   - "a,b,c,d".split(None)
13 + ["a,b,c,d"]
14 | "a,b,c,d".split(",", 1)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:14:1
   |
12 | "a,b,c,d".split(",")
13 | "a,b,c,d".split(None)
14 | "a,b,c,d".split(",", 1)
   | ^^^^^^^^^^^^^^^^^^^^^^^
15 | "a,b,c,d".split(None, 1)
16 | "a,b,c,d".split(sep=",")
   |
help: Replace with list literal
   |
13 | "a,b,c,d".split(None)
   - "a,b,c,d".split(",", 1)
14 + ["a", "b,c,d"]
15 | "a,b,c,d".split(None, 1)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:15:1
   |
13 | "a,b,c,d".split(None)
14 | "a,b,c,d".split(",", 1)
15 | "a,b,c,d".split(None, 1)
   | ^^^^^^^^^^^^^^^^^^^^^^^^
16 | "a,b,c,d".split(sep=",")
17 | "a,b,c,d".split(sep=None)
   |
help: Replace with list literal
   |
14 | "a,b,c,d".split(",", 1)
   - "a,b,c,d".split(None, 1)
15 + ["a,b,c,d"]
16 | "a,b,c,d".split(sep=",")
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:16:1
   |
14 | "a,b,c,d".split(",", 1)
15 | "a,b,c,d".split(None, 1)
16 | "a,b,c,d".split(sep=",")
   | ^^^^^^^^^^^^^^^^^^^^^^^^
17 | "a,b,c,d".split(sep=None)
18 | "a,b,c,d".split(sep=",", maxsplit=1)
   |
help: Replace with list literal
   |
15 | "a,b,c,d".split(None, 1)
   - "a,b,c,d".split(sep=",")
16 + ["a", "b", "c", "d"]
17 | "a,b,c,d".split(sep=None)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:17:1
   |
15 | "a,b,c,d".split(None, 1)
16 | "a,b,c,d".split(sep=",")
17 | "a,b,c,d".split(sep=None)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^
18 | "a,b,c,d".split(sep=",", maxsplit=1)
19 | "a,b,c,d".split(sep=None, maxsplit=1)
   |
help: Replace with list literal
   |
16 | "a,b,c,d".split(sep=",")
   - "a,b,c,d".split(sep=None)
17 + ["a,b,c,d"]
18 | "a,b,c,d".split(sep=",", maxsplit=1)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:18:1
   |
16 | "a,b,c,d".split(sep=",")
17 | "a,b,c,d".split(sep=None)
18 | "a,b,c,d".split(sep=",", maxsplit=1)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
19 | "a,b,c,d".split(sep=None, maxsplit=1)
20 | "a,b,c,d".split(maxsplit=1, sep=",")
   |
help: Replace with list literal
   |
17 | "a,b,c,d".split(sep=None)
   - "a,b,c,d".split(sep=",", maxsplit=1)
18 + ["a", "b,c,d"]
19 | "a,b,c,d".split(sep=None, maxsplit=1)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:19:1
   |
17 | "a,b,c,d".split(sep=None)
18 | "a,b,c,d".split(sep=",", maxsplit=1)
19 | "a,b,c,d".split(sep=None, maxsplit=1)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
20 | "a,b,c,d".split(maxsplit=1, sep=",")
21 | "a,b,c,d".split(maxsplit=1, sep=None)
   |
help: Replace with list literal
   |
18 | "a,b,c,d".split(sep=",", maxsplit=1)
   - "a,b,c,d".split(sep=None, maxsplit=1)
19 + ["a,b,c,d"]
20 | "a,b,c,d".split(maxsplit=1, sep=",")
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:20:1
   |
18 | "a,b,c,d".split(sep=",", maxsplit=1)
19 | "a,b,c,d".split(sep=None, maxsplit=1)
20 | "a,b,c,d".split(maxsplit=1, sep=",")
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
21 | "a,b,c,d".split(maxsplit=1, sep=None)
22 | "a,b,c,d".split(",", maxsplit=1)
   |
help: Replace with list literal
   |
19 | "a,b,c,d".split(sep=None, maxsplit=1)
   - "a,b,c,d".split(maxsplit=1, sep=",")
20 + ["a", "b,c,d"]
21 | "a,b,c,d".split(maxsplit=1, sep=None)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:21:1
   |
19 | "a,b,c,d".split(sep=None, maxsplit=1)
20 | "a,b,c,d".split(maxsplit=1, sep=",")
21 | "a,b,c,d".split(maxsplit=1, sep=None)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
22 | "a,b,c,d".split(",", maxsplit=1)
23 | "a,b,c,d".split(None, maxsplit=1)
   |
help: Replace with list literal
   |
20 | "a,b,c,d".split(maxsplit=1, sep=",")
   - "a,b,c,d".split(maxsplit=1, sep=None)
21 + ["a,b,c,d"]
22 | "a,b,c,d".split(",", maxsplit=1)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:22:1
   |
20 | "a,b,c,d".split(maxsplit=1, sep=",")
21 | "a,b,c,d".split(maxsplit=1, sep=None)
22 | "a,b,c,d".split(",", maxsplit=1)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
23 | "a,b,c,d".split(None, maxsplit=1)
24 | "a,b,c,d".split(maxsplit=1)
   |
help: Replace with list literal
   |
21 | "a,b,c,d".split(maxsplit=1, sep=None)
   - "a,b,c,d".split(",", maxsplit=1)
22 + ["a", "b,c,d"]
23 | "a,b,c,d".split(None, maxsplit=1)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:23:1
   |
21 | "a,b,c,d".split(maxsplit=1, sep=None)
22 | "a,b,c,d".split(",", maxsplit=1)
23 | "a,b,c,d".split(None, maxsplit=1)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
24 | "a,b,c,d".split(maxsplit=1)
25 | "a,b,c,d".split(maxsplit=1.0)
   |
help: Replace with list literal
   |
22 | "a,b,c,d".split(",", maxsplit=1)
   - "a,b,c,d".split(None, maxsplit=1)
23 + ["a,b,c,d"]
24 | "a,b,c,d".split(maxsplit=1)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:24:1
   |
22 | "a,b,c,d".split(",", maxsplit=1)
23 | "a,b,c,d".split(None, maxsplit=1)
24 | "a,b,c,d".split(maxsplit=1)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
25 | "a,b,c,d".split(maxsplit=1.0)
26 | "a,b,c,d".split(maxsplit=1)
   |
help: Replace with list literal
   |
23 | "a,b,c,d".split(None, maxsplit=1)
   - "a,b,c,d".split(maxsplit=1)
24 + ["a,b,c,d"]
25 | "a,b,c,d".split(maxsplit=1.0)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:26:1
   |
24 | "a,b,c,d".split(maxsplit=1)
25 | "a,b,c,d".split(maxsplit=1.0)
26 | "a,b,c,d".split(maxsplit=1)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
27 | "a,b,c,d".split(maxsplit=0)
28 | "VERB AUX PRON ADP DET".split(" ")
   |
help: Replace with list literal
   |
25 | "a,b,c,d".split(maxsplit=1.0)
   - "a,b,c,d".split(maxsplit=1)
26 + ["a,b,c,d"]
27 | "a,b,c,d".split(maxsplit=0)
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:27:1
   |
25 | "a,b,c,d".split(maxsplit=1.0)
26 | "a,b,c,d".split(maxsplit=1)
27 | "a,b,c,d".split(maxsplit=0)
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
28 | "VERB AUX PRON ADP DET".split(" ")
29 | '   1   2   3   '.split()
   |
help: Replace with list literal
   |
26 | "a,b,c,d".split(maxsplit=1)
   - "a,b,c,d".split(maxsplit=0)
27 + ["a,b,c,d"]
28 | "VERB AUX PRON ADP DET".split(" ")
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:28:1
   |
26 | "a,b,c,d".split(maxsplit=1)
27 | "a,b,c,d".split(maxsplit=0)
28 | "VERB AUX PRON ADP DET".split(" ")
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
29 | '   1   2   3   '.split()
30 | '1<>2<>3<4'.split('<>')
   |
help: Replace with list literal
   |
27 | "a,b,c,d".split(maxsplit=0)
   - "VERB AUX PRON ADP DET".split(" ")
28 + ["VERB", "AUX", "PRON", "ADP", "DET"]
29 | '   1   2   3   '.split()
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:29:1
   |
27 | "a,b,c,d".split(maxsplit=0)
28 | "VERB AUX PRON ADP DET".split(" ")
29 | '   1   2   3   '.split()
   | ^^^^^^^^^^^^^^^^^^^^^^^^^
30 | '1<>2<>3<4'.split('<>')
   |
help: Replace with list literal
   |
28 | "VERB AUX PRON ADP DET".split(" ")
   - '   1   2   3   '.split()
29 + ['1', '2', '3']
30 | '1<>2<>3<4'.split('<>')
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:30:1
   |
28 | "VERB AUX PRON ADP DET".split(" ")
29 | '   1   2   3   '.split()
30 | '1<>2<>3<4'.split('<>')
   | ^^^^^^^^^^^^^^^^^^^^^^^
31 |
32 | " a*a a*a a ".split("*", -1)  # [" a", "a a", "a a "]
   |
help: Replace with list literal
   |
29 | '   1   2   3   '.split()
   - '1<>2<>3<4'.split('<>')
30 + ['1', '2', '3<4']
31 |
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:32:1
   |
30 | '1<>2<>3<4'.split('<>')
31 |
32 | " a*a a*a a ".split("*", -1)  # [" a", "a a", "a a "]
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
33 | "".split()  # []
34 | """
   |
help: Replace with list literal
   |
31 |
   - " a*a a*a a ".split("*", -1)  # [" a", "a a", "a a "]
32 + [" a", "a a", "a a "]  # [" a", "a a", "a a "]
33 | "".split()  # []
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:33:1
   |
32 | " a*a a*a a ".split("*", -1)  # [" a", "a a", "a a "]
33 | "".split()  # []
   | ^^^^^^^^^^
34 | """
35 | """.split()  # []
   |
help: Replace with list literal
   |
32 | " a*a a*a a ".split("*", -1)  # [" a", "a a", "a a "]
   - "".split()  # []
33 + []  # []
34 | """
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:34:1
   |
32 |   " a*a a*a a ".split("*", -1)  # [" a", "a a", "a a "]
33 |   "".split()  # []
34 | / """
35 | | """.split()  # []
   | |___________^
36 |   "       ".split()  # []
37 |   "/abc/".split() # ["/abc/"]
   |
help: Replace with list literal
   |
33 | "".split()  # []
   - """
   - """.split()  # []
34 + []  # []
35 | "   	".split()  # []
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:36:1
   |
34 | """
35 | """.split()  # []
36 | "       ".split()  # []
   | ^^^^^^^^^^^^^^^^^
37 | "/abc/".split() # ["/abc/"]
38 | ("a,b,c"
   |
help: Replace with list literal
   |
35 | """.split()  # []
   - "   	".split()  # []
36 + []  # []
37 | "/abc/".split() # ["/abc/"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:37:1
   |
35 | """.split()  # []
36 | "       ".split()  # []
37 | "/abc/".split() # ["/abc/"]
   | ^^^^^^^^^^^^^^^
38 | ("a,b,c"
39 | # comment
   |
help: Replace with list literal
   |
36 | "   	".split()  # []
   - "/abc/".split() # ["/abc/"]
37 + ["/abc/"] # ["/abc/"]
38 | ("a,b,c"
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:38:2
   |
36 |   "       ".split()  # []
37 |   "/abc/".split() # ["/abc/"]
38 |   ("a,b,c"
   |  __^
39 | | # comment
40 | | .split()
   | |________^
41 |   )  # ["a,b,c"]
42 |   ("a,b,c"
   |
help: Replace with list literal
   |
37 | "/abc/".split() # ["/abc/"]
   - ("a,b,c"
   - # comment
   - .split()
38 + (["a,b,c"]
39 | )  # ["a,b,c"]
   |
note: This is an unsafe fix and may change runtime behavior

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:42:2
   |
40 |   .split()
41 |   )  # ["a,b,c"]
42 |   ("a,b,c"
   |  __^
43 | | # comment1
44 | | .split(",")
   | |___________^
45 |   ) # ["a", "b", "c"]
46 |   ("a,"
   |
help: Replace with list literal
   |
41 | )  # ["a,b,c"]
   - ("a,b,c"
   - # comment1
   - .split(",")
42 + (["a", "b", "c"]
43 | ) # ["a", "b", "c"]
   |
note: This is an unsafe fix and may change runtime behavior

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:46:2
   |
44 |   .split(",")
45 |   ) # ["a", "b", "c"]
46 |   ("a,"
   |  __^
47 | | # comment
48 | | "b,"
49 | | "c"
50 | | .split(",")
   | |___________^
51 |   ) # ["a", "b", "c"]
   |
help: Replace with list literal
   |
45 | ) # ["a", "b", "c"]
   - ("a,"
   - # comment
   - "b,"
   - "c"
   - .split(",")
46 + (["a", "b", "c"]
47 | ) # ["a", "b", "c"]
   |
note: This is an unsafe fix and may change runtime behavior

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:53:1
   |
51 |   ) # ["a", "b", "c"]
52 |
53 | / "hello "\
54 | |     "world".split()
   | |___________________^
55 |   # ["hello", "world"]
   |
help: Replace with list literal
   |
52 |
   - "hello "\
   - 	"world".split()
53 + ["hello", "world"]
54 | # ["hello", "world"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:58:1
   |
57 | # prefixes and isc
58 | u"a b".split()  # [u"a", u"b"]
   | ^^^^^^^^^^^^^^
59 | r"a \n b".split()  # [r"a", r"\n", r"b"]
60 | ("a " "b").split()  # ["a", "b"]
   |
help: Replace with list literal
   |
57 | # prefixes and isc
   - u"a b".split()  # [u"a", u"b"]
58 + [u"a", u"b"]  # [u"a", u"b"]
59 | r"a \n b".split()  # [r"a", r"\n", r"b"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:59:1
   |
57 | # prefixes and isc
58 | u"a b".split()  # [u"a", u"b"]
59 | r"a \n b".split()  # [r"a", r"\n", r"b"]
   | ^^^^^^^^^^^^^^^^^
60 | ("a " "b").split()  # ["a", "b"]
61 | "a " "b".split()  # ["a", "b"]
   |
help: Replace with list literal
   |
58 | u"a b".split()  # [u"a", u"b"]
   - r"a \n b".split()  # [r"a", r"\n", r"b"]
59 + [r"a", r"\n", r"b"]  # [r"a", r"\n", r"b"]
60 | ("a " "b").split()  # ["a", "b"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:60:1
   |
58 | u"a b".split()  # [u"a", u"b"]
59 | r"a \n b".split()  # [r"a", r"\n", r"b"]
60 | ("a " "b").split()  # ["a", "b"]
   | ^^^^^^^^^^^^^^^^^^
61 | "a " "b".split()  # ["a", "b"]
62 | u"a " "b".split()  # [u"a", u"b"]
   |
help: Replace with list literal
   |
59 | r"a \n b".split()  # [r"a", r"\n", r"b"]
   - ("a " "b").split()  # ["a", "b"]
60 + ["a", "b"]  # ["a", "b"]
61 | "a " "b".split()  # ["a", "b"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:61:1
   |
59 | r"a \n b".split()  # [r"a", r"\n", r"b"]
60 | ("a " "b").split()  # ["a", "b"]
61 | "a " "b".split()  # ["a", "b"]
   | ^^^^^^^^^^^^^^^^
62 | u"a " "b".split()  # [u"a", u"b"]
63 | "a " u"b".split()  # ["a", "b"]
   |
help: Replace with list literal
   |
60 | ("a " "b").split()  # ["a", "b"]
   - "a " "b".split()  # ["a", "b"]
61 + ["a", "b"]  # ["a", "b"]
62 | u"a " "b".split()  # [u"a", u"b"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:62:1
   |
60 | ("a " "b").split()  # ["a", "b"]
61 | "a " "b".split()  # ["a", "b"]
62 | u"a " "b".split()  # [u"a", u"b"]
   | ^^^^^^^^^^^^^^^^^
63 | "a " u"b".split()  # ["a", "b"]
64 | u"a " r"\n".split()  # [u"a", u"\\n"]
   |
help: Replace with list literal
   |
61 | "a " "b".split()  # ["a", "b"]
   - u"a " "b".split()  # [u"a", u"b"]
62 + [u"a", u"b"]  # [u"a", u"b"]
63 | "a " u"b".split()  # ["a", "b"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:63:1
   |
61 | "a " "b".split()  # ["a", "b"]
62 | u"a " "b".split()  # [u"a", u"b"]
63 | "a " u"b".split()  # ["a", "b"]
   | ^^^^^^^^^^^^^^^^^
64 | u"a " r"\n".split()  # [u"a", u"\\n"]
65 | r"\n " u"\n".split()  # [r"\n"]
   |
help: Replace with list literal
   |
62 | u"a " "b".split()  # [u"a", u"b"]
   - "a " u"b".split()  # ["a", "b"]
63 + ["a", "b"]  # ["a", "b"]
64 | u"a " r"\n".split()  # [u"a", u"\\n"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:64:1
   |
62 | u"a " "b".split()  # [u"a", u"b"]
63 | "a " u"b".split()  # ["a", "b"]
64 | u"a " r"\n".split()  # [u"a", u"\\n"]
   | ^^^^^^^^^^^^^^^^^^^
65 | r"\n " u"\n".split()  # [r"\n"]
66 | r"\n " "\n".split()  # [r"\n"]
   |
help: Replace with list literal
   |
63 | "a " u"b".split()  # ["a", "b"]
   - u"a " r"\n".split()  # [u"a", u"\\n"]
64 + [u"a", u"\\n"]  # [u"a", u"\\n"]
65 | r"\n " u"\n".split()  # [r"\n"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:65:1
   |
63 | "a " u"b".split()  # ["a", "b"]
64 | u"a " r"\n".split()  # [u"a", u"\\n"]
65 | r"\n " u"\n".split()  # [r"\n"]
   | ^^^^^^^^^^^^^^^^^^^^
66 | r"\n " "\n".split()  # [r"\n"]
67 | "a " r"\n".split()  # ["a", "\\n"]
   |
help: Replace with list literal
   |
64 | u"a " r"\n".split()  # [u"a", u"\\n"]
   - r"\n " u"\n".split()  # [r"\n"]
65 + [r"\n"]  # [r"\n"]
66 | r"\n " "\n".split()  # [r"\n"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:66:1
   |
64 | u"a " r"\n".split()  # [u"a", u"\\n"]
65 | r"\n " u"\n".split()  # [r"\n"]
66 | r"\n " "\n".split()  # [r"\n"]
   | ^^^^^^^^^^^^^^^^^^^
67 | "a " r"\n".split()  # ["a", "\\n"]
   |
help: Replace with list literal
   |
65 | r"\n " u"\n".split()  # [r"\n"]
   - r"\n " "\n".split()  # [r"\n"]
66 + [r"\n"]  # [r"\n"]
67 | "a " r"\n".split()  # ["a", "\\n"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:67:1
   |
65 | r"\n " u"\n".split()  # [r"\n"]
66 | r"\n " "\n".split()  # [r"\n"]
67 | "a " r"\n".split()  # ["a", "\\n"]
   | ^^^^^^^^^^^^^^^^^^
68 |
69 | "a,b,c".split(',', maxsplit=0) # ["a,b,c"]
   |
help: Replace with list literal
   |
66 | r"\n " "\n".split()  # [r"\n"]
   - "a " r"\n".split()  # ["a", "\\n"]
67 + ["a", "\\n"]  # ["a", "\\n"]
68 |
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:69:1
   |
67 | "a " r"\n".split()  # ["a", "\\n"]
68 |
69 | "a,b,c".split(',', maxsplit=0) # ["a,b,c"]
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
70 | "a,b,c".split(',', maxsplit=-1)  # ["a", "b", "c"]
71 | "a,b,c".split(',', maxsplit=-2)  # ["a", "b", "c"]
   |
help: Replace with list literal
   |
68 |
   - "a,b,c".split(',', maxsplit=0) # ["a,b,c"]
69 + ["a,b,c"] # ["a,b,c"]
70 | "a,b,c".split(',', maxsplit=-1)  # ["a", "b", "c"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:70:1
   |
69 | "a,b,c".split(',', maxsplit=0) # ["a,b,c"]
70 | "a,b,c".split(',', maxsplit=-1)  # ["a", "b", "c"]
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
71 | "a,b,c".split(',', maxsplit=-2)  # ["a", "b", "c"]
72 | "a,b,c".split(',', maxsplit=-0)  # ["a,b,c"]
   |
help: Replace with list literal
   |
69 | "a,b,c".split(',', maxsplit=0) # ["a,b,c"]
   - "a,b,c".split(',', maxsplit=-1)  # ["a", "b", "c"]
70 + ["a", "b", "c"]  # ["a", "b", "c"]
71 | "a,b,c".split(',', maxsplit=-2)  # ["a", "b", "c"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:71:1
   |
69 | "a,b,c".split(',', maxsplit=0) # ["a,b,c"]
70 | "a,b,c".split(',', maxsplit=-1)  # ["a", "b", "c"]
71 | "a,b,c".split(',', maxsplit=-2)  # ["a", "b", "c"]
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
72 | "a,b,c".split(',', maxsplit=-0)  # ["a,b,c"]
   |
help: Replace with list literal
   |
70 | "a,b,c".split(',', maxsplit=-1)  # ["a", "b", "c"]
   - "a,b,c".split(',', maxsplit=-2)  # ["a", "b", "c"]
71 + ["a", "b", "c"]  # ["a", "b", "c"]
72 | "a,b,c".split(',', maxsplit=-0)  # ["a,b,c"]
   |

SIM905 [*] Consider using a list literal instead of `str.split`
  --> SIM905.py:72:1
   |
70 | "a,b,c".split(',', maxsplit=-1)  # ["a", "b", "c"]
71 | "a,b,c".split(',', maxsplit=-2)  # ["a", "b", "c"]
72 | "a,b,c".split(',', maxsplit=-0)  # ["a,b,c"]
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
73 |
74 | # negatives
   |
help: Replace with list literal
   |
71 | "a,b,c".split(',', maxsplit=-2)  # ["a", "b", "c"]
   - "a,b,c".split(',', maxsplit=-0)  # ["a,b,c"]
72 + ["a,b,c"]  # ["a,b,c"]
73 |
   |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:103:1
    |
102 |   # another positive demonstrating quote preservation
103 | / """
104 | | "itemA"
105 | | 'itemB'
106 | | '''itemC'''
107 | | "'itemD'"
108 | | """.split()
    | |___________^
109 |
110 |   # https://github.com/astral-sh/ruff/issues/18042
    |
help: Replace with list literal
    |
102 | # another positive demonstrating quote preservation
    - """
    - "itemA"
    - 'itemB'
    - '''itemC'''
    - "'itemD'"
    - """.split()
103 + ['"itemA"', "'itemB'", "'''itemC'''", "\"'itemD'\""]
104 |
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:111:7
    |
110 | # https://github.com/astral-sh/ruff/issues/18042
111 | print("a,b".rsplit(","))
    |       ^^^^^^^^^^^^^^^^^
112 | print("a,b,c".rsplit(",", 1))
    |
help: Replace with list literal
    |
110 | # https://github.com/astral-sh/ruff/issues/18042
    - print("a,b".rsplit(","))
111 + print(["a", "b"])
112 | print("a,b,c".rsplit(",", 1))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:112:7
    |
110 | # https://github.com/astral-sh/ruff/issues/18042
111 | print("a,b".rsplit(","))
112 | print("a,b,c".rsplit(",", 1))
    |       ^^^^^^^^^^^^^^^^^^^^^^
113 |
114 | # https://github.com/astral-sh/ruff/issues/18069
    |
help: Replace with list literal
    |
111 | print("a,b".rsplit(","))
    - print("a,b,c".rsplit(",", 1))
112 + print(["a,b", "c"])
113 |
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:116:7
    |
114 | # https://github.com/astral-sh/ruff/issues/18069
115 |
116 | print("".split(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^
117 | print("".split(sep=None, maxsplit=0))
118 | print(" ".split(maxsplit=0))
    |
help: Replace with list literal
    |
115 |
    - print("".split(maxsplit=0))
116 + print([])
117 | print("".split(sep=None, maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:117:7
    |
116 | print("".split(maxsplit=0))
117 | print("".split(sep=None, maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
118 | print(" ".split(maxsplit=0))
119 | print(" ".split(sep=None, maxsplit=0))
    |
help: Replace with list literal
    |
116 | print("".split(maxsplit=0))
    - print("".split(sep=None, maxsplit=0))
117 + print([])
118 | print(" ".split(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:118:7
    |
116 | print("".split(maxsplit=0))
117 | print("".split(sep=None, maxsplit=0))
118 | print(" ".split(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^
119 | print(" ".split(sep=None, maxsplit=0))
120 | print(" x ".split(maxsplit=0))
    |
help: Replace with list literal
    |
117 | print("".split(sep=None, maxsplit=0))
    - print(" ".split(maxsplit=0))
118 + print([])
119 | print(" ".split(sep=None, maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:119:7
    |
117 | print("".split(sep=None, maxsplit=0))
118 | print(" ".split(maxsplit=0))
119 | print(" ".split(sep=None, maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
120 | print(" x ".split(maxsplit=0))
121 | print(" x ".split(sep=None, maxsplit=0))
    |
help: Replace with list literal
    |
118 | print(" ".split(maxsplit=0))
    - print(" ".split(sep=None, maxsplit=0))
119 + print([])
120 | print(" x ".split(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:120:7
    |
118 | print(" ".split(maxsplit=0))
119 | print(" ".split(sep=None, maxsplit=0))
120 | print(" x ".split(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^
121 | print(" x ".split(sep=None, maxsplit=0))
122 | print("  x  ".split(maxsplit=0))
    |
help: Replace with list literal
    |
119 | print(" ".split(sep=None, maxsplit=0))
    - print(" x ".split(maxsplit=0))
120 + print(["x "])
121 | print(" x ".split(sep=None, maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:121:7
    |
119 | print(" ".split(sep=None, maxsplit=0))
120 | print(" x ".split(maxsplit=0))
121 | print(" x ".split(sep=None, maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
122 | print("  x  ".split(maxsplit=0))
123 | print("  x  ".split(sep=None, maxsplit=0))
    |
help: Replace with list literal
    |
120 | print(" x ".split(maxsplit=0))
    - print(" x ".split(sep=None, maxsplit=0))
121 + print(["x "])
122 | print("  x  ".split(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:122:7
    |
120 | print(" x ".split(maxsplit=0))
121 | print(" x ".split(sep=None, maxsplit=0))
122 | print("  x  ".split(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^
123 | print("  x  ".split(sep=None, maxsplit=0))
124 | print("".rsplit(maxsplit=0))
    |
help: Replace with list literal
    |
121 | print(" x ".split(sep=None, maxsplit=0))
    - print("  x  ".split(maxsplit=0))
122 + print(["x  "])
123 | print("  x  ".split(sep=None, maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:123:7
    |
121 | print(" x ".split(sep=None, maxsplit=0))
122 | print("  x  ".split(maxsplit=0))
123 | print("  x  ".split(sep=None, maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
124 | print("".rsplit(maxsplit=0))
125 | print("".rsplit(sep=None, maxsplit=0))
    |
help: Replace with list literal
    |
122 | print("  x  ".split(maxsplit=0))
    - print("  x  ".split(sep=None, maxsplit=0))
123 + print(["x  "])
124 | print("".rsplit(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:124:7
    |
122 | print("  x  ".split(maxsplit=0))
123 | print("  x  ".split(sep=None, maxsplit=0))
124 | print("".rsplit(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^
125 | print("".rsplit(sep=None, maxsplit=0))
126 | print(" ".rsplit(maxsplit=0))
    |
help: Replace with list literal
    |
123 | print("  x  ".split(sep=None, maxsplit=0))
    - print("".rsplit(maxsplit=0))
124 + print([])
125 | print("".rsplit(sep=None, maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:125:7
    |
123 | print("  x  ".split(sep=None, maxsplit=0))
124 | print("".rsplit(maxsplit=0))
125 | print("".rsplit(sep=None, maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
126 | print(" ".rsplit(maxsplit=0))
127 | print(" ".rsplit(sep=None, maxsplit=0))
    |
help: Replace with list literal
    |
124 | print("".rsplit(maxsplit=0))
    - print("".rsplit(sep=None, maxsplit=0))
125 + print([])
126 | print(" ".rsplit(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:126:7
    |
124 | print("".rsplit(maxsplit=0))
125 | print("".rsplit(sep=None, maxsplit=0))
126 | print(" ".rsplit(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^
127 | print(" ".rsplit(sep=None, maxsplit=0))
128 | print(" x ".rsplit(maxsplit=0))
    |
help: Replace with list literal
    |
125 | print("".rsplit(sep=None, maxsplit=0))
    - print(" ".rsplit(maxsplit=0))
126 + print([])
127 | print(" ".rsplit(sep=None, maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:127:7
    |
125 | print("".rsplit(sep=None, maxsplit=0))
126 | print(" ".rsplit(maxsplit=0))
127 | print(" ".rsplit(sep=None, maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
128 | print(" x ".rsplit(maxsplit=0))
129 | print(" x ".rsplit(maxsplit=0))
    |
help: Replace with list literal
    |
126 | print(" ".rsplit(maxsplit=0))
    - print(" ".rsplit(sep=None, maxsplit=0))
127 + print([])
128 | print(" x ".rsplit(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:128:7
    |
126 | print(" ".rsplit(maxsplit=0))
127 | print(" ".rsplit(sep=None, maxsplit=0))
128 | print(" x ".rsplit(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^
129 | print(" x ".rsplit(maxsplit=0))
130 | print(" x ".rsplit(sep=None, maxsplit=0))
    |
help: Replace with list literal
    |
127 | print(" ".rsplit(sep=None, maxsplit=0))
    - print(" x ".rsplit(maxsplit=0))
128 + print([" x"])
129 | print(" x ".rsplit(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:129:7
    |
127 | print(" ".rsplit(sep=None, maxsplit=0))
128 | print(" x ".rsplit(maxsplit=0))
129 | print(" x ".rsplit(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^
130 | print(" x ".rsplit(sep=None, maxsplit=0))
131 | print("  x  ".rsplit(maxsplit=0))
    |
help: Replace with list literal
    |
128 | print(" x ".rsplit(maxsplit=0))
    - print(" x ".rsplit(maxsplit=0))
129 + print([" x"])
130 | print(" x ".rsplit(sep=None, maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:130:7
    |
128 | print(" x ".rsplit(maxsplit=0))
129 | print(" x ".rsplit(maxsplit=0))
130 | print(" x ".rsplit(sep=None, maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
131 | print("  x  ".rsplit(maxsplit=0))
132 | print("  x  ".rsplit(sep=None, maxsplit=0))
    |
help: Replace with list literal
    |
129 | print(" x ".rsplit(maxsplit=0))
    - print(" x ".rsplit(sep=None, maxsplit=0))
130 + print([" x"])
131 | print("  x  ".rsplit(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:131:7
    |
129 | print(" x ".rsplit(maxsplit=0))
130 | print(" x ".rsplit(sep=None, maxsplit=0))
131 | print("  x  ".rsplit(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^
132 | print("  x  ".rsplit(sep=None, maxsplit=0))
    |
help: Replace with list literal
    |
130 | print(" x ".rsplit(sep=None, maxsplit=0))
    - print("  x  ".rsplit(maxsplit=0))
131 + print(["  x"])
132 | print("  x  ".rsplit(sep=None, maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:132:7
    |
130 | print(" x ".rsplit(sep=None, maxsplit=0))
131 | print("  x  ".rsplit(maxsplit=0))
132 | print("  x  ".rsplit(sep=None, maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
133 |
134 | # https://github.com/astral-sh/ruff/issues/19581 - embedded quotes in raw strings
    |
help: Replace with list literal
    |
131 | print("  x  ".rsplit(maxsplit=0))
    - print("  x  ".rsplit(sep=None, maxsplit=0))
132 + print(["  x"])
133 |
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:135:1
    |
134 |   # https://github.com/astral-sh/ruff/issues/19581 - embedded quotes in raw strings
135 | / r"""simple@example.com
136 | | very.common@example.com
137 | | FirstName.LastName@EasierReading.org
138 | | x@example.com
139 | | long.email-address-with-hyphens@and.subdomains.example.com
140 | | user.name+tag+sorting@example.com
141 | | name/surname@example.com
142 | | xample@s.example
143 | | " "@example.org
144 | | "john..doe"@example.org
145 | | mailhost!username@example.org
146 | | "very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
147 | | user%example.com@example.org
148 | | user-@example.org
149 | | I❤️CHOCOLATE@example.com
150 | | this\ still\"not\\allowed@example.com
151 | | stellyamburrr985@example.com
152 | | Abc.123@example.com
153 | | user+mailbox/department=shipping@example.com
154 | | !#$%&'*+-/=?^_`.{|}~@example.com
155 | | "Abc@def"@example.com
156 | | "Fred\ Bloggs"@example.com
157 | | "Joe.\\Blow"@example.com""".split("\n")
    | |_______________________________________^
    |
help: Replace with list literal
    |
134 | # https://github.com/astral-sh/ruff/issues/19581 - embedded quotes in raw strings
    - r"""simple@example.com
    - very.common@example.com
    - FirstName.LastName@EasierReading.org
    - x@example.com
    - long.email-address-with-hyphens@and.subdomains.example.com
    - user.name+tag+sorting@example.com
    - name/surname@example.com
    - xample@s.example
    - " "@example.org
    - "john..doe"@example.org
    - mailhost!username@example.org
    - "very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
    - user%example.com@example.org
    - user-@example.org
    - I❤️CHOCOLATE@example.com
    - this\ still\"not\\allowed@example.com
    - stellyamburrr985@example.com
    - Abc.123@example.com
    - user+mailbox/department=shipping@example.com
    - !#$%&'*+-/=?^_`.{|}~@example.com
    - "Abc@def"@example.com
    - "Fred\ Bloggs"@example.com
    - "Joe.\\Blow"@example.com""".split("\n")
135 + [r"simple@example.com", r"very.common@example.com", r"FirstName.LastName@EasierReading.org", r"x@example.com", r"long.email-address-with-hyphens@and.subdomains.example.com", r"user.name+tag+sorting@example.com", r"name/surname@example.com", r"xample@s.example", r'" "@example.org', r'"john..doe"@example.org', r"mailhost!username@example.org", r'"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com', r"user%example.com@example.org", r"user-@example.org", r"I❤️CHOCOLATE@example.com", r'this\ still\"not\\allowed@example.com', r"stellyamburrr985@example.com", r"Abc.123@example.com", r"user+mailbox/department=shipping@example.com", r"!#$%&'*+-/=?^_`.{|}~@example.com", r'"Abc@def"@example.com', r'"Fred\ Bloggs"@example.com', r'"Joe.\\Blow"@example.com']
136 |
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:160:1
    |
160 | / r"""first
161 | | 'no need' to escape
162 | | "swap" quote style
163 | | "use' ugly triple quotes""".split("\n")
    | |_______________________________________^
164 |
165 |   # https://github.com/astral-sh/ruff/issues/19845
    |
help: Replace with list literal
    |
159 |
    - r"""first
    - 'no need' to escape
    - "swap" quote style
    - "use' ugly triple quotes""".split("\n")
160 + [r"first", r"'no need' to escape", r'"swap" quote style', r""""use' ugly triple quotes"""]
161 |
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:166:7
    |
165 | # https://github.com/astral-sh/ruff/issues/19845
166 | print("S\x1cP\x1dL\x1eI\x1fT".split())
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
167 | print("\x1c\x1d\x1e\x1f>".split(maxsplit=0))
168 | print("<\x1c\x1d\x1e\x1f".rsplit(maxsplit=0))
    |
help: Replace with list literal
    |
165 | # https://github.com/astral-sh/ruff/issues/19845
    - print("S\x1cP\x1dL\x1eI\x1fT".split())
166 + print(["S", "P", "L", "I", "T"])
167 | print("\x1c\x1d\x1e\x1f>".split(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:167:7
    |
165 | # https://github.com/astral-sh/ruff/issues/19845
166 | print("S\x1cP\x1dL\x1eI\x1fT".split())
167 | print("\x1c\x1d\x1e\x1f>".split(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
168 | print("<\x1c\x1d\x1e\x1f".rsplit(maxsplit=0))
    |
help: Replace with list literal
    |
166 | print("S\x1cP\x1dL\x1eI\x1fT".split())
    - print("\x1c\x1d\x1e\x1f>".split(maxsplit=0))
167 + print([">"])
168 | print("<\x1c\x1d\x1e\x1f".rsplit(maxsplit=0))
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:168:7
    |
166 | print("S\x1cP\x1dL\x1eI\x1fT".split())
167 | print("\x1c\x1d\x1e\x1f>".split(maxsplit=0))
168 | print("<\x1c\x1d\x1e\x1f".rsplit(maxsplit=0))
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
169 |
170 | # leading/trailing whitespace should not count towards maxsplit
    |
help: Replace with list literal
    |
167 | print("\x1c\x1d\x1e\x1f>".split(maxsplit=0))
    - print("<\x1c\x1d\x1e\x1f".rsplit(maxsplit=0))
168 + print(["<"])
169 |
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:171:1
    |
170 | # leading/trailing whitespace should not count towards maxsplit
171 | " a b c d ".split(maxsplit=2)  # ["a", "b", "c d "]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
172 | " a b c d ".rsplit(maxsplit=2)  # [" a b", "c", "d"]
173 | "a  b".split(maxsplit=1)  # ["a", "b"]
    |
help: Replace with list literal
    |
170 | # leading/trailing whitespace should not count towards maxsplit
    - " a b c d ".split(maxsplit=2)  # ["a", "b", "c d "]
171 + ["a", "b", "c d "]  # ["a", "b", "c d "]
172 | " a b c d ".rsplit(maxsplit=2)  # [" a b", "c", "d"]
    |

SIM905 [*] Consider using a list literal instead of `str.rsplit`
   --> SIM905.py:172:1
    |
170 | # leading/trailing whitespace should not count towards maxsplit
171 | " a b c d ".split(maxsplit=2)  # ["a", "b", "c d "]
172 | " a b c d ".rsplit(maxsplit=2)  # [" a b", "c", "d"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
173 | "a  b".split(maxsplit=1)  # ["a", "b"]
    |
help: Replace with list literal
    |
171 | " a b c d ".split(maxsplit=2)  # ["a", "b", "c d "]
    - " a b c d ".rsplit(maxsplit=2)  # [" a b", "c", "d"]
172 + [" a b", "c", "d"]  # [" a b", "c", "d"]
173 | "a  b".split(maxsplit=1)  # ["a", "b"]
    |

SIM905 [*] Consider using a list literal instead of `str.split`
   --> SIM905.py:173:1
    |
171 | " a b c d ".split(maxsplit=2)  # ["a", "b", "c d "]
172 | " a b c d ".rsplit(maxsplit=2)  # [" a b", "c", "d"]
173 | "a  b".split(maxsplit=1)  # ["a", "b"]
    | ^^^^^^^^^^^^^^^^^^^^^^^^
    |
help: Replace with list literal
    |
172 | " a b c d ".rsplit(maxsplit=2)  # [" a b", "c", "d"]
    - "a  b".split(maxsplit=1)  # ["a", "b"]
173 + ["a", "b"]  # ["a", "b"]
    |
