Python’da Dizeler ve Dize Fonksiyonları

Dize, bir karakter setidir. Bilgisayarlar karakterleri 0’ların ve 1’lerin bir kombinasyonu olarak saklayıp işlerler. Karakterlerin bu şekilde ikili sayılara dönüştürülmesine kodlama denir. ASCII ve Unicode, popüler kodlamalardan bazılarıdır. Klavyeden bir karakter girildiğinde bilgisayarın anladığı o karakterin ASCII (ya da Unicode) tablosundaki 0 ve 1’lerden oluşan kombinasyonudur. Daha önceki yazılarda da bahsedildiği gibi çift tırnak (“ ”) ya da tek tırnak (‘ ’) arasına karakterler yazılarak string (dize) tanımlanabilir. Bu string değişkenin içerisindeki her bir karaktere indeks numarası kullanılarak erişilebileceğini daha önceki yazılarda bahsetmiştim. Örnek olması için bu yazıda da bir değişken tanımlayıp, indeks numarasını yazdığımız bir karaktere erişelim.

Örnekler

INPUT:
  isim = "Mehmet" 
  isim[2]

OUTPUT:
   'h'

Bu yazıda sizlere bahsetmek istediğim bu string ifadeler üzerinde kullanabileceğimiz fonksiyonlardır. Bunlardan ilki len() fonksiyonudur. Bu fonksiyon dizenin uzunluğunu verir.

INPUT:
  sehir = "istanbul"
  len(sehir)

OUTPUT:
  8

in ve not in operatörlerini kullanarak, bir dize içerisindeki herhangi bir karakterin varlığını sorgulayabiliriz. in operatörü, karakter dize içerisindeyse True, değilse False sonucunu döndürür. Tam tersi olarak, not in operatörü, karakter dize içerisinde değilse True sonucunu, içindeyse False sonucunu döndürür.

INPUT:
  ulke = "Türkiye"  
  k in ulke
 
OUTPUT:
  True
INPUT:
  ulke = "Türkiye"  
  y not in ulke

OUTPUT:
  False

Diğer yandan, satır sonu karakterini (\n) kullanarak satırın sonlandığını belirtebilirsiniz. Böylece aynı dize içerisine yazılan ikinci cümle, bir satır aşağı alınarak çıktı olarak gösterilir. Örnek olarak:

INPUT:
  print("Bugün hava yağmurluydu.\nAncak yarın güneşli olabilir.")

OUTPUT:
   Bugün hava yağmurluydu. 
   Ancak yarın güneşli olabilir.

Sekme karakterini (\t) kullanırsak, dize içerisindeki kelimeler arasından belirgin bir boşluk bırakılır. Bu cümlelerin daha düzgün görünmesi için kullanılabilir. Örnek olarak:

INPUT:
  aday_listesi = [["Gökhan","İstanbul",3.42],["Aslı","Balıkesir",1.96], 
  ["Canan","Ankara",2.97],["Gizem","Tokat",1.96]]
  print("Aday","\t","Şehir","\t","\t","Ort.")
  for aday in aday_listesi:
      print(aday[0],"\t",aday[1],"\t",aday[2])

OUTPUT:
  Aday     Şehir       Ort. 
  Gökhan   İstanbul    3.42
  Aslı     Balıkesir   1.96
  Canan    Ankara      2.97
  Gizem    Erzurum     1.96

Cümle içerisinde, bir değişkene ait değeri kullanabilmek için format() fonksiyonunu kullanabiliriz. Bu fonksiyonu kullanmadan da değişkenin değerini cümle içerisine yazdırabiliriz. Ancak bu her veri tipi için farklı bir karakter kullanılmasını gerektirecektir. Burada yazılanları örnek ile gösterelim.

INPUT:
  gün1 = 26
  gün2 = "salı"
  print("Bugün ayın {0}’sı  ve günlerden {1}’dır.".format(gün1,gün2))
  print("---------------------------------------")
  macSaati = "23.00"
  print("Şampiyonlar ligi maçı %s’de başlar."%macSaati)
  print("---------------------------------------")
  piSayisi = 3.14
  print("pi sayını %f alınız."%piSayisi)
  print("---------------------------------------")
  KacTL = 200
  print("Yunus Emre’nin resmi %d TL’nin arka yüzünde vardır."%KacTL)
  print("---------------------------------------")
  print("Bugün kredi faizleri %s%f azaldı."%("%",1.5)) 
  print("---------------------------------------")
OUTPUT:
   Bugün ayın 26’sı ve günlerden salı’dır.
   ---------------------------------------
   Şampiyonlar ligi maçı 23.00’de başlar.
   ---------------------------------------
   pi sayını 3.140000 alınız.
   ---------------------------------------
   Yunus Emre’nin resmi 200 TL’nin arka yüzünde vardır.
   ---------------------------------------
   Bugün kredi faizleri %1.500000 azaldı.
   ---------------------------------------

upper() ve lower Fonksiyonu

Bir dizedeki tüm karakterleri büyük harfe ya da  küçük harfe dönüştürmek için kullanılan fonksiyonlardır. Örnek olarak:

INPUT:
  sehir1 = "Adıyaman"
  sehir1.upper() 

OUTPUT:
  'ADIYAMAN'
INPUT:
  sehir1 = "Adıyaman"
  sehir1.lower() 

OUTPUT:
   'adıyaman'

find() Fonksiyonu

Bir kelimenin cümle içerisinde olup olmadığını kontrol edebilmek için kullanılan fonksiyondur. find() fonskiyonunun avantajı aradığımız kelimelerin hangi konumda başladığını bize söylemesidir. Yukarıda da bahsettiğim gibi in operatörü kullanarak kelimenin ya da karakterin cümle içerisinde olup olmadığını sorgulayabilirdik. Ancak, in operatörü bize aranan kelimenin ya da karakterin konumunu vermez. Örnek olarak:

INPUT:
  sentence = "En sevdiğim gün Cuma’dır."
  sentence.find("Cuma") 

OUTPUT:
  16

Aradığımız kelime ya da karakter cümle içerisinde yok ise -1 değerini sonuç olarak döndürür.

Eğer bir kelimenin herhangi bir alt kelime ya da karakter ile başlayıp başlamadığını ya da bitip bitmediğini sorgulamak istersek startswith()  ve endswith() fonksiyonlarını kullanabiliriz. startswith(), kelimenin aradığımız alt kelime ya da karakter ile başlayıp başlamadığını kontrol ederken, endswith() ise bitip bitmediğini kontrol eder. True ya da False değerlerini döndürür.

INPUT:
  sentence.startswith("Benim") 

OUTPUT:
  False
INPUT:
  sentence.endswith("r.")

OUTPUT:
  True

split() Fonksiyonu

Cümleyi belirli bir karakter ya da kelimeye göre parçalamak için kullanılan fonksiyondur. Cümleyi parçalayıp bir liste olarak bize geri verir. Örnek olarak:

INPUT: 
  sentence = "Gizemli, bir sıfattır"
  sentence.split(" ")

OUTPUT:
  ['Gizemli', 'bir', 'sıfattır'] 

join() Fonksiyonu

split() fonksiyonu ile parçalara ayrılan ya da liste halinde verilen kelimeleri ya da karakterleri bir karakter ya da alt cümle kullanarak birleştirmek için kullanılan fonksiyondur. Örnek olarak:

INPUT:
  sentence1 = "Haritanın fiziki şartları gereği 25derece görünmektedir."
  words = sentence1.split(" ") 
  print("Ayrılmış hali :",words)
  bosluk = " "
  print("Birleştirilmiş hali : ", bosluk.join(words)) 

OUTPUT:
   Ayrılmış hali : ['Haritanın', 'fiziki', 'şartları', 'gereği', '25', 'derece', 'görünmektedir.']
   Birleştirilmiş hali :  Haritanın fiziki şartları gereği 25 derece görünmektedir.      

replace() Fonksiyonu

Cümle içerisindeki bir karakteri ya da kelimeyi istenilen karakter veya kelime ile değiştirmek için kullanılan fonksiyondur. Örnek olarak:

INPUT:
  cumle = "Bu-bir-python-yazısıdır"  
  cumle.replace("-",".")

OUTPUT:
  'Bu.bir.python.yazısıdır' 

strip() Fonksiyonu

Kullanıcı tarafından girilen ya da metin dosyalarından alınan cümlelerin başında veya sonundaki boşlukları atmak için kullanılır. Eğer cümlelerin sadece başındaki boşluklar atılmak isteniyorsa .rstrip() fonksiyonu, eğer sadece cümle sonundaki boşluklar atılmak isteniyorsa .lstrip() fonksiyonu kullanılabilir. Örnek olarak:

INPUT:
  x = "  Bu cümlenin başında ve sonunda boşluklar vardır.  "
  x.strip()

OUTPUT:
  'Bu cümlenin başında ve sonunda boşluklar vardır.'  

isnumeric() Fonksiyonu

Kullanıcı tarafından girilen cümlelerin sayı değerlerinden oluşup oluşmadığını kontrol etmek için kullanılan fonksiyondur. Eğer cümle sayılardan oluşuyorsa True, oluşmuyorsa False değerini döndürür. Örnek olarak:

INPUT:
  sayi = "1102" 
  sayi.isnumeric( )

OUTPUT:
   True
INPUT:
  uyeler = [["12345","Ali","10","5"],["67890","Gizem","20","7"],["10112","Mustafa","50","15"],["12134","Aslı","5","8"]]
  uyeNo = input("Lütfen üye numarasını giriniz : ")
  if uyeNo.isnumeric():
      for deger in uyeler:
          if deger[0] == uyeNo:
             print("Üye numarası {0} olan, {1} adlı kişinin hesabında {2} TL bakiye bulunmaktadır. Şu zamana kadar {3} adet kitap satın
             almıştır.".format(deger[0],deger[1],deger[2],deger[3]))
             break;
      else:
           print("Bu üye numarasına ait kişi bulunmamıştır.")
  else:
       print("Üye Numarası sayılardan oluşmalıdır.") 

OUTPUT:
   Lütfen üye numarasını giriniz : 12345
   Üye numarası 12345 olan, Ali adlı kişinin hesabında 10 TL bakiye bulunmaktadır. Şu zamana kadar 5 adet kitap satın almıştır.                                    

PYTNVK3L0T72C14L2U

Python’da Listeler

Liste Oluşturma

Bir değişkende birçok öğeyi saklamak için kullanılan yapılara liste denir. Listelere ait öğeler [ ] (köşeli parantez) içerisine yazılırlar. Eğer yazılacak öğe string ise ” ” (tırnak işareti) arasına yazılır. Öğeleri birbirinden ayırmak için virgül kullanılır. Basit bir liste aşağıdaki gibi tanımlanabilir:

names = [“Ahmet”, “Mehmet” , “Ali”, “Ayşe”]

Listenin içerisindeki öğelere erişmek mümkündür. Bunun için her bir öğenin indeks numarasının kullanması gerekir. İndeks numarası 0’dan başlayarak öğe sayısı kadar aritmetik olarak devam eder. Listeler tamsayı, dize ve nesne gibi veri türlerinden oluşabilirler. Aynı zamanda listeler sıralı ve değiştirilebilirlerdir.

example_list = [1,2,3,”Adnan”, [1,2,3]]

example_list[2] yazarsak 2 indeks numarasına sahip öğe çıktı olarak gözükür. Bu da 3 öğesidir. Python’da listelerin içerisindeki öğelere negatif indisler kullanılarakta erişilebilir. Örnek olarak example_list[-1] yazılırsa, en son öğe olan [1,2,3] öğesine erişilir.

Listeye Öğe Ekleme

Listeye öğe eklenildiğinde, eklenilen öğe listenin sonuna yazılır. Eğer listeye öğe eklemek istenilirse  .append() fonksiyonu kullanılabilir.

INPUT:

example_list = [1,2,3,"Adnan", [1,2,3]]
example_list.append(4)
example_list

OUTPUT:

[1, 2, 3, 'Adnan', [1, 2, 3], 4]

 

Yukarıdaki kod bloğunda yapılan işlemle listeye 4 elemanı eklendi. Listeler içerisindeki öğelerin değiştirilebileceği söylenmişti. Bu değişikliği yapmak için değiştirilmek istenen öğenin indeks numarasının kullanılması gerekir. Örnek olarak 1 öğesinin yerine 0 yazılsın.

INPUT:

example_list[0] = 0
example_list

OUTPUT:

[0, 2, 3, 'Adnan', [1, 2, 3], 4]

 

Liste Uzunluğunu Bulma

Listenin içerisindeki eleman sayısı listenin uzunluğunu verir. Listenin içerisindeki eleman sayısını bulmak için len() fonksiyonu kullanılır.

INPUT:

len(example_list)

OUTPUT:

6
 

.append() ile eklenilecek öğe listenin sonuna eklenir. Eklenilen öğenin konumunu kendiniz belirlemek istiyorsanız insert() fonksiyonunu kullanabilirsiniz. Bu fonksiyon insert(konum,değer) şeklinde kullanılır.

INPUT:

example_list.insert(0, "pi404")
example_list 

OUTPUT:

['pi404', 0, 2, 3, 'Adnan', [1, 2, 3], 4]

 

Bu iki ekleme fonksiyonun yanı sıra extend() fonksiyonu da listeye öğe eklemek için kullanılabilir. Bu fonksiyonun diğerlerinden farkı ise birden çok öğeyi listeye ekleyebiliyor olmasıdır.

INPUT:

example_list.extend([7,8,9])
example_list

OUTPUT:

['pi404', 0, 2, 3, 'Adnan', [1, 2, 3], 4, 7, 8, 9]

 
 

Listeden Öğe Çıkarma

Burada kadar gösterilenler listeye öğe eklemek için kullanılan fonksiyonlardı. Şimdi ise bir listeden öğe çıkarmak için kullanılan fonksiyonlardan bahsedelim. remove() fonksiyonu içerisine yazılan tek bir öğeyi listeden kaldırır.

INPUT:

example_list.remove(7)
example_list

OUTPUT:

['pi404', 0, 2, 3, 'Adnan', [1, 2, 3], 4, 8, 9]
 

Eğer listeden aynı öğeden birden fazla var ise ve bu öğe üzerinde remove() fonksiyonu kullanılırsa, indeks numarası önce olan öğe silinir. Aynı olan diğer öğeler ise listede durmaya devam eder.

INPUT:

example_list2 = [1,2,3,4,2]
example_list2.remove(2)
example_list2

OUTPUT:

[1, 3, 4, 2]

 

Bu fonksiyona benzer olarak pop() ve del fonksiyonlarıda kullanılabilir. pop() fonksiyonu kaldırılmak istenen öğenin  indeks numarası kullanılmalıdır. Örnek olarak

INPUT:

example_list.pop(2)
del   example_list[3]
example_list

OUTPUT:

['pi404', 0, 3, [1, 2, 3], 4, 8, 9]
 

Listenin içerisindeki tüm öğeleri silmek için clear() metodu kullanılabilir.

INPUT:

example_list2.clear()
example_list2

OUTPUT:

[]
 

Listelerde Kullanılan Başlıca Fonksiyonlar

index() Fonksiyonu

index() fonksiyonu liste içerisindeki bir öğrenin indeks numarasını öğrenmek için kullanılır. Örnek olarak,

INPUT:

example_list.index([1,2,3])

OUTPUT:

3
 
count() Fonksiyonu

Liste içerisindeki bir öğeden kaç adet olduğunu öğrenmek için count() fonksiyonu kullanılabilir.

INPUT:

example_list3 = ["a","a","a","a","a","a","b","c","d"]
example_list3.count("a")

OUTPUT:

6
 
sort() Fonksiyonu

Liste içerisindeki öğeleri küçükten büyüğe doğru sıralamak için sort() fonksiyonu kullanılabilir.

INPUT:

example_list4 = [5,8,14,7,6,9]
example_list4.sort()
example_list4

OUTPUT:

[5, 6, 7, 8, 9, 14]
 

Burada liste içerisindeki öğelerin hepsi ya dizelerden ya da sayılardan oluşmalıdır. Eğer dize ve sayılar birlikte olduğu bir listede sort() fonksiyonu kullanılırsa hata alınır.

INPUT:

example_list5 = ["Ali", 5]
example_list5.sort()
example_list5

OUTPUT:

----------------------------------------------------------------
TypeError         Traceback (most recent call last) 
<ipython-input-39-e362aaef30e4> in <module>()       
1 example_list5 = ["Ali", 5] 
----> 2 example_list5.sort()      
 3 example_list5 

TypeError: '<' not supported between instances of 'int' and 'str'
 
reverse() Fonksiyonu

Listenin içerisindeki öğeleri tersten yazmak için reverse() fonksiyonu kullanılabilir.

INPUT:

example_list3.reverse()
example_list3

OUTPUT:

['d', 'c', 'b', 'a', 'a', 'a', 'a', 'a', 'a']

 
copy() Fonksiyonu

Oluşturulan bir listenin kopyasını oluşturmak için copy() fonksiyonu kullanılır. Örnek olarak

INPUT:

copyList3 = example_list3.copy()
copyList3

OUTPUT:

['d', 'c', 'b', 'a', 'a', 'a', 'a', 'a', 'a']
 

Liste Oluşturmak için Alternatif Yöntemler

Liste oluşturmak için farklı birkaç yöntem daha kullanılabilir. Örneğin list() fonksiyonu kullanılarak, içerisine yazılan öğelerden bir liste oluşturulabilir.

INPUT:

new_list = list(("pencil","eraser","book", 5))
new_list

OUTPUT:

['pencil', 'eraser', 'book', 5]
 

Bu yöntemin dışında range kullanılarakta liste tanımlamak mümkündür. Örnek olarak:

INPUT:

NewList = [2*x+1 for x in range(10)]
NewList

OUTPUT:

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
 

Liste Dilimleme

Bu bölümde son olarak listelerin dilimlenmesinden ve üyelik testinden bahsedelim. Bir listeyi dilimlemek için a[m:n] ifadesi kullanılabilir. Burada m, dilimlenmeye hangi elemandan başlanılmak isteniyorsa, o elemanın indeks numarasını ifade ederken, n ise dilimlenmenin hangi elemanda son bulması isteniyorsa, o elemanın indeks numarasını ifade eder.

INPUT:

example_list6 = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
mini_list = example_list6[0:6]
mini_list

OUTPUT:

[0, 1, 2, 3, 4, 5]
 

a[m:n] ifadesini kullanarak liste içindeki elemanlardan yeni bir liste oluşturulabilir. Bu durum bir kümenin, alt kümesi gibi düşünülebilir. Ancak burada dikkat edilmesi gereken husus dilimleme ile oluşturulan yeni listenin içerisinde indeks numarası m olan değer bulunurken, indeks numarası n olan değer bulunmaz. Liste oluşturmanın yanı sıra dilimleme ile listenin birden fazla elemanına ulaşılabilir ve bu elemanlar üzerinde çeşitli işlemler yapabilir.

INPUT:

ListOfEvenNumbers = [ ]  
ListOfOddNumbers = [ ]              
for number in example_list6:      
       if number%2 ==0:
          ListOfEvenNumbers.append(number)
       else:
           ListOfOddNumbers.append(number)  
print("0-15 arasındaki çift sayılar kümesi = {}".format(ListOfEvenNumbers))
print("0-15 arasındaki tek sayılar kümesi = {}".format(ListOfOddNumbers))

OUTPUT:

0-15 arasındaki çift sayılar kümesi = [0, 2, 4, 6, 8, 10, 12, 14] 
0-15 arasındaki tek sayılar kümesi = [1, 3, 5, 7, 9, 11, 13, 15]
 

Eğer a[:] ifadesi kullanılırsa, listenin içerisindeki tüm elemanlar çağrılır. Örnek olarak:

INPUT:

example_list6[:]

OUTPUT:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
 

a[m:n:c] ifadesi liste içerisindeki m ile n arasındaki elemanları c(2 olsaydı,2’şerli atlayarak) atlayarak yeni bir liste olarak geri verir.  Örnek olarak:

INPUT:

example_list6[0:10:2]

OUTPUT:

[0, 2, 4, 6, 8]
 

Ayrıca liste içerisindeki elemanlar tersten yazılmak isteniyorsa, [::-1] ifadesi kullanılabilir. Örnek olarak

INPUT:

example_list6[::-1] 

OUTPUT:

[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
 

Üyelik Sorgulama

Üyelik sorgulaması ise bir elemanın liste içerisinde olup olmadığını öğrenmek için yapılır. in ve not in operatörlerini kullanarak bu sorgulama gerçekleştirilebilir. in operatörü eğer eleman liste içerisinde ise True, değilse False döndürür. not in operatörü ise eleman liste içinde değilse True, içinde ise False döndürür. Örnek olarak:

INPUT:

5 in example_list6

OUTPUT:

True

INPUT:

16 in example_list6

OUTPUT:

False

INPUT:

20 not in example_list6

OUTPUT:

True

INPUT:

3 not in example_list6

OUPUT:

False
 

Bir sonraki yazıda Python’dan bahsetmeye devam edeceğim.

PYTN2972U5XK85ULZ9

 

Python’da Operatörler, If-Else ve Döngüler

Bu yazıda sizlere karşılaştırma operatörleri, atama operatörleri, mantıksal operatörler ve döngüler gibi konulardan bahsedeceğim.

Karşılaştırma Operatörleri

Karşılaştırma Operatörleri iki değeri karşılaştırmak için kullanılır. Aşağıdaki tabloda karşılaştırma operatörlerini görebilirsiniz.

OperatörlerAdı
==Eşittir
!=Eşit değil
>Büyüktür
<Küçüktür
>=Büyük ya da eşit
<=Küçük ya da eşit

Karşılaştırma işlemleri True ya da False sonuçlarını verir. Yukarıdaki karşılaştırma operatörleri için örnek vermek gerekirse,

INPUT:

4 == 4

OUTPUT:

True

INPUT:

5 == 4

OUTPUT:

False

INPUT:

6 != 1

OUTPUT:

True
INPUT:

4 > 5

OUTPUT:

False

INPUT:

5 >= 2

OUTPUT:

True







-

Atama Operatörleri  

Python’da bir değişkene değer atamak için atama operatörlerini kullanabiliriz. Başlıca atama operatörleri tablodaki gibidir.

OperatörlerÖrnekAçıklama
=x = 8x’e 8’i atar.
+=x += 8x’e 8 ekler.
-=x -= 8x’ten 8 çıkarır.
*=x *= 8x’i 8 ile çarpar.
/=x /= 8x’i 8’e böler.
%=x %= 8x’in 8 ile bölümünden kalanı x’e atar.
//=x //= 8x’in 8’e bölümündeki bölümü, x’e atar.
**=x **= 8x’in 8 üssünü alır ve x’e atar.

Mantıksal Operatörler

OperatörlerAçıklamaKullanımı
andİki ifade doğruysa True döndürür.z>10 and z<20
orİki ifadeden biri doğruysa True döndürür.x>10 or x<11
notMantıksal durumu tersine çevirir. True ise False döndürür.not(x<10 and x<15)

Kimlik Operatörleri

Python’da kimlik operatörleri iki nesnenin bellek konumunu karşılaştırır.

OperatörlerAçıklamaKullanımı
isİki değişken aynı nesneyse True döndürür.x is y
is notİki değişken aynı nesne değilse True döndürür.x is not y

Üyelik Operatörleri

Üyelik operatörleri tuple’lar, string’ler ve listelerde bir nesnenin var olup olmadığını test etmek için kullanılır ve iki tanedir. Bunlar in ve not in’dir. in, belirtilen nesne tuple, string veya listenin içerisindeyse True sonucunu döndürür. not in, ise belirtilen nesnenin tuple, string ve listenin içerisinde değilse True sonucunu döndürür.

INPUT:

List1 = [1,2,3,4,5]

5 in List1

OUTPUT:

True

INPUT:

6 in List1

OUTPUT:

False

INPUT:

6 not in List1

OUTPUT:

True

 

 

 

 

 

 

 

 

 

 

Python’da Döngüler

Python’da çalışırken yineleme içeren işlemler yapabiliriz. Döngülerin amacı, aynı veya benzer kodu birkaç kez tekrarlamak. Bu tekrarlama belirli bir sayı kadar ya da bir koşul sağlanana kadar sürebilir. Python’da iki tane döngü mevcuttur. Bunlar for döngüsü ve while döngüsüdür.

For Döngüsü

For döngüleri, sabit sayıda tekrarlamak istediğimiz bir kod bloğu olduğunda kullanılır. Sırasıyla dizinin her bir elemanı üzerinde (liste, tuple, string, dictionary olabilir) yineleme yaparak her seferinde bloğu çalıştırır. For döngüsü, “range” ve “xrange” işlevlerini kullanarak bir sayı dizisi üzerinde yineleme yapar. range ile xrange arasındaki fark, range belirtilen aralıktaki sayılar ile bir liste döndürmesidir.

INPUT:

for i in range(0,10):
    print(i)

OUTPUT:
0 
1 
2 
3 
4 
5 
6 
7 
8 
9

INPUT:

t = 0
for k in range(100):
    t += k
print(t)


OUTPUT:

4950


INPUT:


people = ["Ahmet","Mehmet","Ali"]
for name1 in people:
  print("Kişi adı = {}".format(name1))


OUTPUT:


Kişi adı = Ahmet 
Kişi adı = Mehmet 
Kişi adı = Ali
INPUT:

for i in "pi404":
     print(i)

OUTPUT:

p 
i 
4 
0 
4

INPUT:

for x in range(3,30,3):  
    print(x) 
#3’den başlayıp 30’a kadar 3’er 3’er 
#artarak değerleri yazar.

OUTPUT:

3 
6 
9 
12 
15 
18 
21 
24 
27

INPUT:

List1 = [1,2,3,4,5]
new_list = []
for employee in List1:
    employee+= 5
    new_list.append(employee) 
new_list 

OUTPUT:

[6, 7, 8, 9, 10]

Break komutu bir for ya da while döngüsünden çıkmak için kullanılırken, continue komutu ise geçerli blogu atlamak için kullanılır.

INPUT:


stuff = ["bardak","kasik","catal","dolab","masa"]
for new_stuff in stuff:
      if new_stuff == "catal":
         print("Döngü bitti")
         break;

         
OUTPUT:

Döngü bitti

 

 

While Döngüsü

Belirli bir koşul gerçekleşene kadar devam eden döngülere while döngüleri denir.

INPUT:

num1 = 3
sumOf = 0
totalSum = 0
while sumOf < 100:
          sumOf = sumOf + num1
          totalSum +=1
print("Toplam = %d" % sumOf)
print("Döngü sayısı = %d" % totalSum)  

OUTPUT:

Toplam = 102 
Döngü sayısı = 34
INPUT:

list1 = [1,2,3,4,5]
i = 0
while list1[i] != 5:
           print("Seçili eleman = ", list1[i])
           i += 1

OUTPUT:


Seçili eleman =  1 
Seçili eleman =  2 
Seçili eleman =  3 
Seçili eleman =  4

For ve while döngülerinde, döngü bitiminde ya da döngü koşulu başarısız olduğunda yapmak istediğimiz bir eylem varsa else komutunu kullanabiliriz. Eğer döngüden break  komutu ile çıkılırsa, else blogu atlanır.

INPUT:

num1 = 10
while num1 > 5:
          num1-= 1
          print(num1)
else:
        print("Sayi 5’ten küçük, döngü sona erdi.")

OUTPUT:

9 
8 
7 
6 
5 
Sayi 5’ten küçük, döngü sona erdi.
 

İç İçe Döngüler

For ve While döngüleri iç içe döngü olarak kullanılabilirler. Ayrıca for döngüsünden oluşan iç içe döngü ve while döngüsünden oluşan  iç içe döngüler de yaratmak mümkündür.

INPUT:

#Çarpım Tablosu
for i in range(1,11):
      k = 1
      print("{} ile çarpım".format(i))
      while k < 11:
                multiply1 = i*k
                print("\n{}x{} = {}".format(i,k, multiply1))
                k = k + 1
      print("--------------------")

OUTPUT:

1 ile çarpım
 
1x1 = 1 , 1x2 = 2 , 1x3 = 3 , 1x4 = 4 , 1x5 = 5 , 1x6 = 6 ,   1x7 = 7 , 1x8 = 8 , 1x9 = 9 , 1x10 = 10 
--------------------
2 ile çarpım 

2x1 = 2 , 2x2 = 4 , 2x3 = 6 , 2x4 = 8 , 2x5 = 10 , 2x6 = 12 , 2x7 = 14 , 2x8 = 16 , 2x9 = 18 , 2x10 = 20 
--------------------

...

-------------------- 
10 ile çarpım 
10x1 = 10 , 10x2 = 20 , 10x3 = 30 , 10x4 = 40 , 10x5 = 50 ,  10x6 = 60 , 10x7 = 70 , 10x8 = 80 , 10x9 = 90 , 10x10 = 100    
--------------------
 

IF-ELSE-ELİF

If-else blokları, programcı tarafından bir bool koşulunun doğru ya da yanlış olmasına göre belirtilen eylemleri gerçekleştirmeye yarayan özelliktir. Kullanımı ise aşağıdaki gibidir:

if (koşul):

       Koşul sağlanırsa çalışacak kodlar

elif (koşul):

       Yukarıdaki koşul sağlanmaz ve  bu koşul sağlanırsa çalışacak kodlar

else:

      Koşullar sağlanmazsa çalışacak kodlar 

 

INPUT:

x = int(input("Lütfen bir değer giriniz : "))
if x > 5:
   print("Girdiğiniz sayı 5’ten büyük")
elif x < 5:
   print("Girdiğiniz sayı 5’ten küçük") 
else:
   print("Girilen sayı 5’tir.")


OUTPUT:

Lütfen bir değer giriniz : 3 
Girdiğiniz sayı 5’ten küçük

INPUT:

num1 = int(input("Lütfen bir sayı giriniz : "))
if num1 %2 == 1:
   print("Girdiğiniz sayı tek sayıdır.")
else:
   print("Girdiğiniz sayi çift sayıdır.")

OUTPUT:

Lütfen bir sayı giriniz : 22 
Girdiğiniz sayi çift sayıdır.

Bir sonraki yazıda Python’dan bahsetmeye devam edeceğim.

PYTNT911Y115N6IC8U

 

Matlab’de Polinom Türevi ve Denklem Çözme

Bu yazıda sizlere Matematik’te sıklıkla karşımıza çıkan polinomların, türevlerinin ve denklem çözme problemlerinin Matlab’de nasıl hesaplandığından bahsedeceğim.

Polinom Türevi

Sabit katsayılı n. dereceden bir polinomun genel hali:

an xn + an-1 xn-1 + an-2 xn-2 + … + a1 x + a0 gibidir.

Bu polinomun türevi,

an n xn-1 + an-1 (n-1) xn-2 + an-2 (n-2) xn-3 + … + a1  şeklindedir.

Buna göre bir polinomun türevi alınabilir. Ancak bu türevi Matlab ile hesaplamak mümkündür. Bir polinomun Matlab’de türevini hesaplamak için polyder() fonksiyonu kullanılmalıdır. Bu fonksiyon içerisine polinomun katsayılarından oluşan satır vektörü yazıldığında sonuç olarak polinomun türevinin katsayılarından oluşan satır vektörü elde edilir. Örnek olarak P(x) = 5 x4 + 10 x3 + 3 x2 + x + 5 polinomunun türevini Matlab’de hesaplayalım.

INPUT:

>>p = [5 10 3 1 5]

OUTPUT:

p = 
    5    10     3     1     5

INPUT: 
  
>>polyder(p) 

OUTPUT: 
    ans =       2 >> % türev 20 x3 + 30 x2 + 6 x + 1 olarak elde edilir.
 

P(x) = 4 x2 + 5x + 3 ve P(x) = 5 x2 + 6 x + 5 iki polinomun çarpımının türevini Matlab’de hesaplayalım:

INPUT:

>>p1 = [4 5 0 3]


OUTPUT:

p1 = 
     4     5     0     3

INPUT: 
 >>p2 = [5 6 4] 

OUTPUT 

p2 = 

    5     6     4

INPUT: 
>>carpim = conv(p1,p2) 

OUTPUT: 

carpim =            20    49    46    35    18    12


INPUT: 
>>polyder(carpim)

OUTPUT: 
ans = 100 196 138 70 18 
>> %Polinomun türevi: 100 x4 + 196 x3 + 138 x2 + 70 x + 18

Parçalı Kesre Ayırma

Şimdi residue( ) fonksiyonundan bahsedelim. Bu fonksiyon tam kesir halinde verilen bir polinomu parçalı (basit) kesir şeklinde yazmamızı sağlıyor. A(x) ve B(x) iki polinom ise,

şeklindeki kesir ifadesini residue( ) fonksiyonu ile parçalı kesir halinde yazacağız. Öncelikle pay ve paydadaki polinomların katsayılarından oluşan satır vektörünü Matlab’de tanımlayalım.

b = [b1 b2 b3 b4 … bn]

b = [a1 a2 a3 a4 … an] şeklinde tanımlanır.

residue(b, a) fonksiyonunun kullanımı [r, p, k] = residue(b,a) gibidir. Burada r, n’inci parçalı kesrin payı, p, n’inci parçalı kesrin paydası ve k’da sabit terimdir. Böylece verilen tam kesrin parçalı hali aşağıdaki gibi olur:

Örnek olarak A(x)/B(x) = (x2 -2x+1)/ (x2 – 1) kesrini parçalı kesre ayıralım. Bu işlemi aşağıda görüldüğü gibi yapabiliriz:

INPUT:

>> b = [1 -2 1]

OUTPUT:

b =
    1    -2     1

INPUT: 
   >>a = [1 0 -1] 

OUTPUT: 
   a =     1     0    -1 

INPUT: 
>>[pay,payda,sabit] = residue(b,a) 


OUTPUT: 

 pay =        -2           0 
 
 payda =        -1         1 

 sabit =         1   

>> %Düzenlersek (-2/(x+1)) + (0/(x-1)) + 1 = (x-1)/(x+1) olarak bulunur.

 

 

Polinom ile ilgili daha fazla örnek çözümünü sonraki yazılarımızda paylaşmayı düşünüyorum. Şimdi ise Matlab’de birinci dereceden denklemlerin nasıl çözülebildiğine bakalım. Ancak denklem çözümüne geçmeden önce sizlere birkaç komuttan ve sembolik ifadeden bahsetmek istiyorum. Matlab’de integral, türev, limit ve denklem çözümü işlemleri hesaplarken sembolik nesnelere ihtiyacımız olur. Çünkü bu işlemlerde kullanacağımız fonksiyonlar sembolik nesneler ile çalışır. sym ve syms komutları bir değişkeni sembolik nesne yapmaya yarar. Örnek olarak: >> syms x; yazarsak, x değişkeni artık sembolik nesnedir.

pretty() ve simplify() Komutları

Aynı zamanda yaptığımız işlemlerin sonuçlarının daha anlaşılır ve sade olarak görülmesi için pretty() ve simplify( ) komutlarını kullanabiliriz. pretty( ) komutu, sembolik nesneden oluşan sonucun ekranda daha net olarak görünmesini sağlarken, simplify( ) komutu ise sonucu sadeleştirmek için kullanılır. Bu komutların kullanışlarını denklem çözümünde göstereceğim. Burada son olarak expand( ) ve factor( ) komutlarından bahsedeyim. expand( ) komutu, sembolik nesneden oluşan polinomların kuvvet açılımlarını yapmak içini factor( ) komutu ise kuvvet açılımı yapılmış polinomları eski haline dönüştürmek için kullanılır. Örnek olarak (x+1)9 ifadesinin kuvvet açılımını yapalım.

INPUT:

>>syms x;

>>kuvvet = (x+1)^9

OUTPUT:

kuvvet =
        (x + 1)^9 


INPUT:

>>expand(kuvvet)

OUTPUT:

ans =
      x^9 + 9x^8 + 36x^7 + 84x^6 + 126x^5 + 126x^4 + 84x^3 + 36x^2 + 9x + 1  

 

INPUT:

>>syms x;

>>acilim = x^9 + 9x^8 + 36x^7 + 84x^6 + 126x^5 + 126x^4 + 84x^3 + 36x^2 + 9x + 1

OUTPUT:

acilim =
 
         x^9 + 9x^8 + 36x^7 + 84x^6 + 126x^5 + 126x^4 + 84x^3 + 36x^2 + 9x + 1

INPUT:

>>factor(acilim)

OUTPUT:

ans =
 
      [ x + 1, x + 1, x + 1, x + 1, x + 1, x + 1, x + 1, x + 1, x + 1]

DENKLEM ÇÖZÜMÜ

solve() komutu: Verilen denklem ya da denklemlerin, sembolik nesnelerden yararlanarak köklerini bulan komuttur. Komut solve(BURAYA DENKLEM YAZILIR) şeklinde kullanılır. Öncelikle tek bilinmeyenli denklem örneklerine bakalım. Örnek olarak x2 – 6 x – 3 = sqrt(3 x – 5) denkleminin çözümünü solve komutunu kullanarak bulalım. Bu hesaplama işlemi için aşağıdaki işlemler yapılabilir:

INPUT:

>>syms x;

>>cozum = solve(x^2-6x-3-(3x-5)^(1/2));

>>cozum

OUTPUT:

cozum =
 
        7
>>

 

 

Bir başka örnek için e(x2 + 3 x) – 15 x = 0 denklemini Matlab’de çözelim. Bu ifadeyi Matlab’de aşağıda görüldüğü gibi çözebiliriz:

 

INPUT:

>>syms x;

>>cozum = solve(exp(x^2+3*x)-15);

>>cozum

OUTPUT:

cozum =
       (4log(15) + 9)^(1/2)/2 - 3/2,(4log(15) + 9)^(1/2)/2 - 3/2
>> 
 

İki ya da daha fazla bilinmeyenli denklemlerin çözümlerinde de aynı şekilde solve( ) komutu kullanılabilir. Bunun yanı sıra iki ya da daha fazla bilinmeyenli lineer denklemlerde solve( ) komutu kullanılmadan da çözüm bulmak mümkündür. Örnek olarak:

2x + 4y = 10

3x + 5y = 13 

lineer denklem sisteminin çözümünü bulalım.

Bunun için ilk olarak verilen denklemleri matris biçiminde yazalım. Bunu aşağıdaki gibi yazabiliriz:

[2 4 ; 3 5 ].[x ; y] = [10 ; 13]

Bu ifadede çarpma işlemi yapılırsa yukarıdaki denklem sistemi elde edilir. Eşitliğin iki tarafını soldan [2 4 ; 3 5]-1 ile çarpalım. Böylece,

[x ; y] = [2 4 ; 3 5]-1 . [10 ; 13] eşitliği elde edilir.

Eşitliğin sağ tarafındaki işlem yapıldığında bulmak istediğimiz x ve y değerlerine ulaşırız. Öncelikle Matlab’de eşitliğin sağ tarafında bulunan matrisleri tanımlayalım. Ardından [2 4; 3  5]  matrisinin tersiyle [10 ; 13] sütun vektörünü çarparak x ve y’yi elde edelim. Bu işlemin Matlab çıktısı aşağıdaki gibidir:

INPUT: 

>>A = [2 4;3 5];
>>A_tersi = inv(A)

OUTPUT:

A_tersi =
         -2.5000    2.0000
          1.5000   -1.0000

INPUT:

>>B = [10;13];
>>cozum = A_tersi*B

OUTPUT:

cozum =
              1.0000 2.0000 >>
 

Ancak bu denklem solve( ) komutu ile daha kolay bir şekilde çözülebilir. Aşağıda görüldüğü gibi çözüme ulaşılabiliriz:

INPUT:

>>syms x y;
>>[xc,yc] = solve(2x+4y-10,3x+5y-13)

OUTPUT:

xc =
 
    1

yc =
 
    2
>>
 

Başka bir yazıda Matlab’den bahsetmeye devam edeceğim.  

MTLB8E7953F7I2Q41W

 

Matlab’de Polinom Tanımlama,Toplama,Çarpma ve Bölme İşlemleri

Bu yazıda Matlab’de polinomların nasıl tanımlandığını ve polinomlar üzerindeki işlemlerden bahsedeceğim.

Polinom Tanımlama

Polinom, belirli sayıda bağımsız değişken ve sabit sayıdan oluşan ifadelerdir. Matematik’te karşımıza sıklıkla çıkan polinomların özellikle kökünü bulma, toplama, çarpma, polinom bölmesi, grafik çizdirme gibi işlemlerini Matlab’de gerçekleşleştirebiliriz. Bunları yapabilmek için ilk önce polinomu tanımlamamız gerekir. Farz edelim ki,

P(x) =a x5 + b x4 + c x3 + d x2 + e x + f

gibi bir polinom olsun. Bu polinomu Matlab’de bağımsız değişkenlerin azalan kuvvetlerine göre katsayılarından oluşan satır vektörü ile tanımlayabiliriz. Açıklamak gerekirse, p = [a  b  c  d  e  f] şeklinde tanımlanır. Örnek olarak: P1(x) = a x5 + b x3 +c x2 + f  gibi bir polinom olsun. Fakat bu polinom Matlab’e  p1= [a  b  c  f] diye tanımlarsak, Matlab’ın anlayacağı polinom  a x3 + b x2 +c x + f  polinomu olur. Çünkü Matlab’de azalan kuvvetlerin sırasıyla katsayıları yazılarak polinom tanımlanır. Bu tarz durumlarda olmayan kuvvetlerin katsayısına satır vektöründe 0 (sıfır) yazılmalıdır. Böylece Matlab, o kuvvetin polinom içinde olmadığını anlar. P(x) polinomu doğru bir şekilde tanımlamak için:

   p1= [a   0   b    c   0   f]  yazmalıyız.

Bir polinomu Matlab’e bu şekilde tanımlanır. Şimdi tanımladığımız bir polinomun kökünü nasıl bulacağımıza bakalım. Bunun için roots( ) komutu kullanılmalıdır. Örneğin P(x) =  x2 –  x + 6  polinomuna bakalım. Öncelikle bu polinomu Matlab’a tanımlayalım. p = [1  -1  6] olarak tanımlayabiliz. roots( ) komutu ile bu polinomun kökleri aşağıdaki gibi bulunur.

INPUT:

>> p = [1  -1  6] 

OUTPUT:
    
 p =
     1    -1     6 INPUT: >> roots(p) OUTPUT: ans = 0.5000 + 2.3979i 0.5000 - 2.3979i
 

 

Toplama

P1(x) = 6 x3 + 5 x2 + 10 x + 4 ve P2(x) = 6 x3 + 5 x2 + 10 x + 4 gibi iki polinomu Matlab’de toplamak isteyelim. Bunun için herhangi bir komut kullanmamıza gerek yok. Öncelikle polinomları Matlab’de tanımlayalım. Ardından “ + ” operatörünü kullanarak iki polinomu toplayalım.

INPUT:

>>p1 = [6  5 10 4]

OUTPUT:

p1 =
      6     5    10     4 INPUT: >>p2 = [4 5 6 7] OUTPUT: p2 =     4     5     6     7 INPUT: >> toplama = p1+p2 OUTPUT: toplama =          10    10    16    11 
 

Bu iki polinom toplandığında sonuç olarak P3(x) = 10 x3 + 10 x2 + 16 x + 11 polinomunu elde ederiz. Burada dikkat etmemiz gereken husus ise topladığımız iki ya da daha fazla polinomun boyutlarının eşit olmasıdır.

Çarpma

Matlab’de polinom çarpımı yapmak için conv( ) komutunu kullanabiliriz. conv() komutu katsayılardan oluşan iki satır vektörünü çarparak elde edilen polinomun katsayılarını verir.

Örnek olarak P1(x) = 4 x2 + 2 x + 2 ve P2(x) = 3 x2 + 5 x + 4 polinomlarını Matlab’de çarpalım.

INPUT:

>> p1 = [4 0 2 2]

OUTPUT:

p1 =
     4     0     2     2 INPUT: >> p2 = [3 5 2] OUTPUT: p2 =     3     5     2 INPUT: >> carpma = conv(p1,p2) OUTPUT: carpma = 12 20 14 16 14 4 %Elde edilen polinom %12x5+20x4+14x3+16x2+14x+4
 

 

Bölme

Polinomal bölme yapmak için deconv( ) komutunu kullanabiliriz. Bunun için aşağıdaki komutu kullanılabiliriz:

[bölüm,kalan] = deconv(bölünen,bölen)

Örnek olarak P1(x) = 3 x2 + 4 x + 2 ve P2(x) = 2 x + 1 polinomları olsun. Polinom bölmesi aşağıda görüldüğü gibi yapılabilir:

INPUT:

>> p1 = [3 4 2]

OUTPUT:

p1 =
     3     4     2 INPUT: >> p2 = [2 1] OUTPUT: p2 =     2     1 INPUT: >> [bolum,kalan] = deconv(p1,p2) OUTPUT: bolum =         1.5000    1.2500 kalan =         0         0    0.7500
 

Bir polinomun köklerini hesaplamak için roots( ) komutunu kullanıyorduk. Bunun tersi olarakta kökleri verilen bir polinomun kendisinide bulabiliriz. Bunu yapabilmek için poly( ) komutunu kullanmamız gerekir. Katsayılarını bulmak istediğimiz polinomun köklerini satır vektörü olarak tanımlamalıyız. Bu satır vektörünü poly( ) fonksiyonuna girdiğimizde aradığımız polinomun katsayılarını elde etmiş oluruz. Örnek olarak -1 ve 1 köküne sahip polinomu elde etmeye çalışalım. Bu işlem aşağıdaki gibi olur:

INPUT:

>>kokler = [-1 1]

OUTPUT:

kokler =
         -1     1 INPUT: >>poly(kokler) OUTPUT: ans =      1     0    -1 %bulunan polinom x2 - 1 polinomu olur.
 

Değer Hesaplama

Bir polinomun içerisine bir değer (x=5 gibi) yazarak hesaplamayı biliyoruz. Fakat bu işlemi Matlab’de yapmak için polyval( ) komutunu kullanmamız gerekir. polyval( ) fonksiyonu ile elemanları verilen bir polinomun sonucunu hesaplayabiliriz. Örnek olarak x=2 için P(x) = x3 + 3 x2 + 6 x + 1 polinomunun sonucunu Matlab’de hesaplayalım. Bu hesaplama işlemi için aşağıdaki işlemler yapılabilir:

INPUT:

>> p = [3 6 1]

OUTPUT:

p =
    3     6     1 INPUT: >> polyval(p,2) OUTPUT: ans =      25
 

Bir sonraki yazıda sizlere Matlab’de polinomların türevlerinin hesaplanmasından ve denklem çözümünden bahsedeceğim.

MTLB9965Q9972BE5Z8

 

Matlab’de Matris İşlemleri

Önceki yazıda sizlere Matlab’de vektörün nasıl tanımlandığından ve vektör üzerinde kullanabileceğiniz birkaç komuttan bahsetmiştim. Bu yazıda ise matrisin nasıl tanımlandığından ve matris üzerinde kullanabileceğiniz birkaç komuttan bahsedeceğim.

Matris Tanımlama

Matlab’de matris [a b c; d e f ; g h j] şeklinde tanımlanır. Matrisin satırlarını ayırmak için “(;), Noktalı virgül” kullanılır. Burada örnek olarak 3×3’lük bir matris tanımladım ama siz ihtiyacınız olan boyutta, matrisi yine bu şekilde tanımlayabilirsiniz.

 A = [1 2 3 ; 4 5 6 ; 7 8 9] biçiminde 3×3’lük bir matris tanımlayalım. Matrisin içerisinden herhangi bir elemana A(satır numarası, sütun numarası) şeklinde ulaşılır. Burada ise A matrisinin içerisinden 5 elemanına A(2,2) yazarak ulaşılabilir. Matris içerisindeki birden fazla elemana ulaşmak da mümkündür. Örnek olarak A(2, 2:3) yazarak çıktı olarak 2. satırın 2. ve 3. sütunlarının elemanları olan [5 6] değerlerini elde ederiz.

>> A = [1 2 3; 4 5 6; 7 8 9]

A = 

    1  2  3
    4  5  6
    7  8  9

>> A(2,2)

ans =

     5

>> A(2,2:3)

ans =
 
     5  6
 

Matrislere Sütun ya da Satır Ekleyip-Çıkarma

Tanımlanılan bir matrisi ihtiyaç duyulduğu taktirde sütun ya da satır şeklinde elemanlar ekleyip çıkarabiliriz. A matrisine x sütunu eklenmek isteniyorsa, [A, x] yazılabilir. Eğer ki y satırı eklenmek isteniyorsa [A; y] yazılması yeterlidir. Örnek olsun diye A matrisi tanımlamıştık. Bu A matrisine x = [10; 11; 12] vektörünü eklemek istersek, [A, x] yazarız. Bir başka vektör olan y = [13 14 15] vektörünü eklemek istersek, [A; y] yazarız.

INPUT:
  >>A = [1 2 3; 4 5 6; 7 8 9]  

OUTPUT:
  A =    1  2  3    4  5  6    7  8  9   

INPUT:
  >>x = [10; 11; 12]  

OUTPUT:
  x =    10    11    12  
 
INPUT:
  >>[A, x] 

OUTPUT:
ans =      1   2   3   10      4   5   6   11      7   8   9  12  
 
INPUT:
  >>A = [1 2 3; 4 5 6; 7 8 9] 

OUTPUT:
   A =    1  2  3    4  5  6    7  8  9 

INPUT:
  >>y = [13; 14; 15]

OUTPUT:
   x =    13 14 15 

INPUT:
  >>[A, y] 

OUTPUT:
 ans =      1   2   3      4   5   6      7   8   9 13 14 15  
  

Matrisin içerisinden satır ya da sütun silinmek isteniyorsa, A(satır numarası, : ) =[ ] veya A(:, sütun numarası) = [ ] yazılabilir. Burada dikkat edilmesi gereken detay ise matrisin tek bir elemanın silinememesidir. Bunun sebebi ise boyut uyumsuzluğunun ortaya çıkmasıdır. Ancak burada matrisin bir elemanını değiştirmek mümkündür. Örnek ile göstermek gerekirse, A[3,2] = 5 yazarsak yeni matrisimiz aşağıdaki gibi olur.

INPUT:
  >> A = [1 2 3; 4 5 6; 7 8 9]  

OUTPUT:
   A =    1   2   3    4   5   6    7   8   9  

INPUT: 
  >> A(1, :) =[ ]  %satır silme   

OUTPUT:
   A = 4 5 6  7 8 9

INPUT:
  >> A(:, 1) =[ ] %sütun silme 

OUTPUT:
   A = 5 6 8 9

INPUT:
  >> A(2,2) = 3 %değer değiştirme 

OUTPUT:
   A = 5 6 8 3
 

Matrisi Yeniden Boyutlandırma

Matlab’de matrislerle işlemler gerçekleştirilirken, matrisin boyutu işlemlerimize uygun olmayabilir ya da herhangi bir sorun olmamasına rağmen matrisin boyutunu değiştirip işlem yapmak isteyebilirsiniz. Bu durumda reshape() komutu kullanılır.

Örnek olarak B = [1 2; 2 5 ; 7 6] şeklinde (3×2)’lik bir matris tanımlansın. B matrisini (2×3) boyutuna getirmek için C = reshape(B, [2 , 3]) yazılması yeterlidir.

>> B = [1  2 ;  2  5 ; 7  6]

B =

   1   2
   2   5
   7   6

>> C = reshape (B,[2,3])

C =

   1   7   5
   2   2   6
 

Matrislerde Temel Bazı Kodlar

zeros komutu: zeros(m,n) şeklinde kullanılır. mxn’lik sıfır matrisi oluşturmaya yarar.

>> zeros(3,3)

ans =

     0   0   0
     0   0   0
     0   0   0

ones komutu: ones(m,n) şeklinde kullanılır. mxn’lik birlerden oluşan bir matris verir.

>> ones(3,4)

ans =

     1   1   1   1
     1   1   1   1
     1   1   1   1

eye komutu: eye(m,n) şeklinde kullanılır. mxn’lik birim matris oluşturur.‏‏‏‏‏

>> eye(3,3)

ans =

     1   0   0
     0   1   0
     0   0   1

rand komutu: rand(m,n), mxn’lik elemanları 0-1 arasında olan bir matris oluşturur. Elemanlar rastgele seçilir.

>> rand(4,4)

ans =

     0.8147   0.6324   0.9575   0.9572
     0.9058   0.0975   0.9649   0.4854
     0.1270   0.2785   0.1576   0.8003
     0.9134   0.5469   0.9706   0.1419

diag komutu: diag(A), köşegeni A matrisinin köşelerinden oluşan diagonal bir matris üretir.

>> A = [1 2 3; 4 5 6; 7 8 9]

A =

   1   2   3
   4   5   6
   7   8   9

>> diag(A)

ans =

     1
     5
     9

det komutu: Bir matrisin determinantını hesaplamak için kullanılır.

>> det(A)
%aynı matris için
ans =

     6.6613e-16

rank komutu: Matrisin derecesini(rank) hesaplamak için kullanılır.

>> rank(A)
ans =
     2

find komutu: Sıfır olmayan elemanların indeks numaralarını verir.

>> find(A)

ans =

     1
     2
     3
     4
     5
     6
     7
     8
     9

trace komutu: Matrisin köşe elemanlarının toplamını hesaplar.

>> trace(A)

ans =

     15

Önceki bölümde belirtilen komutlar matrislerde de kullanılabilir. Bu komutların kullanımları yukarıdaki komutların kullanımlarına benzerdir.

Buraya tıklayarak önceki yazı olan Matlab’de dört işlem ve temel fonksiyonlar yazısına gidebilirsiniz.

MTLB9XB739DUJU9147

 

Python’da Veri Tipleri

String Veri Tipi

String, çift ya da tek tırnak içerisine yazılabilen bir ya da daha fazla harf, sayı veya özel karakterlerden oluşan bir dizidir. Python’da karakter veri tipi bulunmaz. Tırnaklar arasına yazılan her karakter dizenin bir parçasıdır. Bu parçaların indeks numaralarını kullanarak her bir karaktere erişebiliriz. Aşağıda string veri tipinde bir değişken oluşturulmuş ve bir karakterin indeks numarası kullanılarak karaktere ulaşılmıştır.

INPUT:

isim = "Mehmet"

isim[4]   #İndeks numarası 4 olan karakter "e" dir.

OUTPUT:

' e '

Integer Veri Tipi

Pozitif veya negatif tam sayılardan oluşan 32 bit veri tipidir. Python’da bir tam sayı değerinin uzunluğu sistemin sahip olduğu bellek kapasitesi ile sınırlıdır. Ancak bu uzunluktan daha uzun bir sayı tanımlamak bellek kapasitesi yeterli sistemler için mümkündür.

Long Veri Tipi

Çok daha uzun tam sayıları tanımlamak için kullanılan 64 bitlik veri tipidir.

Float Veri Tipi

Ondalık sayılardan oluşan 64 bitlik veri tipidir.

Complex Veri Tipi

a+bj şeklinde gerçek ve sanal kısımdan oluşan kompleks sayıları ifade eden veri tipidir.

List Veri Tipi

List, birbirinden farklı veri tipine sahip ögeleri barındırabilen, sıralı ve değiştirilebilir veri tipidir. Listeler, [ ] arasına yazılan değerler ile tanımlanabilir. Metinsel(string) değerler “ ”(tırnak) içerisinde yazılması gerekirken numerik değerler(int,long,float) normal yazılır. Liste içerisindeki değerler birbirlerinden “ , ” (virgül) ile ayrılır. Burada da bir ögenin indeks numarası kullanılarak ögeye ulaşılabilir hatta değiştirilebilir.

Tuple Veri Tipi

Tuple, list veri tipi gibi sıralı ögelerden oluşan veri tipidir. Tuple ile list arasındaki fark ise tuple’ın değiştirilemez olmasıdır. Tuple ( ) içerisine yazılan değerler ile tanımlanır.

Dictionary (Sözlük) Veri Tipi

Sözlük, veri değerlerini (anahtar:değer) çiftlerinde tutmak için kullanılan veri tipidir. Sözlüklerin içerisindeki içerisindeki çiftler hemen hemen her veri tipinden oluşabilen, sıralanmamış ve değiştirilebilir ögelerdir. Sözlükler { } (süslü parantez) ile yazılırlar. Bir sözlük içerisindeki anahtarların değerlerini tek tek çağırabiliriz.  Ayrıca bu anahtarların tiplerini de sorgulayabiliriz.

Boolean Veri Tipi

Mantıksal bir veri tipi olan boolean, True ve False olmak üzere iki değere sahiptir. Mantıksal olarak doğru olan duruma True, yanlış olan duruma ise False değeri karşılık gelir.

Python’da kod yazarken yukarıdaki veri tiplerine uygun olarak değişkenler tanımlayabilir ya da input( ) fonksiyonunu kullanarak dışarıdan kendimiz bir değişkene değer verebiliriz. Tanımladığımız ya da dışarıdan girdiğimiz değerlerin veri tiplerini değiştirmek mümkündür. Şimdi bu durumları inceleyelim.

String Veri Tipini Integer Veri Tipine Dönüştürme

String veri tipinde bir değişken tanımlayalım:

x = "12345"

Python, x değişkeninin değerini (“ ”) arasına yazıldığından string tipinde algılayacaktır. Bu string tipindeki x değişkenini int( ) fonksiyonunun içerisine yazarsak x değişkeni artık integer tipinde olur.

INPUT:

int(x)

print(type(x))

OUTPUT:

<class 'int'>

Burada dikkat edilmesi gereken husus tanımlanan bu string değerinin her bir karakterinin sayısal olmasıdır. Yoksa bu dönüştürme işlemi gerçekleşmez.

İki adet string tipinde değişken tanımlayalım:

 x = “1”  ve y = ” 2 ” şeklinde olsun. Burada x ve y’yi toplamayı denersek normal toplama işlemindeki gibi 3 değerini elde etmeyiz. String ifadeleri topladığımızda çıktı olarak iki ifadenin yan yana yazılmış halini görürüz.

INPUT:

x = "1"

y = "2"

print(x+y)

OUTPUT:

12

Örnek olarak tanımladığımız x değişkenini 4 değeri ile çarparsak çıktı olarak 4 defa arka arkaya yazılmış 1 rakamını görürüz.

INPUT:


x = "1"

print(4*x)

OUTPUT:

1111

Böylece toplama ve çarpma işlemlerinin string ifadeler için ekleme ve arka arkaya ekleme işlevlerinde kullanılabileceğini görmüş oluruz.

String Veri Tipini Float Veri Tipine Dönüştürme

Karakterleri rakamlardan oluşan string ifadeleri float() fonksiyonu ile float tipine dönüştürebiliriz.

INPUT:

x = "20.21"

y = float(x)

print(type(y))

OUTPUT:

<class 'float'>

Float ya da Integer’dan String’e Dönüştürme

Tanımladığımız sayısal bir değere sahip olan değişkeni str() fonksiyonu ile string tipine dönüştürebiliriz.

INPUT:

x = 10

y = str(x)

print(type(x))

OUTPUT:

<class 'int'>

Boolean Veri Tipini String Ve Integer Veri Tipine Dönüştürme

Boolean, True ve False değerlerine sahip veri tipi olduğunu belirtmiştik. Aşağıdaki örnekte boolean tipinde bir değişkenin integer ve string veri tiplerine dönüştürülmesi gösterilmiştir.

INPUT:

dogru_mu = True

print(type(dogru_mu))

y = int(dogru_mu)

print(type(y))

OUTPUT:

<class 'bool'>

<class 'int'>

ya da

INPUT:

dogru_mu = False

print(type(dogru_mu))

y = str(dogru_mu)

print(type(y))

OUTPUT:

<class 'bool'>

<class 'str'>

Bu tip dönüştürmenin tersi olan integerdan boolean’a ve string’ten boolean’a dönüştürmeyi örnekle gösterelim.

1-

INPUT:

sonuc = " dogru "

print(type(sonuc))

yeni_sonuc = bool(sonuc)

print(type(yeni_sonuc))

OUTPUT:

<class 'str'>

<class 'bool'>

2-

INPUT:

x = 10

print(type(x))

y = bool(x)

print(type(y)) 

OUTPUT:

<class 'int'>

<class 'bool'>

Böylece veri tiplerini ve tip dönüştürmelerini görmüş olduk. Şimdi ise matematiksel işleçlere göz atalım. Bu işleçleri aşağıdaki tablodan inceleyebilirsiniz.

İŞLEÇLERKARAKTER
Toplama+
Çıkarma
Çarpma*
Bölme/
Tam Sayı Bölme//
Mödüler Bölme%
Kuvvet Alma**

Bu işleçlerden faydalanarak birkaç tane problem çözüp konuyu sonlandıralım.

Örnekler

1- Yarıçapı 5 olan bir dairenin çevresini hesaplayınız.

INPUT:

r = 5

pi = 3.14

dairenin_cevresi = 2*pi*r


print("Dairenin Çevresi :{}".format(dairenin_cevresi))

OUTPUT:

Dairenin Çevresi : 31.400000000000002

2- Yukarı doğru v0 hızı ile atış hareketinde, cismin herhangi bir t anındaki yüksekliği -h = v0.t – (1/2) .g.t bağıntısı ile verilir. Yukarı doğru 20 m/s hızla atılan cismin 5 saniye sonra yüksekliğini hesaplayınız. (g = 9.81 m/s2 , π = 3.14 alınız.)

INPUT:

v0 = 10

t = 3

g = 9.81

h = v0*t-(1/2)*g*(t**2)

print("5 saniye sonra yükseklik : {}".format(-1*h))

OUTPUT:

5 saniye sonra yükseklik : 14.145000000000003

3- L uzunluklu bir basit sarkacın periyodu T = 2π(L/g)(1/2) olarak verilir. 5 m uzunluklu sarkacın periyodunu hesaplayınız. (g = 9.81 m/s2 , π = 3.14 alınız.)

INPUT:

L = 5

g = 9.81

pi = 3.14

T = 2*pi*((L/g)**(1/2))

print("Sarkacın Periyodu : {}".format(T))

OUTPUT:

Sarkacın Periyodu : 4.483427405990983

Bir sonraki yazıda Python’da karşılaştırmalar ve döngülerden bahsedeceğim.

PYTN6O05URZXMNUNQC

 

Python ile Temel Programlamaya Giriş

Bir önceki yazıda Python nedir ve hangi alanlarla kullanılır gibi pek çok konudan bahsetmiştim. Bu yazıda ise Python ile temel programlamaya giriş yapacağım. Python ile kod yazarken bir IDE’ye ihtiyaç duyulur. Bir IDE(Integrated Development Environment, Tümleşik Geliştirme Ortamı), yazılım geliştirme için bilgisayar programcılarına kapsamlı olanaklar sağlayan bir yazılım uygulamasıdır. Atom, Pycharm, IDLE, Jupyter, Spyder gibi IDE’leri kullanabilirsiniz. Bu yazıda sizlere örnek olarak göstereceğim kodlar Jupyter tabanlı Google Colab’ta hazırlanmıştır. Google Colab, Python kodlarını yazmaya yarayan, kurulum gerektirmeyen, ücretsiz, birçok kütüphaneyi içerisinde barındıran ve olmayan kütüphaneleri yüklemeye izin veren; web tarayıcıda çalışan ve bilgisayarınızdan GPU ve RAM kullanmayan bir geliştirme ortamıdır.

Google Colab ile ücretsiz olarak Tesla K80 GPU üzerinde uygulamalar geliştirebilirsiniz.  Çalışmalarınız Google Drive’e kaydedebilir ya da Google Drive’ınıza yüklediğiniz bir çalışmayı Google Colab’ta inceleyebilir ve düzenleyebilirsiniz. Google Colab hakkında daha fazla bilgi almak istiyorsanız buraya tıklayarak resmi sayfaya gidebilirsiniz.

Programlama Hataları

Her programlama dilinde olduğu gibi Python’da da çalışırken hata yapmamak mümkün değildir. Bir uygulama geliştirirken yazılan kodlardaki hataları bulmak ve çözmek geliştirme sürecinde en fazla zaman harcanan bölümü olabilir. Yazacağınız en küçük programda bile onlarca farklı hata çıkma ihtimali vardır. Kod yazarken karşımıza çıkabilecek hataların ne tür bir hata olduğunu bilmek hatayı daha kolay çözmemizi sağlayacaktır.

Yazım Hataları

Syntax (söz dizimi), üzerinde çalıştığımız programlama dilinin kendine has program yapısını ve bu yapının kurulmasında kullanılan kuralları ifade eder. Her programlama dilinin yazımı farklıdır. Python derleyicisi yazdığımız kodlarda bir syntax hatası fark ederse programı durdurur ve nerede syntax hatası olduğunu gösterir. Böylece bizler nerede ve ne tür bir hata yaptığımızı görmüş oluruz. Örnek olarak ad = “Mehmet yazarsak Python derleyicisi bize burada bir hata olduğunu söyleyecektir.

ad = "Mehmet

     File "<ipython-input-1-e098e0017e34>", line 1
          ad ="Mehmet
                     ^
SyntaxError: EOL while scanning string literal

Çünkü string bir değişken tanımlanmaya çalışılmış ancak doğru bir şekilde yazılmamıştır. String ifadeler (” “) arasına yazılarak tanımlanır. Doğrusu ad = “Mehmet” şeklinde olmalıdır.

Çalışma Zamanı Hataları

Bu tür hatalar kodların hatalı yazılmasından ziyade beklenilmeyen durumlarda ortaya çıkabilen hatalardır. Örnek olarak, çalışma yaptığımız bir dosya üzerinde düzenleme iznimiz yoksa ya da veritabanında çalışacak kodlar yazmışsak ve veritabanı ile bağlantı kurmamışsak program hata verecektir.

Anlamsal Hatalar

Python’da kod yazarken, yazdığımız kodlar hatasız bir şekilde çalışır ancak istediğimiz sonuçları vermez ve farklı sonuçlar verirse anlamsal hata ortaya çıkmış demektir. Bu tür hatalar farkedilmesi zor hatalardır. Örnek olarak 13 sonucunu elde edeceğiniz 6 + 20/2 işlemini Python kullanarak çözdünüz. Ancak program size 16 sonucunu verdi.  Burada program size bir hata çıktısı vermeyecektir. Çünkü bu durumda işlem önceliği hatası yapılmıştır. Program ilk olarak 20/2 işlemini gerçekleştirir, ardından bu sonuca 6 ekleyerek sonucu elde edip size gösterir. Düşündüğümüz sonucu elde etmek için ise (6+20)/2 şeklinde yazmamız gerekirdi.

Python’da Değişkenler Ve Veri Tipleri

Değişken (variable), girdiğimiz ya da atadığımız bazı değerlerin geçiçi olarak hafızada saklanması için oluşturulan alanlara denir. Bir değişkene herhangi bir değer atamak için “ = ” ifadesi kullanılır. Örnek olarak:

meslek = "Çiftçi"
dogum_yili = 1995
ondalik_sayi = 0.5

Eğer Python’da değişkene değer ataması yapılmazsa hata alınır. Yukarıda tanımlanılan üç değişkenin tipi sırasıyla string, integer ve float’tır. Burada yazılan değişkenleri kod bloğuna yazdığımızda herhangi bir çıktı göremeyiz çünkü herhangi bir komut vermedik. Ekranda çıktı görmek için print() fonksiyonunu kullanmalıyız. Böylece değişkenlerin değerlerini çıktı olarak görebiliriz. Eğer tanımladığımız bir değişkenin tipini görmek istersek type() fonksiyonunu kullanmalıyız.

type(meslek)
str

type(dogum_yili)
int

type(ondalik_sayi)
float

Tanımlanılan değişkenler harf ile başlayabilir, içerisinde sayı ve alt çizgi barındırabilir, büyük-küçük harf barındırabilirken herhangi bir sayıyla başlayamaz ve içerisinde alt çizgi hariç özel karakterler barındıramazlar. Değişken tanımlarken dikkat etmemiz gereken bir diğer hususta değişkenlere ileride hatırlanabilecek anlamlar verilerek tanımlamaktır. Örnek olarak 5 kişinin not ortalamasını hesaplayacak bir program yazmak istiyoruz. Burada ortalamayı hesaplayacak olan işlemi, alakalı bir değişkenin değeri olarak atamamızda fayda vardır.

kisi1 = 10
kisi2 = 50
kisi3 = 70
kisi4 = 85
kisi5 = 60
notlarin_toplami = kisi1 + kisi2 + kisi3 + kisi4 + kisi5
not_ortalamasi = otlarin_toplami/5
print("Notların Toplamı: ", notlarin_toplami)
print("Not Ortalaması: ", not_ortalamasi)

OUTPUT------------------
Notların Toplamı: 275
Not Ortalaması: 55.0

Python’da anahtar kelime olarak belirlenmiş kelimeleri değişken adı olarak kullanamazsınız. Bunlara örnek olarak print, if-else, class, False, none, break, import, while, for gibi kelimeler verilebilir.

Veri Tipleri

Python’da bulunan başlıca veri tipleri aşağıdaki gibidir:

  • String veri tipi (Metinsel veri tipi)
  • Integer veri tipi (Sayısal veri tipi)
  • Long veri tipi   (Sayısal veri tipi)
  • Float veri tipi (Sayısal veri tipi)
  • Complex veri tipi (Sayısal veri tipi)
  • List veri tipi
  • Tuple veri tipi
  • Dictionary veri tipi

Yukarıda sıralanan veri tiplerinden bir sonraki yazıda detaylı olarak bahsedeceğim.

 

PYTN0FBN4Y72459ALA

 

Pi Sayısı Nedir? Tarihi ve Önemi

Bu yazıda sitemize de adını veren, Matematiğin en önemli sabitlerinden birisi kabul edilen Pi sayısından bahsedeceğim.

Pi sayısı nedir?

Pi sayısı herhangi bir dairenin çevresinin, çapına olan oranıdır. Çemberin boyutu fark etmeksizin bu oran her zaman pi’ye eşittir. 1647’ye kadar evrensel bir adı veya sembolü yoktu Matematikçiler 1700’lü yıllarda Yunanca “çevre” anlamına gelen περιμέτρου (perimetros) kelimesinin ilk harfi olan π’yi sembol olarak  kullanmaya başlamışlardır. William Jones tarafından 1706 yılında tanıtılan sembol, 1737’de İsviçreli matematikçi Leonhard Euler’in sembolü benimsemesinin ardından kullanımı popülerleşti.

William Jones (1675-1749)

Leonhard Euler (1707-1783)

Pi sayısı nasıl hesaplanır?

1767’de İsviçreli matematikçi Johann Heinrich Lambert pi’nin irrasyonel olduğunu kanıtladı ve 1882’de ise Ferdinand von Lindemann pi’nin sonsuz olduğunu kanıtladı. Bu bulgu önemlidir, çünkü bu noktaya kadar “çemberin karesini almak” olarak bilinen eşit alanlı bir kare ve bir daire oluşturulabileceğine inanılıyordu. Pi’nin sonsuz olduğunu kanıtlamak bunun mümkün olmadığını gösterdi. Pi irrasyonel olduğundan diğer tüm irrasyonel sayılar gibi bir kesir (basit veya kaba kesir olarak da bilinir) olarak gösterilemez.  π sonsuz olduğu için cebirsel değildir. Bu da bize π’nin ikinci derecen bir irrasyonel olamayacağını gösterir. İkinci dereceden bir irrasyonel olamaması π’nin periyodik bir sürekli kesire de  sahip olmadığını ifade eder. Ancak, pi dahil her irrasyonel sayı, sürekli kesir adı verilen sonsuz bir iç içe geçmiş kesirler dizisi ile temsil edilebilir:

Kesrin herhangi bir noktada kesilmesi, π için rasyonel bir yaklaşıklık verir; bunların ilk dördü 3, 22/7, 333/106 ve 355/113’tür. Bu şekilde üretilen her yaklaşım, en iyi rasyonel yaklaşımdır; yani, her biri aynı veya daha küçük paydaya sahip diğer herhangi bir kesirden π’ye daha yakındır.

Pi Sayısının Tarihi

Erken Dönem Tarihi

Pi’nin tarihi, MÖ 2000 yılına kadar uzanır. Bu dönemlerde Babilliler ve Mısırlılar π’yi kullanmışlardır. Babilliler (yaklaşık MÖ 2000) pi’yi yaklaşık olarak 3,125 kullandılar; bu değer, bir daire içine yazılmış bir altıgenin çevresini hesaplayarak, dairenin çevresine oranının 24/25 olduğunu varsayarak elde ettikleri bir değerdi. Rhind Papirüsü (yaklaşık MÖ 1650) bize eski Mısırlıların 256/81 veya yaklaşık 3.16045 değerini kullandıklarını gösteriyor. Hem Babilliler hem de Mısırlılar pi değerine ilişkin kaba sayısal tahminlere sahipti ve daha sonra Antik Yunanistan’daki matematikçiler, özellikle Arşimet, pi’yi hesaplamak için algoritmik bir yaklaşım kullanan ilk kişi oldu. Arşimet, bir çemberin içine bir çokgen ve çemberin dışına ikinci bir çokgen çizdi. Sonra sürekli olarak çokgen ekleyerek çemberin şekline gittikçe yaklaştı. Böylece 96 kenarlı çokgenlere ulaşarak 223/71 <π <22/7 veya yaklaşık 3.1418 gibi ortalama bir değer elde etti. Arşimet ayrıca bir dairenin alanının, yarıçapının karesine oranının aynı sabit olduğunu ve bir dairenin alanının, tabanı bu dairenin çevresine ve yüksekliği ise yarıçapına eşit bir üçgenin alanına eşit olduğunu kanıtlamıştır. Benzer bir yaklaşım, Çinli matematikçi ve gök bilimci olan Zu Chongzhi (429-501) tarafından da kullanıldı. Bir çemberin çevresinin çapına oranının değerini 355/113 olarak hesapladı.

Arşimet’in kullandığı yöntem
Arşimet’in kullandığı yöntem
Görsel Kaynak: piday

MS 5.yüzyılda geometrik teknikleri kullanarak Hintli matematikçiler π sayısında beş haneye yaklaşırken, Çinli matematikçiler yedi basamaklı bir yaklaşım yaptı. MS 265 civarında, Wei Hanedanı matematikçisi Liu Hui, poligon tabanlı yinelemeli bir algoritma yarattı ve bunu 3.072 kenarlı bir çokgenle kullanarak 3.1416 değerini elde etti. Liu daha sonra hesaplamanın daha hızlı bir yöntemini icat etti ve ardışık çokgenlerin alanlarındaki farklılıkların 4 faktörlü bir geometrik seri oluşturmasından yararlanarak 96 kenarlı bir çokgenle 3.14 değerini elde etti. Hintli gök bilimci Aryabhata, Āryabhaṭīya’sında (MS 499) 3,1416 değerini kullandı. Fibonacci 1220’de, Arşimet’ten bağımsız bir poligonal yöntem kullanarak 3.1418’i hesapladı.

15. yüzyıl

Fars gök bilimci Jamshad al-Kāshī,  1424 yılında pi’nin yaklaşık 16 ondalık basamağına eşdeğer olan 9 altmışlık basamak üretti. Bu basamak değeri yaklaşık 180 yıldır dünya rekoru olmuştur. Madhava, 1400 civarında π’nin 11 hanesini tahmin etmek için sonsuz seriler kullandı, ancak bu değer, çokgen bir algoritma kullanarak Pers matematikçi Jamsh Jamd al-Kāshī tarafından yaklaşık 1430’da iyileştirildi.

16. ve 17. yüzyıl

Fransız matematikçi François Viète 1579’da 9 basamak elde etti. Flaman matematikçi Adriaan van Roomen ise 1593’te 15 ondalık basamağa ulaştı. 1596’da Hollandalı matematikçi Ludolph van Ceulen 20 haneye ulaştı, bu rekor daha sonra 35 haneye yükseldi. 1630’da Avusturyalı gökbilimci Christoph Grienberger, 1040 kenarlı çokgenleri kullanarak 38 basamaklı pi hesapladı.

On sekizinci yüzyıla gelindiğinde Fransız matematikçi Georges Buffon π’yi olasılığa dayalı hesaplamanın yolunu buldu (Buffon’un iğne problemi veya Buffon’s needle problem). Isaac Newton, 16 ondalık basamağı hızlı bir şekilde hesaplamak için binom teoremini kullanmış, 20. yüzyılın başlarında, Hintli matematikçi Srinivasa Ramanujan, daha sonra bilgisayar algoritmalarına dahil edilen pi hesaplamanın olağanüstü verimli yollarını geliştirmiştir.

π’nin hesaplanmasında, 16. ve 17. yüzyıllarda sonsuz seri tekniklerinin geliştirilmesi ile devrim yaratıldı. Sonsuz seriler, matematikçilerin π’nin hesaplamasını Arşimet ve geometrik teknikler kullanan diğerlerinden çok daha yüksek hassasiyetle yapmalarına olanak sağladı. π’yi hesaplamak için kullanılabilecek sonsuz bir dizinin ilk yazılı açıklaması Hintli gök bilimci Nilakantha Somayaji tarafından MS 1500 civarında Tantrasamgraha’da Sanskritçe dizesinde ortaya konmuştur. Bu açıklama seri kanıt olmadan sunulmasına rağmen kanıtlar ancak MS 1530 civarında daha sonraki bir Hint eserinde sunuldu. Nilakantha ise, bu seriyi daha önceki Hintli matematikçi Madhava’ya atfeder. Günümüzde Madhava serisi veya Gregory-Leibniz serisi olarak anılan sinüs, tanjant ve kosinüs serileri de dahil olmak üzere birkaç sonsuz dizi tanımlanmıştır.

Pi’nin Hesaplanması
Görsel Kaynak : piday
Yakın tarih ve günümüz

20. yüzyılın başlarına gelindiğinde π’nin yaklaşık 500 basamağı biliniyordu. Modern teknolojik gelişmelerle, π’nin 31 trilyon basamağı hesaplandı. Bununla birlikte, gözlemlenebilir evrenimizdeki tüm hesaplamaları neredeyse hiç hata olmadan yapabilmek için yalnızca π’nin ilk 39 basamağına ihtiyacımız vardır.

İlki 1988 yılında Larry Shaw tarafından organize edilen Pi Günü, her yıl 14 Mart’ta kutlanmaktadır.

Hepimizin Pi Günü kutlu olsun! 🙂

Pi’nin Kullanım Alanları

Pi, yayların uzunluklarını veya diğer eğrileri, elips alanlarını ve diğer eğimli yüzeyleri ve birçok katı hacmini içeren çeşitli matematik problemlerinde ortaya çıkar. Ayrıca, açısal hız, sarkaçların hareketi, sicimlerin titreşimi ve alternatif elektrik akımları gibi periyodik olayları tanımlamak için çeşitli fizik ve mühendislik formüllerinde kullanılır.

MATE577212SS3ZFP64

Simpleks Yöntem

Simpleks yöntem çok değişkenli karar değişkenleri ve kısıtlayıcılardan oluşan doğrusal programlama problemlerinde optimum çözümü bulmak için 1947 yılında George Dantizg tarafından geliştirilmiştir. Bir doğrusal programlama problemini simpleks yöntem ile çözmek için standart formda ifade etmemiz gerekir. Bu sebeple ilk önce standart biçimden bahsedelim.

Standart Biçim

Zenk/enb = c1 . x1 + c2 . x2 + … + cn . xn

a11 . x1 + a12 . x2 + a13 . x3 + … + a1n . xn = b1

a21 . x1 + a22 . x2 + a23 . x3 + … + a2n . xn = b2

a31 . x1 + a32 . x2 + a33 . x3 + … + a3n . xn = b3

…..

am1 . x1 + am2 . x2 + am3 . x3 + … + amn . xn = bn

x1, x2, x3, … xn ≥ 0

olarak ifade edilen doğrusal programlama modeli aşağıdaki koşulları sağlarsa standart biçimdedir.

  • Amaç fonksiyonu en büyükleme ya da en küçükleme olabilir.
  • Kısıtlayıcı fonksiyonların sağ taraf sabitleri negatif olmamalıdır.
  • Tüm kısıtlayıcı fonksiyonlar eşitlik halinde olmalıdır.
  • Tüm karar değişkenleri negatif olmamalıdır.

Elimizdeki doğrusal programlama modelinde bazı dönüştürmeler yapmaya ihtiyaç duyabiliriz. Bir doğrusal programlama modeli üzerinde dönüşümlere kısaca göz atalım.

  • Bir doğrusal programlama modelinin amaç fonksiyonunun anlamını değiştirmek için fonksiyonu (-1) ile çarpabiliriz. Bu durumda en büyükleme olan amaç fonksiyonu en küçükleme olacaktır.

Zenb = 2x1 + x2 + x3

Zenk = -2x1 – x2 – x3

  • Bir doğrusal programlama modelinin kısıtlarındaki eşitsizliklerin yönünü değiştirmek için kısıtı (-1) ile çarpabiliriz.

3x1 + 4x2 ≥ 6

-3x1 – 4x2 ≤ -6

  • Eşitsizlik durumundaki bir kısıtı eşitliğe çevirmemiz gerekebilir. Bu çevirme işlemi kısıtın yönüne göre değişmektedir. Eğer a1 . x1 + a2 . x2 + a3 . x3 ≥ b1 gibi bir kısıtı eşitlik haline dönüştürmek istiyorsak, eşitsizliğin sol tarafından negatif olmayan bir değişken çıkarmamız gerekir. Bu değişkene, artık değişken denir. Eğer a1 . x1 + a2 . x2 + a3 . x3 ≤ b1 gibi bir kısıtı eşitlik haline dönüştürmemiz gerekiyorsa, eşitsizliğin sol tarafına negatif olmayan bir aylak değişken eklememiz gerekir. Böylece elimizdeki bir doğrusal programlama modelini standart biçime dönüştürerek simpleks yöntem ile çözebiliriz. Son olarak kısıtlayıcı değişkenler eşitlik durumunda ise, eşitliğin sol tarafına “A” ile gösterilen bir yapay değişken eklenmelidir. Simpleks yöntemi daha iyi anlayabilmek için örnek üzerinde inceleyelim.

Örnek

Zenb = 2x1 + 3x2

6x1 + 4x2 ≤ 20

3x1 + x2 ≤ 30

x1 + x2 ≤ 40

x1, x2 ≥ 0

Simpleks yöntem ile çözünüz.

İlk adım olarak doğrusal problemi standart biçime çevirelim.

Standart Biçim

6x1 + 4x2 + x3 = 20

3x1 + 2x2 + x4 = 30

x1 + x2 + x5 = 40

x1, x2, x3, x4, x5 ≥ 0

Burada x3, x4 ve x5 aylak değişkendir. Aylak değişkenler amaç fonksiyonuna eklenirken katsayısı 0 (sıfır) olarak eklenir. Bu durumda amaç fonksiyonumuz aşağıdaki gibi olur.

Zenb = 2x1 + 3x2 + 0 x3 + 0 x4 + 0 x5

Şimdi ise bu problemi çözebilmek için tablo yapmamız gerekir. Bu tablonun üst kısmında değişkenler, sol kısmında temel değişken vektörü altında aylak ve yapay değişkenler yer almalıdır. Ancak burada artık değişkenler (varsa) yer alamazlar. Çünkü temel çözüm uygun olmaz.

AFKTDVx1x2x3x4x5ÇV
0x3      
0x4      
0x5      
Zj      
Zj – Cj      
Simpleks Başlangıç Tablosu Değerler Yazılmamış Hali

AFK = Temeldeki değişkenlerin (TDV altında) amaç fonksiyonundaki katsayıları

TDV = Temel değişken vektörü

ÇV = Çözüm vektörü

Kısıtları tabloya yerleştirirken sıralamaya dikkat etmemiz gerekir. İlk kısıtımızda x3 aylak değişkeni olduğu için, ilk sıraya x3 aylak değişkenini yazıp, x3 aylak değişkeninin bulunduğu satıra ise kısıtın katsayılarını sırasıyla yerleştirmemiz gerekir. Bu işlemi diğer kısıtlar içinde yapmamız gereklidir. Ardından temeldeki değişkenlerin amaç fonksiyonundaki katsayılarını yanlarına (AFK) yazmamız bizim için faydalı olacaktır. Çünkü Zj satırını elde etmek için bu katsayıları kullanacağız. Her bir Zj değeri o sütundaki elemanlar ile temeldeki değişkenlerin amaç fonksiyonlarındaki katsayıları çarpılıp toplanmasıyla elde edilir. Böylece

Z1 = 0.6 + 0.3 +0.1 = 0

Z2 = 0.4 + 0.1 +0.1 = 0

Z3 = 0.1 + 0.0 +0.0 = 0

Z4 = 0.0 + 0.1 +0.0 = 0

Z5 = 0.0 + 0.0 +0.1 = 0

Ç.V = 0.20 + 0.3 0+0.40 = 0 olarak elde edilir.

Sırada ise Zj – Cj satırını elde etmek var. Bu satırı elde etmek için her bir Zj değerinden karşılık gelen değişkenin amaç fonksiyonu katsayısının çıkarılması gerekir. Bu durumda

Z1 – C1 = 0 – 2 = -2   ——>C1 , x1 ‘in katsayısı

Z2 – C2 = 0 – 3 = -3  ——>C2 , x2 ‘nin katsayısı

Z3 – C3 = 0 – 0 = 0   ——>C3 , x3 ‘ün katsayısı

Z4 – C4 = 0 – 0 = 0   ——>C4 , x4 ‘ün katsayısı

Z5 – C5 = 0 – 0 = 0   ——>C5 , x5 ‘in katsayısı

Bu değerler tabloda ilgili yerlere yazılmalıdır.

Simpleks Başlangıç Çözüm Tablosu

AFKTDVx1x2x3x4x5ÇV
0x36410020
0x43101030
0x51100140
Zj000000
Zj – Cj-2-3000 

Buraya kadar yaptıklarımızla tabloyu doldurduk. Buradan sonra yapmamız gereken anahtar sütun, anahtar satır ve anahtar sayı değerlerini bulmaktır. Anahtar sütun, temele girecek olan değişkeni belirler. Anahtar satır, temelden çıkacak olan değişkeni belirler. Anahtar sayı ise temele yeni giren değişkenin tablodaki değerlerini belirlemek için kullanılır. Anahtar sütun, amaç fonksiyonuna göre iki şekilde belirlenir. Eğer amaç fonksiyonu en büyükleme ise,  Zj – Cj satırındaki mutlak değerce en büyük olan negatif sayının bulunduğu sütun anahtar sütundur.  Amaç fonksiyonu en küçükleme ise, Zj – Cj satırındaki en büyük sayının bulunduğu sütun anahtar sütun olur. Bu şekilde anahtar sütunu belirleyip hangi değişkenin temele gireceğini bulabiliriz. Bir değişken temele girerken, temeldeki hangi değişkenin çıkacağına karar vermek için anahtar satırı bulmamız gerekir. Anahtar satırı bulmak için çözüm vektörü kısmındaki değerleri karşılık gelen anahtar sütun elemanlarına bölerek oran sütununu elde etmemiz gerekir. Oran sütununda hangi değer daha küçük ise o değerin bulunduğu satır, anahtar satır olarak adlandırılır ve temelden çıkarılır. Anahtar sayı ise anahtar sütun ile anahtar satırın kesiştiği değerdir. Şimdi bizim tablomuzdaki değerlere göre anahtar sütun, anahtar satır ve anahtar sayıyı bulalım.

Anahtar Sütun

 X1X2X3X4X5
Zj – Cj-2-3000

Buradan da görüldüğü gibi mutlak değerce en büyük olan negatif sayının bulunduğu sütun x2 sütunudur. Böylece x2 sütunu anahtar sütundur ve temele girmelidir.

Anahtar Satır

 Anahtar sütun(X2)Çözüm Vektörü(ÇV)Oran
x3455/4
x413030
x514040

Böylece x3 ‘ün temelden çıkarılması gerekir. Anahtar sütun(x2) ve anahtar satır’ın(x3) kesiştiği değerin 4 olduğu görülür. Böylece anahtar sayı 4’tür. Bu değerleri elde ettikten sonra simpleks birinci çözüm tablosunu oluşturarak çözüme devam edelim. Burada x2 satırının yeni değerleri x3  satırının değerlerinin anahtar sayıya bölünmesiyle elde edilir.

Simpleks Birinci Çözüm Tablosu

AFKTDVx1x2x3x4x5ÇV
3x23/211/4005
0x43/20-1/41025
0x5-1/20-1/40135
Zj9/233/40015
Zj – Cj5/203/400

Burada tablonun son halini yazdık ama tablonun içerisindeki değerler yeniden hesaplanmalıdır. Bu değerlerin hesaplanmasına geçilmeden önce şunu belirtmemiz gerekir temeldeki değişkenler tabloda birim matris oluştururlar. Biz tablonun yeni değerlerini bulurken bu değişkenlerin oluşturacağı birim matrisi korumamız gerekir. Simpleks başlangıç çözüm tablosuna baktığımızda temeldeki x3, x4 ve x5 değişkenlerinin tabloda birim matris oluşturduğu görülür. Simpleks birinci çözüm tablosunda ise x2, x4 ve x5 birim matris oluşturmalıdır. Temeldeki değişkenlerin bulundukları satırların değerleri bulunurken bu birim matris gözedilerek bulunacaktır. x2 satırının değerlerinin nasıl bulunduğu söylemiştik. Şimdi x4 ve x5 satırlarındaki değerleri bulalım. İlk önce x4 satırının değerlerini hesaplayalım. Bunun için x4 satırının simpleks başlangıç çözümündeki yani eski değerleri ve yeni x2 ’nin değerlerini kullanacağız. Bu değerleri kullanarak ve birim matrisi koruyarak x4 ’ün yeni değerlerini bulacağız.

 x1x2x3x4x5ÇV
Eski x43101030
Yeni x23/211/4005
Yeni x43/20-1/41025

Burada birim matrisin korunması için yeni x4 ’ün x2  sütunundaki değeri 0, x4 satırındaki değeri 1  ve x5 sütunundaki değeri 0 olmalıdır. Bunun için yeni x2 satırı (-1) ile çarpılıp toplanmalıdır. Bulunan yeni x4 satırının değerleri tabloya yazılır.

Şimdi x5 satırının değerlerini bulalım. Bunun için ise simpleks başlangıç çözüm tablosundaki yani eski x5 değerlerini ve yeni x2 değerlerini kullanacağız.

 x1x2x3x4x5ÇV
Eski x51100140
Yeni x23/211/4005
Yeni x5-1/20-1/40135

Yeni x5 değerleri bulunurken birim matrisi korumak için yeni x5‘in x2 sütunundaki değeri 0, x4 sütunundaki değeri 0 ve x5 sütunundaki değeri 1 olmalıdır. Bu sebeple yeni x2 satırı (-1) ile çarpılıp toplanmalıdır. Böylece yeni x5 satırının değerleri hesaplanmış olur. Bu değerlerde tabloya eklendiğinde hesaplamamız gereken Zj ve Zj – Cj satırı kalır. Zj satırındaki değerleri temeldeki değişkenlerin amaç fonksiyonu katsayıları ile tablodaki değerlerin çarpılıp toplanmasıyla elde ediliyordu. O zaman Zj satırındaki değerler aşağıdaki gibi hesaplanır.

Z1 = 3.(3/2)  +  0.(3/2)  +  0.(-1/2) = 9/2

Z2 = 3.1  +  0.0  +  0.0 = 3

Z3 = 3.(1/4)  +  0.(-1/4)  +  0.(-1/4) = 3/4

Z4 = 3.0 +  0.1 +  0.0 = 0

Z5 = 3.0  +  0.0  +  0.1 = 0

Ç.V = 3.5 +  0. 25+  0.35 = 15

Bu değerler tabloya yazılmalıdır. Ardından her bir Zj değeri bulunduğu sütundaki değişkenin amaç fonksiyonundaki katsayısı olan Cj ’den çıkarılarak Zj – Cj  değerleri hesaplanır.

Z1 – C1 = (9/2)– 2 = 5/2   ——>C1 , x1 ‘in katsayısı

Z2 – C2 = 3 – 3 = -0  ——>C2 , x2 ‘nin katsayısı

Z3 – C3 = 3/4 – 0 = 3/4   ——>C3 , x3 ‘ün katsayısı

Z4 – C4 = 0 – 0 = 0   ——>C4 , x4 ‘ün katsayısı

Z5 – C5 = 0 – 0 = 0   ——>C5 , x5 ‘in katsayısı

Amaç fonksiyonumuz en büyükleme olduğu için Zj – Cj satırındaki tüm değerlerin sıfır veya pozitif olması gerekir. Eğer amaç fonksiyonumuz en küçükleme olsaydı Zj – Cj satırındaki tüm değerlerin negatif veya sıfır olması gerekecekti. Yukarıdada görüldüğü gibi Zj – Cj satırındaki tüm değerler sıfır veya pozitif olduğundan en iyi çözüme ulaşmış oluruz. Böylece

Zenb = 15 , x2 = 5 , x3 = 0 , x4 = 25 , x1 = 0 , x5 = 35 olarak elde edilir.

Eğer bizim problemimizde Zj – Cj

satırındaki herhangi bir değer negatif olsaydı çözüm en iyi olmayacaktı. Bu durumda ise tekrar anahtar sütun, anahtar satır ve anahtar sayi değerlerini bulacaktık. Ardından tabloyu tekrar oluşturup buradaki gibi değerleri yeniden hesaplayıp çözümün en iyi olup olmadığını kontrol etmemiz gerekirdi. Çözüm en iyi olana kadar bu işlemleri yapmaya devam edecektik.

MATE7427Q2K8SX9066