Bu kodu daha kısa nasıl yaparım?

def DNA(string):
    o={"A":"T",
         "T":"A",
         "G":"C",
         "C":"G"}
   text = " "
   for i in string:
        text=text+o[i]
  return text
nucleotides = {"A":"T", "T":"A", "G":"C", "C":"G"}
DNA = lambda s: "".join(map(nucleotides.__getitem__, s))

map fonksiyonunu anlamaya çalışıyorum açıklayabilir misinz

Kendisine verilen fonksiyonu (ilk parametre) kendisine verilen iterable’ın (ikinci parametre) bütün elemanları ile çağırarak sırası ile döndürüyor.

peki bu işi nasıl yapıyor bildiğim üzere fonksiyonlarda returnden sonra loopu kesiyor

map fonksiyonu bir iterable döndürüyor, yani yield deyimini kullanıyor gibi düşünebilirsiniz.

peki sizce map fonksiyonun içi nasıl yield olsa ozaman next() lazım değilmi
pekiştirmek istediğim için böyle soruyorum kusuruma bakmayın

İstiyorsanız kendiniz next fonksiyonunu map fonksyonunun döndürdüğü değer ile kullanmayı deneyin :slightly_smiling_face:

kod:print(next(map(lambda s:print(s), range(12)))
sonuç=

0
None

yani anladım iterable döndürüyor

peki burda next kullanmıyoruz nasıl yapıyoruz
ve tahmin ediyorumki join metodu stringlere eleman eklemek için kullanılıyor

Zaten str.join metodu next kullanır. list fonksiyonu da kullanır. tuple fonksiyonu da kullanır. Bunların hepsini herhangi bir iterable ile kullanabilirsiniz. Zaten ilk parametrelerinin ismi “iterable”.

anladım saolun ama anlamadığım birşey var kodumu şöyle çalıştırdım olmadı

def DNA(string):
   o={"A":"T","T":"A","G":"C","C":"G"}
   text = ""
   for i in string:
        text.join(o[i])
        print(text)
   return text


print(DNA("AAT"))

ama şöyle yaptığımda da olmuyorr(generator ile yaptığımda)

def DNA(string):
   o={"A":"T","T":"A","G":"C","C":"G"}
   text = ""
   text.join((o[i] for i in string))
        
   return text


print(DNA("AAT"))

text.join işlemi text değişkenini değiştirmiyor, sadece sonuç döndürüyor.

anladım saolun 20 karakter

“20 karakter” yazmak yerine boşluk da bırakabilirsiniz :smiley:

mantıklı aslında düşündüm sonra heralde öyle değildir dedim :smile: :smile:

Daha da kisaltalim:

l.__getitem__ ile
lambda x:l[x]

ayni boyda, hmm. Yarin/oburgun λ gibi unicode literal’leri getirirlerse 4 karakter / 3 byte kazanabiliriz ama simdilik bir kazanc yok.

Bunun disinda iki bariz sey var: Bosluklar ve nucleotides’in deklarasyonu. Ikisini de kaldirirsak:

DNA=lambda s:" "+"".join(map(lambda x:{"A":"T","T":"A","G":"C","C":"G"}[x],s))

78 karakter.

Hmm, peki map yerine list comprehension kullansak?

DNA=lambda s:" "+"".join([{"A":"T","T":"A","G":"C","C":"G"}[x] for x in s])

75 karakter.

Aslinda numara yapan bir tane daha bosluk var:

DNA=lambda s:" "+"".join([{"A":"T","T":"A","G":"C","C":"G"}[x]for x in s])

Son cevap olacaksa su cift tirnaklari da duzeltmekte fayda var:

DNA=lambda s:' '+''.join([{'A':'T','T':'A','G':'C','C':'G'}[x]for x in s])

(Iki tirnagin da oldugu ve birinin daha cok escape’e sahip oldugu dillerde kodda semantik manasi olan string’leri az escape’li olanla deklare etmeyi tercih ediyorum.)

Fonksiyonun tuketeni insan ise bir kisim cift tirnaga geri donebiliriz, hatta su bastaki igrenc boslugu da atip 70 karaktere inebiliriz! :

DNA=lambda s:"".join([{'A':"T",'T':"A",'G':"C",'C':"G"}[x]for x in s])

list comprehension yerine generator expression kullansak
2 karakterden daha kurtulmuş oluruz :d
DNA=lambda s:"".join({'A':"T",'T':"A",'G':"C",'C':"G"}[x]for x in s)

1 Beğeni

Ben kodun gerçek anlamda uzunluğunu çok düşünmemiştim ama madem işi zorladık benim aklıma da bu geldi :slightly_smiling_face:

DNA=lambda s:"".join(dict(zip("ATGC","TACG"))[x]for x in s)

59 karakter.


Fonksiyona paslarken parantezleri silmeyi de ilk defa görüyorum :thinking:


Hem aynı boyda, hem de bir iş için iki fonksiyonu çağırmaya gerek yok diye düşünmüştüm.

1 Beğeni

A bak bunu bilmiyodum.

Cok iyi! Nasil aklima gelmedi :frowning:
dict()'le filan da ugrasmistim pair’lerden ikisi diger ikisinin tersi diye.