calibre - en to ta translation catalogue (24 entries)

en: XPath tutorial
ta:  ஃபாதை பயிற்சி

en: In this tutorial, you will be given a gentle introduction to `XPath <https://en.wikipedia.org/wiki/XPath>`_, a query language that can be used to select arbitrary parts of `HTML <https://en.wikipedia.org/wiki/HTML>`_ documents in calibre. XPath is a widely used standard, and googling it will yield a ton of information. This tutorial, however, focuses on using XPath for e-book related tasks like finding chapter headings in an unstructured HTML document.
ta: இந்தத் தனிக்கற்கையில், உங்களுக்கு `ஃபாதை <https://en.wikipedia.org/wiki/XPath>`_  ஆவணங்கள் திறனில் `உஉகுமொ <https://en.wikipedia.org/wiki/HTML>`_ இன் தன்னிச்சையான பகுதிகளைத் தேர்ந்தெடுக்கப் பயன்படும் வினவல் மொழி உங்களுக்கு ஒரு மென்மையான அறிமுகம் வழங்கப்படும். ஃபாதை என்பது பரவலாகப் பயன்படுத்தப்படும் தரமாகும், மேலும் இது ஒரு டன் தகவல்களைத் தரும். எவ்வாறாயினும், இந்தத் தனிக்கற்கையில், கட்டமைக்கப்படாத உஉகுமொ ஆவணத்தில் பாட தலைப்புகளைக் கண்டுபிடிப்பது போன்ற மின்-புத்தகம் தொடர்பான பணிகளுக்கு ஃபாதையைப் பயன்படுத்துவதில் கவனம் செலுத்துகிறது.

en: Contents
ta: உள்ளடக்கங்கள்

en: Selecting by tag name
ta: குறிச்சொல் பெயரால் தேர்வு

en: The simplest form of selection is to select tags by name. For example, suppose you want to select all the ``<h2>`` tags in a document. The XPath query for this is simply::
ta: தேர்வின் எளிய வடிவம் குறிச்சொற்களைப் பெயரால் தேர்ந்தெடுப்பதாகும். எடுத்துக்காட்டாக, ஒரு ஆவணத்தில் உள்ள அனைத்து ``<h2>`` குறிச்சொற்களையும் தேர்ந்தெடுக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். இதற்கான ஃபாதை வினவல் வெறுமனே::

en: The prefix `//` means *search at any level of the document*. Now suppose you want to search for ``<span>`` tags that are inside ``<a>`` tags. That can be achieved with::
ta: முன்னொட்டு `//` என்றால் *ஆவணத்தின் எந்த மட்டத்திலும் தேடல்*. இப்போது நீங்கள் ``<a>`` குறிச்சொற்களுக்குள் இருக்கும் ``<span>`` குறிச்சொற்களைத் தேட விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். அதை இதன்மூலம் அடையலாம்::

en: If you want to search for tags at a particular level in the document, change the prefix::
ta: ஆவணத்தில் ஒரு குறிப்பிட்ட மட்டத்தில் குறிச்சொற்களைத் தேட விரும்பினால், முன்னொட்டை மாற்றவும் ::

en: This will match only ``<p>A very short e-book to demonstrate the use of XPath.</p>`` in the :ref:`sample_ebook` but not any of the other ``<p>`` tags. The ``h:`` prefix in the above examples is needed to match XHTML tags. This is because internally, calibre represents all content as XHTML. In XHTML tags have a *namespace*, and ``h:`` is the namespace prefix for HTML tags.
ta: இது ``<p>ஃபாதையின் பயன்பாட்டை நிரூபிக்க மிகக் குறுகிய மின்-புத்தகத்தை மட்டுமே பொருத்தும்.</p>`` :குறி:`எடுத்துகாட்டு_மின்புத்தகம்` இல் உள்ளது மட்டும் வேறு எந்தக் ``<p>`` குறிச்சொற்களும் இல்லை. நீஉஉகுமொ குறிச்சொற்களைப் பொருத்த மேலே உள்ள எடுத்துக்காட்டுகளில் ``த: `` முன்னொட்டு தேவை. ஏனென்றால், உள்ளகத்தில், திறன் அனைத்து உள்ளடக்கங்களையும் நீஉஉகுமொ எனக் குறிக்கிறது. நீஉஉகுமொ குறிச்சொற்களில் *பெயர்வெளி* உள்ளது, மற்றும் ``த:`` என்பது உஉகுமொ குறிச்சொற்களுக்கான பெயர்வெளி முன்னொட்டு.

en: Now suppose you want to select both ``<h1>`` and ``<h2>`` tags. To do that, we need a XPath construct called *predicate*. A :dfn:`predicate` is simply a test that is used to select tags. Tests can be arbitrarily powerful and as this tutorial progresses, you will see more powerful examples. A predicate is created by enclosing the test expression in square brackets::
ta: இப்போது நீங்கள் ``<h1>`` மற்றும் ``<h2>`` குறிச்சொற்கள் இரண்டையும் தேர்ந்தெடுக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். அதைச் செய்ய, நமக்கு *முன்கணிப்பு *எனப்படும் ஃபாதை கட்டுமானம் தேவை. ஒரு :வரையறை:`முன்னறிவிப்பு` என்பது குறிச்சொற்களைத் தேர்ந்தெடுக்கப் பயன்படும் ஒரு சோதனை. சோதனைகள் தன்னிச்சையாகப் பலமானதாக இருக்கலாம், மேலும் இந்தப் பயிற்சி முன்னேறும்போது, நீங்கள் மிகவும் பலமான எடுத்துக்காட்டுகளைக் காண்பீர்கள். சோதனை வெளிப்பாட்டைச் சதுர அடைப்புக்குறிக்குள் இணைப்பதன் மூலம் ஒரு முன்கணிப்பு உருவாக்கப்படுகிறது::

en: There are several new features in this XPath expression. The first is the use of the wildcard ``*``. It means *match any tag*. Now look at the test expression ``name()='h1' or name()='h2'``. :term:`name()` is an example of a *built-in function*. It simply evaluates to the name of the tag. So by using it, we can select tags whose names are either `h1` or `h2`. Note that the :term:`name()` function ignores namespaces so that there is no need for the ``h:`` prefix. XPath has several useful built-in functions. A few more will be introduced in this tutorial.
ta: இந்த ஃபாதை வெளிப்பாட்டில் பல புதிய நற்பொருத்தங்கள் உள்ளன. முதலாவது காட்டுஅட்டையின் பயன்பாடு ``*``. இதன் பொருள் *எந்தக் குறிச்சொல்லுடன் பொருந்துகிறது*. இப்போது சோதனை வெளிப்பாடு `` பெயர்()='த1' அல்லது பெயர்()='த2'``. :கால:`பெயர்()` என்பது *உள்ளமைக்கப்பட்ட செயல்பாட்டின் ஒரு எடுத்துக்காட்டு*. இது வெறுமனே குறிச்சொல்லின் பெயரை மதிப்பீடு செய்கிறது. எனவே அதைப் பயன்படுத்துவதன் மூலம், `த1` அல்லது `த2` என்ற பெயர்கள் குறிச்சொற்களைத் தேர்ந்தெடுக்கலாம். :கால:`பெயர்()` செயல்பாடு பெயர்வெளிகளைப் புறக்கணிக்கிறது, இதனால் ``த:`` முன்னொட்டு தேவையில்லை. ஃபாதை பல பயனுள்ள உள்ளமைக்கப்பட்ட செயல்பாடுகளைக் கொண்டுள்ளது. இந்தத் தனிக்கற்கையில் இன்னும் சில அறிமுகப்படுத்தப்படும்.

en: Selecting by attributes
ta: பண்புகளால் தேர்ந்தெடுப்பது

en: To select tags based on their attributes, the use of predicates is required::
ta: அவற்றின் பண்புகளின் அடிப்படையில் குறிச்சொற்களைத் தேர்ந்தெடுக்க, கணிப்புகளின் பயன்பாடு தேவை::

en: Here, the ``@`` operator refers to the attributes of the tag. You can use some of the `XPath built-in functions`_ to perform more sophisticated matching on attribute values.
ta: இங்கே, ``@`` செயற்குறி குறிச்சொல்லின் பண்புகளைக் குறிக்கிறது. பண்புக்கூறு மதிப்புகளில் புதிய பொருத்தத்தை செய்ய நீங்கள் `ஃபாதை உள்ளமைக்கப்பட்ட செயல்பாடுகள்`_ ஐப் பயன்படுத்தலாம்.

en: Selecting by tag content
ta: குறிச்சொல் உள்ளடக்கத்தால் தேர்ந்தெடுக்கிறது

en: Using XPath, you can even select tags based on the text they contain. The best way to do this is to use the power of *regular expressions* via the built-in function :term:`re:test()`::
ta: ஃபாதையைப் பயன்படுத்தி, அவற்றில் உள்ள உரையின் அடிப்படையில் குறிச்சொற்களைத் தேர்ந்தெடுக்கலாம். இதைச் செய்வதற்கான சிறந்த வழி, உள்ளமைக்கப்பட்ட செயல்பாடு வழியாக *வழக்கமான வெளிப்பாடுகளின்* பலத்தைப் பயன்படுத்துவதாகும் :சொல்:`வவெ:சோதனை()`::

en: Here the ``.`` operator refers to the contents of the tag, just as the ``@`` operator referred to its attributes.
ta: இங்கே ``.`` செயற்குறி குறிச்சொல்லின் உள்ளடக்கங்களைக் குறிக்கிறது, ``@`` செயற்குறி அதன் பண்புகளைக் குறிப்பிடுவது போல.

en: Sample e-book
ta: மாதிரி மின் புத்தகம்

en: XPath built-in functions
ta: ஃபாதை உள்ளமைக்கப்பட்ட செயல்பாடுகள்

en: name()
ta: பெயர்()

en: The name of the current tag.
ta: தற்போதைய குறிச்சொல்லின் பெயர்.

en: contains()
ta: கொண்டுள்ளது()

en: ``contains(s1, s2)`` returns `true` if s1 contains s2.
ta: ``கொண்டுள்ளது(ச1, ச2)`` ச1 ச2 ஐக் கொண்டிருந்தால் `உண்மை` திரும்பும்.

en: re:test()
ta: வவெ:சோதனை()

en: ``re:test(src, pattern, flags)`` returns `true` if the string `src` matches the regular expression `pattern`. A particularly useful flag is ``i``, it makes matching case insensitive. A good primer on the syntax for regular expressions can be found at `regexp syntax <https://docs.python.org/library/re.html>`_
ta: ``வவெ:சோதனை (மூலம், வடிவம், கொடிகள்)`` `மூலம்` என்ற சரம் வழக்கமான வெளிப்பாட்டுடன் `வடிவத்துடன்` பொருந்தினால் `உண்மை` திரும்பும். குறிப்பாகப் பயனுள்ள கொடி ``ஐ``, இது பொருந்தக்கூடிய வழக்கை உணர்ச்சியற்றதாக ஆக்குகிறது. வழக்கமான வெளிப்பாடுகளுக்கான தொடரியல் ஒரு நல்ல அரிச்சுவடி `வழக்கவெளி தொடரியல் <https://docs.python.org/library/re.html>`_
