“f-string” Nedir?

Python’ın 3.6 sürümü ile birlikte hayatımıza giren “f-string” (format string) özelliği sayesinde “string”lerin içine değişkenler eklememiz oldukça kolaylaşmaktadır. Zira Python kodunuzda “f-string” yerine .format() kullanmak ya da % operatörleriyle uğraşmak zaman zaman kafa karıştırıcı olabiliyordu. Buna karşılık “f-string”i kullanmak için tek yapmanız gereken, “string”inizin başına bir f koyup süslü parantez {} içine değişkenlerinizi yazmak. Basit bir örnek üzerinden göstereyim:

name = "John"
age = 25

print(f"Merhaba, benim adım {name} ve {age} yaşındayım.")

Sadece değişken değil, “f-string” ile matematiksel işlemler de yapabiliriz. Örneğin:

a = 5
b = 3

print(f"{a} ile {b} çarpıldığında sonuç {a * b} olur.")

#5 ile 3 çarpıldığında sonuç 15 olur.

Gördüğünüz gibi, süslü parantez içinde doğrudan matematiksel bir işlem yaptık! Bitti mi? Hayır, “f-string” formatlama için de oldukça kullanışlıdır. Diyelim ki bir sayıyı belirli bir ondalık formatta göstermek istiyoruz. Bunu şu şekilde yapabiliriz:

pi = 3.14159

print(f'Pi sayısı yaklaşık olarak {pi:.2f} değerine eşittir.')

Örneğimizdeki .2f ifadesi, sayının virgülden sonra iki basamağını göstereceğimizi belirtiyor.

Neden “f-string” Kullanmalıyım?

• Basit ve okunabilir: Kodunuz daha kısa ve net olur.
• Hızlı: .format() ve % operatörüne göre daha hızlı çalışır.
• Esnek: Değişkenler dışında işlemleri de kolayca yapabilirsiniz.

İşte bu kadar! Python kodlarken “f-string” kullanmak baya işlerinizi kolaylaştıracaktır. Umarım bu yazı sizin için faydalı olmuştur. 🎉 Eğer sorularınız varsa, sormaktan çekinmeyin. Kodlamalarınızda bol şans! 💻

Python’da “f-string” yazısı ilk önce 1Kodum üzerinde ortaya çıktı.

Kodumuzu yazmaya geçmeden önce digit faktöriyelin ne olduğunu açıklayalım; digit faktöriyel, rakamlarının faktöriyelleri toplamı yine kendisine eşit olan sayılara denilmektedir. Buna göre, 145 sayısı için 1! + 4! + 5! = 1+24+120 = 145 olduğundan 145 sayısı digit faktöriyeldir. Ancak belirtmek isterim ki, 1 ve 2 sayıları ilgili şartı sağlamalarına rağmen digit faktoriyel olarak değerlendirilmez.

from math import factorial

def digit_factorials(max_limit):
    """
    Belirli bir üst sınırın altındaki tüm sayıları bulan fonksiyon tanımladık
    Rakamlarının faktöriyellerinin toplamı sayının kendisine eşittir. 
    1 ve 2 bu kapsam dışında tutulmuştur.
    """
    digit_factorial_numbers = []  # Digit faktöriyel sayılarını saklamak için bir liste

    for number in range(10, max_limit):  # 10'dan başlayarak max_limit'e kadar olan tüm sayıları kontrol eder
        sum_of_factorials = sum(factorial(int(digit)) for digit in str(number))  # Sayının her bir rakamının faktöriyelini hesaplar ve toplar
        if sum_of_factorials == number:  # Eğer rakamlarının faktöriyellerinin toplamı kendisine eşitse
            digit_factorial_numbers.append(number)  # Bu sayıyı listeye ekler

    return digit_factorial_numbers

# 100000'den küçük digit faktöriyel sayıları bulma
digit_factorial_numbers = digit_factorials(100000)
print(digit_factorial_numbers)

Kodu Trinket üzerinden çalıştırarak inceleyebilirsiniz. Kodumuzun daha da anlaşılır olması adına neyi niye yaptığımızı maddeler halinde açıklayalım:

1. Fonksiyon Tanımı (def digit_factorials(max_limit)): Özel bir özelliğe sahip sayıları bulmak için yeniden kullanılabilir bir fonksiyon tanımladık. Bu fonksiyon, max_limit parametresi alır ve bu sınırın altındaki tüm “digit faktöriyel” sayıları bulur.
2. Digit Faktöriyel Sayılar Listesi (digit_factorial_numbers = []): Fonksiyonun çalışması sırasında bulunan “digit faktöriyel” sayıları saklamak için liste kullandık.
3. Dış Döngü (For Döngüsü): for number in range(10, max_limit): ile, 10’dan (1 ve 2 hariç tutulduğu için başlangıç 10’dur) max_limit parametresine kadar olan tüm sayıları for döngüsü ile tek tek kontrol ediyoruz.
4. Rakamların Faktöriyellerinin Toplanması: Her bir sayının rakamlarını ayrı ayrı alıp (for digit in str(number)) her birinin faktöriyelini hesaplayarak (factorial(int(digit))) topluyoruz (sum_of_factorials = sum(factorial(int(digit)) for digit in str(number))).
5. Digit Faktöriyel Olup Olmadığının Kontrolü: Eğer bir sayının rakamlarının faktöriyellerinin toplamı kendisine eşit mi diye kontrol etmek için if koşulunu kullandık (if sum_of_factorials == number:) ve eğer öyleyse append metodu ile listeye ekledik (digit_factorial_numbers.append(number)).
6. sum_of_factorials = sum(factorial(int(digit)) for digit in str(number)) ifadesi biraz karışık görülebilir. O yüzden bu kısmı da es geçmek istemedim:
   • str(number): Öncelikle number değişkeni, sayısal bir değeri temsil etmektedir. Bu sayıyı str() fonksiyonu ile bir string’e çeviriyoruz. Böylece, sayının her bir rakamını ayrı ayrı işlemek mümkün hale gelmektedir. Örneğin, number 145 ise, str(number) ifadesi '145' olur.
   • for digit in str(number): Bu döngü, number sayısının her bir rakamını (digit) sırayla alır ve işler. Bu döngü, örneğin ‘145’ için üç kez çalışır: ilk önce ‘1’ için, sonra ‘4’ için ve en son ‘5’ için çalışır.
   • int(digit): Her bir digit (rakam), şu anda bir string’dir. Örneğin, ‘1’, ‘4’, ‘5’. Bu rakamları işleyebilmek için onları tekrar integer’a (tam sayıya) çevirmemiz gerekmektedir. Yani int('1') ifadesi 1’e, int('4') ifadesi 4’e, ve int('5') ifadesi 5’e dönüşür.
   • factorial(int(digit)): Her bir rakamın faktöriyelini alıyoruz. Örneğin, factorial(1), factorial(4), ve factorial(5).
   • sum(... for digit in str(number)): Tüm bu faktöriyel hesaplamalarının sonuçlarını topluyoruz. Yani, 1! + 4! + 5! ifadesinin sonucunu hesaplıyoruz.
   • sum_of_factorials: Tüm bu işlemlerin sonucu, sum_of_factorials değişkenine atanır. Bu değişken, number sayısının rakamlarının faktöriyellerinin toplamını temsil eder. Bu işlem, her bir sayı için for number in range(10, max_limit): döngüsü içinde tekrarlanır.

Python ile “Digit Faktöriyel” Olan Sayıları Bulma yazısı ilk önce 1Kodum üzerinde ortaya çıktı.

1. Fonksiyon kullanarak çözelim:

# Asal sayıları bulup listeye ekleyen ve toplamını hesaplayan Python programı
def asal_sayilari_bul_ve_topla(ust_limit):
    asal_sayilar = []
    for sayi in range(2, ust_limit):
        asal = True
        for i in range(2, sayi):
            if sayi % i == 0:
                asal = False
                break
        if asal:
            asal_sayilar.append(sayi)
    asal_sayilarin_toplami = sum(asal_sayilar)
    return asal_sayilar, asal_sayilarin_toplami
# 1000'den küçük asal sayıları buluyoruz ve toplamlarını hesaplıyoruz
asal_sayilar, toplam = asal_sayilari_bul_ve_topla(1000)
print("Asal Sayılar:", asal_sayilar)
print ("----------")
print("Asal Sayıların Toplamı", toplam)

Kodumuzun nasıl çalıştığını maddeler halinde açıklayalım:

1. Fonksiyon Tanımı (def asal_sayilari_bul_ve_topla(ust_limit)): İşlemi yeniden kullanılabilir ve organize bir şekilde yapabilmek için, belirli bir üst limite kadar olan asal sayıları bulup toplamını hesaplayan bir fonksiyon tanımladık. Bu fonksiyon, ust_limit parametresiyle, hangi sayıya kadar asal sayıları bulacağımızı belirlememize olanak tanır.
2. Asal Sayı Listesi (asal_sayilar = []): Bulunan asal sayıları saklamak için bir liste oluşturduk. Bu liste, fonksiyonun çalışması sırasında asal olarak belirlenen sayılarla doldurulmuştur.
3. Dış Döngü (For Döngüsü): for sayi in range(2, ust_limit): ile, 2’den (asal sayılar 2’den başlar) ust_limit parametresine kadar olan tüm sayıları for döngüsü ile tek tek kontrol ettik.
4. Asallığı Kontrol Etme (asal = True ve İç Döngü): Her sayının başlangıçta asal olduğunu varsayarak (asal = True), bu varsayımı test etmek için bir iç döngü (for i in range(2, sayi)) kullanıyoruz. İç döngü, mevcut sayıyı 2’den kendisine kadar olan sayılara bölerek test eder. Bunu yapabilmek için if koşulunu kullandık. Eğer sayı, bu aralıktaki herhangi bir sayıya tam bölünürse (if sayi % i == 0), o zaman asal değildir ve asal = False olarak işaretlenmiştir.
5. Asal Sayıların Listeye Eklenmesi: Eğer sayı asalsa (if asal), bu sayıyı asal_sayilar listesine append() metodunu kullanarak ekledik (asal_sayilar.append(sayi)).

2. Pekala fonksiyon kullanmadan da yapabiliriz. Bakınız:

 Asal sayılar listesi ve toplamını hesaplamak için değişkenler
asal_sayilar = []
toplam = 0
# 2'den 1000'e kadar olan sayıları kontrol etmek için dış döngü
for sayi in range(2, 1000):
    asal = True  # Varsayılan olarak sayıyı asal kabul ediyoruz
    # Mevcut sayının asal olup olmadığını kontrol etmek için iç döngü
    for i in range(2, sayi):
        if sayi % i == 0:  # Sayı, herhangi bir sayıya tam bölünürse asal değildir
            asal = False
            break
    # Eğer sayı asalsa, listeye ekleyip toplama dahil ediyoruz
    if asal:
        asal_sayilar.append(sayi)
        toplam += sayi
# Asal sayıların listesi ve toplamını yazdır
print(asal_sayilar)
print ("----------")
print("Asal Sayıların Toplamı:", toplam)

Python ile 1000’den Küçük Asal Sayıları Ekrana Yazdırma yazısı ilk önce 1Kodum üzerinde ortaya çıktı.

Malumunuz, bir sayının çarpanlarından asal olanlarına bu sayının asal çarpanları denilmektedir. Örneğin, 30 sayısının çarpanları 1, 2, 3, 5, 6, 10, 15 ve 30’dur. Bu çarpanlar içerisinde asal olanları ise 2, 3 ve 5’tir. Dolayısıyla, 30 sayısının asal çarpanları 2, 3 ve 5’tir ve bu sayı 2 x 3 x 5 şeklinde asal çarpanlara ayrılabilir.

Bu bilgiler eşiğinde sorumuzu alternatif metotlarla beraber çözeceğiz. Ancak ilk olarak, kodumuzda yararlanacağımız çözüm yolumuzu gösteren akış şemasının adımlarını belirleyelim:

1. Sayının asal çarpanlara ayrılma işlemi, sayı 1’e eşit olana kadar süreceği için “while döngüsünü” kullandık. Her döngü iterasyonunda, sayının o anki bölen sayısına (potansiyel asal çarpan) tam bölünüp bölünemediğini kontrol etmek için “if-else” koşullunu kullandık.

def asal_carpanlara_ayir(sayi):
    asal_carpanlar = []
    bolen = 2
    while sayi > 1:
        if sayi % bolen == 0:
            asal_carpanlar.append(bolen)
            sayi //= bolen
        else:
            bolen += 1
    return asal_carpanlar
# Kullanıcıdan sayı alınması
girilen_sayi = int(input("Lütfen asal çarpanlarına ayırmak istediğiniz sayıyı giriniz: "))
asal_carpanlar = asal_carpanlara_ayir(girilen_sayi)
print("Asal Çarpanlar:", asal_carpanlar)

2. Aşağıdaki yöntem, asal sayıları ayrı ayrı kontrol etmek yerine, tüm sayıları kontrol etmektedir.

def asal_carpanlara_ayir(sayi):
    asal_carpanlar = []
    bolen = 2
    while sayi > 1:
        while sayi % bolen == 0:
            asal_carpanlar.append(bolen)
            sayi //= bolen
        bolen += 1
    return asal_carpanlar
# Kullanıcıdan sayı alınması
girilen_sayi = int(input("Lütfen asal çarpanlarına ayırmak istediğiniz sayıyı giriniz: "))
asal_carpanlar = asal_carpanlara_ayir(girilen_sayi)
print("Asal Çarpanlar:", asal_carpanlar)

Yukarıdaki kodumuzda, //= ifadesi kafa karıştırıcı olabileceği için adım adım açıklayalım:

• Bölme İşlemi (//):
  • İlk olarak, // operatörü iki sayının bölme işlemini gerçekleştirir.
  • Fakat bu bölme işlemi, sonucu “tam sayı” olarak verir. Örneğin, 10 // 3 işlemi 3.33 değil, 3 sonucunu verir.
• Atama İşlemi (=):
  • İkinci olarak, = işareti bu bölme işleminin sonucunu bir değişkene atar.
  • Yani, yapılan bölme işleminin sonucu, bu işlemi uyguladığımız değişkenin yeni değeri haline gelir.
• Birleşik İşlem (//=):
  • //= operatörü, yukarıdaki iki adımı tek bir adımda gerçekleştirir.
  • Örneğin, sayi //= bolen ifadesi, sayi‘yı bolen ile bölüp, bu sonucu sayi değişkenine tekrar atar. Yani bu demektir ki, sayi //= bolen ifadesi, sayi = sayi // bolen ifadesinin kısa bir yolu gibidir.

Python ile Girilen Sayıyı Asal Çarpanlara Ayırma yazısı ilk önce 1Kodum üzerinde ortaya çıktı.

15. Bir dizi içerisindeki sıfır değerlerini dizinin sonuna taşıyan bir fonksiyon yazın. Diğer elemanların sıralaması değişmemelidir.:
    • Örnek girdi: [0, 1, 0, 3, 12]
    • Örnek çıktı: [1, 3, 12, 0, 0]

def sifirlari_sona_tasi(dizi):
    sifir_olmayan = 0
    for i in range(len(dizi)):
        if dizi[i] != 0:
            dizi[sifir_olmayan], dizi[i] = dizi[i], dizi[sifir_olmayan]
            sifir_olmayan += 1
    return dizi
# Örnek kullanım:
giris_dizi = [0, 1, 0, 3, 12]
cikis = sifirlari_sona_tasi(giris_dizi)
print("Sıfırlar Sona Taşındı:", cikis)  # [1, 3, 12, 0, 0]

Yukarıdaki örneğimizde, verilen bir dizideki tüm sıfır değerlerini dizinin sonuna taşıyan bir fonksiyonu tanımladık. Fonksiyonumuz sifirlari_sona_tasi, sıfır olmayan tüm elemanları dizinin başına taşırken, sıfırları sona taşımaktır. Bu işlemi gerçekleştirmek için Python’daki birkaç temel programlama özelliğini kullandık.

Öncelikle, fonksiyonun içinde bir for döngüsü kullanılmıştır. Bu döngü, verilen dizinin tüm elemanlarını sırasıyla incelemek için kullanılır. Python’daki for döngüsü, dizinin her bir elemanına kolayca erişim sağlar ve dizinin uzunluğuna bağlı olarak otomatik olarak tekrar eder. Bu durumda, for i in range(len(dizi)) ifadesi, dizinin başından sonuna kadar her bir indeks için döngünün tekrarlanmasını sağlar.

Döngü içerisinde, if ifadesi kullanılarak her elemanın sıfır olup olmadığı kontrol edilir. Eğer eleman sıfır değilse, yani if dizi[i] != 0: koşulu sağlanıyorsa, bu elemanın dizideki konumu değiştirilir. Bu koşulun kullanılması, fonksiyonun sadece sıfır olmayan elemanlar üzerinde işlem yapmasını sağlar ve bu sayede sıfır olan elemanlar doğrudan sona taşınmış olur.

Elemanların yerlerinin değiştirilmesi (swap) işlemi, Python’un çoklu atama özelliği kullanılarak yapılır: dizi[sifir_olmayan], dizi[i] = dizi[i], dizi[sifir_olmayan]. Bu satır, sıfır olmayan elemanı (dizi[i]) sifir_olmayan indeksine taşırken, o indeksteki elemanı (dizi[sifir_olmayan]) şu anki elemanın yerine koyar.

Her bir sıfır olmayan eleman taşındığında, sifir_olmayan sayaç değişkeni bir arttırılır (sifir_olmayan += 1). Bu sayede, sonraki sıfır olmayan eleman için dizide yer açılır. Sayaç değişkeni, sıfır olmayan elemanların dizideki yeni konumlarını takip etmek için kullanılır.

Sonuç olarak, fonksiyon dizinin tamamını taradıktan sonra, tüm sıfır değerlerini dizinin sonuna taşımış olur. Örnek kullanım, fonksiyonun nasıl çalıştığını göstermektedir: [0, 1, 0, 3, 12] giriş dizisi [1, 3, 12, 0, 0] olarak dönüştürülür, burada tüm sıfırlar sona taşınmış ve sıfır olmayan elemanlar korunmuştur. Bu yöntem, özellikle veri işleme ve sayısal hesaplamalarda önemli olabilir, çünkü sıfırları ayrıştırmak, bazı algoritmaların verimliliğini artırabilir.

Python ile Dizi İçerisindeki Bir Sayıyı Dizinin Sonuna Taşıma yazısı ilk önce 1Kodum üzerinde ortaya çıktı.

Kullanıcıdan veri girmesi istendiği için input () fonksiyonu ve koşul ifadesi olduğu için if-else deyimini kullanacağız:

# Sayıları kullanıcıdan al
sayi1 = float(input("Birinci sayıyı giriniz: "))
sayi2 = float(input("İkinci sayıyı giriniz: "))
sayi3 = float(input("Üçüncü sayıyı giriniz: "))
# Üç sayının hepsi aynı mı diye kontrol et
if sayi1 == sayi2 and sayi2 == sayi3:
    print("Üç sayı da aynı. Lütfen farklı sayılar giriniz.")
else:
    # Farklı olan sayıyı bul
    if sayi1 == sayi2:
        farkli_sayi = sayi3
    elif sayi1 == sayi3:
        farkli_sayi = sayi2
    else:
        farkli_sayi = sayi1
    print("Farklı olan sayı: ", farkli_sayi)

Bu kod, üç sayının aynı olup olmadığını kontrol eder ve eğer aynıysa, kullanıcıya farklı sayılar girmesi gerektiğini söyler. Eğer sayılar farklıysa, farklı olan sayıyı bulur ve yazdırır.

Python ile 2’si Aynı Olan 3 Sayıdan Farklı Olanı Bulma yazısı ilk önce 1Kodum üzerinde ortaya çıktı.

14. Bir dizi içerisinde sadece bir kez kullanılan ilk elemanı bulma:
    • Örnek girdi: [1, 2, 2, 3, 4, 1, 2, 3, 4, 5]
    • Örnek çıktı: [1, 2, 3, 4, 5]

def en_uzun_artan_dizi(dizi):
    if not dizi:
        return []
    mevcut_dizi = [dizi[0]]
    en_uzun_dizi = mevcut_dizi[:]
    for i in range(1, len(dizi)):
        if dizi[i] > dizi[i - 1]:
            mevcut_dizi.append(dizi[i])
            if len(mevcut_dizi) > len(en_uzun_dizi):
                en_uzun_dizi = mevcut_dizi[:]
        else:
            mevcut_dizi = [dizi[i]]
    return en_uzun_dizi
# Örnek kullanım:
giris_dizi = [1, 2, 2, 3, 4, 1, 2, 3, 4, 5]
cikis = en_uzun_artan_dizi(giris_dizi)
print("Dizi:", cikis)  # [1, 2, 3, 4, 5]

Yukarıdaki en_uzun_artan_dizi isimli fonksiyon, bir diziyi parametre olarak alıp bu dizideki en uzun artan alt diziyi döndürmek üzere tasarlanmıştır.

Fonksiyon başladığında, öncelikle dizi boş mu diye kontrol eder. Eğer dizi boşsa, fonksiyon hemen boş bir dizi döndürerek çalışmasını sonlandırır.

Ardından, “mevcut_dizi” adında bir değişken tanımlanır. Bu değişken, şu anki artan dizi olarak düşünülebilir. Başlangıç olarak bu değişkene dizinin ilk elemanı atanır. Aynı değer, “en_uzun_dizi” adında başka bir değişkene de kopyalanır. Bu ikinci değişken, şimdiye kadar bulunan en uzun artan dizi olarak kullanılacaktır.

Sonrasında for döngüsü başlar. Bu döngü, dizinin ikinci elemanından başlayarak son elemanına kadar devam eder. Döngü içinde, eğer şu anki eleman bir öncekinden büyükse, bu eleman “mevcut_dizi“ye eklenir. Eğer “mevcut_dizi“, şimdiye kadarki “en_uzun_dizi“den daha uzunsa, “en_uzun_dizi” güncellenir. Eğer şu anki eleman bir öncekinden büyük değilse, “mevcut_dizi” sıfırlanarak sadece şu anki elemanla baştan oluşturulur.

Döngü sona erdikten sonra, “en_uzun_dizi” döndürülür. Bu, fonksiyonun sonucudur ve en uzun artan alt diziyi temsil eder.

Python ile Arka Arkaya Gelen En Uzun Artan Alt Diziyi Bulma yazısı ilk önce 1Kodum üzerinde ortaya çıktı.

13. Bir dizi içerisinde sadece bir kez kullanılan ilk elemanı bulma:
    • Örnek girdi: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
    • Örnek çıktı: [9, 6, 5]

def en_buyuk_uc_sayi(dizi):
    dizi.sort(reverse=True)
    return dizi[:3]
# Örnek kullanım:
giris_dizi = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
cikis = en_buyuk_uc_sayi(giris_dizi)
print("Sıralama Kullanarak Bulunan Üç Sayı:", cikis)  # [9, 6, 5]

Yukarıdaki kodumuzda, en_buyuk_uc_sayi adında bir fonksiyon tanımladık. Fonksiyonumuzda, reverse=True argümanını kullanarak sort() metodundaki sıralamayı büyükten küçüğe olacak şekilde gerçekleştirdik. Ardından dilimleme yöntemini kullanarak (dizi[:3]) en büyük 3 sayıyı döndürdük.

def en_buyuk_uc_sayi(dizi):
    dizi.sort(reverse=True)
    return dizi[:3]
# Örnek kullanım:
giris_dizi = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
cikis = en_buyuk_uc_sayi(giris_dizi)
print("Sıralama Kullanarak Bulunan Üç Sayı:", cikis)  # [9, 6, 5]

Yukarıdaki kodumuzda, en_buyuk_uc_sayi_lineer adında yeni bir fonksiyon tanımladık. Bu fonksiyon, aldığı sayı listesinden en büyük üç sayıyı lineer tarama yöntemiyle bulmayı amaçlar.

Fonksiyonun başlangıcında, max1, max2 ve max3 adında üç değişken tanımlıyoruz. Bu değişkenler sırasıyla en büyük, ikinci en büyük ve üçüncü en büyük sayıları tutmak için kullanılır. Başlangıç değerleri olarak ‘-inf’ (negatif sonsuz) atandı, böylece bu değişkenler ilk karşılaştıkları herhangi bir sayıdan küçük olacaktır.

Dizi içindeki her sayıyı tek tek dolaşarak, bu sayının en büyük üç sayıdan hangisiyle karşılaştırılması gerektiğini kontrol ediyoruz. Eğer sayı max1‘den büyükse, max1‘i max2‘ye, max2‘yi max3‘e atayarak en büyük değeri max1‘e atıyoruz. Aynı mantık, sayı max1 ile max2 arasında veya max2 ile max3 arasında olduğunda da uygulanır.

Tüm dizi bu şekilde tarandıktan sonra, max1, max2 ve max3 değişkenlerindeki değerler en büyük üç sayıyı temsil eder. Bu üç sayıyı bir liste olarak döndürüyoruz.

Son olarak, bir örnek dizi olan giris_dizi ile bu fonksiyonu test ediyoruz. Sonuç olarak [9, 6, 5] değerlerini elde ediyoruz, bu da en büyük üç sayıdır. Bu yöntem, diziyi sadece bir kere tarayarak sonucu bulduğu için lineer zamanda çalışır ve büyük diziler için oldukça verimlidir.

Python ile Dizi İçerisindeki En Büyük Üç Sayıyı Bulma yazısı ilk önce 1Kodum üzerinde ortaya çıktı.

12. Bir dizi içerisinde sadece bir kez kullanılan ilk elemanı bulma:
    • Örnek girdi: [4, 1, 2, 1, 2]
    • Örnek çıktı: 4 (Çünkü 4 sayısı dizide sadece bir kez geçiyor.)

def tek_gecen_sayiyi_bul(dizi):
    sayi_sayim = {}
    for sayi in dizi:
        if sayi in sayi_sayim:
            sayi_sayim[sayi] += 1
        else:
            sayi_sayim[sayi] = 1
            
    for sayi, sayim in sayi_sayim.items():
        if sayim == 1:
            return sayi
# Örnek kullanım:
giris_dizi = [4, 1, 2, 1, 2]
cikis = tek_gecen_sayiyi_bul(giris_dizi)
print("Sözlük Kullanarak Bulunan Sayı:", cikis)  # 4

Yukarıdaki kodumuzda, bir dizide yalnızca bir kez geçen sayıyı bulmayı amaçlıyoruz. Bu işlemi gerçekleştirmek için bir sözlük yapısı (sayi_sayim) kullanıyoruz. Diziyi dolaşırken her eleman için bu elemanın tekrar sayısını bu sözlük içerisinde saklıyoruz.

Kodumuzda, for döngüsü ile diziyi baştan sona dolaşıyoruz. Dizi üzerindeki her bir elemanı incelediğimizde, eğer bu elemanı daha önce gördüysek (if koşulu), bu elemanın tekrar sayısını bir artırıyoruz. Eğer elemanı ilk kez görüyorsak, bu elemanı sözlüğe ekleyip tekrar sayısını 1 olarak ayarlıyoruz.

Bu işlemden sonra sayi_sayim sözlüğünde, her bir elemanın kaç kere tekrar ettiği bilgisi saklanmış oluyor. İkinci döngüde ise, bu sözlükteki elemanların tekrar sayılarını kontrol ediyoruz ve tekrar sayısı 1 olan elemanı bulup döndürüyoruz.

def tek_gecen_sayiyi_bul_xor(dizi):
    sonuc = 0
    for sayi in dizi:
        sonuc ^= sayi
    return sonuc
# Örnek kullanım:
giris_dizi = [4, 1, 2, 1, 2]
cikis_xor = tek_gecen_sayiyi_bul_xor(giris_dizi)
print("XOR Kullanarak Bulunan Sayı:", cikis_xor)  # 4

^ işareti ile gösterilen XOR operatörü, iki bit arasında yapılan bir işlemdir ve eğer iki bit aynıysa sonucu 0, farklıysa sonucu 1 olarak verir. Bu özellik, aynı sayının iki kere XOR işlemine tabi tutulduğunda sonucun 0 olmasını sağlar.

Kodumuzda, for döngüsü ile diziyi baştan sona dolaşıyoruz. Başlangıçta sonucu 0 olarak ayarladıktan sonra, dizi üzerindeki her bir eleman için bu elemanı sonuca XOR işlemi ile ekliyoruz. Eğer bir sayı dizide iki kez bulunuyorsa, bu sayının sonuc üzerindeki etkisi sıfırlanacaktır. Ancak, yalnızca bir kez geçen sayı sonucu etkileyecektir.

Python ile Bir Dizi İçerisinde Bir Kez Kullanılan İlk Elemanı Bulma yazısı ilk önce 1Kodum üzerinde ortaya çıktı.

11. Bir dizi içerisindeki en çok tekrar eden liste elemanını ve kaç kere tekrar edildiğini bulma
    • Örnek girdi: [5, 3, 4, 8, 5, 3, 1, 5]
    • Örnek çıktı: 5 3

def en_cok_tekrar_eden(dizi):
    tekrarlar = {}
    for eleman in dizi:
        if eleman in tekrarlar:
            tekrarlar[eleman] += 1
        else:
            tekrarlar[eleman] = 1
    
    en_cok_tekrar = max(tekrarlar, key=tekrarlar.get)
    return en_cok_tekrar, tekrarlar[en_cok_tekrar]
giris_dizi = [5, 3, 4, 8, 5, 3, 1, 5]
eleman, tekrar_sayisi = en_cok_tekrar_eden(giris_dizi)
print(eleman, tekrar_sayisi)  # 5 3

Yukarıdaki kodumuzda, bir dizide en çok tekrar eden elemanı ve bu elemanın kaç kere tekrar ettiğini bulmayı amaçlıyoruz. Bu işlemi gerçekleştirmek için bir sözlük yapısı (tekrarlar) kullanıyoruz. Diziyi dolaşırken her eleman için bu elemanın tekrar sayısını bu sözlük içerisinde saklıyoruz.

Kodumuzda, for döngüsü ile diziyi baştan sona dolaşıyoruz. Dizi üzerindeki her bir elemanı incelediğimizde, eğer bu eleman daha önce gördüysek (if koşulu), bu elemanın tekrar sayısını bir artırıyoruz. Eğer elemanı ilk kez görüyorsak, bu elemanı sözlüğe ekleyip tekrar sayısını 1 olarak ayarlıyoruz.

Bu işlemden sonra tekrarlar sözlüğünde, her bir elemanın kaç kere tekrar ettiği bilgisi saklanmış oluyor. Daha sonra max fonksiyonunu kullanarak bu sözlükte en yüksek tekrar sayısına sahip elemanı buluyoruz. Bu eleman, en çok tekrar eden eleman olacaktır. Kodu çalıştırmak için: Trinket

Pekala collections modülündeki Counter sınıfı ile hızlı bir şekilde en çok tekrar eden elemanı bulabiliriz:

from collections import Counter
def en_cok_tekrar_eden(dizi):
    tekrar_sayisi = Counter(dizi)
    eleman, sayi = tekrar_sayisi.most_common(1)[0]
    return eleman, sayi
giris_dizi = [5, 3, 4, 8, 5, 3, 1, 5]
eleman, tekrar_sayisi = en_cok_tekrar_eden(giris_dizi)
print(eleman, tekrar_sayisi)  # 5 3

Python ile Dizide En Çok Tekrar Eden Elemanı Bulma yazısı ilk önce 1Kodum üzerinde ortaya çıktı.