Vim'le janjanlı kod yazma hedesi

öhüm 4 günde 9 vizeye girdim kafamda hasar oluştu galiba yaklaşık 100 formül ve 400'e yakın kavramı 15-20 saat gibi kısa bir sürede ezberleyip son derece yüksek seviyede matematik maymunluklarıyla uygulamasını aşkı meşk eyleyip sınavları kendimce başarılı olarak atlatabilmenin haklı ve salak gururunu yaşıyorum sayın olmayan okuyucularım. extremeye baktım paso ubuntu sexy den geliyorlar benim bilmediğim ubuntu adında bi porno yıldızı felan mı var merak etmeye başladım:P

ve gelelüüm günün menüsüne:

vim unix tabanlı sistemlerin sanırım hepsinde olan günün birinde lazım olursa diye Robin Burk'ün UNIX kitabında koca bir bölümünü ona ayırdığı belgeler.org da çok güzel bir giriş klavuzu bulabileceğiniz emacs ile kapıştığı rivayet edilen emacsı beceremeyen ben insanının lanet olsun emacsına da şu çok zeki rmssine de diyip seçtiği gpl lisansına sahip güzel bir editördür.

hemen sitesinden araklıyalım:

What Is Vim?

Vim is a highly configurable text editor built to enable efficient text editing. It is an improved version of the vi editor distributed with most UNIX systems.

Vim is often called a "programmer's editor," and so useful for programming that many consider it an entire IDE. It's not just for programmers, though. Vim is perfect for all kinds of text editing, from composing email to editing configuration files.

What Vim Is Not?

Vim isn't an editor designed to hold its users' hands. It is a tool, the use of which must be learned.

Vim isn't a word processor. Although it can display text with various forms of highlighting and formatting, it isn't there to provide WYSIWYG editing of typeset documents. (It is great for editing TeX, though.)

kaynak: http://www.vim.org/about.php

sitesinden indirip kullanabilirsiniz. linux dağıtımı kullanıyorsanız zaten hazır olarak gelicektir.

bu vim hedesinin içinde :syntax on dedik mi her yer renkleniyor işte syntaxa göre renklendirme yapılıyor.

eğer kodu yazarken boşlukları kendisi versin derseniz

:set cindent

:set sw=4

burda girinti sayısını 4e ayarladık. ama eğer bunları her defasında yapçam mı ben derseniz ubuntudakiler için anlatayım diğer linux kullanıcılarında da buna benzerdir. etcnin içinde vim, vimin içinde de vimrc diye bir dosya var bunda değişiklik yapmamız gerekiyor. ancak root değilken gücümüz bu dosyayı değiştirmeye yetmiyor.

uçbiride :~$ gksu nautilus diyip GÖLGÖLERİN GÜCÜ ADINA GÜÇ BENDE ARTIK ROOHAAAAN diye bağırıp etc/vim/vimrc ye on penguen tıklama gücüyle ulaşıyoruz. oranın sonuna

autocmd BufRead,BufNewFile *.py syntax on
autocmd BufRead,BufNewFile *.py set ai
autocmd BufRead,BufNewFile *.cpp syntax on
autocmd BufRead,BufNewFile *.cpp set ai
autocmd BufRead,BufNewFile *.c syntax on
autocmd BufRead,BufNewFile *.c set ai

autocmd BufRead,BufNewFile *.py set cindent
autocmd BufRead,BufNewFile *.py set sw=4
autocmd BufRead,BufNewFile *.cpp set cindent
autocmd BufRead,BufNewFile *.cpp set sw=4
autocmd BufRead,BufNewFile *.c set cindent
autocmd BufRead,BufNewFile *.c set sw=4

ekleyip olayı kökünden çözüyoruz.

dip not:

autocmd BufRead,BufNewFile *.py syntax on
autocmd BufRead,BufNewFile *.py set ai

kısmını pyton.orgdan çaldım gerisini kendim uydurdum. bi sorun çıkarsa affola:P

günün konusunu resimsiz bırakmak olmaz:

Python yapay sinir ağı modülü

yeni savaşımım bu kodla olucak. pythonda yapay sinir ağı çalışması (bpnn.py) bakalım çözebilcem mi=)

# Back-Propagation Neural Networks
#
# Written in Python. See http://www.python.org/
# Placed in the public domain.
# Neil Schemenauer

import math
import random
import string

random.seed(0)

# calculate a random number where: a <= rand < b
def rand(a, b):
return (b-a)*random.random() + a

# Make a matrix (we could use NumPy to speed this up)
def makeMatrix(I, J, fill=0.0):
m = []
for i in range(I):
m.append([fill]*J)
return m

# our sigmoid function, tanh is a little nicer than the standard 1/(1+e^-x)
def sigmoid(x):
return math.tanh(x)

# derivative of our sigmoid function
def dsigmoid(y):
return 1.0-y*y

class NN:
def __init__(self, ni, nh, no):
# number of input, hidden, and output nodes
self.ni = ni + 1 # +1 for bias node
self.nh = nh
self.no = no

# activations for nodes
self.ai = [1.0]*self.ni
self.ah = [1.0]*self.nh
self.ao = [1.0]*self.no

# create weights
self.wi = makeMatrix(self.ni, self.nh)
self.wo = makeMatrix(self.nh, self.no)
# set them to random vaules
for i in range(self.ni):
for j in range(self.nh):
self.wi[i][j] = rand(-2.0, 2.0)
for j in range(self.nh):
for k in range(self.no):
self.wo[j][k] = rand(-2.0, 2.0)

# last change in weights for momentum
self.ci = makeMatrix(self.ni, self.nh)
self.co = makeMatrix(self.nh, self.no)

def update(self, inputs):
if len(inputs) != self.ni-1:
raise ValueError, 'wrong number of inputs'

# input activations
for i in range(self.ni-1):
#self.ai[i] = sigmoid(inputs[i])
self.ai[i] = inputs[i]

# hidden activations
for j in range(self.nh):
sum = 0.0
for i in range(self.ni):
sum = sum + self.ai[i] * self.wi[i][j]
self.ah[j] = sigmoid(sum)

# output activations
for k in range(self.no):
sum = 0.0
for j in range(self.nh):
sum = sum + self.ah[j] * self.wo[j][k]
self.ao[k] = sigmoid(sum)

return self.ao[:]


def backPropagate(self, targets, N, M):
if len(targets) != self.no:
raise ValueError, 'wrong number of target values'

# calculate error terms for output
output_deltas = [0.0] * self.no
for k in range(self.no):
error = targets[k]-self.ao[k]
output_deltas[k] = dsigmoid(self.ao[k]) * error

# calculate error terms for hidden
hidden_deltas = [0.0] * self.nh
for j in range(self.nh):
error = 0.0
for k in range(self.no):
error = error + output_deltas[k]*self.wo[j][k]
hidden_deltas[j] = dsigmoid(self.ah[j]) * error

# update output weights
for j in range(self.nh):
for k in range(self.no):
change = output_deltas[k]*self.ah[j]
self.wo[j][k] = self.wo[j][k] + N*change + M*self.co[j][k]
self.co[j][k] = change
#print N*change, M*self.co[j][k]

# update input weights
for i in range(self.ni):
for j in range(self.nh):
change = hidden_deltas[j]*self.ai[i]
self.wi[i][j] = self.wi[i][j] + N*change + M*self.ci[i][j]
self.ci[i][j] = change

# calculate error
error = 0.0
for k in range(len(targets)):
error = error + 0.5*(targets[k]-self.ao[k])**2
return error


def test(self, patterns):
for p in patterns:
print p[0], '->', self.update(p[0])

def weights(self):
print 'Input weights:'
for i in range(self.ni):
print self.wi[i]
print
print 'Output weights:'
for j in range(self.nh):
print self.wo[j]

def train(self, patterns, iterations=1000, N=0.5, M=0.1):
# N: learning rate
# M: momentum factor
for i in xrange(iterations):
error = 0.0
for p in patterns:
inputs = p[0]
targets = p[1]
self.update(inputs)
error = error + self.backPropagate(targets, N, M)
if i % 100 == 0:
print 'error %-14f' % error


def demo():
# Teach network XOR function
pat = [
[[0,0], [0]],
[[0,1], [1]],
[[1,0], [1]],
[[1,1], [0]]
]

# create a network with two input, two hidden, and one output nodes
n = NN(2, 2, 1)
# train it with some patterns
n.train(pat)
# test it
n.test(pat)



if __name__ == '__main__':
demo()

python kodları.2

x üssü n i hesaplayalım:

• n sıfırsa 1 çıktısı ver
• n mod 2 de 0 yani çift sayı ise
• x in x le çarpımını n/2 sayısıyla bu fonksiyonda yeniden çalıştır.
• böylece n/2k=1 e kadar xler kademeli olarak çarpılmış olacaktır.
• n tek sayı ise (yukardaki işlemlerden sonra elde ettiğimiz n/2k=1 de dahil)
• x çarpanını ayırıp n i çift sayı haline getirir ve çift sayılardaki işlemi uygular.

python kodları.1

sıfırdan n e kadar olan sayıların toplanması:



def ile topla isimli ve n girdili bir fonksiyon tanımlanmıştır.

sonuc=0 ve i=1 tanımlamaları yapılmıştır. bunlar ilerde kullanılacak değişkenlerdir. while ile i nden küçük ve eşit olduğu sürece çalışacak bir döngü oluşturulmuştur. her döngüde sonuç i ile toplanıp değeri arttırılacak ve i bir arttırılacaktır bölece i ne kadar artar ve return sonuc ile döngüden çıkıp sonucu elde eder.
mesela n=5 için döngüye bakalım:

• sonuc=s=0 ve i=1, i nden küçük ve döngü başlar:
• s= 0+1, i =1+1=2, n den küçük döngüye devam,
• s=1+2, i=2+1=3, yine nden küçük
• s=3+3, i=3+1, yine,
• s=6+4, i=4+1=5, n e eşit son bir döngü daha,
• s=10+5, i=5+1=6 ve nihayet n den büyük ve döngüden çıkar.
• return sonuc a gelir ve cevabı geri döndürür.

python kodları.0

bi sitede python kodları buldum. burada da anlayabildiklerimi yazmaya çalışacağım.


ilki faktöriyel hesaplama:


def ile fonksiyon tanımlanmış fonksiyonun adı faktoryel kullanılan girdi de n dir.

eğer n sıfıra eşitse program 1 çıktııs verir ve biter bunu return komutu sağlar.
sıfırdan farklı bir değerse n faktoryal (n-1) fonksiyonu ile çarpılıp işlem biter. ancak faktoryel n-1 sıfırdan farklı ise o fonksiyonda da (n-1) le faktoryel(n-1 - 1) işlemi vardır ve bu sıfıra kadar gider. sonuç olarak n(n-1)(n-2)(n-3)...(n-(n-2))(n-(n-1) e kadar sürer işlemimiz ve bu da n! e eşittir.

pythona devam II

Tüpler listeye benzer ama içerikleri değiştirilemez. Tüpün elemanları parantez içerisinde sıralanır. Program akışını hızlandırdıkları için programlarda dizilerin yerine kullanılırlar.



Sözlükler listelere benzerler ancak verilerin konumlarını 0 dan başlayan sayılar yerine kendimiz belirleyebiliriz. Bu konum kelimelerine anahtarlar denir. Sözlükteki anahtarları keys() fonksiyonu ile buluruz.

bilgi.keys() gibi.

bilgi.has_key('aranan anahtar') bir anahtarın o sözlükte olup olmadığını bulmamızı sağlar. varsa True yoksa False cevabını verir.

sözlüteki değerleri görüntülemek için values() fonksiyonunu kullanırız.

bilgi.values() gibi.

items() bir sözlükteki anahtar, değer ikililerini (tüplerini) elde etmemizi sağlar.

bilgi.items() şeklinde kullanılır.



yazılarda bahsedilen listeler sözlükler vetüpler iç içe kullanılabilinir.

get() ile sözlükteki bir anahtarın değerini getirir. eğer sözlükte o anahtar yoksa birşey yapmaz, hata vermez. get(x,y) de ise sözlükte eğer x anahtarı yoksa y ye geçer.

del() ile bir anahtarı sözlükten silebiliriz.

clear() ile bir sözlükteki bütün anahtarları ve bağlantılarını silebiliriz.



uptade() ile bir sözlükteki anahtarların değeri başka sözlüktekilerle değiştirilebilir.

>>> sos1={'ahe':2.999,'veha':11111,'dela':222}
>>> sos2={'ahe':3,'veha':0}
>>> sos1.update(sos2)
>>> sos1
{'dela': 222, 'veha': 0, 'ahe': 3}
>>>

python kitabından notlar I

kitabı yeni aldım geri dönüp bakabilmek için notlarım:

3. Bölüm:

>>> a=8
>>> a=a+22
>>> a
30


burada a ya a+22 ifadesi atanmıştır.

>>> c="çağdaş"
>>> c
'\xc3\xa7a\xc4\x9fda\xc5\x9f'
>>> print c
çağdaş

cümle değişkenlere Türkçe karakter atarken sorun çıkmıyor sadece python onu nasıl algıladığını belirtiyor. print c yazınca olması gerektiği gibi görünüyor.

>>> merhaba="Adana'ya ilk gelişiniz mi?"
>>> print merhaba
Adana'ya ilk gelişiniz mi?

kesme işaretiyle ayırmamız gereken bir yer olduğu için, en dışa tırnak işareti koyduk.

>>> arkadasim='"Burada dalmak çok güzel olur baksana cam gibi yukardan bakınca dip görünüyor" dedi.'
>>> print arkadasim
"Burada dalmak çok güzel olur baksana cam gibi yukardan bakınca dip görünüyor" dedi.

Burada alıntı yapmamız gerekti ve en dışa kesmeleri koyduk.

>>> a=9
>>> b="5"
>>>
>>> a=3
>>> b="9"
>>> c=a+b

Traceback (most recent call last):
File "", line 1, in
c=a+b
TypeError: unsupported operand type(s) for +: 'int' and 'str'

buradaki hata

>>> c=a+int(b)
>>> print c
12

yada

>>> c=str(a)+b
>>> print c
39

şeklinde çözülür.

int fonksiyonu cümle değerlerini tamsayıya çevirmek için kullanılır.

>>> int("765")
765

noktalı değerlerde float kullanılır.

>>> float("383.2")
383.19999999999999

str fonksiyonu ise ondalık veya tam sayıları cümle (string) değerlerine çevirmemizi sağlar.

>>> str("234")
'234'
>>> str(1321)
'1321'
>>> str(123.45)
'123.45'

>>> a=14
>>> a.__str__()
'14'

a.__str__() tarzı işlemler nesne modelinde kullanılır.

len() cümlenin uzunluğunu verir.

>>> len("Nasılsın komşu?")
18

>>> "Nasılsın komşu?".__len__()
18

Türkçe karakterlerin 2 olarak değeri olduğunu gördüm.

listeler

>>> p=['ysa', 'perl', 'ga']
>>> p[1]
'perl'
>>> p[:]
['ysa', 'perl', 'ga']
>>> p
['ysa', 'perl', 'ga']
>>> p[0]; p[2]
'ysa'
'ga'
>>> p=p+['pascal']
>>> p
['ysa', 'perl', 'ga', 'pascal']

>>> p[-1]
'pascal'
>>> p[-3]
'perl'

>>> p[1:3]
['perl', 'ga']
>>> p[1:2]
['perl']
>>> p[0:3]
['ysa', 'perl', 'ga']

>>> p.append('frp')
>>> p
['ysa', 'perl', 'ga', 'pascal', 'frp']

listeler birer nesnedir, nesnelerin özelliklerini görmek için dir(nesne) komutu kullanılır.

>>> p=p+['perl']
>>> p
['ysa', 'perl', 'ga', 'pascal', 'frp', 'perl']
>>> p.count('perl')
2

count() bir listedeki bir elemanın kaç tane bulunduğunu verir.

>>> p.extend(['common lisp','fortran'])
>>> p
['ysa', 'perl', 'ga', 'pascal', 'frp', 'perl', 'common lisp', 'fortran']

extend() 'le iki liste toplanır.

index() listedeki bir elemanın yerini verir. eğer birden fazla varsa ilk konumunu verir. olmayan bir elemanı sorgularsanız hata verir.

['ysa', 'perl', 'ga', 'pascal', 'frp', 'perl', 'common lisp', 'fortran']
>>> p.index('perl')
1

insert() listenin istenen yerine ekleme yapmak için kullanılır.

>>> p.insert(3,'scheme')
>>> p
['ysa', 'perl', 'ga', 'scheme', 'scheme', 'pascal', 'frp', 'perl', 'common lisp', 'fortran']

pop() listenin son elemanını siler.

>>> p.pop()
'fortran'
>>> p
['ysa', 'perl', 'ga', 'scheme', 'scheme', 'pascal', 'frp', 'perl', 'common lisp']

remove() eleman silmek için kullanılır. birden fazla varsa o elemandan ilkini çıkrarır.

>>> p.remove('perl')
>>> p
['ysa', 'ga', 'scheme', 'scheme', 'pascal', 'frp', 'perl', 'common lisp']

reverse() , diziyi ters çevirir.

>>> p.reverse()
>>> p
['common lisp', 'perl', 'frp', 'pascal', 'scheme', 'scheme', 'ga', 'ysa']

sort() listenizi sayılardan başlamak üzere alfabetik olarak sıralar.

['common lisp', 'perl', 'frp', 'pascal', 'scheme', 'scheme', 'ga', 'ysa']
>>> p=p+[16, 233]
>>> p
['common lisp', 'perl', 'frp', 'pascal', 'scheme', 'scheme', 'ga', 'ysa', 16, 233]
>>> p.sort()
>>> p
[16, 233, 'common lisp', 'frp', 'ga', 'pascal', 'perl', 'scheme', 'scheme', 'ysa']

len() listenizin kaç elemandan oluştuğunu bulursunuz

>>> len(p)
10

>>> p.__len__()
10

listeyi tamsayıyla çarpma listenin ardarda yazılmasıdır.

>>> x=['y','z']
>>> x*3
['y', 'z', 'y', 'z', 'y', 'z']
>>> x
['y', 'z']

yaptığımız işlemde x'i 3 le çarptık ama x'e başka bir değer atamadık. liste toplamında da bu böyledir.

>>> x
[1, 3, 5]
>>> y=x
>>> y.append(7)
>>> x
[1, 3, 5, 7]
>>> y
[1, 3, 5, 7]

buradali y=x x'e y etiketinin verildiğidir. ikisi ayrı nesneler olmuyor. onun için y'yi x den ayrıca kopyalamak gerekir.

>>> import copy
>>> x=[1,3,5]
>>> y=copy.deepcopy(x)
>>> y.append(7)
>>> y
[1, 3, 5, 7]
>>> x
[1, 3, 5]

şeklinde sorunumuz çözülür.

Tüpler listeye benzer ama içerikleri değiştirilemez. Tüpün elemanları parantez içerisinde sıralanır.

python'a giriş

bu aralar bu dile başladım (beraberinde common lisp ve scheme ye de bakmaya çalışıyorum). Pythonda öğrenebildiklerimi burda aktarmaya çalışacağım. python özgür yazılımdır. (açık kaynak, gnu). nesneye yönelimli bir dildir. öncelikle yüklemekle başlayabiliriz.

son sürümü şimdilik 2.5.1 dir. küçük bişidir.

buradan indirebilirsiniz..

linuxlarda hazır gelmektedir konsola python yazın gelicektir. ancak idle adında editörü de mevcuttur. ben ubuntu kullanıyorum ve kurduğumda idle yoktu, paket yöneticisinden kolayca yükledim. windows sürümünde dökümanları ve idle'yla birlikte gelmektedir.

yükleme işlemi bittikten sonra konsola idle yazın gelicektir. (uygulamalar>programlama>idleden de açabilirsiniz ama konsoldan açmak kadar sağlıklı olmadığı tecrübe edilmiştir)

karşımıza aşağıdaki gibi bir pencere gelmesi lazım.





şimdi ilk işimiz yazılımın kutsal olayını gerçekleştirmek.

>>>print "merhaba, dünya!"

yazın.

>>> 1 + 1
2
>>> a=3
>>> b=5
>>> a*3
9
>>> a,b = 5,20
>>> a+b
25

direkt x=10 gibi tanımlamalar yapabilirsiniz. yada a,b örneğinde olduğu gibi iki değişkeni de aynı anda tanımlayabilirsiniz.

>>> u=v=d=11 şeklinde de tanımlama yapabilmeniz mümkün.




>>> type(3.2)

>>> type("asasasas")

>>> type(33)


şekinde verilerin tipini öğrenebiliriz.

type fonksiyonu harf karakterleri direkt tanımaz hata verir. bu yüzden direkt yazmak yerine onları da tanımlayabiliriz. evet sırf zevk için yapabiliriz bunu.

>>> asasas= "epoke pythonda da mı var?"
>>> print asasas
epoke pythonda da mı var?
>>> type(asasas)


virgüllü değerler:

>>> 7/3
2

veya

>>> 5/6
0

yazarsak virgülden sonrasını hiç tanımadığını görürüz. virgüllü sayıları elde etmek için

>>> 7.0/3
2.3333333333333335
>>> 5/6.0
0.83333333333333337

şeklinde işlemlerimizi yapabiliriz.





idle' de yazdığınız betikleri direkt kaydedemezsiniz. çünkü orası etkileşimli bir ortamdır ve yazdıklarınız python tarafından anında yorumlanır.

sorunu çözmek çok basit, menüden File>New window u seçip oraya yazarsınız ve orada yazdıklarınızı kaydedip daha sonra tekrar çalıştırabilirsiniz.

şimdi değişken atamalardan devam edelim.

değişkenimizi atarken (kilo=5 gibi) karakterler arasında boşluk bırakmamalıyız onun yerine _ altçizgi kullanabiliriz.
dikkat etmemiz gereken diğer bir nokta da bazı anahtar kelimelerin değişken adı olarak kullanılamaması.

29 tane anahtar kelime vardır:

and else import raise
assert except in return
break exec is try
class finally lambda while
continue for not yield
def from or
del global pass
elif if print

Matematiksel ifadelerde öncelik parantez içlerinindir. Daha sonra üslü ifadeler gelir. Pythonda üslü ifadeler a**b şeklinde gösterilir. Matlab'de kullanılan ^ işareti kullanılmaz. o işaret iki sayının farkının mutlak değerini elde etmek için kullanılır. Üslü ifadelerden sonra çarpım (*) ve bölüm (/) işlemleri aynı öncelik sırasına sahiptirler. Bu iki işlemden sonra da toplama ve çıkarma gelir.

Karakterlerden oluşan elemanlar kendi aralarında toplanabilir, bu yan yana dizilmeleri şeklinde olur. Karakter elemanı bir sayıyla çarpılırsa ardarda çarpıldığı sayı kadar yazdırılır. Ancak karakter ve sayılar arasında toplama çıkarma ve ölme yapılamaz.


>>> a="Ali"
>>> b=" ata"
>>> c=" bak."
>>> print a+b+c
Ali ata bak.
>>> "Ali bak"*3
'Ali bakAli bakAli bak'
>>> "Ali bak. "*5
'Ali bak. Ali bak. Ali bak. Ali bak. Ali bak. '




Klavye girişleri:

Programınızda kullanıcıdan bilgi almak veya bazı fonksiyonların değerlerini kullanıcıdan istemek için girdi istenebilir. Pythonda input ve raw_input fonksiyonlarıyla bu girişler yapılabilir. input sayısal değerler için raw_input ise karakter girişi iin kullanılır. raw_input fonksiyonunda Türkçe karakterler sorun çıkarmaktadır.

>>> k=raw_input('bir cümle giriniz:')
bir cümle giriniz:Merhaba
>>> k
'Merhaba'
>>> l=input('bir sayı giriniz')
bir sayı giriniz148
>>> l
148

Kodunuzun neresinde hangi işlemleri yaptığınızı hatırlamak için yada başkaları tarafından kolay anlaşılır olması için # karakteri ile yorumlar koyabilirsiniz.

>>> #yorumların programda etkisi yoktur.