def kare(sayi):
return sayi*sayi
print(kare(10)) # Çıktısı: 100
Fonksiyona ikinci bir arguman ekleyip kendisiyle kac defa carpmasi gerektigini verebiliyor olsak nasil olurdu?
ussunu_al(10, 2) # 10 * 10 = 100
ussunu_al(10, 3) # 10 * 10 * 10 = 1000
ussunu_al(2, 10) # 2 ussu 10 = 1024
2 Beğeni
o o zaman üs olur o fonksiyon
ussunu_al fonksiyonunu yazmayi deneyelim mi pratik icin? Sen basla
biraz zor oldu:
def üssünü_al(sayı,sayı2,sonuç = 1):
for _ in range(sayı2):
sonuç *= sayı
return sonuç
print(üssünü_al(2,3))
1 Beğeni
sonuç değişkenini parametre olarak değil de, fonksiyonun içinde tanımlasanız daha iyi olur. Çünkü burada üçüncü bir argümanın kullanılmasına izin veriyorsunuz. üssünü_al(2,3,2) yazdığımızda fonksiyon beklediğiniz gibi çalışmaz.
ellerine saglik reis cok guzel olmus tak diye cozdun valla 
Ben de boyle yazdim:
from functools import reduce
from operator import mul
ussunu_al = lambda base, exponent: reduce(mul, [base] * exponent, 1)
Eski günleri yâd ettirdin bana kardeşim. Ben de yıllar önce bir forumda henüz yeni Python’a başlamış bir arkadaşa 100 satırlık kodunu 20 satıra indirip böylesi daha iyi demiştim de çocuğu Python’dan soğutmuştum. Nerede ve ne yapıyor acaba şu an çocuk 
2 Beğeni
Code golf!
from functools import reduce
print("3 ** 4 =",
(lambda m: lambda n: n((lambda m: lambda n: m((lambda m: lambda n: m(lambda n: lambda f: lambda x: f(n(f)(x)))(n))(n))(lambda f: lambda x: x))(m))((lambda n: lambda f: lambda x: f(n(f)(x)))(lambda f: lambda x: x)))
(lambda f: lambda x: reduce(lambda acc, v: v(acc), [f for _ in range(3)], x))
(lambda f: lambda x: reduce(lambda acc, v: v(acc), [f for _ in range(4)], x))
(lambda n: n + 1)(0)
)
1 Beğeni
spoiler
church0 = lambda f: lambda x: x
succ = lambda n: lambda f: lambda x: f(n(f)(x))
add = lambda m: lambda n: m(succ)(n)
mul = lambda m: lambda n: m(add(n))(church0)
exp = lambda m: lambda n: n(mul(m))(succ(church0))
church_to_int = c2i = lambda c: c(lambda n: n + 1)(0)
from functools import reduce
int_to_church = i2c = lambda n: lambda f: lambda x: reduce(lambda acc, v: v(acc), [f for _ in range(n)], x)
print("2+3 =", c2i(add(i2c(2))(i2c(3))))
print("2*3 =", c2i(mul(i2c(2))(i2c(3))))
print("2^3 =", c2i(exp(i2c(2))(i2c(3))))
print("3^2 =", c2i(exp(i2c(3))(i2c(2))))
print("2^5 =", c2i(exp(i2c(2))(i2c(5))))
print("5^2 =", c2i(exp(i2c(5))(i2c(2))))
assert c2i(church0) == 0
assert c2i(succ(church0)) == 1
assert c2i(succ(succ(church0))) == 2
assert c2i(i2c(42)) == 42
assert c2i(add(i2c(2))(i2c(3))) == 5
assert c2i(add(i2c(3))(i2c(2))) == 5
assert c2i(mul(i2c(2))(i2c(3))) == 6
assert c2i(mul(i2c(3))(i2c(2))) == 6
assert c2i(exp(i2c(2))(i2c(3))) == 8
assert c2i(exp(i2c(3))(i2c(2))) == 9
(bkz: Lambda calculus), (bkz: Church numeral)
mul ve exp icin kisa formlari kafadan cikartamadim, ama lambda sadelestirmelerini uygulasak olur herhalde. Bu sekilde her islemin bir oncekinin tekrari oldugu daha rahat goruluyor. Tetrasyon filan da ayni sekilde eklenebilir. (Tetrasyonun birim elemani ne?)
Edit: Olmadi. Su kadar filan sadelesti exp:
lambda m0: lambda n0: n0((lambda n1: m0(n1(lambda n3: lambda f: lambda x: f(n3(f)(x))))(lambda f: lambda x: x))) (lambda f: f)
exp’in kisa formu λm: λn: n(m) bu arada. Ters kullanmayi goze alirsaniz λm: λn: m(n) yani λn: n oluyor. Yani aslinda Church sayilarini birbirlerine paslayarak us islemi yapabiliyorsunuz:
uc = i2c(3)
print(c2i(uc(uc))) #27
Ve bu arada
kare = iki = succ(succ(church0)) = lambda f: lambda x: f(f(x))
Sunu yazarken utaniyorum:
print("3 ** 2 =",
(lambda f: lambda x: f(f(x)))
(lambda f: lambda x: reduce(lambda acc, v: v(acc), [f for _ in range(3)], x))
(lambda n: n + 1)(0)
)
cunku kodun cogunlugu i2c ve c2i. Kare fonksiyonu iki sayisiyla ayni oldugunda boyle oluyor tabi…
def üssünü_al(sayı,sayı2,sonuç = 1):
for _ in range(sayı2):
sonuç *= sayı
return sonuç
print(üssünü_al(2,3))
Olay bundan
from functools import reduce
from operator import mul
ussunu_al = lambda base, exponent: reduce(mul, [base] * exponent, 1)
Buna nasıl geldi?
Sonuncunun ne işe yaradığını çevirebilmek için yazbelin neresine kadar okumak lazım. Bu modülleri anlatıyor mu?
Ve kod alanını nasıl açılıyordu?
Butun yontemleri surada: Soru Sorarken Sıkça Düşülen Hatalar #1
Fonksiyonel programlama gerecleriyle. Fonksiyonel programlamada loop olmadigi icin, recursion temel bir sey. Map/fold (map/reduce) data uzerinde yapilan bir suru islemi ifade edebilen son derece kullanisli seyler, ve alisinca gundelik imperatif programlama koduna bile girebiliyorlar.
Malesef, yazbel belgeleri bir programlama dersinden ziyade Python dokumentasyon cevirisi gibi. Sizi, bulabildiginiz butun kaynaklari denemeye davet etmek isterim.
O ve benzeri kaynaklar map ve reduce fonksiyonlarinin tam olarak nasil calistiklarini anlatabilirler, fakat bunlarla neler yapabileceginize sadece deginebilirler. (Tornavida almaya gittiginizi dusunun. Hangi vidalari vidalayabileceginizi soyleyebilirler, ama bu vidalarla neleri insa veya tamir edebileceginizi anlatamazlar.)
Butun loop’lar recursive fonksiyona, ve butun recursive fonksiyonlar loop’a donusturulebiliyor. Lutfen bana inanmayip kendiniz deneyin.
Bu arada Church-Turing tezine gore hepsi lambda calculus’ta da ifade edilebiliyor. Yukarida lambda calculus’a Church sayilariyla ufak bir giris yaptim.
2 Beğeni
nasıl yani yad ettirdin derken