```Python hl_lines="6"
{!../../docs_src/first_steps/tutorial001.py!}
```

`@app.get("/")` dekoratörü, **FastAPI**'a hemen altındaki fonksiyonun aşağıdaki durumlardan sorumlu olduğunu söyler:

* <abbr title="Bir HTTP GET metodu"><code>get</code> operasyonu</abbr> ile
* `/` yoluna gelen istekler

/// info | "`@decorator` Bilgisi"

Python'da `@something` sözdizimi "<abbr title="Decorator">dekoratör</abbr>" olarak adlandırılır.

            // now get the 'public method', the method declared by a
            // public interface or class (because the actual implementing
            // class may be a facade...)

            Method publicMethod = getPublicMethod(method);

            // it is entirely possible that there is no public method for
            // the methods of this class (i.e. in the facade, a method

    Method[] methods = getMostConcreteMethods(interfaceType);
    AccessibleObject.setAccessible(methods, true);
    for (Method method : methods) {
      // Interfaces can have default methods that aren't abstract.
      // No need to verify them.
      // Can't check isDefault() for Android compatibility.
      if (!Modifier.isAbstract(method.getModifiers())) {
        continue;
      }

"Operacje" tutaj odnoszą się do jednej z "metod" HTTP.

Jedna z:

* `POST`
* `GET`
* `PUT`
* `DELETE`

...i te bardziej egzotyczne:

* `OPTIONS`
* `HEAD`
* `PATCH`
* `TRACE`

W protokole HTTP można komunikować się z każdą ścieżką za pomocą jednej (lub więcej) "metod".

---

Podczas tworzenia API zwykle używasz tych metod HTTP do wykonania określonej akcji.

pkg go/types, method (*Interface) EmbeddedTypes() iter.Seq[Type] #66626
pkg go/types, method (*Interface) ExplicitMethods() iter.Seq[*Func] #66626
pkg go/types, method (*Interface) Methods() iter.Seq[*Func] #66626
pkg go/types, method (*MethodSet) Methods() iter.Seq[*Selection] #66626
pkg go/types, method (*Named) Methods() iter.Seq[*Func] #66626
pkg go/types, method (*Scope) Children() iter.Seq[*Scope] #66626
pkg go/types, method (*Struct) Fields() iter.Seq[*Var] #66626

   */
  @CanIgnoreReturnValue
  public B suppressing(Method... methods) {
    return suppressing(asList(methods));
  }

  @CanIgnoreReturnValue
  public B suppressing(Collection<Method> methods) {
    suppressedTests.addAll(methods);
    return self();
  }

  public Set<Method> getSuppressedTests() {
    return suppressedTests;
  }

      </replaceConfiguration>

 * provided {@code standardAddAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingList}.
 *
 * <p>The {@code standard} methods and any collection views they return are not guaranteed to be

     */
    private static LinkedList<Method> getApplicables(List<Method> methods, Class<?>... classes) {
        LinkedList<Method> list = new LinkedList<>();

        for (Method method : methods) {
            if (isApplicable(method, classes)) {
                list.add(method);
            }
        }
        return list;
    }

    /**

  public static TestSuite suite() {
    TestSuite suite = new TestSuite();

    Method[] methods = Monitor.class.getMethods();
    sortMethods(methods);
    for (Method method : methods) {
      if (isAnyEnter(method) || isWaitFor(method)) {
        validateMethod(method);
        addTests(suite, method);
      }
    }

    assertEquals(980, suite.testCount());

    return suite;
  }