```

////

This means:

* The variable `prices` is a `dict`:
    * The keys of this `dict` are of type `str` (let's say, the name of each item).
    * The values of this `dict` are of type `float` (let's say, the price of each item).

#### Union { #union }

You can declare that a variable can be any of **several types**, for example, an `int` or a `str`.

<img src="/img/deployment/concepts/process-ram.drawio.svg">

Und natürlich würden auf derselben Maschine neben Ihrer Anwendung wahrscheinlich auch **andere Prozesse** laufen.

Ein interessantes Detail ist dabei, dass der Prozentsatz der von jedem Prozess verwendeten **CPU** im Laufe der Zeit stark **variieren** kann, der **Arbeitsspeicher (RAM)** jedoch normalerweise mehr oder weniger **stabil** bleibt.

      // `entries`. The `oldNext` loop is going to traverse that linked list.
      // We need to rewrite the `next` link of each of the elements so that it is in the appropriate
      // linked list starting from `newTable`. In general, each element from the old linked list
      // belongs to a different linked list from `newTable`. We insert each element in turn at the
      // head of its appropriate `newTable` linked list.
      while (oldNext != UNSET) {

        </field>
      </fields>
    </class>
    <class java.clone="deep">
      <name>ActivationOS</name>
      <version>1.0.0+</version>
      <description>
        This is an activator which will detect an operating system's attributes in order to activate
        its profile.
      </description>
      <fields>
        <field>
          <name>name</name>
          <version>1.0.0+</version>

page.user.max.fetch.size=1000
# Maximum number of role records to fetch per page.
page.role.max.fetch.size=1000
# Maximum number of group records to fetch per page.
page.group.max.fetch.size=1000
# Maximum number of crawling info parameters to fetch per page.
page.crawling.info.param.max.fetch.size=100
# Maximum number of crawling info records to fetch per page.
page.crawling.info.max.fetch.size=1000

   * the discussion in the {@link #addListener} documentation. All its warnings about heavyweight
   * listeners are also applicable to heavyweight callbacks passed to this method.
   *
   * <p>For a more general interface to attach a completion listener, see {@link #addListener}.
   *
   * <p>This method is similar to {@link java.util.concurrent.CompletableFuture#whenComplete} and

                        }

                        if (resolved == null) {
                            // TODO add better exception that can detail the two conflicting artifacts
                            ArtifactResolutionException are = new ArtifactResolutionException(
                                    "Cannot resolve artifact version conflict between "

Então, quando você digita `python` no terminal, o sistema encontrará o programa Python em

```plaintext
C:\Users\user\code\awesome-project\.venv\Scripts\python
```

e usa esse.

////

The solution to the problems of having all the packages in the global environment is to use a **virtual environment for each project** you work on.

A virtual environment is a **directory**, very similar to the global one, where you can install the packages for a project.

This way, each project will have its own virtual environment (`.venv` directory) with its own packages.

```mermaid
flowchart TB

<img src="/img/deployment/concepts/process-ram.drawio.svg">

E, claro, a mesma máquina provavelmente teria **outros processos** em execução, além do seu aplicativo.

Um detalhe interessante é que a porcentagem da **CPU usada** por cada processo pode **variar** muito ao longo do tempo, mas a **memória (RAM)** normalmente fica mais ou menos **estável**.