தேடலுக்கான செயல்பாட்டு முறை மற்றும் மாற்றத்திற்கான செயல்பாடு முறை¶

தி: கிலாபெல்: எடிட்டரில் தேடல் மற்றும் மாற்றவும் கருவி ஒரு *செயல்பாட்டு பயன்முறையை *ஆதரிக்கவும். இந்த பயன்முறையில், எல்லா வகையான மேம்பட்ட உரை செயலாக்கத்தையும் செய்ய தன்னிச்சையாக சக்திவாய்ந்த பைதான் செயல்பாடுகளுடன் வழக்கமான வெளிப்பாடுகளை (DOC: Regexp) இணைக்கலாம்.

தேடல் மற்றும் மாற்றத்திற்கான நிலையான * Regexp * பயன்முறையில், தேடுவதற்கான வழக்கமான வெளிப்பாடு இரண்டையும் நீங்கள் குறிப்பிடுகிறீர்கள், அத்துடன் காணப்படும் அனைத்து போட்டிகளையும் மாற்றுவதற்குப் பயன்படுத்தப்படும் ஒரு வார்ப்புரு. செயல்பாட்டு பயன்முறையில், ஒரு நிலையான வார்ப்புருவைப் பயன்படுத்துவதற்குப் பதிலாக, `பைதான் நிரலாக்க மொழியில் <https://docs.python.org> _ _ இல் ஒரு தன்னிச்சையான செயல்பாட்டைக் குறிப்பிடுகிறீர்கள். எளிய வார்ப்புருக்கள் மூலம் சாத்தியமில்லாத பல விஷயங்களைச் செய்ய இது உங்களை அனுமதிக்கிறது.

செயல்பாட்டு பயன்முறை மற்றும் தொடரியல் ஆகியவற்றைப் பயன்படுத்துவதற்கான நுட்பங்கள் எடுத்துக்காட்டுகள் மூலம் விவரிக்கப்படும், இது படிப்படியாக மிகவும் சிக்கலான பணிகளைச் செய்வதற்கான செயல்பாடுகளை எவ்வாறு உருவாக்குவது என்பதைக் காட்டுகிறது.

ஆவணத்தில் உள்ள தலைப்புகளின் வழக்கை தானாக சரிசெய்தல்¶

இங்கே, எடிட்டரில் உள்ள பில்டின் செயல்பாடுகளில் ஒன்றை நாங்கள் பயன்படுத்துவோம், எல்லா உரையும் தலைப்பு குறிச்சொற்களை தலைப்பு வழக்குக்கு மாற்றுவோம்

Find expression: <([Hh][1-6])[^>]*>.+?</\1>

செயல்பாட்டிற்கு, வெறுமனே: கிலாபெல்: தலைப்பு-வழக்கு உரை (குறிச்சொற்களை புறக்கணிக்கவும்) பில்டின் செயல்பாடு என்பதைத் தேர்வுசெய்க. இதுபோன்ற தலைப்புகளை மாற்றும்: `` <H1> சில தலைப்பு </h1> `` முதல் `` <H1> சில தலைப்பு </h1> ``. தலைப்பு குறிச்சொற்களுக்குள் வேறு HTML குறிச்சொற்கள் இருந்தாலும் அது வேலை செய்யும்.

உங்கள் முதல் தனிப்பயன் செயல்பாடு - ஸ்மார்டிங் ஹைபன்கள்¶

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

ஒரு புதிய செயல்பாட்டை உருவாக்க, ஒரு புதிய செயல்பாட்டை உருவாக்க உருவாக்கு/திருத்து பொத்தானைக் கிளிக் செய்து, கீழே இருந்து பைதான் குறியீட்டை நகலெடுக்கவும்.

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    return match.group().replace('--', '—').replace('-', '—')

ஒவ்வொன்றும்: கிலாபெல்: தேடல் மற்றும் மாற்றுதல் தனிப்பயன் செயல்பாடு ஒரு தனித்துவமான பெயரைக் கொண்டிருக்க வேண்டும் மற்றும் மாற்றாக பெயரிடப்பட்ட பைதான் செயல்பாட்டைக் கொண்டிருக்க வேண்டும், இது மேலே காட்டப்பட்டுள்ள அனைத்து வாதங்களையும் ஏற்றுக்கொள்கிறது. இப்போதைக்கு, `` மாற்றவும் () `` செயல்பாட்டுக்கு வெவ்வேறு வாதங்களைப் பற்றி நாங்கள் கவலைப்பட மாட்டோம். `` மேட்ச்`` வாதத்தில் கவனம் செலுத்துங்கள். தேடலை இயக்கும் போது இது ஒரு போட்டியைக் குறிக்கிறது. கிடைக்கிறது இங்கே <https://docs.python.org/library/re.html#match-objects> _. `` மேட்ச். குழு () `` பொருந்திய அனைத்து உரையையும் வெறுமனே திருப்பித் தருகிறது, மேலும் நாம் செய்வதெல்லாம் அந்த உரையில் உள்ள ஹைபன்களை எம்-டாஷ்களுடன் மாற்றுவதோடு, முதலில் இரட்டை ஹைபன்கள் மற்றும் பின்னர் ஒற்றை ஹைபன்களை மாற்றும்.

வழக்கமான வெளிப்பாட்டைக் கண்டுபிடி இந்த செயல்பாட்டைப் பயன்படுத்தவும்

>[^<>]+<

இது அனைத்து ஹைபன்களையும் எம்-டாஷ்களுடன் மாற்றும், ஆனால் உண்மையான உரையில் மட்டுமே மற்றும் HTML குறிச்சொல் வரையறைகளுக்குள் அல்ல.

செயல்பாட்டு பயன்முறையின் சக்தி - தவறான ஹைபனேட்டட் சொற்களை சரிசெய்ய எழுத்துப்பிழை அகராதியைப் பயன்படுத்துதல்¶

பெரும்பாலும், அச்சிடப்பட்ட புத்தகங்களின் ஸ்கேன்களிலிருந்து உருவாக்கப்பட்ட மின் புத்தகங்களில் தவறான ஹைபனேட்டட் சொற்கள் உள்ளன-அச்சிடப்பட்ட பக்கத்தில் வரியின் முடிவில் பிரிக்கப்பட்ட சொற்கள். அத்தகைய சொற்களை தானாகவே கண்டுபிடித்து சரிசெய்ய ஒரு எளிய செயல்பாட்டை எழுதுவோம்.

import regex
from calibre import replace_entities
from calibre import prepare_string_for_xml

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):

    def replace_word(wmatch):
        # Try to remove the hyphen and replace the words if the resulting
        # hyphen free word is recognized by the dictionary
        without_hyphen = wmatch.group(1) + wmatch.group(2)
        if dictionaries.recognized(without_hyphen):
            return without_hyphen
        return wmatch.group()

    # Search for words split by a hyphen
    text = replace_entities(match.group()[1:-1])  # Handle HTML entities like &amp;
    corrected = regex.sub(r'(\w+)\s*-\s*(\w+)', replace_word, text, flags=regex.VERSION1 | regex.UNICODE)
    return '>%s<' % prepare_string_for_xml(corrected)  # Put back required entities

இந்த செயல்பாட்டை முன்பு போலவே அதே கண்டுபிடிப்பு வெளிப்பாட்டுடன் பயன்படுத்தவும், அதாவது

>[^<>]+<

மேலும் இது புத்தகத்தின் உரையில் உள்ள அனைத்து தவறான ஹைபனேட்டட் சொற்களையும் மாயமாக சரிசெய்யும். முக்கிய தந்திரம் என்னவென்றால், மாற்றும் செயல்பாட்டிற்கு பயனுள்ள கூடுதல் வாதங்களில் ஒன்றைப் பயன்படுத்துவது, `` அகராதிகள்``. இது புத்தகத்தில் உரையை சரிபார்க்க எடிட்டர் பயன்படுத்தும் அகராதிகளைக் குறிக்கிறது. இந்த செயல்பாடு என்னவென்றால், ஒரு ஹைபனால் பிரிக்கப்பட்ட சொற்களைத் தேடுவது, ஹைபனை அகற்றி, அகராதி கலப்பு வார்த்தையை அங்கீகரிக்கிறதா என்று சரிபார்க்கவும், அவ்வாறு செய்தால், அசல் சொற்கள் ஹைபன் இலவச கலப்பு வார்த்தையால் மாற்றப்படுகின்றன.

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

ஆட்டோ எண் பிரிவுகள்¶

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

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    section_number = '%d. ' % number
    return match.group(1) + section_number + match.group(2)

# Ensure that when running over multiple files, the files are processed
# in the order in which they appear in the book
replace.file_order = 'spine'

கண்டுபிடி வெளிப்பாட்டுடன் இதைப் பயன்படுத்தவும்

(?s)(<h2[^<>]*>)(.+?</h2>)

கோப்பின் மேற்புறத்தில் கர்சரை வைக்கவும், கிளிக் செய்யவும்: கிலாபெல்: அனைத்தையும் மாற்றவும்.

இந்த செயல்பாடு `` மாற்றவும் () : `` எண் வாதத்திற்கு பயனுள்ள கூடுதல் வாதங்களில் ஒன்றைப் பயன்படுத்துகிறது. ஒரு: கிலாபெல் செய்யும்போது: ஒவ்வொரு தொடர்ச்சியான போட்டிக்கும் அனைத்து எண்ணை மாற்றவும் தானாகவே அதிகரிக்கும்.

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

தானாக உள்ளடக்க அட்டவணையை உருவாக்கவும்¶

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

from calibre import replace_entities
from calibre.ebooks.oeb.polish.toc import TOC, toc_to_html
from calibre.gui2.tweak_book import current_container
from calibre.ebooks.oeb.base import xml2str

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    if match is None:
        # All matches found, output the resulting Table of Contents.
        # The argument metadata is the metadata of the book being edited
        if 'toc' in data:
            toc = data['toc']
            root = TOC()
            for (file_name, tag_name, anchor, text) in toc:
                parent = root.children[-1] if tag_name == 'h2' and root.children else root
                parent.add(text, file_name, anchor)
            toc = toc_to_html(root, current_container(), 'toc.html', 'Table of Contents for ' + metadata.title, metadata.language)
            print(xml2str(toc))
        else:
            print('No headings to build ToC from found')
    else:
        # Add an entry corresponding to this match to the Table of Contents
        if 'toc' not in data:
            # The entries are stored in the data object, which will persist
            # for all invocations of this function during a 'Replace All' operation
            data['toc'] = []
        tag_name, anchor, text = match.group(1), replace_entities(match.group(2)), replace_entities(match.group(3))
        data['toc'].append((file_name, tag_name, anchor, text))
        return match.group()  # We don't want to make any actual changes, so return the original matched text

# Ensure that we are called once after the last match is found so we can
# output the ToC
replace.call_after_last_match = True
# Ensure that when running over multiple files, this function is called,
# the files are processed in the order in which they appear in the book
replace.file_order = 'spine'

கண்டுபிடி வெளிப்பாட்டுடன் அதைப் பயன்படுத்தவும்

<(h[12]) [^<>]* id=['"]([^'"]+)['"][^<>]*>([^<>]+)

தேடலை இயக்கவும்: கிலாபெல்: அனைத்து உரை கோப்புகளும் மற்றும் தேடலின் முடிவில், ஒரு சாளரம்" உங்கள் செயல்பாட்டிலிருந்து பிழைத்திருத்த வெளியீடு "உடன் பாப் அப் செய்யும், இது HTML உள்ளடக்க அட்டவணையைக் கொண்டிருக்கும், ஒட்டுவதற்கு தயாராக உள்ளது: கோப்பு:` toc.html`.

மேலே உள்ள செயல்பாடு பெரிதும் கருத்து தெரிவித்துள்ளது, எனவே அதைப் பின்பற்றுவது எளிதாக இருக்க வேண்டும். முக்கிய புதிய அம்சம் `` மாற்றவும் () `` செயல்பாடு, `` தரவு`` பொருளுக்கு மற்றொரு பயனுள்ள கூடுதல் வாதத்தைப் பயன்படுத்துவதாகும். `` தரவு`` பொருள் ஒரு பைதான் * அகராதி *, இது ஒரு தொடர்ச்சியான அனைத்து தொடர்ச்சியான அழைப்புகளுக்கும் இடையில் தொடர்கிறது (மாற்றவும் () ஒரு ஒற்றை போது: கிலாபெல்: அனைத்து செயல்பாடுகளையும் மாற்றவும்.

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

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

செயல்பாட்டு பயன்முறைக்கான ஏபிஐ¶

அனைத்து செயல்பாட்டு முறை செயல்பாடுகளும் பின்வரும் கையொப்பத்துடன் மாற்றப்பட்ட பைதான் செயல்பாடுகளாக இருக்க வேண்டும்

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    return a_string

கண்டுபிடிக்கப்பட்ட ஒவ்வொரு போட்டிக்கும் ஒரு கண்டுபிடிப்பு/மாற்றீடு இயக்கப்படும்போது, `` மாற்றவும் () `` செயல்பாடு அழைக்கப்படும், அது அந்த போட்டிக்கான மாற்று சரத்தை திருப்பித் தர வேண்டும். மாற்றீடுகள் எதுவும் செய்யப்படாவிட்டால், அது `` மேட்ச். குழு () `` என்பது அசல் சரம். `` மாற்று () `` செயல்பாட்டிற்கான பல்வேறு வாதங்கள் கீழே ஆவணப்படுத்தப்பட்டுள்ளன.

`` போட்டி`` வாதம்¶

`` மேட்ச்`` வாதம் தற்போது காணப்பட்ட போட்டியைக் குறிக்கிறது. இது ஒரு பைதான் மேட்ச் பொருள் <https://docs.python.org/library/re.html#match-objects> _. அதன் மிகவும் பயனுள்ள முறை `` குழு () `` ஆகும், இது தேடல் வழக்கமான வெளிப்பாட்டில் தனிப்பட்ட பிடிப்பு குழுக்களுடன் தொடர்புடைய பொருந்திய உரையைப் பெற பயன்படுத்தப்படலாம்.

`` எண்`` வாதம்¶

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

`` File_name`` வாதம்¶

தற்போதைய போட்டி கண்டறியப்பட்ட கோப்பின் கோப்பு பெயர் இது. குறிக்கப்பட்ட உரைக்குள் தேடும்போது, `` file_name`` காலியாக உள்ளது. `` File_name`` / பாதை பிரிப்பானாகப் பயன்படுத்தும் புத்தகத்தின் மூலத்துடன் தொடர்புடைய ஒரு பாதையான நியமன வடிவத்தில் உள்ளது.

`` மெட்டாடேட்டா`` வாதம்¶

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

`` அகராதிகள்`` வாதம்¶

இது தற்போதைய புத்தகத்தை சரிபார்க்க எழுத்துப்பிழைக்கு பயன்படுத்தப்படும் அகராதிகளின் தொகுப்பைக் குறிக்கிறது. அதன் மிகவும் பயனுள்ள முறை `` அகராதிகள். அங்கீகரிக்கப்பட்ட (சொல்) `` இது தற்போதைய புத்தகத்தின் மொழிக்கான அகராதியால் வேர்டில் தேர்ச்சி பெற்றால் `` உண்மை`` திரும்பும்.

`` தரவு`` வாதம்¶

இது ஒரு எளிய பைதான் `` அகராதி``. நீங்கள் ஓடும்போது: கிலாபெல்: அனைத்தையும் மாற்றவும், அடுத்தடுத்த ஒவ்வொரு போட்டியும் `` மாற்றவும் () `` அதே `` அகராதி`` தரவைப் போல அழைக்கப்பட வேண்டும். `` மாற்றவும் () `` ஒரு: கிலாபெல்: `அனைத்து செயல்பாடுகளையும் மாற்றவும்.

`` செயல்பாடுகள்`` வாதம்¶

`` செயல்பாடுகள்`` வாதம் மற்ற அனைத்து பயனர் வரையறுக்கப்பட்ட செயல்பாடுகளையும் அணுகும். குறியீடு மறு பயன்பாட்டிற்கு இது பயனுள்ளதாக இருக்கும். பயன்பாட்டு செயல்பாடுகளை ஒரே இடத்தில் வரையறுக்கலாம் மற்றும் அவற்றை உங்கள் மற்ற எல்லா செயல்பாடுகளிலும் மீண்டும் பயன்படுத்தலாம். எடுத்துக்காட்டாக, நீங்கள் ஒரு செயல்பாட்டு பெயரை உருவாக்குகிறீர்கள் என்று வைத்துக்கொள்வோம் `` எனது செயல்பாடு`` இது போன்றவை:

def utility():
   # do something

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    ...

பின்னர், மற்றொரு செயல்பாட்டில், நீங்கள் `` பயன்பாடு () `` இது போன்ற செயல்பாட்டை அணுகலாம்:

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    utility = functions['My Function']['utility']
    ...

தொடர்ச்சியான தரவைச் சேமிக்க செயல்பாடுகள் பொருளையும் நீங்கள் பயன்படுத்தலாம், அவை பிற செயல்பாடுகளால் மீண்டும் பயன்படுத்தப்படலாம். எடுத்துக்காட்டாக, இயங்கும் போது நீங்கள் ஒரு செயல்பாட்டைக் கொண்டிருக்கலாம்: கிலாபெல்: அனைத்தையும் மாற்றவும் சில தரவுகளையும், பின்னர் இயங்கும் போது அதைப் பயன்படுத்தும் மற்றொரு செயல்பாட்டையும் சேகரிக்கிறது. பின்வரும் இரண்டு செயல்பாடுகளைக் கவனியுங்கள்:

# Function One
persistent_data = {}

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    ...
    persistent_data['something'] = 'some data'

# Function Two
def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    persistent_data = functions['Function One']['persistent_data']
    ...

உங்கள் செயல்பாடுகளை பிழைத்திருத்துகிறது¶

பைத்தானில் இருந்து நிலையான `` அச்சு () `` செயல்பாட்டைப் பயன்படுத்தி நீங்கள் உருவாக்கும் செயல்பாடுகளை பிழைத்திருத்தலாம். கண்டுபிடிப்பு/மாற்றப்பட்ட பிறகு அச்சின் வெளியீடு பாப்அப் சாளரத்தில் காண்பிக்கப்படும். மேலே உள்ள உள்ளடக்கங்களின் முழு அட்டவணையை வெளியிட `` அச்சு () `` பயன்படுத்துவதற்கான உதாரணத்தை நீங்கள் பார்த்தீர்கள்.

பல HTML கோப்புகளில் இயங்கும் போது கோப்பு வரிசையைத் தேர்வுசெய்க¶

நீங்கள் ஒரு: கிலாபெல்: பல HTML கோப்புகளில் அனைத்தையும் மாற்றவும், கோப்புகள் செயல்முறைகள் இருக்கும் வரிசையில் நீங்கள் திருத்துவதற்கு எந்த கோப்புகளை வைத்திருக்கிறீர்கள் என்பதைப் பொறுத்தது. இது போன்ற உங்கள் செயல்பாட்டில் ` file_order` பண்புகளை அமைப்பதன் மூலம் தோன்றும் வரிசையில் கோப்புகளை செயலாக்க தேடலை நீங்கள் கட்டாயப்படுத்தலாம்:

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    ...

replace.file_order = 'spine'

`` file_order`` இரண்டு மதிப்புகளை ஏற்றுக்கொள்கிறது, `` முதுகெலும்பு`` மற்றும் `` முதுகெலும்பு-தலைகீழ்``, இது முறையே புத்தகத்தில் தோன்றும் வரிசையில் பல கோப்புகளை செயலாக்குகிறது, முறையே முன்னோக்கி அல்லது பின்னோக்கி.

கடைசி போட்டி கண்டுபிடிக்கப்பட்ட பிறகு உங்கள் செயல்பாடு கூடுதல் நேரம் என்று அழைக்கப்படுகிறது¶

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

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    ...

replace.call_after_last_match = True

செயல்பாட்டிலிருந்து குறிக்கப்பட்ட உரையில் வெளியீட்டைச் சேர்க்கிறது¶

குறிக்கப்பட்ட உரையில் தேடலை இயக்கி மாற்றும்போது, சில நேரங்களில் அதைச் செய்வது பயனுள்ளதாக இருக்கும், எனவே குறிக்கப்பட்ட உரையின் முடிவில் உரை செய்யவும். உங்கள் செயல்பாட்டில் `` append_final_output_to_marked`` பண்புகளை அமைப்பதன் மூலம் நீங்கள் அதைச் செய்யலாம் (நீங்கள் `` Call_after_last_match`` ஐ அமைக்க வேண்டும் என்பதை நினைவில் கொள்க):

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    ...
    return 'some text to append'

replace.call_after_last_match = True
replace.append_final_output_to_marked = True

குறிக்கப்பட்ட உரையில் தேடல்களைச் செய்யும்போது முடிவு உரையாடலை அடக்குதல்¶

இது போன்ற உங்கள் செயல்பாட்டில் `` அடக்கி_ரெஸ்யூல்ட்_டியாலாக்`` பண்புகளை அமைப்பதன் மூலம் முடிவு உரையாடலை (இது பல தொகுதிகளில் ஒரு தேடல்/மாற்றத்தை மெதுவாக்கும்) அடக்கலாம்:

def replace(match, number, file_name, metadata, dictionaries, data, functions, *args, **kwargs):
    ...

replace.suppress_result_dialog = True

மேலும் எடுத்துக்காட்டுகள்¶

காலிபர் பயனர்களால் பங்களிக்கப்பட்ட மிகவும் பயனுள்ள எடுத்துக்காட்டுகள், காலிபர் மின் புத்தக எடிட்டர் மன்றத்தில் <https://www.mobileered.com/forums/showthread.php?t=237181> _.