Python'da Üsler: Yeni Başlayanlar İçin Kapsamlı Rehber

Üs alma, veri analizinden algoritma tasarımına kadar programlamanın çeşitli alanlarında temeldir. Uygulamaları arasında sosyal medya trendleri gibi büyük veri kümelerindeki üstel desenlerin analiz edilmesi ve bileşik büyüme ya da faiz oranları gibi matematiksel hesaplamaların yapılması yer alır.

Ayrıca, üstel hesaplama Makine Öğrenimi (ML) ve Yapay Zeka (AI) alanlarında, özellikle sinir ağları ve görüntü tanıma konularında kritik bir rol oynar. Bu nedenle, Python'da üslerle etkili şekilde nasıl hesaplama yapılacağını anlamak esastır.

Bu rehberde, Python'da üs alma için kullanılan çeşitli yöntemleri keşfedeceğiz. Yerleşik fonksiyonları, math modülündeki fonksiyonları ve Numpy kütüphanesindekileri inceleyeceğiz. Her yöntemin kendine özgü avantajları vardır. Bir adım öne geçmek, bilginizi pekiştirmek ve uzmanlaşmak için Python Programming Fundamentals beceri yoluna kaydolun. 

Python'da Üsler

Python, üs hesaplamak için birden fazla yol sunar:

• **: Çift yıldız operatörü (**) üs alma için en basit ve temel seçenektir. Örneğin, x ** y ifadesi, x'in y üssünü hesaplar.

• pow(): Bu yerleşik fonksiyon iki argüman alır: taban ve üs. Tabanın üssü alınarak elde edilen sonucu döndürür. Ayrıca modüler üstel hesaplama için isteğe bağlı üçüncü bir argüman alır. Örnek: pow(x, y).

• math.pow(): math modülündeki bu fonksiyon pow() ile benzerdir, ancak sonucu her zaman kayan noktalı sayı olarak döndürür. İki argüman alır; her ikisi de float veya tamsayı olabilir. Örnek: math.pow(x, y).

• math.exp(): math modülünden bir diğer fonksiyon olup bir sayının doğal üstelini, yani e'nin argüman kuvvetini döndürür. Örnek: math.exp(argument).

• np.power(): NumPy kütüphanesinden bu fonksiyon, diziler veya matrislerle çalışmak için tasarlanmıştır. Eleman bazında üs alma yapar. Örnek: np.power(array, exponent).

Python Üs Alma Temelleri

Çift yıldız operatörü (**), Python'da üs hesaplamanın en sade yoludur. Bu operatör, sol işleneni (taban) sağ işlenenin (üs) kuvvetine yükseltir. Güç operatörü ya da üstel operatör olarak da adlandırılır.

Python programlama becerilerinizi geliştirmek ve gerçek bir programcı gibi kod yazmayı öğrenmek istiyorsanız, Python Programming kursuna göz atın.

Pozitif üs

Bu kod parçasında, pozitif üsler kullanarak üstel hesaplamanın nasıl yapıldığını gösteriyoruz. Örneğin, 2'nin 3. kuvveti 2 × 2 × 2 olarak hesaplanır ve sonuç 8'dir. Benzer şekilde, -10'un 4. kuvveti -10 × -10 × -10 × -10 olarak hesaplanır ve sonuç 10000'dir.

base = 2
exponent = 3
print(base**exponent)  # Output: 8

base = -10
exponent = 4
print(base**exponent)  # Output: 10000Altyapı:

Negatif üs

Bu kod, bir tabanın negatif bir üse yükseltilmesi sonucunu hesaplar. Örneğin, 5'in -2. kuvveti 0,04'e eşittir. Benzer şekilde, 25'in -5. kuvveti bilimsel gösterimde ifade edilen çok küçük bir değer (1.024e-07) verir.

base = 5
exponent = -2
print(base**exponent) # 0.04

base = 25
exponent = -5
print(base**exponent) # 1.024e-07Altyapı:

Bir sayıyı negatif bir üse yükseltmek, aynı sayının pozitif üssünün tersini almaya eşdeğerdir.

Python'da, ** operatörü 0.0'ı negatif bir üste yükseltirseniz ZeroDivisionError döndürür; çünkü sıfıra bölme tanımsızdır.

base = 0
exponent = -5
print(base**exponent)Altyapı:

Çıktı şöyledir:

Kayan noktalı üs

Kod örnekleri, Python'un 2 gibi pozitif bir tabanın 1,5 gibi kesirli bir üse yükseltilmesi sonucunu doğru şekilde hesapladığını gösterir. Ancak, negatif bir tabanın kesirli bir üse yükseltilmesi karmaşık bir sayı ile sonuçlanır.

base = 2
exponent = 1.5
print(base**exponent) # 2.8284271247461903

base = -0.25
exponent = 1.25
print(base**exponent) # (-0.12500000000000003-0.125j)Altyapı:

Daha Derine İniyoruz: Yerleşik Fonksiyonlar

Python, üs hesaplamak için çeşitli yerleşik fonksiyonlar sunar; ancak biz iki tanesine odaklanacağız: pow() ve math.pow(). İlk bakışta bu fonksiyonlar benzer görünse de aralarında önemli farklar vardır.

pow()

pow() fonksiyonu iki zorunlu argüman alır: taban ve üs. İsteğe bağlı olarak, üstel değerin modülünü hesaplamak için üçüncü bir argüman kabul eder. Söz dizimi şöyledir: pow(base, exp, mod); burada 'mod' modülü temsil eder. Bu fonksiyon, üstel hesaplamanın kalanını döndürür.

Temel üstel hesaplama

Temel hesaplamalar için, taban ve üssü fonksiyona verin; ** operatörüne benzer şekilde çalışır.

r = pow(2, 3)
print(r) # 8

r = pow(4, -10)
print(r) # 2.56e-06Altyapı:

Kayan noktalı üstel hesaplama

Aşağıdaki kodda, bazıları negatif olan tabanlar ve üsler için kayan noktalı sayılar kullanıyoruz. Bu yaklaşım ** operatörüyle benzer şekilde çalışır.

r = pow(3.5, 2)
print(r)  # 12.25

r = pow(3.5, -2)
print(r)  # 0.08163265306122448

r = pow(3.5, 3.2)
print(r)  # 55.08301986166747

r = pow(-3.5, -3.3)
print(r)  # (-0.009414432347757688+0.012957854474952653j)

r = pow(-3.5, 3.3)
print(r)  # (-36.698070584660925-50.510560868902246j)Altyapı:

Not: Modüler hesaplamaya gerek olmayan temel üstel işlemler için, ** operatörü pow() fonksiyonuna kıyasla daha öz ve okunabilirdir.

Modüler üstel hesaplama

pow() fonksiyonunun isteğe bağlı modül parametresi, modüler üstel hesaplamada oldukça değerlidir. Bu, özellikle kriptografide veya büyük sayılarla çalışırken kullanışlıdır; çünkü modüler üstel hesaplama daha yüksek verimlilik sunar. Örneğin, 3'ün 4. kuvvetinin 5 ile modülü hesaplandığında sonuç 1'dir; zira 81 mod 5 eşittir 1.

r = pow(3, 4, 5)
print(r)  # 1

r = pow(123, 456, 789)
print(r)  # 699

r = pow(2, -3, 7)
print(r)  # 1

r = pow(-13, 8, 62)
print(r)  # 7Altyapı:

Neden modüler üstel hesaplama için doğrudan pow() kullanmanın pow(base, exp) % mod veya (base**exp) % mod ifadelerinden daha verimli olduğunu merak edebilirsiniz. Yerleşik pow() fonksiyonu bu işlem için özel olarak tasarlanmıştır; diğer yöntemler ise gereksiz ara hesaplamalar yapar. Bu, özellikle büyük değerlerde performansta kayda değer fark yaratabilir.

import timeit

start_pow_mod = timeit.default_timer()
pow(500000000, 3000, 4000)
stop_pow_mod = timeit.default_timer()

pow_mod_time = stop_pow_mod - start_pow_mod

print("Time using pow(base, exp, mod): ", pow_mod_time)

start_pow_other = timeit.default_timer()
pow(500000000, 3000) % 4000
stop_pow_other = timeit.default_timer()

pow_other_time = stop_pow_other - start_pow_other

print("Time using pow(base, exp) % mod:", pow_other_time)


start_aestrisk = timeit.default_timer()
(500000000**3000) % 4000
stop_aestrisk = timeit.default_timer()

aestrisk_time = stop_aestrisk - start_aestrisk

print("Time using (base ** exp) % mod: ", aestrisk_time)


print(
    f"Speed comparison: pow(base, exp, mod) was {pow_other_time / pow_mod_time} times faster than pow(base, exp) % mod and {aestrisk_time/pow_mod_time} times faster than (base ** exp) % mod"
)Altyapı:

Çıktı şöyledir:

pow() fonksiyonu duruma bağlı olarak farklı hatalar fırlatabilir.

# Karmaşık sayıların modülünü almaya çalışmak ValueError yükseltir.
print(pow(2 + 3j, 4, 5))  # ValueError: complex modulo

# İkinci argüman negatifse üçüncü argümanı kullanmak yasaktır.
print(pow(10, -11, 4))  # ValueError: base is not invertible for the given modulus

# Birinci veya ikinci argüman float ise üçüncü argüman kabul edilmez.
print(pow(2.4, 3, 4))  # TypeError: pow() 3rd argument not allowed unless all arguments are integers

# Herhangi bir argümanın string olması TypeError ile sonuçlanır.
print(pow(2, 4, '3'))  # TypeError: unsupported operand type(s) for pow(): 'int', 'int', 'str'Altyapı:

math.pow()

math.pow(x, n) fonksiyonu x'i n üssüne yükseltir. math.pow() argümanları float'a dönüştürür ve sonucu kesin kayan noktalı üstel hesaplama olarak döndürür. Bu hassasiyet, doğruluğun kritik olduğu veri analizi ve bilimsel hesaplama gibi alanlarda önem kazanır.

İşte basit bir kod. math.pow() fonksiyonu kayan noktalı bir değer döndürürken, pow() fonksiyonu tamsayı bir değer döndürür.

import math
print(math.pow(6, 3))  # 216.0
print(pow(6, 3))  # 216Altyapı:

math.pow() fonksiyonu sanal sayıları kabul etmez.

math.pow(), kesirli üslerle birlikte negatif tabanları kabul etmez; ValueError yükseltir.

Gelişmiş Üstel Hesaplama İçin Kütüphanelerden Yararlanma

Bir sayının üstel değerini bulmak veya dizilerde/matrislerde eleman bazında üstel hesaplama yapmak gibi gelişmiş görevleri ele almak için iki fonksiyondan yararlanabilirsiniz: np.power() ve math.exp() .

np.power()

Python'da üstel hesaplama yerleşik fonksiyonlarla sınırlı değildir. Python, diziler üzerinde çok çeşitli matematiksel işlemleri mümkün kılan güçlü bir kütüphane olan NumPy'a sahiptir. Bazen, tüm bir dizi boyunca üstel hesaplama yapmanız gerekir; işte np.power() burada devreye girer. Dizilerin eleman bazında üstel hesaplaması için tasarlanmıştır.

import numpy as np
r = np.power([2, 4, 8], 2)
print(r)  # [4, 16, 64]

r = np.power([2, 4, 8], [1, 2, 3])
print(r)  # [4 64 4096]

r = np.power([[2, 3, 4], [5, 6, 7]], [1, 2, 3])
print(r) # [[2 9 64] [5 36 343]]Altyapı:

np.power() fonksiyonu negatif üs kabul etmez.

import numpy as np
r = np.power([2, 4, 8], -2)
print(r)Altyapı:

Çıktı şöyledir:

Negatif bir sayıyı tamsayı olmayan bir üse yükseltmeye çalışırsanız, NumPy NaN (Not a Number) döndürür.

math.exp()

math.exp(x) fonksiyonu x'in üstel değerini hesaplar; bu, Euler sayısı e'nin x üssüne yükseltilmesine eşdeğerdir. Euler sayısı yaklaşık 2,71828'dir ve bu işlem matematiksel gösterimde e^x olarak ifade edilir.

import math
x = 2
r = math.exp(x)
print("Exponential of", x, ":", r) # 7.38905609893065Altyapı:

math.exp(x)'in önemli bir özelliği uyarlanabilirliğidir. Pozitif sayıları, negatif sayıları ve hatta kayan noktalı sayıları işleyebilir.

import math
print(math.exp(-2))  # 0.1353352832366127
print(math.exp(-2.5))  # 0.0820849986238988
print(math.exp(2.5))  # 12.182493960703473Altyapı:

Pratik Uygulamalar ve Örnekler

Üs alma, matematikte temel bir işlemdir ve veri analizi ile bilimsel hesaplamada çok sayıda uygulaması vardır.

Python ile veri analizi temellerine hâkim olmak istiyorsanız, Introduction to Python for Data Science kursuna göz atın.

Diyelim ki birden fazla satır için anapara tutarı, faiz oranı ve yatırım süresi verilerini içeren bir CSV dosyanız var. Yukarıda bahsedilen yöntemlerden herhangi birini kullanarak her satır için bileşik faizi hesaplayabilirsiniz.

Principal,Rate,Years
1000,0.05,5
2000,0.03,10
1500,0.08,3
3000,0.06,7
2500,0.04,9
1800,0.07,4
2200,0.025,6
3500,0.09,2
2800,0.035,8
4000,0.02,5Altyapı:

Kod şöyle:

import csv


def compound_interest(principal, rate, years):
    return principal * (1 + rate) ** years


# Read data from CSV file

data = []
with open("data.csv", newline="") as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        row["Compound Interest"] = compound_interest(
            float(row["Principal"]), float(row["Rate"]), int(row["Years"])
        )
        data.append(row)
# Write data to a new CSV file with compound interest column

output_file = "data.csv"
fieldnames = ["Principal", "Rate", "Years", "Compound Interest"]

with open(output_file, mode="w", newline="") as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    for row in data:
        writer.writerow(row)
print("Compound interest calculations saved to", output_file)Altyapı:

Sonuç şöyledir:

Harika! Tüm satırlar için bileşik faizi hesapladınız ve ayrı bir sütunda sakladınız. Bu verileri ileri analizler için kullanabilirsiniz. Benzer şekilde, zaman içinde nüfus artışını modelleme gibi üstel hesaplamanın yoğun biçimde kullanıldığı yüzlerce başka kullanım alanı vardır.

Sonuç

Bu rehberde, her biri kendine özgü avantajlar sunan Python'da üs hesaplamaya yönelik beş farklı yöntemi inceledik. Bunları bileşik faiz bulma, nüfus artışını modelleme ve daha pek çok pratik senaryoda kullanabilirsiniz.

• Çift yıldız operatörü (**): Günlük kullanım için basit ve doğrudan.
• pow(): İsteğe bağlı "modül" hilesiyle çok yönlü.
• math.pow(): Kayan noktalı sayılar olarak hassas sonuçlar.
• np.power(): Dizileri ele alma ve hata kontrolü için güçlü.
• math.exp(): Üstel değeri hesaplamak için özelleşmiş araç.

İstatistiksel becerilerinizi geliştirmek ve Python kullanarak verilerden nasıl toplanır, analiz edilir ve doğru sonuçlar çıkarılır öğrenmek istiyorsanız, Introduction to Statistics in Python kursuna göz atın.