Python Kullanıcı Girdisi: İşleme, Doğrulama ve En İyi Uygulamalar

Kullanıcı girdisi, etkileşimli Python programlamanın temel taşlarından biridir. Kullanıcıdan ad istemek gibi basit betiklerden yapılandırılmış veri girdisine dayanan karmaşık sistemlere kadar, kullanıcı bilgisi toplama ve işleme becerisi esastır. Programlarınızın yalnızca kendi başına çalışmanın ötesine geçmesini istiyorsanız, girdi işlemede ustalaşmak şarttır.

Bu rehberde, Python'da kullanıcı girdisini ele almanın temel kavram ve tekniklerini adım adım anlatacağım. Bu makale, ister yeni başlıyor olun ister daha sağlam girdi stratejileriyle becerilerinizi derinleştirmek isteyin, özellikle başlangıç ve orta seviye Python programcıları için hazırlandı.

Hedef, projelerinize hemen uygulayabileceğiniz pratik, gerçek dünya odaklı bir yol haritası sunmaktır. Birlikte, input fonksiyonunun temellerinden güvenli girdi, doğrulama çatıları ve hatta yapay zekâ destekli yaklaşımlar gibi ileri konulara kadar her şeyi keşfedeceğiz. Bunu, yalnızca çalışan değil, kullanıcılarla da iyi çalışan Python programları geliştirmeniz için adım adım bir eşlikçi olarak düşünün.

Python'a yeniyseniz, Python Programlama Temelleri yetkinlik yolumuzu veya Python'da Veri İçe Aktarmaya Giriş kursumuzu değerlendirebilirsiniz.

Python Girdi İşlemenin Temel Kavramları

Daha gelişmiş tekniklere geçmeden önce temelleri sağlamlaştıralım. Python'un kullanıcı girdisini çekirdeğinde nasıl ele aldığını anlamak, kullanıcıların yazdıklarına akıllıca yanıt veren programlar geliştirmek istiyorsanız kritik önemdedir. 

Bu bölümde, her Python programcısının araç setinde bulunması gereken temel araç ve kalıpları anlatacağım.

input() fonksiyonu: Söz dizimi ve temel kullanım

Python'da kullanıcı girdisinin temel taşı olan input() fonksiyonu ile başlayalım. Bu yerleşik fonksiyon programınızı duraklatır, kullanıcının konsola bir şey yazmasını ve Enter'a basmasını bekler. Son derece basit ama bir o kadar da güçlüdür. İşleyişine hızlı bir örnek:

# Basic usage of input()
name = input("Enter your name: ")
print(f"Hello, {name}!")

Enter your name: Benito
Hello, Benito!

Bu parçada, Enter your name:  kullanıcıya gösterilen istemdir; kullanıcı yazmadan önce bunu görür. Daima açık ve açıklayıcı istemler vermeyi öneririm. Küçük bir ayrıntı gibi görünse de programınızın ne kadar sezgisel ve kullanıcı dostu hissettirdiğinde büyük fark yaratabilir.

Python'da Metin Verisi kopya kâğıdımızda da ele aldığımız gibi, hatırlanması gereken önemli nokta input() fonksiyonunun veriyi her zaman string olarak döndürmesidir. Yani kullanıcı bir sayı yazsa bile, Python bunu metin olarak ele alır:

# Input class type
age = input("Enter your age: ")
print(type(age))  

Enter your age: 25
<class 'str'>

Bu varsayılan davranış, bizi bir sonraki kritik konuya getiriyor: girdiyi sonraki kullanım için doğru veri tipine dönüştürmek.

Tip dönüştürme stratejileri

Gerçek dünya uygulamalarının çoğunda yalnızca metin yetmez. Sayılar, boolean'lar veya başka türde yapılandırılmış girdiler gerekir. İşte tip dönüştürme burada devreye girer. 

Kullanıcı girdisi üzerinde aritmetik yapmak istiyorsam, onu int() veya float() gibi fonksiyonlarla string'ten sayısal türe dönüştürmem gerekir.

# Type conversion
num1 = input("Enter a number: ")
num2 = input("Enter another number: ")
result = int(num1) + int(num2)
print(f"The sum is: {result}")

Enter a number: 25
Enter another number: 30
The sum is: 55

Kullanıcı geçerli sayılar girdiği sürece bu gayet iyi çalışır. Peki ya 10 yerine ten yazarsam ne olur? Python bir ValueError yükseltir ve doğru ele alınmazsa programı çökertir.

Daha dayanıklı kod yazmak için, kullanıcı girdisini dönüştürürken try ve except blokları kullanmak iyi bir pratiktir:

# Error handling
try:
    age = int(input("Enter your age: "))
    print(f"Next year, you'll be {age + 1}.")
except ValueError:
    print("Please enter a valid number.")

Enter your age: ten
Please enter a valid number.

Bu yaklaşım, beklenmedik girdiler yüzünden programın bozulmasını engeller. Ayrıca kullanıcılara hatalarını düzeltme şansı verir; küçük bir ekleme olsa da kodunuzu belirgin şekilde daha kullanıcı dostu yapar.

Girdi Doğrulama ve Temizleme Teknikleri

Girdiyi yakalamayı ve kullanılabilir veriye dönüştürmeyi öğrendikten sonra, sıradaki önemli adım girdinin geçerli olduğundan emin olmaktır. Uygun kontroller olmadan kullanıcı girdisini kabul etmek hatalara, veri bozulmasına hatta güvenlik açıklarına yol açabilir. Bu bölümde, programlarınızın sağlam ve güvenli kalması için girdiyi nasıl doğrulayıp temizleyeceğinizi anlatacağım.

Yapısal doğrulama kalıpları

Girdi doğrulama, veri bütünlüğünü korumak için gereklidir. Bir program kullanıcı girdisi istediğinde, kullanıcının talimatlara uyacağının garantisi yoktur. Sayı beklenen yere harf girebilir veya alanları tamamen boş bırakabilir. Bu nedenle, kullanmadan önce kullanıcı girdisini doğrulamak kritik bir adımdır.

Doğrulama için başvurabileceğiniz birkaç yaygın strateji vardır:

• Tip kontrolü: Verinin doğru tipte olduğundan emin olmak; örneğin girdiyi int veya float'a dönüştürmek ve dönüşüm başarısız olursa istisnaları yakalamak.
• Aralık doğrulaması: Bir sayının tanımlı bir aralıkta olduğunu doğrulamak. Örneğin, yaşın 0 ile 120 arasında olduğundan emin olmak.
• Biçim uyumu: String'lerin belirli biçimlerle eşleştiğini sağlamak. Tipik bir kullanım alanı, düzenli ifadelerle e-posta adresleri veya telefon numaralarını doğrulamaktır.
• İçerik temizleme: HTML etiketlerini kaldırmak veya tampon taşmaları ve enjeksiyon saldırılarını önlemek için girdi uzunluğunu sınırlamak gibi zarar verebilecek karakterleri kaldırmak veya kaçırmak.

İşte bir kullanıcının yaşının sayı olup makul bir aralıkta olduğunu kontrol eden bir örnek:

# Range validation
try:
    age = int(input("Enter your age: "))
    if 0 <= age <= 120:
        print("Valid age entered.")
    else:
        print("Age must be between 0 and 120.")
except ValueError:
    print("Please enter a valid number.")

Enter your age: 150
Age must be between 0 and 120.

Bu basit doğrulama mantığı, hatalı verilerin sızmasını engeller ve net, eyleme dönük hata mesajları sunarak kullanıcının girdisini düzeltmesine yardımcı olur. İyi geri bildirim yalnızca kullanıcı deneyimini iyileştirmekle kalmaz, programı kullanmayı daha sezgisel hâle getirir.

İstisna yakalama çatıları

try ve except bloklarının hatalı girdiler nedeniyle programınızın çökmesini nasıl engellediğini gösterdim. Ancak daha karmaşık girdi senaryolarıyla uğraşmaya başladığınızda temel hata yönetimi yeterli olmayabilir. İşte katmanlı istisna yakalama burada devreye girer.

İç içe try blokları kullanmak veya özel istisnalar tanımlamak, daha temiz ve bilgilendirici kullanıcı etkileşimleri sağlar. İşte tip ve aralık kontrollerini iç içe istisna yakalamayla birleştiren daha gelişmiş bir örnek:

# Nested exception handling
try:
    value = input("Enter a number between 1 and 10: ")
    try:
        number = int(value)
        if 1 <= number <= 10:
            print("Thanks, that is a valid number.")
        else:
            raise ValueError("Number out of range.")
    except ValueError as inner_error:
        print(f"Invalid input: {inner_error}")
except Exception as outer_error:
    print(f"Unexpected error: {outer_error}")

Enter a number between 1 and 10: 15
Invalid input: Number out of range.

Enter a number between 1 and 10: fifteen
Invalid input: invalid literal for int() with base 10: 'fifteen'

Bu durumda, özel Number out of range. hata mesajı yalnızca girdi sayısal olup beklenen sınırların dışına çıktığında gösterilir. Bu tür ayrıntılı geri bildirim, daha etkileşimli programlarda oldukça kullanışlıdır.

Doğrulama mantığıyla istisna yakalamayı düşünceli bir şekilde birleştirerek uygulamaları daha dayanıklı ve kullanıcı dostu hâle getirebilirsiniz. Bu aynı zamanda ileride daha gelişmiş girdi akışlarını ele almak için temel oluşturur.

İleri Düzey Python Girdi Yöntemleri

Temel girdi işleme ve doğrulamayı öğrendikten sonra bir sonraki adım, daha karmaşık girdi senaryolarını yönetmeyi öğrenmektir. Komut satırı aracı ya da veri giriş uygulaması geliştiriyor olun, kimi zaman birden çok satırlı girdiyi desteklemeniz veya hassas verileri güvenle işlemeniz gerekir.

Çok satırlı girdi işleme

Deneyimlerime göre çoğu zaman tek satırlık girdi yeterlidir. Ancak bazı durumlarda kullanıcının birden fazla satır metin girmesine izin vermek isteyebilirsiniz. Bu, not alma uygulamalarında, geri bildirim formlarında ya da kod veya markdown gibi yapılandırılmış metin kabul ederken karşınıza çıkar.

Python'da çok satırlı girdiyi yakalamanın birkaç yolu vardır. En yalın yaklaşımlardan biri, belirli bir koşul sağlanana kadar input() fonksiyonunu tekrarlamaktır. Yaygın bir kalıp, girdinin sonunu belirtmek için boş bir satırı (hiçbir şey yazmadan Enter'a basmak) kullanmaktır:

# Capturing multiline input
print("Enter your text (press Enter twice to finish):")
lines = []
while True:
    line = input()
    if line == "":
        break
    lines.append(line)

text = "\n".join(lines)
print("You entered:")
print(text)

Enter your text (press Enter twice to finish):
Good
Morning!

You entered:
Good
Morning!

Bu yöntem, kullanıcının ne kadar girdi vereceği üzerinde kontrol sağlar ve pek çok kullanım durumu için yeterince esnektir. 

Güvenli girdi işleme

Bazı durumlarda istediğiniz bilgiler hassastır. Parolalar, kişisel bilgiler veya API anahtarları, kullanıcı yazarken ekranda görünmemelidir. Bu veriyi açıkça göstermek yalnızca kötü bir kullanıcı deneyimi olmakla kalmaz, güvenlik riski de oluşturabilir.

Bu tür girdileri korumak için Python getpass modülünü sunar. input() gibi çalışır, ancak kullanıcı tarafından yazılan karakterleri gizler:

# Secure input with getpass
from getpass import getpass

password = getpass("Enter your password: ")
print("Password received.")

Enter your password: ··········
Password received.

getpass kullanmak, hassas verileri korumanın basit ama etkili bir yoludur. Kimlik doğrulama yapan, bulut servisleriyle çalışan veya kimlik bilgilerini daha sonra kullanmak üzere saklayan betiklerde özellikle kullanışlıdır.

Çok satırlı girdi ve güvenli istem desteği ekleyerek programlarınız daha gelişmiş etkileşim kalıplarına hazır hâle gelir. Bu özellikler, kullanılabilirliğe ve kullanıcı gizliliğine saygı duyan gerçek dünya uygulamaları oluşturma yolunda küçük ama önemli adımlardır.

Gerçek Dünya Uygulama Kalıpları

Artık girdi işlemenin temellerini anladığınıza göre, sıradaki adım bunları gerçek dünya programlama bağlamlarında uygulamaktır. Bu bölümde, projelerinizle ölçeklenen kalıp ve araçları kullanarak daha gelişmiş ve yeniden kullanılabilir girdi stratejilerini nasıl yapılandıracağınıza bakacağız.

Etkileşimli yapılandırma sihirbazları

Birçok uygulamada, özellikle komut satırı arayüzüne sahip olanlarda veya ilk kurulum rutinlerinde, girdi tek seferlik bir etkileşim değildir. Mantıksal bir sırayla birden fazla veri parçası toplamak için kullanıcıları bir dizi istemle adım adım yönlendirmeniz gerekir. Bu adım adım dizilere genellikle yapılandırma sihirbazları denir.

İyi bir sihirbaz işleri basit ve net tutar. Soruları tek tek sunar ve ileriye geçmeden önce kullanıcıların anlamlı yanıtlar verdiğinden emin olmak için doğrulama mantığı içerir. Örneğin, kullanıcıdan bir yapılandırma türü seçmesini isteyebilir, ardından o yanıta göre seçimine özgü takip seçenekleri sunabilirsiniz.

Bu fikri gösteren basit bir akış:

# Simple configuration wizard
print("Welcome to the setup wizard.")
username = input("Enter a username: ")

while True:
    role = input("Choose a role (admin/user): ").lower()
    if role in ("admin", "user"):
        break
    print("Please enter 'admin' or 'user'.")

print(f"Configuration complete for {username} with role: {role}.")

Welcome to the setup wizard.
Enter a username: Benito
Choose a role (admin/user): admin
Configuration complete for Benito with role: admin.

Bu tür bir yapı, geçersiz yapılandırmaları önlemeye yardımcı olur ve akıcı bir başlangıç deneyimi sağlar.

Veri doğrulama çatıları

Daha karmaşık projelerde, her girdi alanı için doğrulama mantığını elle yazmak zahmetli ve hataya açık hâle gelebilir. Veri doğrulama çatıları burada devreye girer. Bu kütüphaneler, beklenen girdilerinizi bildirimselle tanımlamanıza ve tip zorlaması, kısıt kontrolü ve hata mesajlarını çatıya bırakmanıza izin verir.

Popüler örneklerden biri, özellikle yapılandırılmış kullanıcı girdisiyle iyi çalışan bir veri doğrulama ve ayrıştırma kütüphanesi olan Pydantic'tir. Standart Python sınıfları ve tip ipuçlarıyla girdi modelleri tanımlamanıza olanak tanır ve gelen veriyi otomatik olarak doğrular.

İşte kullanıcının girdisinin doğrulama aralığı içinde olduğu basit bir örnek:

# Pydantic validation
from typing import Annotated
from pydantic import BaseModel, Field, ValidationError

class UserConfig(BaseModel):
    username: str
    age: Annotated[int, Field(strict=True, gt=0, lt=120)]  # greater than 0, less than 120

try:
    user = UserConfig(username="Benito", age=27)
    print(user)
except ValidationError as e:
    print(e)

username='Benito' age=27

Girdi değerleri doğrulama aralığının dışına çıkarsa, çatı bir doğrulama hatası döndürür:

try:
    user = UserConfig(username="Benito", age=150)
    print(user)
except ValidationError as e:
    print(e)

1 validation error for UserConfig
age
  Input should be less than 120 [type=less_than, input_value=150, input_type=int]
    For further information visit https://errors.pydantic.dev/2.11/v/less_than

Bu yaklaşımın avantajları açıktır. Merkezi doğrulama kuralları, daha temiz kod ve kutudan çıktığı gibi ayrıntılı hata mesajları elde edersiniz. Yapılandırılmış kullanıcı girdisiyle çalışan API'ler veya etkileşimli uygulamalar geliştirirken bunu özellikle faydalı buluyorum.

Performans Hususları ve İyileştirme

Gerçek dünya uygulamalarında, özellikle ölçekli çalışanlarda, kullanıcı girdisiyle uğraşırken performans kilit bir konu hâline gelir. Verimli girdi işleme yalnızca hızı artırmakla kalmaz, kaynak kullanımını da azaltır.

Girdi arabelleğe alma stratejileri

Arabelleğe alınmış girdi, yüksek verimlilik gerektiren uygulamalarda performansı artırmanın temel bir tekniğidir. Dosya veya ağ gibi bir kaynaktan veri okurken, Python okuma işlemlerinin sayısını azaltmak için bir arabellek kullanabilir. Her şeyi satır satır belleğe yüklemek yerine, arabelleğe alınmış girdi veriyi bir defada bir blok olarak okur ve ardından kademeli olarak işler. Bu, büyük ölçekli sistemlerde darboğaz olabilen G/Ç ek yükünü önemli ölçüde azaltır.

İşte bir dosyayı parçalar hâlinde okuyup paragraf paragraf işleyen arabelleğe alınmış girdi örneği:

# Buffered chunk processing 
def process_chunks_paragraphs(filepath, buffer_size=1024):
    with open(filepath, 'r') as file:
        while True:
            chunk = file.read(buffer_size)
            if not chunk:
                break

            parts = chunk.split("\n\n")  # Split paragraphs 

            for paragraph in parts:
                paragraph = paragraph.strip()
                if "exit" in paragraph:
                    return
                print(f"Processed paragraph:\n{paragraph}\n")

process_chunks_paragraphs("input.txt")

Processed paragraph:
Processed the first chunk

Processed paragraph:
Processed the second chunk

Processed paragraph:
Processed the third chunk

Bu yaklaşım, tam dosyayı belleğe yüklemekten kaçınır ve her paragrafı ayrı ayrı işler. Verinin doğal olarak bloklar hâlinde geldiği günlükler, yapılandırılmış raporlar veya dökümler için özellikle kullanışlıdır.

Okuma işlemlerinin sayısını azaltarak arabelleğe alınmış girdi, G/Ç ek yükünü önemli ölçüde düşürür. Bu, yavaş disk erişimi, uzak dosya sistemleri veya akış verileriyle çalışırken özellikle faydalıdır. Daha az okuma, daha az bağlam değişimi ve daha düşük CPU kullanımı anlamına gelir; bu da daha hızlı ve verimli uygulamalara dönüşür. Gigabaytlarca veri işlerken veya gerçek zamanlı sistemleri desteklerken önemli bir husustur.

Bellek verimli işleme

Büyük veya sürekli girdi akışlarıyla çalışırken her şeyi bellekte tutmak verimsiz hatta imkânsız olabilir. Böyle senaryolarda, Python'un jeneratörleri zarif ve verimli bir çözüm sunar.

Jeneratörler, yield anahtar sözcüğünü return yerine kullanan özel fonksiyonlardır. Jeneratör her çağrıldığında dizideki bir sonraki değeri üretir ve bir sonraki değer istenene kadar durumunu duraklatır. Bu, tüm veri kümesi için bellek ayırmadan, öğelerle teker teker çalışmanıza olanak tanır.

İşte done yazarak tamamlanabilen, jeneratör tabanlı girdi işleme örneği:

# Generator for memory-efficient input processing
def read_lines():
    while True:
        line = input()
        if line.lower() == "done":
            break
        yield line

for line in read_lines():
    print(f"Processing: {line}")

hello
Processing: hello
how
Processing: how
are
Processing: are
you?
Processing: you?
done

Bu kalıp, girdi akışları, büyük veri setleri veya etkileşimli oturumlarla uğraşırken özellikle güçlüdür. Her satır okunur, işlenir ve bir sonrakine geçmeden önce atılır; böylece bellek kullanımı en aza indirilir.

Arabelleğe alınmış girdi ve jeneratör tabanlı işlemeyi birleştirerek, performanstan ödün vermeden yoğun girdi yüklerini kaldırabilen, duyarlı ve ölçeklenebilir programlar geliştirebilirsiniz.

Yükselen Eğilimler ve Gelecek Yönelimler

Teknoloji geliştikçe yazılımla etkileşim yollarımız da gelişiyor. Sesli arayüzlerden akıllı doğrulama sistemlerine kadar, modern girdi işleme geleneksel klavye ve farenin ötesine uzanıyor.

Sesle etkinleştirilen girdi sistemleri

Akıllı asistanlar ve eller serbest cihazlar her yerdeyken, Python uygulamalarınıza konuşmayı metne dönüştürme eklemek giderek daha pratik hâle geliyor. speech_recognition, openai-whisper ve Google Speech API gibi servislerle, Python geliştiricileri sesli komutları veya dikte edilmiş girdileri kabul edip bunları sonraki işlem için metne dönüştürebilir.

Bu dönüşüm, kullanıcıların hareket hâlinde ya da eller serbest ortamlarda cihazlarla etkileşime girebileceği Nesnelerin İnterneti (IoT) gibi alanlarda özellikle etkileyicidir. Örneğin, ev otomasyon sistemleri, aydınlatma, termostatlar veya cihazları kontrol etmek için doğal dil komutlarıyla zenginleştirilebilir. Endüstriyel bağlamlarda, sesle kontrol; teknisyenlerin dokunmatik ekran veya klavye kullanmak için duraksamadan makine çalıştırmasına veya verilere erişmesine yardımcı olabilir.

Erişilebilirlik, sesli girdinin derin fark yarattığı bir diğer kritik alandır. Motor engeli olan kullanıcılar için geleneksel girdi yöntemleri zorlayıcı veya tamamen erişilemez olabilir. Sesle etkinleştirilen sistemler, yazılımda gezinme, mesaj yazma veya hatta kod yazma imkânı sağlayarak daha geniş bir kullanıcı kitlesinin teknolojiyle kendi koşullarında etkileşim kurmasını mümkün kılar. Konuşma tanıma doğruluğu geliştikçe ve farklı aksanlar ile konuşma biçimlerini daha kapsayıcı hâle geldikçe, sesle yönlendirilen deneyimlere giriş bariyeri istikrarlı biçimde azalıyor.

Yapay zekâ destekli girdi doğrulama

Geleneksel doğrulama kuralları katıdır; açıkça tanımlanmış verilerde iyi çalışırlar ancak girdi belirsiz olduğunda veya biçim sürekli değiştiğinde zorlanırlar. Yapay zekâ destekli doğrulama burada devreye girer. Makine öğrenmesi modellerini kalıpları, anormallikleri veya hatta kötü niyetli girdileri tanıyacak şekilde eğiterek, uygulamalar yeni senaryolara daha esnek ve akıllıca yanıt verebilir.

Bazı kullanım örnekleri şunlardır:

• Dolandırıcılık tespiti: Davranış kalıplarına dayalı finansal girdilerde.
• Doğal dil girdi ayrıştırma: İfade farklılıklarına uyum sağlayan sistemler.
• Güvenlik süzgeci: Bilinen saldırı imzalarının ötesinde potansiyel olarak zararlı girdileri tanımlamak.

Örneğin, bir NLP modeli kullanıcı tarafından girilen bir mesajın, bilinen kalıplarla eşleşmese bile spam isteği veya enjeksiyon teşebbüsü gibi görünüp görünmediğini tespit edecek şekilde eğitilebilir. Transformer'lar veya LSTM ağları gibi modeller, örneklerden genelleme yapabilir ve kural tabanlı sistemlerin kaçırdığı uç durumları yakalayabilir.

Bu hâlâ gelişen bir alan olmakla birlikte, scikit-learn, spaCy gibi Python kütüphaneleri veya PyTorch ve TensorFlow gibi derin öğrenme çerçeveleri, bugün akıllı girdi doğrulamasıyla denemelere başlamanıza yardımcı olabilir.

Öğrenmeye devam etmenize yardımcı olacak bu kaynaklara göz atın:

• scikit-learn ile Makine Öğrenimi kursu 
• spaCy ile Doğal Dil İşleme kursu
• Python'da Derin Öğrenmeye Giriş kursu
• Python'da TensorFlow'a Giriş kursu

Sonuç

Kullanıcı girdisi, programlamanın en temel ancak çoğu zaman göz ardı edilen yönlerinden biridir. Statik bir kod bloğu ile etkileşimli, kullanıcı odaklı bir deneyim arasındaki geçittir. Bu rehber boyunca gördük ki Python'da girdi işleme yalnızca değer okumaktan ibaret değildir; gerçek dünya gereksinimlerine uyacak şekilde girdiyi doğrulamak, güvence altına almak, optimize etmek ve uyarlamaktır.

input() fonksiyonunun temellerinde ustalaşmaktan sağlam hata yönetimi, yapılandırılmış doğrulama ve hatta ses tanıma ile yapay zekâ destekli filtreleme gibi ileri teknikleri uygulamaya kadar, girdi işlemenin yelpazesi geniş ve etkilidir. İster hızlı bir betik ister üretim düzeyi bir sistem olsun, kullanıcıyla etkileşime giren her program sağlam girdi uygulamalarına dayanır.

Bu rehberde ele alınan stratejileri uygulayarak yalnızca çalışan değil, aynı zamanda özenli bir kullanıcı deneyimi sunan kod yazacaksınız. Öğrenmeye devam etmek için Python Programlama Temelleri yetkinlik yolumuza veya Python'da Veri İçe Aktarmaya Giriş kursumuza mutlaka göz atın.