calibre - en to ta translation catalogue (63 entries)

en: Function mode for Search & replace in the Editor
ta: தேடலுக்கான செயல்பாட்டு முறை மற்றும் மாற்றத்திற்கான செயல்பாடு முறை

en: The :guilabel:`Search & replace` tool in the editor support a *function mode*. In this mode, you can combine regular expressions (see :doc:`regexp`) with arbitrarily powerful Python functions to do all sorts of advanced text processing.
ta: தி: கிலாபெல்: எடிட்டரில் `தேடல் மற்றும் மாற்றவும்` கருவி ஒரு *செயல்பாட்டு பயன்முறையை *ஆதரிக்கவும். இந்த பயன்முறையில், எல்லா வகையான மேம்பட்ட உரை செயலாக்கத்தையும் செய்ய தன்னிச்சையாக சக்திவாய்ந்த பைதான் செயல்பாடுகளுடன் வழக்கமான வெளிப்பாடுகளை (DOC: `Regexp`) இணைக்கலாம்.

en: In the standard *regexp* mode for search and replace, you specify both a regular expression to search for as well as a template that is used to replace all found matches. In function mode, instead of using a fixed template, you specify an arbitrary function, in the `Python programming language <https://docs.python.org>`_. This allows you to do lots of things that are not possible with simple templates.
ta: தேடல் மற்றும் மாற்றத்திற்கான நிலையான * Regexp * பயன்முறையில், தேடுவதற்கான வழக்கமான வெளிப்பாடு இரண்டையும் நீங்கள் குறிப்பிடுகிறீர்கள், அத்துடன் காணப்படும் அனைத்து போட்டிகளையும் மாற்றுவதற்குப் பயன்படுத்தப்படும் ஒரு வார்ப்புரு. செயல்பாட்டு பயன்முறையில், ஒரு நிலையான வார்ப்புருவைப் பயன்படுத்துவதற்குப் பதிலாக, `பைதான் நிரலாக்க மொழியில் <https://docs.python.org> _ _ இல் ஒரு தன்னிச்சையான செயல்பாட்டைக் குறிப்பிடுகிறீர்கள். எளிய வார்ப்புருக்கள் மூலம் சாத்தியமில்லாத பல விஷயங்களைச் செய்ய இது உங்களை அனுமதிக்கிறது.

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.
ta: செயல்பாட்டு பயன்முறை மற்றும் தொடரியல் ஆகியவற்றைப் பயன்படுத்துவதற்கான நுட்பங்கள் எடுத்துக்காட்டுகள் மூலம் விவரிக்கப்படும், இது படிப்படியாக மிகவும் சிக்கலான பணிகளைச் செய்வதற்கான செயல்பாடுகளை எவ்வாறு உருவாக்குவது என்பதைக் காட்டுகிறது.

en: The Function mode
ta: செயல்பாட்டு முறை

en: Automatically fixing the case of headings in the document
ta: ஆவணத்தில் உள்ள தலைப்புகளின் வழக்கை தானாக சரிசெய்தல்

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::
ta: இங்கே, எடிட்டரில் உள்ள பில்டின் செயல்பாடுகளில் ஒன்றை நாங்கள் பயன்படுத்துவோம், எல்லா உரையும் தலைப்பு குறிச்சொற்களை தலைப்பு வழக்குக்கு மாற்றுவோம் ::

en: Your first custom function - smartening hyphens
ta: உங்கள் முதல் தனிப்பயன் செயல்பாடு - ஸ்மார்டிங் ஹைபன்கள்

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.
ta: செயல்பாட்டு பயன்முறையின் உண்மையான சக்தி உங்கள் சொந்த செயல்பாடுகளை தன்னிச்சையான வழிகளில் செயலாக்க உங்கள் சொந்த செயல்பாடுகளை உருவாக்க முடியும் என்பதிலிருந்து வருகிறது. எடிட்டரில் உள்ள ஸ்மார்டன் நிறுத்தற்குறி கருவி தனிப்பட்ட ஹைபன்களை தனியாக விட்டுவிடுகிறது, எனவே அவற்றை ஈ.எம்-டாஷ்களுடன் மாற்ற இந்த செயல்பாட்டைப் பயன்படுத்தலாம்.

en: To create a new function, simply click the :guilabel:`Create/edit` button to create a new function and copy the Python code from below.
ta: ஒரு புதிய செயல்பாட்டை உருவாக்க, ஒரு புதிய செயல்பாட்டை உருவாக்க `உருவாக்கு/திருத்து` பொத்தானைக் கிளிக் செய்து, கீழே இருந்து பைதான் குறியீட்டை நகலெடுக்கவும்.

en: Every :guilabel:`Search & replace` custom function must have a unique name and consist of a Python function named replace, that accepts all the arguments shown above. For the moment, we won't worry about all the different arguments to ``replace()`` function. Just focus on the ``match`` argument. It represents a match when running a search and replace. Its full documentation in available `here <https://docs.python.org/library/re.html#match-objects>`_. ``match.group()`` simply returns all the matched text and all we do is replace hyphens in that text with em-dashes, first replacing double hyphens and then single hyphens.
ta: ஒவ்வொன்றும்: கிலாபெல்: `தேடல் மற்றும் மாற்றுதல்` தனிப்பயன் செயல்பாடு ஒரு தனித்துவமான பெயரைக் கொண்டிருக்க வேண்டும் மற்றும் மாற்றாக பெயரிடப்பட்ட பைதான் செயல்பாட்டைக் கொண்டிருக்க வேண்டும், இது மேலே காட்டப்பட்டுள்ள அனைத்து வாதங்களையும் ஏற்றுக்கொள்கிறது. இப்போதைக்கு, `` மாற்றவும் () `` செயல்பாட்டுக்கு வெவ்வேறு வாதங்களைப் பற்றி நாங்கள் கவலைப்பட மாட்டோம். `` மேட்ச்`` வாதத்தில் கவனம் செலுத்துங்கள். தேடலை இயக்கும் போது இது ஒரு போட்டியைக் குறிக்கிறது. கிடைக்கிறது `இங்கே <https://docs.python.org/library/re.html#match-objects>` _. `` மேட்ச். குழு () `` பொருந்திய அனைத்து உரையையும் வெறுமனே திருப்பித் தருகிறது, மேலும் நாம் செய்வதெல்லாம் அந்த உரையில் உள்ள ஹைபன்களை எம்-டாஷ்களுடன் மாற்றுவதோடு, முதலில் இரட்டை ஹைபன்கள் மற்றும் பின்னர் ஒற்றை ஹைபன்களை மாற்றும்.

en: Use this function with the find regular expression::
ta: வழக்கமான வெளிப்பாட்டைக் கண்டுபிடி இந்த செயல்பாட்டைப் பயன்படுத்தவும் ::

en: And it will replace all hyphens with em-dashes, but only in actual text and not inside HTML tag definitions.
ta: இது அனைத்து ஹைபன்களையும் எம்-டாஷ்களுடன் மாற்றும், ஆனால் உண்மையான உரையில் மட்டுமே மற்றும் HTML குறிச்சொல் வரையறைகளுக்குள் அல்ல.

en: The power of function mode - using a spelling dictionary to fix mis-hyphenated words
ta: செயல்பாட்டு பயன்முறையின் சக்தி - தவறான ஹைபனேட்டட் சொற்களை சரிசெய்ய எழுத்துப்பிழை அகராதியைப் பயன்படுத்துதல்

en: Often, e-books created from scans of printed books contain mis-hyphenated words -- words that were split at the end of the line on the printed page. We will write a simple function to automatically find and fix such words.
ta: பெரும்பாலும், அச்சிடப்பட்ட புத்தகங்களின் ஸ்கேன்களிலிருந்து உருவாக்கப்பட்ட மின் புத்தகங்களில் தவறான ஹைபனேட்டட் சொற்கள் உள்ளன-அச்சிடப்பட்ட பக்கத்தில் வரியின் முடிவில் பிரிக்கப்பட்ட சொற்கள். அத்தகைய சொற்களை தானாகவே கண்டுபிடித்து சரிசெய்ய ஒரு எளிய செயல்பாட்டை எழுதுவோம்.

en: Use this function with the same find expression as before, namely::
ta: இந்த செயல்பாட்டை முன்பு போலவே அதே கண்டுபிடிப்பு வெளிப்பாட்டுடன் பயன்படுத்தவும், அதாவது ::

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.
ta: மேலும் இது புத்தகத்தின் உரையில் உள்ள அனைத்து தவறான ஹைபனேட்டட் சொற்களையும் மாயமாக சரிசெய்யும். முக்கிய தந்திரம் என்னவென்றால், மாற்றும் செயல்பாட்டிற்கு பயனுள்ள கூடுதல் வாதங்களில் ஒன்றைப் பயன்படுத்துவது, `` அகராதிகள்``. இது புத்தகத்தில் உரையை சரிபார்க்க எடிட்டர் பயன்படுத்தும் அகராதிகளைக் குறிக்கிறது. இந்த செயல்பாடு என்னவென்றால், ஒரு ஹைபனால் பிரிக்கப்பட்ட சொற்களைத் தேடுவது, ஹைபனை அகற்றி, அகராதி கலப்பு வார்த்தையை அங்கீகரிக்கிறதா என்று சரிபார்க்கவும், அவ்வாறு செய்தால், அசல் சொற்கள் ஹைபன் இலவச கலப்பு வார்த்தையால் மாற்றப்படுகின்றன.

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.
ta: இந்த நுட்பத்தின் ஒரு வரம்பு இது மோனோ-மொழி புத்தகங்களுக்கு மட்டுமே வேலை செய்யும் என்பதை நினைவில் கொள்க, ஏனென்றால், இயல்பாக, `` அகராதிகள். அங்கீகரிக்கப்பட்ட () `` புத்தகத்தின் முக்கிய மொழியைப் பயன்படுத்துகின்றன.

en: Auto numbering sections
ta: ஆட்டோ எண் பிரிவுகள்

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>`.
ta: இப்போது நாம் கொஞ்சம் வித்தியாசமாக ஒன்றைக் காண்போம். உங்கள் HTML கோப்பில் பல பிரிவுகள் உள்ளன என்று வைத்துக்கொள்வோம், ஒவ்வொன்றும் ஒரு: குறியீட்டில்: `<h2>` போன்ற குறிச்சொல்: குறியீடு: `<h2> சில உரை </h2>`. தனிப்பயன் செயல்பாட்டை நீங்கள் உருவாக்கலாம், இது இந்த தலைப்புகளை தானாகவே தொடர்ச்சியான பிரிவு எண்களுடன் எண்ணும், இதனால் அவை போல இருக்கும்: குறியீடு: `<H2> 1. சில உரை </h2> `.

en: Use it with the find expression::
ta: கண்டுபிடி வெளிப்பாட்டுடன் இதைப் பயன்படுத்தவும் ::

en: Place the cursor at the top of the file and click :guilabel:`Replace all`.
ta: கோப்பின் மேற்புறத்தில் கர்சரை வைக்கவும், கிளிக் செய்யவும்: கிலாபெல்: `அனைத்தையும் மாற்றவும்`.

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.
ta: இந்த செயல்பாடு `` மாற்றவும் () ``: `` எண்`` வாதத்திற்கு பயனுள்ள கூடுதல் வாதங்களில் ஒன்றைப் பயன்படுத்துகிறது. ஒரு: கிலாபெல் செய்யும்போது: ஒவ்வொரு தொடர்ச்சியான போட்டிக்கும் அனைத்து எண்ணை மாற்றவும் தானாகவே அதிகரிக்கும்.

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.
ta: மற்றொரு புதிய அம்சம் `` `` fallace.file_order`` - `` 'முதுகெலும்பு'`` என்று அமைப்பது, இந்த தேடல் பல HTML கோப்புகளில் இயங்கினால், கோப்புகள் அவை தோன்றும் வரிசையில் செயலாக்கப்படுகின்றன புத்தகம். காண்க: குறிப்பு: விவரங்களுக்கு `file_order_replace_all`.

en: Auto create a Table of Contents
ta: தானாக உள்ளடக்க அட்டவணையை உருவாக்கவும்

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:
ta: இறுதியாக, இன்னும் கொஞ்சம் லட்சியத்தை முயற்சி செய்யலாம். உங்கள் புத்தகத்தில் `` H1`` மற்றும் `` H2`` குறிச்சொற்களில் தலைப்புகள் உள்ளன என்று வைத்துக்கொள்வோம், அவை `` <h1 id = "sneid"> சில உரை </h1> ``. இந்த தலைப்புகளின் அடிப்படையில் ஒரு HTML உள்ளடக்க அட்டவணையை தானாக உருவாக்குவோம். தனிப்பயன் செயல்பாட்டை கீழே உருவாக்கவும்:

en: And use it with the find expression::
ta: கண்டுபிடி வெளிப்பாட்டுடன் அதைப் பயன்படுத்தவும் ::

en: Run the search on :guilabel:`All text files` and at the end of the search, a window will popup with "Debug output from your function" which will have the HTML Table of Contents, ready to be pasted into :file:`toc.html`.
ta: தேடலை இயக்கவும்: கிலாபெல்: `அனைத்து உரை கோப்புகளும்` மற்றும் தேடலின் முடிவில், ஒரு சாளரம்" உங்கள் செயல்பாட்டிலிருந்து பிழைத்திருத்த வெளியீடு "உடன் பாப் அப் செய்யும், இது HTML உள்ளடக்க அட்டவணையைக் கொண்டிருக்கும், ஒட்டுவதற்கு தயாராக உள்ளது: கோப்பு:` toc.html`.

en: The function above is heavily commented, so it should be easy to follow. The key new feature is the use of another useful extra argument to the ``replace()`` function, the ``data`` object. The ``data`` object is a Python *dictionary* that persists between all successive invocations of ``replace()`` during a single :guilabel:`Replace All` operation.
ta: மேலே உள்ள செயல்பாடு பெரிதும் கருத்து தெரிவித்துள்ளது, எனவே அதைப் பின்பற்றுவது எளிதாக இருக்க வேண்டும். முக்கிய புதிய அம்சம் `` மாற்றவும் () `` செயல்பாடு, `` தரவு`` பொருளுக்கு மற்றொரு பயனுள்ள கூடுதல் வாதத்தைப் பயன்படுத்துவதாகும். `` தரவு`` பொருள் ஒரு பைதான் * அகராதி *, இது ஒரு தொடர்ச்சியான அனைத்து தொடர்ச்சியான அழைப்புகளுக்கும் இடையில் தொடர்கிறது (`மாற்றவும் ()` `ஒரு ஒற்றை போது: கிலாபெல்:` அனைத்து செயல்பாடுகளையும் மாற்றவும்.

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``.
ta: மற்றொரு புதிய அம்சம் `` gall_after_last_match`` - `` மாற்றவும் () `செயல்பாட்டில்` `உண்மை` ஆகியவற்றை அமைப்பது என்பது ஆசிரியர்` `மாற்றவும் ()` `எல்லாவற்றிற்கும் மேலாக ஒரு கூடுதல் நேரம் என்று அழைப்பார் என்று பொருள் போட்டிகள் கண்டுபிடிக்கப்பட்டுள்ளன. இந்த கூடுதல் அழைப்பிற்கு, போட்டி பொருள் `` எதுவுமில்லை`` இருக்கும்.

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`.
ta: இது செயல்பாட்டு பயன்முறையின் சக்தியைக் காண்பிப்பதற்கான ஒரு ஆர்ப்பாட்டமாகும், உங்கள் புத்தகத்தில் உள்ள தலைப்புகளிலிருந்து உள்ளடக்கங்களின் அட்டவணையை உருவாக்க உங்களுக்கு உண்மையிலேயே தேவைப்பட்டால், நீங்கள் உள்ளடக்கத்தின் அர்ப்பணிப்பு அட்டவணையைப் பயன்படுத்துவது நல்லது: கிலாபெல்: `கருவிகள்-> உள்ளடக்க அட்டவணை`.

en: The API for the function mode
ta: செயல்பாட்டு பயன்முறைக்கான ஏபிஐ

en: All function mode functions must be Python functions named replace, with the following signature::
ta: அனைத்து செயல்பாட்டு முறை செயல்பாடுகளும் பின்வரும் கையொப்பத்துடன் மாற்றப்பட்ட பைதான் செயல்பாடுகளாக இருக்க வேண்டும் ::

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.
ta: கண்டுபிடிக்கப்பட்ட ஒவ்வொரு போட்டிக்கும் ஒரு கண்டுபிடிப்பு/மாற்றீடு இயக்கப்படும்போது, `` மாற்றவும் () `` செயல்பாடு அழைக்கப்படும், அது அந்த போட்டிக்கான மாற்று சரத்தை திருப்பித் தர வேண்டும். மாற்றீடுகள் எதுவும் செய்யப்படாவிட்டால், அது `` மேட்ச். குழு () `` என்பது அசல் சரம். `` மாற்று () `` செயல்பாட்டிற்கான பல்வேறு வாதங்கள் கீழே ஆவணப்படுத்தப்பட்டுள்ளன.

en: The ``match`` argument
ta: `` போட்டி`` வாதம்

en: The ``match`` argument represents the currently found match. It is a `Python Match object <https://docs.python.org/library/re.html#match-objects>`_. Its most useful method is ``group()`` which can be used to get the matched text corresponding to individual capture groups in the search regular expression.
ta: `` மேட்ச்`` வாதம் தற்போது காணப்பட்ட போட்டியைக் குறிக்கிறது. இது ஒரு `பைதான் மேட்ச் பொருள் <https://docs.python.org/library/re.html#match-objects>` _. அதன் மிகவும் பயனுள்ள முறை `` குழு () `` ஆகும், இது தேடல் வழக்கமான வெளிப்பாட்டில் தனிப்பட்ட பிடிப்பு குழுக்களுடன் தொடர்புடைய பொருந்திய உரையைப் பெற பயன்படுத்தப்படலாம்.

en: The ``number`` argument
ta: `` எண்`` வாதம்

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.
ta: `` எண்`` வாதம் தற்போதைய போட்டியின் எண்ணிக்கை. நீங்கள் ஓடும்போது: கிலாபெல்: `அனைத்தையும் மாற்றவும்`, அடுத்தடுத்த ஒவ்வொரு போட்டியும்` `மாற்றவும் ()` `அதிகரிக்கும் எண்ணிக்கையுடன் அழைக்கப்பட வேண்டும். முதல் போட்டியில் எண் 1 உள்ளது.

en: The ``file_name`` argument
ta: `` File_name`` வாதம்

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.
ta: தற்போதைய போட்டி கண்டறியப்பட்ட கோப்பின் கோப்பு பெயர் இது. குறிக்கப்பட்ட உரைக்குள் தேடும்போது, `` file_name`` காலியாக உள்ளது. `` File_name`` ``/`` பாதை பிரிப்பானாகப் பயன்படுத்தும் புத்தகத்தின் மூலத்துடன் தொடர்புடைய ஒரு பாதையான நியமன வடிவத்தில் உள்ளது.

en: The ``metadata`` argument
ta: `` மெட்டாடேட்டா`` வாதம்

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).
ta: இது தலைப்பு, ஆசிரியர்கள், மொழி போன்ற தற்போதைய புத்தகத்தின் மெட்டாடேட்டாவைக் குறிக்கிறது. இது வர்க்கத்தின் பொருள்: வகுப்பு: `calibre.ebooks.metadata.book.base.metadata`. பயனுள்ள பண்புகளில், `` தலைப்பு``, `` ஆசிரியர்கள்`` (ஆசிரியர்களின் பட்டியல்) மற்றும் `` மொழி`` (மொழி குறியீடு) ஆகியவை அடங்கும்.

en: The ``dictionaries`` argument
ta: `` அகராதிகள்`` வாதம்

en: This represents the collection of dictionaries used for spell checking the current book. Its most useful method is ``dictionaries.recognized(word)`` which will return ``True`` if the passed in word is recognized by the dictionary for the current book's language.
ta: இது தற்போதைய புத்தகத்தை சரிபார்க்க எழுத்துப்பிழைக்கு பயன்படுத்தப்படும் அகராதிகளின் தொகுப்பைக் குறிக்கிறது. அதன் மிகவும் பயனுள்ள முறை `` அகராதிகள். அங்கீகரிக்கப்பட்ட (சொல்) `` இது தற்போதைய புத்தகத்தின் மொழிக்கான அகராதியால் வேர்டில் தேர்ச்சி பெற்றால் `` உண்மை`` திரும்பும்.

en: The ``data`` argument
ta: `` தரவு`` வாதம்

en: This a simple Python ``dictionary``. When you run :guilabel:`Replace all`, every successive match will cause ``replace()`` to be called with the same ``dictionary`` as data. You can thus use it to store arbitrary data between invocations of ``replace()`` during a :guilabel:`Replace all` operation.
ta: இது ஒரு எளிய பைதான் `` அகராதி``. நீங்கள் ஓடும்போது: கிலாபெல்: `அனைத்தையும் மாற்றவும்`, அடுத்தடுத்த ஒவ்வொரு போட்டியும் `` மாற்றவும் () `` அதே `` அகராதி`` தரவைப் போல அழைக்கப்பட வேண்டும். `` மாற்றவும் () `` ஒரு: கிலாபெல்: `அனைத்து செயல்பாடுகளையும் மாற்றவும்.

en: The ``functions`` argument
ta: `` செயல்பாடுகள்`` வாதம்

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:
ta: `` செயல்பாடுகள்`` வாதம் மற்ற அனைத்து பயனர் வரையறுக்கப்பட்ட செயல்பாடுகளையும் அணுகும். குறியீடு மறு பயன்பாட்டிற்கு இது பயனுள்ளதாக இருக்கும். பயன்பாட்டு செயல்பாடுகளை ஒரே இடத்தில் வரையறுக்கலாம் மற்றும் அவற்றை உங்கள் மற்ற எல்லா செயல்பாடுகளிலும் மீண்டும் பயன்படுத்தலாம். எடுத்துக்காட்டாக, நீங்கள் ஒரு செயல்பாட்டு பெயரை உருவாக்குகிறீர்கள் என்று வைத்துக்கொள்வோம் `` எனது செயல்பாடு`` இது போன்றவை:

en: Then, in another function, you can access the ``utility()`` function like this:
ta: பின்னர், மற்றொரு செயல்பாட்டில், நீங்கள் `` பயன்பாடு () `` இது போன்ற செயல்பாட்டை அணுகலாம்:

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:
ta: தொடர்ச்சியான தரவைச் சேமிக்க செயல்பாடுகள் பொருளையும் நீங்கள் பயன்படுத்தலாம், அவை பிற செயல்பாடுகளால் மீண்டும் பயன்படுத்தப்படலாம். எடுத்துக்காட்டாக, இயங்கும் போது நீங்கள் ஒரு செயல்பாட்டைக் கொண்டிருக்கலாம்: கிலாபெல்: `அனைத்தையும் மாற்றவும்` சில தரவுகளையும், பின்னர் இயங்கும் போது அதைப் பயன்படுத்தும் மற்றொரு செயல்பாட்டையும் சேகரிக்கிறது. பின்வரும் இரண்டு செயல்பாடுகளைக் கவனியுங்கள்:

en: Debugging your functions
ta: உங்கள் செயல்பாடுகளை பிழைத்திருத்துகிறது

en: You can debug the functions you create by using the standard ``print()`` function from Python. The output of print will be displayed in a popup window after the Find/replace has completed. You saw an example of using ``print()`` to output an entire table of contents above.
ta: பைத்தானில் இருந்து நிலையான `` அச்சு () `` செயல்பாட்டைப் பயன்படுத்தி நீங்கள் உருவாக்கும் செயல்பாடுகளை பிழைத்திருத்தலாம். கண்டுபிடிப்பு/மாற்றப்பட்ட பிறகு அச்சின் வெளியீடு பாப்அப் சாளரத்தில் காண்பிக்கப்படும். மேலே உள்ள உள்ளடக்கங்களின் முழு அட்டவணையை வெளியிட `` அச்சு () `` பயன்படுத்துவதற்கான உதாரணத்தை நீங்கள் பார்த்தீர்கள்.

en: Choose file order when running on multiple HTML files
ta: பல HTML கோப்புகளில் இயங்கும் போது கோப்பு வரிசையைத் தேர்வுசெய்க

en: When you run a :guilabel:`Replace all` on multiple HTML files, the order in which the files are processes depends on what files you have open for editing. You can force the search to process files in the order in which the appear by setting the ``file_order`` attribute on your function, like this:
ta: நீங்கள் ஒரு: கிலாபெல்: `பல HTML கோப்புகளில் அனைத்தையும் மாற்றவும், கோப்புகள் செயல்முறைகள் இருக்கும் வரிசையில் நீங்கள் திருத்துவதற்கு எந்த கோப்புகளை வைத்திருக்கிறீர்கள் என்பதைப் பொறுத்தது. இது போன்ற உங்கள் செயல்பாட்டில் `` `file_order`` பண்புகளை அமைப்பதன் மூலம் தோன்றும் வரிசையில் கோப்புகளை செயலாக்க தேடலை நீங்கள் கட்டாயப்படுத்தலாம்:

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.
ta: `` file_order`` இரண்டு மதிப்புகளை ஏற்றுக்கொள்கிறது, `` முதுகெலும்பு`` மற்றும் `` முதுகெலும்பு-தலைகீழ்``, இது முறையே புத்தகத்தில் தோன்றும் வரிசையில் பல கோப்புகளை செயலாக்குகிறது, முறையே முன்னோக்கி அல்லது பின்னோக்கி.

en: Having your function called an extra time after the last match is found
ta: கடைசி போட்டி கண்டுபிடிக்கப்பட்ட பிறகு உங்கள் செயல்பாடு கூடுதல் நேரம் என்று அழைக்கப்படுகிறது

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:
ta: சில நேரங்களில், மேலே உள்ள உள்ளடக்கங்களின் உதாரணத்தில் ஆட்டோ உருவாக்கும் அட்டவணையைப் போலவே, கடைசி போட்டி கண்டுபிடிக்கப்பட்ட பிறகு உங்கள் செயல்பாடு கூடுதல் நேரம் என்று அழைக்கப்படுவது பயனுள்ளதாக இருக்கும். இது போன்ற உங்கள் செயல்பாட்டில் `` call_after_last_match`` பண்புகளை அமைப்பதன் மூலம் இதைச் செய்யலாம்:

en: Appending the output from the function to marked text
ta: செயல்பாட்டிலிருந்து குறிக்கப்பட்ட உரையில் வெளியீட்டைச் சேர்க்கிறது

en: When running search and replace on marked text, it is sometimes useful to append so text to the end of the marked text. You can do that by setting the ``append_final_output_to_marked`` attribute on your function (note that you also need to set ``call_after_last_match``), like this:
ta: குறிக்கப்பட்ட உரையில் தேடலை இயக்கி மாற்றும்போது, சில நேரங்களில் அதைச் செய்வது பயனுள்ளதாக இருக்கும், எனவே குறிக்கப்பட்ட உரையின் முடிவில் உரை செய்யவும். உங்கள் செயல்பாட்டில் `` append_final_output_to_marked`` பண்புகளை அமைப்பதன் மூலம் நீங்கள் அதைச் செய்யலாம் (நீங்கள் `` Call_after_last_match`` ஐ அமைக்க வேண்டும் என்பதை நினைவில் கொள்க):

en: Suppressing the result dialog when performing searches on marked text
ta: குறிக்கப்பட்ட உரையில் தேடல்களைச் செய்யும்போது முடிவு உரையாடலை அடக்குதல்

en: You can also suppress the result dialog (which can slow down the repeated application of a search/replace on many blocks of text) by setting the ``suppress_result_dialog`` attribute on your function, like this:
ta: இது போன்ற உங்கள் செயல்பாட்டில் `` அடக்கி_ரெஸ்யூல்ட்_டியாலாக்`` பண்புகளை அமைப்பதன் மூலம் முடிவு உரையாடலை (இது பல தொகுதிகளில் ஒரு தேடல்/மாற்றத்தை மெதுவாக்கும்) அடக்கலாம்:

en: More examples
ta: மேலும் எடுத்துக்காட்டுகள்

en: More useful examples, contributed by calibre users, can be found in the `calibre E-book editor forum <https://www.mobileread.com/forums/showthread.php?t=237181>`_.
ta: காலிபர் பயனர்களால் பங்களிக்கப்பட்ட மிகவும் பயனுள்ள எடுத்துக்காட்டுகள், `காலிபர் மின் புத்தக எடிட்டர் மன்றத்தில் <https://www.mobileered.com/forums/showthread.php?t=237181>` _.
