pyupgrade

py升级

一个工具（和预提交挂钩），用于自动升级该语言新版本的语法。

安装

pip install pyupgrade

作为预提交钩子

请参阅预提交以获取说明

示例.pre-commit-config.yaml ：

-   repo : https://github.com/asottile/pyupgrade
    rev : v3.19.0
    hooks :
    -   id : pyupgrade 

已实现的功能

设置文字

 - set(())
+ set()
- set([])
+ set()
- set((1,))
+ {1}
- set((1, 2))
+ {1, 2}
- set([1, 2])
+ {1, 2}
- set(x for x in y)
+ {x for x in y}
- set([x for x in y])
+ {x for x in y}

字典推导式

 - dict((a, b) for a, b in y)
+ {a: b for a, b in y}
- dict([(a, b) for a, b in y])
+ {a: b for a, b in y}

替换collections.defaultdict调用中不必要的 lambda

 - defaultdict(lambda: [])
+ defaultdict(list)
- defaultdict(lambda: list())
+ defaultdict(list)
- defaultdict(lambda: {})
+ defaultdict(dict)
- defaultdict(lambda: dict())
+ defaultdict(dict)
- defaultdict(lambda: ())
+ defaultdict(tuple)
- defaultdict(lambda: tuple())
+ defaultdict(tuple)
- defaultdict(lambda: set())
+ defaultdict(set)
- defaultdict(lambda: 0)
+ defaultdict(int)
- defaultdict(lambda: 0.0)
+ defaultdict(float)
- defaultdict(lambda: 0j)
+ defaultdict(complex)
- defaultdict(lambda: '')
+ defaultdict(str)

格式说明符

 - '{0} {1}'.format(1, 2)
+ '{} {}'.format(1, 2)
- '{0}' '{1}'.format(1, 2)
+ '{}' '{}'.format(1, 2)

printf 风格的字符串格式

可用性：

• 除非传递了--keep-percent-format 。

 - '%s %s' % (a, b)
+ '{} {}'.format(a, b)
- '%r %2f' % (a, b)
+ '{!r} {:2f}'.format(a, b)
- '%(a)s %(b)s' % {'a': 1, 'b': 2}
+ '{a} {b}'.format(a=1, b=2)

Unicode 文字

 - u'foo'
+ 'foo'
- u"foo"
+ 'foo'
- u'''foo'''
+ '''foo'''

无效的转义序列

 # strings with only invalid sequences become raw strings
- 'd'
+ r'd'
 # strings with mixed valid / invalid sequences get escaped
- 'nd'
+ 'n\d'
- u'd'
+ r'd'
 # this fixes a syntax error in python3.3+
- 'N'
+ r'N'

is / is not与常量文字比较

在 python3.8+ 中，与文字的比较成为SyntaxWarning因为这些比较的成功与否是特定于实现的（由于公共对象缓存）。

 - x is 5
+ x == 5
- x is not 5
+ x != 5
- x is 'foo'
+ x == 'foo'

.encode()到字节文字

 - 'foo'.encode()
+ b'foo'
- 'foo'.encode('ascii')
+ b'foo'
- 'foo'.encode('utf-8')
+ b'foo'
- u'foo'.encode()
+ b'foo'
- 'xa0'.encode('latin1')
+ b'xa0'

print(...)中的无关括号

python-modernize/python-modernize#178 的修复

 # ok: printing an empty tuple
 print(())
 # ok: printing a tuple
 print((1,))
 # ok: parenthesized generator argument
 sum((i for i in range(3)), [])
 # fixed:
- print(("foo"))
+ print("foo")

常量折叠isinstance / issubclass / except

 - isinstance(x, (int, int))
+ isinstance(x, int)

- issubclass(y, (str, str))
+ issubclass(y, str)

 try:
     raises()
- except (Error1, Error1, Error2):
+ except (Error1, Error2):
     pass

unittest 不推荐使用别名

将已弃用的单元测试方法别名重写为其未弃用的形式。

 from unittest import TestCase


 class MyTests(TestCase):
     def test_something(self):
-        self.failUnlessEqual(1, 1)
+        self.assertEqual(1, 1)
-        self.assertEquals(1, 1)
+        self.assertEqual(1, 1)

super()调用

 class C(Base):
     def f(self):
-        super(C, self).f()
+        super().f()

“新风格”课程

重写类声明

 - class C(object): pass
+ class C: pass
- class C(B, object): pass
+ class C(B): pass 

删除__metaclass__ = type声明

 class C:
-    __metaclass__ = type

强制str("native")文字

 - str()
+ ''
- str("foo")
+ "foo"

.encode("utf-8")

 - "foo".encode("utf-8")
+ "foo".encode()

# coding: ...评论

从 PEP 3120 开始，python 源的默认编码是 UTF-8

 - # coding: utf-8
 x = 1

__future__导入移除

可用性：

• 默认情况下删除nested_scopes ， generators ， with_statement ， absolute_import ， division ， print_function ， unicode_literals
• --py37-plus还将删除generator_stop

 - from __future__ import with_statement

删除不必要的 py3-compat 导入

 - from io import open
- from six.moves import map
- from builtins import object  # python-future

进口替代品

可用性：

• --py36-plus （和其他）将取代导入

另请参阅 reorder-python-imports

一些例子：

 - from collections import deque, Mapping
+ from collections import deque
+ from collections.abc import Mapping 

 - from typing import Sequence
+ from collections.abc import Sequence 

 - from typing_extensions import Concatenate
+ from typing import Concatenate

重写mock导入

可用性：

• 除非在命令行上传递--keep-mock 。

 - from mock import patch
+ from unittest.mock import patch

yield => yield from

 def f():
-    for x in y:
-        yield x
+    yield from y
-    for a, b in c:
-        yield (a, b)
+    yield from c

Python2 和旧的 Python3.x 块

 import sys
- if sys.version_info < (3,):  # also understands `six.PY2` (and `not`), `six.PY3` (and `not`)
-    print('py2')
- else:
-    print('py3')
+ print('py3')

可用性：

• --py36-plus将删除 Python <= 3.5 only 块
• --py37-plus将删除仅 Python <= 3.6 的块
• 等等等等

 # using --py36-plus for this example

 import sys
- if sys.version_info < (3, 6):
-    print('py3.5')
- else:
-    print('py3.6+')
+ print('py3.6+')

- if sys.version_info <= (3, 5):
-    print('py3.5')
- else:
-    print('py3.6+')
+ print('py3.6+')

- if sys.version_info >= (3, 6):
-    print('py3.6+')
- else:
-    print('py3.5')
+ print('py3.6+')

请注意，没有else if块不会被重写，因为它可能会引入语法错误。

删除six兼容性代码

 - six.text_type
+ str
- six.binary_type
+ bytes
- six.class_types
+ (type,)
- six.string_types
+ (str,)
- six.integer_types
+ (int,)
- six.unichr
+ chr
- six.iterbytes
+ iter
- six.print_(...)
+ print(...)
- six.exec_(c, g, l)
+ exec(c, g, l)
- six.advance_iterator(it)
+ next(it)
- six.next(it)
+ next(it)
- six.callable(x)
+ callable(x)
- six.moves.range(x)
+ range(x)
- six.moves.xrange(x)
+ range(x)


- from six import text_type
- text_type
+ str

- @six.python_2_unicode_compatible
 class C:
     def __str__(self):
         return u'C()'

- class C(six.Iterator): pass
+ class C: pass

- class C(six.with_metaclass(M, B)): pass
+ class C(B, metaclass=M): pass

- @six.add_metaclass(M)
- class C(B): pass
+ class C(B, metaclass=M): pass

- isinstance(..., six.class_types)
+ isinstance(..., type)
- issubclass(..., six.integer_types)
+ issubclass(..., int)
- isinstance(..., six.string_types)
+ isinstance(..., str)

- six.b('...')
+ b'...'
- six.u('...')
+ '...'
- six.byte2int(bs)
+ bs[0]
- six.indexbytes(bs, i)
+ bs[i]
- six.int2byte(i)
+ bytes((i,))
- six.iteritems(dct)
+ dct.items()
- six.iterkeys(dct)
+ dct.keys()
- six.itervalues(dct)
+ dct.values()
- next(six.iteritems(dct))
+ next(iter(dct.items()))
- next(six.iterkeys(dct))
+ next(iter(dct.keys()))
- next(six.itervalues(dct))
+ next(iter(dct.values()))
- six.viewitems(dct)
+ dct.items()
- six.viewkeys(dct)
+ dct.keys()
- six.viewvalues(dct)
+ dct.values()
- six.create_unbound_method(fn, cls)
+ fn
- six.get_unbound_function(meth)
+ meth
- six.get_method_function(meth)
+ meth.__func__
- six.get_method_self(meth)
+ meth.__self__
- six.get_function_closure(fn)
+ fn.__closure__
- six.get_function_code(fn)
+ fn.__code__
- six.get_function_defaults(fn)
+ fn.__defaults__
- six.get_function_globals(fn)
+ fn.__globals__
- six.raise_from(exc, exc_from)
+ raise exc from exc_from
- six.reraise(tp, exc, tb)
+ raise exc.with_traceback(tb)
- six.reraise(*sys.exc_info())
+ raise
- six.assertCountEqual(self, a1, a2)
+ self.assertCountEqual(a1, a2)
- six.assertRaisesRegex(self, e, r, fn)
+ self.assertRaisesRegex(e, r, fn)
- six.assertRegex(self, s, r)
+ self.assertRegex(s, r)

 # note: only for *literals*
- six.ensure_binary('...')
+ b'...'
- six.ensure_str('...')
+ '...'
- six.ensure_text('...')
+ '...'

open别名

 - with io.open('f.txt') as f:
+ with open('f.txt') as f:
     ...

冗余open模式

 - open("foo", "U")
+ open("foo")
- open("foo", "Ur")
+ open("foo")
- open("foo", "Ub")
+ open("foo", "rb")
- open("foo", "rUb")
+ open("foo", "rb")
- open("foo", "r")
+ open("foo")
- open("foo", "rt")
+ open("foo")
- open("f", "r", encoding="UTF-8")
+ open("f", encoding="UTF-8")
- open("f", "wt")
+ open("f", "w")

OSError错误别名

 # also understands:
 # - IOError
 # - WindowsError
 # - mmap.error and uses of `from mmap import error`
 # - select.error and uses of `from select import error`
 # - socket.error and uses of `from socket import error`

 def throw():
-    raise EnvironmentError('boom')
+    raise OSError('boom')

 def catch():
     try:
         throw()
-    except EnvironmentError:
+    except OSError:
         handle_error()

TimeoutError别名

可用性：

• --py310-plus用于socket.timeout
• --py311-plus用于asyncio.TimeoutError

 def throw(a):
     if a:
-        raise asyncio.TimeoutError('boom')
+        raise TimeoutError('boom')
     else:
-        raise socket.timeout('boom')
+        raise TimeoutError('boom')

 def catch(a):
     try:
         throw(a)
-    except (asyncio.TimeoutError, socket.timeout):
+    except TimeoutError:
         handle_error()

typing.Text str 别名

 - def f(x: Text) -> None:
+ def f(x: str) -> None:
     ...

解包列表理解

 - foo, bar, baz = [fn(x) for x in items]
+ foo, bar, baz = (fn(x) for x in items)

将xml.etree.cElementTree重写为xml.etree.ElementTree

 - import xml.etree.cElementTree as ET
+ import xml.etree.ElementTree as ET
- from xml.etree.cElementTree import XML
+ from xml.etree.ElementTree import XML

重写原语type

 - type('')
+ str
- type(b'')
+ bytes
- type(0)
+ int
- type(0.)
+ float

typing.NamedTuple / typing.TypedDict py36+ 语法

可用性：

• --py36-plus在命令行上传递。

 - NT = typing.NamedTuple('NT', [('a', int), ('b', Tuple[str, ...])])
+ class NT(typing.NamedTuple):
+    a: int
+    b: Tuple[str, ...]

- D1 = typing.TypedDict('D1', a=int, b=str)
+ class D1(typing.TypedDict):
+    a: int
+    b: str

- D2 = typing.TypedDict('D2', {'a': int, 'b': str})
+ class D2(typing.TypedDict):
+    a: int
+    b: str

F 弦

可用性：

• --py36-plus在命令行上传递。

 - '{foo} {bar}'.format(foo=foo, bar=bar)
+ f'{foo} {bar}'
- '{} {}'.format(foo, bar)
+ f'{foo} {bar}'
- '{} {}'.format(foo.bar, baz.womp)
+ f'{foo.bar} {baz.womp}'
- '{} {}'.format(f(), g())
+ f'{f()} {g()}'
- '{x}'.format(**locals())
+ f'{x}'

注意： pyupgrade故意胆怯，如果它会使表达式更长或者替换参数足够复杂（因为这会降低可读性），则不会创建 f 字符串。

subprocess.run ：用text替换universal_newlines

可用性：

• --py37-plus在命令行上传递。

 - output = subprocess.run(['foo'], universal_newlines=True)
+ output = subprocess.run(['foo'], text=True)

subprocess.run ：用capture_output=True替换stdout=subprocess.PIPE, stderr=subprocess.PIPE

可用性：

• --py37-plus在命令行上传递。

 - output = subprocess.run(['foo'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ output = subprocess.run(['foo'], capture_output=True)

从@functools.lru_cache()中删除括号

可用性：

• --py38-plus在命令行上传递。

 import functools

- @functools.lru_cache()
+ @functools.lru_cache
 def expensive():
     ...

shlex.join

可用性：

• --py38-plus在命令行上传递。

 - ' '.join(shlex.quote(arg) for arg in cmd)
+ shlex.join(cmd)

将@functools.lru_cache(maxsize=None)替换为简写

可用性：

• --py39-plus在命令行上传递。

 import functools

- @functools.lru_cache(maxsize=None)
+ @functools.cache
 def expensive():
     ...

pep 585 打字重写

可用性：

• from __future__ import annotations导入文件
  • 除非在命令行上传递--keep-runtime-typing 。
• --py39-plus在命令行上传递。

 - def f(x: List[str]) -> None:
+ def f(x: list[str]) -> None:
     ...

pep 604 打字重写

可用性：

• from __future__ import annotations导入文件
  • 除非在命令行上传递--keep-runtime-typing 。
• --py310-plus在命令行上传递。

 - def f() -> Optional[str]:
+ def f() -> str | None:
     ...

 - def f() -> Union[int, str]:
+ def f() -> int | str:
     ...

pep 696 TypeVar 默认值

可用性：

• from __future__ import annotations导入文件
  • 除非在命令行上传递--keep-runtime-typing 。
• --py313-plus在命令行上传递。

 - def f() -> Generator[int, None, None]:
+ def f() -> Generator[int]:
     yield 1

 - async def f() -> AsyncGenerator[int, None]:
+ async def f() -> AsyncGenerator[int]:
     yield 1

删除引用的注释

可用性：

• from __future__ import annotations导入文件

 - def f(x: 'queue.Queue[int]') -> C:
+ def f(x: queue.Queue[int]) -> C:

使用datetime.UTC别名

可用性：

• --py311-plus在命令行上传递。

 import datetime

- datetime.timezone.utc
+ datetime.UTC