# 8. Hatalar ve Özel Durumlar

Şimdiye kadar hata mesajlarından fazla bahsedilmedi, ancak örnekleri denediyseniz muhtemelen bazılarını görmüşsünüzdür. (En azından) iki ayırt edilebilir hata türü vardır: söz dizimi hataları (syntax errors) ve özel durumlar (exceptions).

## 8.1. Söz Dizimi Hataları

Ayrıştırma hataları olarak da bilinen söz dizimi hataları, Python öğrenirken belki de en sık karşılaşılan hatalardan biridir:

    >>> while True print('Hello world')
      File "<stdin>", line 1
        while True print('Hello world')
                       ^
    SyntaxError: invalid syntax

Ayrıştırıcı, hatalı satırı yineler ve hatanın algılandığı en erken noktayı gösteren küçük bir ‘ok’ görüntüler. Hata oktan önceki dizgede meydana gelmiştir: örnekte, hata `print()` fonksiyonunda algılanır, çünkü öncesinde iki nokta üst üste (`':'`) eksiktir. Dosya adı ve satır numarası yazdırılır, böylece girişin bir komut dosyasından gelmesi durumunda nereye bakacağınızı bilirsiniz.

## 8.2. Özel Durumlar

Bir komut veya ifade söz dizimsel olarak doğru olsa bile, yürütülmeye çalışıldığında hataya neden olabilir. Yürütme sırasında algılanan hatalara exceptions (özel durumlar) denir ve bazıları programlar için kritik değildir: yakında Python programlarında bunların üstesinden gelmeyi öğreneceksiniz. Ancak, çoğu özel durum programlar tarafından önlenemez ve burada gösterildiği gibi hata iletileriyle sonuçlanır:

    >>> 10 * (1/0)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ZeroDivisionError: division by zero
    >>> 4 + spam*3
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: name 'spam' is not defined
    >>> '2' + 2
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: can only concatenate str (not "int") to str

Hata iletisinin son satırı hataya neyin sebep olduğu gösterir. Özel durumlar farklı türlerde gelir ve tür iletinin bir parçası olarak yazdırılır: örnekteki türler şunlardır `ZeroDivisionError`, `NameError` ve `TypeError`. Özel durum türü olarak yazdırılan dize, oluşan gömülü özel durumun adıdır. Bu, tüm gömülü özel durumlar için geçerlidir, ancak kullanıcı tanımlı özel durumlar için doğru olması gerekmez (yararlı bir kural olmasına rağmen). Standart özel durum adları gömülü tanımlayıcılardır (ayrılmış anahtar sözcükler değildir).

Satırın geri kalanı, özel durum türüne ve buna neyin neden olduğuna bağlı olarak ayrıntı gösterir.

Hata iletisinin önceki bölümü, özel durumun oluştuğu bağlamı yığın izleme geri dönüşü biçiminde gösterir. Genel olarak, kaynak satırları listeleyen bir yığın izleme listesi içerir; ancak, standart girişten okunan satırları görüntülemez.

Built-in Exceptions yerleşik özel durumları ve anlamlarını listeler.

## 8.3. Özel Durumları İşleme

Seçili özel durumları işleyen programlar yazmak mümkündür. Geçerli bir tam sayı girilene kadar kullanıcıdan giriş isteyen, ancak kullanıcının programı kesmesine izin veren aşağıdaki örneğe bakın (``Control`-`C`` veya işletim sistemi ne destekliyorsa onu kullanarak); kullanıcı kaynaklı kesintilerin `KeyboardInterrupt` özel durumu ile gösterildiğini unutmayın.

    >>> while True:
    ...     try:
    ...         x = int(input("Please enter a number: "))
    ...         break
    ...     except ValueError:
    ...         print("Oops!  That was no valid number.  Try again...")
    ...

`try` ifadesi aşağıdaki gibi çalışır.

- İlk olarak, try yan tümcesi (`try` ve `except` anahtar kelimeleri arasındaki ifadeler) yürütülür.

- Özel durum oluşmazsa, except yan tümcesi atlanır ve `try` ifadesinin yürütülmesi tamamlanır.

- `try` yan tümcesinin yürütülmesi sırasında bir özel durum oluşursa, yan tümcenin geri kalanı atlanır. Daha sonra belirtilen `except` türü ile karşılaşılırsa, except yan tümcesi yürütülür ve try/except bloğundan sonra yürütme devam eder.

- except yan tümcesinde adı geçen özel durumla eşleşmeyen bir özel durum oluşursa, daha dışarıda olan `try` ifadelerine geçirilir; işleyici bulunamazsa, bu bir işlenmeyen özel durum olur ve yürütme yukarıda gösterildiği gibi bir iletiyle durur.

`try` ifadesi, farklı özel durumlar için işleyiciler belirtmek üzere birden fazla except yan tümcesi alabilir. Maksimum bir tane işleyici yürütülür. İşleyiciler yalnızca karşılık gelen try yan tümcesinde oluşan özel durumları işler, aynı `try` ifadesinin diğer işleyicilerinde işlemez. except yan tümcesi birden çok özel durumu parantezli demet olarak adlandırabilir, örneğin:

    ... except (RuntimeError, TypeError, NameError):
    ...     pass

`except` yan tümcesi, aynı sınıf veya temel sınıf ise özel durum ile uyumludur (ancak türetilmiş bir sınıfı listeleyen except yan tümcesi temel sınıfla uyumlu olmadığından tersi olamaz). Örneğin, aşağıdaki kod B, C, D’yi bu sırada yazdırır:

    class B(Exception):
        pass

    class C(B):
        pass

    class D(C):
        pass

    for cls in [B, C, D]:
        try:
            raise cls()
        except D:
            print("D")
        except C:
            print("C")
        except B:
            print("B")

except yan tümceleri tersine çevrilmişse (ilk olarak `except B` ile) B, B, B şeklinde yazdırılacaktır — ilk eşleşen except yan tümcesi tetiklenir.

Tüm özel durumlar `BaseException` ‘dan kalıt alınır ve böylece joker karakter olarak kullanılabilir. Bunu çok dikkatli kullanın, çünkü gerçek bir programlama hatasını bu şekilde maskelemek kolaydır! Ayrıca, bir hata iletisi yazdırmak ve sonra özel durumu yeniden yükseltmek için de kullanılabilir (çağıranın özel durumu işlemesine izin vermek):

    import sys

    try:
        f = open('myfile.txt')
        s = f.readline()
        i = int(s.strip())
    except OSError as err:
        print("OS error: {0}".format(err))
    except ValueError:
        print("Could not convert data to an integer.")
    except BaseException as err:
        print(f"Unexpected {err=}, {type(err)=}")
        raise

Alternatif olarak, son özel durum yan tümcesi özel durum ad(ları)nı atlayabilir, ancak özel durum değeri daha sonra `sys.exc_info()[1]` ‘den alınmalıdır.

`try` … `except` ifadesinin isteğe bağlı bir else yan tümcesi vardır, bu da mevcut olduğunda tüm except yan tümcelerini izlemelidir. try yan tümcesi bir özel durum oluşturmazsa yürütülmesi gereken kod için yararlıdır. Mesela:

    for arg in sys.argv[1:]:
        try:
            f = open(arg, 'r')
        except OSError:
            print('cannot open', arg)
        else:
            print(arg, 'has', len(f.readlines()), 'lines')
            f.close()

`else` yan tümcesinin kullanılması, `try` yan tümcesine ek kod eklemekten daha iyidir çünkü yanlışlıkla `try` tarafından korunan kod tarafından oluşturulmamış bir istisnayı yakalamayı önler. … `except` ifadesi.

Bir istisna oluştuğunda, istisnanın argümanı olarak da bilinen ilişkili bir değeri olabilir. Argümanın varlığı ve türü, istisna türüne bağlıdır.

except yan tümcesi, istisna adından sonra bir değişken belirtebilir. Değişken, `instance.args` içinde depolanan bağımsız değişkenlerle bir istisna örneğine bağlıdır. Kolaylık sağlamak için, istisna örneği `__str__()` öğesini tanımlar, böylece argümanlar `.args` öğesine başvurmak zorunda kalmadan doğrudan yazdırılabilir. Ayrıca, bir istisna, onu yükseltmeden önce başlatabilir ve istendiği gibi ona herhangi bir nitelik ekleyebilir.

    >>> try:
    ...     raise Exception('spam', 'eggs')
    ... except Exception as inst:
    ...     print(type(inst))    # the exception instance
    ...     print(inst.args)     # arguments stored in .args
    ...     print(inst)          # __str__ allows args to be printed directly,
    ...                          # but may be overridden in exception subclasses
    ...     x, y = inst.args     # unpack args
    ...     print('x =', x)
    ...     print('y =', y)
    ...
    <class 'Exception'>
    ('spam', 'eggs')
    ('spam', 'eggs')
    x = spam
    y = eggs

Bir istisnanın argümanları varsa, bunlar işlenmeyen istisnalar için mesajın son kısmı (‘ayrıntı’) olarak yazdırılır.

İstisna işleyicileri, istisnaları yalnızca try yan tümcesinde hemen ortaya çıktıklarında değil, aynı zamanda try yan tümcesinde çağrılan (dolaylı olarak bile) işlevlerin içinde ortaya çıktıklarında da ele alırlar. Örneğin:

    >>> def this_fails():
    ...     x = 1/0
    ...
    >>> try:
    ...     this_fails()
    ... except ZeroDivisionError as err:
    ...     print('Handling run-time error:', err)
    ...
    Handling run-time error: division by zero

## 8.4. Hata Ortaya Çıkartma

`raise` ifadesi, programcının belirli bir istisnanın gerçekleşmesini zorlamasını sağlar. Örneğin:

    >>> raise NameError('HiThere')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    NameError: HiThere

`raise` için tek argüman, ortaya çıkacak istisnayı belirtir. Bu, bir istisna örneği veya bir istisna sınıfı (`Exception` dan türetilen bir sınıf) olmalıdır. Argüman verilmezse, yapıcısı hiçbir argüman olmadan çağrılarak örtük olarak başlatılacaktır:

    raise ValueError  # shorthand for 'raise ValueError()'

Bir istisnanın oluşturulup oluşturulmadığını belirlemeniz gerekiyorsa ancak onu işlemeyi düşünmüyorsanız, `raise` ifadesinin daha basit bir biçimi, istisnayı yeniden oluşturmanıza olanak tanır:

    >>> try:
    ...     raise NameError('HiThere')
    ... except NameError:
    ...     print('An exception flew by!')
    ...     raise
    ...
    An exception flew by!
    Traceback (most recent call last):
      File "<stdin>", line 2, in <module>
    NameError: HiThere

## 8.5. İstisna Zincirleme

If an unhandled exception occurs inside an `except` section, it will have the exception being handled attached to it and included in the error message:

    >>> try:
    ...     open("database.sqlite")
    ... except OSError:
    ...     raise RuntimeError("unable to handle error")
    ...
    Traceback (most recent call last):
      File "<stdin>", line 2, in <module>
    FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'

    During handling of the above exception, another exception occurred:

    Traceback (most recent call last):
      File "<stdin>", line 4, in <module>
    RuntimeError: unable to handle error

To indicate that an exception is a direct consequence of another, the `raise` statement allows an optional `from` clause:

    # exc must be exception instance or None.
    raise RuntimeError from exc

Bu, özel durumları dönüştürürken yararlı olabilir. Mesela:

    >>> def func():
    ...     raise ConnectionError
    ...
    >>> try:
    ...     func()
    ... except ConnectionError as exc:
    ...     raise RuntimeError('Failed to open database') from exc
    ...
    Traceback (most recent call last):
      File "<stdin>", line 2, in <module>
      File "<stdin>", line 2, in func
    ConnectionError

    The above exception was the direct cause of the following exception:

    Traceback (most recent call last):
      File "<stdin>", line 4, in <module>
    RuntimeError: Failed to open database

It also allows disabling automatic exception chaining using the `from None` idiom:

    >>> try:
    ...     open('database.sqlite')
    ... except OSError:
    ...     raise RuntimeError from None
    ...
    Traceback (most recent call last):
      File "<stdin>", line 4, in <module>
    RuntimeError

Zincirleme mekaniği hakkında daha fazla bilgi için bkz. Built-in Exceptions.

## 8.6. Kullanıcı Tanımlı İstisnalar

Programlar yeni bir istisna sınıfı oluşturarak kendi özel durumlarını adlandırabilir (Python sınıfları hakkında daha fazla bilgi için bkz: Sınıflar ). Özel durumlar genellikle doğrudan veya dolaylı olarak `Exception` sınıfından türetilmelidir.

Exception classes can be defined which do anything any other class can do, but are usually kept simple, often only offering a number of attributes that allow information about the error to be extracted by handlers for the exception.

Çoğu özel durum, standart özel durumların adlandırışına benzer şekilde “Hata” ile biten adlarla tanımlanır.

Birçok standart modül, tanımladıkları işlevlerde oluşabilecek hataları bildirmek için kendi istisnalarını tanımlar. Dersler hakkında daha fazla bilgi Sınıflar bölümünde sunulmaktadır.

## 8.7. Temizleme Eylemlerini Tanımlama

`try` deyimi, her koşulda yürütülmesi gereken temizleme eylemlerini tanımlamayı amaçlayan başka bir opsiyonel yan tümceye sahiptir. Mesela:

    >>> try:
    ...     raise KeyboardInterrupt
    ... finally:
    ...     print('Goodbye, world!')
    ...
    Goodbye, world!
    Traceback (most recent call last):
      File "<stdin>", line 2, in <module>
    KeyboardInterrupt

Bir `finally` yan tümcesi varsa, `finally` yan tümcesi `try` deyimi tamamlanmadan önceki son görev olarak yürütülür. `finally` yan tümcesi `try` deyiminin bir istisna oluşturup oluşturmadığından bağımsız çalışır. Aşağıdaki noktalarda, bir istisna oluştuğunda daha karmaşık durumlar anlatılmaktadır:

- `try` yan tümcesinin yürütülmesi sırasında bir istisna oluşursa, istisna bir `except` yan tümcesi tarafından işlenebilir. İstisna bir `except` yan tümcesi tarafından ele alınmıyorsa, istisna `finally` yan tümcesi yürütüldükten sonra yeniden oluşturulur.

- Bir `except` veya `else` yan tümcesinin yürütülmesi sırasında bir istisna oluşabilir. Yine, istisna, `finally` yan tümcesi yürütüldükten sonra yeniden oluşturulur.

- `finally` yan tümcesi bir `break`, `continue` veya `return` deyimini yürütürse, istisnalar yeniden oluşturulmaz.

- `try` ifadesi bir `break`, `continue` veya `return` ifadesine ulaşırsa, `finally` yan tümcesi `break`, `continue` veya `return` ifadesinin yürütülmesinin hemen öncesinde yürütülür.

- Bir `finally` yan tümcesi bir `return` ifadesini içeriyorsa, döndürülen değer, `finally` yan tümcesinin `return` ifadesindeki değer olacaktır, `try` yan tümcesinin `return` ifadesindeki değer değil.

Mesela:

    >>> def bool_return():
    ...     try:
    ...         return True
    ...     finally:
    ...         return False
    ...
    >>> bool_return()
    False

Daha karmaşık bir örnek:

    >>> def divide(x, y):
    ...     try:
    ...         result = x / y
    ...     except ZeroDivisionError:
    ...         print("division by zero!")
    ...     else:
    ...         print("result is", result)
    ...     finally:
    ...         print("executing finally clause")
    ...
    >>> divide(2, 1)
    result is 2.0
    executing finally clause
    >>> divide(2, 0)
    division by zero!
    executing finally clause
    >>> divide("2", "1")
    executing finally clause
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<stdin>", line 3, in divide
    TypeError: unsupported operand type(s) for /: 'str' and 'str'

Gördüğünüz gibi, `finally` yan tümcesi her durumda yürütülür. İki dizeyi bölerek oluşturulan `TypeError`, `except` yan tümcesi tarafından işlenmez ve bu nedenle `finally` yan tümcesi yürütüldikten sonra yeniden yükseltilir.

Gerçek dünyadaki uygulamalarda `finally` yan tümcesi, kaynağın kullanımının başarılı olup olmadığına bakılmaksızın dış kaynakları (dosyalar veya ağ bağlantıları gibi) serbest bırakmak için yararlıdır.

## 8.8. Önceden Tanımlanmış Temizleme Eylemleri

Bazı nesneler, nesneyi kullanan işlemin başarılı veya başarısız olup olmadığına bakılmaksızın, nesne artık gerekli olmadığında gerçekleştirilecek standart temizleme eylemlerini tanımlar. Bir dosyayı açmaya ve içeriğini ekrana yazdırmaya çalışan aşağıdaki örneğe bakın.

    for line in open("myfile.txt"):
        print(line, end="")

Bu kodla ilgili sorun, kodun bu bölümünün yürütülmesi tamamlandıktan sonra dosyayı belirsiz bir süre açık bırakmasıdır. Bu basit komut dosyalarında bir sorun değildir, ancak daha büyük uygulamalar için bir sorun olabilir. `with` ifadesi, dosyalar gibi nesnelerin her zaman hızlı ve doğru temizlenmesini sağlayacak şekilde kullanılmasına izin verir.

    with open("myfile.txt") as f:
        for line in f:
            print(line, end="")

İfade çalıştırıldıktan sonra, satırlar işlenirken bir sorunla karşılaşılsa bile f dosyası her zaman kapatılır. Dosyalar gibi önceden tanımlanmış temizleme eylemleri sağlayan nesneler dokümantasyonlarında bunu gösterir.