Python Programlama Diline Giriş III

 

Python Programlama Diline Giriş III

Merhaba Arkadaşlar. Bu haftadaki konularımız.

1 Python'da Deyimler

2 İfade sel Deyimler (Expression Statements)

3 Bileşik Deyimler

4 Bileşik Deyimlerin Genel Yazım Biçimi

5 if Deyimi

6 Döngü Deyimleri (Loop Statements)

7 while Döngüleri

8 for Döngüleri

9 break Deyimi

10 continue Deyimi

11 Pyton'da Switch-Case Deyimi Yoktur

12 pass Deyimi

13 Koşul Operatörü

14 Fonksiyonların Tanımlanması

15 Fonksiyonların Parametre Değişkenleri

16 Modüller ve Modüllerin Import Edilmesi

17 Bir Modülü Import Etmekle Çalıştırmak Arasındaki Fark

18 Python'da İsim Arama

19 Python'da Değişkenlerin Ömürleri

Python'da Deyimler

Deyim (statements) bir dildeki çalışma birimleridir. Yani bir program aslında deyimlerin çalıştırılmasıyla çalıştırılır. Bir Python programını deyimler topluluğu olarak düşünebiliriz. Python'da deyimler iki gruba ayrılmaktadır:

1 Basit deyimler

2 Bileşik deyimler

Python'da tek bir satıra yazılabilen deyimlere basit deyim denilmektedir. Deyimlerin bir grubu böyle tek satıra yazılabilen basit deyimlerden, bir grubu da bileşik deyimlerden oluşmaktadır.

 

İfadesel Deyimler (Expression Statements)

Anımsanacağı gibi operatörlerin, sabitlerin ve değişkenlerin her bir kombinasyonuna ifade (expression) deniliyordu. İşte ifadeler aynı zamanda bir deyim de belirtmektedir. İfadesel deyimler kategori olarak basit deyim durumundadır. Örneğin:

a = b

x = y + 10

z = foo(10) * 2

Bu satırların her biri birer ifadesel deyimdir.

Bileşik Deyimler

Bileşik deyimler kendi içerisinde başka deyimleri de içerebilen deyimlerdir. Bunların çoğu program akışını yönetmek için kullanılmaktadır. Bunlara pek çok programlama dilinde "kontrol deyimleri" de denilmektedir. Bileşik deyimlerin içindeki deyimler aynı girinti füzeyine sahip olacak biçimde "girintili olarak" yazılmak zorundadır. Her iç bileşik deyime geçildiğinde girinti düzeyi artırılır. Aynı girinti düzeyine sahip olan deyimler aynı bileşik deyimin içerisinde kabul edilmektedir.

 

 

Bileşik Deyimlerin Genel Yazım Biçimi

Bileşik deyimlerin genel biçimleri birbirlerine benzemektedir. Bileşik deyimler bir anahtar sözcük ile başlatılır (if, for, while gibi) sonra bunların bir başlık kısmı olur. Ondan sonra da bu başlık kısmını ':' atomu izler. Sonra bu deyimlerin içerisindeki deyimler girintilenerek (yani indent'lenerek) yazılırlar. Bileşik deyimlerin içerisindeki deyimler aynı girinti düzeyine sahip olmalıdır. Yukarıda da belirtildiği gibi Python yorumlayıcısı aynı girinti düzeyine sahip olan deyimlerin aynı bileşik deyiminin içerisinde olduğunu düşünmektedir.

Bileşik deyimlerin yazımı "suite" kavramı ile daha kolay açıklanabilir. "suite" bileşik deyimin ':' atomundan sonraki kısmına ilişkin bir kavramdır. Bir suit aynı satır üzerine yazılmış olan birden fazla basit deyimi ya da aynı girinti düzeyine sahip farklı satırlarda yazılmış birden fazla deyimi belirtmektedir.

Bu bir suite belirtmektedir. Örneğin:

ifade1

ifade2

ifade3

İşte bileşik deyimler genellikle böyle suit'ler içermektedir. Örneğin while deyimi (ileride görülecek) ':' atomundan sonra bir suite almaktadır. Genel biçimi şöyledir:

while <ifade>: <suite>

Bu durumda aşağıdaki while deyimi geçerlidir:

while i < 10: ifade1; ifade2; ifade2

Aşağıdaki while deyimi de geçerlidir:

while i < 10:

ifade1

ifade2

ifade3

Ancak aşağıdaki while deyimi geçerli değildir:

while i < 10: ifade1

ifade2

ifade3

 

Çünkü burada hem aynı satıra hem de aşağıdaki satıra deyim yazılmıştır. Oysa suit ya aynı satıra yazılan birden fazla basit deyimi ya da aynı girinti düzeyine sahip birden fazla satıra yazılan deyimleri belirtmektedir.

 

if Deyimi

if deyimi bir koşulun doğru ya da yanlış olmasına göre birtakım deyimleri çalıştıran temel bir kontrol deyimidir. Genel biçimi şöyledir:

if <koşul ifadesi>: <suit>

[else: <suit>]

if anahtar sözcüğü ile else anahtar sözcüğünün aynı girinti düzeyine sahip olması gerekir. Ancak if deyiminin doğruysa ve yanlışsa kısmındaki suite'lerin aynı girinti düzeyine sahip olması gerekmez.

if deyimi şöyle çalışır: Önce if anahtar sözcüğünün yanındaki ifadenin değeri hesaplanır. Bu değer bool türüne dönüştürülür (Sıfır dışı değerler True olarak sıfır değeri False olarak) sonra bu ifade True ise if deyiminin doğruysa kısmındaki suite çalıştırılır, False ise yanlışsa kısmındaki suite çalıştırılır. Örneğin:

Burada son rint deyiminin if dışında olduğuna dikkat ediniz.

Örneğin:

Burada ikinci derece bir denklemin kökleri bulunmuştur.

Şimdi ise üç sayının en büyüğünü ekrana yazdıran bir Python programı yazalım:

Ayrık koşulları else-if biçiminde ele almak iyi tekniktir. Örneğin bir sayının pozitif negatif ya da sıfır olduğunu anlamaya çalışalım.

Döngü Deyimleri (Loop Statements)

Bir grup deyimin yinelemeli olarak çalıştırılmasını sağlayan kontrol deyimlerine döngü (loop) denilmektedir. Program aslında çalışma zamanının çoğunu döngülerde geçirir. Python'da iki çeşit döngü vardır: while döngüleri ve for döngüleri. Python’daki while döngülerinde kontrol başta yapılır. Ayrıca Pyton’da kontrolün sonda yapıldığı while döngüleri (dowhile döngüleri) yoktur.

 

 

while Döngüleri

while döngüleri bir koşul sağlandığı sürece yinelenmeye yol açar. Genel biçimi şöyledir:

while <koşul>: <suite >

[ else: <suit>]

while döngüsü şöyle çalışır: Her yinelemede while anahtar sözcüğünün yanındaki ifadenin değeri hesaplanır. Bu değer bool türüne dönüştürülür. Eğer ifadenin değeri True ise suit içerisindeki deyimler sırasıyla çalıştırılır, False ise döngü sonlandırılır. Döngü sonlandığında eğer döngüden break deyimi ile çıkılmamışsa döngünün else kısmındaki suit de çalıştırılır.

Biz bir listenin tüm elemanlarını while döngüsü ile tek tek ekrana yazdırabiliriz. Örneğin:

for Döngüleri

Python'da artırımlı for döngüleri yoktur. Python'daki for döngüleri diğer dillerdeki foreach döngüleri gibi çalışmaktadır. Python'da for döngüleri yalnızca dolaşılabilir (itrerable) nesnelerle kullanılabilir. Bu durumda her yinelenmede dolaşılabilir nesnenin sıradaki elemanı dönü değişkenine atanır sonra döngüyü oluşturan deyimler çalıştırılır. Dolaşma işlemi bittiğinde döngü de biter.

for döngülerinin genel biçimi şöyledir:

for <değişken> in <dizilim>: <suit>

[else:<suit>]

Daha açık bir anlatımla Python'daki for döngüleri şöyle çalışmaktadır: in anahtar sözcüğünün sağındaki dolaşılabilir nesnenin sıradaki elemanı döngü değişkenine atanır, sonra döngü deyimleri çalıştırılır. Bu böyle devam eder. Dolaşılabilir nesnenin elemanları bitince döngü de sonlanmış olur. Tıpkı while döngülerinde olduğu gibi for döngülerinin de else kısmı vardır. Bu else kısmı döngüden break deyimi ile çıkılmamışsa döngü bitince çalıştırılmaktadır.

Örneğin:

Tabii for döngüsüyle dolaştığımız nesnenin elemanlarının aynı türden olması zorunlu değildir. Python dinamik tür sistemine sahip olduğuna göre her dolaşımda döngü değişkeninin türü de nesnenin o elemanının türü ile aynı olacaktır.

Örneğin:

Python'da while ve for döngülerinin else kısımları eğer döngüden break deyimi ile çıkılmışsa çalıştırılmaz. Pekiyi neden break ile çıkıldığında döngülerin else kısımları çalıştırılmamaktadır? Bazen döngünün kendi kendine sonlanması ile break ile sonlandırılması arasında programcı açısından farklılık oluşalabilmektedir. İşte bu farklılıktan programcı lehine faydalanılmak istenmiştir. Örneğin bir liste içerisinde bir değeri sıralı olarak aradığımızı düşünelim (gerçi list sınıfının böyle bir metodu vardır). Eğer liste bittiği halde biz aradığımız değeri bulamamışsak başarısız olduğumuz sonıcunu çıkarabiliriz. Tabii aradığımız değeri bulursak break ile döngüden çıkarız:

Pyton'da Switch-Case Deyimi Yoktur

Pek çok programlama dilinde bir ifadenin çeşitli sayısal değerine göre değişik işlemleri yapabilmek için switch-case deyimleri vardır. Ancak Python'da böyle bir deyime gerek görülmemiştir. Python'da sözlükler zaten switch-case benzeri bir kullanım olanağı sunmaktadır. Her ne kadar daha fonksiyon tanımlaması yapmamış olsak da aşağıdaki örnek bir fikir verebilecektir:

pass Deyimi

C, C++, Java ve C# gibi dillerde yalnızca ';' boş deyim anlamına gelmektedir. Python'da girintili bir yazım biçimi olduğu için boş deyimler pass isimli anahtar sözcükle temsil edilmişlerdir. Örneğin biz bir fonksiyonun, for ya da while döngülerinin içerisinde hiçbir şey yapmak istemeyebiliriz. Bu durumda oraya bir deyim olarak pass yerleştirilmelidir.

Örneğin:

for k in range(10):

for i in range(10000000):

pass

print(k)

yalnızca döngülerde değil suit gereken her yerde (örneğin fonksiyon ve sınıf tanımlamalaında) pass deyimini kullanabiliriz.

 

Koşul Operatörü

Python'da da tıpkı C, C++, Java ve C#'ta olduğu gibi bir koşul operatörü vardır. Koşul operatörü if deyimi gibi çalışır fakat bir değer üretir. Genel biçimi şöyledir:

<ifade1> if <bool türden ifade> else <ifade2>

Koşul operatörü bir operatör olduğu için bir değer üretir. Önce if ile else anahtar sözcüklerinin arasındaki ifadenin değeri hesaplanır. Bu ifade Bool türüne dönüştürülür. Eğer bu ifade True ise if anahtar sözcüğünün solundaki ifade, False ise else anahtar sözcüğünün sağındaki ifade çalıştırılır.

Koşul operatörü düşük öncelikli bir operatördür. Dolayısıyla bunun sonucu üzerinde işlem yapabilmek için paranteze alınması gerekir. Örneğin:

Fonksiyonların Tanımlanması

Şimdiye kadar biz yalnızca var olan (yani başkaları tarafından yazılmış olan) fonksiyonları çağırdık. Şimdi biz de fonksiyon yazacağız. Bir fonksiyonun yazımına Python referans kitaplarında "fonksiyonun tanımlanması (function definitions)" denilmektedir. Fonksiyon tanımlama işleminin genel biçimi şöyledir:

def <fonksiyon ismi>([parametre listesi]): <suit>

Örneğin:

def foo():

   print('I am foo')

Burada fonksiyonun ismi foo olarak verilmiştir. Fonksiyonun herhangi bir parametresi yoktur.

Python'da fonksiyon tanımlamaları da birer deyim statüsündedir. Python yorumlayıcısı bir fonksiyonun tanımlandığını gördüğünde onun kodlarını saklar. Fonksiyon çağrıldığında o kodları çalıştırır. Yani bir fonksiyon tanımlandığında henüz onun kodları çalıştırılmamaktadır. Fonksiyon çağrıldığında onun kodları çalıştırılır.

 

Fonksiyonların Parametre Değişkenleri

Fonksiyonların parametreleri söz konusu olabilir. Python dinamik tür sistemine sahip olduğu için parametreler bildirilirken tür belirtilmez. Parametrelerin yalnızca isimleri parametre parantezinin içerisine aralarına ',' atomu yerleştirilerek yazılmaktadır. Örneğin:

def foo(a, b, c): print(a); print(b); print(c)

Tıpkı normal değişkenlerde olduğu gibi paremtre değişkenleri için de bir tür bildiriminin yapılmadığına dikkat ediniz. Parametrelerin türleri fonksiyonun hangi türden argümanlarla çağrıldığına bağlı olarak programın çalışma zamanı sırasında değişebilmektedir. Örneğin:

def foo(x):

   print(type(x))

 

foo(10)

foo(20.2)

foo('Mehmet')

 

 

Modüller ve Modüllerin Import Edilmesi

Python'da .py uzantılı Python kaynak dosyaları aynı zamanda bir modül (module) belirtmektedir. Yani her yazdığımız script dosyası aslında bir modüldür. Bir modül dosyasının içerisinde program kodları da olabilir, sınıflar, fonksiyonlar ve değişkenler de olabilir. Örneğin biz a.py isimli bir Python script dosyasını çalıştıracak olalım. Bu dosya da b.py isimli bir Python dosyasındaki fonksiyonları kullanacak olsun. İşte bunun için bizim a.py içerisinde b.py modülünü import etmemiz gerekir.

import etme sırasında bazı Python yorumlayıcıları bazı hazırlık işlemlerini de yapmaktadır. Örneğin CPython ve diğer bazı yorumlayıcılar import işlemi sırasında kaynak dosyadaki kodları daha hızlı ele almak için onalrı bir çeşit ara koda dönüştürmektedir.

import Pyton'da bir deyim statüsündedir. Genel biçimi şöyledir:

import <dosya ismi> [as <isim>] [, <dosya ismi> [as <isim>], <dosya ismi> [as <isim>] , ...>]

Örneğin:

import a

import b, c as d

import a as b, b as c

 

Bir Modülü Import Etmekle Çalıştırmak Arasındaki Fark

Bir Python modülü komut satırından ya da IDE'den çalıştırılabileceği gibi import işlemiyle de çalıştırılabilmektedir.

İşte bizim bazen bir modülün nasıl çalıştırıldığını bilmemiz gerekebilir. Çünkü biz doğrudan yorumlayıcı ile çalıştırmada bir şey import ile çalıştırmada başka bir şey yapmak isteyebiliriz. Bir modülün doğrudan yorumlayıcı ile mi çalıştırıldığı yoksa import deyimiyle mi çalıştırıldığı built-in __name__ isimli değişkene bakılarak belirlenir. Eğer bu değişken modülün ismini veriyorsa bu durumda ilgili modül import ile çalıştırılmıştır.

Eğer bu değişken "__main_" ismini veriyorsa bu durumda modül doğrudan yorumlayıcı tarafından çalıştırılmıştır. __name__ değişkeni her zaman str türündendir. Örneğin test.py dosyasının içeriği şöyle olsun:

print(__name__)

Şimdi biz bu modülü python yorumlayıcısı ile çalıştırırsak. Sonuç şöyle olacaktır:

__main__

 

Python'da İsim Arama

İsim araması (name lookup) bir değişkenin hangi noktada hangi faaliyet alanlarında aranacağını belirtmektedir.

Python dinamik tür sistemine sahip olduğu için ve çalışma yorumlayıcılarla yapıldığı için isim araması da dinamik bir biçimde yapılmaktadır. Kullanılan bir değişken isminin yaratılmış olup olmadığına diğer dillerde olduğu gibi işin başında derleme aşamasında bakılmaz. Arama program akışı o değişkenin kullanıldığı noktaya geldiğinde yapılmaktadır.

Böylece değişkenin kullanıldığı noktada, önce bulunulan fonksiyon içerisinde sonra kapsayan fonksiyonlar içerisinde sonra da global alanda arama yapılmaktadır. Comprehension'lar ve lambda ifadeleri kendi faaliyet alanlarına sahiptir. Bu konu ileride ele alınacaktır. Örneğin:

def foo():

    print(a)             #geçerlidir

a = 10

foo()

 

Burada her ne kadar foo fonksiyonu tanımlanırken henüz a değişkeni yoksa da foo fonksiyonu çağrılıp akış foo içerisindeki a'nın kullanıldığı yere geldiğinde artık a değişkeni isim aramasında bulunacaktır. Ancak çağırma işlemi aşağıdaki gibi a'nın yaratılmasından önce yapısaydı error oluşurdu:

def foo():

    print(a)

foo()                    # hatalı

a = 10

 

Python'da Değişkenlerin Ömürleri

Python'da değişken ile nesne arasında farklılık vardır. Anımsanacağı gibi Python'da tüm değişkenler aslında nesnelerin adreslerini tutmaktadır.

Değişkenlerin bellekte yer kapladığı zaman aralığına ömür denilmektedir. Değişkenler süreki bellekte yerkaplamazlar. Programın çalışmasının belli bir aşamasında yaratılıp belli bir aşamasında yok edilirler. Python'da birglobal değişken akış o değişkene ilk kez değer atandığı noktada yaratılır. Program sonlanana kadar bellekte kalır.

Yerel değişkenler ise fonksiyon ya da metot çağrılıp onlara ilk kez değer atandığında yaratılırlar akış fonksiyondan ya da metotttan çıktığında otomatik olarak yok edilirler. Yani yerel değişkenler sürekli bellekte kalmazlar. Fonksiyon ya da bittiğinde onlar bellekten boşaltılırlar. Parametre değişkenleri de Python'da fonksiyon ya da metot çağrıldığında yaratılırlar. Fonksiyon ya da metot sonlandığında yok edilirler.