Sayıların Okunuşu

Emerald_Gamer · Şubat 26, 2020, 4:34ös

O zaman amacı ne onu zasak ta yazmasak da aynı

EkremDincel · Şubat 26, 2020, 4:34ös

Çünkü bu sadece kullanıcıyı bilgilendirme amaçlı, Python dilinin nasıl çalıştığını değiştirmiyor.

dildeolupbiten · Şubat 26, 2020, 4:37ös

Mesela aşağıdaki gösterimin de bir etkisi yok, bu da bilgilendirme amaçlı kullanılan bir ifade. Burada fonksiyondan dönen veri tipinin tuple olduğunun bilgisini paylaşmış oluyorsunuz.

def f(arg: str = "") -> tuple: return arg

aib · Şubat 27, 2020, 9:39öö

Evet. Tam olarak boyle bir degisiklik esnasinda sorun cikartabilecek yerleri tanimlamak icin kullaniliyor zaten “code smell”. “Daha bozulmadi ama kokmaya baslamis” gibilerinden.

Sayili degiskenler boyle mesela: Datanin hic bir zaman dinamik uzunlukta gelemeyecegini, datadaki uzunluk degisiminin koda yansiyacagini garantiliyor. Bu her zaman sorun degil:

Color primaryColor1, primaryColor2, primaryColor3;

Insanlarin cogunlugunun 3 koni hucresi var ve onyillarca dorduncu bir ana renge ihtiyacimiz olmayacak.

Boyle bariz olmayan secimler yerine gore tartisiliyor. Ama bu durumlari “code smell” yapan tartisma yaratmalari.

Buradaki anahtar kelime “ufak”. Code smell yapilmasi gereken degisikligin beklenenden buyuk olabilecegini belirtiyor.

Bir kodu degisikliklere fazla kapali yapmak da, fazla acik yapmak da mumkun. Bu yuzden programcilik bir sanat formu.

dildeolupbiten · Şubat 27, 2020, 10:40öö

Aslında mevcut kodun geçerliliğini yitirdiği durumlar benim hoşuma bile gidiyor. Çünkü hem mevcut yapının geliştirilmeye müsait olmadığını anlamış oluyoruz, hem de geliştirilmeye müsait bir kod yapısı ortaya çıkartmaya yaklaşıyoruz. Yani kodlardaki ilk değişim genelde daha büyük olurken, ikinci, üçüncü değişimler yeni eklenecek özelliğin kodlarıyla sınırlı kalabiliyor. Mesela “Şu özelliği de ekleyebilir misiniz?” şeklinde bir öneri geldikten sonra şöyle düşünmeye başlıyorum: “Programı öyle bir hale getireyim ki, henüz önerilmemiş ama önerilmesi muhtemel olan değişiklikler hemen uygulanabilir olsunlar.” Ve gerçekten henüz dillendirilmemiş olan bu yeni özellikler daha sonra öneri olarak geliyor (Her zaman değil tabi). Ve bu duruma önceden hazırlandığınız için yeni özellikleri programa eklemek kolaylaşıyor.

aib · Şubat 28, 2020, 11:59öö

Tamamen katiliyorum. Tek ekleyecegim,

bunu fazla yapmak da mumkun. (Yukarida “fazla acik” dedigim.) Kisisel/ogrenme surecinde olmuyor veya olmasi kotu bir sey degil, fakat is ortaminda hem isi uzatiyor, hem de tasarlanan parcayi kullanacak insanin hayatini zorlastiriyor olabiliyor.

Architecture lead butun gelecek mesajlasma/queue/RPC gereksinimlerimize hitap edecek bir queue kutuphane arayuzu tasarlarken sadece tek bir tur sunucuya baglanip send ve receive fonksiyonlari saglayan kutuphanenin kendisini VE o kutuphaneyi kullanan kodu bitirmisligim var mesela. (Muhtesem tasarim hala kendi branch’inde; is biteli 8 sene oldu.)

dildeolupbiten · Şubat 28, 2020, 12:40ös

Hakkınız var. İş ortamındaki beklentiler farklı. Yapılması istenen bir işin, mevcut tasarımla uyuşmadığı durumlarda, tasarımı sırf bu yeni iş için yeniden tasarlamaya çalışmak zaman, emek ve kaynak israfına yol açabilir.

Bazen bu tip durumlar tasarımcının suçu da olmayabiliyor. Karşımızdaki insanın bizden yapmamızı istediği şeyi açıkça tanımlamadığı durumlarda işin uzuyor olması bu durumdan bir bakıma iş verenin de sorumlu olduğu anlamına geliyor. “Keşke bunu önceden söyleseydiniz.” diyebileceğimiz durumlarla karşılaşabiliyoruz. Bu durumu şuna benzetiyorum: Çocukken annelerimiz bizi bakkala bir şeyler almaya gönderirdi. O şeyleri alıp eve dönerdik ve annemiz bize başka bir şeyin alınması için tekrar bakkala gitmemiz gerektiğini söylerdi. Bu durum da biraz canımızı sıkardı.

aib · Şubat 29, 2020, 11:57öö

Bu arada okunamaz Python’a da cevirdim kodumu:

import functools

pcomp = lambda f, g: lambda n: (lambda fstrnum: (lambda gstrnum: (gstrnum[0] + fstrnum[0], gstrnum[1]))(g(fstrnum[1])))(f(n))

parserFrom = lambda arr: lambda n: (list(filter(lambda x: x != "", [arr[n % 10]])), n // 10)

parse0 = lambda n: (["sifir"], 0) if n == 0 else ([], n)
parse1   = parserFrom(["", "bir", "iki",     "uc",     "dort",     "bes",     "alti",     "yedi",     "sekiz",     "dokuz"])
parse10  = parserFrom(["", "on",  "yirmi",   "otuz",   "kirk",     "elli",    "altmis",   "yetmis",   "seksen",    "doksan"])
parse100 = parserFrom(["", "yuz", "iki yuz", "uc yuz", "dort yuz", "bes yuz", "alti yuz", "yedi yuz", "sekiz yuz", "dokuz yuz"])

parse1k = pcomp(pcomp(parse1, parse10), parse100)

parseGroup = lambda label: lambda n: ((lambda gstr: (gstr + ([] if gstr == [] else [label]), n // 1000))(parse1k(n % 1000)[0]))
parseThousands = lambda n: ((lambda gstr: (([] if gstr == [] else (["bin"] if gstr == ["bir"] else (gstr + ["bin"]))), n // 1000))(parse1k(n % 1000)[0]))

parseAll = lambda groups: functools.reduce(pcomp, [parse0, parse1k, parseThousands] + list(map(parseGroup, groups)))

##

readNumber = lambda n: " ".join(parseAll(["milyon", "milyar", "trilyon"])(n)[0])

def checkEqual(x, y):
    if x == y:
        print(x, "\033[32m==\033[0m", y)
    else:
        print(x, "\033[31m!=\033[0m", y)

def main():
      checkEqual(readNumber(0),"sifir")
      checkEqual(readNumber(1),"bir")
      checkEqual(readNumber(2),"iki")
      checkEqual(readNumber(10),"on")
      checkEqual(readNumber(11),"on bir")
      checkEqual(readNumber(19),"on dokuz")
      checkEqual(readNumber(40),"kirk")
      checkEqual(readNumber(42),"kirk iki")
      checkEqual(readNumber(100),"yuz")
      checkEqual(readNumber(109),"yuz dokuz")
      checkEqual(readNumber(110),"yuz on")
      checkEqual(readNumber(114),"yuz on dort")
      checkEqual(readNumber(140),"yuz kirk")
      checkEqual(readNumber(142),"yuz kirk iki")
      checkEqual(readNumber(400),"dort yuz")
      checkEqual(readNumber(405),"dort yuz bes")
      checkEqual(readNumber(440),"dort yuz kirk")
      checkEqual(readNumber(448),"dort yuz kirk sekiz")

      checkEqual(readNumber(1000),"bin")
      checkEqual(readNumber(1001),"bin bir")
      checkEqual(readNumber(1002),"bin iki")
      checkEqual(readNumber(1010),"bin on")
      checkEqual(readNumber(1011),"bin on bir")
      checkEqual(readNumber(1018),"bin on sekiz")
      checkEqual(readNumber(1040),"bin kirk")
      checkEqual(readNumber(1042),"bin kirk iki")
      checkEqual(readNumber(1100),"bin yuz")
      checkEqual(readNumber(1107),"bin yuz yedi")
      checkEqual(readNumber(1110),"bin yuz on")
      checkEqual(readNumber(1116),"bin yuz on alti")
      checkEqual(readNumber(1140),"bin yuz kirk")
      checkEqual(readNumber(1142),"bin yuz kirk iki")
      checkEqual(readNumber(1400),"bin dort yuz")
      checkEqual(readNumber(1405),"bin dort yuz bes")
      checkEqual(readNumber(1440),"bin dort yuz kirk")
      checkEqual(readNumber(1448),"bin dort yuz kirk sekiz")

      checkEqual(readNumber(3000),"uc bin")
      checkEqual(readNumber(3001),"uc bin bir")
      checkEqual(readNumber(3002),"uc bin iki")
      checkEqual(readNumber(3010),"uc bin on")
      checkEqual(readNumber(3011),"uc bin on bir")
      checkEqual(readNumber(3018),"uc bin on sekiz")
      checkEqual(readNumber(3040),"uc bin kirk")
      checkEqual(readNumber(3042),"uc bin kirk iki")
      checkEqual(readNumber(3100),"uc bin yuz")
      checkEqual(readNumber(3107),"uc bin yuz yedi")
      checkEqual(readNumber(3110),"uc bin yuz on")
      checkEqual(readNumber(3116),"uc bin yuz on alti")
      checkEqual(readNumber(3140),"uc bin yuz kirk")
      checkEqual(readNumber(3142),"uc bin yuz kirk iki")
      checkEqual(readNumber(3400),"uc bin dort yuz")
      checkEqual(readNumber(3405),"uc bin dort yuz bes")
      checkEqual(readNumber(3440),"uc bin dort yuz kirk")
      checkEqual(readNumber(3448),"uc bin dort yuz kirk sekiz")

      checkEqual(readNumber(1003000),"bir milyon uc bin")
      checkEqual(readNumber(1003001),"bir milyon uc bin bir")
      checkEqual(readNumber(1003002),"bir milyon uc bin iki")
      checkEqual(readNumber(1003010),"bir milyon uc bin on")
      checkEqual(readNumber(1003011),"bir milyon uc bin on bir")
      checkEqual(readNumber(1003018),"bir milyon uc bin on sekiz")
      checkEqual(readNumber(1003040),"bir milyon uc bin kirk")
      checkEqual(readNumber(1003042),"bir milyon uc bin kirk iki")
      checkEqual(readNumber(1003100),"bir milyon uc bin yuz")
      checkEqual(readNumber(1003107),"bir milyon uc bin yuz yedi")
      checkEqual(readNumber(1003110),"bir milyon uc bin yuz on")
      checkEqual(readNumber(1003116),"bir milyon uc bin yuz on alti")
      checkEqual(readNumber(1003140),"bir milyon uc bin yuz kirk")
      checkEqual(readNumber(1003142),"bir milyon uc bin yuz kirk iki")
      checkEqual(readNumber(1003400),"bir milyon uc bin dort yuz")
      checkEqual(readNumber(1003405),"bir milyon uc bin dort yuz bes")
      checkEqual(readNumber(1003440),"bir milyon uc bin dort yuz kirk")
      checkEqual(readNumber(1003448),"bir milyon uc bin dort yuz kirk sekiz")

      checkEqual(readNumber(42000456123),"kirk iki milyar dort yuz elli alti bin yuz yirmi uc")
      checkEqual(readNumber(42789000123),"kirk iki milyar yedi yuz seksen dokuz milyon yuz yirmi uc")
      checkEqual(readNumber(42789456000),"kirk iki milyar yedi yuz seksen dokuz milyon dort yuz elli alti bin")
      checkEqual(readNumber(42789456123),"kirk iki milyar yedi yuz seksen dokuz milyon dort yuz elli alti bin yuz yirmi uc")

      checkEqual(readNumber(1042789456123),"bir trilyon kirk iki milyar yedi yuz seksen dokuz milyon dort yuz elli alti bin yuz yirmi uc")

if __name__ == '__main__':
    main()

scan · Şubat 29, 2020, 10:16ös

Hepinizin ellerine sağlık:) Benim de ilk öğrenmeye başladığım zaman aklıma takılmıştı bu konu. Bilhassa tersten dizme zor(unlu)luğu çok heyecan verici gelmişti… Ama if’li else’li yaparsam sonu gelmez diye düşünüp bir for döngüsünde bitireyim işi demiştim… (kısacık kodlar, en sevdiğim )

while True:
    sayi = input("Sayı girin: ")
    basamak = len(sayi)-1
    print(basamak)

    sayilar = [["BİR", "İKİ", "ÜÇ", "DÖRT", "BEŞ", "ALTI", "YEDİ", "SEKİZ", "DOKUZ", ""],
               ["ON", "YİRMİ", "OTUZ", "KIRK", "ELLİ", "ALTMIŞ", "YETMİŞ", "SEKSEN", "DOKSAN", ""],
               ["YÜZ", "İKİYÜZ", "ÜÇYÜZ", "DÖRTYÜZ", "BEŞYÜZ", "ALTIYÜZ", "YEDİYÜZ", "SEKİZYÜZ", "DOKUZYÜZ", ""],
               ["BİRBİN", "İKİBİN", "ÜÇBİN", "DÖRTBİN", "BEŞBİN", "ALTIBİN", "YEDİBİN", "SEKİZBİN", "DOKUZBİN", "BİN"],
               ["ON", "YİRMİ", "OTUZ", "KIRK", "ELLİ", "ALTMIŞ", "YETMİŞ", "SEKSEN", "DOKSAN", ""],
               ["YÜZ", "İKİYÜZ", "ÜÇYÜZ", "DÖRTYÜZ", "BEŞYÜZ", "ALTIYÜZ", "YEDİYÜZ", "SEKİZYÜZ", "DOKUZYÜZ", ""],
               ["BİRMİLYON", "İKİMİLYON", "ÜÇMİLYON", "DÖRTMİLYON", "BEŞMİLYON", "ALTIMİLYON", "YEDİMİLYON", "SEKİZMİLYON", "DOKUZMİLYON", ""]]

    # PROBLEM SAYI 5001980... BİRBİN!!

    yaziyla = ""

    for i in sayi:
        yaziyla += sayilar[basamak][int(i)-1]+" "
        basamak -= 1

    print(yaziyla)

Araya not aldığım gibi ‘5001980’ benzeri sayılarda bir sorun yaşamışım. Araya bir tek if atarak çözülebilir sanki ancak hiç içimden gelmiyor hala… Belki bir yer değişikliği öneriniz olur… Ne dersiniz…

Orhan61 · Mart 1, 2020, 7:12öö

Bende aynı sorunla karşılaştım ama if ile kurtuldum sorundan başka yol olabilirmi biraz düşünmek gerek

EkremDincel · Mart 21, 2020, 8:48ös

Ben de kodu bi baştan yazdım:

digit = ['sıfır', 'bir', 'iki', 'üç', 'dört', 'beş', 'altı', 'yedi', 'sekiz', 'dokuz']
digit2 = ['', 'on', 'yirmi', 'otuz', 'kırk', 'elli', 'altmış', 'yetmiş', 'seksen', 'doksan']
digit3 = ['milyon', 'milyar', 'trilyon', 'katrilyon', 'kentilyon', 'sekstilyon', 'septilyon', 'oktilyon', 'nonilyon', 'desilyon', 'andesilyon', 'dodesilyon', 'tredesilyon', 'katordesilyon', 'kendesilyon', 'seksdesilyon', 'septendesilyon', 'oktodesilyon', 'novemdesilyon', 'vicintilyon', 'anvicintilyon', 'dovicintilyon', 'trevicintilyon', 'katorvicintilyon', 'kenkavicintilyon', 'sesvicintilyon', 'septemvicintilyon', 'oktovicintilyon', 'novemvicintilyon', 'tricintilyon', 'antricintilyon']


onluk = lambda i: (digit[i] if i<10 else digit2[i // 10] + " " + digit[i % 10]) if i%10 else digit2[i // 10]
yüzlük = lambda i: onluk(i) if i < 100 else ("yüz " + onluk(i - 100) if i-100 else "yüz") if i < 200 else digit[i // 100] + " yüz " + onluk(i % 100) if i%100 else digit[i // 100] + " yüz"
binlik = lambda i: ("bin" if i == 1 else yüzlük(i) + " bin") if i else ""

def number_to_turkish(number):
    if not number: return "sıfır"
    number = str(number)
    l = []
    i = len(number)
    while i > 0:
        l.append(int(number[max(i-3, 0):i]))
        i -= 3
        
    if temp := yüzlük(l[0]): k = [temp]
    else: k = []
    if len(l) == 1: return k[0]
    if temp := binlik(l[1]): k.insert(0, temp)

    if len(l) == 2: return " ".join(k)
    for i, j in enumerate(l[2:]):
        if j: k.insert(0, yüzlük(j) + " " + digit3[i])
    return " ".join(k)

Side effecti olmayan fonksiyonları bir lambda’ya sıkıştırmak çok hoşuma gitmeye başladı