* Der Prozess kann von Ihnen oder vom Betriebssystem **terminiert** („beendet“, „gekillt“) werden. An diesem Punkt hört es auf zu laufen/ausgeführt zu werden und kann **keine Dinge mehr tun**.
* Hinter jeder Anwendung, die Sie auf Ihrem Computer ausführen, steckt ein Prozess, jedes laufende Programm, jedes Fenster usw. Und normalerweise laufen viele Prozesse **gleichzeitig**, während ein Computer eingeschaltet ist.

Diese Daten werden jeden Monat berechnet, Sie können den <a href="https://github.com/tiangolo/fastapi/blob/master/.github/actions/people/app/main.py" class="external-link" target="_blank">Quellcode hier lesen</a>.

Hier weise ich auch auf Beiträge von Sponsoren hin.

                           &shape_info));
  auto iter = shape_info.find("sink");
  EXPECT_NE(iter, shape_info.end());
  EXPECT_EQ(iter->second.size(), 1);
  EXPECT_EQ(iter->second.at(0).handle_type, DT_FLOAT);
  TensorShape resource_shape;
  EXPECT_TRUE(iter->second.at(0).handle_shape.AsTensorShape(&resource_shape));
  EXPECT_EQ(resource_shape, TensorShape({2, 3}));
}

            Currency.FRANC, Country.SWITZERLAND);
    EnumBiMap<Currency, Country> bimap = EnumBiMap.create(map);

    Iterator<Currency> iter = bimap.keySet().iterator();
    assertEquals(Currency.DOLLAR, iter.next());
    assertEquals(Currency.FRANC, iter.next());
    iter.remove();

    // forward map ordered by currency
    assertThat(bimap.keySet()).containsExactly(Currency.DOLLAR, Currency.PESO).inOrder();

  std::set<std::string> seen_request_inputs;

  for (const auto& [alias, tensor_info] : signature.inputs()) {
    const std::string& feed_name = tensor_info.name();
    auto iter = request_inputs.find(alias);

    if (iter == request_inputs.end()) {
      auto default_inputs_iter = signature.defaults().find(alias);
      if (default_inputs_iter == signature.defaults().end()) {

<!-- see ../../3-iter.md -->...

}

XlaDevice::~XlaDevice() {
  VLOG(1) << "Destroying XLA device " << jit_device_name_ << " " << this;
  mutex_lock lock(mu_);
  for (const auto& iter : device_contexts_) {
    iter->Unref();
  }
}

absl::StatusOr<xla::LocalClient*> XlaDevice::GetOrCreateClient() const {
  // We lazily create the client because the platform commits to the

    VLOG(1) << "Failed to create XLA_GPU device: " << platform.status();
    return absl::OkStatus();
  }

  auto iter = session_options.config.device_count().find("GPU");
  if (iter != session_options.config.device_count().end() &&
      iter->second == 0) {
    // Device count for GPU is 0.
    return absl::OkStatus();
  }

  string allowed_gpus =

# `APIRouter`-Klasse

Hier sind die Referenzinformationen für die Klasse `APIRouter` mit all ihren Parametern, Attributen und Methoden.

Sie können die `APIRouter`-Klasse direkt von `fastapi` importieren:

```python
from fastapi import APIRouter
```

::: fastapi.APIRouter
    options:
        members:
            - websocket
            - include_router
            - get
            - put
            - post
            - delete

	c.ClientBuilder = TestingBuildClientsFromConfig
	client.RunAndWait(stopCh)
	secrets := clienttest.NewWriter[*v1.Secret](t, client)
	iter := 0
	component := BuildMultiClusterComponent(c, func(cluster *Cluster) testHandler {
		iter++
		return testHandler{
			ID:     cluster.ID,
			Iter:   iter,
			Closed: atomic.NewBool(false),
			Synced: atomic.NewBool(false),
		}
	})
	client.RunAndWait(stopCh)