Python Veri Tiplerine Giriş¶

Python isteğe bağlı olarak "tip belirteçlerini" destekler.

"Tip belirteçleri" bir değişkenin tipinin belirtilmesine olanak sağlayan özel bir sözdizimidir.

Değişkenlerin tiplerini belirterek editör ve araçlardan daha fazla destek alabilirsiniz.

Bu pythonda tip belirteçleri için hızlı bir başlangıç / bilgi tazeleme rehberidir . Bu rehber FastAPI kullanmak için gereken minimum konuyu kapsar ki bu da çok az bir miktardır.

FastAPI' nin tamamı bu tür tip belirteçleri ile donatılmıştır ve birçok avantaj sağlamaktadır.

FastAPI kullanmayacak olsanız bile tür belirteçleri hakkında bilgi edinmenizde fayda var.

Not

Python uzmanıysanız ve tip belirteçleri ilgili her şeyi zaten biliyorsanız, sonraki bölüme geçin.

Motivasyon¶

Basit bir örnek ile başlayalım:

def get_full_name(first_name, last_name):
    full_name = first_name.title() + " " + last_name.title()
    return full_name


print(get_full_name("john", "doe"))

Programın çıktısı:

John Doe

Fonksiyon sırayla şunları yapar:

first_name ve last_name değerlerini alır.
title() ile değişkenlerin ilk karakterlerini büyütür.
Değişkenleri aralarında bir boşlukla beraber Birleştirir.

def get_full_name(first_name, last_name):
    full_name = first_name.title() + " " + last_name.title()
    return full_name


print(get_full_name("john", "doe"))

Düzenle¶

Bu çok basit bir program.

Ama şimdi sıfırdan yazdığınızı hayal edin.

Bir noktada fonksiyonun tanımına başlayacaktınız, parametreleri hazır hale getirdiniz...

Ama sonra "ilk harfi büyük harfe dönüştüren yöntemi" çağırmanız gerekir.

upper mıydı ? Yoksa uppercase' mi? first_uppercase? capitalize?

Ardından, programcıların en iyi arkadaşı olan otomatik tamamlama ile denediniz.

'first_name', ardından bir nokta ('.') yazıp otomatik tamamlamayı tetiklemek için 'Ctrl+Space' tuşlarına bastınız.

Ancak, ne yazık ki, yararlı hiçbir şey elde edemediniz:

Tipleri ekle¶

Önceki sürümden sadece bir satırı değiştirelim.

Tam olarak bu parçayı, işlevin parametrelerini değiştireceğiz:

    first_name, last_name

ve bu hale getireceğiz:

    first_name: str, last_name: str

Bu kadar.

İşte bunlar "tip belirteçleri":

def get_full_name(first_name: str, last_name: str):
    full_name = first_name.title() + " " + last_name.title()
    return full_name


print(get_full_name("john", "doe"))

Bu, aşağıdaki gibi varsayılan değerleri bildirmekle aynı şey değildir:

    first_name="john", last_name="doe"

Bu tamamen farklı birşey

İki nokta üst üste (:) kullanıyoruz , eşittir (=) değil.

Normalde tip belirteçleri eklemek, kod üzerinde olacakları değiştirmez.

Şimdi programı sıfırdan birdaha yazdığınızı hayal edin.

Aynı noktada, Ctrl+Space ile otomatik tamamlamayı tetiklediniz ve şunu görüyorsunuz:

Aradığınızı bulana kadar seçenekleri kaydırabilirsiniz:

Daha fazla motivasyon¶

Bu fonksiyon, zaten tür belirteçlerine sahip:

def get_name_with_age(name: str, age: int):
    name_with_age = name + " is this old: " + age
    return name_with_age

Editör değişkenlerin tiplerini bildiğinden, yalnızca otomatik tamamlama değil, hata kontrolleri de sağlar:

Artık age değişkenini str(age) olarak kullanmanız gerektiğini biliyorsunuz:

def get_name_with_age(name: str, age: int):
    name_with_age = name + " is this old: " + str(age)
    return name_with_age

Tip bildirme¶

Az önce tip belirteçlerinin en çok kullanıldığı yeri gördünüz.

FastAPIile çalışırken tip belirteçlerini en çok kullanacağımız yer yine fonksiyonlardır.

Basit tipler¶

Yalnızca str değil, tüm standart Python tiplerinin bildirebilirsiniz.

Örneğin şunları kullanabilirsiniz:

int
float
bool
bytes

def get_items(item_a: str, item_b: int, item_c: float, item_d: bool, item_e: bytes):
    return item_a, item_b, item_c, item_d, item_d, item_e

Tip parametreleri ile Generic tipler¶

"dict", "list", "set" ve "tuple" gibi diğer değerleri içerebilen bazı veri yapıları vardır. Ve dahili değerlerinin de tip belirtecleri olabilir.

Bu tipleri ve dahili tpileri bildirmek için standart Python modülünü "typing" kullanabilirsiniz.

Bu tür tip belirteçlerini desteklemek için özel olarak mevcuttur.

`List`¶

Örneğin str değerlerden oluşan bir list tanımlayalım.

From typing, import List (büyük harf olan L ile):

from typing import List


def process_items(items: List[str]):
    for item in items:
        print(item)

Değişkenin tipini yine iki nokta üstüste (:) ile belirleyin.

tip olarak List kullanın.

Liste, bazı dahili tipleri içeren bir tür olduğundan, bunları köşeli parantez içine alırsınız:

from typing import List


def process_items(items: List[str]):
    for item in items:
        print(item)

Ipucu

Köşeli parantez içindeki bu dahili tiplere "tip parametreleri" denir.

Bu durumda str, Liste iletilen tür parametresidir.

Bunun anlamı şudur: "items değişkeni bir listtir ve bu listedeki öğelerin her biri bir strdir".

Bunu yaparak, düzenleyicinizin listedeki öğeleri işlerken bile destek sağlamasını sağlayabilirsiniz:

Tip belirteçleri olmadan, bunu başarmak neredeyse imkansızdır.

item değişkeninin items listesindeki öğelerden biri olduğuna dikkat edin.

Ve yine, editör bunun bir str olduğunu biliyor ve bunun için destek sağlıyor.

`Tuple` ve `Set`¶

Tuple ve setlerin tiplerini bildirmek için de aynısını yapıyoruz:

from typing import Set, Tuple


def process_items(items_t: Tuple[int, int, str], items_s: Set[bytes]):
    return items_t, items_s

Bu şu anlama geliyor:

items_t değişkeni sırasıyla int, int, ve str tiplerinden oluşan bir tuple türündedir .
items_s ise her öğesi bytes türünde olan bir set örneğidir.

`Dict`¶

Bir dict tanımlamak için virgülle ayrılmış iki parametre verebilirsiniz.

İlk tip parametresi dict değerinin key değeri içindir.

İkinci parametre ise dict değerinin value değeri içindir:

from typing import Dict


def process_items(prices: Dict[str, float]):
    for item_name, item_price in prices.items():
        print(item_name)
        print(item_price)

Bu şu anlama gelir:

prices değişkeni dict tipindedir:
- dict değişkeninin key değeri str tipindedir (herbir item'ın "name" değeri).
- dict değişkeninin value değeri float tipindedir (lherbir item'ın "price" değeri).

`Optional`¶

Optional bir değişkenin strgibi bir tipi olabileceğini ama isteğe bağlı olarak tipinin None olabileceğini belirtir:

from typing import Optional


def say_hi(name: Optional[str] = None):
    if name is not None:
        print(f"Hey {name}!")
    else:
        print("Hello World")

str yerine Optional[str] kullanmak editorün bu değerin her zaman str tipinde değil bazen None tipinde de olabileceğini belirtir ve hataları tespit etmemizde yardımcı olur.

Generic tipler¶

Köşeli parantez içinde tip parametreleri alan bu türler, örneğin:

List
Tuple
Set
Dict
Optional
...and others.

Generic types yada Generics olarak adlandırılır.

Tip olarak Sınıflar¶

Bir değişkenin tipini bir sınıf ile bildirebilirsiniz.

Diyelim ki name değerine sahip Person sınıfınız var:

class Person:
    def __init__(self, name: str):
        self.name = name


def get_person_name(one_person: Person):
    return one_person.name

Sonra bir değişkeni 'Person' tipinde tanımlayabilirsiniz:

class Person:
    def __init__(self, name: str):
        self.name = name


def get_person_name(one_person: Person):
    return one_person.name

Ve yine bütün editör desteğini alırsınız:

Pydantic modelleri¶

Pydantic veri doğrulaması yapmak için bir Python kütüphanesidir.

Verilerin "biçimini" niteliklere sahip sınıflar olarak düzenlersiniz.

Ve her niteliğin bir türü vardır.

Sınıfın bazı değerlerle bir örneğini oluşturursunuz ve değerleri doğrular, bunları uygun türe dönüştürür ve size tüm verileri içeren bir nesne verir.

Ve ortaya çıkan nesne üzerindeki bütün editör desteğini alırsınız.

Resmi Pydantic dokümanlarından alınmıştır:

from datetime import datetime
from typing import List, Union

from pydantic import BaseModel


class User(BaseModel):
    id: int
    name: str = "John Doe"
    signup_ts: Union[datetime, None] = None
    friends: List[int] = []


external_data = {
    "id": "123",
    "signup_ts": "2017-06-01 12:22",
    "friends": [1, "2", b"3"],
}
user = User(**external_data)
print(user)
# > User id=123 name='John Doe' signup_ts=datetime.datetime(2017, 6, 1, 12, 22) friends=[1, 2, 3]
print(user.id)
# > 123

Info

Daha fazla şey öğrenmek için Pydantic'i takip edin.

FastAPI tamamen Pydantic'e dayanmaktadır.

Daha fazlasini görmek için Tutorial - User Guide.

FastAPI tip belirteçleri¶

FastAPI birkaç şey yapmak için bu tür tip belirteçlerinden faydalanır.

FastAPI ile parametre tiplerini bildirirsiniz ve şunları elde edersiniz:

Editor desteği.
Tip kontrolü.

...ve FastAPI aynı belirteçleri şunlar için de kullanıyor:

Gereksinimleri tanımlama: request path parameters, query parameters, headers, bodies, dependencies, ve benzeri gereksinimlerden
Verileri çevirme: Gönderilen veri tipinden istenilen veri tipine çevirme.
Verileri doğrulama: Her gönderilen verinin:
- doğrulanması ve geçersiz olduğunda otomatik hata oluşturma.
OpenAPI kullanarak apinizi Belgeleyin :
- bu daha sonra otomatik etkileşimli dokümantasyon kullanıcı arayüzü tarafından kullanılır.

Bütün bunlar kulağa soyut gelebilir. Merak etme. Tüm bunları çalışırken göreceksiniz. Tutorial - User Guide.

Önemli olan, standart Python türlerini tek bir yerde kullanarak (daha fazla sınıf, dekoratör vb. eklemek yerine), FastAPI'nin bizim için işi yapmasını sağlamak.