# 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

The interpreter acts as a simple calculator: you can type an expression at it and it will write the value. Expression syntax is straightforward: the operators `+`, `-`, `*` and `/` can be used to perform arithmetic; parentheses (`()`) can be used for grouping. For example:

    >>> 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.

Bölme (`/`) her zaman bir ondalıklı sayı döndürür. floor division yapmak ve bir tam sayı sonucu almak için `//` operatörünü kullanabilirsiniz; kalanı hesaplamak içinse `%` operatörünü kullanabilirsiniz:

    >>> 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. Metin

Python sayıların yanı sıra metinleri de (“string” olarak adlandırılan `str` türü ile temsil edilir) işleyebilir. Bu karakterleri “`!`”, kelimeleri “`tavşan`”, isimleri “`Paris`”, cümleleri “`Arkanı kolluyorum.`”, vb. içerir. “`Yay! :)`”. Tek tırnak (`'...'`) veya çift tırnak (`"..."`) içine alınabilirler ve aynı sonucu verirler [2].

    >>> 'spam eggs'  # single quotes
    'spam eggs'
    >>> "Paris rabbit got your back :)! Yay!"  # double quotes
    'Paris rabbit got your back :)! Yay!'
    >>> '1975'  # digits and numerals enclosed in quotes are also strings
    '1975'

Bir alıntıyı alıntılamak için, önüne `\` koyarak “kaçmamız”(escape) gerekir. Alternatif olarak, diğer tırnak işareti türlerini de kullanabiliriz:

    >>> '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.'

Python kabuğunda(shell), string tanımı ve çıktı stringi farklı görünebilir. `print()` fonksiyonu, tırnak işaretlerini atlayarak ve kaçan ve özel karakterleri yazdırarak daha okunabilir bir çıktı üretir:

    >>> s = 'First line.\nSecond line.'  # \n means newline
    >>> s  # without print(), special characters are included in the string
    'First line.\nSecond line.'
    >>> print(s)  # with print(), special characters are interpreted, so \n produces 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

Ham dizelerin ince bir yönü vardır: ham bir dize tek sayıda `\` karakterle bitmeyebilir; daha fazla bilgi ve geçici çözümler için SSS ‘e bakın.

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.

In addition to indexing, slicing is also supported. While indexing is used to obtain individual characters, slicing allows you to obtain a substring:

    >>> 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.

f-strings

  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]

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]

You can also add new items at the end of the list, by using the `list.append()` method (we will see more about methods later):

    >>> 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]

Simple assignment in Python never copies data. When you assign a list to a variable, the variable refers to the existing list. Any changes you make to the list through one variable will be seen through all other variables that refer to it.:

    >>> rgb = ["Red", "Green", "Blue"]
    >>> rgba = rgb
    >>> id(rgb) == id(rgba)  # they reference the same object
    True
    >>> rgba.append("Alph")
    >>> rgb
    ["Red", "Green", "Blue", "Alph"]

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:

    >>> correct_rgba = rgba[:]
    >>> correct_rgba[-1] = "Alpha"
    >>> correct_rgba
    ["Red", "Green", "Blue", "Alpha"]
    >>> rgba
    ["Red", "Green", "Blue", "Alph"]

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.

- The `print()` function writes the value of the argument(s) it is given. It differs from just writing the expression you want to write (as we did earlier in the calculator examples) in the way it handles multiple arguments, floating-point quantities, and strings. Strings are printed without quotes, and a space is inserted between items, so you can format things nicely, like this:

      >>> 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.