E tem que haver algo responsável por **renovar os certificados HTTPS**, pode ser o mesmo componente ou pode ser algo diferente.

### Ferramentas de exemplo para HTTPS

Algumas das ferramentas que você pode usar como um proxy de terminação TLS são:

* Traefik
    * Lida automaticamente com renovações de certificados ✨
* Caddy

Y debe haber algo encargado de **renovar los certificados HTTPS**, podría ser el mismo componente o algo diferente.

### Herramientas de Ejemplo para HTTPS

Algunas de las herramientas que podrías usar como Proxy de Terminación TLS son:

* Traefik
    * Maneja automáticamente las renovaciones de certificados ✨
* Caddy

{* ../../docs_src/python_types/tutorial002.py hl[1] *}

Isso não é o mesmo que declarar valores padrão como seria com:

```Python
    first_name="john", last_name="doe"
```

É uma coisa diferente.

Estamos usando dois pontos (`:`), não é igual a (`=`).

E adicionar type hints normalmente não muda o que acontece do que aconteceria sem eles.

///

### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a>

**FastAPI** não é uma alternativa para **Requests**. O escopo deles é muito diferente.

Na verdade é comum utilizar Requests *dentro* de uma aplicação FastAPI.

Ainda assim, FastAPI pegou alguma inspiração do Requests.

///

### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a>

**FastAPI** no es en realidad una alternativa a **Requests**. Su ámbito es muy diferente.

De hecho, sería común usar Requests *dentro* de una aplicación FastAPI.

Aun así, FastAPI se inspiró bastante en Requests.

À ne pas confondre avec la déclaration de valeurs par défaut comme ici :

```Python
    first_name="john", last_name="doe"
```

C'est une chose différente.

On utilise un deux-points (`:`), et pas un égal (`=`).

Et ajouter des annotations de types ne crée normalement pas de différence avec le comportement qui aurait eu lieu si elles n'étaient pas là.

La **concurrence** et le **parallélisme** sont tous deux liés à l'idée de "différentes choses arrivant plus ou moins au même moment".

Mais les détails entre la **concurrence** et le **parallélisme** diffèrent sur de nombreux points.

Pour expliquer la différence, voici une histoire de burgers :

#### Burgers concurrents

   * }
   */
  @Override
  int hashCode();

  /**
   * A difference between the mappings from two maps with the same key. The {@link #leftValue} and
   * {@link #rightValue} are not equal, and one but not both of them may be null.
   *
   * @since 2.0
   */
  @DoNotMock("Use Maps.difference")
  interface ValueDifference<V extends @Nullable Object> {

						</difference>
						<difference>
							<className>jcifs/Configuration</className>
							<differenceType>7012</differenceType>
							<method>java.lang.String getGuestPassword()</method>
						</difference>
						<difference>
							<className>jcifs/SmbResource</className>
							<differenceType>7012</differenceType>
							<method>void setFileTimes(long, long, long)</method>
						</difference>
					</ignored>

import com.google.common.collect.Sets;
import java.util.Map;
import java.util.Random;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests that the different algorithms benchmarked in {@link QuantilesBenchmark} are actually all
 * returning more-or-less the same answers.
 */
@NullUnmarked
public class QuantilesAlgorithmTest extends TestCase {