Jump to content

Será que Type Hinting em Python afeta a performance de alguma forma em tempo de execução?


Recommended Posts

Posted

Tenho vindo a perguntar-me se o uso de type hinting em Python 3.X é considerado um favor que fazemos ao interpretador ou não.

Será que afeta a performance de alguma forma a performance, não em termos notaveis mas pelo menos em alguns milisegundos? Será que type hinting faz-lo ser mais rapido, ou ligeiramente mais lento? Tenho esta curiosidade. Não sei ao certo como testar isto para obter conclusões.

Eu encontrei este post (stackoverflow) sobre o assunto a referenciar os proposals mas é um tanto quanto antigo, debatem o assunto da versão em que primeiro esta feature foi implementada, para não falar que o Python passou por mudanças serias no seu interpretador ao longo das versões e não encontrei testes em lado nenhum sobre o assunto.

Tenho aqui um exemplo de um codigo em Python em que estou a "abusar" do type hinting (Sim, estou ciente que é redundante em muita coisa que estou a usar, é apenas para provar um ponto):

Codigo Tipado:

from random import randint

def add(a: int, b: int) -> int:
    result: int = a + b
    return result

def getInput() -> int:
    randomValue: int = randint(0, 1000)
    return randomValue

def main() -> None:
    result: int = 0
    try:
        inputValue: tuple[str, str] = getInput(), getInput()
        a: int = int(inputValue[0])
        b: int = int(inputValue[1])
        result = add(a, b)
    except ValueError as e:
        formattedError: str = f"{inputValue[0]} + {inputValue[1]} = {e}"
        print(formattedError)
        return

    print(result)
    return

if __name__ == "__main__":
    main()


Codigo Não Tipado:

from random import randint

def add(a, b):
    result = a + b
    return result

def getInput():
    randomValue = randint(0, 1000)
    return randomValue

def main():
    result = 0
    try:
        inputValue = getInput(), getInput()
        a = int(inputValue[0])
        b = int(inputValue[1])
        result = add(a, b)
    except ValueError as e:
        formattedError = f"{inputValue[0]} + {inputValue[1]} = {e}"
        print(formattedError)
        return

    print(result)
    return

if __name__ == "__main__":
    main()


Eu tentei chegar a uma conclusão com o seguinte script Bash usando o hyperfine para me poupar um pouco de trabalho a dar parse aos comandos time:

#!/bin/bash

WARM_UP=100
TEST_AMOUNT=10000

hyperfine --warmup $WARM_UP --runs $TEST_AMOUNT 'python3.13 Typed.py'
hyperfine --warmup $WARM_UP --runs $TEST_AMOUNT 'python3.13 NotTyped.py'

hyperfine --warmup $WARM_UP --runs $TEST_AMOUNT 'python3.12 Typed.py'
hyperfine --warmup $WARM_UP --runs $TEST_AMOUNT 'python3.12 NotTyped.py'

Será que seria o suficiente? Obtive os resultados seguintes:

$ ./test.sh
Benchmark 1: python3.13 Typed.py
  Time (mean ± σ):      18.0 ms ±   1.7 ms    [User: 9.2 ms, System: 1.8 ms]
  Range (min … max):    13.4 ms …  25.6 ms    1000 runs

Benchmark 1: python3.13 NotTyped.py
  Time (mean ± σ):      18.1 ms ±   1.7 ms    [User: 9.3 ms, System: 1.7 ms]
  Range (min … max):    14.3 ms …  33.6 ms    1000 runs

  Warning: Statistical outliers were detected. Consider re-running this benchmark on a quiet system without any interferences from other programs. It might help to use the '--warmup' or '--prepare' options.

Benchmark 1: python3.12 Typed.py
  Time (mean ± σ):      20.0 ms ±   1.7 ms    [User: 10.4 ms, System: 2.6 ms]
  Range (min … max):    16.9 ms …  32.6 ms    1000 runs

Benchmark 1: python3.12 NotTyped.py
  Time (mean ± σ):      20.5 ms ±   1.7 ms    [User: 10.7 ms, System: 2.3 ms]
  Range (min … max):    16.9 ms …  28.2 ms    1000 runs

$ ./test.sh
Benchmark 1: python3.13 Typed.py
  Time (mean ± σ):      18.5 ms ±   4.0 ms    [User: 9.7 ms, System: 1.9 ms]
  Range (min … max):    13.3 ms … 130.1 ms    10000 runs

  Warning: Statistical outliers were detected. Consider re-running this benchmark on a quiet system without any interferences from other programs. It might help to use the '--warmup' or '--prepare' options.

Benchmark 1: python3.13 NotTyped.py
  Time (mean ± σ):      17.1 ms ±   1.7 ms    [User: 9.1 ms, System: 1.7 ms]
  Range (min … max):    12.5 ms …  28.7 ms    10000 runs

Benchmark 1: python3.12 Typed.py
  Time (mean ± σ):      19.7 ms ±   1.9 ms    [User: 10.3 ms, System: 2.4 ms]
  Range (min … max):    14.6 ms …  36.3 ms    10000 runs

Benchmark 1: python3.12 NotTyped.py
  Time (mean ± σ):      19.7 ms ±   1.8 ms    [User: 10.4 ms, System: 2.3 ms]
  Range (min … max):    14.9 ms …  35.8 ms    10000 runs

  Warning: Statistical outliers were detected. Consider re-running this benchmark on a quiet system without any interferences from other programs. It might help to use the '--warmup' or '--prepare' options.



Em suma, a minha questão é a seguinte:
O Codigo Tipado traria alguma diferença em performance comparado com o Codigo Não Tipado?

  • Vote 1

Mas façam o que fizerem nunca façam:

sudo apt remove python

 

Posted

A minha resposta é:

1.se o problema é velocidade de execução não será em Type Hinting que vai fazer diferença, o problema estará quase sempre entre o ecrã e a cadeira.

2. se velocidade de execução é o problema a solução é mudar para linguagens compiladas C (e variaveis), Rust, Assembly.

3. sem ter a certeza se correres a partir de um ficheiro em principio o impacto é praticamente 0 pq o python primeiro compila para bytecode e ignora o texto (aka Type Hints não são compiladas), se correres no interpretador diretamente ai acredito que possa ser notável comparado a correr a partir de um ficheiro, mas novamente será quase 0.
4. se quiseres usar type hints para fazeres o teu código correr mais devagar é usares as antigas versões de type  hint em que se usava strings, mas só irá afetar a compilação para bytecode, pq novamente as type hints não são compiladas.

Versão antiga de type hints:
 

def add(a: "int", b: "int") -> "int":
    result: int = a + b
    return result

def getInput() -> "int":
    randomValue: int = randint(0, 1000)
    return randomValue

 

O importante é o código legível, é por isso que é usado.  se fosse por causa de velocidade (ler 2.)

Posted

Pelo que compreendo do type hint não tem como objetivo ajudar na execução mas sim ajudar na verficiação estática e na dcoumentação, o que ajuda os IDEs a ajudarem-nos e potencia a resolução de bugs.

Ou seja, o type hint é isso mesmo: uma dica, nada mais.

10 REM Generation 48K!
20 INPUT "URL:", A$
30 IF A$(1 TO 4) = "HTTP" THEN PRINT "400 Bad Request": GOTO 50
40 PRINT "404 Not Found"
50 PRINT "./M6 @ Portugal a Programar."

 

Posted
Em 16/10/2024 às 09:30, M6 disse:

Pelo que compreendo do type hint não tem como objetivo ajudar na execução mas sim ajudar na verficiação estática e na dcoumentação, o que ajuda os IDEs a ajudarem-nos e potencia a resolução de bugs.

Ou seja, o type hint é isso mesmo: uma dica, nada mais.

Sim, os type hints são mesmo "só" para os IDEs, exemplo disso é este pedaço de código, que os os types hints são autenticos monstros os IDEs vão se queixar, mas em run time, nada acontece:
 

def add(a: Tuple[Self,...], b: Callable[[Dict[Any, Any]], IO ]) -> NoReturn:
    result: int = a + b
    return result

print(add("Hello", "World"))

>>> HelloWorld

O interpretador de python não faz type checks.

Como referi a acima, ""só" para os IDEs", existem pacotes/ferramentas que fazem hard type checks (mypy , pydantic), mas nunca  funcionei com elas, mas sei que dá para fazer impedir correr código se não cumprir type checks.

 

Nota: antes da introdução dos PEP-484 PEP-3107 os type hints eram feitos directamente nas docstrings (algo ainda aceite, mas cada vez mais raro de se ver):


def add(a ,b):
    """
    :type a: int
    :type b: int
    :rtype: int
    """
    result: int = a + b
    return result
  • 8 months later...
Posted

Penso que as diferenças no tempo de execução são negligenciáveis. Os benefícios são mesmo: 

1. Uma melhor compreensão por parte de quem está a ler o código.
2. Melhor experiencia para o programador, devido às ajudas do IDE.
3. Detenção de erros o mais cedo possível, por meio de ferramentas como o `mypy`, quando os tipos não batem certo.

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.