# 3. Python’a Resmi Olmayan Bir Giriş

İlerleyen örneklerde; giriş ve çıkış, bilgi istemlerinin olup olmamasına göre ayırt edilir (>>> ve …): örneği tekrarlamak için bilgi isteminden sonra her şeyi yazmalısınız, istem göründüğünde bir bilgi istemi ile başlamayan satırlar yorumlayıcıdan çıkar. Bir örnekte tek başına bir satırdaki ikincil istemin boş bir satır yazmanız gerektiği anlamına geldiğini unutmayın; bu, çok satırlı bir komutu sonlandırmak için kullanılır.

Bir örnek kutusunun sağ üst köşesindeki `>>>` üzerine tıklayarak istemlerin ve çıktıların görüntülenmesini değiştirebilirsiniz. Bir örnek için istemleri ve çıktıyı gizlerseniz, giriş satırlarını kolayca kopyalayıp yorumlayıcınıza yapıştırabilirsiniz.

Bu kılavuzdaki örneklerin çoğu, etkileşimli komut isteminde girilenler dahil, yorumlar içerir. Python’da yorumlar, `#` hash karakteriyle başlar ve fiziksel satırın sonuna kadar uzanır. Bir satırın başında veya boşluk veya kodun ardından bir yorum görünebilir, ancak bir dize sabiti içinde değil. Bir dize sabiti içindeki bir hash karakteri, yalnızca bir hash karakterdir. Yorumlar kodu netleştirmek için olduğundan ve Python tarafından yorumlanmadığından örnekler yazarken atlanabilirler.

Bazı örnekler:

    # this is the first comment
    spam = 1  # and this is the second comment
              # ... and now a third!
    text = "# This is not a comment because it's inside quotes."

## 3.1. Python’ı Hesap Makinesi Olarak Kullanmak

Bazı basit Python komutlarını deneyelim. Yorumlayıcıyı başlatın ve `>>>` birincil istemini bekleyin. (Uzun sürmemelidir.)

### 3.1.1. Sayılar

Yorumlayıcı basit bir hesap makinesi görevi görür: ona bir ifade yazabilirsiniz ve değeri yazacaktır. İfade sözdizimi basittir: `+`, `-`, `*` ve `/` operatörleri, tıpkı diğer birçok dilde (örneğin, Pascal veya C) olduğu gibi çalışır; gruplama için parantezler (`()`) kullanılabilir. Örneğin:

    >>> 2 + 2
    4
    >>> 50 - 5*6
    20
    >>> (50 - 5*6) / 4
    5.0
    >>> 8 / 5  # division always returns a floating point number
    1.6

Tam sayıların (örneğin `2`, `4`, `20`) türü `int` olup, kesirli kısmı olanlar (örneğin `5.0`, `1.6`) `float` türüne sahiptir. Sayısal türler hakkında sonrasında daha fazlasını göreceğiz.

Division (`/`) always returns a float. To do floor division and get an integer result you can use the `//` operator; to calculate the remainder you can use `%`:

    >>> 17 / 3  # classic division returns a float
    5.666666666666667
    >>>
    >>> 17 // 3  # floor division discards the fractional part
    5
    >>> 17 % 3  # the % operator returns the remainder of the division
    2
    >>> 5 * 3 + 2  # floored quotient * divisor + remainder
    17

Python ile üslü sayıları hesaplamak için `**` operatörünü kullanmak mümkündür 1:

    >>> 5 ** 2  # 5 squared
    25
    >>> 2 ** 7  # 2 to the power of 7
    128

Bir değişkene değer atamak için eşittir işareti (`=`) kullanılır. Daha sonra, bir sonraki etkileşimli komut isteminden önce hiçbir sonuç görüntülenmez:

    >>> width = 20
    >>> height = 5 * 9
    >>> width * height
    900

Bir değişken “tanımlı” değilse (bir değer atanmamışsa), onu kullanmaya çalışmak size bir hata verecektir:

    >>> n  # try to access an undefined variable
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'n' is not defined

Ondalıklı sayı için tam destek var; karışık türde işlenenlere sahip operatörler, tam sayı işlenenini ondalıklı sayıya dönüştürür:

    >>> 4 * 3.75 - 1
    14.0

Etkileşimli modda, son yazdırılan ifade `_` değişkenine atanır. Bu, Python’ı bir masa hesap makinesi olarak kullandığınızda, hesaplamalara devam etmenin biraz daha kolay olduğu anlamına gelir, örneğin:

    >>> tax = 12.5 / 100
    >>> price = 100.50
    >>> price * tax
    12.5625
    >>> price + _
    113.0625
    >>> round(_, 2)
    113.06

Bu değişken, kullanıcı tarafından salt okunur olarak ele alınmalıdır. Açıkça ona bir değer atamayın — sihirli davranışları olan bu gömülü değişkeni maskeleyen aynı ada sahip bağımsız bir yerel değişken yaratırsınız.

`int` ve `float` ‘a ek olarak Python, `Decimal` ve `Fraction` gibi diğer sayı türlerini de destekler. Python ayrıca karmaşık sayılar için gömülü desteğe sahiptir ve hayali kısmı belirtmek için `j` veya `J` son ekini kullanır (ör. `3+5j`).

### 3.1.2. Dizeler

Sayıların yanı sıra Python, çeşitli şekillerde ifade edilebilen dizeleri de değiştirebilir. Tek tırnak (`'...'`) veya çift tırnak (`"..."`) içine alınabilirler ve aynı sonuç olur 2. `\` tırnaklardan kaçmak için kullanılabilir:

    >>> 'spam eggs'  # single quotes
    'spam eggs'
    >>> 'doesn\'t'  # use \' to escape the single quote...
    "doesn't"
    >>> "doesn't"  # ...or use double quotes instead
    "doesn't"
    >>> '"Yes," they said.'
    '"Yes," they said.'
    >>> "\"Yes,\" they said."
    '"Yes," they said.'
    >>> '"Isn\'t," they said.'
    '"Isn\'t," they said.'

Etkileşimli yorumlayıcıda, çıktı dizesi tırnak işaretleri içine alınır ve özel karakterler ters eğik çizgiyle çıkarılır. Bu bazen girdiden farklı görünse de (ilgili tırnak işaretleri değişebilir), iki dize eş değerdir. Dize tek bir tırnak işareti içeriyorsa ve çift tırnak içermiyorsa dize çift tırnak içine alınır, aksi takdirde tek tırnak içine alınır. `print()` fonksiyonu, ekteki tırnak işaretlerini atlayarak ve çıkış karakterlerini ve özel karakterleri yazdırarak daha okunaklı bir çıktı üretir:

    >>> '"Isn\'t," they said.'
    '"Isn\'t," they said.'
    >>> print('"Isn\'t," they said.')
    "Isn't," they said.
    >>> s = 'First line.\nSecond line.'  # \n means newline
    >>> s  # without print(), \n is included in the output
    'First line.\nSecond line.'
    >>> print(s)  # with print(), \n produces a new line
    First line.
    Second line.

`\` ile başlayan karakterlerin özel karakterler olarak yorumlanmasını istemiyorsanız, ilk alıntıdan önce bir `r` ekleyerek ham dizeleri (raw strings) kullanabilirsiniz:

    >>> print('C:\some\name')  # here \n means newline!
    C:\some
    ame
    >>> print(r'C:\some\name')  # note the r before the quote
    C:\some\name

There is one subtle aspect to raw strings: a raw string may not end in an odd number of `\` characters; see the FAQ entry for more information and workarounds.

Dize sabitleri birden çok satıra yayılabilir. Bunun bir yolu üçlü tırnak kullanmaktır: `"""..."""` veya `'''...'''`. Satır sonu otomatik olarak dizeye dahil edilir, ancak satırın sonuna `\` ekleyerek bunu önlemek mümkündür. Aşağıdaki örnek:

    print("""\
    Usage: thingy [OPTIONS]
         -h                        Display this usage message
         -H hostname               Hostname to connect to
    """)

aşağıdaki çıktıyı üretir (ilk yeni satırın dahil olmadığını unutmayın):

    Usage: thingy [OPTIONS]
         -h                        Display this usage message
         -H hostname               Hostname to connect to

Dizeler `+` operatörüyle birleştirilebilir (birbirine yapıştırılabilir) ve `*` ile tekrarlanabilir:

    >>> # 3 times 'un', followed by 'ium'
    >>> 3 * 'un' + 'ium'
    'unununium'

Yan yana iki veya daha fazla dize sabiti (yani, tırnak işaretleri arasına alınanlar) otomatik olarak birleştirilir.

    >>> 'Py' 'thon'
    'Python'

Bu özellik, özellikle uzun dizeleri kırmak istediğinizde kullanışlıdır:

    >>> text = ('Put several strings within parentheses '
    ...         'to have them joined together.')
    >>> text
    'Put several strings within parentheses to have them joined together.'

Bu, değişkenler veya ifadelerle değil, yalnızca iki sabit değerle çalışır:

    >>> prefix = 'Py'
    >>> prefix 'thon'  # can't concatenate a variable and a string literal
      File "<stdin>", line 1
        prefix 'thon'
               ^^^^^^
    SyntaxError: invalid syntax
    >>> ('un' * 3) 'ium'
      File "<stdin>", line 1
        ('un' * 3) 'ium'
                   ^^^^^
    SyntaxError: invalid syntax

Değişkenleri veya bir değişkeni ve bir sabiti birleştirmek istiyorsanız, `+` kullanın:

    >>> prefix + 'thon'
    'Python'

Dizeler, ilk karakterin indeksi 0 olacak şekilde dizine eklenebilir (abone olabilir). Karakterler için ayrı bir tür yoktur; karakterler yalnızca bir uzunluğunda dizelerdir:

    >>> word = 'Python'
    >>> word[0]  # character in position 0
    'P'
    >>> word[5]  # character in position 5
    'n'

Sağdan saymaya başlamak için indeksler negatif sayılar da olabilir:

    >>> word[-1]  # last character
    'n'
    >>> word[-2]  # second-last character
    'o'
    >>> word[-6]
    'P'

-0 ile 0 aynı olduğundan, negatif endekslerin -1’den başladığını unutmayın.

İndekslemeye ek olarak dilimleme de desteklenir. Tek tek karakterleri elde etmek için indeksleme kullanılırken, dilimleme alt dizeyi elde etmenizi sağlar:

    >>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
    'Py'
    >>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
    'tho'

Dilim indekslerinin kullanışlı varsayılanları vardır; atlanmış bir ilk dizin varsayılanı sıfırdır, atlanmış bir ikinci dizin varsayılanı dilimlenmekte olan dizenin boyutudur.

    >>> word[:2]   # character from the beginning to position 2 (excluded)
    'Py'
    >>> word[4:]   # characters from position 4 (included) to the end
    'on'
    >>> word[-2:]  # characters from the second-last (included) to the end
    'on'

Başlangıcın her zaman dahil edildiğine ve sonun her zaman hariç tutulduğuna dikkat edin. Bu, `s[:i] + s[i:]` değerinin her zaman `s` değerine eşit olmasını sağlar:

    >>> word[:2] + word[2:]
    'Python'
    >>> word[:4] + word[4:]
    'Python'

Dilimlerin nasıl çalıştığını hatırlamanın bir yolu, dizinleri ilk karakterin sol kenarı 0 ile arasındaki karakterleri işaret ediyor olarak düşünmektir. Ardından, n karakterli bir dizenin son karakterinin sağ kenarında n dizini vardır, örneğin:

     +---+---+---+---+---+---+
     | P | y | t | h | o | n |
     +---+---+---+---+---+---+
     0   1   2   3   4   5   6
    -6  -5  -4  -3  -2  -1

İlk sayı satırı, dizideki 0…6 endekslerinin konumunu verir; ikinci satır, karşılık gelen negatif endeksleri verir. i ile j arasındaki dilim, sırasıyla i ve j etiketli kenarlar arasındaki tüm karakterlerden oluşur.

Negatif olmayan indeksler için, her ikisi de sınırlar içindeyse, bir dilimin uzunluğu indekslerin farkıdır. Örneğin, `kelime[1:3]` ‘ün uzunluğu 2’dir.

Çok büyük bir dizin kullanmaya çalışmak bir hataya neden olur:

    >>> word[42]  # the word only has 6 characters
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    IndexError: string index out of range

Ancak, aralık dışı dilim endeksleri, dilimleme için kullanıldığında zarif bir şekilde işlenir:

    >>> word[4:42]
    'on'
    >>> word[42:]
    ''

Python dizeleri değiştirilemez — bunlar immutable ‘dır. Bu nedenle, dizide dizine alınmış bir konuma atamak bir hatayla sonuçlanır:

    >>> word[0] = 'J'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment
    >>> word[2:] = 'py'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment

Farklı bir dizeye ihtiyacınız varsa, yeni bir tane oluşturmalısınız:

    >>> 'J' + word[1:]
    'Jython'
    >>> word[:2] + 'py'
    'Pypy'

Yerleşik işlev `len()`, bir dizenin uzunluğunu döndürür:

    >>> s = 'supercalifragilisticexpialidocious'
    >>> len(s)
    34

Ayrıca bakınız

Metin Sırası Türü — str

  Dizeler, sıra türlerinin örnekleridir ve bu türler tarafından desteklenen genel işlemleri destekler.

dize-yöntemleri

  Dizeler, temel dönüşümler ve arama için çok sayıda yöntemi destekler.

Formatted string literals

  Gömülü ifadelere sahip dize sabitleri.

Format String Syntax

  `str.format()` ile dize biçimlendirme hakkında bilgi.

printf-style String Formatting

  Dizeler `%` operatörünün sol işleneni olduğunda çağrılan eski biçimlendirme işlemleri burada daha ayrıntılı olarak açıklanmaktadır.

### 3.1.3. Listeler

Python, diğer değerleri gruplamak için kullanılan bir dizi bileşik veri türünü bilir. En çok yönlü olanı, köşeli parantezler arasında virgülle ayrılmış değerlerin (ögelerin) bir listesi olarak yazılabilen liste’dir. Listeler farklı türde ögeler içerebilir, ancak genellikle ögelerin tümü aynı türdedir.

    >>> squares = [1, 4, 9, 16, 25]
    >>> squares
    [1, 4, 9, 16, 25]

Dizeler gibi (ve diğer tüm yerleşik sequence türleri), listeler dizine alınabilir ve dilimlenebilir:

    >>> squares[0]  # indexing returns the item
    1
    >>> squares[-1]
    25
    >>> squares[-3:]  # slicing returns a new list
    [9, 16, 25]

Tüm dilim işlemleri, istenen ögeleri içeren yeni bir liste döndürür. Bu, aşağıdaki dilimin listenin bir shallow copy döndürdüğü anlamına gelir:

    >>> squares[:]
    [1, 4, 9, 16, 25]

Ayrıca listeler birleştirme gibi işlemleri de destekler:

    >>> squares + [36, 49, 64, 81, 100]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

immutable olan dizelerin aksine, listeler mutable türündedir, yani içeriklerini değiştirmek mümkündür:

    >>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
    >>> 4 ** 3  # the cube of 4 is 64, not 65!
    64
    >>> cubes[3] = 64  # replace the wrong value
    >>> cubes
    [1, 8, 27, 64, 125]

Ayrıca, `append()` method’u kullanarak listenin sonuna yeni öğeler ekleyebilirsiniz (yöntemler hakkında daha fazla bilgiyi daha sonra göreceğiz):

    >>> cubes.append(216)  # add the cube of 6
    >>> cubes.append(7 ** 3)  # and the cube of 7
    >>> cubes
    [1, 8, 27, 64, 125, 216, 343]

Dilimlere atama da mümkündür ve bu, listenin boyutunu bile değiştirebilir veya tamamen temizleyebilir:

    >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> letters
    ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> # replace some values
    >>> letters[2:5] = ['C', 'D', 'E']
    >>> letters
    ['a', 'b', 'C', 'D', 'E', 'f', 'g']
    >>> # now remove them
    >>> letters[2:5] = []
    >>> letters
    ['a', 'b', 'f', 'g']
    >>> # clear the list by replacing all the elements with an empty list
    >>> letters[:] = []
    >>> letters
    []

Yerleşik işlev `len()` ayrıca listeler için de geçerlidir:

    >>> letters = ['a', 'b', 'c', 'd']
    >>> len(letters)
    4

Listeleri iç içe yerleştirmek (diğer listeleri içeren listeler oluşturmak) mümkündür, örneğin:

    >>> a = ['a', 'b', 'c']
    >>> n = [1, 2, 3]
    >>> x = [a, n]
    >>> x
    [['a', 'b', 'c'], [1, 2, 3]]
    >>> x[0]
    ['a', 'b', 'c']
    >>> x[0][1]
    'b'

## 3.2. Programlamaya Doğru İlk Adımlar

Elbette Python’ı iki ile ikiyi toplamaktan daha komplike görevler için kullanabiliriz. Örneğin, Fibonacci serisinin ilk alt dizisini aşağıdaki gibi yazabiliriz:

    >>> # Fibonacci series:
    ... # the sum of two elements defines the next
    ... a, b = 0, 1
    >>> while a < 10:
    ...     print(a)
    ...     a, b = b, a+b
    ...
    0
    1
    1
    2
    3
    5
    8

Bu örnek, birkaç yeni özellik sunar.

- İlk satır bir çoklu atama: `a` ve `b` değişkenleri aynı anda yeni 0 ve 1 değerlerini alır. Tarafların tümü, herhangi bir görev yapılmadan önce değerlendirilir. Sağ taraftaki ifadeler soldan sağa doğru değerlendirilir.

- `while` döngüsü, koşul (burada: `a < 10`) doğru kaldığı sürece yürütülür. Python’da, C’de olduğu gibi, sıfır olmayan herhangi bir tam sayı değeri doğrudur; sıfır yanlıştır. Koşul ayrıca bir dizi veya liste değeri, aslında herhangi bir dizi olabilir; uzunluğu sıfır olmayan her şey doğrudur, boş diziler yanlıştır. Örnekte kullanılan test basit bir karşılaştırmadır. Standart karşılaştırma işleçleri C’dekiyle aynı şekilde yazılır: `<` (küçüktür), `>` (büyüktür), `==` (eşittir), `<=` ( küçük veya eşit), `>=` (büyük veya eşit) ve `!=` (eşit değil).

- Döngünün gövdesi girintilidir: girinti, Python’un ifadeleri gruplama şeklidir. Etkileşimli komut isteminde, girintili her satır için bir sekme veya boşluk(lar) yazmanız gerekir. Pratikte, bir metin düzenleyici ile Python için daha karmaşık girdiler hazırlayacaksınız; tüm düzgün metin editörlerinin otomatik girinti özelliği vardır. Bir bileşik deyim etkileşimli olarak girildiğinde, tamamlandığını belirtmek için boş bir satırdan sonra gelmelidir (çünkü ayrıştırıcı son satırı ne zaman yazdığınızı tahmin edemez). Bir temel blok içindeki her satırın aynı miktarda girintili olması gerektiğini unutmayın.

- `print()` işlevi, kendisine verilen argüman(lar)ın değerini yazar. Yalnızca yazmak istediğiniz ifadeyi yazmaktan (daha önce hesap makinesi örneklerinde yaptığımız gibi) birden çok bağımsız değişkeni, kayan nokta miktarlarını ve dizeleri işleme biçiminden farklıdır. Dizeler tırnak işaretleri olmadan yazdırılır ve öğelerin arasına bir boşluk eklenir, böylece şunları güzel bir şekilde biçimlendirebilirsiniz:

      >>> i = 256*256
      >>> print('The value of i is', i)
      The value of i is 65536

  end anahtar sözcüğü argümanı, çıktıdan sonra yeni satırı önlemek veya çıktıyı farklı bir dizeyle bitirmek için kullanılabilir:

      >>> a, b = 0, 1
      >>> while a < 1000:
      ...     print(a, end=',')
      ...     a, b = b, a+b
      ...
      0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Dipnotlar

1

  `**`, `-` ‘den daha yüksek önceliğe sahip olduğundan, `-3**2`, `-(3**2)` olarak yorumlanacak ve dolayısıyla `-9` ile sonuçlanacaktır. Bundan kaçınmak ve `9` elde etmek için `(-3)**2` kullanabilirsiniz.

2

  Diğer dillerden farklı olarak, `\n` gibi özel karakterler hem tek (`'...'`) hem de çift (`"..."`) tırnak işaretleri ile aynı anlama sahiptir. İkisi arasındaki tek fark, tek tırnak içinde `"` dan kaçmanıza gerek olmamasıdır (ancak `\'` dan kaçmanız gerekir) ve bunun tersi de geçerlidir.