# 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.10\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2023-02-04 22:37+0000\n"

"PO-Revision-Date: 2022-01-17 22:57+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.0.1\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

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

#, fuzzy

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

#, fuzzy

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

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

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

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:`__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:`__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

msgid ""

"Of course, the :meth:`__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

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

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

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

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

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"