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't convert 'int' object to str implicitly

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.

The preceding part of the error message shows the context where the
exception happened, in the form of a stack traceback. In general it
contains a stack traceback listing source lines; however, it will not
display lines read from standard input.

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.

* If an exception occurs during execution of the try clause, the rest
  of the clause is skipped.  Then if its type matches the exception
  named after the "except" keyword, the except clause is executed, and
  then execution continues after the "try" statement.

* 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 a message as shown above.

A "try" statement may have more than one except clause, to specify
handlers for different exceptions.  At most one handler will be
executed. Handlers only handle exceptions that occur in the
corresponding try clause, not in other handlers of the same "try"
statement.  An except clause may name multiple exceptions as a
parenthesized tuple, for example:

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

A class in an "except" clause is compatible with an exception if it is
the same class or a base class thereof (but not the other way around
--- an except clause listing a derived class is not compatible with a
base class).  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")

Note that if the except clauses were reversed (with "except B" first),
it would have printed B, B, B --- the first matching except clause is
triggered.

The last except clause may omit the exception name(s), to serve as a
wildcard. Use this with extreme caution, since it is easy to mask a
real programming error in this way!  It can also be used to print an
error message and then re-raise the exception (allowing a caller to
handle the exception as well):

   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:
       print("Unexpected error:", sys.exc_info()[0])
       raise

The "try" ... "except" statement has an optional *else clause*, which,
when present, must follow all except clauses.  It is useful for code
that must be executed if the try clause does not raise an exception.
For example:

   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.

The except clause may specify a variable after the exception name.
The variable is bound to an exception instance with the arguments
stored in "instance.args".  For convenience, the exception instance
defines "__str__()" so the arguments can be printed directly without
having to reference ".args".  One may also instantiate an exception
first before raising it and add any attributes to it as desired.

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

Exception handlers don't just handle exceptions if they occur
immediately in the try clause, but also if they occur inside functions
that are called (even indirectly) in the try clause. For example:

   >>> 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. 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.  When creating a module that can raise
several distinct errors, a common practice is to create a base class
for exceptions defined by that module, and subclass that to create
specific exception classes for different error conditions:

   class Error(Exception):
       """Base class for exceptions in this module."""
       pass

   class InputError(Error):
       """Exception raised for errors in the input.

       Attributes:
           expression -- input expression in which the error occurred
           message -- explanation of the error
       """

       def __init__(self, expression, message):
           self.expression = expression
           self.message = message

   class TransitionError(Error):
       """Raised when an operation attempts a state transition that's not
       allowed.

       Attributes:
           previous -- state at beginning of transition
           next -- attempted new state
           message -- explanation of why the specific transition is not allowed
       """

       def __init__(self, previous, next, message):
           self.previous = previous
           self.next = next
           self.message = message

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

* "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.7. Ö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.
