# Refatorando para otimização de desempenho

O Bate-papo do Copilot pode sugerir maneiras de acelerar código com execução lenta.

O código existente pode funcionar corretamente, mas ser ineficiente, levando a gargalos de desempenho. Exemplos de codificação que podem afetar negativamente o desempenho incluem loops ineficientes, cálculos desnecessários e alocação excessiva de memória.

O Bate-papo do Copilot é capaz de identificar gargalos de desempenho e sugerir estratégias de refatoração, como otimizar estruturas de dados (por exemplo, usar tabelas de hash em vez de matrizes), reduzir cálculos redundantes e melhorar a eficiência dos algoritmos. Ele também pode recomendar mecanismos de cache ou paralelização de operações para aprimorar o desempenho.

## Cenário de exemplo

O código Python a seguir imprime cada 1.000º número primo até o 10.000º primo. Ele inclui um temporizador e imprime quanto tempo o código leva para ser executado como a última linha da saída. O programa leva vários segundos para ser concluído.

```python id=slow-prime
import time

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

def every_1000th_prime():
    primes = []
    num = 2
    while len(primes) < 10000:
        if is_prime(num):
            primes.append(num)
        num += 1
    return [primes[i] for i in range(999, 10000, 1000)]

if __name__ == "__main__":
    start_time = time.time()
    primes = every_1000th_prime()
    for prime in primes:
        print(prime)
    end_time = time.time()
    elapsed_time = end_time - start_time
    print(f"Time taken: {elapsed_time:.10f} seconds")
```

## Solicitação de exemplo

```copilot copy prompt ref=slow-prime
Optimize this code for performance
```

## Exemplo de resposta

O Copilot sugere usar uma função de crivo para gerar os números primos de forma muito mais eficiente. Se você executar este programa, ele será concluído em uma fração de segundo.

> \[!NOTE] Respostas do Bate-papo do Copilot são não determinísticas, portanto, você pode obter uma resposta diferente da mostrada aqui.

```python
import time

def sieve_of_eratosthenes(limit):
    sieve = [True] * (limit + 1)
    sieve[0] = sieve[1] = False
    for start in range(2, int(limit**0.5) + 1):
        if sieve[start]:
            for multiple in range(start*start, limit + 1, start):
                sieve[multiple] = False
    return [num for num, is_prime in enumerate(sieve) if is_prime]

def every_1000th_prime():
    limit = 105000  # Higher than needed to ensure 10,000 primes
    primes = sieve_of_eratosthenes(limit)
    return [primes[i] for i in range(999, 10000, 1000)]

if __name__ == "__main__":
    start_time = time.time()
    primes = every_1000th_prime()
    for prime in primes:
        print(prime)
    end_time = time.time()
    elapsed_time = end_time - start_time
    print(f"Time taken: {elapsed_time:.10f} seconds")
```

## Leitura adicional

* [Engenharia de prompts para o GitHub Copilot Chat](/pt/copilot/using-github-copilot/prompt-engineering-for-github-copilot)
* [Práticas recomendadas para usar GitHub Copilot](/pt/copilot/using-github-copilot/best-practices-for-using-github-copilot)