classes.po

# Python Documentation Turkish Translation
# Copyright (C) 2001-2023, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.11\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-09-18 19:05+0000\n"
"PO-Revision-Date: 2023-02-02 02:32+0300\n"
"Last-Translator: \n"
"Language-Team: TURKISH <python.docs.tr@gmail.com>\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/classes.rst:5
msgid "Classes"
msgstr "Sınıflar"

#: tutorial/classes.rst:7
msgid ""
"Classes provide a means of bundling data and functionality together.  "
"Creating a new class creates a new *type* of object, allowing new "
"*instances* of that type to be made.  Each class instance can have "
"attributes attached to it for maintaining its state.  Class instances can "
"also have methods (defined by its class) for modifying its state."
msgstr ""
"Sınıflar, verileri ve işlevleri bir arada tutan bir araçtır. Yeni bir sınıf "
"oluşturulurken, objeye ait yeni örnekler (instances) oluşturulur. Sınıf "
"örnekleri, durumlarını korumak için onlara iliştirilmiş niteliklere sahip "
"olabilir. Sınıfların durumunu modifiye etmek için ise metotlar "
"kullanılabilir."

#: tutorial/classes.rst:13
msgid ""
"Compared with other programming languages, Python's class mechanism adds "
"classes with a minimum of new syntax and semantics.  It is a mixture of the "
"class mechanisms found in C++ and Modula-3.  Python classes provide all the "
"standard features of Object Oriented Programming: the class inheritance "
"mechanism allows multiple base classes, a derived class can override any "
"methods of its base class or classes, and a method can call the method of a "
"base class with the same name.  Objects can contain arbitrary amounts and "
"kinds of data.  As is true for modules, classes partake of the dynamic "
"nature of Python: they are created at runtime, and can be modified further "
"after creation."
msgstr ""
"Diğer programlama dilleriyle karşılaştırıldığında, Python'un sınıf "
"mekanizması olabildiğince az yeni sözdizimi ve semantik içeren sınıflar "
"ekler.  C++ ve Modula-3'te bulunan sınıf mekanizmalarının bir karışımıdır.  "
"Python sınıfları Nesne Yönelimli Programlama'nın tüm standart özelliklerini "
"sağlar: sınıf devralma mekanizması birden çok temel sınıfa izin verir, "
"türetilmiş bir sınıf temel sınıfının veya sınıflarının herhangi bir metodunu "
"geçersiz kılabilir ve bir metot aynı ada sahip bir temel sınıfın metodunu "
"çağırabilir.  Nesneler farklı miktar ve türlerde veri içerebilir.  Modüller "
"için olduğu gibi, sınıflar da Python'un dinamik doğasına uygundur: çalışma "
"sırasında oluşturulurlar ve oluşturulduktan sonra da değiştirilebilirler."

#: tutorial/classes.rst:23
msgid ""
"In C++ terminology, normally class members (including the data members) are "
"*public* (except see below :ref:`tut-private`), and all member functions are "
"*virtual*.  As in Modula-3, there are no shorthands for referencing the "
"object's members from its methods: the method function is declared with an "
"explicit first argument representing the object, which is provided "
"implicitly by the call.  As in Smalltalk, classes themselves are objects.  "
"This provides semantics for importing and renaming.  Unlike C++ and "
"Modula-3, built-in types can be used as base classes for extension by the "
"user.  Also, like in C++, most built-in operators with special syntax "
"(arithmetic operators, subscripting etc.) can be redefined for class "
"instances."
msgstr ""
"C++ terminolojisinde, normalde sınıf üyeleri (veri üyeleri dahil) *public* "
"(aşağıdakine bakın :ref:`tut-private`) ve tüm üye fonksiyonları *virtual*' "
"dır.  Modula-3'te olduğu gibi, nesnenin üyelerine metotlarından ulaşmak için "
"bir kısayol yoktur: metodun işlevi, çağrı tarafından örtülü olarak sağlanan "
"objeyi temsil eden açık bir argümanla bildirilir.  Smalltalk'ta olduğu gibi, "
"sınıfların kendileri de birer nesnedir.  Bu sayede metotlar yeniden "
"isimlendirilebilir veya içe aktarılabilir.  C++ ve Modula-3'ün aksine, "
"yerleşik türler kullanıcının üzerlerine yapacağı geliştirmeler için temel "
"sınıflar olarak kullanılabilir.  Ayrıca, C++'ta olduğu gibi, özel "
"sözdizimine sahip çoğu yerleşik işleç (aritmetik işleçler, alt simgeleme "
"vb.) sınıf örnekleri için yeniden tanımlanabilir, geliştirilebilir."

#: tutorial/classes.rst:34
msgid ""
"(Lacking universally accepted terminology to talk about classes, I will make "
"occasional use of Smalltalk and C++ terms.  I would use Modula-3 terms, "
"since its object-oriented semantics are closer to those of Python than C++, "
"but I expect that few readers have heard of it.)"
msgstr ""
"(Sınıflara dair evrensel terimlerin yanı sıra, nadiren Smalltalk ve C++ "
"terimlerini kullanacağım. Onun yerine Modula-3 terimlerini kullanacağım "
"çünkü Python'un nesne yönelimli semantiğine C++'tan daha yakın, yine de "
"ancak çok az okuyucunun bunları duymuş olacağını tahmin ediyorum.)"

#: tutorial/classes.rst:43
msgid "A Word About Names and Objects"
msgstr "İsim ve Nesneler Hakkında Birkaç Şey"

#: tutorial/classes.rst:45
msgid ""
"Objects have individuality, and multiple names (in multiple scopes) can be "
"bound to the same object.  This is known as aliasing in other languages.  "
"This is usually not appreciated on a first glance at Python, and can be "
"safely ignored when dealing with immutable basic types (numbers, strings, "
"tuples).  However, aliasing has a possibly surprising effect on the "
"semantics of Python code involving mutable objects such as lists, "
"dictionaries, and most other types. This is usually used to the benefit of "
"the program, since aliases behave like pointers in some respects.  For "
"example, passing an object is cheap since only a pointer is passed by the "
"implementation; and if a function modifies an object passed as an argument, "
"the caller will see the change --- this eliminates the need for two "
"different argument passing mechanisms as in Pascal."
msgstr ""
"Nesnelerin bireyselliği vardır ve birden çok ad (birden çok kapsamda) aynı "
"nesneye bağlanabilir.  Bu, diğer dillerde örtüşme (aliasing) olarak "
"bilinir.  Bu genellikle Python'a ilk bakışta takdir edilmeyen bir özellik "
"olsa da değiştirilemeyen veri türleriyle (sayılar, dizeler, diziler) "
"uğraşırken rahatlıkla göz ardı edilebilir.  Ancak, örtüşmeler, listeler, "
"sözlükler ve diğer türlerin çoğu gibi değişebilir nesneleri içeren Python "
"kodunun semantiği üzerinde şaşırtıcı bir etkiye sahiptir. Diğer adlar bazı "
"açılardan işaretçiler (pointers) gibi davrandığından, bu genellikle "
"programın yararına kullanılır.  Örneğin, bir nesneyi geçirmek kolaydır çünkü "
"uygulama tarafından geçirilen şey yalnızca bir işaretçidir; bir fonksiyon "
"argüman olarak geçirilen bir nesneyi değiştirirse, çağıran bu değişikliği "
"görür --- bu Pascal'daki iki farklı bağımsız değişken geçirme mekanizmasına "
"olan gereksinimi ortadan kaldırır."

#: tutorial/classes.rst:61
msgid "Python Scopes and Namespaces"
msgstr "Python Etki Alanları ve Ad Alanları"

#: tutorial/classes.rst:63
msgid ""
"Before introducing classes, I first have to tell you something about "
"Python's scope rules.  Class definitions play some neat tricks with "
"namespaces, and you need to know how scopes and namespaces work to fully "
"understand what's going on. Incidentally, knowledge about this subject is "
"useful for any advanced Python programmer."
msgstr ""
"Sınıflara başlamadan önce, size Python'un etki alanı kuralları hakkında bir "
"şey söylemeliyim.  Sınıf tanımlarında ad alanlarının kullanımının bazı püf "
"noktaları vardır ve neler olduğunu tam olarak anlamak için etki alanlarının "
"ve isimlerin nasıl çalıştığını bilmeniz gerekir. Bu arada, bu konuda bilgi "
"edinmek herhangi bir ileri düzey Python programcısı için yararlıdır."

#: tutorial/classes.rst:69
msgid "Let's begin with some definitions."
msgstr "Haydi birkaç tanımlama ile başlayalım."

#: tutorial/classes.rst:71
msgid ""
"A *namespace* is a mapping from names to objects.  Most namespaces are "
"currently implemented as Python dictionaries, but that's normally not "
"noticeable in any way (except for performance), and it may change in the "
"future.  Examples of namespaces are: the set of built-in names (containing "
"functions such as :func:`abs`, and built-in exception names); the global "
"names in a module; and the local names in a function invocation.  In a sense "
"the set of attributes of an object also form a namespace.  The important "
"thing to know about namespaces is that there is absolutely no relation "
"between names in different namespaces; for instance, two different modules "
"may both define a function ``maximize`` without confusion --- users of the "
"modules must prefix it with the module name."
msgstr ""
"*Ad alanları* (namespace), adlardan nesnelere eşlemedir.  Çoğu isim şu anda "
"Python sözlükleri olarak uygulanmaktadır, ancak bu fark edilir çapta bir "
"fark yaratmaz (performans hariç) ve gelecekte değişebilir.  Ad alanlarına "
"örnek olarak şunlar verilebilir: yerleşik isimler (:func:`abs` ve yerleşik "
"özel durum adları gibi fonksiyonları içerir); modüldeki global adlar; ve bir "
"fonksiyon çağırmadaki yerel adlar.  Bir bakıma, bir nesnenin nitelik kümesi "
"de bir ad alanı oluşturur.  İsimler hakkında bilinmesi gereken önemli şey, "
"farklı ad alanlarındaki adlar arasında kesinlikle bir ilişki olmamasıdır; "
"örneğin, iki farklı modülün her ikisi de karışıklık olmadan ``maximize`` "
"fonksiyonunu tanımlayabilir --- modül kullanıcılarının modül adını "
"örneklemesi gerekir."

#: tutorial/classes.rst:82
msgid ""
"By the way, I use the word *attribute* for any name following a dot --- for "
"example, in the expression ``z.real``, ``real`` is an attribute of the "
"object ``z``.  Strictly speaking, references to names in modules are "
"attribute references: in the expression ``modname.funcname``, ``modname`` is "
"a module object and ``funcname`` is an attribute of it.  In this case there "
"happens to be a straightforward mapping between the module's attributes and "
"the global names defined in the module: they share the same namespace!  [#]_"
msgstr ""
"Bu arada, *nitelik* sözcüğünü bir noktayı takip eden herhangi bir isim için "
"kullanıyorum. Mesela,  ``z.real`` ifadesinde ``real``, ``z`` nesnesine ait "
"bir niteliktir. Açıkçası, modüllerde isimlere yapılan referanslar nitelik "
"referanslarıdır: ``modname.funcname`` ifadesinde ``modname`` bir modül "
"nesnesi ve ``funcname`` onun bir niteliğidir. Bu durumda, modülün "
"nitelikleri ve modüldeki global değişkenler arasında bir eşleşme olur: aynı "
"ad alanını paylaşmaları! [#]_"

#: tutorial/classes.rst:90
#, fuzzy
msgid ""
"Attributes may be read-only or writable.  In the latter case, assignment to "
"attributes is possible.  Module attributes are writable: you can write "
"``modname.the_answer = 42``.  Writable attributes may also be deleted with "
"the :keyword:`del` statement.  For example, ``del modname.the_answer`` will "
"remove the attribute :attr:`!the_answer` from the object named by "
"``modname``."
msgstr ""
"Nitelikler salt okunur veya düzenlenebilir olabilir.  İkinci durumda, "
"niteliklere atama yapmak mümkündür.  Modül nitelikleri düzenlenebilir: "
"``modname.the_answer = 42`` yazabilirsiniz.  Düzenlenebilir nitelikler :"
"keyword:`del` ifadesiyle de silinebilir.  Örneğin, ``del modname."
"the_answer`` ifadesi :attr:`the_answer` niteliğini ``modname`` tarafından "
"adlandırılan nesneden kaldırır."

#: tutorial/classes.rst:96
msgid ""
"Namespaces are created at different moments and have different lifetimes.  "
"The namespace containing the built-in names is created when the Python "
"interpreter starts up, and is never deleted.  The global namespace for a "
"module is created when the module definition is read in; normally, module "
"namespaces also last until the interpreter quits.  The statements executed "
"by the top-level invocation of the interpreter, either read from a script "
"file or interactively, are considered part of a module called :mod:"
"`__main__`, so they have their own global namespace.  (The built-in names "
"actually also live in a module; this is called :mod:`builtins`.)"
msgstr ""
"Ad alanları farklı anlarda oluşturulur ve farklı yaşam sürelerine sahiptir.  "
"Yerleşik adları içeren ad alanı, Python yorumlayıcısı başlatıldığında "
"oluşturulur ve hiçbir zaman silinmez.  Modül tanımı okunduğunda modül için "
"genel ad alanı oluşturulur; normalde, modül ad alanları da yorumlayıcı çıkıp "
"bitene kadar sürer.  Bir komut dosyasından veya etkileşimli olarak okunan "
"yorumlayıcının en üst düzey çağrısı tarafından yürütülen ifadeler :mod:"
"`__main__` adlı bir modülün parçası olarak kabul edilir, bu nedenle kendi "
"genel ad alanlarına sahiptirler.  (Yerleşik isimler aslında bir modülde de "
"yaşar; buna :mod:`builtins`.)"

#: tutorial/classes.rst:106
msgid ""
"The local namespace for a function is created when the function is called, "
"and deleted when the function returns or raises an exception that is not "
"handled within the function.  (Actually, forgetting would be a better way to "
"describe what actually happens.)  Of course, recursive invocations each have "
"their own local namespace."
msgstr ""
"Bir işlevin yerel ad alanı, bir fonksiyon çağrıldığında oluşturulur ve "
"fonksiyon başa çıkamadığı bir hata veya istisna ile karşılaştığında "
"silinir.  (Aslında, bir bakıma ad alanı unutulmaktadır diyebiliriz.)  Tabii "
"ki, özyinelemeli çağrıların her birinin kendi yerel ad alanı vardır."

#: tutorial/classes.rst:112
msgid ""
"A *scope* is a textual region of a Python program where a namespace is "
"directly accessible.  \"Directly accessible\" here means that an unqualified "
"reference to a name attempts to find the name in the namespace."
msgstr ""
"*scope*, bir ad alanının doğrudan erişilebilir olduğu Python programının "
"metinsel bölgesidir.  Burada \"Doğrudan erişilebilir\", niteliksiz bir "
"başvurunun hedeflediği ismi ad alanında bulmaya çalıştığı anlamına gelir."

#: tutorial/classes.rst:116
msgid ""
"Although scopes are determined statically, they are used dynamically. At any "
"time during execution, there are 3 or 4 nested scopes whose namespaces are "
"directly accessible:"
msgstr ""
"Kapsamlar statik olarak belirlense de, dinamik olarak kullanılırlar. Yürütme "
"sırasında herhangi bir zamanda, ad alanlarına doğrudan erişilebilen 3 veya 4 "
"iç içe kapsam vardır:"

#: tutorial/classes.rst:120
msgid "the innermost scope, which is searched first, contains the local names"
msgstr ""
"en içte bulunan kapsam, ilk aranan olmakla birlikte yerel isimleri içerir"

#: tutorial/classes.rst:121
msgid ""
"the scopes of any enclosing functions, which are searched starting with the "
"nearest enclosing scope, contain non-local, but also non-global names"
msgstr ""
"en yakın kapsayan kapsamdan başlayarak aranan kapsayan fonksiyonların "
"kapsamları yerel olmayan, aynı zamanda genel olmayan adlar içerir"

#: tutorial/classes.rst:123
msgid "the next-to-last scope contains the current module's global names"
msgstr "sondan bir önceki kapsam, geçerli modülün genel adlarını içerir"

#: tutorial/classes.rst:124
msgid ""
"the outermost scope (searched last) is the namespace containing built-in "
"names"
msgstr "en dıştaki kapsam (en son aranan), yerleşik adlar içeren ad alanıdır"

#: tutorial/classes.rst:126
msgid ""
"If a name is declared global, then all references and assignments go "
"directly to the next-to-last scope containing the module's global names.  To "
"rebind variables found outside of the innermost scope, the :keyword:"
"`nonlocal` statement can be used; if not declared nonlocal, those variables "
"are read-only (an attempt to write to such a variable will simply create a "
"*new* local variable in the innermost scope, leaving the identically named "
"outer variable unchanged)."
msgstr ""
"Bir ad global olarak bildirilirse, tüm başvurular ve atamalar doğrudan "
"modülün genel adlarını içeren orta kapsama gider.  En iç kapsamın dışında "
"bulunan değişkenleri yeniden bağlamak için :keyword:`nonlocal` ifadesi "
"kullanılabilir; yerel olarak bildirilmezse de, bu değişkenler salt okunurdur "
"(böyle bir değişken düzenlenirse, aynı adlı dış değişkeni değiştirmeden en "
"iç kapsamda *yeni* bir yerel değişken oluşturur)."

#: tutorial/classes.rst:133
msgid ""
"Usually, the local scope references the local names of the (textually) "
"current function.  Outside functions, the local scope references the same "
"namespace as the global scope: the module's namespace. Class definitions "
"place yet another namespace in the local scope."
msgstr ""
"Genellikle, yerel kapsam (metinsel olarak) geçerli fonksiyonun yerel "
"adlarına başvurur.  Dış fonksiyonlarda, yerel kapsam genel kapsamla aynı ad "
"alanına başvurur: modülün ad alanı. Sınıf tanımları yerel kapsamda başka bir "
"ad alanı yerleştirir."

#: tutorial/classes.rst:138
msgid ""
"It is important to realize that scopes are determined textually: the global "
"scope of a function defined in a module is that module's namespace, no "
"matter from where or by what alias the function is called.  On the other "
"hand, the actual search for names is done dynamically, at run time --- "
"however, the language definition is evolving towards static name resolution, "
"at \"compile\" time, so don't rely on dynamic name resolution!  (In fact, "
"local variables are already determined statically.)"
msgstr ""
"Kapsamların metinsel olarak belirlendiğini fark etmek önemlidir: bir modülde "
"tanımlanan bir işlevin genel kapsamı, işlevin nereden veya hangi diğer adla "
"adlandırıldığından bağımsız olarak modülün ad alanıdır.  Öte yandan, gerçek "
"ad araması dinamik olarak yapılır, çalışma zamanında --- ancak, dil tanımı "
"statik ad çözümlemelerine doğru, \"derleme\" zamanında gelişir, bu nedenle "
"dinamik ad çözümlemesini güvenmeyin!  (Aslında, yerel değişkenler zaten "
"statik olarak belirlenir.)"

#: tutorial/classes.rst:146
msgid ""
"A special quirk of Python is that -- if no :keyword:`global` or :keyword:"
"`nonlocal` statement is in effect -- assignments to names always go into the "
"innermost scope. Assignments do not copy data --- they just bind names to "
"objects.  The same is true for deletions: the statement ``del x`` removes "
"the binding of ``x`` from the namespace referenced by the local scope.  In "
"fact, all operations that introduce new names use the local scope: in "
"particular, :keyword:`import` statements and function definitions bind the "
"module or function name in the local scope."
msgstr ""
"Python'un özel bir cilvesi, eğer :keyword:`global` veya :keyword:`nonlocal` "
"deyimi geçerli değilse -- isimlere yapılan atamaların her zaman en içteki "
"kapsama girmesidir. Atamalar verileri kopyalamaz --- adları nesnelere "
"bağlarlar.  Aynı şey silme için de geçerlidir: ``del x`` deyimi, ``x`` "
"bağlamasını yerel kapsam tarafından başvurulan ad alanından kaldırır.  "
"Aslında, yeni adlar tanıtan tüm işlemler yerel kapsamı kullanır: özellikle, :"
"keyword:`import` ifadeleri ve işlev tanımları modül veya işlev adını yerel "
"kapsamda bağlar."

#: tutorial/classes.rst:154
msgid ""
"The :keyword:`global` statement can be used to indicate that particular "
"variables live in the global scope and should be rebound there; the :keyword:"
"`nonlocal` statement indicates that particular variables live in an "
"enclosing scope and should be rebound there."
msgstr ""
":keyword:`global` deyimi, belirli değişkenlerin genel kapsamda yaşadığını ve "
"orada geri alınması gerektiğini belirtmek için kullanılabilir; :keyword:"
"`nonlocal` deyimi, belirli değişkenlerin bir çevreleme kapsamında yaşadığını "
"ve orada geri alınması gerektiğini gösterir."

#: tutorial/classes.rst:162
msgid "Scopes and Namespaces Example"
msgstr "Kapsamlar ve Ad Alanları Örneği"

#: tutorial/classes.rst:164
msgid ""
"This is an example demonstrating how to reference the different scopes and "
"namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect "
"variable binding::"
msgstr ""
"Bu, farklı kapsamlara ve ad alanlarına başvurmayı ve :keyword:`global` ve :"
"keyword:`nonlocal` değişken bağlamasını nasıl etkileyeceğini gösteren bir "
"örnektir::"

#: tutorial/classes.rst:191
msgid "The output of the example code is:"
msgstr "Örnek kodun çıktısı şudur:"

#: tutorial/classes.rst:200
msgid ""
"Note how the *local* assignment (which is default) didn't change "
"*scope_test*\\'s binding of *spam*.  The :keyword:`nonlocal` assignment "
"changed *scope_test*\\'s binding of *spam*, and the :keyword:`global` "
"assignment changed the module-level binding."
msgstr ""
"Varsayılan atama olan *local* atamasının *scope_test*\\'in *spam* "
"bağlamasını nasıl değiştirmediğini unutmayın.  :keyword:`nonlocal` ataması "
"*scope_test*\\'in *spam* bağlamasını değiştirdi, hatta :keyword:`global` "
"ataması modül düzeyindeki bağlamasını değiştirdi."

#: tutorial/classes.rst:205
msgid ""
"You can also see that there was no previous binding for *spam* before the :"
"keyword:`global` assignment."
msgstr ""
"Ayrıca :keyword:`global` atamasından önce *spam* için herhangi bir bağlama "
"olmadığını görebilirsiniz."

#: tutorial/classes.rst:212
msgid "A First Look at Classes"
msgstr "Sınıflara İlk Bakış"

#: tutorial/classes.rst:214
msgid ""
"Classes introduce a little bit of new syntax, three new object types, and "
"some new semantics."
msgstr ""
"Sınıflar biraz yeni söz dizimi, üç yeni nesne türü ve bazı yeni semantiklere "
"sahiptir."

#: tutorial/classes.rst:221
msgid "Class Definition Syntax"
msgstr "Sınıf Tanımlama Söz Dizimi"

#: tutorial/classes.rst:223
msgid "The simplest form of class definition looks like this::"
msgstr "Sınıf tanımlamasının en basit biçimi şöyledir:"

#: tutorial/classes.rst:232
msgid ""
"Class definitions, like function definitions (:keyword:`def` statements) "
"must be executed before they have any effect.  (You could conceivably place "
"a class definition in a branch of an :keyword:`if` statement, or inside a "
"function.)"
msgstr ""
"Sınıf tanımlamaları, fonksiyon tanımlamaları (:keyword:`def` deyimleri) ile "
"aynı şekilde, herhangi bir etkiye sahip olmadan önce yürütülmelidir.  (Bir "
"sınıf tanımını :keyword:`if` ifadesinin bir dalına veya bir fonksiyonun "
"içine yerleştirebilirsiniz.)"

#: tutorial/classes.rst:236
msgid ""
"In practice, the statements inside a class definition will usually be "
"function definitions, but other statements are allowed, and sometimes useful "
"--- we'll come back to this later.  The function definitions inside a class "
"normally have a peculiar form of argument list, dictated by the calling "
"conventions for methods --- again, this is explained later."
msgstr ""
"Uygulamada, bir sınıf tanımı içindeki ifadeler genellikle fonksiyon "
"tanımlamaları olacaktır, ancak diğer ifadelere de izin verilir ve daha sonra "
"bahsedeceğimiz üzere bazen yararlılardır. Bir sınıfın içindeki fonksiyon "
"tanımları normalde, yöntemler için çağırma kuralları tarafından dikte edilen "
"tuhaf bir bağımsız değişken listesi biçimine sahiptir --- bu daha sonra "
"açıklanacak."

#: tutorial/classes.rst:242
msgid ""
"When a class definition is entered, a new namespace is created, and used as "
"the local scope --- thus, all assignments to local variables go into this "
"new namespace.  In particular, function definitions bind the name of the new "
"function here."
msgstr ""
"Sınıf tanımı girildiğinde, yeni bir ad alanı oluşturulur ve yerel kapsam "
"olarak kullanılır --- böylece yerel değişkenlere yapılan tüm atamalar bu "
"yeni ad alanına gider.  Özellikle, fonksiyon tanımlamaları yeni "
"fonksiyonların adını buraya bağlar."

#: tutorial/classes.rst:247
#, fuzzy
msgid ""
"When a class definition is left normally (via the end), a *class object* is "
"created.  This is basically a wrapper around the contents of the namespace "
"created by the class definition; we'll learn more about class objects in the "
"next section.  The original local scope (the one in effect just before the "
"class definition was entered) is reinstated, and the class object is bound "
"here to the class name given in the class definition header (:class:`!"
"ClassName` in the example)."
msgstr ""
"Bir sınıf tanımı normal olarak bırakıldığında (uç aracılığıyla), bir *sınıf "
"nesnesi* oluşturulur.  Bu temelde sınıf tanımı tarafından oluşturulan ad "
"alanının içerikleri için bir aracıdır, sınıf nesneleri hakkında daha fazla "
"bilgiyi ise sonraki bölümde öğreneceğiz.  Orijinal yerel kapsam (sınıf "
"tanımı girilmeden hemen önce geçerli olan) yeniden etkinleştirilir ve sınıf "
"nesnesi burada sınıf tanımı üstbilgisinde verilen sınıf adına bağlı olur "
"(örnekte :class:`ClassName`)."

#: tutorial/classes.rst:259
msgid "Class Objects"
msgstr "Sınıf Nesneleri"

#: tutorial/classes.rst:261
msgid ""
"Class objects support two kinds of operations: attribute references and "
"instantiation."
msgstr ""
"Sınıf nesneleri iki tür işlemi destekler: nitelik referansları ve örnekleme."

#: tutorial/classes.rst:264
msgid ""
"*Attribute references* use the standard syntax used for all attribute "
"references in Python: ``obj.name``.  Valid attribute names are all the names "
"that were in the class's namespace when the class object was created.  So, "
"if the class definition looked like this::"
msgstr ""
"*Nitelik referansları*, Python'daki tüm nitelik referansları için kullanılan "
"standart söz dizimi olan ``obj.name`` kullanır.  Geçerli nitelik adları, "
"sınıf nesnesi oluşturulduğunda sınıfın ad alanında bulunan tüm adlardır.  "
"Yani, sınıf tanımı şöyle görünüyorsa::"

#: tutorial/classes.rst:276
#, fuzzy
msgid ""
"then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, "
"returning an integer and a function object, respectively. Class attributes "
"can also be assigned to, so you can change the value of ``MyClass.i`` by "
"assignment. :attr:`!__doc__` is also a valid attribute, returning the "
"docstring belonging to the class: ``\"A simple example class\"``."
msgstr ""
"bu durumda ``MyClass.i`` ve ``MyClass.f`` geçerli nitelik referanslarıdır ve "
"sırasıyla bir tamsayı ve fonksiyon nesnesi döndürür. Sınıf nitelikleri de "
"atanabilir, böylece atamayla ``MyClass.i`` değerini değiştirebilirsiniz. "
"Aynı zamanda :attr:`__doc__`, geçerli bir nitelik olarak sınıfa ait "
"docstring döndürür: ``\"Basit bir örnek sınıf\"``."

#: tutorial/classes.rst:282
msgid ""
"Class *instantiation* uses function notation.  Just pretend that the class "
"object is a parameterless function that returns a new instance of the class. "
"For example (assuming the above class)::"
msgstr ""
"Sınıf *örnekleme* fonksiyon notasyonunu kullanır.  Sınıf nesnesinin, sınıfın "
"yeni bir örneğini döndüren parametresiz bir fonksiyon olduğunu varsayın. "
"Örneğin (yukarıdaki sınıfı varsayarsak)::"

#: tutorial/classes.rst:288
msgid ""
"creates a new *instance* of the class and assigns this object to the local "
"variable ``x``."
msgstr ""
"sınıfın yeni bir *örnek* öğesini oluşturur ve bu nesneyi ``x`` yerel "
"değişkenine atar."

#: tutorial/classes.rst:291
#, fuzzy
msgid ""
"The instantiation operation (\"calling\" a class object) creates an empty "
"object. Many classes like to create objects with instances customized to a "
"specific initial state. Therefore a class may define a special method named :"
"meth:`~object.__init__`, like this::"
msgstr ""
"Örnekleme işlemi (\"sınıf nesnesi çağırma\") boş bir nesne oluşturur. Birçok "
"sınıf, belirli bir başlangıç durumuna göre özelleştirilmiş örneklerle "
"nesneler oluşturmayı sever. Bu nedenle bir sınıf, :meth:`__init__` adlı özel "
"bir metot tanımlayabilir:"

#: tutorial/classes.rst:299
#, fuzzy
msgid ""
"When a class defines an :meth:`~object.__init__` method, class instantiation "
"automatically invokes :meth:`!__init__` for the newly created class "
"instance.  So in this example, a new, initialized instance can be obtained "
"by::"
msgstr ""
"Bir sınıf bir :meth:`__init__` metodunu tanımladığında, örnekleme işlemi "
"yeni oluşturulan sınıf örneği için otomatik olarak :meth:`__init__` öğesini "
"çağırır.  Bu örnekte, yeni başlatılmış bir örnek şu şekilde elde edilebilir::"

#: tutorial/classes.rst:305
#, fuzzy
msgid ""
"Of course, the :meth:`~object.__init__` method may have arguments for "
"greater flexibility.  In that case, arguments given to the class "
"instantiation operator are passed on to :meth:`!__init__`.  For example, ::"
msgstr ""
"Tabii ki, :meth:`__init__` yöntemi daha fazla esneklik için argümanlara "
"sahip olabilir.  Bu durumda, sınıf örnekleme işlecine verilen bağımsız "
"değişkenler :meth:`__init__` için aktarılır.  Mesela::"

#: tutorial/classes.rst:322
msgid "Instance Objects"
msgstr "Örnek Nesneleri"

#: tutorial/classes.rst:324
msgid ""
"Now what can we do with instance objects?  The only operations understood by "
"instance objects are attribute references.  There are two kinds of valid "
"attribute names: data attributes and methods."
msgstr ""
"Şimdi örnek nesnelerle ne yapabiliriz?  Örnek nesneleri tarafından anlaşılan "
"tek işlemler nitelik başvurularıdır.  İki tür geçerli öznitelik adı vardır: "
"veri nitelikleri ve metotları."

#: tutorial/classes.rst:328
#, fuzzy
msgid ""
"*data attributes* correspond to \"instance variables\" in Smalltalk, and to "
"\"data members\" in C++.  Data attributes need not be declared; like local "
"variables, they spring into existence when they are first assigned to.  For "
"example, if ``x`` is the instance of :class:`!MyClass` created above, the "
"following piece of code will print the value ``16``, without leaving a "
"trace::"
msgstr ""
"*veri nitelikleri*, Smalltalk'taki \"örnek değişkenlerine\" ve C++'taki "
"\"veri üyelerine\" karşılık gelir.  Veri niteliklerinin önceden tanımlanması "
"gerekmez; yerel değişkenler gibi, ilk değer atandığı anda varlıkları "
"başlar.  Örneğin, ``x`` yukarıda oluşturulan :class:`MyClass` örneğiyse, "
"aşağıdaki kod parçası iz bırakmadan ``16`` değerini yazdırır::"

#: tutorial/classes.rst:340
msgid ""
"The other kind of instance attribute reference is a *method*. A method is a "
"function that \"belongs to\" an object.  (In Python, the term method is not "
"unique to class instances: other object types can have methods as well.  For "
"example, list objects have methods called append, insert, remove, sort, and "
"so on. However, in the following discussion, we'll use the term method "
"exclusively to mean methods of class instance objects, unless explicitly "
"stated otherwise.)"
msgstr ""
"Diğer örnek nitelik başvurusu türü bir *metot*. Metot, bir nesneye \"ait\" "
"olan bir fonksiyondur.  (Python'da, terim metodu sınıf örneklerine özgü "
"değildir: diğer nesne türlerinin de metotları olabilir.  Örneğin, liste "
"nesnelerini genişletme, ekleme, kaldırma, sıralama vb. Ancak, aşağıdaki "
"tartışmada, aksi açıkça belirtilmedikçe, yalnızca sınıf örneği nesnelerinin "
"metotlarını ifade etmek için terim metodunu kullanacağız.)"

#: tutorial/classes.rst:349
msgid ""
"Valid method names of an instance object depend on its class.  By "
"definition, all attributes of a class that are function  objects define "
"corresponding methods of its instances.  So in our example, ``x.f`` is a "
"valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is "
"not, since ``MyClass.i`` is not.  But ``x.f`` is not the same thing as "
"``MyClass.f`` --- it is a *method object*, not a function object."
msgstr ""
"Örnek nesnesinin geçerli metot adları nesnenin sınıfına bağlıdır.  Fonksiyon "
"nesneleri olan bir sınıfın tüm nitelikleri, örneklerinin karşılık gelen "
"fonksiyonlarını tanımlar.  Bu nedenle, örneğimizde, ``x.f`` geçerli bir "
"metot referansıdır, ne de olsa ``MyClass.f`` bir fonksiyondur ancak "
"``MyClass.i`` fonksiyon olmadığından ``x.i`` değildir.  Ancak ``x.f``, "
"``MyClass.f`` ile aynı şey değildir çünkü bir fonksiyon nesnesi değil, "
"*metot nesnesi* 'dir."

#: tutorial/classes.rst:360
msgid "Method Objects"
msgstr "Metot Nesneleri"

#: tutorial/classes.rst:362
msgid "Usually, a method is called right after it is bound::"
msgstr "Genellikle, bir metot bağlandıktan hemen sonra çağrılır::"

#: tutorial/classes.rst:366
#, fuzzy
msgid ""
"In the :class:`!MyClass` example, this will return the string ``'hello "
"world'``. However, it is not necessary to call a method right away: ``x.f`` "
"is a method object, and can be stored away and called at a later time.  For "
"example::"
msgstr ""
":class:`MyClass` örneğinde, ``hello world`` string'ini döndürür. Lakin, "
"hemen bir metot çağırmak gerekli değildir: ``x.f`` bir metot nesnesidir, "
"yani daha sonra depolanabilir ve çağrılabilir.  Mesela::"

#: tutorial/classes.rst:374
msgid "will continue to print ``hello world`` until the end of time."
msgstr "daima ``hello world`` yazdırmaya devam edecek."

#: tutorial/classes.rst:376
#, fuzzy
msgid ""
"What exactly happens when a method is called?  You may have noticed that ``x."
"f()`` was called without an argument above, even though the function "
"definition for :meth:`!f` specified an argument.  What happened to the "
"argument? Surely Python raises an exception when a function that requires an "
"argument is called without any --- even if the argument isn't actually "
"used..."
msgstr ""
"Bir yöntem çağrıldığında tam olarak ne gerçekleşir?  :meth:`f` fonksiyon "
"tanımı bir argüman belirtmiş olsa da, ``x.f()`` öğesinin yukarıda bir "
"argüman olmadan çağrıldığını fark etmiş olabilirsiniz.  Peki argümana ne "
"oldu? Elbette Python, argüman gerektiren bir fonksiyon, argüman verilmemiş "
"iken çağırılırsa --- fonksiyon aslında kullanılmasa bile hata verir..."

#: tutorial/classes.rst:382
msgid ""
"Actually, you may have guessed the answer: the special thing about methods "
"is that the instance object is passed as the first argument of the "
"function.  In our example, the call ``x.f()`` is exactly equivalent to "
"``MyClass.f(x)``.  In general, calling a method with a list of *n* arguments "
"is equivalent to calling the corresponding function with an argument list "
"that is created by inserting the method's instance object before the first "
"argument."
msgstr ""
"Aslında, cevabı tahmin etmiş olabilirsiniz: yöntemlerle ilgili özel şey, "
"örnek nesnesinin fonksiyonun ilk argüman olarak geçirilmesidir.  "
"Örneğimizde, ``x.f()`` çağrısı tam olarak ``MyClass.f(x)`` ile eş değerdir.  "
"Genel olarak, *n* tane argümana sahip bir metodu çağırmak, ilk argümandan "
"önce metodun örnek nesnesi eklenerek oluşturulan bir argüman listesiyle "
"karşılık gelen fonksiyonu çağırmaya eş değerdir."

#: tutorial/classes.rst:389
msgid ""
"If you still don't understand how methods work, a look at the implementation "
"can perhaps clarify matters.  When a non-data attribute of an instance is "
"referenced, the instance's class is searched.  If the name denotes a valid "
"class attribute that is a function object, a method object is created by "
"packing (pointers to) the instance object and the function object just found "
"together in an abstract object: this is the method object.  When the method "
"object is called with an argument list, a new argument list is constructed "
"from the instance object and the argument list, and the function object is "
"called with this new argument list."
msgstr ""
"Metotların nasıl çalıştığını hala anlamıyorsanız, nasıl uygulandığına bakmak "
"belki de sorunları açıklığa kavuşturabilir.  Bir örneğin, veri olmayan bir "
"niteliğine başvurulduğu zaman bu örneğin ait olduğu sınıfa bakılır.  Ad bir "
"fonksiyon nesnesi olan geçerli bir sınıf özniteliğini gösterirse, örnek "
"nesne ve fonksiyon nesnesi soyut bir nesnede paketlenerek (işaretçiler) bir "
"metot nesnesi oluşturulur. İşte bu metot nesnesidir.  Metot nesnesi bir "
"argüman listesiyle çağrıldığında, örnek nesneden ve argüman listesinden yeni "
"bir argüman listesi oluşturulur ve fonksiyon nesnesi bu yeni argüman "
"listesiyle çağrılır."

#: tutorial/classes.rst:403
msgid "Class and Instance Variables"
msgstr "Sınıf ve Örnek Değişkenleri"

#: tutorial/classes.rst:405
msgid ""
"Generally speaking, instance variables are for data unique to each instance "
"and class variables are for attributes and methods shared by all instances "
"of the class::"
msgstr ""
"Genel olarak, örnek değişkenleri o örneğe özgü veriler içindir ve sınıf "
"değişkenleri sınıfın tüm örnekleri tarafından paylaşılan nitelikler ile "
"metotlar içindir::"

#: tutorial/classes.rst:427
msgid ""
"As discussed in :ref:`tut-object`, shared data can have possibly surprising "
"effects with involving :term:`mutable` objects such as lists and "
"dictionaries. For example, the *tricks* list in the following code should "
"not be used as a class variable because just a single list would be shared "
"by all *Dog* instances::"
msgstr ""
":ref:`tut-object` 'te anlatıldığı gibi, paylaşılan veriler listeler ve "
"sözlükler gibi :term:`mutable` nesnelerini içeren şaşırtıcı etkilere sahip "
"olabilir. Örneğin, aşağıdaki koddaki *tricks* listesi sınıf değişkeni olarak "
"kullanılmamalıdır, çünkü yalnızca tek bir liste tüm *Dog* örnekleri "
"tarafından paylaşılacaktır::"

#: tutorial/classes.rst:450
msgid "Correct design of the class should use an instance variable instead::"
msgstr ""
"Doğru olan ise veriyi paylaşmak yerine bir örnek değişkeni kullanmaktır:"

#: tutorial/classes.rst:474
msgid "Random Remarks"
msgstr "Rastgele Açıklamalar"

#: tutorial/classes.rst:478
msgid ""
"If the same attribute name occurs in both an instance and in a class, then "
"attribute lookup prioritizes the instance::"
msgstr ""
"Aynı nitelik adı hem bir örnekte hem de bir sınıfta oluşuyorsa, nitelik "
"araması örneğe öncelik verir::"

#: tutorial/classes.rst:493
msgid ""
"Data attributes may be referenced by methods as well as by ordinary users "
"(\"clients\") of an object.  In other words, classes are not usable to "
"implement pure abstract data types.  In fact, nothing in Python makes it "
"possible to enforce data hiding --- it is all based upon convention.  (On "
"the other hand, the Python implementation, written in C, can completely hide "
"implementation details and control access to an object if necessary; this "
"can be used by extensions to Python written in C.)"
msgstr ""
"Veri niteliklerine metotların yanı sıra bir nesnenin sıradan kullanıcıları "
"(\"istemciler\") tarafından başvurulabilir.  Başka bir deyişle, sınıflar saf "
"soyut veri türlerini uygulamak için kullanılamaz.  Aslında, Python'daki "
"hiçbir şey, veri gizlemeyi zorlamaz. Bu durum geleneksel kullanımından "
"dolayı bu şekildedir.  (Öte yandan, C ile yazılan Python uygulamaları, "
"uygulama ayrıntılarını tamamen gizleyebilir ve gerekirse bir nesneye erişimi "
"kontrol edebilir; bu, C ile yazılmış Python uzantıları tarafından "
"kullanılabilir.)"

#: tutorial/classes.rst:501
msgid ""
"Clients should use data attributes with care --- clients may mess up "
"invariants maintained by the methods by stamping on their data attributes.  "
"Note that clients may add data attributes of their own to an instance object "
"without affecting the validity of the methods, as long as name conflicts are "
"avoided --- again, a naming convention can save a lot of headaches here."
msgstr ""
"İstemciler veri niteliklerini dikkatle kullanmalıdır --- istemciler veri "
"özniteliklerini damgalayarak yöntemler tarafından tutulan değişmezleri "
"bozabilir.  İstemcilerin, metotların geçerliliğini etkilemeden bir örnek "
"nesnesine kendi veri niteliklerini ekleyebileceğini unutmayın. Tabii ki "
"burada da ad çakışmalarından kaçınılmalıdır, adlandırma kuralları ise "
"kaçınmak için oldukça faydalı olabilir."

#: tutorial/classes.rst:507
msgid ""
"There is no shorthand for referencing data attributes (or other methods!) "
"from within methods.  I find that this actually increases the readability of "
"methods: there is no chance of confusing local variables and instance "
"variables when glancing through a method."
msgstr ""
"Yöntemlerin içinden veri niteliklerine (veya diğer metotlara!) başvurmak "
"için kısa yol yoktur.  Bu aslında metotların okunabilirliğini arttırıyor, "
"çünkü bir metoda bakarken yerel değişkenleri ve örnek değişkenlerini "
"karıştırma ihtimali bırakmamış oluyoruz."

#: tutorial/classes.rst:512
msgid ""
"Often, the first argument of a method is called ``self``.  This is nothing "
"more than a convention: the name ``self`` has absolutely no special meaning "
"to Python.  Note, however, that by not following the convention your code "
"may be less readable to other Python programmers, and it is also conceivable "
"that a *class browser* program might be written that relies upon such a "
"convention."
msgstr ""
"Genellikle, bir metodun ilk bağımsız değişkenine ``self`` denir.  Bu bir "
"kullanım geleneğinden başka bir şey değildir, yani ``self`` adının Python "
"için kesinlikle özel bir anlamı yoktur.  Bununla birlikte, kurala "
"uymadığınızda kodunuzun diğer Python programcıları tarafından daha az "
"okunabilir olabileceğini ve yazılabilecek potansiyel bir *sınıf tarayıcısı* "
"programının bu kurala dayanıyor olabileceğini unutmayın."

#: tutorial/classes.rst:518
msgid ""
"Any function object that is a class attribute defines a method for instances "
"of that class.  It is not necessary that the function definition is "
"textually enclosed in the class definition: assigning a function object to a "
"local variable in the class is also ok.  For example::"
msgstr ""
"Sınıf niteliği olan herhangi bir fonksiyon nesnesi, bu sınıfın örnekleri "
"için bir metot tanımlar.  Fonksiyon tanımının metinsel olarak sınıf tanımına "
"dahil olması gerekli değildir: sınıftaki yerel bir değişkene fonksiyon "
"nesnesi atamak da uygundur.  Mesela::"

#: tutorial/classes.rst:535
#, fuzzy
msgid ""
"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`!C` that "
"refer to function objects, and consequently they are all methods of "
"instances of :class:`!C` --- ``h`` being exactly equivalent to ``g``.  Note "
"that this practice usually only serves to confuse the reader of a program."
msgstr ""
"Buradaki ``f``, ``g`` ve ``h`` fonksiyonları nesnelerine başvuran :class:`C` "
"sınıfının bütün nitelikleridir ve sonuç olarak hepsi :class:`C` --- ``h`` "
"sınıfının örneklerinin metotları olarak tümüyle ``g`` 'ye eş değerdir.  Bu "
"kullanım şeklinin genellikle yalnızca bir programı okuyan kişinin kafasını "
"karıştırmaya yaradığını unutmayın."

#: tutorial/classes.rst:540
msgid ""
"Methods may call other methods by using method attributes of the ``self`` "
"argument::"
msgstr ""
"Metotlar, ``self`` bağımsız değişkeninin metot niteliklerini kullanarak "
"diğer metotları çağırabilir::"

#: tutorial/classes.rst:554
msgid ""
"Methods may reference global names in the same way as ordinary functions.  "
"The global scope associated with a method is the module containing its "
"definition.  (A class is never used as a global scope.)  While one rarely "
"encounters a good reason for using global data in a method, there are many "
"legitimate uses of the global scope: for one thing, functions and modules "
"imported into the global scope can be used by methods, as well as functions "
"and classes defined in it.  Usually, the class containing the method is "
"itself defined in this global scope, and in the next section we'll find some "
"good reasons why a method would want to reference its own class."
msgstr ""
"Metotlar, global adlara sıradan işlevler gibi başvuru yapabilir.  Bir "
"metotla ilişkili genel kapsam, tanımını içeren modüldür.  (Bir sınıf hiçbir "
"zaman genel kapsam olarak kullanılmaz.)  Global verileri bir metotta "
"kullanmak için nadiren iyi bir nedenle karşılaşılsa da, genel kapsamın "
"birçok meşru kullanımı vardır: bir kere, genel kapsamlıya içe aktarılan "
"fonksiyon ve modüller, metotlar ve içinde tanımlanan fonksiyonlar ve "
"sınıflar tarafından kullanılabilir.  Genellikle, metodu içeren sınıfın "
"kendisi bu genel kapsamda tanımlanır ve sonraki bölümde bir yöntemin kendi "
"sınıfına başvurmak istemesinin bazı iyi nedenlerini bulacağız."

#: tutorial/classes.rst:564
msgid ""
"Each value is an object, and therefore has a *class* (also called its "
"*type*). It is stored as ``object.__class__``."
msgstr ""
"Her değer bir nesnedir ve bu nedenle bir *sınıf* (*type* olarak da "
"adlandırılır) bulundurur. ``object.__class__`` olarak depolanır."

#: tutorial/classes.rst:571
msgid "Inheritance"
msgstr "Kalıtım"

#: tutorial/classes.rst:573
msgid ""
"Of course, a language feature would not be worthy of the name \"class\" "
"without supporting inheritance.  The syntax for a derived class definition "
"looks like this::"
msgstr ""
"Tabii ki, bir dil özelliği kalıtımı desteklemeden \"sınıf\" adına layık "
"olmaz.  Türetilmiş sınıf tanımının söz dizimi şöyle görünür::"

#: tutorial/classes.rst:584
#, fuzzy
msgid ""
"The name :class:`!BaseClassName` must be defined in a scope containing the "
"derived class definition.  In place of a base class name, other arbitrary "
"expressions are also allowed.  This can be useful, for example, when the "
"base class is defined in another module::"
msgstr ""
":class:`BaseClassName` adı, türetilmiş sınıf tanımını içeren bir kapsamda "
"tanımlanmalıdır.  Temel sınıf adı yerine, diğer rasgele ifadelere de izin "
"verilir.  Bu, örneğin, temel sınıf başka bir modülde tanımlandığında yararlı "
"olabilir::"

#: tutorial/classes.rst:591
msgid ""
"Execution of a derived class definition proceeds the same as for a base "
"class. When the class object is constructed, the base class is remembered.  "
"This is used for resolving attribute references: if a requested attribute is "
"not found in the class, the search proceeds to look in the base class.  This "
"rule is applied recursively if the base class itself is derived from some "
"other class."
msgstr ""
"Türetilmiş bir sınıf tanımının yürütülmesi, temel sınıfla aynı şekilde devam "
"eder. Sınıf nesnesi inşa edildiğinde, temel sınıf hatırlanır.  Bu, nitelik "
"başvurularını çözmek için kullanılır: istenen nitelik sınıfta bulunmazsa, "
"arama temel sınıfa bakmaya devam eder.  Temel sınıfın kendisi başka bir "
"sınıftan türetilmişse, bu kural özyinelemeli olarak uygulanır."

#: tutorial/classes.rst:597
msgid ""
"There's nothing special about instantiation of derived classes: "
"``DerivedClassName()`` creates a new instance of the class.  Method "
"references are resolved as follows: the corresponding class attribute is "
"searched, descending down the chain of base classes if necessary, and the "
"method reference is valid if this yields a function object."
msgstr ""
"Türetilmiş sınıfların somutlaştırılmasında özel bir şey yoktur: "
"``DerivedClassName()`` sınıfın yeni bir örneğini oluşturur.  Metot "
"başvuruları aşağıdaki gibi çözümlenir: ilgili sınıf niteliği aranır, "
"gerekirse temel sınıflar zincirinin aşağısına inilir ve bu bir fonksiyon "
"nesnesi veriyorsa metot başvurusu geçerlidir."

#: tutorial/classes.rst:603
msgid ""
"Derived classes may override methods of their base classes.  Because methods "
"have no special privileges when calling other methods of the same object, a "
"method of a base class that calls another method defined in the same base "
"class may end up calling a method of a derived class that overrides it.  "
"(For C++ programmers: all methods in Python are effectively ``virtual``.)"
msgstr ""
"Türetilmiş sınıflar, temel sınıflarının metotlarını geçersiz kılabilir.  "
"Metotlar aynı nesnenin diğer yöntemlerini çağırırken özel ayrıcalıkları "
"olmadığından, aynı temel sınıfta tanımlanan başka bir metodu çağıran bir "
"temel sınıfın metodu, onu geçersiz kılan türetilmiş bir sınıfın metodunu "
"çağırabilir.  (C++ programcıları için: Python'daki tüm yöntemler etkili bir "
"şekilde ``sanal``.)"

#: tutorial/classes.rst:609
msgid ""
"An overriding method in a derived class may in fact want to extend rather "
"than simply replace the base class method of the same name. There is a "
"simple way to call the base class method directly: just call ``BaseClassName."
"methodname(self, arguments)``.  This is occasionally useful to clients as "
"well.  (Note that this only works if the base class is accessible as "
"``BaseClassName`` in the global scope.)"
msgstr ""
"Türetilmiş bir sınıfta geçersiz kılma yöntemi aslında yalnızca aynı adlı "
"temel sınıf yöntemini değiştirmek yerine genişletmek isteyebilir. Temel "
"sınıf metodunu doğrudan çağırmanın basit bir yolu vardır: sadece "
"``BaseClassName.methodname(self, arguments)`` çağırın.  Bu bazen müşteriler "
"için de yararlıdır.  (Bunun yalnızca temel sınıfa genel kapsamda "
"``BaseClassName`` olarak erişilebiliyorsa çalıştığını unutmayın.)"

#: tutorial/classes.rst:616
msgid "Python has two built-in functions that work with inheritance:"
msgstr "Python'un kalıtımla çalışan iki yerleşik fonksiyonu vardır:"

#: tutorial/classes.rst:618
msgid ""
"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` "
"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "
"derived from :class:`int`."
msgstr ""
"Bir örneğin türünü denetlemek için :func:`isinstance` kullanın: "
"``isinstance(obj, int)`` yalnızca ``obj.__class__`` :class:`int` veya :class:"
"`int` sınıfından türetilmiş bir sınıfsa ``True`` olacaktır."

#: tutorial/classes.rst:622
msgid ""
"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "
"is ``True`` since :class:`bool` is a subclass of :class:`int`.  However, "
"``issubclass(float, int)`` is ``False`` since :class:`float` is not a "
"subclass of :class:`int`."
msgstr ""
"Sınıf kalıtımını denetlemek için :func:`issubclass` kullanın: "
"``issubclass(bool, int)`` ``True`` 'dur, çünkü :class:`bool` :class:`int` "
"'in bir alt sınıfıdır.  Ancak, ``issubclass(float, int)`` ``False`` "
"olduğundan :class:`float`, :class:`int` alt sınıfı değildir."

#: tutorial/classes.rst:632
msgid "Multiple Inheritance"
msgstr "Çoklu Kalıtım"

#: tutorial/classes.rst:634
msgid ""
"Python supports a form of multiple inheritance as well.  A class definition "
"with multiple base classes looks like this::"
msgstr ""
"Python, çoklu kalıtım biçimini de destekler.  Birden çok temel sınıf içeren "
"bir sınıf tanımı şöyle görünür::"

#: tutorial/classes.rst:644
#, fuzzy
msgid ""
"For most purposes, in the simplest cases, you can think of the search for "
"attributes inherited from a parent class as depth-first, left-to-right, not "
"searching twice in the same class where there is an overlap in the "
"hierarchy. Thus, if an attribute is not found in :class:`!DerivedClassName`, "
"it is searched for in :class:`!Base1`, then (recursively) in the base "
"classes of :class:`!Base1`, and if it was not found there, it was searched "
"for in :class:`!Base2`, and so on."
msgstr ""
"Basitçe, bir üst sınıftan devralınan nitelikleri aramayı, hiyerarşide "
"çakışmanın olduğu aynı sınıfta iki kez arama yapmadan, derinlik öncelikli, "
"soldan sağa olarak düşünebilirsiniz. Bu nedenle, bir nitelik :class:"
"`DerivedClassName` içinde bulunamazsa, :class:`Base1` 'de, sonra "
"(özyinelemeli olarak) :class:`Base1` temel sınıflarında aranır ve orada "
"bulunamazsa :class:`Base2` vb."

#: tutorial/classes.rst:651
msgid ""
"In fact, it is slightly more complex than that; the method resolution order "
"changes dynamically to support cooperative calls to :func:`super`.  This "
"approach is known in some other multiple-inheritance languages as call-next-"
"method and is more powerful than the super call found in single-inheritance "
"languages."
msgstr ""
"Aslında, durum bundan biraz daha karmaşıktır: yöntem çözümleme sırası, :func:"
"`super` için işbirliği çağrılarını desteklemek için dinamik olarak değişir.  "
"Bu yaklaşım, diğer bazı çoklu kalıtım dillerinde sonraki çağrı yöntemi "
"olarak bilinir ve tekli kalıtım dillerinde bulunan süper çağrıdan daha "
"güçlüdür."

#: tutorial/classes.rst:657
msgid ""
"Dynamic ordering is necessary because all cases of multiple inheritance "
"exhibit one or more diamond relationships (where at least one of the parent "
"classes can be accessed through multiple paths from the bottommost class).  "
"For example, all classes inherit from :class:`object`, so any case of "
"multiple inheritance provides more than one path to reach :class:`object`.  "
"To keep the base classes from being accessed more than once, the dynamic "
"algorithm linearizes the search order in a way that preserves the left-to-"
"right ordering specified in each class, that calls each parent only once, "
"and that is monotonic (meaning that a class can be subclassed without "
"affecting the precedence order of its parents). Taken together, these "
"properties make it possible to design reliable and extensible classes with "
"multiple inheritance.  For more detail, see https://www.python.org/download/"
"releases/2.3/mro/."
msgstr ""
"Çoklu kalıtımın tüm durumları bir veya daha fazla elmas ilişkisi "
"gösterdiğinden (üst sınıflardan en az birine, en alttaki sınıftan birden çok "
"yol üzerinden erişilebildiği ilişkiler) dinamik sıralama gereklidir.  "
"Örneğin, tüm sınıflar :class:`object` öğesini devralır, bu nedenle çoklu "
"kalıtım durumu :class:`object` 'e ulaşmak için birden fazla yol sağlar. "
"Temel sınıflara birden çok kez erişilmesini önlemek için, dinamik algoritma "
"arama sırasını her sınıfta belirtilen soldan sağa sıralamayı koruyacak "
"şekilde doğrular, her üst öğeyi yalnızca bir kez çağırır ve monotondur (yani "
"bir sınıf, üst sınıfının öncelik sırasını etkilemeden alt "
"sınıflandırılabilir). Birlikte ele alındığında, bu özellikler çoklu kalıtım "
"ile güvenilir ve genişletilebilir sınıflar tasarlamayı mümkün kılar.  Daha "
"fazla ayrıntı için bkz. https://www.python.org/download/releases/2.3/mro/."

#: tutorial/classes.rst:674
msgid "Private Variables"
msgstr "Özel Değişkenler"

#: tutorial/classes.rst:676
msgid ""
"\"Private\" instance variables that cannot be accessed except from inside an "
"object don't exist in Python.  However, there is a convention that is "
"followed by most Python code: a name prefixed with an underscore (e.g. "
"``_spam``) should be treated as a non-public part of the API (whether it is "
"a function, a method or a data member).  It should be considered an "
"implementation detail and subject to change without notice."
msgstr ""
"Python'da bir nesnenin içinden erişilmesi dışında asla erişilemeyen \"özel\" "
"örnek değişkenleri yoktur.  Ancak, çoğu Python kodu tarafından izlenen bir "
"kural vardır: alt çizgi (örneğin ``_spam``) ile öneklenmiş bir ad API'nin "
"genel olmayan bir parçası olarak kabul edilmelidir (bir fonksiyon, metot "
"veya veri üyesi olsun).  Bir uygulama detayıdır ve önceden haber "
"verilmeksizin değiştirilebilir."

#: tutorial/classes.rst:686
msgid ""
"Since there is a valid use-case for class-private members (namely to avoid "
"name clashes of names with names defined by subclasses), there is limited "
"support for such a mechanism, called :dfn:`name mangling`.  Any identifier "
"of the form ``__spam`` (at least two leading underscores, at most one "
"trailing underscore) is textually replaced with ``_classname__spam``, where "
"``classname`` is the current class name with leading underscore(s) "
"stripped.  This mangling is done without regard to the syntactic position of "
"the identifier, as long as it occurs within the definition of a class."
msgstr ""
"Sınıf-özel üyeler için geçerli bir kullanım örneği olduğundan (yani alt "
"sınıflar tarafından tanımlanan adlara sahip adların ad çakışmasını önlemek "
"için), :dfn:`name mangling` adı verilen böyle bir mekanizma için sınırlı "
"destek vardır.  ``__spam`` formunun herhangi bir tanımlayıcısı (en az iki "
"satır altı, en fazla bir alt çizgi) metinsel olarak ``_classname__spam`` ile "
"değiştirilir;  Bu mangling, bir sınıfın tanımı içinde gerçekleştiği sürece "
"tanımlayıcının söz dizimsel konumuna bakılmaksızın yapılır."

#: tutorial/classes.rst:695
msgid ""
"Name mangling is helpful for letting subclasses override methods without "
"breaking intraclass method calls.  For example::"
msgstr ""
"Ad mangling, alt sınıfların sınıf içi metot çağrılarını kesmeden metotları "
"geçersiz kılmasına izin vermek için yararlıdır.  Mesela::"

#: tutorial/classes.rst:717
msgid ""
"The above example would work even if ``MappingSubclass`` were to introduce a "
"``__update`` identifier since it is replaced with ``_Mapping__update`` in "
"the ``Mapping`` class  and ``_MappingSubclass__update`` in the "
"``MappingSubclass`` class respectively."
msgstr ""
"Yukarıdaki örnek, ``MappingSubclass`` sırasıyla ``Mapping`` sınıfında "
"``_Mapping__update`` ve ``mappingSubclass`` sınıfında "
"``_MappingSubclass__update`` ile değiştirildiği için ``__update`` "
"tanımlayıcısı tanıtsa bile çalışır."

#: tutorial/classes.rst:722
msgid ""
"Note that the mangling rules are designed mostly to avoid accidents; it "
"still is possible to access or modify a variable that is considered "
"private.  This can even be useful in special circumstances, such as in the "
"debugger."
msgstr ""
"Mangling kurallarının çoğunlukla kazaları önlemek için tasarlandığını "
"unutmayın; özel olarak kabul edilen bir değişkene erişmek veya değiştirmek "
"hala mümkündür.  Bu, hata ayıklayıcı gibi özel durumlarda bile yararlı "
"olabilir."

#: tutorial/classes.rst:726
msgid ""
"Notice that code passed to ``exec()`` or ``eval()`` does not consider the "
"classname of the invoking class to be the current class; this is similar to "
"the effect of the ``global`` statement, the effect of which is likewise "
"restricted to code that is byte-compiled together.  The same restriction "
"applies to ``getattr()``, ``setattr()`` and ``delattr()``, as well as when "
"referencing ``__dict__`` directly."
msgstr ""
"``exec()`` veya ``eval()`` koduna geçirilen kodun çağırma sınıfının sınıf "
"adını geçerli sınıf olarak görmediğine dikkat edin; bu, etkisi aynı şekilde "
"birlikte bayt derlenmiş kodla sınırlı olan ``global`` deyiminin etkisine "
"benzer.  Aynı kısıtlama ``getattr()``, ``setattr()`` ve ``delattr()`` ve "
"doğrudan ``__dict__`` atıfta bulunurken de geçerlidir."

#: tutorial/classes.rst:737
msgid "Odds and Ends"
msgstr "Oranlar ve Bitişler"

#: tutorial/classes.rst:739
msgid ""
"Sometimes it is useful to have a data type similar to the Pascal \"record\" "
"or C \"struct\", bundling together a few named data items. The idiomatic "
"approach is to use :mod:`dataclasses` for this purpose::"
msgstr ""
"Bazen, birkaç adlandırılmış veri öğesini bir araya getirerek Pascal *record* "
"'u veya C *struct* 'ına benzer bir veri türüne sahip olmak yararlıdır. "
"Deyimsel yaklaşım, bu amaç için :mod:`dataclasses` kullanmaktır::"

#: tutorial/classes.rst:759
#, fuzzy
msgid ""
"A piece of Python code that expects a particular abstract data type can "
"often be passed a class that emulates the methods of that data type "
"instead.  For instance, if you have a function that formats some data from a "
"file object, you can define a class with methods :meth:`~io.TextIOBase.read` "
"and :meth:`~io.TextIOBase.readline` that get the data from a string buffer "
"instead, and pass it as an argument."
msgstr ""
"Belirli bir soyut veri türünü bekleyen Python kodunun bir parçası genellikle "
"bunun yerine bu veri türünün yöntemlerine öykünen bir sınıfa geçirilebilir.  "
"Örneğin, bir dosya nesnesinden bazı verileri biçimlendiren bir fonksiyonunuz "
"varsa, bunun yerine verileri bir dize arabelleğinden alan ve bağımsız "
"değişken olarak geçiren :meth:`read` ve :meth:`!readline` yöntemlerine sahip "
"bir sınıf tanımlayabilirsiniz."

#: tutorial/classes.rst:771
#, fuzzy
msgid ""
"Instance method objects have attributes, too: ``m.__self__`` is the instance "
"object with the method :meth:`!m`, and ``m.__func__`` is the function object "
"corresponding to the method."
msgstr ""
"Örnek yöntem nesnelerinin de nitelikleri vardır: ``m.__self__`` yöntemi olan "
"örnek nesnedir :meth:`m`, ve ``m.__func__`` yönteme karşılık gelen fonksiyon "
"nesnesidir."

#: tutorial/classes.rst:779
msgid "Iterators"
msgstr "Yineleyiciler"

#: tutorial/classes.rst:781
msgid ""
"By now you have probably noticed that most container objects can be looped "
"over using a :keyword:`for` statement::"
msgstr ""
"Şimdiye kadar büyük olasılıkla çoğu kapsayıcı nesnenin bir :keyword:`for` "
"deyimi kullanılarak döngüye alınabileceğini fark etmişsinizdir::"

#: tutorial/classes.rst:795
msgid ""
"This style of access is clear, concise, and convenient.  The use of "
"iterators pervades and unifies Python.  Behind the scenes, the :keyword:"
"`for` statement calls :func:`iter` on the container object.  The function "
"returns an iterator object that defines the method :meth:`~iterator."
"__next__` which accesses elements in the container one at a time.  When "
"there are no more elements, :meth:`~iterator.__next__` raises a :exc:"
"`StopIteration` exception which tells the :keyword:`!for` loop to "
"terminate.  You can call the :meth:`~iterator.__next__` method using the :"
"func:`next` built-in function; this example shows how it all works::"
msgstr ""
"Bu erişim tarzı açık, özlü ve kullanışlıdır.  Yineleyicilerin kullanımı "
"Python'u istila eder ve birleştirir.  Perde arkasında :keyword:`for` deyimi "
"kapsayıcı nesne üzerinde :func:`iter` öğesini çağırır.  Fonksiyon, "
"kapsayıcıdaki öğelere teker teker erişen :meth:`~iterator.__next__` metodunu "
"tanımlayan bir yineleyici nesnesi döndürür.  Başka öğe olmadığında, :meth:"
"`~iterator.__next__`, :keyword:`!for` döngüsünün sonlandırılacağını bildiren "
"bir :exc:`StopIteration` hatası oluşturur.  :func:`next` yerleşik "
"fonksiyonunu kullanarak :meth:`~iterator.__next__` yöntemini "
"çağırabilirsiniz; Bu örnek, her şeyin nasıl çalıştığını gösterir::"

#: tutorial/classes.rst:820
#, fuzzy
msgid ""
"Having seen the mechanics behind the iterator protocol, it is easy to add "
"iterator behavior to your classes.  Define an :meth:`~container.__iter__` "
"method which returns an object with a :meth:`~iterator.__next__` method.  If "
"the class defines :meth:`!__next__`, then :meth:`!__iter__` can just return "
"``self``::"
msgstr ""
"Yineleme protokolünün arkasındaki mekaniği gördükten sonra, sınıflarınıza "
"yineleme davranışı eklemek kolaydır.  :meth:`~iterator.__next__` metodu ile "
"bir nesne döndüren :meth:`__iter__` metodunu tanımlayın.  Sınıf  :meth:"
"`__next__` tanımlarsa, :meth:`__iter__`  sadece  ``self`` döndürebilir::"

#: tutorial/classes.rst:857
msgid "Generators"
msgstr "Üreteçler"

#: tutorial/classes.rst:859
msgid ""
":term:`Generators <generator>` are a simple and powerful tool for creating "
"iterators.  They are written like regular functions but use the :keyword:"
"`yield` statement whenever they want to return data.  Each time :func:`next` "
"is called on it, the generator resumes where it left off (it remembers all "
"the data values and which statement was last executed).  An example shows "
"that generators can be trivially easy to create::"
msgstr ""
":term:`Üreteçler <generator>` yineleyiciler oluşturmak için basit ve güçlü "
"bir araçtır.  Normal fonksiyonlar gibi yazılırlar, ancak veri döndürmek "
"istediklerinde :keyword:`yield` deyimini kullanırlar.  Üzerinde her :func:"
"`next` çağrıldığı zaman, üreteç kaldığı yerden devam eder (tüm veri "
"değerlerini ve hangi deyimin en son yürütüldüğını hatırlar).  Bu örnek, "
"üreteçlerin oluşturulmasının ne kadar da kolay olabileceğini gösterir::"

#: tutorial/classes.rst:880
#, fuzzy
msgid ""
"Anything that can be done with generators can also be done with class-based "
"iterators as described in the previous section.  What makes generators so "
"compact is that the :meth:`~iterator.__iter__` and :meth:`~generator."
"__next__` methods are created automatically."
msgstr ""
"Üreteçlerle yapılabilecek her şey, önceki bölümde açıklandığı gibi sınıf "
"tabanlı yineleyicilerle de yapılabilir.  Üreteçleri bu kadar kompakt yapan "
"şey: :meth:`__iter__` ve :meth:`~generator.__next__` yöntemlerinin otomatik "
"olarak oluşturulmasıdır."

#: tutorial/classes.rst:885
msgid ""
"Another key feature is that the local variables and execution state are "
"automatically saved between calls.  This made the function easier to write "
"and much more clear than an approach using instance variables like ``self."
"index`` and ``self.data``."
msgstr ""
"Başka bir önemli özellik, yerel değişkenlerin ve yürütme durumunun çağrılar "
"arasında otomatik olarak kaydedilmesidir.  Bu, fonksiyonun yazılmasını "
"kolaylaştırdı ve ``self.index`` ve ``self.data`` gibi değişkenleri "
"kullanmaya kıyasla çok daha net hale getirdi."

#: tutorial/classes.rst:890
msgid ""
"In addition to automatic method creation and saving program state, when "
"generators terminate, they automatically raise :exc:`StopIteration`. In "
"combination, these features make it easy to create iterators with no more "
"effort than writing a regular function."
msgstr ""
"Otomatik metot oluşturma ve kaydetme programı durumuna ek olarak, üreteçler "
"sonlandırıldığında otomatik olarak :exc:`StopIteration` 'ı yükseltirler. "
"Birlikte, bu özellikler normal bir işlev yazmaktan daha fazla çaba "
"harcamadan yinelemeler oluşturmayı kolaylaştırır."

#: tutorial/classes.rst:899
msgid "Generator Expressions"
msgstr "Üreteç İfadeleri"

#: tutorial/classes.rst:901
msgid ""
"Some simple generators can be coded succinctly as expressions using a syntax "
"similar to list comprehensions but with parentheses instead of square "
"brackets. These expressions are designed for situations where the generator "
"is used right away by an enclosing function.  Generator expressions are more "
"compact but less versatile than full generator definitions and tend to be "
"more memory friendly than equivalent list comprehensions."
msgstr ""
"Bazı basit üreteçler, listelere benzer bir söz dizimi kullanılarak ve köşeli "
"ayraçlar yerine parantezlerle kısaca kodlanabilir. Bu ifadeler, üreteçlerin "
"kapsayıcı bir fonksiyon tarafından hemen kullanıldığı durumlar için "
"tasarlanmıştır.  Üreteç ifadeleri tam üreteç tanımlarından daha kompakt "
"ancak daha az çok yönlüdür ve aynı özellikle liste anlamalarından daha "
"bellek dostu olma eğilimindedir."

#: tutorial/classes.rst:908
msgid "Examples::"
msgstr "Örnekler::"

#: tutorial/classes.rst:929
msgid "Footnotes"
msgstr "Dipnotlar"

#: tutorial/classes.rst:930
msgid ""
"Except for one thing.  Module objects have a secret read-only attribute "
"called :attr:`~object.__dict__` which returns the dictionary used to "
"implement the module's namespace; the name :attr:`~object.__dict__` is an "
"attribute but not a global name. Obviously, using this violates the "
"abstraction of namespace implementation, and should be restricted to things "
"like post-mortem debuggers."
msgstr ""
"Bir şey hariç.  Modül nesneleri,  :attr:`~object.__dict__`  denen sadece "
"okunabilir bir özelliğe sahiptir, bu da modülün ad alanını uygulamak için "
"bir sözlük döndürür: :attr:`~object.__dict__` ismi bir özellik olsa da "
"global bir isim değildir. Kuşkusuz, bu durum ad alanlarının soyutlanış "
"özelliklerine aykırı, dolayısıyla sadece programın durması sonrası çalışan "
"hata ayıklayıcılar gibilerinin kullanımına kısıtlanmalı."

#: tutorial/classes.rst:347
#, fuzzy
msgid "object"
msgstr "Metot Nesneleri"

#: tutorial/classes.rst:347
msgid "method"
msgstr ""

#: tutorial/classes.rst:683
msgid "name"
msgstr ""

#: tutorial/classes.rst:683
msgid "mangling"
msgstr ""