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", "1")
    ~~~~~~^^^^^^^^^^
  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
    +------------------------------------
>>>