# 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

The parser repeats the offending line and displays little ‘arrow’s pointing at the token in the line where the error was detected. The error may be caused by the absence of a token before the indicated token. In the example, the error is detected at the function `print()`, since a colon (`':'`) is missing before it. File name and line number are printed so you know where to look in case the input came from a script.

## 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>
        10 * (1/0)
              ~^~
    ZeroDivisionError: division by zero
    >>> 4 + spam*3
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
        4 + spam*3
            ^^^^
    NameError: name 'spam' is not defined
    >>> '2' + 2
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
        '2' + 2
        ~~~~^~~
    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.

Gömülü İstisnalar 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.

- If an exception occurs which does not match the exception named in the except clause, it is passed on to outer `try` statements; if no handler is found, it is an unhandled exception and execution stops with an error message.

`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

A class in an `except` clause matches exceptions which are instances of the class itself or one of its derived classes (but not the other way around — an except clause listing a derived class does not match instances of its base classes). For example, the following code will print B, C, D in that order:

    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.

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.

The except clause may specify a variable after the exception name. The variable is bound to the exception instance which typically has an `args` attribute that stores the arguments. For convenience, builtin exception types define `__str__()` to print all the arguments without explicitly accessing `.args`.

    >>> try:
    ...     raise Exception('spam', 'eggs')
    ... except Exception as inst:
    ...     print(type(inst))    # the exception type
    ...     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

The exception’s `__str__()` output is printed as the last part (‘detail’) of the message for unhandled exceptions.

`BaseException`, tüm istisnaların ortak temel sınıfıdır. Alt sınıflarından biri olan `Exception`, tüm önemli olmayan istisnaların temel sınıfıdır. `Exception` öğesinin alt sınıfları olmayan istisnalar genellikle işlenmez, çünkü bunlar programın sona ermesi gerektiğini belirtmek için kullanılır. Bunlar `sys.exit()` tarafından oluşturulan `SystemExit` ve bir kullanıcı programı kesmek istediğinde ortaya çıkan `KeyboardInterrupt` içerir.

`Exception` (neredeyse) her şeyi yakalayan bir joker karakter (wildcard) olarak kullanılabilir. Ancak, işlemeyi amaçladığımız istisna türleri konusunda mümkün olduğunca spesifik olmak ve beklenmeyen istisnaların yayılmasına izin vermek iyi bir uygulamadır.

`Exception` işlemek için en yaygın model, istisnayı yazdırmak veya log’a kaydetmek ve ardından yeniden yükseltmektir (arayanın istisnayı da işlemesine izin verir):

    import sys

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

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

İstisna işleyicileri, yalnızca try yan tümcesinde anında ortaya çıkan istisnaları değil, aynı zamanda try yan tümcesinde çağrılan (dolaylı olarak da olsa) işlevlerin içinde oluşan istisnaları da işler. Ö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 Yükseltme

`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>
        raise NameError('HiThere')
    NameError: HiThere

`raise` için tek argüman, ortaya çıkacak istisnayı belirtir. Bu, bir istisna örneği veya bir istisna sınıfı (`BaseException` ‘dan türetilen bir sınıf, örneğin `Exception` veya alt sınıflarından) olmalıdır. Bir istisna sınıfı iletilirse, yapıcısını hiçbir argüman olmadan çağırarak dolaylı olarak başlatılı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>
        raise NameError('HiThere')
    NameError: HiThere

## 8.5. İstisna Zincirleme

Bir `except` bölümü içinde işlenmeyen bir istisna meydana gelirse, istisnanın kendisine eklenmiş olarak işlenmesi ve şu hata mesajına dahil edilmesi gerekir:

    >>> try:
    ...     open("database.sqlite")
    ... except OSError:
    ...     raise RuntimeError("unable to handle error")
    ...
    Traceback (most recent call last):
      File "<stdin>", line 2, in <module>
        open("database.sqlite")
        ~~~~^^^^^^^^^^^^^^^^^^^
    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>
        raise RuntimeError("unable to handle error")
    RuntimeError: unable to handle error

`raise` ifadesi, bir istisnanın başka bir istisnanın doğrudan sonucu olduğunu belirtmek için isteğe bağlı `from` yan tümcesine izin verir:

    # 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>
        func()
        ~~~~^^
      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>
        raise RuntimeError('Failed to open database') from exc
    RuntimeError: Failed to open database

Ayrıca, `from None` deyimi kullanılarak otomatik istisna zincirlemenin devre dışı bırakılmasına izin verir:

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

Zincirleme mekaniği hakkında daha fazla bilgi için bkz. Gömülü İstisnalar.

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

İstisna sınıfları, başka herhangi bir sınıfın yapabileceği her şeyi yapan tanımlanabilir, ancak genellikle basit tutulur ve çoğu zaman yalnızca istisna için işleyiciler tarafından hatayla ilgili bilgilerin çıkarılmasına izin veren bir dizi öznitelik sunar.

Ç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ı raporlamak için kendi istisnalarını tanımlar.

## 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>
        raise KeyboardInterrupt
    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>
        divide("2", "0")
        ~~~~~~^^^^^^^^^^
      File "<stdin>", line 3, in divide
        result = x / y
                 ~~^~~
    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.

## 8.9. Birden Fazla Alakasız İstisna Oluşturma ve İşleme

Meydana gelen birkaç istisnanın rapor edilmesinin gerekli olduğu durumlar vardır. Bu, genellikle birkaç görevin paralel olarak başarısız olabileceği eşzamanlılık çerçevelerinde geçerlidir, ancak ilk istisnayı yükseltmek yerine yürütmeye devam etmenin ve birden çok hata toplamanın istendiği başka kullanım durumları da vardır.

Yerleşik `ExceptionGroup`, birlikte oluşturulabilmeleri için istisna örneklerinin bir listesini sarar. Kendisi bir istisnadır, bu nedenle herhangi bir istisna gibi yakalanabilir.

    >>> def f():
    ...     excs = [OSError('error 1'), SystemError('error 2')]
    ...     raise ExceptionGroup('there were problems', excs)
    ...
    >>> f()
      + Exception Group Traceback (most recent call last):
      |   File "<stdin>", line 1, in <module>
      |     f()
      |     ~^^
      |   File "<stdin>", line 3, in f
      |     raise ExceptionGroup('there were problems', excs)
      | ExceptionGroup: there were problems (2 sub-exceptions)
      +-+---------------- 1 ----------------
        | OSError: error 1
        +---------------- 2 ----------------
        | SystemError: error 2
        +------------------------------------
    >>> try:
    ...     f()
    ... except Exception as e:
    ...     print(f'caught {type(e)}: e')
    ...
    caught <class 'ExceptionGroup'>: e
    >>>

`except` yerine `except*` kullanarak, yalnızca gruptaki belirli bir türle eşleşen istisnaları seçerek işleyebiliriz. İç içe geçmiş bir istisna grubunu gösteren aşağıdaki örnekte, her bir `except*` yan tümcesi, diğer tüm istisnaların diğer yan tümcelere yayılmasına ve sonunda yeniden ortaya çıkmasına izin verirken, belirli bir türdeki grup istisnalarını çıkarır.

    >>> def f():
    ...     raise ExceptionGroup(
    ...         "group1",
    ...         [
    ...             OSError(1),
    ...             SystemError(2),
    ...             ExceptionGroup(
    ...                 "group2",
    ...                 [
    ...                     OSError(3),
    ...                     RecursionError(4)
    ...                 ]
    ...             )
    ...         ]
    ...     )
    ...
    >>> try:
    ...     f()
    ... except* OSError as e:
    ...     print("There were OSErrors")
    ... except* SystemError as e:
    ...     print("There were SystemErrors")
    ...
    There were OSErrors
    There were SystemErrors
      + Exception Group Traceback (most recent call last):
      |   File "<stdin>", line 2, in <module>
      |     f()
      |     ~^^
      |   File "<stdin>", line 2, in f
      |     raise ExceptionGroup(
      |     ...<12 lines>...
      |     )
      | ExceptionGroup: group1 (1 sub-exception)
      +-+---------------- 1 ----------------
        | ExceptionGroup: group2 (1 sub-exception)
        +-+---------------- 1 ----------------
          | RecursionError: 4
          +------------------------------------
    >>>

Bir istisna grubunda iç içe geçmiş istisnaların türler değil, örnekler olması gerektiğini unutmayın. Bunun nedeni, pratikte istisnaların tipik olarak, aşağıdaki kalıp boyunca program tarafından önceden oluşturulmuş ve yakalanmış olanlar olmasıdır:

    >>> excs = []
    ... for test in tests:
    ...     try:
    ...         test.run()
    ...     except Exception as e:
    ...         excs.append(e)
    ...
    >>> if excs:
    ...    raise ExceptionGroup("Test Failures", excs)
    ...

## 8.10. İstisnaları Notlarla Zenginleştirme

Yükseltilmek üzere bir istisna oluşturulduğunda, genellikle meydana gelen hatayı açıklayan bilgilerle başlatılır. İstisna yakalandıktan sonra bilgi eklemenin yararlı olduğu durumlar vardır. Bu amaçla, istisnaların bir dizgiyi kabul eden ve onu istisnanın notlar listesine ekleyen `add_note(note)` metodu vardır. Standart geri işleme (traceback) oluşturma, tüm notları istisnadan sonra eklendikleri sırayla içerir.

    >>> try:
    ...     raise TypeError('bad type')
    ... except Exception as e:
    ...     e.add_note('Add some information')
    ...     e.add_note('Add some more information')
    ...     raise
    ...
    Traceback (most recent call last):
      File "<stdin>", line 2, in <module>
        raise TypeError('bad type')
    TypeError: bad type
    Add some information
    Add some more information
    >>>

Örneğin, istisnaları bir istisna grubuna toplarken, bireysel hatalar için bağlam bilgisi eklemek isteyebiliriz. Aşağıda, gruptaki her özel durum, bu hatanın ne zaman oluştuğunu gösteren bir nota sahiptir.

    >>> def f():
    ...     raise OSError('operation failed')
    ...
    >>> excs = []
    >>> for i in range(3):
    ...     try:
    ...         f()
    ...     except Exception as e:
    ...         e.add_note(f'Happened in Iteration {i+1}')
    ...         excs.append(e)
    ...
    >>> raise ExceptionGroup('We have some problems', excs)
      + Exception Group Traceback (most recent call last):
      |   File "<stdin>", line 1, in <module>
      |     raise ExceptionGroup('We have some problems', excs)
      | ExceptionGroup: We have some problems (3 sub-exceptions)
      +-+---------------- 1 ----------------
        | Traceback (most recent call last):
        |   File "<stdin>", line 3, in <module>
        |     f()
        |     ~^^
        |   File "<stdin>", line 2, in f
        |     raise OSError('operation failed')
        | OSError: operation failed
        | Happened in Iteration 1
        +---------------- 2 ----------------
        | Traceback (most recent call last):
        |   File "<stdin>", line 3, in <module>
        |     f()
        |     ~^^
        |   File "<stdin>", line 2, in f
        |     raise OSError('operation failed')
        | OSError: operation failed
        | Happened in Iteration 2
        +---------------- 3 ----------------
        | Traceback (most recent call last):
        |   File "<stdin>", line 3, in <module>
        |     f()
        |     ~^^
        |   File "<stdin>", line 2, in f
        |     raise OSError('operation failed')
        | OSError: operation failed
        | Happened in Iteration 3
        +------------------------------------
    >>>