calibre - en to tr translation catalogue (42 entries)

en: Techniques for using function mode and the syntax will be described by means of examples, showing you how to create functions to perform progressively more complex tasks.
tr: Fonksiyon kipi ve söz dizimi kullanım teknikleri örneklerle açıklanacak, gittikçe zorlaşan görevleri fonksiyon kipiyle nasıl yapacağınız gösterilecektir.

en: Automatically fixing the case of headings in the document
tr: Belgedeki başlık büyük küçük harflerinin otomatik düzeltilmesi

en: Here, we will leverage one of the builtin functions in the editor to automatically change the case of all text inside heading tags to title case::
tr: Burda, düzenleyicideki dahili fonksiyonlardan birini göz önüne alıp başlık etiketleri içindeki tüm metnin harflerini nasıl otomatik olarak başlık boyutuna değiştireceğimize bakacağız::

en: Your first custom function - smartening hyphens
tr: İlk özel fonksiyonunuz - akıllı tireler

en: The real power of function mode comes from being able to create your own functions to process text in arbitrary ways. The Smarten Punctuation tool in the editor leaves individual hyphens alone, so you can use the this function to replace them with em-dashes.
tr: Fonksiyon kipinin asıl gücü metni keyfi şekillerde işlemenizi sağlayan kendi fonksiyonlarınızı yazabilmenizden gelir. Düzenleyicideki Akıllı Noktalama aracı bağımsız tirelere dokunmaz, yani bu fonksiyonu kullanarak onları uzun tirelerle değiştirebilirsiniz.

en: Use this function with the find regular expression::
tr: Bu fonksiyonu arama düzenli ifadesi ile kullanın::

en: And it will replace all hyphens with em-dashes, but only in actual text and not inside HTML tag definitions.
tr: Tüm tireleri uzun tire ile değiştirecektir, ama yalnızca asıl metin içinde HTML etiket tanımlarında değil.

en: The power of function mode - using a spelling dictionary to fix mis-hyphenated words
tr: Fonksiyon kipinin gücü - yanlış tirelenmiş kelimeler için bir yazım denetim sözlüğü kullanmak

en: Use this function with the same find expression as before, namely::
tr: Bu fonksiyonu aynı bulma ifadesi ile kullanın, açmak gerekirse::

en: And it will magically fix all mis-hyphenated words in the text of the book. The main trick is to use one of the useful extra arguments to the replace function, ``dictionaries``.  This refers to the dictionaries the editor itself uses to spell check text in the book. What this function does is look for words separated by a hyphen, remove the hyphen and check if the dictionary recognizes the composite word, if it does, the original words are replaced by the hyphen free composite word.
tr: Böylece kitap metnindeki tüm yanlış tirelenmiş kelimeleri sihirli bir şekilde düzeltecektir. Ana nokta replace fonksiyonuna verilen kullanışlı bir ek bağımsız değişken olan ``dictionaries``.  Bu düzenleyicinin kitap metninde yazım denetimi yaptığı sözlükleri kasteder. Bu fonksiyonun yaptığı ise bir tire ile ayrılmış kelimelere bakmak, tireyi kaldırmak ve karma kelimenin sözlük tarafından tanınıp tanınmadığına bakmaktır, eğer tanınıyorsa asıl kelimeler tire olmayan karma kelimelerle değiştirilir.

en: Note that one limitation of this technique is it will only work for mono-lingual books, because, by default, ``dictionaries.recognized()`` uses the main language of the book.
tr: Bu tekniğin kısıtlarından biri yalnızca tek dilli kitaplarda çalışacak olmasıdır, çünkü var sayılan olarak, ``dictionaries.recognized()`` kitabın ana dilini kullanır.

en: Auto numbering sections
tr: Kısımların otomatik numaralandırılması

en: Now we will see something a little different. Suppose your HTML file has many sections, each with a heading in an :code:`<h2>` tag that looks like :code:`<h2>Some text</h2>`. You can create a custom function that will automatically number these headings with consecutive section numbers, so that they look like :code:`<h2>1. Some text</h2>`.
tr: Şimdi biraz daha farklı bir şey göreceğiz. HTML dosyanızın birçok kısmı olduğunu farz edin, her biri bir :code:`<h2>` etiketi içinde :code:`<h2>Bir metin</h2>` gibi görünen başlıkla. Özel bir fonksiyon oluşturup bu başlıkları otomatik olarak sıralı numaralar şeklinde numaralandırabilirsiniz, böylece :code:`<h2>1. Bir metin</h2>` olarak görünürler.

en: Use it with the find expression::
tr: Arama ifadesiyle birlikte kullanın::

en: Place the cursor at the top of the file and click :guilabel:`Replace all`.
tr: İmleci dosyanın üstüne konumlandırın ve :guilabel:`Hepsini değiştir` tıklayın.

en: This function uses another of the useful extra arguments to ``replace()``: the ``number`` argument. When doing a :guilabel:`Replace All` number is automatically incremented for every successive match.
tr: Bu fonksiyon ``replace()`` fonksiyonuna ek başka kullanışlı bir bağımsız değişken kullanır: ``number`` değişkeni. :guilabel:`Hepsini değiştir` yaparken sayı otomatik olarak her başarılı eşleşmede artırılır.

en: Another new feature is the use of ``replace.file_order`` -- setting that to ``'spine'`` means that if this search is run on multiple HTML files, the files are processed in the order in which they appear in the book. See :ref:`file_order_replace_all` for details.
tr: Yeni başka bir özellik ``replace.file_order`` kullanımıdır -- bunun ``'spine'`` olarak ayarlanması bu aramanın birden fazla HTML dosyada aranması durumunda, dosyaların kitapta bulundukları sırada işlenmesini anlamına gelir. Detaylar için bknz :ref:`file_order_replace_all`.

en: Auto create a Table of Contents
tr: Otomatik olarak bir İçindekiler oluştur

en: Finally, lets try something a little more ambitious. Suppose your book has headings in ``h1`` and ``h2`` tags that look like ``<h1 id="someid">Some Text</h1>``. We will auto-generate an HTML Table of Contents based on these headings. Create the custom function below:
tr: Son olarak, biraz daha iddialı bir şey deneyelim. Kitabınızda ``<h1 id="birtakimid">Bir Metin</h1>`` gibi görünen ``h1`` ve ``h2`` etiketli başlıklar olduğunu var sayın. Bu başlıklara dayalı bir İçindekileri otomatik olarak üreteceğiz. Aşağıdaki özel fonksiyonu oluşturun:

en: And use it with the find expression::
tr: Ve bulma ifadesiyle kullanın::

en: Another new feature is the use of ``call_after_last_match`` -- setting that to ``True`` on the ``replace()`` function means that the editor will call ``replace()`` one extra time after all matches have been found. For this extra call, the match object will be ``None``.
tr: Başka yeni bir özellik de ``call_after_last_match`` kullanımıdır -- bunu ``replace()`` fonksiyonunda ``True`` olarak ayarlamak düzenleyicinin tüm eşleşmeler bulunduktan sonra bir kere daha ``replace()`` çağırması demektir. Bu ek çağrı için, eşleşme nesnesi ``None`` olacaktır.

en: This was just a demonstration to show you the power of function mode, if you really needed to generate a Table of Contents from headings in your book, you would be better off using the dedicated Table of Contents tool in :guilabel:`Tools->Table of Contents`.
tr: Bu yalnızca fonksiyon kipinin gücünü göstermek için bir gösteriydi, gerçekten bir kitaptaki başlıklardan İçindekiler oluşturmaya ihtiyacınız varsa, :guilabel:`Araçlar->İçindekiler` içindeki bu iş için atanmış İçindekiler aracını kullansanız daha iyi edersiniz.

en: The API for the function mode
tr: Fonksiyon kipi için API

en: When a find/replace is run, for every match that is found, the ``replace()`` function will be called, it must return the replacement string for that match. If no replacements are to be done, it should return ``match.group()`` which is the original string. The various arguments to the ``replace()`` function are documented below.
tr: Bir bul/değiştir çalıştığında, bulunan her eşleşme için, bu eşleşme için değiştirme karater dizisini döndürmesi gereken ``replace()`` fonksiyonu çağrılacaktır. Herhangi bir değiştirme yapılmayacaksa, asıl karakter dizisi olan ``match.group()`` döndürmelidir. ``replace()`` fonksiyonuna verilen çeşitli bağımsız değişkenler aşağıda belgelenmiştir.

en: The ``match`` argument
tr: ``match`` bağımsız değişkeni

en: The ``number`` argument
tr: ``number`` bağımsız değişkeni

en: The ``number`` argument is the number of the current match. When you run :guilabel:`Replace All`, every successive match will cause ``replace()`` to be called with an increasing number. The first match has number 1.
tr: ``number`` bağımsız değişkeni mevcut eşleşmenin sayısıdır. :guilabel:`Hepsini Değiştir` çalıştırdığınızda, her başarılı eşleşme ``replace()``in artan bir sayıyla çağrılmasına sebep olur. İlk eşleşmenin 1 numarası vardır.

en: The ``file_name`` argument
tr: ``file_name`` bağımsız değişkeni

en: This is the filename of the file in which the current match was found. When searching inside marked text, the ``file_name`` is empty. The ``file_name`` is in canonical form, a path relative to the root of the book, using ``/`` as the path separator.
tr: Mevcut eşleşmenin bulunduğu dosyanın dosya ismidir. İşaretli metin içinde arama yaparken, ``file_name`` boştur. ``file_name`` kuralsal biçimindedir, ayraç olarak ``/`` kullanan kitabın köküne göreceli bir yol.

en: The ``metadata`` argument
tr: ``metadata`` bağımsız değişkeni

en: This represents the metadata of the current book, such as title, authors, language, etc. It is an object of class :class:`calibre.ebooks.metadata.book.base.Metadata`. Useful attributes include, ``title``, ``authors`` (a list of authors) and ``language`` (the language code).
tr: Bu mevcut kitabın metadata'sını temsil eder, başlık, yazarlar, dil, vs. Bir :class:`calibre.ebooks.metadata.book.base.Metadata` nesnesidir. Kullanışlı öznitelikler arasında ``başlık``, ``yazarlar`` (yazar listesi) ve ``dil`` (dil kodu) bulunur.

en: The ``dictionaries`` argument
tr: ``dictionaries`` bağımsız değişkeni

en: The ``data`` argument
tr: ``data`` bağımsız değişkeni

en: The ``functions`` argument
tr: ``functions`` bağımsız değişkeni

en: The ``functions`` argument gives you access to all other user defined functions. This is useful for code re-use. You can define utility functions in one place and re-use them in all your other functions. For example, suppose you create a function name ``My Function`` like this:
tr: ``functions`` bağımsız değişkeni diğer tüm kullanıcı tanımlı fonksiyonlara erişim verir. Bu kod tekrar kullanımı için faydalıdır. Yardımcı fonksiyonları bir yerde tanımlayabilir ve diğer tüm fonksiyonlarınızda tekrar kullanabilirsiniz. Örneğin, şu şekilde ``My Function`` isimli bir fonksiyon tanımladığınızı var sayalım:

en: Then, in another function, you can access the ``utility()`` function like this:
tr: Sonra, başka bir fonksiyon içinde, ``utility()`` fonksiyonuna şu şekilde erişebilirsiniz:

en: You can also use the functions object to store persistent data, that can be re-used by other functions. For example, you could have one function that when run with :guilabel:`Replace All` collects some data and another function that uses it when it is run afterwards. Consider the following two functions:
tr: Fonksiyonlar nesnesini diğer fonksiyonlarca tekrar kullanılabilen kalıcı veri depolamak için de kullanabilirsiniz. Örneğin, :guilabel:`Hepsini Değiştir` ile çağrıldığında veri toplayan bir fonksiyonunuz ve daha sonra çağrıldığında bunu kullanan ikinci bir fonksiyonunuz olabilir. Şu iki fonksiyonu göz önüne alın:

en: Debugging your functions
tr: Fonksiyonlarınızda hata ayıklama

en: Choose file order when running on multiple HTML files
tr: Çoklu HTML dosyalarında çalışırkenki dosya sırasını seç

en: ``file_order`` accepts two values, ``spine`` and ``spine-reverse`` which cause the search to process multiple files in the order they appear in the book, either forwards or backwards, respectively.
tr: ``file_order`` iki değer alır, aramanın birden çok dosyayı kitapta göründükleri sırada işlemesine sebep olan ve sırayla ileri veya geri anlamına gelen``spine`` ve ``spine-reverse``.

en: Having your function called an extra time after the last match is found
tr: Fonksiyonunuzun son eşleşme bulunduktan sonra ek bir sefer daha çağrılması

en: Sometimes, as in the auto generate table of contents example above, it is useful to have your function called an extra time after the last match is found. You can do this by setting the ``call_after_last_match`` attribute on your function, like this:
tr: Bazen, yukarıdaki içindekileri otomatik olarak üreten örnek gibi, son eşleşme bulunduktan sonra fonksiyonunuzu bir kere daha çağırmak faydalı olabilir. Bunu fonksiyonunuzda ``call_after_last_match`` özniteliğini şu şekilde ayarlayarak yapabilirsiniz:
