Çerezler
Bu web sitesi sizlere daha iyi hizmet verebilmek için çerezleri kullanır.
Python'ın standart kütüphanesinin bir parçası olan math modülü, temel ve gelişmiş matematiksel fonksiyonlara erişim sağlar. Bu modül, bilimsel hesaplamalar, mühendislik uygulamaları ve karmaşık matematiksel problemlerin çözümü için vazgeçilmez bir araçtır. math modülü, çoğu durumda kayan noktalı sayılar (float) üzerinde işlem yapmak üzere tasarlanmıştır ve sabitler, trigonometrik fonksiyonlar, logaritmik fonksiyonlar, üs alma işlemleri ve daha fazlasını içerir.
math modülünü kullanmak için öncelikle onu Python programınıza dahil etmeniz gerekmektedir. Bu işlem, genellikle dosyanın başında import anahtar kelimesi kullanılarak yapılır. Modül dahil edildikten sonra, içerdiği fonksiyonlara ve sabitlere math. öneki ile erişilir.
import math
# Bir fonksiyona erişim
sonuc = math.sqrt(25)
# Bir sabite erişim
pi_degeri = math.pi
Yukarıdaki sözdizimi, math modülünün nasıl kullanılacağına dair temel prensipleri ortaya koymaktadır. Her bir bileşenin işlevi aşağıdaki gibidir:
import math: Bu ifade, Python'a math adlı modülü yüklemesini söyler. Modül yüklendikten sonra, içinde tanımlı tüm fonksiyonlar, sınıflar ve değişkenler programınızda kullanılabilir hale gelir.
math.fonksiyon_adı(argümanlar): Modül içindeki bir fonksiyona erişmek için kullanılır. math. öneki, fonksiyonun math modülüne ait olduğunu belirtir ve aynı ada sahip diğer fonksiyonlarla olası ad çakışmalarını önler. Örneğin, math.sqrt(25) ifadesi 25'in karekökünü hesaplar.
math.sabit_adı: Modül içinde tanımlanmış matematiksel sabitlere erişmek için kullanılır. Örneğin, math.pi sabiti pi (π) değerini, math.e sabiti Euler sayısını (e) temsil eder.
Aşağıdaki örnekler, math modülünün çeşitli fonksiyonlarının gerçek dünya senaryolarında nasıl kullanılabileceğini göstermektedir.
Örnek 1: Temel Sabitler ve Karekök Hesaplama
import math
# Pi ve Euler sabitlerini kullanma
print(f"Pi değeri: {math.pi}")
print(f"e değeri: {math.e}")
# Bir sayının karekökünü bulma
sayi = 144
karekok = math.sqrt(sayi)
print(f"{sayi}'nin karekökü: {karekok}")
# Bir sayının üssünü alma (2^3)
us_alma = math.pow(2, 3)
print(f"2 üzeri 3: {us_alma}")
Bu örnek, math.pi ve math.e gibi sabitlerin nasıl kullanıldığını ve math.sqrt() ile bir sayının karekökünün, math.pow() ile de bir sayının üssünün nasıl hesaplandığını göstermektedir.
Örnek 2: Trigonometrik Fonksiyonlar
import math
# Açı değerini radyana çevirme (trigonometrik fonksiyonlar radyan bekler)
derece = 90
radyan = math.radians(derece)
print(f"{derece} derece radyan olarak: {radyan}")
# Sinüs, Kosinüs ve Tanjant hesaplama
sinus_degeri = math.sin(radyan)
cosinus_degeri = math.cos(radyan)
tanjant_degeri = math.tan(radyan)
print(f"sin({derece}°): {sinus_degeri}")
print(f"cos({derece}°): {cosinus_degeri}")
print(f"tan({derece}°): {tanjant_degeri}")
Bu örnek, math.radians() fonksiyonunun dereceleri radyanlara dönüştürmek için nasıl kullanıldığını ve ardından math.sin(), math.cos(), math.tan() gibi trigonometrik fonksiyonların nasıl uygulandığını göstermektedir.
Örnek 3: Logaritmik ve Tavan/Taban Fonksiyonları
import math
# Doğal logaritma (ln) ve 10 tabanında logaritma (log10)
sayi_log = 100
dogal_log = math.log(sayi_log)
taban10_log = math.log10(sayi_log)
taban2_log = math.log2(sayi_log) # Python 2.6 ve sonrası
print(f"{sayi_log}'un doğal logaritması: {dogal_log}")
print(f"{sayi_log}'un 10 tabanında logaritması: {taban10_log}")
print(f"{sayi_log}'un 2 tabanında logaritması: {taban2_log}")
# Tavan (ceil) ve Taban (floor) değerleri
ondalikli_sayi = 4.7
tavan_degeri = math.ceil(ondalikli_sayi)
taban_degeri = math.floor(ondalikli_sayi)
print(f"{ondalikli_sayi}'nin tavan değeri: {tavan_degeri}")
print(f"{ondalikli_sayi}'nin taban değeri: {taban_degeri}")
Bu örnek, math.log(), math.log10(), math.log2() fonksiyonlarının farklı tabanlarda logaritma hesaplamak için kullanılışını ve math.ceil() ile bir sayıyı yukarı, math.floor() ile aşağı tam sayıya yuvarlamanın nasıl yapıldığını açıklamaktadır.
Kayan Noktalı Sayılar (float): math modülündeki fonksiyonların çoğu, kayan noktalı sayılarla (float) çalışmak üzere tasarlanmıştır. Tam sayı (int) argümanları genellikle otomatik olarak kayan noktalı sayılara dönüştürülür.
Açı Birimleri: Trigonometrik fonksiyonlar (sin, cos, tan vb.) açıları radyan cinsinden bekler. Derece cinsinden bir açıyı kullanmak için math.radians() fonksiyonunu kullanarak önce radyanlara dönüştürmeniz gerekmektedir.
Hata Yönetimi: Geçersiz argümanlar (örneğin, negatif bir sayının karekökü math.sqrt(-1)) ValueError hatasına neden olabilir. Bu tür durumları ele almak için uygun hata yönetimi (try-except blokları) kullanılmalıdır.
math.pow() ve ** Operatörü: Python'da üs alma işlemi için hem math.pow() fonksiyonu hem de ** operatörü bulunur. math.pow() her zaman kayan noktalı bir sonuç dönerken, ** operatörü, işlenenlerin türüne bağlı olarak bir tam sayı veya kayan noktalı sonuç döndürebilir.
math.fabs() ve abs(): Mutlak değer almak için math.fabs() ve yerleşik abs() fonksiyonları mevcuttur. math.fabs() her zaman kayan noktalı bir sonuç dönerken, abs() işlenenle aynı türde bir sonuç döner.
Python, tarih ve saat verilerini işlemek için güçlü ve esnek bir modül olan datetime modülünü sunar. Bu modül, tarihleri, saatleri veya her ikisini birden temsil eden nesnelerle çalışmayı kolaylaştırır. Bir uygulamanın olayları zaman damgasıyla kaydetmesi, randevuları planlaması veya belirli bir zaman dilimindeki verileri analiz etmesi gerektiğinde, datetime modülü temel bir araç haline gelir.
datetime modülü, farklı ihtiyaçlar için çeşitli sınıflar sunar. En yaygın kullanılanları şunlardır:
date: Yıl, ay ve gün bilgilerini içerir.
time: Saat, dakika, saniye ve mikrosaniye bilgilerini içerir.
datetime: Hem tarih hem de saat bilgilerini içerir.
timedelta: İki tarih veya saat arasındaki farkı temsil eder.
Bu sınıfları kullanmak için öncelikle modülün içe aktarılması gerekir:
from datetime import date, time, datetime, timedeltaHer bir sınıfın temel kullanımını ve nesne oluşturma yöntemlerini inceleyelim:
date SınıfıBir date nesnesi oluşturmak için date(yıl, ay, gün) yapısı kullanılır. Yıl dört haneli, ay 1-12 arası, gün 1-31 arası bir değer olmalıdır.
from datetime import date
bugun = date(2023, 10, 26)
print(bugun)
# Çıktı: 2023-10-26Mevcut tarihi almak için date.today() metodu kullanılır.
from datetime import date
bugun_an = date.today()
print(f"Bugünün tarihi: {bugun_an}")
# Örnek Çıktı: Bugünün tarihi: 2023-10-26time SınıfıBir time nesnesi oluşturmak için time(saat, dakika, saniye, mikrosaniye) yapısı kullanılır. Mikrosaniye isteğe bağlıdır. Saat 0-23, dakika 0-59, saniye 0-59, mikrosaniye 0-999999 aralığında olmalıdır.
from datetime import time
su_an_saat = time(14, 30, 0, 500000) # 14:30:00.500000
print(su_an_saat)
# Çıktı: 14:30:00.500000datetime SınıfıHem tarih hem de saat bilgilerini içeren en yaygın kullanılan sınıftır. Bir datetime nesnesi oluşturmak için datetime(yıl, ay, gün, saat, dakika, saniye, mikrosaniye) yapısı kullanılır. Saat, dakika, saniye ve mikrosaniye parametreleri isteğe bağlıdır.
from datetime import datetime
belirli_zaman = datetime(2023, 10, 26, 15, 45, 30)
print(belirli_zaman)
# Çıktı: 2023-10-26 15:45:30Mevcut tarih ve saati almak için datetime.now() metodu kullanılır.
from datetime import datetime
su_an = datetime.now()
print(f"Şu anki tarih ve saat: {su_an}")
# Örnek Çıktı: Şu anki tarih ve saat: 2023-10-26 15:45:30.123456timedelta Sınıfıİki date, time veya datetime nesnesi arasındaki farkı temsil eder. Ayrıca, bir tarih veya saate belirli bir süre eklemek veya çıkarmak için de kullanılabilir.
from datetime import datetime, timedelta
bugun = datetime.now()
gelecek_hafta = bugun + timedelta(weeks=1)
gecen_ay = bugun - timedelta(days=30)
print(f"Bugün: {bugun}")
print(f"Gelecek hafta: {gelecek_hafta}")
print(f"Geçen ay: {gecen_ay}")strftime)strftime() metodu, datetime nesnelerini belirli bir formatta string'e dönüştürmek için kullanılır. Format kodları, tarih ve saat bileşenlerini temsil eder.
from datetime import datetime
simdi = datetime.now()
print(f"Varsayılan format: {simdi}") # Örnek: 2023-10-26 15:45:30.123456
# Özel formatlama
formatli_tarih_saat = simdi.strftime("%Y-%m-%d %H:%M:%S")
print(f"Formatlı (YYYY-MM-DD HH:MM:SS): {formatli_tarih_saat}") # Örnek: 2023-10-26 15:45:30
formatli_tarih_turkce = simdi.strftime("%d %B %Y, %A")
print(f"Formatlı (DD Ay YYYY, Gün): {formatli_tarih_turkce}") # Örnek: 26 Ekim 2023, Perşembe
formatli_saat_am_pm = simdi.strftime("%I:%M %p")
print(f"Formatlı (HH:MM AM/PM): {formatli_saat_am_pm}") # Örnek: 03:45 PMYaygın strftime format kodları:
%Y: Dört haneli yıl (örn. 2023)
%m: İki haneli ay (01-12)
%d: İki haneli gün (01-31)
%H: 24 saat formatında saat (00-23)
%M: İki haneli dakika (00-59)
%S: İki haneli saniye (00-59)
%f: Mikrosaniye (000000-999999)
%A: Haftanın tam adı (örn. Perşembe)
%B: Ayın tam adı (örn. Ekim)
%a: Haftanın kısa adı (örn. Per)
%b: Ayın kısa adı (örn. Eki)
%j: Yılın günü (001-366)
%w: Haftanın günü (0 Pazar, 6 Cumartesi)
%x: Yerel tarih formatı
%X: Yerel saat formatı
%c: Yerel tarih ve saat formatı
%I: 12 saat formatında saat (01-12)
%p: AM/PM göstergesi
strptime)strptime() metodu, belirli bir formatta string bir ifadeyi datetime nesnesine dönüştürmek için kullanılır. Bu, özellikle dış kaynaklardan alınan tarih verilerini işlerken önemlidir.
from datetime import datetime
tarih_string = "26-10-2023 16:00:00"
format_string = "%d-%m-%Y %H:%M:%S"
donusturulen_tarih = datetime.strptime(tarih_string, format_string)
print(f"String'den dönüştürülen datetime nesnesi: {donusturulen_tarih}")
# Çıktı: String'den dönüştürülen datetime nesnesi: 2023-10-26 16:00:00
# Farklı bir format
diger_tarih_string = "2023/10/26 4:00 PM"
diger_format = "%Y/%m/%d %I:%M %p"
donusturulen_tarih_2 = datetime.strptime(diger_tarih_string, diger_format)
print(f"İkinci örnek: {donusturulen_tarih_2}")
# Çıktı: İkinci örnek: 2023-10-26 16:00:00strptime metodunda kullanılan format string'in, dönüştürülecek string ile tam olarak eşleşmesi gerektiğini unutmamak önemlidir; aksi takdirde bir ValueError hatası alınır.
datetime nesneleri, standart karşılaştırma operatörleri (<, >, <=, >=, ==, !=) kullanılarak kolayca karşılaştırılabilir.
from datetime import datetime
simdi = datetime.now()
gelecek_zaman = datetime(2024, 1, 1, 0, 0, 0) # Yeni Yıl
gecmis_zaman = datetime(2023, 1, 1, 0, 0, 0) # Geçen Yıl Başlangıcı
print(f"Şimdi < Gelecek Zaman: {simdi < gelecek_zaman}")
print(f"Şimdi > Geçmiş Zaman: {simdi > gecmis_zaman}")
print(f"Gelecek Zaman == Geçmiş Zaman: {gelecek_zaman == gecmis_zaman}")Zaman Dilimleri (Timezones): datetime modülü varsayılan olarak zaman dilimi bilgisini içermez (naive datetime nesneleri). Zaman dilimi farklarını yönetmek için pytz gibi üçüncü taraf kütüphaneler veya Python 3.9 ve sonrası için zoneinfo modülü kullanılması önerilir.
Performans: Büyük ölçekli zaman serisi işlemleri veya çok sayıda tarih hesaplaması yapılıyorsa, pandas kütüphanesi gibi daha optimize edilmiş araçlar değerlendirilebilir.
Hata Yönetimi: strptime() kullanırken, geçersiz bir tarih string'i veya uyumsuz bir format verilirse ValueError hatası fırlatılır. Bu durumları try-except blokları ile yönetmek önemlidir.
Modül İçe Aktarımı: Genellikle from datetime import datetime, date, time, timedelta şeklinde belirli sınıfları içe aktarmak daha yaygındır. Ancak tüm modülü import datetime olarak içe aktarıp datetime.datetime.now() gibi kullanmak da mümkündür.
Python programlama dili, kodun yeniden kullanılabilirliğini ve projelerin düzenini sağlamak amacıyla modül kavramını benimsemiştir. Modüller, Python kodunun organize edilmiş birimleridir ve fonksiyonlar, sınıflar, değişkenler gibi yapıları içerebilir. Bu yaklaşım, büyük ölçekli uygulamaların geliştirilmesini kolaylaştırır, kodu daha okunabilir hale getirir ve hata ayıklama sürecini optimize eder. Bir modül, esasen .py uzantılı bir dosyadır ve başka Python programları tarafından içe aktarılarak kullanılabilir. Bu rehber, Python dilinde modüllerin nasıl tanımlandığını, nasıl içe aktarıldığını ve etkin bir şekilde nasıl kullanıldığını adım adım açıklayacaktır.
Python'da bir modülü veya modül içindeki belirli bileşenleri içe aktarmak için çeşitli sözdizimleri mevcuttur. Her bir sözdizimi, farklı kullanım senaryolarına hizmet eder.
Tüm modülü içe aktarma:
import module_nameModülü bir takma ad (alias) ile içe aktarma:
import module_name as alias_nameModülden belirli nesneleri içe aktarma:
from module_name import object_name_1, object_name_2Modülden belirli bir nesneyi takma ad ile içe aktarma:
from module_name import object_name as alias_nameModüldeki tüm nesneleri içe aktarma (önerilmez):
from module_name import *import module_name: Bu ifade, belirtilen modülün tamamını mevcut kapsam içine alır. Modül içindeki fonksiyonlara, sınıflara veya değişkenlere erişmek için her zaman modül adını önek olarak kullanmak gerekir. Örneğin, math modülündeki sqrt fonksiyonuna math.sqrt() şeklinde erişilir.
import module_name as alias_name: Bu yöntem, özellikle uzun modül adlarına sahip modüller için veya farklı modüllerden aynı isimde nesneler içe aktarılırken isim çakışmalarını önlemek amacıyla kullanılır. Modüle daha kısa veya daha açıklayıcı bir takma ad verilir. Kullanım örneği: alias_name.object_name.
from module_name import object_name_1, object_name_2: Bu sözdizimi, bir modülün tamamını değil, yalnızca belirli fonksiyonlarını, sınıflarını veya değişkenlerini içe aktarır. İçe aktarılan nesneler doğrudan kendi isimleriyle kullanılabilir; modül adını önek olarak kullanmaya gerek kalmaz. Bu, kodun daha kısa ve okunabilir olmasını sağlayabilir.
from module_name import object_name as alias_name: Bu, belirli bir nesneyi içe aktarırken ona bir takma ad atamanın yoludur. Özellikle içe aktarılan nesnenin adı mevcut kapsamdaki başka bir isimle çakışıyorsa veya daha kısa bir isimle kullanılmak isteniyorsa faydalıdır.
from module_name import *: Bu ifade, belirtilen modüldeki tüm genel nesneleri (alt çizgi ile başlamayanlar) mevcut kapsam içine aktarır. Kodun kısalmasını sağlasa da, isim çakışmalarına (namespace pollution) neden olabileceği ve kodun okunabilirliğini azaltabileceği için genellikle önerilmez. Hangi nesnelerin içe aktarıldığını açıkça görmek zorlaşır.
math Modülünü KullanmaBu örnek, Python'ın yerleşik math modülünü kullanarak basit matematiksel işlemlerin nasıl gerçekleştirileceğini gösterir.
import math
# Pi sayısına erişim
print(f"Pi sayısı: {math.pi}")
# Karekök hesaplama
sayi = 16
karekok = math.sqrt(sayi)
print(f"{sayi}'nin karekökü: {karekok}")
# Faktöriyel hesaplama
fakt = math.factorial(5)
print(f"5'in faktöriyeli: {fakt}")random Modülünü Takma Ad ile Kullanmarandom modülünü rnd takma adıyla içe aktararak rastgele sayı üretimini gösteren bir örnektir.
import random as rnd
# 1 ile 100 arasında rastgele bir tam sayı üretme
rastgele_sayi = rnd.randint(1, 100)
print(f"Üretilen rastgele sayı: {rastgele_sayi}")
# Rastgele bir eleman seçme
liste = ["elma", "armut", "kiraz", "muz"]
secilen_meyve = rnd.choice(liste)
print(f"Seçilen meyve: {secilen_meyve}")datetime Modülünden Belirli Nesneleri İçe Aktarmadatetime modülünden sadece date ve timedelta sınıflarını içe aktararak mevcut tarih ve gelecekteki bir tarihi hesaplama örneği.
from datetime import date, timedelta
# Bugünün tarihini alma
bugun = date.today()
print(f"Bugünün tarihi: {bugun}")
# 7 gün sonraki tarihi hesaplama
gelecek_tarih = bugun + timedelta(days=7)
print(f"7 gün sonraki tarih: {gelecek_tarih}")Bu örnek, kendi .py dosyanızı (modülünüzü) oluşturup başka bir Python betiğinde nasıl kullanacağınızı gösterir.
İlk olarak, my_module.py adında bir dosya oluşturalım:
# my_module.py
def selamla(isim):
"""Belirtilen ismi selamlayan bir fonksiyon."""
return f"Merhaba, {isim}!"
def topla(a, b):
"""İki sayıyı toplayan bir fonksiyon."""
return a + b
Şimdi bu modülü main_app.py adında başka bir dosyada kullanalım (aynı dizinde olmalılar):
# main_app.py
import my_module
# my_module'deki selamla fonksiyonunu kullanma
mesaj = my_module.selamla("Dünya")
print(mesaj)
# my_module'deki topla fonksiyonunu kullanma
sonuc = my_module.topla(10, 20)
print(f"Toplam: {sonuc}")
# Belirli bir fonksiyonu doğrudan içe aktarma
from my_module import selamla
print(selamla("Python"))İsim Çatışmaları (Namespace Pollution): from module import * ifadesi, modüldeki tüm nesneleri doğrudan mevcut ad alanına getirir. Bu, kendi kodunuzdaki değişken veya fonksiyon isimleriyle çakışmalara yol açabilir ve hatalara neden olabilir. Bu nedenle, bu kullanım genellikle kaçınılması gereken bir pratiktir.
Modül Arama Yolu (sys.path): Python, import ifadesiyle bir modül ararken belirli dizinlere bakar. Bu dizinler sys.path listesinde bulunur. Kendi modüllerinizin bulunabilmesi için ya mevcut çalışma dizininde olmaları ya da sys.path'e eklenmiş bir dizinde yer almaları gerekir.
Göreceli İçe Aktarmalar (Relative Imports): Büyük projelerde, bir paketin içindeki alt modüller arasında içe aktarma yaparken göreceli içe aktarmalar (örneğin, from . import other_module veya from .. import parent_module) kullanılır. Bu, kodun taşınabilirliğini artırır.
Modül Yeniden Yükleme: Bir modülü değiştirdikten sonra, Python yorumlayıcısını yeniden başlatmadan değişiklikleri görmek için importlib.reload(module_name) kullanılabilir. Ancak bu, genellikle geliştirme aşamasında kullanılır ve üretim kodunda nadiren ihtiyaç duyulur.
Modül Adlandırma Kuralları: Python topluluğunda kabul görmüş adlandırma standartlarına (PEP 8) uymak önemlidir. Modül adları genellikle küçük harflerle ve alt çizgilerle ayrılmış kelimelerle (snake_case) yazılır (örneğin, my_utility_module.py).
Döngüsel İçe Aktarmalar (Circular Imports): İki veya daha fazla modülün birbirini doğrudan veya dolaylı olarak içe aktarması durumunda döngüsel içe aktarma oluşur. Bu durum, çalışma zamanı hatalarına yol açabilir ve kodun anlaşılmasını zorlaştırır. Tasarımda bu tür döngülerden kaçınılmalıdır.
Python'da iterators (yineleyiciler), verimli ve bellek dostu bir şekilde veri koleksiyonları üzerinde gezinmek için temel bir mekanizma sunar. Bu kavram, listeler, demetler, dizeler gibi standart koleksiyon türlerinin ve özel veri yapılarının nasıl döngülenebildiğini anlamak için hayati öneme sahiptir. Bir iterator, bir dizi veri üzerinde adım adım ilerlemeyi sağlayan bir nesnedir ve Python'ın for döngülerinin arkasındaki gücü temsil eder. Bu makale, Python iterators kavramını, temel sözdizimini ve pratik uygulama yöntemlerini detaylı bir şekilde açıklayacaktır.
Python'da bir iterator oluşturmak ve kullanmak için temel olarak iki ana fonksiyon ve özel metotlar bulunur:
iter(): Bir nesneden bir iterator elde etmek için kullanılır.
next(): Bir iteratörden bir sonraki öğeyi almak için kullanılır.
Kendi iterator'ınızı tanımlamak istediğinizde, sınıfınızda aşağıdaki özel metotları (`dunder metotlar`) uygulamanız gerekmektedir:
__iter__(self): Bu metot, bir iteratör nesnesi döndürmelidir. Genellikle, bu metot çağrıldığında `self` (nesnenin kendisi) döndürülür.
__next__(self): Bu metot, bir sonraki öğeyi döndürmelidir. Tüm öğeler tüketildiğinde, StopIteration istisnasını yükseltmelidir.
Bir iterable (yinelenebilir) nesne, üzerinde döngü yapılabilecek herhangi bir nesnedir; yani, bu nesneden bir iterator elde edilebilir. Listeler, demetler, dizeler ve sözlükler Python'daki yaygın yinelenebilir nesnelerdir. Bu nesneler, __iter__() metodunu uygularlar ve bu metot çağrıldığında kendilerinden bir iterator nesnesi döndürürler.
Bir iterator ise, bir iterable nesneden elde edilen ve durumu hatırlayabilen bir nesnedir. Iterator nesnesinin __next__() metodu vardır. Bu metot her çağrıldığında, iterator'ın temsil ettiği veri dizisinden bir sonraki öğeyi verir. Dizide başka öğe kalmadığında, __next__() metodu otomatik olarak StopIteration istisnasını yükseltir. Bu istisna, döngü mekanizmalarına (örneğin for döngüsüne) öğelerin tükendiğini bildirir.
for döngüsü, perde arkasında bu mekanizmayı kullanır: Öncelikle, döngü yapılacak nesne üzerinde iter() fonksiyonunu çağırarak bir iterator elde eder. Ardından, her döngü adımında bu iterator üzerinde next() fonksiyonunu çağırır. StopIteration istisnası yükseltildiğinde döngüyü sonlandırır.
Aşağıdaki örnekler, Python iterators'ın nasıl çalıştığını ve nasıl kendi iterator'ınızı oluşturabileceğinizi göstermektedir.
Bir liste üzerinde iter() ve next() fonksiyonlarının doğrudan kullanımını inceleyelim.
# Bir iterable liste tanımlayın
my_list = [10, 20, 30, 40]
# Listeden bir iterator elde edin
my_iterator = iter(my_list)
# next() fonksiyonunu kullanarak öğeleri tek tek alın
print(next(my_iterator)) # Çıktı: 10
print(next(my_iterator)) # Çıktı: 20
print(next(my_iterator)) # Çıktı: 30
print(next(my_iterator)) # Çıktı: 40
# Tüm öğeler tüketildiğinde StopIteration istisnası yükselir
# print(next(my_iterator)) # Hata: StopIteration
Belirli bir aralıktaki sayıları üreten özel bir iterator sınıfı tanımlayalım.
class MyRangeIterator:
def __init__(self, start, end):
self.current = start
self.end = end
def __iter__(self):
# Iterator nesnesinin kendisini döndürür
return self
def __next__(self):
if self.current < self.end:
# Mevcut değeri döndür ve bir sonraki adıma hazırla
value = self.current
self.current += 1
return value
else:
# Aralık bittiğinde StopIteration yükselt
raise StopIteration
# Kendi iterator sınıfımızı kullanarak bir nesne oluşturalım
my_custom_range = MyRangeIterator(1, 5)
# for döngüsü ile iterator'ı kullanalım
print("For döngüsü ile:")
for num in my_custom_range:
print(num)
# Çıktı: 1 2 3 4
# Iterator bir kez tüketildikten sonra tekrar kullanılamaz (yeni bir nesne oluşturulmalı)
print("\nManuel next() ile (yeni iterator):")
my_custom_range_manual = MyRangeIterator(1, 3)
print(next(my_custom_range_manual)) # Çıktı: 1
print(next(my_custom_range_manual)) # Çıktı: 2
# print(next(my_custom_range_manual)) # Hata: StopIteration
Iterable ve Iterator Farkı: Bir iterable, üzerinde döngü yapılabilecek bir nesnedir (__iter__() metoduna sahiptir). Bir iterator ise, bu iterable'dan elde edilen ve bir sonraki öğeyi döndürme yeteneğine sahip olan (__next__() metoduna sahip) bir nesnedir. Her iterator bir iterable'dır, ancak her iterable bir iterator değildir.
Bellek Verimliliği: Iteratorlar, tüm veri kümesini belleğe yüklemek yerine, öğeleri talep edildiğinde birer birer ürettikleri için özellikle büyük veri kümeleriyle çalışırken bellek dostu bir çözüm sunar. Bu, "lazy evaluation" (tembel değerlendirme) prensibine dayanır.
StopIteration İstisnası: Bu istisna, bir iterator'ın tüm öğelerini tüketmesi durumunda __next__() metodu tarafından otomatik olarak yükseltilir. Bu, Python'daki döngü mekanizmalarının döngüyü güvenli bir şekilde sonlandırmasını sağlar.
Tek Kullanımlık Yapı: Çoğu iterator, öğeleri bir kez tükettikten sonra sıfırlanmaz ve tekrar kullanılamaz. Eğer aynı veri kümesi üzerinde tekrar döngü yapmak isterseniz, iterable nesneden yeni bir iterator elde etmeniz gerekir.
Generator'lar ile İlişkisi: Python'da generator'lar, iterator oluşturmanın daha basit ve kısa bir yoludur. yield anahtar kelimesi kullanılarak tanımlanan generator fonksiyonları veya generator ifadeleri, otomatik olarak bir iterator döndürür ve __iter__() ile __next__() metotlarını sizin yerinize yönetir.
Python programlama dilinde, veri koleksiyonlarını depolamak için çeşitli yapılar bulunur. En yaygın kullanılanlardan biri list olsa da, özellikle sayısal verilerle çalışırken bellek verimliliği ve performans açısından array modülü önemli bir alternatif sunar. Bu makale, Python'ın array modülünü kullanarak tip-belirli dizilerin nasıl oluşturulduğunu, yönetildiğini ve günlük programlama görevlerinde nasıl kullanılabileceğini teknik detaylarıyla açıklamaktadır.
array modülünü kullanmak için öncelikle bu modülün içe aktarılması gerekmektedir. Dizi oluşturma işlemi, dizinin depolayacağı veri tipini belirten bir "tip kodu" ve başlangıç elemanlarını içeren bir iterable nesne ile gerçekleştirilir.
from array import array
dizi_adi = array('tip_kodu', [eleman1, eleman2, ...])array modülünün temel yapısı iki ana bileşenden oluşur:
tip_kodu (Type Code): Bu tek karakterlik string, dizinin depolayacağı veri tipini belirtir. Her tip kodu, belirli bir C veri tipine karşılık gelir ve dizideki tüm elemanların bu tipte olmasını sağlar. Bu sayede bellek kullanımı optimize edilir. Yaygın kullanılan bazı tip kodları şunlardır:
'b': İşaretli küçük tam sayı (signed char)
'B': İşaretsiz küçük tam sayı (unsigned char)
'h': İşaretli kısa tam sayı (signed short)
'H': İşaretsiz kısa tam sayı (unsigned short)
'i': İşaretli tam sayı (signed int)
'I': İşaretsiz tam sayı (unsigned int)
'l': İşaretli uzun tam sayı (signed long)
'L': İşaretsiz uzun tam sayı (unsigned long)
'q': İşaretli uzun uzun tam sayı (signed long long) (Sadece belirli sistemlerde mevcuttur)
'Q': İşaretsiz uzun uzun tam sayı (unsigned long long) (Sadece belirli sistemlerde mevcuttur)
'f': Kayan nokta (float)
'd': Çift hassasiyetli kayan nokta (double)
iterable: Bu, dizinin başlangıç elemanlarını içeren bir koleksiyondur. Genellikle bir list kullanılır, ancak tuple veya başka bir iterable nesne de olabilir. Dizi oluşturulurken bu iterable içindeki elemanlar belirtilen tip_kodu'na dönüştürülür. Eğer eleman tipi, tip_kodu ile uyumlu değilse TypeError hatası alınır.
Aşağıdaki örnekler, Python array modülünün farklı senaryolarda nasıl kullanılabileceğini göstermektedir.
'i' tip kodu ile işaretli tam sayılardan oluşan bir dizi oluşturalım ve elemanlarına erişelim.
from array import array
# 'i' tip kodlu (işaretli tam sayı) bir dizi oluşturma
int_array = array('i', [1, 2, 3, 4, 5])
print("Oluşturulan Dizi:", int_array)
print("Dizinin Boyutu:", len(int_array))
# İndeks kullanarak elemanlara erişim
print("İlk Eleman:", int_array[0])
print("Son Eleman:", int_array[-1])
# Elemanı güncelleme
int_array[2] = 10
print("Güncellenmiş Dizi:", int_array)Kayan noktalı sayılar için 'f' tip kodunu kullanarak bir dizi oluşturalım.
from array import array
# 'f' tip kodlu (float) bir dizi oluşturma
float_array = array('f', [1.0, 2.5, 3.7, 4.2])
print("Float Dizi:", float_array)
# Eleman ekleme
float_array.append(5.9)
print("append() sonrası:", float_array)
# Eleman kaldırma
float_array.remove(2.5) # Değere göre kaldırır
print("remove() sonrası:", float_array)
# Yeni bir dizi ile genişletme
another_float_array = array('f', [6.1, 7.3])
float_array.extend(another_float_array)
print("extend() sonrası:", float_array)array nesneleri, özellikle büyük ikili veri setleriyle çalışırken doğrudan dosya işlemleri için de kullanılabilir.
from array import array
import os
# Bir dizi oluştur
data = array('i', [10, 20, 30, 40, 50])
file_name = "array_data.bin"
# Diziyi ikili dosyaya yazma
with open(file_name, 'wb') as f:
data.tofile(f)
print(f"Dizi '{file_name}' dosyasına yazıldı.")
# Dosyadan geri okuma
read_data = array('i') # Boş bir dizi oluştur
with open(file_name, 'rb') as f:
read_data.fromfile(f, len(data)) # Orijinal boyutu kadar oku
print("Dosyadan okunan dizi:", read_data)
# Dosyayı temizle
os.remove(file_name)
print(f"'{file_name}' dosyası silindi.")Bellek Verimliliği: array.array, list nesnelerine göre daha az bellek kullanır çünkü tüm elemanları aynı tipte tutar ve bu elemanlar arka planda kompakt bir C dizisi olarak depolanır. Büyük sayısal veri setleriyle çalışırken bu önemlidir.
Tip Kısıtlaması: array nesneleri yalnızca belirtilen tip_kodu'na uygun verileri depolayabilir. Farklı tiplerde eleman eklemeye çalışmak TypeError hatasına yol açar. Bu, list'in esnekliğine kıyasla bir kısıtlamadır.
Performans: Tip-belirli olması ve doğrudan bellek erişimine izin vermesi nedeniyle, özellikle sayısal işlemler ve dosya G/Ç (I/O) operasyonlarında array nesneleri list'lere göre daha hızlı performans sergileyebilir.
list ile Farkı: Python'da list, farklı veri tiplerini aynı anda barındırabilen genel amaçlı, dinamik bir dizi gibidir. array.array ise belirli bir veri tipine sıkı sıkıya bağlıdır ve genellikle büyük, homojen sayısal veri koleksiyonları için tercih edilir. Eğer esnekliğe ihtiyacınız varsa list kullanın; bellek ve performans kritikse ve verileriniz homojense array düşünün.
Modül İçe Aktarma: array modülü standart kütüphanenin bir parçasıdır ve ek kurulum gerektirmez. Kullanmadan önce from array import array veya import array şeklinde içe aktarmalısınız.
Diğer Operasyonlar: array nesneleri, append(), extend(), insert(), pop(), remove() gibi list'e benzer birçok yöntemi destekler. Ayrıca tofile(), fromfile(), tobytes(), frombytes() gibi ikili dosya ve bayt işlemleri için özel yöntemleri de vardır.
Python programlama dilinde, belirli bir aralıkta sayı dizileri oluşturmak ve özellikle döngülerde bu dizileri kullanmak için sıklıkla başvurulan temel yapı taşlarından biri range() fonksiyonudur. Bu fonksiyon, liste veya tuple gibi tüm sayıları bellekte tutmak yerine, gerektiğinde sayıları üreten bir "range nesnesi" döndürerek bellek verimliliği sağlar. Genellikle for döngüleriyle birlikte kullanılarak belirli sayıda tekrar eden işlemler gerçekleştirmek için idealdir.
range() fonksiyonunun üç farklı kullanım şekli bulunmaktadır:
range(stop)
range(start, stop)
range(start, stop, step)range() fonksiyonunun parametreleri şu anlamlara gelmektedir:
start (isteğe bağlı): Dizinin başlayacağı tam sayıyı belirtir. Eğer belirtilmezse, varsayılan değeri 0'dır.
stop (zorunlu): Dizinin biteceği tam sayıyı belirtir. Bu sayı, üretilen diziye dahil edilmez. Yani, dizi stop - 1 değerinde sona erer.
step (isteğe bağlı): Dizideki ardışık sayılar arasındaki artış miktarını belirtir. Eğer belirtilmezse, varsayılan değeri 1'dir. Negatif bir değer de olabilir, bu durumda dizi azalan sırada üretilir.
range(), bir iterable nesne döndürür, doğrudan bir liste değil. Bu nesne, üzerinde iterasyon yapılabilir ancak tüm elemanları aynı anda bellekte tutmaz.
Örnek 1: Tek Parametre Kullanımı (stop)
Bu kullanım, 0'dan başlayıp stop değerine kadar (hariç) bir dizi oluşturur.
# 0'dan 4'e kadar (5 hariç) sayılar üretir
for i in range(5):
print(i)
# Çıktı:
# 0
# 1
# 2
# 3
# 4Örnek 2: İki Parametre Kullanımı (start, stop)
Bu kullanım, start değerinden başlayıp stop değerine kadar (hariç) bir dizi oluşturur.
# 2'den 6'ya kadar (7 hariç) sayılar üretir
for i in range(2, 7):
print(i)
# Çıktı:
# 2
# 3
# 4
# 5
# 6Örnek 3: Üç Parametre Kullanımı (start, stop, step)
Bu kullanım, start değerinden başlayıp stop değerine kadar (hariç), step miktarı kadar artarak bir dizi oluşturur.
# 0'dan 10'a kadar (11 hariç), 2'şer artarak sayılar üretir
for i in range(0, 11, 2):
print(i)
# Çıktı:
# 0
# 2
# 4
# 6
# 8
# 10Örnek 4: Negatif step Kullanımı (Geriye Doğru Sayma)
step parametresine negatif bir değer verilerek azalan bir dizi oluşturulabilir. Bu durumda start değeri stop değerinden büyük olmalıdır.
# 10'dan 0'a kadar (0 hariç), 1'er azalarak sayılar üretir
for i in range(10, 0, -1):
print(i)
# Çıktı:
# 10
# 9
# 8
# 7
# 6
# 5
# 4
# 3
# 2
# 1Örnek 5: range Nesnesini Bir Listeye Dönüştürme
range nesnesinin içeriğini görmek veya bir liste olarak kullanmak isterseniz, list() fonksiyonunu kullanabilirsiniz.
# 0'dan 5'e kadar bir range nesnesi oluştur
my_range = range(5)
print(my_range)
# Range nesnesini listeye dönüştür
my_list = list(my_range)
print(my_list)
# Çıktı:
# range(0, 5)
# [0, 1, 2, 3, 4]range() fonksiyonu, kayan noktalı sayılar (float) ile çalışmaz. Yalnızca tam sayılar (integer) için geçerlidir.
stop parametresi daima üretilen dizinin dışında kalır. Bu, Python'daki birçok slicing ve aralık belirleme işlemine benzer bir davranıştır.
Büyük sayı aralıkları için bile range() kullanmak bellek açısından verimlidir, çünkü tüm sayıları belleğe yüklemez. Yalnızca o anki sayıyı ve bir sonraki sayıyı hesaplamak için gereken bilgiyi tutar.
range() tarafından döndürülen nesne, doğrudan bir liste olmasa da, len() fonksiyonu ile uzunluğu alınabilir ve üzerinde indeksleme yapılabilir (örneğin, my_range[0]).
Sonsuz döngüden kaçınmak için step değerinin doğru ayarlandığından emin olun. Özellikle negatif step kullanırken start ve stop değerlerinin mantıklı bir sıra izlemesi önemlidir (örneğin, azalan dizide start > stop).
Python'da fonksiyonlar, belirli bir görevi yerine getiren, yeniden kullanılabilir kod bloklarıdır. Bu yapısal elemanlar, kodun modülerliğini artırır, okunabilirliği iyileştirir ve aynı kod bloğunu birden fazla kez yazma ihtiyacını ortadan kaldırarak geliştirme sürecini hızlandırır. Fonksiyonlar, karmaşık problemleri daha küçük, yönetilebilir parçalara ayırmak için temel bir araçtır ve her programlama dilinde olduğu gibi Python'da da etkin kod yazımının vazgeçilmez bir parçasıdır.
Python'da bir fonksiyon tanımlamanın temel sözdizimi aşağıdaki gibidir:
def fonksiyon_adi(parametre1, parametre2=varsayilan_deger):
"""
Bu bir docstring'dir. Fonksiyonun ne iş yaptığını açıklar.
"""
# Fonksiyon gövdesi (işlemlerin yapıldığı yer)
if kosul:
islem1
else:
islem2
return deger
def: Python'da bir fonksiyon tanımlamak için kullanılan anahtar kelimedir. Her fonksiyon tanımı bu kelime ile başlar.
fonksiyon_adi: Fonksiyonunuza verdiğiniz isimdir. Fonksiyon isimleri, işlevlerini yansıtmalı ve snake_case (küçük harflerle ve kelimeler arasına alt çizgi konularak) kuralına uygun olmalıdır. Örneğin: veri_isleme, toplama_yap.
(parametre1, parametre2=varsayilan_deger): Fonksiyonun dışarıdan alacağı giriş değerlerini (argümanları) temsil eden parametre listesidir. Parantezler boş bırakılabilir (parametre almayan fonksiyonlar için), veya virgülle ayrılmış bir ya da daha fazla parametre içerebilir. Parametrelere varsayılan değerler atanabilir; bu durumda, fonksiyon çağrılırken bu parametreler için bir değer sağlanmazsa varsayılan değer kullanılır.
: (İki Nokta Üst Üste): Fonksiyon başlığının sonuna gelir ve fonksiyon gövdesinin başladığını belirtir.
"""Docstring""": Fonksiyonun hemen altında üç tırnak (tek veya çift) içinde yer alan isteğe bağlı bir dizedir. Bu, fonksiyonun ne işe yaradığını, aldığı parametreleri ve döndürdüğü değeri açıklayan bir belgeleme metnidir. Kodun anlaşılırlığını büyük ölçüde artırır ve help() fonksiyonu ile erişilebilir.
# Fonksiyon gövdesi: Fonksiyonun ana mantığını ve çalıştıracağı komutları içeren bloktur. Bu bloktaki tüm satırlar, def anahtar kelimesi ile aynı hizada başlayan satıra göre girintili (genellikle 4 boşluk) olmalıdır. Python'da girintileme, kod bloklarını tanımlamak için kullanılır ve sözdiziminin önemli bir parçasıdır.
return deger: Fonksiyonun çalışmasını sonlandıran ve çağıran yere bir değer döndüren anahtar kelimedir. Bir return ifadesi kullanıldığında, fonksiyonun yürütülmesi durur ve belirtilen değer geri döndürülür. Eğer bir return ifadesi kullanılmazsa veya boş bir return kullanılırsa, Python otomatik olarak None değerini döndürür.
Aşağıdaki örnekler, fonksiyonların Python'da nasıl tanımlandığını ve kullanıldığını göstermektedir.
Örnek 1: Parametre almayan ve değer döndürmeyen basit bir fonksiyon.
def selamla():
"""
Kullanıcıyı selamlayan basit bir fonksiyon.
"""
print("Merhaba, Python dünyasına hoş geldiniz!")
# Fonksiyonu çağırma
selamla()
Örnek 2: Parametre alan ve değer döndüren bir fonksiyon.
def topla(sayi1, sayi2):
"""
İki sayıyı toplayıp sonucu döndüren fonksiyon.
Args:
sayi1 (int/float): Toplanacak birinci sayı.
sayi2 (int/float): Toplanacak ikinci sayı.
Returns:
int/float: İki sayının toplamı.
"""
sonuc = sayi1 + sayi2
return sonuc
# Fonksiyonu çağırma ve döndürülen değeri kullanma
toplam_sonucu = topla(10, 5)
print(f"10 ve 5'in toplamı: {toplam_sonucu}")
farkli_toplam = topla(2.5, 7.3)
print(f"2.5 ve 7.3'ün toplamı: {farkli_toplam}")
Örnek 3: Varsayılan parametre değeri olan bir fonksiyon.
def hesapla_indirim(fiyat, indirim_orani=0.10):
"""
Belirtilen fiyata indirim uygulayarak yeni fiyatı döndüren fonksiyon.
Args:
fiyat (float): Ürünün orijinal fiyatı.
indirim_orani (float, optional): Uygulanacak indirim oranı. Varsayılan %10'dur.
Returns:
float: İndirimli fiyat.
"""
indirim_miktari = fiyat * indirim_orani
indirimli_fiyat = fiyat - indirim_miktari
return indirimli_fiyat
# Fonksiyonu varsayılan indirim oranıyla çağırma
urun_fiyati_1 = 100
yeni_fiyat_1 = hesapla_indirim(urun_fiyati_1)
print(f"100 TL'lik ürünün %10 indirimli fiyatı: {yeni_fiyat_1}")
# Fonksiyonu özel bir indirim oranıyla çağırma
urun_fiyati_2 = 250
yeni_fiyat_2 = hesapla_indirim(urun_fiyati_2, 0.25) # %25 indirim
print(f"250 TL'lik ürünün %25 indirimli fiyatı: {yeni_fiyat_2}")
Girintileme (Indentation): Python'da kod blokları (fonksiyon gövdeleri, döngüler, koşullu ifadeler) girintileme ile tanımlanır. Yanlış girintileme IndentationError hatasına yol açar.
return Anahtar Kelimesi: Bir fonksiyonun bir değer döndürmesini sağlar. Eğer bir fonksiyon return ifadesi içermiyorsa, otomatik olarak None döndürür. print() fonksiyonu ekrana çıktı verirken, return bir değeri fonksiyonun çağrıldığı yere geri verir.
Değişken Kapsamı (Scope): Fonksiyon içinde tanımlanan değişkenler yereldir ve yalnızca o fonksiyon içinde erişilebilirler. Fonksiyon dışında tanımlanan değişkenler ise globaldir ve fonksiyon içinde de erişilebilirler (ancak global anahtar kelimesi kullanılmadan doğrudan değiştirilemezler).
Fonksiyon İsimlendirme Kuralları: Fonksiyon isimleri genellikle küçük harflerle ve kelimeler arasına alt çizgi konularak yazılır (snake_case). Fonksiyonun amacını açıkça belirtmelidir.
Docstring Kullanımı: Her fonksiyon için açıklayıcı bir docstring yazmak iyi bir programlama pratiğidir. Bu, kodunuzu başkaları (veya gelecekteki siz) için daha anlaşılır hale getirir. help(fonksiyon_adi) komutu ile bu belgelere erişebilirsiniz.
Fonksiyon Çağırma: Bir fonksiyonu çalıştırmak için adını ve ardından parantezleri () kullanmanız gerekir (örneğin, selamla()). Parantezler olmadan sadece fonksiyon adını yazmak, fonksiyonun kendisine bir referans verir, onu çalıştırmaz.
Python, okunabilirliği ve sadeliği ile bilinen güçlü bir programlama dilidir. Birçok programlama görevinde tekrarlayan işlemler, döngüler aracılığıyla etkin bir şekilde gerçekleştirilir. Python'da, belirli bir dizi (liste, demet, dize, küme, sözlük veya diğer yinelenebilir nesneler) üzerinde yineleme yapmak için for döngüsü kullanılır. Bu makale, Python'daki for döngüsünün temel yapısını, kullanımını ve pratik örneklerini detaylı bir şekilde açıklamaktadır.
Python'da for döngüsünün genel sözdizimi aşağıdaki gibidir:
for eleman in yinelenebilir_nesne:
# Döngü bloğu
# Her yinelemede çalışacak kod buraya yazılır
# 'eleman' değişkeni her adımda yinelenebilir_nesnenin bir sonraki öğesini alır
Yukarıdaki sözdiziminde yer alan her bir bileşenin işlevi şöyledir:
for: Python'da bir döngü başlatmak için kullanılan anahtar kelimedir.
eleman: Her yinelemede, yinelenebilir_nesne'den alınan mevcut öğeyi temsil eden bir değişkendir. Bu değişkenin adı isteğe bağlıdır ve genellikle döngü içinde işlenecek öğenin anlamını yansıtır.
in: eleman değişkeninin hangi yinelenebilir_nesne içinde aranacağını belirtmek için kullanılan bir anahtar kelimedir.
yinelenebilir_nesne: Üzerinde yineleme yapılacak olan bir koleksiyon veya dizidir. Bu, bir list, tuple, string, set, dictionary veya özel olarak yinelenebilir hale getirilmiş herhangi bir nesne olabilir.
: (İki nokta üst üste): for döngüsü başlığının sonunu işaret eder ve döngü bloğunun başladığını belirtir.
Döngü bloğu (girintili kod): for döngüsünün her adımında çalıştırılacak kod satırlarıdır. Python'da kod blokları girintileme ile tanımlanır. Tüm döngü bloğu aynı seviyede girintili olmalıdır.
Aşağıdaki örnekler, for döngüsünün farklı senaryolarda nasıl kullanılabileceğini göstermektedir.
Örnek 1: Liste Öğeleri Üzerinde Yineleme
Bir liste içindeki her bir sayıyı ekrana yazdırma.
sayilar = [1, 2, 3, 4, 5]
for sayi in sayilar:
print(sayi)
Çıktı:
1
2
3
4
5
Örnek 2: Bir Dize Üzerinde Yineleme
Bir dizedeki her karakteri tek tek yazdırma.
kelime = "Python"
for karakter in kelime:
print(karakter)
Çıktı:
P
y
t
h
o
n
Örnek 3: range() Fonksiyonu ile Belirli Sayıda Yineleme
range() fonksiyonu, belirli bir aralıkta sayı dizileri oluşturmak için kullanılır ve for döngüleriyle sıkça tercih edilir.
# 0'dan 4'e kadar (5 dahil değil) sayılar
for i in range(5):
print(i)
Çıktı:
0
1
2
3
4
Örnek 4: Sözlük Öğeleri Üzerinde Yineleme
Bir sözlüğün anahtarları, değerleri veya hem anahtarları hem de değerleri üzerinde yineleme yapılabilir.
ayarlar = {"kullanici": "admin", "dil": "Türkçe", "tema": "koyu"}
print("Sözlük Anahtarları:")
for anahtar in ayarlar: # Varsayılan olarak anahtarları yineler
print(anahtar)
print("\nSözlük Değerleri:")
for deger in ayarlar.values():
print(deger)
print("\nSözlük Öğeleri (Anahtar-Değer çiftleri):")
for anahtar, deger in ayarlar.items():
print(f"{anahtar}: {deger}")
Çıktı:
Sözlük Anahtarları:
kullanici
dil
tema
Sözlük Değerleri:
admin
Türkçe
koyu
Sözlük Öğeleri (Anahtar-Değer çiftleri):
kullanici: admin
dil: Türkçe
tema: koyu
Örnek 5: enumerate() Fonksiyonu ile İndeks ve Değere Erişim
Bazen bir koleksiyonun öğeleri üzerinde yinelerken hem öğenin kendisine hem de indeksine ihtiyaç duyulur. enumerate() fonksiyonu bu durumu kolaylaştırır.
meyveler = ["elma", "muz", "çilek"]
for indeks, meyve in enumerate(meyveler):
print(f"{indeks}: {meyve}")
Çıktı:
0: elma
1: muz
2: çilek
Girintileme Önemlidir: Python'da kod blokları girintileme ile tanımlanır. for döngüsünün altına yazılan tüm kod satırlarının aynı girinti seviyesinde olması gerektiğini unutmayın. Yanlış girintileme IndentationError hatasına yol açacaktır.
Yinelenebilir Nesneler: for döngüsü sadece yinelenebilir (iterable) nesneler üzerinde çalışır. Sayılar veya boolean değerler gibi yinelenebilir olmayan nesneleri doğrudan for döngüsünde kullanamazsınız.
Döngü Kesme (break): Bir döngüyü belirli bir koşul sağlandığında tamamen sonlandırmak için break anahtar kelimesini kullanabilirsiniz.
Döngü Atlatma (continue): Bir döngünün mevcut yinelemesini atlayıp bir sonraki yinelemeye geçmek için continue anahtar kelimesini kullanabilirsiniz.
Performans: Büyük veri kümeleri üzerinde çalışırken, for döngüleri yerine list comprehension veya generator ifadelerini kullanmak performansı artırabilir. Ancak, temel kullanım için for döngüleri oldukça etkilidir.
Python programlama dilinde while döngüsü, belirli bir koşul doğru olduğu sürece bir kod bloğunu tekrar tekrar yürütmek için kullanılır. Bu döngü yapısı, bir işlemin ne zaman duracağının belirli bir sayı yerine bir koşula bağlı olduğu senaryolarda oldukça etkilidir. Kullanıcı girdisi beklenmesi, bir veri yapısındaki öğelerin işlenmesi veya bir oyun döngüsünün sürdürülmesi gibi durumlarda program akışını kontrol etmek için vazgeçilmez bir araçtır.
Bir while döngüsünün genel yapısı aşağıdaki gibidir:
while koşul:
# Koşul doğru olduğu sürece yürütülecek kod bloğu
# Döngü değişkenini güncelleyen ifadeler
else:
# Koşul yanlış olduğunda (ve break kullanılmadığında) yürütülecek kod bloğu
Bu yapıda:
while: Döngüyü başlatan anahtar kelimedir.
koşul: Her iterasyonun başında değerlendirilen bir boolean ifadedir. Bu koşul True olduğu sürece döngü devam eder.
: (İki nokta üst üste): Koşul ifadesinden sonra gelir ve döngü bloğunun başladığını belirtir.
Girintili Kod Bloğu: Koşul doğru olduğunda yürütülecek olan bir veya daha fazla satırdan oluşur. Python'da girinti (indentation) kod bloklarını tanımlamak için kullanılır.
else (İsteğe Bağlı): while döngüsüyle birlikte kullanılabilen isteğe bağlı bir bloktur. Döngü koşulu False olduğunda ve döngü break ifadesiyle sonlandırılmadığında yürütülür.
Aşağıdaki örnekler, while döngüsünün çeşitli kullanım senaryolarını göstermektedir.
Örnek 1: Basit Bir Sayıcı Döngüsü
Bu örnekte, bir değişkenin değeri belirli bir sayıya ulaşana kadar döngüyü sürdürüyoruz.
sayac = 0
while sayac < 5:
print(f"Sayı: {sayac}")
sayac += 1 # Sayacı her döngüde bir artırıyoruz
print("Döngü tamamlandı.")
Açıklama: sayac değişkeni 0'dan başlar ve her iterasyonda 1 artırılır. sayac < 5 koşulu False olana kadar döngü devam eder. Koşul False olduğunda döngüden çıkılır ve "Döngü tamamlandı." mesajı yazdırılır.
Örnek 2: break İfadesiyle Döngüyü Sonlandırma
break ifadesi, döngü koşulu hala True olsa bile döngüden hemen çıkmak için kullanılır.
i = 1
while True: # Sonsuz döngü başlatıyoruz
print(f"i'nin değeri: {i}")
if i == 3:
print("3'e ulaşıldı, döngüden çıkılıyor.")
break # Döngüyü sonlandır
i += 1
print("Döngü dışı.")
Açıklama: while True ile teorik olarak sonsuz bir döngü başlatılır. Ancak, i değişkeni 3 olduğunda break ifadesi çalışır ve döngü anında sonlanır. Bu, belirli bir iç koşul karşılandığında döngüden çıkmak için kullanışlıdır.
Örnek 3: continue İfadesiyle İterasyonu Atlatma
continue ifadesi, mevcut iterasyonun geri kalanını atlayarak döngünün bir sonraki iterasyonuna geçmek için kullanılır.
j = 0
while j < 5:
j += 1
if j == 3:
print(f"{j} atlanıyor...")
continue # Bu iterasyonun geri kalanını atla
print(f"j'nin değeri: {j}")
print("Döngü tamamlandı.")
Açıklama: j 3 olduğunda, "3 atlanıyor..." mesajı yazdırılır ve continue ifadesi çalışarak print(f"j'nin değeri: {j}") satırını atlar. Döngü bir sonraki iterasyondan devam eder.
Örnek 4: else Bloğu Kullanımı
else bloğu, döngü koşulu False olduğunda ve döngü break ile sonlandırılmadığında yürütülür.
k = 0
while k < 3:
print(f"k'nin değeri: {k}")
k += 1
else:
print("While döngüsü doğal yollarla tamamlandı.")
Açıklama: Bu örnekte döngü k 3 olana kadar devam eder. Koşul False olduğunda else bloğu yürütülür. Eğer break ifadesi ile döngüden çıkılsaydı, else bloğu çalışmazdı.
Sonsuz Döngülerden Kaçının: while döngüsünde koşulun her zaman True kalması veya hiçbir zaman False olmaması durumunda sonsuz bir döngü oluşur. Bu, programınızın kilitlenmesine neden olabilir. Koşulu etkileyecek bir ifadeyi (örneğin, bir sayacı artıran veya bir kullanıcı girdisi alan) döngü içinde bulundurduğunuzdan emin olun.
Koşulu Güncelleyin: Döngü koşulunun sonunda False değerini almasını sağlayacak bir mekanizma mutlaka olmalıdır. Aksi takdirde sonsuz döngü oluşur.
break ve continue Dikkatli Kullanın: Bu ifadeler güçlüdür ve döngü akışını değiştirirler. Kodun okunabilirliğini azaltmamak için gerektiğinde ve anlaşılır bir şekilde kullanılmalıdır.
else Bloğunun Davranışı: else bloğu, yalnızca while döngüsü koşulunun False olmasıyla doğal bir şekilde sona erdiğinde yürütülür. Eğer döngü bir break ifadesiyle kesilirse, else bloğu yürütülmez.
for vs. while: Belirli bir öğe dizisi üzerinde (örneğin bir liste veya dize) yineleme yapmanız gerektiğinde genellikle for döngüsü daha uygundur. while döngüsü ise, döngünün kaç kez çalışacağını önceden bilmediğiniz, belirli bir koşulun karşılanmasını beklediğiniz durumlarda tercih edilir.
Python 3.10 ile tanıtılan yapısal desen eşleştirme (structural pattern matching) özelliği, programcılara kodlarını daha okunaklı ve yönetilebilir hale getirme imkanı sunar. Özellikle karmaşık veri yapılarını analiz ederken veya farklı durumları işlerken, match deyimi if/elif/else zincirlerine modern ve güçlü bir alternatif sunar. Bu makale, Python'daki match deyiminin temel prensiplerini, sözdizimini ve çeşitli kullanım senaryolarını detaylı bir şekilde açıklamaktadır.
Python'daki match deyiminin temel sözdizimi aşağıdaki gibidir:
match konu:
case desen_1:
# desen_1 eşleşirse çalışacak kod
case desen_2 if koşul:
# desen_2 eşleşirse ve koşul doğruysa çalışacak kod
case _:
# hiçbir desen eşleşmezse çalışacak kod (isteğe bağlı)match deyiminin her bir bileşeni belirli bir amaca hizmet eder:
match konu:
konu ifadesi, eşleştirme yapılmak istenen herhangi bir Python objesidir. Bu, bir değişken, bir fonksiyon çağrısının sonucu veya doğrudan bir değer olabilir. match deyimi, bu konu objesini sırasıyla tanımlanan case desenleriyle karşılaştırır.
case desen:
Her case bloğu, konu ile eşleştirilmeye çalışılan bir desen tanımlar. Desenler çeşitli tiplerde olabilir ve aşağıdaki gibi farklı eşleştirme mekanizmalarını destekler:
Değer Desenleri (Literal Patterns): Sabit değerlerle (sayılar, dizeler, True, False, None) eşleşir. Örn: case 1:, case "hata":.
Yakalama Desenleri (Capture Patterns): Bir değeri bir değişkene atar. Örn: case x:. Eğer x daha önce tanımlanmamışsa, eşleşen değeri x'e atar. Eğer _ kullanılırsa, bu bir wildcard (joker) deseni olarak kabul edilir ve değeri yakalamaz, sadece eşleşir.
Sıra Desenleri (Sequence Patterns): Listeler veya tuple'lar gibi sıralı veri yapılarını eşleştirmek için kullanılır. Örn: case [x, y]:, case (başlangıç, *diğerleri):.
Haritalama Desenleri (Mapping Patterns): Sözlükler gibi anahtar-değer çiftlerini içeren veri yapılarını eşleştirmek için kullanılır. Örn: case {"tip": "hata", "kod": c}:.
Sınıf Desenleri (Class Patterns): Belirli bir sınıfın örneklerini eşleştirmek ve bu örneklerin niteliklerine erişmek için kullanılır. Örn: case Nokta(x=nx, y=ny):.
OR Desenleri (OR Patterns): Birden fazla deseni | operatörü ile birleştirerek, herhangi bir desenin eşleşmesi durumunda kod bloğunun çalışmasını sağlar. Örn: case "a" | "b":.
AS Desenleri (AS Patterns): Bir deseni eşleştirirken aynı zamanda eşleşen değeri başka bir değişkene atamak için kullanılır. Örn: case ["komut", *args] as tüm_komut:.
if koşul: (Guard)
Her case deseninin arkasına isteğe bağlı olarak bir if koşul: ifadesi eklenebilir. Bu, desenin eşleşmesinin yanı sıra, belirtilen koşulun da doğru olmasını gerektirir. Koşul, desende yakalanan değişkenleri kullanabilir. Örn: case {"yaş": y} if y >= 18:.
Aşağıdaki örnekler, match deyiminin farklı senaryolarda nasıl kullanılabileceğini göstermektedir.
Bir HTTP durum kodunu işleme:
durum_kodu = 200
match durum_kodu:
case 200:
print("OK - İstek başarıyla işlendi.")
case 404:
print("Bulunamadı - Kaynak mevcut değil.")
case 500:
print("Sunucu Hatası - İç sunucu hatası oluştu.")
case _: # Joker desen, diğer tüm durumlar için
print(f"Bilinmeyen durum kodu: {durum_kodu}")Çıktı:
OK - İstek başarıyla işlendi.Bir komut listesini ayrıştırma:
komut = ["yükle", "uygulama.exe", "--sessiz"]
match komut:
case ["yükle", dosya, *argümanlar]:
print(f"'{dosya}' yükleniyor. Argümanlar: {argümanlar}")
case ["sil", dosya]:
print(f"'{dosya}' siliniyor.")
case _:
print("Geçersiz komut.")Çıktı:
'uygulama.exe' yükleniyor. Argümanlar: ['--sessiz']Bir kullanıcı objesini işleme:
kullanici_verisi = {"ad": "Mehmet", "rol": "admin", "aktif": True}
match kullanici_verisi:
case {"rol": "admin", "aktif": True}:
print("Yönetici girişi yapıldı.")
case {"rol": "editor", "aktif": True, "ad": isim}:
print(f"Editör '{isim}' giriş yaptı.")
case {"aktif": False}:
print("Kullanıcı hesabı pasif.")
case _:
print("Bilinmeyen kullanıcı durumu.")Çıktı:
Yönetici girişi yapıldı.Özel bir sınıfın örneklerini eşleştirme. Önce sınıfı tanımlayalım:
class Nokta:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Nokta(x={self.x}, y={self.y})"
nokta_objesi = Nokta(10, 20)
mesaj_objesi = "Merhaba"
match nokta_objesi:
case Nokta(x=0, y=0):
print("Orijin noktasında.")
case Nokta(x=nx, y=ny) if nx == ny:
print(f"x ve y değerleri eşit: {nx}")
case Nokta(x=nx, y=ny):
print(f"Farklı bir nokta: x={nx}, y={ny}")
case _:
print("Bir Nokta objesi değil.")Çıktı:
Farklı bir nokta: x=10, y=20Birden fazla durumu tek bir case altında işleme ve değeri yakalama:
durum = "başarılı"
# durum = "tamamlandı"
# durum = "işlem_yapılmadı"
match durum:
case "başarılı" | "tamamlandı" as sonuc:
print(f"İşlem {sonuc} şekilde tamamlandı.")
case "hata" | "başarısız":
print("İşlemde bir hata oluştu.")
case _:
print("Bilinmeyen durum.")Çıktı:
İşlem başarılı şekilde tamamlandı.Sıralama Önemlidir: match deyimi, case bloklarını yukarıdan aşağıya doğru sırayla değerlendirir. İlk eşleşen case bloğu yürütülür ve match deyiminden çıkılır. Bu nedenle, daha spesifik desenler genel desenlerden önce gelmelidir.
_ (Wildcard): Alt çizgi (_), hiçbir şeyi yakalamayan ve her zaman eşleşen bir joker desendir. Genellikle match bloğunun son case'i olarak, varsayılan bir durumu ele almak için kullanılır (else gibi).
if Koşulları (Guards): Bir case deseni eşleşse bile, arkasından gelen if koşulu False ise o case bloğu yürütülmez. Bu, daha karmaşık koşulları desen eşleştirmeye dahil etmek için güçlü bir yoldur.
Değişken Yakalama: Bir desende kullanılan ve daha önce tanımlanmamış bir isim (örneğin case x:), eşleşen değeri o değişkene atar. Bu, yakalama deseni olarak bilinir.
Python 3.10 ve Sonrası: match deyimi, Python'ın 3.10 sürümü ile birlikte tanıtılmıştır. Daha eski Python sürümlerinde bu özellik bulunmamaktadır.
Performans: Küçük ve basit koşullar için if/elif/else zincirleri hala uygun olabilir. Ancak karmaşık veri yapıları üzerinde birden fazla durumu ele alırken match deyimi, kodu daha okunaklı ve sürdürülebilir hale getirir.
Python programlamada karar verme mekanizmaları, kodun belirli koşullara göre farklı yollar izlemesini sağlar. Bu, programlarınızın dinamik ve etkileşimli olmasının temelini oluşturur. Python'daki if, elif (else if'in kısaltması) ve else ifadeleri, bu koşullu mantığı uygulamanın anahtarıdır. Bu kılavuz, Python'da koşullu ifadelerin nasıl kullanılacağını, temel sözdiziminden başlayarak pratik uygulamalara ve önemli ipuçlarına kadar adım adım açıklamaktadır.
Python'da if...elif...else yapısının genel sözdizimi aşağıdaki gibidir:
if koşul1:
# koşul1 doğruysa çalışacak kod bloğu
elif koşul2:
# koşul1 yanlış VE koşul2 doğruysa çalışacak kod bloğu
else:
# koşul1 ve koşul2 yanlışsa çalışacak kod bloğu
Her koşul ifadesi bir kolon (:) ile biter ve koşula bağlı kod bloğu girinti (indentation) ile tanımlanır. Python'da girintiler, kod bloklarını belirtmek için zorunludur.
if ifadesi: Koşullu bloğun başlangıcını işaret eder. Belirtilen koşul1 bir boolean (True veya False) olarak değerlendirilir. Eğer koşul True ise, if bloğunun içindeki kod çalıştırılır. Aksi takdirde, program bir sonraki elif veya else ifadesine geçer.
elif ifadesi (isteğe bağlı): Birden fazla koşulu kontrol etmek için kullanılır. Eğer önceki if koşulu yanlışsa, program bir sonraki elif koşulunu kontrol eder. koşul2 doğruysa, ilgili elif bloğu çalıştırılır. Bir if yapısında birden fazla elif ifadesi bulunabilir.
else ifadesi (isteğe bağlı): Tüm önceki if ve elif koşulları yanlış olduğunda çalıştırılacak kodu tanımlar. Bu ifade, hiçbir koşulun sağlanmadığı durumlar için bir 'varsayılan' yol sağlar ve yapının sonunda yer alır.
Unutulmamalıdır ki, bir if...elif...else zincirinde yalnızca bir kod bloğu çalıştırılır. İlk doğru koşul bulunduğunda, ilgili blok çalışır ve tüm yapıdan çıkılır.
Aşağıdaki örnekler, if...elif...else yapısının farklı senaryolarda nasıl kullanıldığını göstermektedir.
Örnek 1: Tek Bir if İfadesi
yaş = 18
if yaş >= 18:
print("Oy kullanabilirsiniz.")
Bu örnekte, yaş değişkeninin değeri 18 veya daha büyükse mesaj yazdırılır.
Örnek 2: if...else Kullanımı
hava_durumu = "yağmurlu"
if hava_durumu == "güneşli":
print("Dışarı çıkıp yürüyüş yapın.")
else:
print("İçeride kalın ve kitap okuyun.")
Burada, hava_durumu değişkeni "güneşli" ise ilk blok, aksi halde else bloğu çalışır.
Örnek 3: if...elif...else Zinciri
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 F")
Bu örnekte, puan değişkenine göre farklı notlar atanır. Koşullar yukarıdan aşağıya doğru kontrol edilir ve ilk doğru koşulun bloğu çalıştırılır.
Örnek 4: İç İçe if İfadeleri
kullanici_adi = "admin"
sifre = "12345"
if kullanici_adi == "admin":
if sifre == "12345":
print("Yönetici panelinize hoş geldiniz.")
else:
print("Yanlış şifre.")
else:
print("Kullanıcı adı bulunamadı.")
Koşullar karmaşıklaştığında, if ifadelerini iç içe kullanmak mümkündür. Ancak aşırı iç içe geçmiş yapılar kodun okunabilirliğini azaltabilir.
Girinti (Indentation): Python'da kod blokları girintilerle belirlenir. Genellikle 4 boşluk kullanılır. Yanlış girinti IndentationError hatasına yol açar.
Kolon (:): Her if, elif ve else ifadesinden sonra bir kolon (:) gelmelidir.
Koşul İfadeleri: Koşul ifadeleri genellikle karşılaştırma operatörleri (==, !=, <, >, <=, >=) ve mantıksal operatörler (and, or, not) kullanılarak oluşturulur.
Kısa Devre Değerlendirmesi: Mantıksal operatörler kullanılırken Python, koşulları soldan sağa değerlendirir ve sonucun zaten belirlenebildiği durumlarda değerlendirmeyi durdurur. Örneğin, False and (pahalı_işlem()) ifadesinde pahalı_işlem() fonksiyonu asla çağrılmaz.
Boş Bloklar: Bir koşul bloğunun içine henüz kod yazmak istemiyorsanız, pass anahtar kelimesini kullanarak boş bir blok oluşturabilirsiniz. Bu, bir IndentationError oluşmasını engeller.
Python programlama dilinde, verileri etkili bir şekilde depolamak ve yönetmek için çeşitli yerleşik veri yapıları bulunmaktadır. Bu yapılardan biri olan set, benzersiz elemanlardan oluşan, sırasız ve değiştirilebilir bir koleksiyondur. set'ler, özellikle bir koleksiyondaki yinelenen değerleri kaldırmak, üyelik testleri yapmak veya iki set arasındaki matematiksel küme işlemlerini (birleşim, kesişim, fark vb.) gerçekleştirmek için son derece kullanışlıdır. Bu makale, Python set'lerinin temel kullanımını, sözdizimini ve pratik uygulamalarını detaylandıracaktır.
set'ler, süslü parantezler {} kullanılarak veya set() yapıcı fonksiyonu aracılığıyla oluşturulabilir. Boş bir set oluşturmak için set() fonksiyonu kullanılmalıdır, çünkü {} boş bir sözlük (dict) oluşturur.
Bir set oluşturmanın iki ana yolu vardır:
Literaller Kullanarak: Virgülle ayrılmış elemanları süslü parantezler içine alarak bir set oluşturabilirsiniz. Örnek: {"elma", "muz", "kiraz"}. Bu yöntem, başlangıçta elemanları olan bir set oluşturmak için idealdir.
set() Yapıcı Fonksiyonunu Kullanarak: Bir iterable (örneğin, liste, tuple, string) bir set'e dönüştürmek için set() fonksiyonunu kullanabilirsiniz. Örnek: set(["elma", "muz"]). Boş bir set oluşturmak için yalnızca set() kullanılmalıdır. {} kullanımı boş bir sözlük oluşturur.
set'lerin temel özellikleri şunlardır:
Benzersiz Elemanlar: Bir set yalnızca benzersiz elemanlar içerebilir. Yinelenen elemanlar eklenmeye çalışıldığında, set bunları otomatik olarak görmezden gelir.
Sırasız: set elemanlarının belirli bir sırası yoktur. Her çalıştırmada elemanların sırası değişebilir ve indeksleme yoluyla elemanlara erişilemez.
Değiştirilebilir (Mutable): Bir set oluşturulduktan sonra eleman ekleyebilir veya silebilirsiniz. Ancak set'in kendisi değiştirilebilirken, elemanları hashable olmalıdır. Yani, set elemanları listeler veya başka set'ler gibi değiştirilebilir nesneler olamaz.
1. set Oluşturma ve Yinelenen Elemanları Kaldırma:
# Süslü parantezlerle set oluşturma
meyveler = {"elma", "muz", "kiraz", "elma"}
print(f"Meyveler seti: {meyveler}")
# set() fonksiyonu ile liste üzerinden set oluşturma
sayilar_listesi = [1, 2, 2, 3, 4, 4, 5]
sayilar_seti = set(sayilar_listesi)
print(f"Sayılar seti: {sayilar_seti}")
# Boş set oluşturma
bos_set = set()
print(f"Boş set: {bos_set}")
# Hata: {} boş bir sözlük oluşturur
bos_sozluk = {}
print(f"Boş süslü parantez: {type(bos_sozluk)}")
2. set Elemanlarına Ekleme ve Silme:
renkler = {"kırmızı", "mavi"}
print(f"Orijinal renkler seti: {renkler}")
# add() metodu ile eleman ekleme
renkler.add("yeşil")
print(f"add() sonrası: {renkler}")
# Mevcut bir elemanı tekrar ekleme (değişiklik olmaz)
renkler.add("kırmızı")
print(f"Tekrar add() sonrası: {renkler}")
# update() metodu ile birden fazla eleman ekleme (iterable kullanarak)
renkler.update(["sarı", "mor", "mavi"])
print(f"update() sonrası: {renkler}")
# remove() metodu ile eleman silme (eleman yoksa KeyError verir)
renkler.remove("mavi")
print(f"remove() sonrası: {renkler}")
# discard() metodu ile eleman silme (eleman yoksa hata vermez)
renkler.discard("turuncu")
print(f"discard() sonrası (olmayan eleman): {renkler}")
# pop() metodu ile rastgele bir eleman silme ve döndürme
silinen_renk = renkler.pop()
print(f"pop() ile silinen: {silinen_renk}, Kalan renkler: {renkler}")
# clear() metodu ile tüm elemanları silme
renkler.clear()
print(f"clear() sonrası: {renkler}")
3. set Üzerinde Küme İşlemleri:
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# Birleşim (Union): | operatörü veya union() metodu
birlesim = set1 | set2
print(f"Birleşim: {birlesim}") # veya set1.union(set2)
# Kesişim (Intersection): & operatörü veya intersection() metodu
kesisim = set1 & set2
print(f"Kesişim: {kesisim}") # veya set1.intersection(set2)
# Fark (Difference): - operatörü veya difference() metodu
fark1 = set1 - set2 # set1'de olup set2'de olmayanlar
print(f"Set1 - Set2 farkı: {fark1}") # veya set1.difference(set2)
fark2 = set2 - set1 # set2'de olup set1'de olmayanlar
print(f"Set2 - Set1 farkı: {fark2}") # veya set2.difference(set1)
# Simetrik Fark (Symmetric Difference): ^ operatörü veya symmetric_difference() metodu
# Her iki sette de olup kesişimde olmayanlar
simetrik_fark = set1 ^ set2
print(f"Simetrik Fark: {simetrik_fark}") # veya set1.symmetric_difference(set2)
# Alt Küme (Subset) ve Üst Küme (Superset) Testleri
set_a = {1, 2}
set_b = {1, 2, 3, 4}
print(f"Set A, Set B'nin alt kümesi mi? {set_a.issubset(set_b)}")
print(f"Set B, Set A'nın üst kümesi mi? {set_b.issuperset(set_a)}")
4. set Üyelik Testi:
harfler = {'a', 'b', 'c'}
print(f"'a' harfler setinde mi? {'a' in harfler}")
print(f"'d' harfler setinde mi? {'d' in harfler}")
Boş set Oluşturma: Boş bir set oluşturmak için mutlaka set() fonksiyonunu kullanın. {} boş bir sözlük oluşturur.
Sırasız Yapı: set'ler sırasızdır. Elemanların eklenme sırası korunmaz ve indeksleme (my_set[0] gibi) kullanılamaz.
Değiştirilemez Elemanlar: set elemanları hashable (değiştirilemez) olmalıdır. Bu nedenle, list'ler, dict'ler veya başka set'ler doğrudan bir set'in elemanı olamaz. Eğer değiştirilemez bir set'e ihtiyacınız varsa frozenset kullanabilirsiniz.
Performans: set'ler, elemanların benzersizliğini kontrol etmek ve üyelik testleri (in operatörü) için yüksek performans sunar, özellikle büyük veri kümelerinde.
Kullanım Alanları: Tekrarlanan elemanları kaldırma, veri temizleme, iki koleksiyon arasındaki ortak veya farklı elemanları bulma gibi senaryolarda set'ler oldukça etkilidir.
2025 © Tüm Hakları Saklıdır.