Python Temelleri: İlk Adımınızı Atın ve Kodlamaya Başlayın

Modern dünyada teknolojiyle iç içe yaşarken, yazılım geliştirme becerileri artık sadece uzmanlara özgü bir alan olmaktan çıktı. Peki, programlama dünyasına ilk adımınızı atmak ve kendi projelerinizi geliştirmeye başlamak istiyorsanız nereden başlamalısınız? İşte bu noktada Python, kullanıcı dostu yapısı, geniş kütüphane desteği ve çok yönlülüğü ile en ideal başlangıç dillerinden biri olarak öne çıkıyor. Bu makalede, Python programlamanın temel taşlarını “Day 01” felsefesiyle, yani sıfırdan ve adım adım öğreneceğiz. İster kariyerinizi yazılım yönüne çevirmek isteyin, ister otomasyon projeleri geliştirmek, ister veri analizi yapmak… Python’ın sunduğu imkanlar oldukça geniş. Bu kapsamlı rehberde, Python’ın temel sözdiziminden değişkenlere, veri tiplerinden operatörlere, hatta döngülere ve koşullu ifadelere kadar birçok konuyu uygulamalı örneklerle ele alacağız. Hatta, gerçek dünya senaryolarını yansıtan vaka analizleri ile öğrendiklerinizi pekiştirme fırsatı bulacaksınız. Unutmayın, her büyük yazılımcı ilk satır kodunu yazarak başladı. Şimdi sıra sizde!

Python Neden Bu Kadar Popüler ve Temel Kavramları Nelerdir?

Python, günümüzün en popüler programlama dillerinden biri olarak kabul edilir ve bu popülaritesini birçok nedene borçludur. Öncelikle, Python’ın sözdizimi oldukça anlaşılır ve İngilizceye yakındır, bu da onu yeni başlayanlar için ideal bir seçenek haline getirir. Karmaşık görünen birçok işlem, Python’da yalnızca birkaç satır kod ile kolayca gerçekleştirilebilir. Bu sade ve minimalist yapı, kod okunaklığını artırır ve geliştirme sürecini hızlandırır.

Python’ın bir diğer önemli avantajı ise çok yönlülüğüdür. Web geliştirmeden (Django, Flask), veri bilimine (Pandas, NumPy), yapay zekadan (TensorFlow, Keras), otomasyona, oyun geliştirmeye ve hatta masaüstü uygulamalarına kadar geniş bir uygulama alanına sahiptir. Bu çeşitlilik, Python öğrenen birine gelecekteki kariyerinde veya kişisel projelerinde sayısız kapı açar. Geniş ve aktif bir topluluğa sahip olması da cabasıdır; herhangi bir sorunla karşılaştığınızda, çevrimiçi forumlarda, Stack Overflow gibi platformlarda veya GitHub gibi kaynaklarda kolayca destek bulabilirsiniz.

Peki, Python nasıl çalışır? Python, bir yorumlayıcı (interpreter) dilidir. Bu, yazdığınız kodun doğrudan makine koduna derlenmek yerine, Python yorumlayıcısı tarafından satır satır okunup çalıştırıldığı anlamına gelir. Bu özellik, kodu hızlı bir şekilde test etme ve hata ayıklama esnekliği sağlar. Yorumlayıcılı diller genellikle platformdan bağımsızdır, yani yazdığınız Python kodu Windows, macOS veya Linux gibi farklı işletim sistemlerinde yorumlayıcı yüklü olduğu sürece sorunsuz çalışır.

Programlamaya başlarken doğru araçları seçmek oldukça önemlidir. Python kodunuzu yazmak ve çalıştırmak için bir Metin Editörü veya Entegre Geliştirme Ortamı (IDE) kullanmanız gerekir. Yeni başlayanlar için genellikle Visual Studio Code (VS Code) önerilir. VS Code, ücretsiz olması, hafif yapısı, Python desteği için geniş eklenti seçenekleri ve güçlü hata ayıklama özellikleriyle mükemmel bir seçimdir. Kurulumu da oldukça basittir; Python’ı sisteminize kurduktan sonra VS Code’u indirip Python eklentisini kurarak hemen kod yazmaya başlayabilirsiniz.

Artık temel kavramlara ve araçlara aşina olduğunuza göre, ilk Python programımızı yazmanın zamanı geldi: “Merhaba Dünya!”. Bu, programlama dünyasındaki herkesin attığı ilk adımdır.

      print("Merhaba Dünya!")
    

Yukarıdaki kodu bir metin dosyasına kaydedip (örneğin, ilk_program.py olarak) terminalinizden python ilk_program.py komutunu çalıştırdığınızda, ekranda “Merhaba Dünya!” yazısını göreceksiniz. print() fonksiyonu, Python’da ekrana çıktı vermek için kullanılan temel fonksiyondur. Tırnak içindeki metin ise bir karakter dizisidir (string) ve print() fonksiyonu tarafından olduğu gibi ekrana yazdırılır. İşte bu kadar basit! Programlama maceranıza hoş geldiniz.

Python’da Değişkenler ve Veri Tipleri Nasıl Yönetilir?

Programlamada, verileri geçici olarak depolamak ve üzerinde işlemler yapmak için değişkenler kullanılır. Değişkenler, bilgisayar belleğinde bir değeri tutan sembolik isimlerdir. Python’da değişken tanımlamak oldukça kolaydır ve diğer bazı dillerden farklı olarak, bir değişkenin tipini önceden belirtmenize gerek yoktur. Python, atadığınız değere göre değişkenin tipini otomatik olarak algılar.

Değişken Tanımlama Kuralları ve İlkeler

Değişken isimlendirirken dikkat etmeniz gereken bazı kurallar ve iyi uygulamalar bulunmaktadır:

• Bir değişken ismi harf veya alt çizgi (_) ile başlamalıdır. Sayı ile başlayamaz.
• Değişken ismi sadece harfler, sayılar ve alt çizgiler içerebilir. Özel karakterler (. , ! vb.) kullanılamaz.
• Python’da büyük/küçük harf duyarlılığı vardır (sayi ve Sayi farklı değişkenlerdir).
• Python’ın ayrılmış kelimeleri (if, else, for, while gibi) değişken ismi olarak kullanılamaz.
• Değişken isimleri anlamlı olmalı ve neyi temsil ettiğini açıkça belirtmelidir (örneğin kullanici_adi yerine k_ad tercih edilmemelidir).

Örnek değişken tanımlamaları:

      isim = "Ahmet"        # String (metin)
      yas = 30             # Integer (tam sayı)
      boy = 1.75           # Float (ondalıklı sayı)
      evli_mi = False      # Boolean (mantıksal değer)
    

Temel Veri Tipleri: Int, Float, Str, Bool

Python’da sıkça kullanılan temel veri tiplerini daha yakından inceleyelim:

1. Integer (int): Tam sayılar için kullanılır. Pozitif veya negatif olabilirler.
   

             sayi1 = 10
             sayi2 = -500
           

2. Float (float): Ondalıklı sayılar için kullanılır.
   

             pi_sayisi = 3.14159
             ortalama = 98.7
           

3. String (str): Metin verileri için kullanılır. Tek tırnak (') veya çift tırnak (") arasına yazılırlar. Çok satırlı metinler için üç tırnak (""" veya ''') kullanılabilir.
   

             mesaj = "Merhaba Python!"
             kullanici_adi = 'ayse_yildiz'
             cok_satirli_metin = """Bu,
             çok satırlı bir
             metin örneğidir."""
           

4. Boolean (bool): Sadece iki değere sahip olabilir: True (doğru) veya False (yanlış). Genellikle koşullu ifadelerde ve mantıksal işlemlerde kullanılır.
   

             is_active = True
             has_permission = False
           

Veri Tipi Dönüşümleri (Casting)

Bazen bir veri tipini başka bir veri tipine dönüştürmeniz gerekebilir. Bu işleme “casting” denir. Python, bu dönüşümleri sağlayan yerleşik fonksiyonlara sahiptir: int(), float(), str(), bool().

      sayi_str = "123"
      sayi_int = int(sayi_str)      # "123" stringini 123 integer'a çevirir
      print(type(sayi_int))         # Çıktı: 

      ondalik_str = "10.5"
      ondalik_float = float(ondalik_str) # "10.5" stringini 10.5 float'a çevirir
      print(type(ondalik_float))    # Çıktı: 

      tam_sayi = 25
      tam_sayi_str = str(tam_sayi)  # 25 integer'ını "25" stringine çevirir
      print(type(tam_sayi_str))     # Çıktı: 

      sifir_int = 0
      sifir_bool = bool(sifir_int)  # 0, False'a dönüşür
      print(sifir_bool)             # Çıktı: False

      bes_int = 5
      bes_bool = bool(bes_int)      # 0 dışındaki sayılar True'a dönüşür
      print(bes_bool)               # Çıktı: True
    

Bu dönüşümler, özellikle kullanıcıdan alınan verilerle (genellikle string formatında gelir) işlem yaparken veya farklı veri tiplerini birleştirmeye çalışırken kritik öneme sahiptir.

Vaka Analizi: Basit Bir Not Ortalaması Hesaplayıcı

Öğrendiğimiz değişken ve veri tiplerini kullanarak basit bir not ortalaması hesaplayıcı yapalım. Bu senaryoda, üç farklı dersten alınan notları (integer veya float) alıp, ortalamasını hesaplayıp ekrana yazdıracağız.

      # Değişkenleri tanımlama ve değer atama
      matematik_notu = 85
      fizik_notu = 78.5
      kimya_notu = 92

      # Notları toplama
      toplam_not = matematik_notu + fizik_notu + kimya_notu

      # Ortalama hesaplama
      ortalama_not = toplam_not / 3

      # Sonucu ekrana yazdırma
      print("Matematik Notu:", matematik_notu)
      print("Fizik Notu:", fizik_notu)
      print("Kimya Notu:", kimya_notu)
      print("Öğrencinin Genel Not Ortalaması:", ortalama_not)
    

Bu örnekte, hem tam sayı (matematik_notu, kimya_notu) hem de ondalıklı sayı (fizik_notu) değişkenlerini kullandık. Python, bu iki tipi otomatik olarak doğru şekilde toplayıp float bir sonuç üretti. Bu, Python’ın esnek ve güçlü yönlerinden biridir.

Python Operatörleri: Verileri Nasıl İşleyebiliriz?

Programlama dillerinde operatörler, değişkenler ve değerler üzerinde işlemler gerçekleştirmek için kullanılan sembollerdir. Python, çeşitli türde operatörler sunarak matematiksel hesaplamalardan mantıksal karşılaştırmalara kadar geniş bir yelpazede işlemleri kolayca yapmamızı sağlar.

Aritmetik Operatörler: Hesaplamaların Temeli

Aritmetik operatörler, temel matematiksel işlemleri gerçekleştirmek için kullanılır:

• + : Toplama (x + y)
• - : Çıkarma (x - y)
• * : Çarpma (x * y)
• / : Bölme (x / y) – Sonuç her zaman float tipinde olur.
• % : Modülüs (Kalan) (x % y) – Bölme işleminden kalanı verir.
• : Üs alma (x y) – x’in y. kuvveti.
• // : Tam sayı bölme (x // y) – Bölümün tam sayı kısmını verir.

      a = 10
      b = 3

      print("Toplama:", a + b)   # 13
      print("Çıkarma:", a - b)   # 7
      print("Çarpma:", a * b)    # 30
      print("Bölme:", a / b)     # 3.3333...
      print("Modülüs:", a % b)   # 1 (10'un 3'e bölümünden kalan)
      print("Üs alma:", a ** b)  # 1000 (10^3)
      print("Tam sayı bölme:", a // b) # 3
    

Karşılaştırma Operatörleri: Değerleri Karşılaştırma

Bu operatörler, iki değeri karşılaştırmak ve bir boolean (True veya False) sonuç döndürmek için kullanılır:

• == : Eşittir (x == y)
• != : Eşit değildir (x != y)
• > : Büyüktür (x > y)
• < : Küçüktür (x < y)
• >= : Büyük veya eşittir (x >= y)
• <= : Küçük veya eşittir (x <= y)

      x = 15
      y = 10

      print("Eşit mi?", x == y)     # False
      print("Eşit değil mi?", x != y) # True
      print("Büyük mü?", x > y)       # True
      print("Küçük mü?", x < y)       # False
      print("Büyük veya eşit mi?", x >= y) # True
      print("Küçük veya eşit mi?", x <= y) # False
    

Mantıksal Operatörler: Koşulları Birleştirme

Mantıksal operatörler, birden fazla koşulu birleştirmek veya koşulları tersine çevirmek için kullanılır:

• and : Her iki koşul da doğruysa True döndürür.
• or : Koşullardan en az biri doğruysa True döndürür.
• not : Koşulun mantıksal tersini döndürür.

      yas = 25
      gelir = 5000

      # Hem yaş 18'den büyük VE gelir 4000'den büyük ise
      if yas > 18 and gelir > 4000:
          print("Kredi başvurusu uygun.") # Bu koşul True olduğu için çalışır

      ehliyet_var_mi = True
      yas = 17

      # Yaş 18'den büyük VEYA ehliyeti var ise
      if yas > 18 or ehliyet_var_mi:
          print("Araç kullanabilir.") # 'ehliyet_var_mi' True olduğu için çalışır

      is_admin = False
      print("Admin değil mi?", not is_admin) # True (is_admin False olduğu için tersi True olur)
    

Atama Operatörleri: Değer Atama ve Kısayollar

Atama operatörleri, bir değişkene değer atamak için kullanılır. Genellikle aritmetik işlemlerle birleşerek kısa yollar sunarlar:

• = : Değer atar (x = 5)
• += : Topla ve ata (x += 3 <--> x = x + 3)
• -= : Çıkar ve ata (x -= 3 <--> x = x - 3)
• *= : Çarp ve ata (x *= 3 <--> x = x * 3)
• /= : Böl ve ata (x /= 3 <--> x = x / 3)
• %= : Modülüs al ve ata (x %= 3 <--> x = x % 3)
• = : Üs al ve ata (x = 3 <--> x = x ** 3)
• //= : Tam sayı böl ve ata (x //= 3 <--> x = x // 3)

      sayac = 0
      sayac += 1    # sayac = sayac + 1, yani 1
      print(sayac)  # 1

      fiyat = 100
      fiyat *= 1.18 # fiyat = fiyat * 1.18 (KDV ekleme)
      print(fiyat)  # 118.0
    

Operatör Önceliği

Bir ifadede birden fazla operatör kullanıldığında, Python belirli bir öncelik sırasına göre işlem yapar. Bu, matematikteki işlem önceliği (parantez, üslü sayılar, çarpma/bölme, toplama/çıkarma) ile benzerdir. Parantez () kullanarak bu öncelik sırasını değiştirebilirsiniz.

En yüksek öncelikten en düşüğe doğru genel sıralama:

1. Parantezler ()
2. Üs alma **
3. Çarpma *, Bölme /, Tam sayı bölme //, Modülüs %
4. Toplama +, Çıkarma -
5. Karşılaştırma operatörleri ==, !=, >, <, >=, <=
6. Mantıksal operatörler not, and, or

      sonuc1 = 5 + 3 * 2  # Önce çarpma (3*2=6), sonra toplama (5+6=11)
      print(sonuc1)       # 11

      sonuc2 = (5 + 3) * 2 # Önce parantez içi (5+3=8), sonra çarpma (8*2=16)
      print(sonuc2)       # 16
    

Operatörleri ve önceliklerini anlamak, beklediğiniz gibi çalışan doğru ve hatasız kodlar yazmanız için kritik öneme sahiptir.

Kullanıcıyla Etkileşim: input() ve print() Fonksiyonları

Programlarımızın sadece önceden tanımlanmış verilerle değil, aynı zamanda kullanıcıdan alınan gerçek zamanlı verilerle de etkileşim kurması çoğu zaman gereklidir. Python'da bu etkileşimi sağlamak için print() ve input() fonksiyonları kullanılır. print() fonksiyonunu daha önce basitçe görmüştük, şimdi daha gelişmiş kullanımlarına ve input() fonksiyonuna detaylıca bakalım.

print() Fonksiyonunun Gelişmiş Kullanımları

print(), ekrana çıktı vermek için kullanılan çok yönlü bir fonksiyondur. Sadece basit metinleri değil, değişkenleri ve karmaşık ifadelerin sonuçlarını da gösterebilir.

Birden Fazla Argüman ve Ayrıcı (sep)

print() fonksiyonuna virgülle ayrılmış birden fazla argüman verebilirsiniz. Varsayılan olarak, bu argümanlar arasında bir boşluk bırakılarak ekrana yazdırılır. Ancak sep (separator - ayırıcı) parametresi ile bu davranışı değiştirebilirsiniz.

      ad = "Ayşe"
      yas = 28
      print("Ad:", ad, "Yaş:", yas) # Çıktı: Ad: Ayşe Yaş: 28
      print("Ad:", ad, "Yaş:", yas, sep=" | ") # Çıktı: Ad: | Ayşe | Yaş: | 28
    

Satır Sonu Karakteri (end)

print() fonksiyonu her çağrıldığında, varsayılan olarak çıktının sonuna bir yeni satır karakteri (\n) ekler. Bu, her print() çağrısının yeni bir satırdan başlamasına neden olur. end parametresi ile bu varsayılan davranışı değiştirebilirsiniz.

      print("Merhaba", end=" ")
      print("Dünya!") # Çıktı: Merhaba Dünya! (tek satırda)

      print("Liste elemanları:")
      print(1, end=", ")
      print(2, end=", ")
      print(3) # Çıktı: Liste elemanları: 1, 2, 3
    

F-stringler (Formatted String Literals)

Python 3.6 ve sonrası sürümlerde gelen f-stringler, string formatlama için en modern ve okunur yoldur. String'in başına f veya F ekleyerek, süslü parantezler {} içine değişkenleri veya ifadeleri doğrudan yazabilirsiniz.

      urun_adi = "Laptop"
      fiyat = 1250.75
      indirim_orani = 0.15

      print(f"Ürün: {urun_adi}, Fiyat: {fiyat:.2f} TL.") # Fiyatı 2 ondalık basamakla gösterir
      print(f"İndirimli Fiyat: {fiyat * (1 - indirim_orani):.2f} TL.")
    

F-stringler, okunabilirliği artırması ve kullanımı kolay olması nedeniyle şiddetle tavsiye edilir.

input() Fonksiyonu ile Kullanıcıdan Veri Alma

input() fonksiyonu, kullanıcıdan veri almak için kullanılır. Bu fonksiyon, kullanıcının girdiği her şeyi bir string (karakter dizisi) olarak döndürür. Eğer sayısal bir değer almayı bekliyorsanız, gelen string'i uygun bir veri tipine (int() veya float() kullanarak) dönüştürmeniz gerekir.

      # Kullanıcıdan isim alma
      kullanici_adi = input("Lütfen adınızı giriniz: ")
      print(f"Merhaba, {kullanici_adi}!")

      # Kullanıcıdan yaş alma (string olarak gelir)
      yas_str = input("Lütfen yaşınızı giriniz: ")
      # Yaşı integer'a dönüştürme
      yas_int = int(yas_str)
      print(f"Demek {yas_int} yaşındasınız. Gelecek yıl {yas_int + 1} olacaksınız.")
    

Yukarıdaki örnekte, input() fonksiyonuna parametre olarak verilen string, kullanıcıya gösterilecek bir ipucu veya soru mesajıdır. Kullanıcı bu mesajı gördükten sonra klavyeden bir değer girer ve Enter tuşuna basar.

Vaka Analizi: Basit Bir Yaş Hesaplama Uygulaması

Şimdiye kadar öğrendiğimiz input(), print(), değişkenler ve operatörleri birleştirerek basit bir yaş hesaplama uygulaması yapalım. Bu uygulama, kullanıcının doğum yılını alacak ve mevcut yıla göre yaşını hesaplayıp ekrana yazdıracaktır.

      import datetime # datetime modülünü mevcut yılı almak için dahil ediyoruz

      # Mevcut yılı alalım
      mevcut_yil = datetime.datetime.now().year

      # Kullanıcıdan doğum yılını alalım
      dogum_yili_str = input("Lütfen doğum yılınızı giriniz: ")

      # Doğum yılını string'den integer'a dönüştürelim
      dogum_yili_int = int(dogum_yili_str)

      # Yaşı hesaplayalım
      yas = mevcut_yil - dogum_yili_int

      # Sonucu f-string kullanarak ekrana yazdıralım
      print(f"Merhaba! Mevcut yıl {mevcut_yil}. Doğum yılınız {dogum_yili_int} olduğuna göre, yaklaşık yaşınız {yas}.")

      # Bir sonraki yaş tahmini
      print(f"Gelecek yıl {yas + 1} yaşında olacaksınız.")
    

Bu uygulama, Python'ın nasıl kullanıcı etkileşimi sağlayabildiğini, veri tipleri arasında dönüşüm yapabildiğini ve basit hesaplamaları gerçekleştirebildiğini göstermektedir. datetime modülünü kullanmak, Python'ın zengin standart kütüphanelerinden yalnızca birine ufak bir bakış atmamızı sağladı. İleride çok daha karmaşık modüllerle çalışacaksınız!

Karar Mekanizmaları: if, elif, else Yapıları Nasıl Kullanılır?

Programlama, sadece adım adım talimatları takip etmekten ibaret değildir; aynı zamanda belirli koşullara göre farklı yollar izleyebilme yeteneğidir. İşte bu noktada "koşullu ifadeler" devreye girer. Python'da, program akışını kontrol etmek için if, elif (else if'in kısaltması) ve else yapılarını kullanırız. Bu yapılar, belirli bir koşulun doğru (True) veya yanlış (False) olmasına bağlı olarak farklı kod bloklarının çalıştırılmasını sağlar.

Akış Kontrolü ve if Deyimi

if deyimi, en temel koşullu yapıdır. Belirtilen koşul doğruysa, if bloğunun içindeki kod çalıştırılır. Koşul yanlışsa, if bloğu atlanır.

Genel Yapı:

      if koşul:
          # Koşul doğru ise çalışacak kod bloğu
    

Unutmayın, Python'da kod blokları girintilerle (boşluk veya tab) belirlenir. Bu, diğer birçok dildeki süslü parantezlerin {} yerini tutar ve Python'ın okunabilirliğini artıran önemli bir özelliğidir.

      hava_durumu = "yağmurlu"

      if hava_durumu == "yağmurlu":
          print("Şemsiyeni almayı unutma!")

      # Koşul yanlış olduğu için aşağıdaki blok çalışmaz
      sicaklik = 15
      if sicaklik > 25:
          print("Hava sıcak, ince giyin.")
    

else Deyimi: Koşul Yanlışsa Ne Olacak?

else deyimi, if koşulunun yanlış olması durumunda çalıştırılacak kodu belirtir. Yani, if koşulu doğru değilse, program otomatik olarak else bloğuna geçer.

Genel Yapı:

      if koşul:
          # Koşul doğru ise çalışacak kod
      else:
          # Koşul yanlış ise çalışacak kod
    

      yas = 16

      if yas >= 18:
          print("Oy kullanabilirsiniz.")
      else:
          print("Oy kullanmak için yaşınız küçük.")
    

Bu örnekte, yas değişkeni 18'den küçük olduğu için if koşulu yanlış döner ve else bloğu çalışarak "Oy kullanmak için yaşınız küçük." çıktısını verir.

elif Deyimi: Birden Fazla Koşul Zinciri

Bazen ikiden fazla olası durumunuz olabilir ve bu durumlara göre farklı eylemler gerçekleştirmek isteyebilirsiniz. İşte burada elif (else if) devreye girer. elif, bir önceki if veya elif koşulu yanlış olduğunda kontrol edilecek ek bir koşul belirtmenizi sağlar.

Genel Yapı:

      if ilk_koşul:
          # ilk_koşul doğru ise çalışacak kod
      elif ikinci_koşul:
          # ilk_koşul yanlış VE ikinci_koşul doğru ise çalışacak kod
      else:
          # Tüm koşullar yanlış ise çalışacak kod
    

Bir if-elif-else zincirinde, yalnızca bir kod bloğu çalıştırılır: ilk doğru koşulun bloğu.

      puan = 85

      if puan >= 90:
          print("Notunuz: A")
      elif puan >= 80:
          print("Notunuz: B")
      elif puan >= 70:
          print("Notunuz: C")
      else:
          print("Notunuz: D veya daha düşük")
    

Bu örnekte puan 85 olduğu için, ilk koşul (puan >= 90) yanlış olur. İkinci koşul (puan >= 80) doğru olduğu için "Notunuz: B" çıktısı verilir ve diğer elif ve else blokları kontrol edilmez.

İç İçe if Yapıları ve Mantıksal Operatörlerle Koşulları Birleştirme

Daha karmaşık durumlar için koşulları iç içe geçirebilir veya mantıksal operatörler (and, or, not) kullanarak aynı satırda birden fazla koşulu kontrol edebilirsiniz.

İç İçe if

      kullanici_adi = "admin"
      sifre = "12345"

      if kullanici_adi == "admin":
          if sifre == "12345":
              print("Yönetici girişi başarılı.")
          else:
              print("Yanlış şifre.")
      else:
          print("Kullanıcı bulunamadı.")
    

Mantıksal Operatörler Kullanarak

Genellikle, iç içe if yerine mantıksal operatörler kullanmak kodu daha okunur ve kısa yapar.

      kullanici_adi = "admin"
      sifre = "12345"

      if kullanici_adi == "admin" and sifre == "12345":
          print("Yönetici girişi başarılı.")
      elif kullanici_adi == "admin": # Sadece kullanıcı adı doğru, şifre yanlışsa
          print("Yanlış şifre.")
      else:
          print("Kullanıcı bulunamadı.")
    

Vaka Analizi: Bir Sayının Pozitif/Negatif/Sıfır Olduğunu Bulan Program

Kullanıcıdan bir sayı alıp, bu sayının pozitif mi, negatif mi yoksa sıfır mı olduğunu belirleyen basit bir program yazalım.

      # Kullanıcıdan sayı girişi alalım
      sayi_str = input("Lütfen bir sayı giriniz: ")

      # Girişi integer'a dönüştürelim. Hata durumlarını daha sonra ele alacağız.
      sayi = int(sayi_str)

      # Koşullu ifadeler kullanarak sayıyı kontrol edelim
      if sayi > 0:
          print(f"Girilen sayı ({sayi}) pozitif bir sayıdır.")
      elif sayi < 0:
          print(f"Girilen sayı ({sayi}) negatif bir sayıdır.")
      else:
          print(f"Girilen sayı ({sayi}) sıfırdır.")
    

Bu örnek, input(), int(), if, elif, else ve f-string kullanımını bir araya getirerek temel bir karar mekanizması oluşturmanın ne kadar kolay olduğunu gösteriyor. Programlamanın temel yapı taşlarından biri olan koşullu ifadeler, uygulamalarınıza zeka ve esneklik katmanızı sağlar.

Tekrar Eden Görevler İçin: for ve while Döngüleri

Programlamada sıkça karşılaşılan bir durum, belirli bir kod bloğunu birden fazla kez çalıştırma ihtiyacıdır. Örneğin, bir listedeki her öğeyi işlemek, bir dosyayı belirli bir sayıda okumak veya bir koşul sağlanana kadar bir işlemi tekrar etmek isteyebilirsiniz. İşte bu tekrar eden görevleri otomatikleştirmek için "döngüler" kullanılır. Python'da iki ana döngü türü bulunur: for döngüsü ve while döngüsü.

for Döngüsü ve range() Fonksiyonu: Belirli Bir Aralıkta Yineleme

for döngüsü, bir dizi (liste, tuple, string, range vb.) üzerindeki öğeler arasında dolaşmak (iterate etmek) için kullanılır. Her bir yinelemede, diziden bir öğe alınır ve döngü içindeki kod bloğu bu öğe ile çalıştırılır.

Genel Yapı:

      for öğe in dizi:
          # öğe ile yapılacak işlemler
    

      meyveler = ["elma", "armut", "kiraz"]
      for meyve in meyveler:
          print(f"Benim en sevdiğim meyve: {meyve}")

      # Çıktı:
      # Benim en sevdiğim meyve: elma
      # Benim en sevdiğim meyve: armut
      # Benim en sevdiğim meyve: kiraz
    

range() fonksiyonu, belirli bir sayı dizisi oluşturmak için sıklıkla for döngüleriyle birlikte kullanılır. Üç farklı şekilde kullanılabilir:

• range(stop): 0'dan stop-1'e kadar sayılar üretir.
• range(start, stop): start'tan stop-1'e kadar sayılar üretir.
• range(start, stop, step): start'tan stop-1'e kadar step (adım) değeriyle sayılar üretir.

      # 0'dan 4'e kadar sayılar (5 dahil değil)
      for i in range(5):
          print(i, end=" ") # Çıktı: 0 1 2 3 4

      print("\n") # Yeni satıra geçmek için

      # 2'den 7'ye kadar sayılar (7 dahil değil)
      for i in range(2, 7):
          print(i, end=" ") # Çıktı: 2 3 4 5 6

      print("\n")

      # 10'dan 0'a kadar 2'şer azalarak
      for i in range(10, 0, -2):
          print(i, end=" ") # Çıktı: 10 8 6 4 2
    

while Döngüsü: Bir Koşul Sağlandığı Sürece Tekrar

while döngüsü, belirli bir koşul doğru (True) olduğu sürece bir kod bloğunu tekrar tekrar çalıştırmak için kullanılır. Koşul yanlış (False) olduğunda döngü sona erer. while döngülerinde, döngünün sonsuz bir döngüye girmemesi için koşulu değiştiren bir mekanizma olması çok önemlidir.

Genel Yapı:

      while koşul:
          # Koşul doğru olduğu sürece çalışacak kod
          # Koşulu değiştiren ifade (döngüden çıkış için)
    

      sayac = 0
      while sayac < 5:
          print(f"Sayaç değeri: {sayac}")
          sayac += 1 # Sayacı artırarak döngünün bir noktada sona ermesini sağlıyoruz

      # Çıktı:
      # Sayaç değeri: 0
      # Sayaç değeri: 1
      # Sayaç değeri: 2
      # Sayaç değeri: 3
      # Sayaç değeri: 4
    

Eğer sayac += 1 ifadesi olmasaydı, sayac her zaman 0 olarak kalacak ve sayac < 5 koşulu her zaman doğru olacağı için program sonsuz bir döngüye girecekti.

break ve continue İfadeleri: Döngü Kontrolü

Döngülerin akışını kontrol etmek için break ve continue ifadelerini kullanabiliriz.

• break: İçinde bulunduğu döngüyü tamamen sonlandırır ve kontrolü döngüden sonraki ilk ifadeye geçirir.
  

            for i in range(10):
                if i == 5:
                    break # i 5 olduğunda döngü sona erer
                print(i, end=" ") # Çıktı: 0 1 2 3 4
          

• continue: İçinde bulunduğu döngünün o anki yinelemesini atlar ve bir sonraki yinelemeye geçer.
  

            for i in range(10):
                if i % 2 == 0: # Eğer sayı çift ise
                    continue   # Bu yinelemeyi atla, bir sonraki sayıya geç
                print(i, end=" ") # Çıktı: 1 3 5 7 9
          

Vaka Analizi: Bir Listedeki Sayıların Toplamını Bulan Program

for döngüsünü ve basit aritmetik işlemleri kullanarak bir listedeki tüm sayıların toplamını hesaplayan bir program yazalım.

      sayilar_listesi = [10, 20, 30, 40, 50]
      toplam = 0 # Toplamı tutacak değişkeni başlangıçta sıfır olarak tanımlıyoruz

      # Liste üzerindeki her bir sayı için döngü kuralım
      for sayi in sayilar_listesi:
          toplam += sayi # Her sayıyı toplama ekleyelim
          print(f"Mevcut toplam: {toplam}, Eklenen sayı: {sayi}") # Her adımda durumu gösterelim

      print(f"\nListenin elemanları toplamı: {toplam}")

      # Veya while döngüsü ile yapalım
      toplam_while = 0
      index = 0
      while index < len(sayilar_listesi): # listenin uzunluğu kadar dön
          toplam_while += sayilar_listesi[index]
          print(f"Mevcut toplam (while): {toplam_while}, Eklenen sayı: {sayilar_listesi[index]}")
          index += 1
      print(f"\nListenin elemanları toplamı (while): {toplam_while}")
    

Bu örnek, for döngüsünün bir veri yapısı üzerindeki elemanları nasıl etkili bir şekilde işleyebildiğini göstermektedir. while döngüsüyle de aynı sonucu elde edebileceğimizi de gösterdik. Hangi döngüyü kullanacağınız, karşılaştığınız senaryoya bağlıdır: belirli bir dizi üzerinde dolaşmak için for, bir koşul doğru olduğu sürece çalışmak için while daha uygundur.

Python'da Veri Koleksiyonları: Listeler ve Tuple'lar

Gerçek dünya uygulamalarında genellikle tekil değerlerle değil, birbiriyle ilişkili birden fazla değeri bir arada tutan koleksiyonlarla çalışırız. Python, bu tür koleksiyonları yönetmek için güçlü ve esnek yerleşik veri yapıları sunar. Bunlardan en temel ikisi "listeler" ve "tuple'lar"dır. Her ikisi de birden fazla öğeyi sıralı bir şekilde depolamanıza olanak tanır, ancak önemli farklılıkları vardır.

Listeler: Esnek ve Değiştirilebilir Koleksiyonlar

Python listeleri, farklı veri tiplerinden (integer, float, string, hatta başka listeler) herhangi bir sayıda öğeyi sıralı bir şekilde depolayan, değiştirilebilir (mutable) veri yapılarıdır. Köşeli parantezler [] arasına virgülle ayrılarak tanımlanırlar.

Liste Oluşturma ve Elemanlara Erişim

      # Boş liste oluşturma
      bos_liste = []
      print(bos_liste) # Çıktı: []

      # Farklı veri tipleri içeren bir liste
      karisik_liste = ["elma", 123, True, 3.14]
      print(karisik_liste) # Çıktı: ['elma', 123, True, 3.14]

      # Elemanlara index numarası ile erişim (index 0'dan başlar)
      meyveler = ["elma", "armut", "kiraz", "muz"]
      print(meyveler[0]) # Çıktı: elma (ilk eleman)
      print(meyveler[2]) # Çıktı: kiraz (üçüncü eleman)

      # Negatif indexler sondan başlar
      print(meyveler[-1]) # Çıktı: muz (son eleman)
      print(meyveler[-2]) # Çıktı: kiraz (sondan ikinci eleman)

      # Belirli bir aralıktaki elemanlara erişim (dilimleme - slicing)
      print(meyveler[1:3]) # Çıktı: ['armut', 'kiraz'] (1. indexten başlar, 3. indexe kadar ama 3. dahil değil)
      print(meyveler[:2])  # Çıktı: ['elma', 'armut'] (baştan 2. indexe kadar)
      print(meyveler[2:])  # Çıktı: ['kiraz', 'muz'] (2. indexten sona kadar)
    

Liste Metotları: Eleman Ekleme, Çıkarma ve Düzenleme

Listeler değiştirilebilir olduğu için, elemanlarını kolayca ekleyebilir, çıkarabilir veya güncelleyebilirsiniz. Python, bunun için birçok yerleşik metot sunar:

• append(item): Listenin sonuna bir eleman ekler.
  

            meyveler.append("portakal")
            print(meyveler) # Çıktı: ['elma', 'armut', 'kiraz', 'muz', 'portakal']
          

• insert(index, item): Belirtilen index'e eleman ekler.
  

            meyveler.insert(1, "çilek")
            print(meyveler) # Çıktı: ['elma', 'çilek', 'armut', 'kiraz', 'muz', 'portakal']
          

• remove(item): Belirtilen değeri olan ilk elemanı listeden kaldırır.
  

            meyveler.remove("armut")
            print(meyveler) # Çıktı: ['elma', 'çilek', 'kiraz', 'muz', 'portakal']
          

• pop(index): Belirtilen index'teki elemanı kaldırır ve döndürür (index belirtilmezse son elemanı kaldırır).
  

            cikarilan_meyve = meyveler.pop(0) # İlk elemanı (elma) kaldırır
            print(f"Çıkarılan meyve: {cikarilan_meyve}") # Çıktı: Çıkarılan meyve: elma
            print(meyveler) # Çıktı: ['çilek', 'kiraz', 'muz', 'portakal']
          

• len(list): Listenin eleman sayısını döndürür.
  

            print(len(meyveler)) # Çıktı: 4
          

• list.sort() veya sorted(list): Listeyi sıralar. .sort() listeyi yerinde değiştirir, sorted() ise yeni bir sıralanmış liste döndürür.
  

            sayilar = [3, 1, 4, 1, 5, 9, 2]
            sayilar.sort()
            print(sayilar) # Çıktı: [1, 1, 2, 3, 4, 5, 9]
  
            isimler = ["Ayşe", "Zeynep", "Ali"]
            sirali_isimler = sorted(isimler, reverse=True) # Tersine sıralama
            print(sirali_isimler) # Çıktı: ['Zeynep', 'Ayşe', 'Ali']
          

Tuple'lar: Sabit ve Değiştirilemez Koleksiyonlar

Tuple'lar da listeler gibi birden fazla öğeyi sıralı bir şekilde depolar. Ancak, listelerden en önemli farkları, tuple'ların değiştirilemez (immutable) olmasıdır. Bir tuple oluşturulduktan sonra elemanları eklenemez, çıkarılamaz veya değiştirilemez. Parantezler () arasına virgülle ayrılarak tanımlanırlar.

Tuple Oluşturma ve Elemanlara Erişim

      # Bir tuple oluşturma
      koordinatlar = (10, 20)
      print(koordinatlar) # Çıktı: (10, 20)

      # Farklı veri tipleri içeren tuple
      kullanici_bilgisi = ("Ahmet", "Yılmaz", 30, True)
      print(kullanici_bilgisi) # Çıktı: ('Ahmet', 'Yılmaz', 30, True)

      # Tek elemanlı tuple (virgül önemlidir!)
      tek_elemanli_tuple = ("tek_eleman",)
      print(type(tek_elemanli_tuple)) # Çıktı: 
      sadece_string = ("tek_eleman")
      print(type(sadece_string)) # Çıktı: 

      # Elemanlara index ile erişim (listelerle aynı)
      print(kullanici_bilgisi[0])  # Çıktı: Ahmet
      print(kullanici_bilgisi[1:3]) # Çıktı: ('Yılmaz', 30)
    

Listeler ve Tuple'lar Arasındaki Farklar ve Kullanım Senaryoları

| Özellik | Liste (list) | Tuple (tuple) |
|----------------|--------------------------|--------------------------|
| Değiştirilebilirlik | Değiştirilebilir (Mutable) | Değiştirilemez (Immutable) |
| Tanımlama | Köşeli parantez [] | Parantez () |
| Performans | Genellikle Tuple'dan yavaş | Genellikle Liste'den hızlı |
| Kullanım Senaryosu | Elemanları değişmesi beklenen koleksiyonlar (ör: kullanıcı listeleri, alışveriş sepeti öğeleri) | Elemanları sabit kalması gereken koleksiyonlar (ör: koordinatlar, renk kodları, veritabanı kayıtları) |

Tuple'lar, veri bütünlüğünün önemli olduğu ve koleksiyonun içeriğinin değişmemesi gereken durumlarda tercih edilir. Ayrıca, fonksiyonlardan birden fazla değer döndürmek için sıkça kullanılırlar.

İleri Düzey İpuçları ve En İyi Uygulamalar: Python Kodunuzu Geliştirmek İçin İpuçları

Python'ın temellerini öğrenmek harika bir başlangıçtır, ancak profesyonel ve etkili kod yazmak için bazı en iyi uygulamaları ve ileri düzey ipuçlarını bilmek kod kalitenizi önemli ölçüde artıracaktır. Bu bölümde, kodunuzu daha okunur, bakımı daha kolay ve daha verimli hale getirecek yöntemlere değineceğiz.

PEP 8 Standartları: Okunabilir Kodun Temeli

PEP 8 (Python Enhancement Proposal 8), Python kodu için stil rehberidir. Kodun nasıl biçimlendirilmesi gerektiğini (girintileme, boşluklar, isimlendirme kuralları vb.) tanımlar. Bu standartlara uymak, kodunuzun sadece sizin için değil, başkaları tarafından da kolayca okunmasını ve anlaşılmasını sağlar. En yaygın PEP 8 kurallarından bazıları:

• Her seviyede 4 boşluk girinti kullanın.
• Değişken ve fonksiyon isimleri için snake_case (küçük harfler ve alt çizgi) kullanın (ör: ilk_degisken).
• Sınıf isimleri için CamelCase (her kelimenin ilk harfi büyük) kullanın (ör: KullaniciHesabi).
• Boş satırları kullanarak kod bloklarını ayırın (fonksiyonlar arası 2 boş satır, metotlar arası 1 boş satır).
• Satır uzunluğunu 79 karakterle sınırlayın.
• Operatörlerin etrafına boşluk bırakın (ör: a = b + c yerine a=b+c değil).

Bu kurallara uyum sağlamak için VS Code gibi IDE'lerde otomatik formatlama araçlarını (örneğin Black veya Autopep8 eklentileri) kullanabilirsiniz.

Yorum Satırları (#): Kodunuzu Açıklayın

Kodunuzun ne yaptığını açıklayan yorum satırları eklemek çok önemlidir. Kendinize veya başkalarına kodunuzu anlamalarında yardımcı olur. Python'da tek satırlık yorumlar için # karakteri kullanılır. Çok satırlık yorumlar veya fonksiyon/sınıf açıklamaları için üçlü tırnaklar (docstring'ler) tercih edilir.

      # Bu bir tek satırlık yorumdur.

      def kare_al(sayi):
          """
          Verilen sayının karesini hesaplar ve döndürür.
          Bu bir docstring örneğidir, fonksiyonun ne işe yaradığını açıklar.
          """
          return sayi * sayi

      sonuc = kare_al(5) # kare_al fonksiyonunu çağırıyoruz
      print(sonuc)
    

Sanal Ortamlar: Projelerinizi İzole Edin

Python projeleri genellikle farklı kütüphanelere ve farklı versiyonlarına ihtiyaç duyar. Sanal ortamlar (Virtual Environments), her projenin kendi bağımlılık setine sahip olmasını sağlayarak bu çakışmaları önler. Python'ın venv modülü ile kolayca sanal ortamlar oluşturabilirsiniz.

1. Oluşturma: python -m venv myenv (myenv yerine istediğiniz adı verebilirsiniz)
2. Aktif Etme (Windows): .\myenv\Scripts\activate
3. Aktif Etme (macOS/Linux): source myenv/bin/activate
4. Yükleme: pip install kütüphane_adi
5. Devre dışı bırakma: deactivate

Bu sayede bir projeniz Django 3 kullanırken, diğer projeniz sorunsuz bir şekilde Django 4 kullanabilir.

Hata Ayıklama (Debugging) İpuçları

Kod yazarken hata yapmak kaçınılmazdır. Önemli olan bu hataları (bug'ları) hızlı ve etkili bir şekilde bulup düzeltebilmektir.

• print() ifadeleri: Basit hatalar için değişken değerlerini farklı noktalarda print() ile ekrana bastırmak hızlı bir yol olabilir.
• IDE Hata Ayıklayıcıları: VS Code gibi modern IDE'ler, kodunuzu adım adım çalıştırmanıza, değişkenlerin değerlerini anlık olarak izlemenize ve breakpoint'ler (kesme noktaları) ayarlamanıza olanak tanıyan güçlü hata ayıklayıcılara sahiptir. Bunları kullanmayı öğrenmek, karmaşık sorunları çözmede çok zaman kazandırır.
• Hata Mesajlarını Okuyun: Python bir hata verdiğinde, terminalde çıkan hata mesajını (traceback) dikkatlice okuyun. Hata türü (NameError, TypeError vb.) ve hatanın hangi satırda olduğu genellikle belirtilir. Bu bilgiler, sorunu anlamak için ilk ve en önemli adımdır.

Mobil Uyumlu HTML ve Python Arasındaki İlişki (Konseptsel Örnek)

Python kodunun kendisi doğrudan "mobil uyumlu HTML" üretmez; bu genellikle web çerçeveleri (Django, Flask) ile Python'ın backend'de çalışması ve HTML/CSS/JavaScript'in frontend'de kullanıcı arayüzünü oluşturmasıyla sağlanır. Ancak, Python'ın modüler ve düzenli kod yazma prensipleri, mobil uyumlu bir web uygulamasının backend'ini tasarlarken de önemlidir.

Bir web uygulamasında, mobil uyumluluk genellikle HTML ve CSS'in (özellikle media query'ler) görevidir. Örneğin, bir Python web uygulaması bir API endpoint'i aracılığıyla veri sağlar ve bu veriyi alan frontend (HTML, CSS, JS) bu veriyi mobil cihazlara uygun şekilde görüntüler.

Aşağıdaki HTML ve CSS örneği, bir web sayfasının mobil cihazlarda nasıl farklı görünebileceğini göstermektedir. Python backend'iniz bu HTML'i dinamik olarak üretebilir veya bir şablon motoru aracılığıyla sunabilir.

      
      
      
      
          
          
          
          
      
      
          

              

                  
Mobil Uyumlu Web Sayfası Başlığı
              
              

                  
Bu paragraf, ekran boyutuna göre farklı görünecektir. Büyük ekranlarda standart, küçük ekranlarda daha küçük yazı tipine sahip olacaktır. Python, bu içeriği dinamik olarak sağlayarak, web uygulamanızın farklı cihazlarda uyumlu olmasını destekler.
                  
Python'ın backend'deki rolü, veri işleme, API oluşturma ve bu HTML'i tarayıcıya gönderme gibi konularda yatar. Frontend (HTML/CSS) ise bu veriyi kullanıcıya göstermek için media query gibi teknikleri kullanarak responsive bir deneyim sunar.
              
          
      
      
    

Görüldüğü üzere, Python doğrudan CSS yazmasa da, mobil uyumlu bir web deneyimi sunan uygulamaların altyapısını oluşturmada kilit rol oynar. Python ile sağlam bir backend oluşturarak, frontend geliştiricilerinin media query gibi tekniklerle daha esnek ve responsive kullanıcı arayüzleri tasarlamalarına olanak tanırsınız.

Python ile İlk Adımınızı Attınız: Şimdi Sıra Sizde!

Tebrikler! "Python basics - Day 01" kapsamında, Python programlamanın temel kavramlarını, sözdizimini, değişkenleri, veri tiplerini, operatörleri, kullanıcı etkileşimini, koşullu ifadeleri ve döngüleri başarıyla öğrendiniz. Ayrıca, listeler ve tuple'lar gibi temel veri yapılarına göz attık ve Python kodunuzu daha iyi hale getirecek en iyi uygulamaları ve ipuçlarını ele aldık. İlk "Merhaba Dünya!" programınızdan, karar verme mekanizmalarına ve tekrar eden görevleri otomatikleştirmeye kadar, programlamanın temel yapı taşlarını inşa ettiniz.

Bu makalede edindiğiniz bilgiler, Python yolculuğunuzda sağlam bir temel oluşturacaktır. Ancak, gerçek öğrenme pratik yaparak gerçekleşir. Bol bol kod yazmaktan, küçük projeler geliştirmekten, hata yapmaktan ve bu hatalardan ders çıkarmaktan çekinmeyin. İnternet, Python kaynakları açısından çok zengindir; çevrimiçi dersler, dokümantasyonlar, forumlar ve açık kaynak projeler, bilgi birikiminizi derinleştirmek için harika fırsatlar sunar. Unutmayın, her ustalık, ilk adımdan sonra gelen binlerce pratikle kazanılır. Şimdi kendi projelerinizi başlatma ve Python'ın sunduğu sınırsız olasılıkları keşfetme zamanı! Başarılar dileriz.

Sıkça Sorulan Sorular

Python öğrenmek ne kadar sürer?

Python'ın temellerini kavramak ve basit uygulamalar yazabilecek seviyeye gelmek, kişinin öğrenme hızına ve pratik yapma sıklığına bağlı olarak birkaç hafta ile birkaç ay arasında değişebilir. Ancak, ileri düzey konuları (web geliştirme, veri bilimi, makine öğrenimi vb.) öğrenmek ve uzmanlaşmak yıllar süren sürekli pratik ve öğrenme gerektirebilir. İlk adımı atmak en önemlisidir.

Hangi işletim sistemlerinde Python kullanabilirim?

Python, platformdan bağımsız bir dildir ve Windows, macOS ve Linux gibi popüler tüm işletim sistemlerinde sorunsuz bir şekilde çalışır. Python'ı resmi web sitesinden indirip kurabilir veya bazı Linux dağıtımlarında olduğu gibi ön yüklü olarak bulabilirsiniz.

Python ile neler yapabilirim?

Python ile yapabilecekleriniz neredeyse sınırsızdır:

• Web Geliştirme: Django, Flask gibi çerçevelerle dinamik web siteleri ve web uygulamaları geliştirebilirsiniz.
• Veri Bilimi ve Yapay Zeka: NumPy, Pandas, Scikit-learn, TensorFlow, Keras gibi kütüphanelerle veri analizi, makine öğrenimi ve derin öğrenme modelleri oluşturabilirsiniz.
• Otomasyon ve Scripting: Tekrarlayan görevleri otomatikleştiren betikler yazabilir, sistem yönetimi görevlerini kolaylaştırabilirsiniz.
• Masaüstü Uygulamaları: PyQt, Tkinter gibi kütüphanelerle grafik arayüzlü masaüstü uygulamaları geliştirebilirsiniz.
• Oyun Geliştirme: Pygame gibi kütüphanelerle basit 2D oyunlar yapabilirsiniz.

Python öğrenirken yapılan yaygın hatalar nelerdir?

Yeni başlayanların sıkça yaptığı hatalar şunlardır:

• Girinti Hataları (IndentationError): Python'da kod blokları girintilerle belirlendiği için, yanlış girintileme sıkça karşılaşılan bir hatadır.
• Veri Tipi Uyuşmazlıkları: Özellikle input()'tan alınan string değerleri sayısal işlemlerde kullanmaya çalışmak ve int() veya float() ile dönüştürmeyi unutmak.
• Değişken İsimlendirme Hataları: Ayrılmış kelimeleri kullanmak veya büyük/küçük harf farklılıklarını göz ardı etmek.
• Sonsuz Döngüler: while döngüsünde koşulu değiştiren bir mekanizma eklemeyi unutarak sonsuz döngüye girmek.
• Dokümantasyon Okumamak: Hata mesajlarını veya fonksiyonların nasıl kullanıldığını öğrenmek için Python dokümantasyonunu okumaması.

Sanal ortamlar neden önemlidir?

Sanal ortamlar, farklı Python projelerinin birbirlerinin kütüphane bağımlılıklarını etkilemesini önlemek için kritik öneme sahiptir. Her proje için izole bir ortam oluşturarak, bir projenin kullandığı bir kütüphane versiyonunun başka bir projenin ihtiyaç duyduğu farklı bir versiyonla çakışmasını engellersiniz. Bu, geliştirme ortamınızı temiz ve yönetilebilir tutar.