Comparación do comprobador de tipos de Python: inferencia de contedores baleiros

Por que os contedores baleiros rompen os comprobadores de tipo Python e que podes facer con iso

O sistema de escritura gradual de Python madurou significativamente desde que PEP 484 introduciu as suxestións de tipo en 2015. Hoxe, millóns de desenvolvedores confían en verificadores de tipos estáticos para detectar erros antes de chegar á produción. Pero hai un recuncho sutil e frustrante do sistema de tipos que aínda fai tropezar ata enxeñeiros experimentados: que tipo ten un recipiente baleiro? Cando escribes x = [] sen anotacións, o teu corrector de tipo ten que adiviñar, e as distintas fichas adiviñan de forma diferente. Esta diverxencia crea problemas reais para os equipos que manteñen grandes bases de código, onde cambiar ou combinar verificadores de tipos pode aparecer centos de erros inesperados durante a noite.

Este artigo desglosa como os catro principais verificadores de tipos de Python (mypy, pyright, pytype e pyre) manexan a inferencia de contedores baleiros, por que non están de acordo e que estratexias prácticas podes adoptar para escribir Python seguro de tipos independentemente da ferramenta que elixas.

O problema principal: os contedores baleiros son intrínsecamente ambiguos

Considera esta liña inocua de Python: resultados = []. É resultados unha lista[int]? Unha lista[str]? Unha lista[dict[str, Any]]? Sen contexto adicional, realmente non hai forma de sabelo. O tempo de execución de Python non lle importa (as listas son heteroxéneas por natureza), pero os verificadores de tipos estáticos precisan asignar un tipo concreto a cada variable para facer o seu traballo. Isto crea unha tensión fundamental entre a flexibilidade dinámica de Python e as garantías que a análise estática tenta ofrecer.

O problema compónse con dicionarios e conxuntos. En realidade, un {} baleiro analízase como un dicto, non como un conxunto, o que engade ambigüidade sintáctica por riba da ambigüidade a nivel de tipo. E os contedores aniñados (pensa defaultdict(lista) ou results = {k: [] for k in keys}) empuxan os motores de inferencia ao seu límite. Cada verificador de tipos desenvolveu as súas propias heurísticas e as diferenzas son máis significativas do que a maioría dos desenvolvedores pensan.

Nos sistemas de produción que procesan cargas de traballo reais, xa sexa un CRM que manexa os rexistros de clientes, un módulo de facturación que xere elementos de liña ou unha canalización de análise que agrega métricas, os contedores baleiros aparecen constantemente como patróns de inicialización. Equivocar os seus tipos non só produce avisos de linter; pode enmascarar erros xenuínos que se deslizan ata o tempo de execución.

Mypy: inferencia diferida con calquera implícita

Mypy, o comprobador de tipos de Python máis antigo e máis adoptado, adopta un enfoque relativamente indulgente para os contedores baleiros. Cando atopa x = [] no ámbito da función, tenta aplazar a decisión do tipo e inferir o tipo de elemento do uso posterior. Se escribe x = [] seguido de x.append(42), mypy inferirá list[int]. Esta estratexia de "unir" funciona sorprendentemente ben para casos sinxelos nos que o contedor se enche no mesmo ámbito.

Non obstante, o comportamento de mypy cambia drasticamente dependendo do contexto e da configuración de rigor. No ámbito do módulo (código de nivel superior) ou cando o contedor se pasa a outra función antes de encher, mypy adoita volver a list[Any]. Baixo a marca --strict, isto desencadea un erro, pero no modo predeterminado pasa silenciosamente. Isto significa que os equipos que executan mypy sen o modo estrito poden acumular decenas de contedores implícitamente escritos que actúan como escotillas de escape do sistema de tipos, o que invalida o seu propósito.

Un comportamento especialmente sutil: as versións mypy anteriores á 0.990 ás veces inferirían lista[Descoñecido] internamente e despois ampliaban a lista[Calquera] na asignación. Despois de 0.990, a inferencia reforzouse, pero o cambio rompeu un número sorprendente de bases de código do mundo real que estiveran confiando no comportamento permisivo sen darse conta. Este é un tema recorrente: os cambios na inferencia de contedores baleiros están entre as actualizacións de verificación de tipos máis perturbadoras porque os patróns son tan omnipresentes.

Pyright: inferencia estrita e tipo "descoñecido"

Pyright, desenvolvido por Microsoft e que impulsa a Pylance en VS Code, adopta unha postura filosófica fundamentalmente diferente. En lugar de volver silenciosamente a Calquera, pyright distingue entre Descoñecido (un tipo que aínda non se determinou) e Calquera (unha desactivación explícita da comprobación de tipo). Cando escribes x = [] no modo estrito de pyright, infire lista[Descoñecido] e informa dun diagnóstico, o que o obriga a proporcionar unha anotación.

Pyright tamén é máis agresivo á hora de reducir o seu alcance. Se escribes:

• x = [] seguido de x.append("hola") — pyright deduce list[str]
• x = [] seguido de x.append(1) e despois x.append("hola") — pyright deduce list[int | str
• x = [] pasou directamente a unha función que esperaba list[int] — pyright deduce list[int] a partir do contexto do sitio de chamada
• x = [] devolto dunha función sen unha anotación de tipo de retorno: pyright informa dun erro en lugar de adiviñar

Esta inferencia bidireccional (usando o uso posterior e os tipos esperados dos sitios de chamadas) fai que pyright sexa notablemente máis preciso que mypy para contedores baleiros. A compensación é a verbosidade: o modo estrito de pyright marca aproximadamente un 30-40 % máis de problemas nunha base de código típica sen anotación en comparación co modo estrito de mypy, segundo a análise de varios informes de migración de código aberto. Para os equipos que crean sistemas de backend complexos (por exemplo, unha plataforma que xestione 207 módulos interconectados que abarcan CRM, nóminas e análises), o rigor de pyright detecta sutís desaxustes de interface que non se perderían as inferencias indulgentes.

Pytype e Pyre: as estradas menos transitadas

O pytype de Google é quizais o enfoque máis pragmático. En lugar de esixir anotacións ou recurrir a Calquera, pytype usa a análise de todo o programa para rastrexar como se usa un contedor a través dos límites das funcións. Se creas unha lista baleira nunha función e pásaa a outra que engade números enteiros, pytype adoita deducir list[int] sen ningunha anotación. Esta inferencia de funcións cruzadas é custosa computacionalmente (pytype é significativamente máis lento que mypy ou pyright en grandes bases de código), pero produce menos falsos positivos en código non anotado.

Pytype tamén introduce o concepto de "tipos parciais" para os contedores baleiros. Un [] recén creado obtén un tipo parcial que se vai perfeccionando progresivamente a medida que o corrector atopa máis uso. Isto é conceptualmente elegante, pero pode producir mensaxes de erro confusas cando o tipo parcial non se pode resolver por completo, como cando un contedor baleiro pasa por varias funcións sen que nunca se enche.

A pira de Meta, mentres tanto, achégase máis ao comportamento de mypy pero con valores predeterminados máis estrictos. Pyre trata x = [] como lista[descoñecida] e require anotacións na maioría dos contextos. O lugar onde pyre se diferencia é no seu manexo de literais de dicionario baleiros usados ​​como kwargs, un patrón común nos frameworks web. Pyre ten lóxica de casos especiais para inferir tipos de dicionario a partir de contextos de argumentos de palabras clave, reducindo a carga de anotacións nas bases de código pesadas en marcos. Dado que a maioría das aplicacións web modernas implican un uso intensivo do desempaquetado do dicionario para a configuración e o manexo de solicitudes, este pragmatismo dá beneficios.

Impacto no mundo real: cando morde a diverxencia da inferencia

As diferenzas entre os verificadores de tipos poden parecer académicas ata que as experimentas nunha base de códigos de produción. Considere un patrón común nas aplicacións empresariais: inicializar unha estrutura de datos que se enche condicionalmente.