Python ile öğrenme. 2- Değişkenler, ifadeler ve cümleler
Cümle Python yorumlayıcısı tarafından işlenebilecek bir yönergedir (komuttur). Şimdiye kadar iki cümle gördük: print ve atama cümleleri. Bir cümleyi komut ...
Bilgisayar Bilimcisi gibi Düşünmek: Python ile öğrenme. 2- Değişkenler, ifadeler ve cümleler

# 2\. Değişkenler, deyimler ve cümleler

01. [Değerler ve tipler](#auto0)
02. [Değişkenler](#auto1)
03. [Değişken isimleri ve anahtar kelimeler](#auto2)
04. [Cümleler](#auto3)
05. [Deyimleri değerlendirme](#auto4)
06. [İşleçler ve işlenenler](#auto5)
07. [İşleçlerin sırası](#auto6)
08. [Karakter dizisi üzerindeki işlemler](#auto7)
09. [Girdi](#auto8)
10. [Kompozisyon](#auto9)
11. [Yorumlar](#auto10)
12. [Sözlük](#auto11)
13. [Alıştırmalar](#auto12)

## 2.1 Değerler ve tipler

**Değer** programın işlediği temel şeylerden - harf veya rakam gibi - biridir. Şimdiye kadar gördüğümüz değerler `2` ( `1 + 1` işleminin sonucu), ve `"Merhaba, Dünya!"`.


Bu değerler farklı **tiplere** aittir: `2` bir _tamsayı (integer)_ dır, ve `"Merhaba, Dünya!"` bir _karakter dizisi (string)_ dir, çünkü karakterlerden oluşan bir dizidir. Siz (ve yorumlayıcı) karakter dizilerini ayırtedebilir, çünkü tırnak işaretleri arasında yazılmıştır.


print cümlesi tamsayılar için de çalışır.


```
>>> print 4
4
```

Eğer bir değerin tipinden emin değilseniz, yorumlayıcı bunu size söyleyebilir.


```
>>> type("Merhaba, Dünya!")
<type 'str'>
>>> type(17)
<type 'int'>
```

Sürpriz olmayacak şekilde, karakter dizisi **str** tipine ve tamsayılar da **int** tipine aittir. Ayrıca, ondalık basamağa sahip sayılar **float** adında bir tipe ait olacaktır, çünkü bu sayılar _kayan noktalı (floating point)_ biçiminde temsil edilmektedir.


```
>>> type(3.2)
<type 'float'>
```

Peki `"17"` ve `"3.2"` şeklinde ifadelerin tipi nedir? Sayı gibi gözükmektedirler, ancak karakter dizileri gibi tırnak işaretleri arasındalar.


```
>>> type("17")
<type 'str'>
>>> type("3.2")
<type 'str'>
```

Onlar da karakter dizisidir.


Python'da karakter dizileri tek tırnak (') veya çift tırnak (") arasına alınabilir:


```
>>> type('Bu bir karakter dizisidir.')
<type 'str'>
>>> type("Bu da öyle.")
<type 'str'>
```

Çift tırnaklı karakter dizileri `"Emre'nin sakalı"` örneğinde olduğu gibi tek tırnak, ve tek tırnaklı karakter dizileri `'"Ni!" söyleyen şövalyeler'` örneğindeki gibi çift tırnak içerebilir.


Büyük bir tamsayı yazdığınızda, üçlü rakam grupları arasında `1,000,000` örneğinde olduğu gibi virgül kullanmak isteyebilirsiniz. Bu Python için geçerli bir tamsayı gösterimi değildir, ancak geçerli bir ifadedir:


```
>>> print 1,000,000
1 0 0
```

Bu beklediğimiz bir sonuç değil! Python `1,000,000` ifadesini üç öğe içeren bir liste şeklinde yorumlar ve o şekilde ekranda görüntüler. Bu yüzden tamsayılarda rakamlar arasında virgül kullanmamayı unutmamalısınız.


## 2.2 Değişkenler

Programlama dilinin en güçlü özelliklerinden birisi **değişkenleri** değiştirebilme (adından anlaşılacağı gibi ) yeteneğidir. Bir değişken bir değeri tutan bir isimdir.


**Atama cümlesi** yeni bir değişken yaratır ve değerlerini atar:


```
>>> mesaj = "Naber, doktor?"
>>> n = 17
>>> pi = 3.14159
```

Bu örnek üç atama gerçekleştirmektedir. İlk atama `mesaj` isimli yeni yarattığı bir değişkene `"Naber, doktor?"` karakter dizisini atar. İkinci atama `n` değişkenine, `17` tamsayı değerini ve son atama `pi` değişkenine `3.14159` kayan noktalı sayı değerini verir.


**Atama işleci**, `=`, "eşittir" işaretiyle (aynı karakteri kullansa da) karıştırılmamalıdır. Atama işleçleri _isim_ , işlecin sol tarafı, ve _değer_ , işlecin sağ tarafı, ifadelerini birbirine bağlar. Bu yüzden aşağıdaki ifadeyi yazdığınızda hata mesajıyla karşılaşırsınız:


```
 >>> 17 = n

```

Değişkenleri kağıt üstünde göstermenin genel bir yolu değişken isminden bir ok çıkarıp değerini işaret etmektir. Bu çeşit gösterime **durum diyagramı** denilir, çünkü her bir değişkenin durumunu gösterir (değişkenin ruh hali olarak da düşünebilirsiniz). Bu diyagram atama cümlelerinin sonuçlarını gösterir:


![](illustrations/state2.png)

print cümlesi değişkenlerle de çalışır.


```
 >>> print mesaj
Naber, doktor?
>>> print n
17
>>> print pi
3.14159

```

Her bir durumda sonuç değişkenin o an ki değeridir. Değişkenler de tiplere sahiptir; yorumlayıcıya tiplerini sorabiliriz.


```
 >>> type(mesaj)
<type 'str'>
>>> type(n)
<type 'int'>
>>> type(pi)
<type 'float'>

```

Değişkenin tipi referans ettiği değerin tipidir.


## 2.3 Değişken isimleri ve anahtar kelimeler

Programcılar değişkenleri için genellikle anlamlı isimler seçerler, böylece kullandıkları değişkenleri ne için kullanıldıklarına dair belgelendirmiş olurlar.


**Değişken isimleri** isteğe bağlı olarak uzun olabilir. Hem harf hem de rakam içerebilir, ancak mutlaka bir harfle başlamaları gerekir. Her ne kadar büyük harf kullanmak geçerli olsa da, geleneksel olarak kullanmayız. Unutulmaması gereken harfin büyük veya küçük olması farklı şeylerdir. `Emre` ve `emre` farklı değişkenlerdir.


Altçizgi karakteri ( `_`) bir isimde yeralabilir. Genellikle birden fazla harf içeren kelimelerde kullanılmaktadır, `benim_ismim` veya `cinde_cayin_fiyati` şeklinde.


Eğer değişkene geçerli olmayan bir isim verirseninz, bir sözdizimi hatasıyla karşılaşırsınız:


```
 >>> 76trombones = "big parade"
SyntaxError: invalid syntax
>>> more$ = 1000000
SyntaxError: invalid syntax
>>> class = "Computer Science 101"
SyntaxError: invalid syntax

```

`76trombones` geçersizdir çünkü harf ile başlamamaktadır. `more$` geçersizdir çünkü geçersiz bir karakter içermektedir, dolar işareti. Peki `class` isminin sorunu nedir?


`class` isminin Python tarafından kullanılan **anahtar kelimeler** den biri olduğu ortadadır. Anahtar kelimeler genellikle dilin kural ve yapısını tanımlarlar, ve değişken isimleri olarak kullanılamazlar.


Python otuz bir adet anahtar kelimeye sahiptir (bu kelimeleri değişken ismi olarak kullanamazsınız):


and

del

from

not

while

as

elif

global

or

with

assert

else

if

pass

yield

break

except

import

print

class

exec

in

raise

continue

finally

is

return

def

for

lambda

try


Bu listeyi akılda tutmalı veya gerektiğinde erişebileceğiniz bir yerde olmalıdır. Eğer yorumlayıcı değişkenlerinizden birinin isminden şikayet eder ve siz nedenini bulamazsanız, bir de değişkenlerinizi bu listeye göre kontrol edersiniz.


## 2.4 Cümleler

**Cümle** Python yorumlayıcısı tarafından işlenebilecek bir yönergedir (komuttur). Şimdiye kadar iki cümle gördük: print ve atama cümleleri.


Bir cümleyi komut satırına yazdığınızda, Python cümleyi yürütür ve sonucu gösterir, eğer bir sonuç varsa. print cümlesinin sonucu bir değerdir. Atama cümleleri herhangi bir sonuç üretmez.


Betik genellikle peşpeşe gelen cümlelerden oluşur. Eğer birden fazla cümle varsa, sonuçlar cümleler teker teker işlendiği için teker teker gözükürler (ilgili cümle yürütülünce ilgili sonuç - eğer varsa - görüntülenir)


Örneğin, aşağıdaki betik:


```
        print 1
        x = 2
        printx

```

şu çıktıyı üretir:


```
1
2

```

Yine tekrar etmek gerekir, atama cümlesi herhangi bir çıktı üretmez.


## 2.5 Deyimleri değerlendirme

Bir **deyim** değerlerden, değişkenlerden ve işleçlerden oluşan bir yapıdır. Eğer bir deyimi komut satırına yazarsanız, yorumlayıcı deyimi **değerlendirir** ve sonucu gösterir:


```
>>> 1 + 1
2

```

_Deyimi değerlendirme_ bir değer üretir, bu nedenle deyimler atama işlecinin sağ tarafından kullanılabilir. Değer de basit bir deyimdir, değişken de öyle.


```
>>> 17
17
>>> x
2

```

Karıştırmamak gerekir, bir deyimi değerlendirmek, değeri ekranda göstermek ile aynı şey değildir.


```
>>> message = "Naber, doktor?"
>>> mesaj
"Naber, doktor?"
>>> print mesaj
Naber, doktor?

```

Python kabuğu bir deyimin değerini ekranda gösterirken, değer girmek için kullanacağınız aynı biçimi kullanır. Karakter dizileri kullandığınızı varsayarsak, görüntülemede tırnak işaretlerini kullandığını görebiliriz. Ancak print cümlesi deyimin değerini ekranda gösterir, bu durumda karakter dizisinin içeriğini gösterecektir.


Betik içerisinde, deyim kendi başına geçerli bir cümledir, ancak hiçbir şey yapmaz. Betik


```
        17
        3.2
        "Merhaba, Dünya!"
        1 + 1

```

herhangi bir çıktı üretmez. Bu betiği nasıl değiştirmeliyiz ki, bu dört deyimin değeri ekranda gösterilsin?


## 2.6 İşleçler ve işlenenler

**İşleçler** toplama, çarpma, vb. hesaplamaları temsil eden özel sembollerdir. İşleçler tarafından kullanılan değerler **işlenen** adını almaktadır.


Aşağıdakilerin hepsi geçerli (anlamı açık veya tam açık olmayan) Python deyimleridir:


```
 20+32   hour-1   hour*60+minute   minute/60   5**2   (5+9)*(15-7)

```

`+`, `-`, ve `/` sembolleri ve gruplama için parantez kullanımı Python'da da matematikteki anlamlarıyla kullanılmaktadır. Yıldız işareti ( `*`) çarpmanın ve `**` işareti de üs almanın sembolleridir.


Bir işlenenin yerinde değişkenin ismi yer aldığında, işlem yapılmadan önce bu değişken değeriyle değiştirilir.


Toplama, çıkarma, çarpma ve üs alma işlemleri neyi bekliyorsanız onu yapan işlemlerdir. Ancak bölme işlemine şaşırabilirsiniz. Aşağıdaki örnek beklemediğiniz bir sonuç üretecektir:


```
>>> dakika = 59
>>> dakika/60
0

```

`dakika`'nın değeri 59'dur ve 59, 60 ile bölündüğünde sonuç 0.98333 olmalıdır, 0 değil. Python'da bu farklı sonucun ortaya çıkmasının nedeni yukarıdaki örnekte **tamsayı bölme** işleminin uygulanmasıdır.


Eğer her iki işlenen de tamsayı ise, sonuçta bir tamsayı olmalıdır, ve geleneksel olarak tamsayı bölme işlemi her zaman _aşağı_ yuvarlanır, hatta örnekte olduğu gibi tamsayıların birbirine çok yakın olduğu durumlarda dahi.


Bu soruna olası bir çözüm kesir yerine yüzdeyi hesaplamaktır:


```
>>> dakika*100/60
98

```

Yine görüleceği üzere, sonuç aşağı yuvarlanmıştır ama en azından şimdi yaklaşık olarak doğru bir sonuç elde edebildik. Bir başka çözüm noktalı kayan (floating-point) bölme işlemini kullanmaktır. Dördüncü bölümde tamsayı değerleri ve değişkenleri kayan noktalı değerlere dönüştürmeyi göreceğiz.


## 2.7 İşleçlerin sırası

Eğer bir deyim içerisinde birden fazla işleç varsa, bu işleçlerin değerlendirilme sırası **öncelik kurallarına** göre belirlenir. Python matematikteki öncelik sırası kurallarının aynısını kullanır. PÜÇBTÇ (komik olduğunu biliyorum) kısaltması bu kuralları hatırlamak için kullanılabilecek bir kısaltmadır:


1. **P** arantezler en yüksek önceliğe sahiptir ve deyimlerin hangi sırada değerlendirilmesine yönelik ayarlamaları yapmanızı sağlarlar. Parantez içerisindeki deyimler daha önce değerlendirildiği için, `2 * (3-1)` 4, ve `(1+1)**(5-2)` 8'dir. Parantezleri ayrıca deyimleri daha kolay okumak için kullanabilirsiniz, `(minute * 100) / 60` örneğinde olduğu gibi, sonucu da değiştirmemiş olursunuz.

2. **Ü** s alma daha az önceliğe sahiptir, `2**1+1` ifadesi 3'tür 4 değil, ve `3*1**3` ifadesi de 3'tür 27 değil.

3. **Ç** arpma ve **B** ölme aynı önceliğe sahiptir, ve **T** oplama ve **Ç** ıkarmadan (ki bunlar da aynı önceliğe sahiptir) yüksek önceliklidir. `2*3-1` ifadesi 4 yerine 5 üretir, ve `2/3-1` ifadesi -1'dir, 1 değil (tamsayı bölmede 2/3=0 olduğunu hatırlayalım).

4. Aynı önceliğe sahip işleçlerin değerlendirilmesinde soldan sağa kuralı izlenir. `dakika*100/60` ifadesinde, çarpma işlemi önceliklidir 5900/60 sonucuna yol açar, bu ifade de 98'i üretir. Eğer işleçler sağdan sola değerlendirilecek olsaydı sonuç `59*1` olacaktır, bu da 59'u, yanlış bir sonucu üretecekti.


## 2.8 Karakter dizisi üzerindeki işlemler

Genel olarak, karakter dizileri üzerinde matematiksel işlemler uygulanamaz, her ne kadar karakter dizileri sayı gibi gözükse de. Aşağıdaki deyimler geçersiz deyimlerdir ( `mesaj`'ın `karakter dizisi (string)` tipinde olduğunu varsayalım):


```
 mesaj-1   "Merhaba"/123   mesaj*"Merhaba"   "15"+2

```

Ancak, `+` işleci karakter dizileriyle çalışmaktadır, ancak beklediğiniz sonucu üretmemektedir. Karakter dizileri için, `+` işleci **birleştirme (concatenation)** , bunun anlamı iki karakter dizisini uç uca bağlamaktır, işlemini yapacaktır. Örneğin:


```
        meyve = "muz"
        iyi_pisirilmis = " fındık ekmeği"
        print meyve + iyi_pisirilmis

```

Bu programın çıktısı `muz fındık ekmeği` olacaktır. `fındık`'tan önceki boşluk karakter dizisinin bir parçasıdır, ve birleştirme işleminde birleştirilen karakter dizileri arasında boşluk olmasını sağlıyor.


`*` işleci de karakter dizileri üzerinde çalışır. Tekrarlama işlemini gerçekleştirir. Örneğin `'Eğlence'*3` ifadesi `'EğlenceEğlenceEğlence'` sonucunu üretecektir. İşlenenlerden biri karakter dizisi, diğeri de tamsayı olmalıdır.


Diğer taraftan, `+` ve `*` işleçleri toplama ve çarpma benzerliğiyle daha rahat anlaşılabilir. `4*3` örneğinin `4+4+4` ifadesine eşit olması gibi, karakter dizilerinde de `'Eğlence'*3` ifadesinin `'Eğlence'+'Eğlence'+'Eğlence'` ifadesine eşit olmasını bekliyoruz ve eşittir. Ancak, karakter dizisi birleştirme ve tekrarlamasının tamsayı toplama ve çarpmasına göre önemli bir farkı vardır. Toplama ve çarpma işleminin sahip olduğu ancak karakter dizisi birleştirme ve tekrarlama işleminin sahip olmadığı bir özellik düşünebiliyor musunuz?


## 2.9 Girdi

Klavyeden girdi alabilmek için Python içerisinde tanımlı iki fonksiyon vardır:


```
        n = raw_input("Lütfen isminizi giriniz: ")
        print n
        n = input("Nümerik bir ifade giriniz: ")
        print n

```

Bu betiğin çalıştırılması aşağıdaki gibi bir sonuç üretecektir:


```
$ python tryinput.py
Lütfen isminizi giriniz: Arthur, İngiltere Kralı
Arthur, İngiltere Kralı
Nümerik bir ifade giriniz: 7 * 3
21

```

Her bir fonksiyon parantez içerisinde verilmiş ifadenin _gösterilmesini_ sağlar.


## 2.10 Kompozisyon

Şimdiye kadar programın öğelerini - değişkenler, deyimler, ve cümleler - ayrı ayrı inceledik, bunları nasıl birleştireceğimizden bahsetmedik.


Programlama dillerinin en kullanışlı özelliklerinden biri küçük yapısal blokları üretmek ve bunları `birleştirebilme (kompozisyon)` özelliğidir. Örneğin, sayıları nasıl ekleyeceğimizi ve ekranda değeri nasıl göstereceğimizi biliyoruz; bu ikisini birleştirerek aynı anda gerçekleştirebiliriz:


```
>>>  print 17 + 3
20

```

Gerçekte, toplama işlemi görüntülemeden önce yapılmalıdır, bu yüzden eylemler aynı anda olmamaktadır. Buradaki önemli nokta; sayıları, karakter dizilerini ve değişkenleri içeren herhangi bir deyim print cümlesi içinde kullanılabilir. Bunun örneklerini daha önce görmüştünüz:


```
        print "Geceyarısından beri geçen dakika: ", saat*60+dakika

```

İsteğe bağlı olarak bazı deyimleri atama cümlesinin sağında kullanabilirsiniz:


```
        yuzde = (dakika * 100) / 60

```

Bu özellik şu an etkileyici görünmeyebilir, ilerleyen süreçte kompozisyonun ne kadar etkili olabileceğini karmaşık hesaplamaları temiz ve kısaca yapabildiğinizde göreceksiniz.


Uyarı: Bazı deyimleri kullanmanıza yönelik olarak kısıtlamalar vardır. Örneğin, atama cümlesinin sol tarafı mutlaka _değişken_ ismi olmalıdır, deyim olamaz. Bu yüzden, aşağıdaki geçersiz bir ifadedir: `dakika + 1 = saat`.


## 2.11 Yorumlar

Programlar büyüyüp, karmaşıklaştıkça okunması zorlaşmaktadır. Biçimsel diller yoğundur ve kaynak kodun bir parçasına bakıp ne yaptığını veya neden bunu yaptığını anlamak oldukça zordur.


Bu nedenle, programlara kodu açıklayan doğal dilde notlar ve açıklamalar yazmak iyi bir fikirdir. Bu notlara **yorumlar** adı verilmektedir, ve `#` işaretiyle belirtilir:


```
        # gecen saatin yuzdesini hesaplayalim
        yuzde = (dakika * 100) / 60

```

Bu durumda yorum bir satır şeklinde gözükür. Yorumlar ayrıca satır sonuna da yerleştirilebilir:


```
        yuzde = (dakika * 100) / 60 # dikkat: tamsayi bolme

```

`#` işaretinden itibaren satır sonuna kadar her şey yoksayılır - program üzerinde bir etkisi yoktur-. Yorumların amacı ileride programı okuyacak ve inceleyecek programcılar içindir. Bu durumda, okuyucuya tamsayı bölme durumunu hatırlatma görevi üstlenmiştir.


## 2.12 Sözlük

değer:

Bir değişkende saklanabilecek veya bir deyimde hesaplanacak bir sayı veya karakter dizisidir (veya daha sonra isimlendirilecek bir şey).

tip:

Değerler kümesidir. Bir değerin tipi, deyimler içerisinde nasıl kullanabileceğini belirler. Şu ana kadar gördüğünüz değerler tamsayılar ( `int` tipi), kayan noktalı sayılar ( `float` tipi) ve karakter dizileridir ( `string` tipi).

int:

Pozitif ve negatif tam sayıları tutan Python veri tipidir.

str:
Karakter dizisi (string) tutan Python veri tipidir.

float:
_Kayan noktalı_ sayıları saklayan Python veri tipidir. Kayan noktalı sayılar içsel olarak iki parça şeklinde saklanır: bir _taban_ ve bir _üst_. Standart biçimde görüntülendiğinde, ondalık sayılar gibi gözükürler. `float` kullandığınızda yuvarlama hatalarına dikkat etmeniz gerekmektedir, ve yaklaşık değer barındırırlar.

değişken:

Bir değeri temsil eden isimdir.

atama cümlesi:

Bir isime (değişkene) değer atayan cümledir. Atama işlecinin , `=`, sol tarafı bir isimdir. Atama işlecinin sağ tarafı ise Python yorumlayıcısı tarafından değerlendirilecek ve isime atanacak değeri üretecek deyimdir. Atama işlecinin sol ve sağ taraflar arasındaki fark genellikle yeni programcıların kafasını karıştırabilir. Aşağıdaki atamada:


```
            n = n + 1

```

`n` değişkeni `=` işlecinin iki tarafında farklı görevler üstlenir. Sağ tarafta bir _değerdir_ ve Python yorumlayıcısı tarafından sol taraftaki isme atanmadan önce değerlendirilecek _deyimin_ bir kısmını oluşturur.

atama işleci:
`=` Python'un temel atama işlecidir, aynı işareti kullanan matematiksel karşılaştırma işleci ile karıştırılmamalıdır.

durum diyagramı:

Değişkenlerin ve referans ettikleri değerlerin grafiksel bir gösterimidir.

değişken ismi:

Bir değişkene verilen isimdir. Python'da değişken isimleri bir harf ile başlayan harf (a..z, A..Z ve \_) ve sayılardan (0..9) serilerinden oluşur. En iyi programlama pratiğinde değişken isimleri program içerisindeki kullanımlarını anlatacak şekilde seçilir, böylece program için _öz belgeleme_ yapmış olur.

anahtar kelime:

Derleyici tarafından programı ayrıştırmak için ayrılmış kelimelerdir; anahtar kelimelerini - `if`, `def`, ve `while` gibi - değişken isimleri olarak kullanamazsınız.

cümle:

Python yorumlayıcı tarafından yürütülebilecek yönergedir (komuttur). Cümlelerin örnekleri atama cümleleri ve print cümlesini içerir.

deyim:

Tek bir sonuç değeri temsil eden değişken, işleç ve değerlerin bir kombinasyonudur.

değerlendirme:

Bir deyimi basitleştirmek ve tek bir değer üretmek için sırasıyla işlemleri gerçekleştirmektir.

işleç:

Toplama, çarpma veya karakter dizisi birleştirme gibi tek bir hesaplamayı temsil eden özel işarettir.

işlenen:

İşlecin üzerinde işlem yaptığı değerlerden biridir.

tamsayı bölme:

Bir tamsayıyı başka bir tamsayı ile bölüp, tamsayı değer üreten işlemdir. Tamsayı bölme sadece bölünenin bölende kaç kere geçtiğini bulan tam sayılar üretir, kalanı yoksayar.

öncelik kuralları:

Çok sayıda işleç ve işlenen içeren deyimlerin değerlendirilme sırasını belirleyen kurallar kümesidir.

birleştirme:

İki işlenen uç uca eklemedir.

kompozisyon:

Basit deyimleri ve cümleleri, karmaşık hesaplamaları temsil etmek için bir araya getirip bileşik cümleler ve deyimler oluşturma özelliğidir.

yorum:

Program içerisinde diğer programcılar (veya kaynak kodu okuyan herhangi biri için) yazılmış olan bilgilerdir ve programın çalışması üzerinde bir etkisi yoktur.


## 2.13 Alıştırmalar

1. Aşağıdaki atama cümlelerini çalıştırdığınızda olanları kaydedin:


```
    >>> print n = 7

```


    Peki bu?


```
    >>> print 7 + 5

```


    Ya bu?


```
    >>> print 5.2, "bu", 4 - 2, "şu", 5/2.0

```

`print` cümlesi için genel bir kural düşünebiliyor musunuz? `print` cümlesi ne döndürmektedir?


2. _Tüm iş ve oyun oynamama Mustafa'yı anlayışsız yapmaktadır_ cümlesini ele alın ve her kelimeyi farklı bir değişkende saklayın, son olarak cümleyi tek bir print cümlesi yardımıyla tek satırda yazdırın.


3. `6*1-2` ifadesine parantez ekleyerek değerini 4'ten -6'ya dönüştürün.


4. Daha önce çalışmış bir koda yorum ekleyerek tekrar çalıştırın, ve sonucu inceleyin.


5. `input` ve `raw_input` arasındaki fark `input` girdi karakter dizisini değerlendirirken, `raw_input` değerlendirmemektedir. Aşağıdakileri yorumlayıcıda sınayın ve sonucu inceleyin:


```
    >>> x = input()
3.14
>>> type(x)

```



```
    >>> x = raw_input()
3.14
>>> type(x)

```



```
    >>> x = input()
'The knights who say "ni!"'
>>> x

```


    Aşağıdakini tırnak işaretleri olmadan denerseniz ne olur?


```
    >>> x = input()
The knights who say "ni!"
>>> x

```



```
    >>> x = raw_input()
'The knights who say "ni!"'
>>> x

```


    Her sonucu anlatın ve açıklayın.


6. Python yorumlayıcısını başlatın ve `bruce+4` ifadesini bilgi istemine girin. Bu size bir hata verecektir:


```
    NameError: name 'bruce' is not defined

```

`bruce` ismine bir değer atayın, böylece `bruce + 4` `10` değerini üretebilsin.


7. İsmi `madlib.py` bir program (Python betiği) yazın, bu program kullanıcıdan peşpeşe isimler, yüklemler, tümleçler, sıfatlar, çoğul isimler, geçmiş zaman yüklemleri, vb. cümle öğeleri istesin ve daha sonra bu girilen ifadeleri sözdizimi olarak doğru ancak anlambilimsel olarak yanlış bir paragraf üretsin (örnekler için [http://madlibs.org](http://madlibs.org) adresini inceleyebilirsiniz).



[İçindekiler](index.xhtml) \| [Dizin](dex.xhtml)