# Python Documentation Turkish Translation # Copyright (C) 2001-2024, Python Software Foundation # This file is distributed under the same license as the Python package. # msgid "" msgstr "" "Project-Id-Version: Python 3.12\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2024-11-01 00:21+0000\n" "PO-Revision-Date: 2022-12-28 22:18+0300\n" "Last-Translator: \n" "Language-Team: TURKISH \n" "Language: tr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" "X-Generator: Poedit 3.2.2\n" #: tutorial/errors.rst:5 msgid "Errors and Exceptions" msgstr "Hatalar ve Özel Durumlar" #: tutorial/errors.rst:7 msgid "" "Until now error messages haven't been more than mentioned, but if you have " "tried out the examples you have probably seen some. There are (at least) " "two distinguishable kinds of errors: *syntax errors* and *exceptions*." msgstr "" "Ş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*)." #: tutorial/errors.rst:15 msgid "Syntax Errors" msgstr "Söz Dizimi Hataları" #: tutorial/errors.rst:17 msgid "" "Syntax errors, also known as parsing errors, are perhaps the most common " "kind of complaint you get while you are still learning Python::" msgstr "" "Ayrıştırma hataları olarak da bilinen söz dizimi hataları, Python öğrenirken " "belki de en sık karşılaşılan hatalardan biridir::" #: tutorial/errors.rst:20 msgid "" ">>> while True print('Hello world')\n" " File \"\", line 1\n" " while True print('Hello world')\n" " ^^^^^\n" "SyntaxError: invalid syntax" msgstr "" #: tutorial/errors.rst:26 #, fuzzy msgid "" "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 :func:`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." msgstr "" "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 :func:`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." #: tutorial/errors.rst:37 msgid "Exceptions" msgstr "Özel Durumlar" #: tutorial/errors.rst:39 msgid "" "Even if a statement or expression is syntactically correct, it may cause an " "error when an attempt is made to execute it. Errors detected during " "execution are called *exceptions* and are not unconditionally fatal: you " "will soon learn how to handle them in Python programs. Most exceptions are " "not handled by programs, however, and result in error messages as shown " "here::" msgstr "" "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::" #: tutorial/errors.rst:45 msgid "" ">>> 10 * (1/0)\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "ZeroDivisionError: division by zero\n" ">>> 4 + spam*3\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "NameError: name 'spam' is not defined\n" ">>> '2' + 2\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "TypeError: can only concatenate str (not \"int\") to str" msgstr "" #: tutorial/errors.rst:58 msgid "" "The last line of the error message indicates what happened. Exceptions come " "in different types, and the type is printed as part of the message: the " "types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:" "`TypeError`. The string printed as the exception type is the name of the " "built-in exception that occurred. This is true for all built-in exceptions, " "but need not be true for user-defined exceptions (although it is a useful " "convention). Standard exception names are built-in identifiers (not reserved " "keywords)." msgstr "" "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 :exc:`ZeroDivisionError`, :exc:`NameError` ve :" "exc:`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)." #: tutorial/errors.rst:66 msgid "" "The rest of the line provides detail based on the type of exception and what " "caused it." msgstr "" "Satırın geri kalanı, özel durum türüne ve buna neyin neden olduğuna bağlı " "olarak ayrıntı gösterir." #: tutorial/errors.rst:69 msgid "" "The preceding part of the error message shows the context where the " "exception occurred, 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." msgstr "" "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." #: tutorial/errors.rst:74 msgid "" ":ref:`bltin-exceptions` lists the built-in exceptions and their meanings." msgstr "" ":ref:`bltin-exceptions` yerleşik özel durumları ve anlamlarını listeler." #: tutorial/errors.rst:80 msgid "Handling Exceptions" msgstr "Özel Durumları İşleme" #: tutorial/errors.rst:82 msgid "" "It is possible to write programs that handle selected exceptions. Look at " "the following example, which asks the user for input until a valid integer " "has been entered, but allows the user to interrupt the program (using :kbd:" "`Control-C` or whatever the operating system supports); note that a user-" "generated interruption is signalled by raising the :exc:`KeyboardInterrupt` " "exception. ::" msgstr "" "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 (:kbd:`Control-C` veya işletim " "sistemi ne destekliyorsa onu kullanarak); kullanıcı kaynaklı kesintilerin :" "exc:`KeyboardInterrupt` özel durumu ile gösterildiğini unutmayın. ::" #: tutorial/errors.rst:88 msgid "" ">>> while True:\n" "... try:\n" "... x = int(input(\"Please enter a number: \"))\n" "... break\n" "... except ValueError:\n" "... print(\"Oops! That was no valid number. Try again...\")\n" "..." msgstr "" #: tutorial/errors.rst:96 msgid "The :keyword:`try` statement works as follows." msgstr ":keyword:`try` ifadesi aşağıdaki gibi çalışır." #: tutorial/errors.rst:98 msgid "" "First, the *try clause* (the statement(s) between the :keyword:`try` and :" "keyword:`except` keywords) is executed." msgstr "" "İlk olarak, *try yan tümcesi* (:keyword:`try` ve :keyword:`except` anahtar " "kelimeleri arasındaki ifadeler) yürütülür." #: tutorial/errors.rst:101 msgid "" "If no exception occurs, the *except clause* is skipped and execution of the :" "keyword:`try` statement is finished." msgstr "" "Özel durum oluşmazsa, *except yan tümcesi* atlanır ve :keyword:`try` " "ifadesinin yürütülmesi tamamlanır." #: tutorial/errors.rst:104 msgid "" "If an exception occurs during execution of the :keyword:`try` clause, the " "rest of the clause is skipped. Then, if its type matches the exception " "named after the :keyword:`except` keyword, the *except clause* is executed, " "and then execution continues after the try/except block." msgstr "" ":keyword:`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 :keyword:`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." #: tutorial/errors.rst:109 #, fuzzy msgid "" "If an exception occurs which does not match the exception named in the " "*except clause*, it is passed on to outer :keyword:`try` statements; if no " "handler is found, it is an *unhandled exception* and execution stops with an " "error message." msgstr "" "*except yan tümcesinde* adı geçen özel durumla eşleşmeyen bir özel durum " "oluşursa, daha dışarıda olan :keyword:`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." #: tutorial/errors.rst:113 msgid "" "A :keyword:`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 :keyword:`!try` statement. " "An *except clause* may name multiple exceptions as a parenthesized tuple, " "for example::" msgstr "" ":keyword:`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ı :keyword:`!try` ifadesinin diğer " "işleyicilerinde işlemez. *except yan tümcesi* birden çok özel durumu " "parantezli demet olarak adlandırabilir, örneğin::" #: tutorial/errors.rst:119 msgid "" "... except (RuntimeError, TypeError, NameError):\n" "... pass" msgstr "" #: tutorial/errors.rst:122 #, fuzzy msgid "" "A class in an :keyword:`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::" msgstr "" ":keyword:`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::" #: tutorial/errors.rst:127 msgid "" "class B(Exception):\n" " pass\n" "\n" "class C(B):\n" " pass\n" "\n" "class D(C):\n" " pass\n" "\n" "for cls in [B, C, D]:\n" " try:\n" " raise cls()\n" " except D:\n" " print(\"D\")\n" " except C:\n" " print(\"C\")\n" " except B:\n" " print(\"B\")" msgstr "" #: tutorial/errors.rst:146 msgid "" "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." msgstr "" "*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." #: tutorial/errors.rst:149 msgid "" "When an exception occurs, it may have associated values, also known as the " "exception's *arguments*. The presence and types of the arguments depend on " "the exception type." msgstr "" "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." #: tutorial/errors.rst:153 #, fuzzy msgid "" "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 :meth:`~object.__str__` to print all the arguments without " "explicitly accessing ``.args``. ::" msgstr "" "*except yan tümcesi*, istisna adından sonra bir değişken belirtebilir. " "Değişken, genellikle bağımsız değişkenleri depolayan bir ``args`` " "özniteliğine sahip istisna örneğine bağlıdır. Kolaylık sağlamak için, " "yerleşik istisna türleri :meth:`__str__`, ``.args`` öğesine açıkça erişmeden " "tüm argümanları yazdırmak için tanımlar. ::" #: tutorial/errors.rst:159 msgid "" ">>> try:\n" "... raise Exception('spam', 'eggs')\n" "... except Exception as inst:\n" "... print(type(inst)) # the exception type\n" "... print(inst.args) # arguments stored in .args\n" "... print(inst) # __str__ allows args to be printed directly,\n" "... # but may be overridden in exception " "subclasses\n" "... x, y = inst.args # unpack args\n" "... print('x =', x)\n" "... print('y =', y)\n" "...\n" "\n" "('spam', 'eggs')\n" "('spam', 'eggs')\n" "x = spam\n" "y = eggs" msgstr "" #: tutorial/errors.rst:176 #, fuzzy msgid "" "The exception's :meth:`~object.__str__` output is printed as the last part " "('detail') of the message for unhandled exceptions." msgstr "" "İstisnanın :meth:`__str__` çıktısı, işlenmeyen istisnalar için mesajın son " "kısmı ('ayrıntı') olarak yazdırılır." #: tutorial/errors.rst:179 msgid "" ":exc:`BaseException` is the common base class of all exceptions. One of its " "subclasses, :exc:`Exception`, is the base class of all the non-fatal " "exceptions. Exceptions which are not subclasses of :exc:`Exception` are not " "typically handled, because they are used to indicate that the program should " "terminate. They include :exc:`SystemExit` which is raised by :meth:`sys." "exit` and :exc:`KeyboardInterrupt` which is raised when a user wishes to " "interrupt the program." msgstr "" ":exc:`BaseException`, tüm istisnaların ortak temel sınıfıdır. Alt " "sınıflarından biri olan :exc:`Exception`, tüm önemli olmayan istisnaların " "temel sınıfıdır. :exc:`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 :meth:`sys.exit` tarafından oluşturulan :" "exc:`SystemExit` ve bir kullanıcı programı kesmek istediğinde ortaya çıkan :" "exc:`KeyboardInterrupt` içerir." #: tutorial/errors.rst:187 msgid "" ":exc:`Exception` can be used as a wildcard that catches (almost) everything. " "However, it is good practice to be as specific as possible with the types of " "exceptions that we intend to handle, and to allow any unexpected exceptions " "to propagate on." msgstr "" ":exc:`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." #: tutorial/errors.rst:192 msgid "" "The most common pattern for handling :exc:`Exception` is to print or log the " "exception and then re-raise it (allowing a caller to handle the exception as " "well)::" msgstr "" ":exc:`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)::" #: tutorial/errors.rst:196 msgid "" "import sys\n" "\n" "try:\n" " f = open('myfile.txt')\n" " s = f.readline()\n" " i = int(s.strip())\n" "except OSError as err:\n" " print(\"OS error:\", err)\n" "except ValueError:\n" " print(\"Could not convert data to an integer.\")\n" "except Exception as err:\n" " print(f\"Unexpected {err=}, {type(err)=}\")\n" " raise" msgstr "" #: tutorial/errors.rst:210 msgid "" "The :keyword:`try` ... :keyword:`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::" msgstr "" ":keyword:`try` ... :keyword:`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::" #: tutorial/errors.rst:215 msgid "" "for arg in sys.argv[1:]:\n" " try:\n" " f = open(arg, 'r')\n" " except OSError:\n" " print('cannot open', arg)\n" " else:\n" " print(arg, 'has', len(f.readlines()), 'lines')\n" " f.close()" msgstr "" #: tutorial/errors.rst:224 msgid "" "The use of the :keyword:`!else` clause is better than adding additional code " "to the :keyword:`try` clause because it avoids accidentally catching an " "exception that wasn't raised by the code being protected by the :keyword:`!" "try` ... :keyword:`!except` statement." msgstr "" ":keyword:`!else` yan tümcesinin kullanılması, :keyword:`try` yan tümcesine " "ek kod eklemekten daha iyidir çünkü yanlışlıkla :keyword:`!try` tarafından " "korunan kod tarafından oluşturulmamış bir istisnayı yakalamayı önler. ... :" "keyword:`!except` ifadesi." #: tutorial/errors.rst:229 msgid "" "Exception handlers do not handle only exceptions that occur immediately in " "the *try clause*, but also those that occur inside functions that are called " "(even indirectly) in the *try clause*. For example::" msgstr "" "İ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::" #: tutorial/errors.rst:233 msgid "" ">>> def this_fails():\n" "... x = 1/0\n" "...\n" ">>> try:\n" "... this_fails()\n" "... except ZeroDivisionError as err:\n" "... print('Handling run-time error:', err)\n" "...\n" "Handling run-time error: division by zero" msgstr "" #: tutorial/errors.rst:247 msgid "Raising Exceptions" msgstr "Hata Yükseltme" #: tutorial/errors.rst:249 msgid "" "The :keyword:`raise` statement allows the programmer to force a specified " "exception to occur. For example::" msgstr "" ":keyword:`raise` ifadesi, programcının belirli bir istisnanın " "gerçekleşmesini zorlamasını sağlar. Örneğin::" #: tutorial/errors.rst:252 msgid "" ">>> raise NameError('HiThere')\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "NameError: HiThere" msgstr "" #: tutorial/errors.rst:257 msgid "" "The sole argument to :keyword:`raise` indicates the exception to be raised. " "This must be either an exception instance or an exception class (a class " "that derives from :class:`BaseException`, such as :exc:`Exception` or one of " "its subclasses). If an exception class is passed, it will be implicitly " "instantiated by calling its constructor with no arguments::" msgstr "" ":keyword:`raise` için tek argüman, ortaya çıkacak istisnayı belirtir. Bu, " "bir istisna örneği veya bir istisna sınıfı (:class:`BaseException` 'dan " "türetilen bir sınıf, örneğin :exc:`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::" #: tutorial/errors.rst:263 msgid "raise ValueError # shorthand for 'raise ValueError()'" msgstr "" #: tutorial/errors.rst:265 msgid "" "If you need to determine whether an exception was raised but don't intend to " "handle it, a simpler form of the :keyword:`raise` statement allows you to re-" "raise the exception::" msgstr "" "Bir istisnanın oluşturulup oluşturulmadığını belirlemeniz gerekiyorsa ancak " "onu işlemeyi düşünmüyorsanız, :keyword:`raise` ifadesinin daha basit bir " "biçimi, istisnayı yeniden oluşturmanıza olanak tanır::" #: tutorial/errors.rst:269 msgid "" ">>> try:\n" "... raise NameError('HiThere')\n" "... except NameError:\n" "... print('An exception flew by!')\n" "... raise\n" "...\n" "An exception flew by!\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" "NameError: HiThere" msgstr "" #: tutorial/errors.rst:284 msgid "Exception Chaining" msgstr "İstisna Zincirleme" #: tutorial/errors.rst:286 msgid "" "If an unhandled exception occurs inside an :keyword:`except` section, it " "will have the exception being handled attached to it and included in the " "error message::" msgstr "" "Bir :keyword:`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::" #: tutorial/errors.rst:290 msgid "" ">>> try:\n" "... open(\"database.sqlite\")\n" "... except OSError:\n" "... raise RuntimeError(\"unable to handle error\")\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" "FileNotFoundError: [Errno 2] No such file or directory: 'database.sqlite'\n" "\n" "During handling of the above exception, another exception occurred:\n" "\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" "RuntimeError: unable to handle error" msgstr "" #: tutorial/errors.rst:305 msgid "" "To indicate that an exception is a direct consequence of another, the :" "keyword:`raise` statement allows an optional :keyword:`from` clause::" msgstr "" ":keyword:`raise` ifadesi, bir istisnanın başka bir istisnanın doğrudan " "sonucu olduğunu belirtmek için isteğe bağlı :keyword:`from` yan " "tümcesine izin verir::" #: tutorial/errors.rst:308 msgid "" "# exc must be exception instance or None.\n" "raise RuntimeError from exc" msgstr "" #: tutorial/errors.rst:311 msgid "This can be useful when you are transforming exceptions. For example::" msgstr "Bu, özel durumları dönüştürürken yararlı olabilir. Mesela::" #: tutorial/errors.rst:313 msgid "" ">>> def func():\n" "... raise ConnectionError\n" "...\n" ">>> try:\n" "... func()\n" "... except ConnectionError as exc:\n" "... raise RuntimeError('Failed to open database') from exc\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" " File \"\", line 2, in func\n" "ConnectionError\n" "\n" "The above exception was the direct cause of the following exception:\n" "\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" "RuntimeError: Failed to open database" msgstr "" #: tutorial/errors.rst:332 msgid "" "It also allows disabling automatic exception chaining using the ``from " "None`` idiom::" msgstr "" "Ayrıca, ``from None`` deyimi kullanılarak otomatik istisna zincirlemenin " "devre dışı bırakılmasına izin verir::" #: tutorial/errors.rst:335 msgid "" ">>> try:\n" "... open('database.sqlite')\n" "... except OSError:\n" "... raise RuntimeError from None\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 4, in \n" "RuntimeError" msgstr "" #: tutorial/errors.rst:344 msgid "" "For more information about chaining mechanics, see :ref:`bltin-exceptions`." msgstr "" "Zincirleme mekaniği hakkında daha fazla bilgi için bkz. :ref:`bltin-" "exceptions`." #: tutorial/errors.rst:350 msgid "User-defined Exceptions" msgstr "Kullanıcı Tanımlı İstisnalar" #: tutorial/errors.rst:352 msgid "" "Programs may name their own exceptions by creating a new exception class " "(see :ref:`tut-classes` for more about Python classes). Exceptions should " "typically be derived from the :exc:`Exception` class, either directly or " "indirectly." msgstr "" "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: :ref:" "`tut-classes` ). Özel durumlar genellikle doğrudan veya dolaylı olarak :exc:" "`Exception` sınıfından türetilmelidir." #: tutorial/errors.rst:356 msgid "" "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." msgstr "" "İ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." #: tutorial/errors.rst:360 msgid "" "Most exceptions are defined with names that end in \"Error\", similar to the " "naming of the standard exceptions." msgstr "" "Çoğu özel durum, standart özel durumların adlandırışına benzer şekilde " "\"Hata\" ile biten adlarla tanımlanır." #: tutorial/errors.rst:363 msgid "" "Many standard modules define their own exceptions to report errors that may " "occur in functions they define." msgstr "" "Birçok standart modül, tanımladıkları işlevlerde oluşabilecek hataları " "raporlamak için kendi istisnalarını tanımlar." #: tutorial/errors.rst:370 msgid "Defining Clean-up Actions" msgstr "Temizleme Eylemlerini Tanımlama" #: tutorial/errors.rst:372 msgid "" "The :keyword:`try` statement has another optional clause which is intended " "to define clean-up actions that must be executed under all circumstances. " "For example::" msgstr "" ":keyword:`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::" #: tutorial/errors.rst:376 msgid "" ">>> try:\n" "... raise KeyboardInterrupt\n" "... finally:\n" "... print('Goodbye, world!')\n" "...\n" "Goodbye, world!\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" "KeyboardInterrupt" msgstr "" #: tutorial/errors.rst:386 msgid "" "If a :keyword:`finally` clause is present, the :keyword:`!finally` clause " "will execute as the last task before the :keyword:`try` statement completes. " "The :keyword:`!finally` clause runs whether or not the :keyword:`!try` " "statement produces an exception. The following points discuss more complex " "cases when an exception occurs:" msgstr "" "Bir :keyword:`finally` yan tümcesi varsa, :keyword:`!finally` yan tümcesi :" "keyword:`try` deyimi tamamlanmadan önceki son görev olarak yürütülür. :" "keyword:`!finally` yan tümcesi :keyword:`!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:" #: tutorial/errors.rst:392 msgid "" "If an exception occurs during execution of the :keyword:`!try` clause, the " "exception may be handled by an :keyword:`except` clause. If the exception is " "not handled by an :keyword:`!except` clause, the exception is re-raised " "after the :keyword:`!finally` clause has been executed." msgstr "" ":keyword:`!try` yan tümcesinin yürütülmesi sırasında bir istisna oluşursa, " "istisna bir :keyword:`except` yan tümcesi tarafından işlenebilir. İstisna " "bir :keyword:`!except` yan tümcesi tarafından ele alınmıyorsa, istisna :" "keyword:`!finally` yan tümcesi yürütüldükten sonra yeniden oluşturulur." #: tutorial/errors.rst:398 msgid "" "An exception could occur during execution of an :keyword:`!except` or :" "keyword:`!else` clause. Again, the exception is re-raised after the :keyword:" "`!finally` clause has been executed." msgstr "" "Bir :keyword:`!except` veya :keyword:`!else` yan tümcesinin yürütülmesi " "sırasında bir istisna oluşabilir. Yine, istisna, :keyword:`!finally` yan " "tümcesi yürütüldükten sonra yeniden oluşturulur." #: tutorial/errors.rst:402 msgid "" "If the :keyword:`!finally` clause executes a :keyword:`break`, :keyword:" "`continue` or :keyword:`return` statement, exceptions are not re-raised." msgstr "" ":keyword:`!finally` yan tümcesi bir :keyword:`break`, :keyword:`continue` " "veya :keyword:`return` deyimini yürütürse, istisnalar yeniden oluşturulmaz." #: tutorial/errors.rst:406 msgid "" "If the :keyword:`!try` statement reaches a :keyword:`break`, :keyword:" "`continue` or :keyword:`return` statement, the :keyword:`!finally` clause " "will execute just prior to the :keyword:`!break`, :keyword:`!continue` or :" "keyword:`!return` statement's execution." msgstr "" ":keyword:`!try` ifadesi bir :keyword:`break`, :keyword:`continue` veya :" "keyword:`return` ifadesine ulaşırsa, :keyword:`!finally` yan tümcesi :" "keyword:`!break`, :keyword:`!continue` veya :keyword:`!return` ifadesinin " "yürütülmesinin hemen öncesinde yürütülür." #: tutorial/errors.rst:412 msgid "" "If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the " "returned value will be the one from the :keyword:`!finally` clause's :" "keyword:`!return` statement, not the value from the :keyword:`!try` " "clause's :keyword:`!return` statement." msgstr "" "Bir :keyword:`!finally` yan tümcesi bir :keyword:`!return` ifadesini " "içeriyorsa, döndürülen değer, :keyword:`!finally` yan tümcesinin :keyword:`!" "return` ifadesindeki değer olacaktır, :keyword:`!try` yan tümcesinin :" "keyword:`!return` ifadesindeki değer değil." #: tutorial/errors.rst:418 msgid "For example::" msgstr "Mesela::" #: tutorial/errors.rst:420 msgid "" ">>> def bool_return():\n" "... try:\n" "... return True\n" "... finally:\n" "... return False\n" "...\n" ">>> bool_return()\n" "False" msgstr "" #: tutorial/errors.rst:429 msgid "A more complicated example::" msgstr "Daha karmaşık bir örnek::" #: tutorial/errors.rst:431 msgid "" ">>> def divide(x, y):\n" "... try:\n" "... result = x / y\n" "... except ZeroDivisionError:\n" "... print(\"division by zero!\")\n" "... else:\n" "... print(\"result is\", result)\n" "... finally:\n" "... print(\"executing finally clause\")\n" "...\n" ">>> divide(2, 1)\n" "result is 2.0\n" "executing finally clause\n" ">>> divide(2, 0)\n" "division by zero!\n" "executing finally clause\n" ">>> divide(\"2\", \"1\")\n" "executing finally clause\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" " File \"\", line 3, in divide\n" "TypeError: unsupported operand type(s) for /: 'str' and 'str'" msgstr "" #: tutorial/errors.rst:454 msgid "" "As you can see, the :keyword:`finally` clause is executed in any event. " "The :exc:`TypeError` raised by dividing two strings is not handled by the :" "keyword:`except` clause and therefore re-raised after the :keyword:`!" "finally` clause has been executed." msgstr "" "Gördüğünüz gibi, :keyword:`finally` yan tümcesi her durumda yürütülür. İki " "dizeyi bölerek oluşturulan :exc:`TypeError`, :keyword:`except` yan tümcesi " "tarafından işlenmez ve bu nedenle :keyword:`!finally` yan tümcesi " "yürütüldikten sonra yeniden yükseltilir." #: tutorial/errors.rst:459 msgid "" "In real world applications, the :keyword:`finally` clause is useful for " "releasing external resources (such as files or network connections), " "regardless of whether the use of the resource was successful." msgstr "" "Gerçek dünyadaki uygulamalarda :keyword:`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." #: tutorial/errors.rst:467 msgid "Predefined Clean-up Actions" msgstr "Önceden Tanımlanmış Temizleme Eylemleri" #: tutorial/errors.rst:469 msgid "" "Some objects define standard clean-up actions to be undertaken when the " "object is no longer needed, regardless of whether or not the operation using " "the object succeeded or failed. Look at the following example, which tries " "to open a file and print its contents to the screen. ::" msgstr "" "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. ::" #: tutorial/errors.rst:474 msgid "" "for line in open(\"myfile.txt\"):\n" " print(line, end=\"\")" msgstr "" #: tutorial/errors.rst:477 msgid "" "The problem with this code is that it leaves the file open for an " "indeterminate amount of time after this part of the code has finished " "executing. This is not an issue in simple scripts, but can be a problem for " "larger applications. The :keyword:`with` statement allows objects like files " "to be used in a way that ensures they are always cleaned up promptly and " "correctly. ::" msgstr "" "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. :" "keyword:`with` ifadesi, dosyalar gibi nesnelerin her zaman hızlı ve doğru " "temizlenmesini sağlayacak şekilde kullanılmasına izin verir. ::" #: tutorial/errors.rst:483 msgid "" "with open(\"myfile.txt\") as f:\n" " for line in f:\n" " print(line, end=\"\")" msgstr "" #: tutorial/errors.rst:487 msgid "" "After the statement is executed, the file *f* is always closed, even if a " "problem was encountered while processing the lines. Objects which, like " "files, provide predefined clean-up actions will indicate this in their " "documentation." msgstr "" "İ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." #: tutorial/errors.rst:495 msgid "Raising and Handling Multiple Unrelated Exceptions" msgstr "Birden Fazla Alakasız İstisna Oluşturma ve İşleme" #: tutorial/errors.rst:497 msgid "" "There are situations where it is necessary to report several exceptions that " "have occurred. This is often the case in concurrency frameworks, when " "several tasks may have failed in parallel, but there are also other use " "cases where it is desirable to continue execution and collect multiple " "errors rather than raise the first exception." msgstr "" "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." #: tutorial/errors.rst:503 msgid "" "The builtin :exc:`ExceptionGroup` wraps a list of exception instances so " "that they can be raised together. It is an exception itself, so it can be " "caught like any other exception. ::" msgstr "" "Yerleşik :exc:`ExceptionGroup`, birlikte oluşturulabilmeleri için istisna " "örneklerinin bir listesini sarar. Kendisi bir istisnadır, bu nedenle " "herhangi bir istisna gibi yakalanabilir. ::" #: tutorial/errors.rst:507 msgid "" ">>> def f():\n" "... excs = [OSError('error 1'), SystemError('error 2')]\n" "... raise ExceptionGroup('there were problems', excs)\n" "...\n" ">>> f()\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 1, in \n" " | File \"\", line 3, in f\n" " | ExceptionGroup: there were problems\n" " +-+---------------- 1 ----------------\n" " | OSError: error 1\n" " +---------------- 2 ----------------\n" " | SystemError: error 2\n" " +------------------------------------\n" ">>> try:\n" "... f()\n" "... except Exception as e:\n" "... print(f'caught {type(e)}: e')\n" "...\n" "caught : e\n" ">>>" msgstr "" #: tutorial/errors.rst:529 msgid "" "By using ``except*`` instead of ``except``, we can selectively handle only " "the exceptions in the group that match a certain type. In the following " "example, which shows a nested exception group, each ``except*`` clause " "extracts from the group exceptions of a certain type while letting all other " "exceptions propagate to other clauses and eventually to be reraised. ::" msgstr "" "``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. ::" #: tutorial/errors.rst:536 msgid "" ">>> def f():\n" "... raise ExceptionGroup(\n" "... \"group1\",\n" "... [\n" "... OSError(1),\n" "... SystemError(2),\n" "... ExceptionGroup(\n" "... \"group2\",\n" "... [\n" "... OSError(3),\n" "... RecursionError(4)\n" "... ]\n" "... )\n" "... ]\n" "... )\n" "...\n" ">>> try:\n" "... f()\n" "... except* OSError as e:\n" "... print(\"There were OSErrors\")\n" "... except* SystemError as e:\n" "... print(\"There were SystemErrors\")\n" "...\n" "There were OSErrors\n" "There were SystemErrors\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 2, in \n" " | File \"\", line 2, in f\n" " | ExceptionGroup: group1\n" " +-+---------------- 1 ----------------\n" " | ExceptionGroup: group2\n" " +-+---------------- 1 ----------------\n" " | RecursionError: 4\n" " +------------------------------------\n" ">>>" msgstr "" #: tutorial/errors.rst:572 msgid "" "Note that the exceptions nested in an exception group must be instances, not " "types. This is because in practice the exceptions would typically be ones " "that have already been raised and caught by the program, along the following " "pattern::" msgstr "" "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::" #: tutorial/errors.rst:577 msgid "" ">>> excs = []\n" "... for test in tests:\n" "... try:\n" "... test.run()\n" "... except Exception as e:\n" "... excs.append(e)\n" "...\n" ">>> if excs:\n" "... raise ExceptionGroup(\"Test Failures\", excs)\n" "..." msgstr "" #: tutorial/errors.rst:592 msgid "Enriching Exceptions with Notes" msgstr "İstisnaları Notlarla Zenginleştirme" #: tutorial/errors.rst:594 msgid "" "When an exception is created in order to be raised, it is usually " "initialized with information that describes the error that has occurred. " "There are cases where it is useful to add information after the exception " "was caught. For this purpose, exceptions have a method ``add_note(note)`` " "that accepts a string and adds it to the exception's notes list. The " "standard traceback rendering includes all notes, in the order they were " "added, after the exception. ::" msgstr "" "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. ::" #: tutorial/errors.rst:601 msgid "" ">>> try:\n" "... raise TypeError('bad type')\n" "... except Exception as e:\n" "... e.add_note('Add some information')\n" "... e.add_note('Add some more information')\n" "... raise\n" "...\n" "Traceback (most recent call last):\n" " File \"\", line 2, in \n" "TypeError: bad type\n" "Add some information\n" "Add some more information\n" ">>>" msgstr "" #: tutorial/errors.rst:615 msgid "" "For example, when collecting exceptions into an exception group, we may want " "to add context information for the individual errors. In the following each " "exception in the group has a note indicating when this error has occurred. ::" msgstr "" "Ö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. ::" #: tutorial/errors.rst:619 msgid "" ">>> def f():\n" "... raise OSError('operation failed')\n" "...\n" ">>> excs = []\n" ">>> for i in range(3):\n" "... try:\n" "... f()\n" "... except Exception as e:\n" "... e.add_note(f'Happened in Iteration {i+1}')\n" "... excs.append(e)\n" "...\n" ">>> raise ExceptionGroup('We have some problems', excs)\n" " + Exception Group Traceback (most recent call last):\n" " | File \"\", line 1, in \n" " | ExceptionGroup: We have some problems (3 sub-exceptions)\n" " +-+---------------- 1 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | File \"\", line 2, in f\n" " | OSError: operation failed\n" " | Happened in Iteration 1\n" " +---------------- 2 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | File \"\", line 2, in f\n" " | OSError: operation failed\n" " | Happened in Iteration 2\n" " +---------------- 3 ----------------\n" " | Traceback (most recent call last):\n" " | File \"\", line 3, in \n" " | File \"\", line 2, in f\n" " | OSError: operation failed\n" " | Happened in Iteration 3\n" " +------------------------------------\n" ">>>" msgstr "" #~ msgid "" #~ "All exceptions inherit from :exc:`BaseException`, and so it can be used " #~ "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)::" #~ msgstr "" #~ "Tüm özel durumlar :exc:`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)::" #~ msgid "" #~ "Alternatively the last except clause may omit the exception name(s), " #~ "however the exception value must then be retrieved from ``sys.exc_info()" #~ "[1]``." #~ msgstr "" #~ "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." #~ msgid "" #~ "The :keyword:`raise` statement allows an optional :keyword:`from` " #~ "which enables chaining exceptions. For example::" #~ msgstr "" #~ ":keyword:`raise` ifadesi, zincirleme istisnalar sağlayan opsiyonel bir :" #~ "keyword:`raise` 'e izin verir. Örneğin::" #~ msgid "" #~ "Exception chaining happens automatically when an exception is raised " #~ "inside an :keyword:`except` or :keyword:`finally` section. This can be " #~ "disabled by using ``from None`` idiom:" #~ msgstr "" #~ "İstisna zincirlemesi, bir :keyword:`except` veya :keyword:`finally` " #~ "bölümünde bir istisna açıldığında otomatik olarak gerçekleşir. Bu, ``from " #~ "None`` deyimi kullanılarak devre dışı bırakılabilir:"