Petua jenis Python 3 dan analisis statik

Python 3.5 memperkenalkan modul jenis baharu yang menyediakan sokongan perpustakaan standard untuk menggunakan anotasi fungsi untuk memberikan pembayang jenis pilihan. Ini membuka pintu kepada semakan jenis statik (seperti mypy) dan mungkin pengoptimuman berasaskan jenis automatik pada masa hadapan. Pembayang jenis dinyatakan dalam PEP-483 dan PEP-484.

Dalam tutorial ini, saya akan meneroka kemungkinan pemaparan pembayang jenis dan menunjukkan kepada anda cara menggunakan mypy untuk menganalisis program Python anda secara statik dan meningkatkan kualiti kod dengan ketara.

Petua Jenis

Petua jenis dibina di atas anotasi fungsi. Ringkasnya, anotasi fungsi membolehkan anda menganotasi parameter dan mengembalikan nilai fungsi atau kaedah dengan metadata arbitrari. Pembayang jenis ialah kes khas anotasi fungsi yang secara khusus menganotasi parameter fungsi dan mengembalikan nilai dengan maklumat jenis standard. Anotasi fungsi am dan pembayang jenis khas adalah pilihan sepenuhnya. Mari lihat contoh mudah:

def reverse_slice(text: str, start: int, end: int) -> str:
    return text[start:end][::-1]
    
reverse_slice('abcdef', 3, 5)
'ed'

Parameter dianotasi dengan jenis dan nilai pulangannya. Tetapi penting untuk menyedari bahawa Python benar-benar mengabaikan perkara ini. Ia menyediakan maklumat jenis melalui anotasi sifat objek fungsi, dan tidak lebih.

reverse_slice.__annotations
{'end': int, 'return': str, 'start': int, 'text': str}

Untuk mengesahkan bahawa Python benar-benar mengabaikan pembayang jenis, mari kita kacau dengan pembayang jenis sepenuhnya:

def reverse_slice(text: float, start: str, end: bool) -> dict:
    return text[start:end][::-1]
    
reverse_slice('abcdef', 3, 5)
'ed'

Seperti yang anda lihat, kod berkelakuan sama tanpa mengira jenis pembayang.

motivasi jenis gesaan

Baiklah. Pembayang jenis adalah pilihan. Python mengabaikan sepenuhnya petunjuk jenis. Jadi apa maksud mereka? Nah, terdapat beberapa sebab yang baik:

• analisis statik
• sokongan IDE
• Dokumen Standard

Saya akan menggunakan Mypy untuk analisis statik nanti. Sokongan IDE telah bermula dengan sokongan PyCharm 5 untuk petunjuk jenis. Dokumentasi standard berguna untuk pembangun yang boleh mengetahui jenis parameter dan nilai pulangan dengan mudah hanya dengan melihat tandatangan fungsi, serta penjana dokumentasi automatik yang boleh mengekstrak maklumat jenis daripada petunjuk.

modul menaiptyping 模块

输入模块包含旨在支持类型提示的类型。为什么不直接使用现有的 Python 类型，如 int、str、list 和 dict？您绝对可以使用这些类型，但由于 Python 的动态类型，除了基本类型之外，您无法获得很多信息。例如，如果您想指定一个参数可以是字符串和整数之间的映射，则使用标准 Python 类型无法做到这一点。使用输入模块，就像这样简单：

Mapping[str, int]

让我们看一个更完整的示例：一个带有两个参数的函数。其中之一是字典列表，其中每个字典包含字符串键和整数值。另一个参数是字符串或整数。类型模块允许精确指定此类复杂的参数。

from typing import List, Dict, Union

def foo(a: List[Dict[str, int]],
        b: Union[str, int]) -> int:
    """Print a list of dictionaries and return the number of dictionaries
    """
    if isinstance(b, str):
        b = int(b)
    for i in range(b):
        print(a)


x = [dict(a=1, b=2), dict(c=3, d=4)]
foo(x, '3')

[{'b': 2, 'a': 1}, {'d': 4, 'c': 3}]
[{'b': 2, 'a': 1}, {'d': 4, 'c': 3}]
[{'b': 2, 'a': 1}, {'d': 4, 'c': 3}]

有用的类型

让我们看看打字模块中一些更有趣的类型。

Callable 类型允许您指定可以作为参数传递或作为结果返回的函数，因为 Python 将函数视为一等公民。可调用对象的语法是提供一个参数类型数组（同样来自打字模块），后跟一个返回值。如果这令人困惑，这里有一个例子：

def do_something_fancy(data: Set[float], on_error: Callable[[Exception, int], None]):
    ...
    

on_error 回调函数被指定为接受 Exception 和整数作为参数且不返回任何内容的函数。

Any 类型意味着静态类型检查器应允许任何操作以及对任何其他类型的赋值。每个类型都是 Any 的子类型。

当参数可以有多种类型时，您之前看到的 Union 类型非常有用，这在 Python 中很常见。在以下示例中，verify_config() 函数接受一个配置参数，该参数可以是 Config 对象或文件名。如果是文件名，则调用另一个函数将文件解析为 Config 对象并返回。

def verify_config(config: Union[str, Config]):
    if isinstance(config, str):
        config = parse_config_file(config)
    ...
    
def parse_config_file(filename: str) -> Config:
    ...
    

Optional 类型意味着参数也可以为 None。 可选[T] 相当于 Union[T, None]

Modul input mengandungi jenis yang direka untuk menyokong pembayang jenis. Mengapa tidak hanya menggunakan jenis Python sedia ada seperti int, str, senarai, dan dict? Anda pasti boleh menggunakan jenis ini, tetapi disebabkan oleh penaip dinamik Python, anda tidak akan mendapat banyak maklumat di luar jenis asas. Sebagai contoh, jika anda ingin menentukan bahawa parameter boleh menjadi peta antara rentetan dan integer, anda tidak boleh melakukan ini menggunakan jenis Python standard. Menggunakan modul input, semudah ini:

class A:
    def merge(other: A) -> A:
        ...

      1 class A:
----> 2         def merge(other: A = None) -> A:
      3                 ...
      4

NameError: name 'A' is not defined

Mari kita lihat contoh yang lebih lengkap: fungsi dengan dua parameter. Salah satunya ialah senarai kamus, di mana setiap kamus mengandungi kunci rentetan dan nilai integer. Parameter lain ialah rentetan atau integer. Modul jenis membenarkan parameter kompleks tersebut ditentukan dengan tepat.

class A:
    def merge(other: 'A' = None) -> 'A':
        ...

Jenis yang berguna

Mari lihat beberapa jenis yang lebih menarik dalam modul menaip.

Jenis Boleh Panggil membolehkan anda menentukan fungsi yang boleh dihantar sebagai hujah atau dikembalikan sebagai hasil, kerana Python menganggap fungsi sebagai warga kelas pertama. Sintaks untuk objek boleh dipanggil adalah untuk menyediakan tatasusunan jenis parameter (juga daripada modul menaip), diikuti dengan nilai pulangan. Jika ini mengelirukan, berikut ialah contoh:

Data = Dict[int, Sequence[Dict[str, Optional[List[float]]]]

def foo(data: Data) -> bool:
    ...

on_error Fungsi panggil balik ditentukan sebagai fungsi yang menerima Pengecualian dan integer sebagai argumen dan tidak mengembalikan apa-apa. #🎜🎜# #🎜🎜#Sebarang jenis bermakna penyemak jenis statik harus membenarkan sebarang operasi dan tugasan kepada mana-mana jenis lain. Setiap jenis ialah subjenis Mana-mana. #🎜🎜# #🎜🎜#Jenis Kesatuan yang anda lihat sebelum ini berguna apabila argumen boleh terdiri daripada pelbagai jenis, yang biasa digunakan dalam Python. Dalam contoh berikut, fungsi #🎜🎜#verify_config()#🎜🎜# menerima parameter konfigurasi, yang boleh menjadi objek Config atau nama fail. Jika ia adalah nama fail, panggil fungsi lain untuk menghuraikan fail ke dalam objek Config dan mengembalikannya. #🎜🎜#

print(A.merge.__annotations__)

{'other': 'A', 'return': 'A'}

#🎜🎜#Jenis pilihan bermakna parameter juga boleh Tiada. Pilihan[T] adalah bersamaan dengan Union[T, None]#🎜🎜# #🎜🎜# Terdapat banyak lagi jenis yang mewakili pelbagai fungsi, seperti Iterable, Iterator, Reversible, SupportsInt, SupportsFloat, Sequence, MutableSequence dan IO. Lihat dokumentasi modul menaip untuk senarai lengkap. #🎜🎜# #🎜🎜# Paling penting, anda boleh menentukan jenis hujah dengan cara yang sangat halus, menyokong sistem jenis Python dengan kesetiaan tinggi dan membenarkan kelas asas generik dan abstrak. #🎜🎜# #🎜🎜#Petikan Hadapan#🎜🎜# #🎜🎜#Kadangkala anda ingin merujuk kelas dalam pembayang jenis untuk salah satu kaedahnya. Sebagai contoh, katakan kelas A boleh melakukan beberapa operasi gabungan yang mengambil contoh A yang lain, menggabungkannya dengan dirinya sendiri dan mengembalikan hasilnya. Berikut ialah percubaan naif untuk menentukannya menggunakan petunjuk jenis: #🎜🎜#

print(get_type_hints(A.merge))

{'return': , 'other': typing.Union[__main__.A, NoneType]}

#🎜🎜#Apa yang berlaku? Apabila Python menyemak petunjuk jenis untuk kaedah merge()nya, kelas A belum ditakrifkan, jadi kelas A tidak boleh digunakan (secara langsung) pada masa ini. Penyelesaiannya sangat mudah dan saya telah melihatnya digunakan dengan SQLAlchemy sebelum ini. Anda hanya tentukan pembayang jenis sebagai rentetan. Python akan memahami ia adalah rujukan ke hadapan dan melakukan perkara yang betul: #🎜🎜#

class A:
    def merge(other: 'A' = None) -> 'A':
        ...

输入别名

对长类型规范使用类型提示的一个缺点是，即使它提供了大量类型信息，它也会使代码变得混乱并降低可读性。您可以像任何其他对象一样为类型添加别名。很简单：

Data = Dict[int, Sequence[Dict[str, Optional[List[float]]]]

def foo(data: Data) -> bool:
    ...

get_type_hints() 辅助函数

类型模块提供 get_type_hints() 函数，该函数提供有关参数类型和返回值的信息。虽然 annotations 属性返回类型提示，因为它们只是注释，但我仍然建议您使用 get_type_hints() 函数，因为它可以解析前向引用。另外，如果您为其中一个参数指定默认值 None，则 get_type_hints() 函数将自动将其类型返回为 Union[T, NoneType]（如果您刚刚指定了 T）。让我们看看使用 A.merge() 方法的区别之前定义：

print(A.merge.__annotations__)

{'other': 'A', 'return': 'A'}

annotations 属性仅按原样返回注释值。在本例中，它只是字符串“A”，而不是 A 类对象，“A”只是对其的前向引用。

print(get_type_hints(A.merge))

{'return': , 'other': typing.Union[__main__.A, NoneType]}

由于 None 默认参数，get_type_hints() 函数将 other 参数的类型转换为 A（类）和 NoneType 的并集。返回类型也转换为 A 类。

装饰器

类型提示是函数注释的特殊化，它们也可以与其他函数注释一起工作。

为了做到这一点，类型模块提供了两个装饰器：@no_type_check和@no_type_check_decorator。 @no_type_check 装饰器可以应用于类或函数。它将 no_type_check 属性添加到函数（或类的每个方法）。这样，类型检查器就会知道忽略注释，它们不是类型提示。

这有点麻烦，因为如果你编写一个将被广泛使用的库，你必须假设将使用类型检查器，并且如果你想用非类型提示来注释你的函数，你还必须装饰它们与@no_type_check。

使用常规函数注释时的一个常见场景也是有一个对其进行操作的装饰器。在这种情况下，您还想关闭类型检查。一种选择是除了装饰器之外还使用 @no_type_check 装饰器，但这会过时。相反，@no_Type_check_decorator可用于装饰您的装饰器，使其行为类似于@no_type_check（添加no_type_check属性）。 p>

让我来说明所有这些概念。如果您尝试在使用常规字符串注释的函数上使用 get_type_hint() （任何类型检查器都会这样做），则 get_type_hints() 会将其解释为前向引用：

def f(a: 'some annotation'):
    pass

print(get_type_hints(f))

SyntaxError: ForwardRef must be an expression -- got 'some annotation'

要避免这种情况，请添加 @no_type_check 装饰器，get_type_hints 仅返回一个空字典，而 __annotations__ 属性返回注释：

@no_type_check
def f(a: 'some annotation'):
    pass
    
print(get_type_hints(f))
{}

print(f.__annotations__)
{'a': 'some annotation'}

现在，假设我们有一个打印注释字典的装饰器。您可以使用 @no_Type_check_decorator 装饰它，然后装饰该函数，而不用担心某些类型检查器调用 get_type_hints() 并感到困惑。对于每个使用注释操作的装饰器来说，这可能是最佳实践。不要忘记@functools.wraps，否则注释将不会被复制到装饰函数中，一切都会崩溃。 Python 3 函数注释对此进行了详细介绍。

@no_type_check_decorator
def print_annotations(f):
    @functools.wraps(f)
    def decorated(*args, **kwargs):
        print(f.__annotations__)
        return f(*args, **kwargs)
    return decorated

现在，您可以仅使用 @print_annotations 来装饰该函数，并且每当调用它时，它都会打印其注释。

@print_annotations
def f(a: 'some annotation'):
    pass
    
f(4)
{'a': 'some annotation'}

调用 get_type_hints() 也是安全的，并返回一个空字典。

print(get_type_hints(f))
{}

使用 Mypy 进行静态分析

Mypy 是一个静态类型检查器，它是类型提示和类型模块的灵感来源。 Guido van Rossum 本人是 PEP-483 的作者，也是 PEP-484 的合著者。

安装 Mypy

Mypy 正处于非常活跃的开发阶段，截至撰写本文时，PyPI 上的软件包已经过时，并且无法与 Python 3.5 一起使用。要将 Mypy 与 Python 3.5 结合使用，请从 GitHub 上的 Mypy 存储库获取最新版本。很简单：

pip3 install git+git://github.com/JukkaL/mypy.git

使用 Mypy

一旦安装了 Mypy，您就可以在您的程序上运行 Mypy。以下程序定义了一个需要字符串列表的函数。然后它使用整数列表调用该函数。

from typing import List

def case_insensitive_dedupe(data: List[str]):
    """Converts all values to lowercase and removes duplicates"""
    return list(set(x.lower() for x in data))


print(case_insensitive_dedupe([1, 2]))

运行程序时，显然在运行时失败并出现以下错误：

python3 dedupe.py
Traceback (most recent call last):
  File "dedupe.py", line 8, in <module>
    print(case_insensitive_dedupe([1, 2, 3]))
  File "dedupe.py", line 5, in case_insensitive_dedupe
    return list(set(x.lower() for x in data))
  File "dedupe.py", line 5, in <genexpr>
    return list(set(x.lower() for x in data))
AttributeError: 'int' object has no attribute 'lower'

这有什么问题吗？问题在于，即使在这个非常简单的案例中，也无法立即弄清楚根本原因是什么。是输入类型的问题吗？或者代码本身可能是错误的，不应该尝试调用“int”对象的 lower() 方法。另一个问题是，如果您没有 100% 的测试覆盖率（老实说，我们都没有），那么此类问题可能潜伏在一些未经测试、很少使用的代码路径中，并在生产中最糟糕的时间被检测到。

静态类型在类型提示的帮助下，通过确保您始终使用正确的类型调用函数（用类型提示注释），为您提供了额外的安全网。这是 Mypy 的输出：

(N) > mypy dedupe.py
dedupe.py:8: error: List item 0 has incompatible type "int"
dedupe.py:8: error: List item 1 has incompatible type "int"
dedupe.py:8: error: List item 2 has incompatible type "int"

这很简单，直接指出问题，并且不需要运行大量测试。静态类型检查的另一个好处是，如果您提交它，则可以跳过动态类型检查，除非解析外部输入（读取文件、传入的网络请求或用户输入）。就重构而言，它还建立了很大的信心。

结论

类型提示和类型模块对于 Python 的表达能力来说是完全可选的补充。虽然它们可能不适合每个人的口味，但对于大型项目和大型团队来说它们是不可或缺的。证据是大型团队已经使用静态类型检查。现在类型信息已经标准化，共享使用它的代码、实用程序和工具将变得更加容易。像 PyCharm 这样的 IDE 已经利用它来提供更好的开发人员体验。

Atas ialah kandungan terperinci Petua jenis Python 3 dan analisis statik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!