راهنمای عبارت باقاعده¶

نویسنده:: A.M. Kuchling <amk@amk.ca>

مقدمه¶

عبارت‌های باقاعده (که به آن‌ها RE، regex یا الگوهای regex گفته می‌شود) در واقع یک زبان برنامه‌نویسی کوچک و بسیار تخصصی است که درون پایتون تعبیه شده و از طریق ماژول re در دسترس قرار می‌گیرد. با استفاده از این زبان کوچک، قواعد مجموعه‌ای از رشته‌های ممکن را که می‌خواهید با آن‌ها تطابق انجام دهید مشخص می‌کنید؛ این مجموعه ممکن است شامل جملات انگلیسی، نشانی‌های ایمیل، دستورات TeX یا هر چیزی باشد که بخواهید. سپس می‌توانید پرسش‌هایی مانند «آیا این رشته با الگو تطابق دارد؟» یا «آیا تطابقی برای الگو در هر جای این رشته وجود دارد؟» بپرسید. همچنین می‌توانید از REها برای تغییر یک رشته یا تقسیم آن به روش‌های مختلف استفاده کنید.

الگوهای عبارت باقاعده به رشته‌ای از بایت‌کدها کامپایل می‌شوند که سپس توسط یک موتور تطبیق نوشته‌شده به زبان C اجرا می‌شوند. برای استفاده‌ی پیشرفته، ممکن است لازم باشد به‌دقت به نحوه‌ی اجرای یک RE مشخص توسط موتور توجه کنید و RE را به شکل خاصی بنویسید تا بایت‌کدی تولید شود که سریع‌تر اجرا می‌شود. بهینه‌سازی در این سند پوشش داده نمی‌شود، زیرا نیاز دارد که شما درک خوبی از جزئیات داخلی موتور تطبیق داشته باشید.

زبان عبارت‌های باقاعده نسبتاً کوچک و محدود است، بنابراین نمی‌توان همه‌ی کارهای ممکن در پردازش رشته را با عبارت‌های باقاعده انجام داد. همچنین کارهایی وجود دارند که می‌توان آن‌ها را با عبارت‌های باقاعده انجام داد، اما عبارت‌ها بسیار پیچیده می‌شوند. در این موارد، ممکن است بهتر باشد برای انجام پردازش کد پایتون بنویسید؛ اگرچه کد پایتون از یک عبارت منظم مفصل کندتر خواهد بود، اما احتمالاً قابل‌فهم‌تر نیز خواهد بود.

الگوهای ساده¶

با یادگیری ساده‌ترین عبارات باقاعده‌ی ممکن آغاز می‌کنیم. از آن‌جا که عبارات باقاعده برای انجام عملیات روی رشته‌ها به کار می‌روند، با رایج‌ترین وظیفه شروع می‌کنیم: تطبیق نویسه‌ها.

برای توضیحی دقیق درباره علوم کامپیوتری که زیربنای عبارت‌های باقاعده است (اتوماتای متناهی قطعی و غیرقطعی)، می‌توانید به تقریباً هر کتاب درسی درباره نوشتن کامپایلرها مراجعه کنید.

تطبیق نویسه‌ها¶

بیشتر حروف و نویسه‌ها به‌سادگی با خودشان مطابقت دارند. برای مثال، عبارت باقاعده‌ی test دقیقاً با رشته‌ی test مطابقت خواهد داشت. (می‌توانید حالت بدون حساسیت به بزرگی و کوچکی حروف را فعال کنید تا این عبارت باقاعده بتواند با Test یا TEST نیز مطابقت داشته باشد؛ بعداً بیشتر درباره‌ی این موضوع توضیح داده می‌شود.)

برای این قاعده استثناهایی وجود دارد؛ برخی از نویسه‌ها، metacharacters ویژه‌ای هستند و با خودشان تطابق ندارند. در عوض، آن‌ها نشان می‌دهند که باید چیز غیرمعمولی تطابق داده شود، یا با تکرار آن‌ها یا تغییر معنایشان، بر بخش‌های دیگری از عبارت باقاعده تأثیر می‌گذارند. بخش عمده‌ای از این سند به بحث درباره‌ی فرانویسه‌های گوناگون و کاری که انجام می‌دهند اختصاص دارد.

در اینجا فهرست کاملی از فرانویسه‌ها آمده است؛ معانی آن‌ها در ادامه‌ی این HOWTO بحث خواهد شد.

. ^ $ * + ? { } [ ] \ | ( )

اولین فرانویسه‌هایی که بررسی خواهیم کرد، [ و ] هستند. آن‌ها برای تعیین یک کلاس نویسه به کار می‌روند که مجموعه‌ای از نویسه‌هایی است که می‌خواهید آن‌ها را تطبیق دهید. نویسه‌ها می‌توانند به‌صورت جداگانه فهرست شوند، یا می‌توان یک بازه از نویسه‌ها را با دادن دو نویسه و جدا کردن آن‌ها با یک '-' مشخص کرد. برای مثال، [abc] با هر یک از نویسه‌های a، b یا c تطابق دارد؛ این معادل [a-c] است که از یک بازه برای بیان همان مجموعه از نویسه‌ها استفاده می‌کند. اگر بخواهید فقط حروف کوچک را تطبیق دهید، RE شما [a-z] خواهد بود.

فرانویسه‌ها (به جز \) درون کلاس‌ها فعال نیستند. برای مثال، [akm$] با هر یک از نویسه‌های 'a'، 'k'، 'm' یا '$' مطابقت دارد؛ '$' معمولاً یک فرانویسه است، اما درون یک کلاس نویسه، خاصیت ویژه‌ی آن حذف می‌شود.

می‌توانید با متمم‌سازی <complementing> مجموعه، نویسه‌هایی را که در کلاس فهرست نشده‌اند تطبیق دهید. این کار با قرار دادن '^' به‌عنوان اولین نویسه‌ی کلاس مشخص می‌شود. برای مثال، [^5] هر نویسه‌ای به جز '5' را تطبیق می‌دهد. اگر نویسه‌ی ^ در جای دیگری از یک کلاس نویسه ظاهر شود، معنای خاصی ندارد. برای مثال: [5^] یا '5' یا '^' را تطبیق می‌دهد.

شاید مهم‌ترین فرانویسه، بک‌اسلش، \ باشد. مانند مقادیر لفظی رشته پایتون، پس از بک‌اسلش می‌توان از نویسه‌های مختلفی استفاده کرد تا دنباله‌های ویژه‌ی گوناگون نشان داده شوند. همچنین از آن برای خنثی کردن همه‌ی فرانویسه‌ها استفاده می‌شود تا همچنان بتوانید آن‌ها را در الگوها تطبیق دهید؛ برای مثال، اگر نیاز دارید [ یا \ را تطبیق دهید، می‌توانید پیش از آن‌ها یک بک‌اسلش قرار دهید تا معنای خاص آن‌ها از بین برود: \[ یا \\.

برخی از دنباله‌های خاص که با '\' آغاز می‌شوند، بیانگر مجموعه‌های از پیش تعریف‌شده‌ای از نویسه‌ها هستند که اغلب مفید هستند، مانند مجموعه ارقام، مجموعه حروف، یا مجموعه هر چیزی غیر از فضای سفید.

مثالی را در نظر بگیرید: \w با هر نویسه‌ی الفبایی‌عددی مطابقت دارد. اگر الگوی عبارت باقاعده به‌صورت بایت بیان شده باشد، این معادل کلاس [a-zA-Z0-9_] است. اگر الگوی عبارت باقاعده یک رشته باشد، \w با تمام نویسه‌هایی که در پایگاه داده‌ی یونیکد ارائه‌شده توسط ماژول unicodedata به‌عنوان حرف علامت‌گذاری شده‌اند، مطابقت خواهد کرد. شما می‌توانید با استفاده از پرچم re.ASCII هنگام کامپایل عبارت باقاعده، از تعریف محدودتر \w در یک الگوی رشته‌ای استفاده کنید.

فهرست زیر از دنباله‌های ویژه کامل نیست. برای فهرست کاملی از دنباله‌ها و تعریف‌های گسترش‌یافته کلاس برای الگوهای رشته یونیکد، بخش پایانی سینتکس عبارت باقاعده را در مرجع کتابخانه استاندارد ببینید. به‌طور کلی، نسخه‌های یونیکد با هر نویسه‌ای که در دسته مناسب در پایگاه داده یونیکد قرار دارد، مطابقت می‌کنند.

\d: با هر رقم ده‌دهی مطابقت دارد؛ این معادل کلاس [0-9] است.
\D: با هر نویسه‌ی غیررقمی مطابقت دارد؛ این معادل کلاس [^0-9] است.
\s: با هر نویسه فضای سفید مطابقت دارد؛ این معادل کلاس [ \t\n\r\f\v] است.
\S: با هر نویسه‌ای که فضای خالی نیست مطابقت دارد؛ این معادل کلاس [^ \t\n\r\f\v] است.
\w: با هر نویسه‌ی الفبایی-عددی مطابقت دارد؛ این معادل کلاس [a-zA-Z0-9_] است.
\W: با هر نویسه‌ی غیرالفبایی-عددی مطابقت دارد؛ این معادل کلاس [^a-zA-Z0-9_] است.

این دنباله‌ها می‌توانند درون یک کلاس نویسه گنجانده شوند. برای مثال، [\s,.] یک کلاس نویسه است که با هر نویسه فضای سفید، یا ',' یا '.' مطابقت خواهد داشت.

آخرین فرانویس سرآیند این بخش . است. این با هر چیزی به‌جز نویسه‌ی خط جدید تطابق دارد و حالت جایگزینی (re.DOTALL) وجود دارد که در آن حتی با خط جدید نیز تطابق خواهد داشت. از . اغلب در جایی استفاده می‌شود که بخواهید با «هر نویسه‌ای» تطابق داشته باشید.

تکرار چیزها¶

توانایی تطبیق مجموعه‌های متفاوتی از نویسه‌ها نخستین کاری است که عبارت‌های باقاعده می‌توانند انجام دهند و با متدهای موجود برای رشته‌ها از پیش امکان‌پذیر نیست. با این حال، اگر این تنها قابلیت اضافی عبارت‌های باقاعده بود، پیشرفت چندانی محسوب نمی‌شدند. قابلیت دیگر این است که می‌توانید مشخص کنید بخش‌هایی از عبارت باقاعده باید تعداد معینی تکرار شوند.

اولین فرانویسه برای تکرار که بررسی خواهیم کرد، * است. * با نویسه‌ی عینی '*' تطابق ندارد؛ در عوض، مشخص می‌کند که نویسه‌ی قبلی می‌تواند به جای دقیقاً یک بار، صفر بار یا بیشتر تطابق داشته باشد.

برای مثال، ca*t با 'ct' (۰ نویسه 'a')، 'cat' (۱ 'a')، 'caaat' (۳ نویسه 'a') و غیره مطابقت دارد.

تکرارهایی مانند * حریص <greedy> هستند؛ هنگام تکرار یک RE، موتور تطبیق تلاش می‌کند آن را تا حد ممکن تکرار کند. اگر بخش‌های بعدی الگو مطابقت نداشته باشند، موتور تطبیق سپس عقب‌گرد می‌کند و دوباره با تکرارهای کمتر تلاش می‌کند.

یک مثال گام‌به‌گام این موضوع را روشن‌تر می‌کند. عبارت a[bcd]*b را در نظر بگیرید. این عبارت با نویسه 'a'، صفر یا چند نویسه از کلاس [bcd] مطابقت می‌کند و در نهایت با یک 'b' تمام می‌شود. حال مطابقت این عبارت باقاعده (RE) با رشته 'abcbd' را تصور کنید.

مرحله	تطبیق‌شده	توضیح
1	`a`	`a` در RE مطابقت می‌کند.
2	`abcbd`	موتور، `[bcd]*` را تطابق می‌دهد و تا جایی که می‌تواند پیش می‌رود، یعنی تا انتهای رشته.
3	Failure	موتور تلاش می‌کند `b` را تطبیق دهد، اما موقعیت فعلی در انتهای رشته قرار دارد، بنابراین شکست می‌خورد.
4	`abcb`	به عقب برگردید، تا `[bcd]*` با یک نویسه کمتر مطابقت داشته باشد.
۵	Failure	بار دیگر `b` را امتحان کنید، اما موقعیت فعلی روی آخرین نویسه قرار دارد که یک `'d'` است.
6	`abc`	دوباره عقب‌گرد کنید، به‌طوری‌که `[bcd]*` فقط `bc` را تطبیق دهد.
۷	`abcb`	دوباره `b` را امتحان کنید. این بار نویسه‌ی موقعیت فعلی `'b'` است، بنابراین موفق می‌شود.

اکنون به انتهای RE رسیده‌ایم و آن با 'abcb' مطابقت کرده است. این نشان می‌دهد که موتور تطبیق در ابتدا تا جایی که می‌تواند پیش می‌رود و اگر هیچ تطابقی پیدا نشود، سپس به‌تدریج عقب می‌رود و بقیه‌ی RE را بارها و بارها دوباره امتحان می‌کند. آن‌قدر عقب می‌رود تا صفر تطابق را برای [bcd]* امتحان کند و اگر سپس شکست بخورد، موتور نتیجه می‌گیرد که رشته اصلاً با RE مطابقت ندارد.

یکی دیگر از فرانویسه‌های تکرار، + است که یک یا چند بار تطابق دارد. به تفاوت میان * و + با دقت توجه کنید؛ * صفر یا چند بار تطابق دارد، بنابراین ممکن است هر آنچه تکرار می‌شود اصلاً وجود نداشته باشد، در حالی که + حداقل به یک بار نیاز دارد. برای استفاده از مثالی مشابه، ca+t با 'cat' (۱ 'a')، 'caaat' (۳ 'a') تطابق خواهد داشت، اما با 'ct' تطابق نخواهد داشت.

دو عملگر تکرار یا کمیت‌گذار دیگر نیز وجود دارد. نویسه‌ی علامت سؤال، ?، یا یک بار یا صفر بار تطابق می‌یابد؛ می‌توانید آن را به‌عنوان علامت‌گذاری اختیاری بودن چیزی در نظر بگیرید. برای مثال، home-?brew یا با 'homebrew' یا با 'home-brew' تطابق دارد.

پیچیده‌ترین کمیت‌گذار (quantifier) {m,n} است که در آن m و n اعداد صحیح مبنای ده هستند. این کمیت‌گذار به این معناست که باید حداقل m تکرار و حداکثر n تکرار وجود داشته باشد. برای مثال، a/{1,3}b با 'a/b'، 'a//b' و 'a///b' مطابقت خواهد کرد. این الگو با 'ab' که هیچ اسلشی ندارد، یا 'a////b' که چهار اسلش دارد، مطابقت نخواهد کرد.

می‌توانید m یا n را حذف کنید؛ در این صورت، یک مقدار معقول برای مقدار غایب فرض می‌شود. حذف m به‌عنوان کران پایین ۰ تفسیر می‌شود، در حالی که حذف n به کران بالای بی‌نهایت منجر می‌شود.

ساده‌ترین حالت {m} دقیقاً m بار با آیتم پیشین مطابقت دارد. برای مثال، a/{2}b فقط با 'a//b' مطابقت خواهد داشت.

خوانندگان با گرایش تقلیل‌گرایانه ممکن است متوجه شوند که سه کمیت‌گذار دیگر را می‌توان با استفاده از این نمادگذاری بیان کرد. {0,} همان * است، {1,} معادل + است، و {0,1} همان ? است. بهتر است در صورت امکان از *، + یا ? استفاده کنید، صرفاً به این دلیل که کوتاه‌تر و خواناتر هستند.

استفاده از عبارات باقاعده¶

اکنون که برخی عبارت‌های باقاعده ساده را بررسی کردیم، چگونه واقعاً از آن‌ها در پایتون استفاده کنیم؟ ماژول re رابطی به موتور عبارت‌های باقاعده فراهم می‌کند و به شما امکان می‌دهد REها را به اشیاء کامپایل کنید و سپس با آن‌ها تطبیق‌ها را انجام دهید.

کامپایل عبارت‌های باقاعده¶

عبارت‌های باقاعده به اشیای الگو کامپایل می‌شوند، که متدهایی برای عملیات مختلف مانند جست‌وجو برای تطابق‌های الگو یا انجام جایگزینی‌های رشته‌ای دارند.

>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')

re.compile() همچنین یک آرگومان اختیاری flags را می‌پذیرد که برای فعال‌سازی قابلیت‌های ویژه و تغییرات سینتکسی گوناگون استفاده می‌شود. بعداً تنظیمات موجود را بررسی خواهیم کرد، اما فعلاً یک مثال کافی است:

>>> p = re.compile('ab*', re.IGNORECASE)

RE به‌صورت یک رشته به re.compile() ارسال می‌شود. REها به‌صورت رشته پردازش می‌شوند، زیرا عبارت‌های باقاعده بخشی از زبان اصلی پایتون نیستند و هیچ سینتکس خاصی برای بیان آن‌ها ایجاد نشده است. (برنامه‌هایی وجود دارند که اصلاً به RE نیاز ندارند، بنابراین نیازی به حجیم کردن مشخصات زبان با گنجاندن آن‌ها نیست.) در عوض، ماژول re صرفاً یک ماژول توسعه C است که همراه با پایتون گنجانده شده است، درست مانند ماژول‌های socket یا zlib.

قرار دادن عبارت‌های باقاعده در رشته‌ها، زبان پایتون را ساده‌تر نگه می‌دارد، اما یک عیب دارد که موضوع بخش بعدی است.

آفت بک‌اسلش¶

همان‌طور که پیش‌تر گفته شد، عبارات باقاعده از نویسه‌ی بک‌اسلش ('\') استفاده می‌کنند تا شکل‌های ویژه را نشان دهند یا اجازه دهند که نویسه‌های ویژه بدون فراخوانی معنای ویژه‌ی آن‌ها به کار گرفته شوند. این موضوع با استفاده‌ی پایتون از همان نویسه برای همان هدف در رشته‌های لفظی (string literals) تعارض دارد.

فرض کنید می‌خواهید یک عبارت باقاعده بنویسید که با رشته‌ی \section مطابقت کند، که ممکن است در یک پرونده LaTeX یافت شود. برای این‌که بدانید در کد برنامه چه بنویسید، با رشته‌ی موردنظر برای مطابقت شروع کنید. سپس باید هر بک‌اسلش و سایر متانویسه‌ها را با قرار دادن یک بک‌اسلش پیش از آن‌ها خنثی کنید، که در نتیجه رشته‌ی \\section به دست می‌آید. رشته‌ی حاصل که باید به re.compile() داده شود، باید \\section باشد. با این حال، برای بیان این به‌عنوان یک رشته‌ی لفظی پایتون، هر دو بک‌اسلش باید دوباره خنثی شوند.

نویسه‌ها	مرحله
`\section`	رشته‌ی متنی برای تطبیق
`\\section`	بک‌اسلش خنثی‌شده برای `re.compile()`
`"\\\\section"`	بک‌اسلش‌های خنثی‌شده برای یک رشته‌ی لفظی

به‌طور خلاصه، برای تطبیق یک بک‌اسلش به‌صورت لفظی، باید '\\\\' را به‌عنوان رشته‌ی عبارت باقاعده بنویسید، زیرا عبارت باقاعده باید \\ باشد و هر بک‌اسلش باید داخل یک رشته‌ی معمولی پایتون به‌صورت \\ بیان شود. در عبارت‌های باقاعده‌ای که شامل بک‌اسلش‌های مکرر هستند، این موضوع به تکرار زیاد بک‌اسلش‌ها منجر می‌شود و درک رشته‌های حاصل را دشوار می‌سازد.

راه‌حل این است که از نمادگذاری رشته‌ی خام پایتون برای عبارات باقاعده استفاده کنید؛ بک‌اسلش‌ها در یک رشته‌ی ادبی با پیشوند 'r' به هیچ شکل خاصی پردازش نمی‌شوند، بنابراین r"\n" یک رشته‌ی دو نویسه‌ای است که شامل '\' و 'n' است، در حالی که "\n" یک رشته‌ی تک‌نویسه‌ای است که شامل یک خط جدید است. عبارات باقاعده اغلب با استفاده از این نمادگذاری رشته‌ی خام در کد پایتون نوشته می‌شوند.

به‌علاوه، دنباله‌های خنثی‌سازی خاصی که در عبارات باقاعده معتبرند، اما به‌عنوان مقادیر لفظی رشته پایتون معتبر نیستند، اکنون منجر به SyntaxWarning می‌شوند و سرانجام به SyntaxError تبدیل خواهند شد؛ این بدان معناست که اگر از نمادگذاری رشته خام یا خنثی کردن بک‌اسلش‌ها استفاده نشود، این دنباله‌ها نامعتبر خواهند بود.

رشته معمولی	رشته خام
`"ab*"`	`r"ab*"`
`"\\\\section"`	`r"\\section"`
`"\\w+\\s+\\1"`	`r"\w+\s+\1"`

انجام تطبیق‌ها¶

هنگامی که یک شیء نشان‌دهنده یک عبارت باقاعده کامپایل‌شده دارید، با آن چه کار می‌کنید؟ اشیای الگو چندین متد و ویژگی دارند. در اینجا فقط مهم‌ترین آن‌ها بررسی می‌شود؛ برای فهرست کامل به مستندات re مراجعه کنید.

متد/ویژگی	هدف
`match()`	تعیین می‌کند که آیا عبارت باقاعده در ابتدای رشته تطابق دارد یا خیر.
`search()`	یک رشته را پیمایش می‌کند و به دنبال هر موقعیتی می‌گردد که این عبارت باقاعده در آن مطابقت دارد.
`findall()`	همه زیررشته‌هایی را که RE با آن‌ها مطابقت دارد پیدا می‌کند و آن‌ها را به‌صورت یک فهرست برمی‌گرداند.
`finditer()`	تمام زیررشته‌هایی را که RE با آن‌ها مطابقت دارد پیدا کنید و آن‌ها را به‌عنوان یک iterator برگردانید.

match() و search() در صورتی که هیچ تطابقی یافت نشود، None برمی‌گردانند. اگر موفق باشند، نمونه‌ای از شیء تطابق برگردانده می‌شود که حاوی اطلاعاتی درباره‌ی تطابق است: محل شروع و پایان آن، زیررشته‌ای که با آن تطابق داشته است، و موارد دیگر.

می‌توانید با آزمایش تعاملی ماژول re، درباره این موضوع بیاموزید.

این HOWTO برای مثال‌های خود از مفسر استاندارد پایتون استفاده می‌کند. ابتدا مفسر پایتون را اجرا کنید، ماژول re را ایمپورت کنید و یک RE را کامپایل کنید:

>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')

اکنون می‌توانید تطبیق رشته‌های مختلف با عبارت باقاعده [a-z]+ را امتحان کنید. یک رشته خالی به‌هیچ‌وجه نباید تطبیق پیدا کند، زیرا + به معنای «یک یا چند تکرار» است. در این حالت match() باید None برگرداند، که باعث می‌شود مفسر هیچ خروجی چاپ نکند. می‌توانید برای روشن‌تر شدن این موضوع، نتیجه match() را به‌صورت صریح چاپ کنید.

>>> p.match("")
>>> print(p.match(""))
None

اکنون، بیایید آن را روی رشته‌ای که باید با آن تطبیق داشته باشد، مانند tempo امتحان کنیم. در این حالت، match() یک شیء تطبیق برمی‌گرداند، بنابراین باید نتیجه را برای استفاده بعدی در یک متغیر ذخیره کنید.

>>> m = p.match('tempo')
>>> m
<re.Match object; span=(0, 5), match='tempo'>

اکنون می‌توانید برای دریافت اطلاعات درباره رشته‌ی تطبیق‌یافته، از شیء تطبیق پرس‌وجو کنید. نمونه‌های شیء تطبیق همچنین چندین متد و ویژگی دارند؛ مهم‌ترین آن‌ها عبارت‌اند از:

متد/ویژگی	هدف
`group()`	رشته‌ی تطبیق‌یافته با RE را برمی‌گرداند
`start()`	موقعیت شروع تطبیق را برمی‌گرداند
`end()`	موقعیت پایانی تطابق را برمی‌گرداند
`span()`	یک تاپل شامل موقعیت‌های (start, end) تطبیق را برمی‌گرداند

آزمودن این متدها به‌زودی معنای آن‌ها را روشن خواهد کرد:

>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

group() زیررشته‌ای را برمی‌گرداند که با عبارت باقاعده مطابقت داشته است. start() و end() اندیس‌های شروع و پایان تطابق را برمی‌گردانند. span() هر دو اندیس شروع و پایان را در یک تاپل واحد برمی‌گرداند. از آن‌جا که متد match() فقط بررسی می‌کند که آیا عبارت باقاعده در ابتدای یک رشته تطابق دارد یا خیر، start() همیشه ۰ خواهد بود. با این حال، متد search() الگوها، رشته را پیمایش می‌کند، بنابراین در آن حالت ممکن است تطابق از ۰ شروع نشود.

>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<re.Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)

در برنامه‌های واقعی، رایج‌ترین سبک این است که شیء تطبیق را در یک متغیر ذخیره کنید و سپس بررسی کنید که آیا None است یا خیر. این معمولاً به این شکل است:

p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

دو متد الگو، همه‌ی تطابق‌های یک الگو را برمی‌گردانند. findall() فهرستی از رشته‌های مطابقت‌کننده را برمی‌گرداند:

>>> p = re.compile(r'\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

پیشوند r که این رشته را به یک رشته‌ی خام تبدیل می‌کند، در این مثال لازم است، زیرا دنباله‌های فرار در یک رشته‌ی معمولی «پخته» (cooked) که توسط پایتون، برخلاف عبارات باقاعده، شناسایی نمی‌شوند، اکنون منجر به SyntaxWarning می‌شوند و سرانجام به SyntaxError تبدیل خواهند شد. به آفت بک‌اسلش مراجعه کنید.

findall() باید کل فهرست را ایجاد کند تا بتواند آن را به‌عنوان نتیجه بازگرداند. متد finditer() دنباله‌ای از نمونه‌های شیء تطبیق را به‌صورت یک پیمایش‌گر برمی‌گرداند:

>>> iterator = p.finditer('12 drummers drumming, 11 ... 10 ...')
>>> iterator
<callable_iterator object at 0x...>
>>> for match in iterator:
...     print(match.span())
...
(0, 2)
(22, 24)
(29, 31)

توابع سطح ماژول¶

شما مجبور نیستید یک شیء الگو ایجاد کنید و متدهای آن را فراخوانی کنید؛ ماژول re همچنین توابع سطح بالایی به نام‌های match()، search()، findall()، sub() و غیره ارائه می‌دهد. این توابع همان آرگومان‌های متد متناظر الگو را، با اضافه شدن رشته RE به‌عنوان اولین آرگومان، می‌پذیرند، و همچنان یا None یا نمونه‌ای از شیء تطبیق را برمی‌گردانند.

>>> print(re.match(r'From\s+', 'Fromage amk'))
None
>>> re.match(r'From\s+', 'From amk Thu May 14 19:12:10 1998')
<re.Match object; span=(0, 5), match='From '>

در پشت صحنه، این توابع به‌سادگی یک شیء الگو برای شما ایجاد می‌کنند و متد مناسب را روی آن فراخوانی می‌کنند. همچنین شیء کامپایل‌شده را در نهانگاه ذخیره می‌کنند، بنابراین فراخوانی‌های آینده با استفاده از همان RE نیازی ندارند که الگو را دوباره و دوباره تجزیه کنند.

آیا باید از این توابع سطح ماژول استفاده کنید، یا باید خودتان الگو را دریافت کنید و متدهای آن را فراخوانی کنید؟ اگر در یک حلقه از یک عبارت باقاعده استفاده می‌کنید، از پیش کامپایل کردن آن باعث صرفه‌جویی در چند فراخوانی تابع می‌شود. خارج از حلقه‌ها، به لطف نهانگاه داخلی تفاوت چندانی وجود ندارد.

پرچم‌های کامپایل¶

پرچم‌های کامپایل به شما امکان می‌دهند برخی جنبه‌های نحوه‌ی کار عبارات باقاعده را تغییر دهید. پرچم‌ها در ماژول re با دو نام در دسترس هستند: نامی بلند مانند IGNORECASE و صورتی کوتاه و تک‌حرفی مانند I. (اگر با اصلاح‌کننده‌های الگوی Perl آشنا هستید، صورت‌های تک‌حرفی از همان حروف استفاده می‌کنند؛ برای مثال، صورت کوتاه re.VERBOSE برابر re.X است.) می‌توان چند پرچم را با OR بیتی کردن آن‌ها مشخص کرد؛ برای مثال، re.I | re.M هر دو پرچم I و M را تنظیم می‌کند.

در اینجا جدولی از پرچم‌های موجود آمده است و در ادامه، توضیح دقیق‌تری برای هر یک ارائه می‌شود.

پرچم	معنی
`ASCII`, `A`	باعث می‌شود چندین دنباله‌ی خنثی‌سازی مانند `\w`، `\b`، `\s` و `\d` فقط با نویسه‌های ASCII دارای ویژگی مربوطه مطابقت کنند.
`DOTALL`, `S`	باعث می‌شود `.` با هر نویسه‌ای، از جمله سطرهای جدید، تطبیق داده شود.
`IGNORECASE`, `I`	تطبیق‌های بدون حساسیت به بزرگی و کوچکی حروف را انجام دهید.
`LOCALE`, `L`	یک تطبیق آگاه از locale انجام دهید.
`MULTILINE`, `M`	تطبیق چندخطی، که بر `^` و `$` تأثیر می‌گذارد.
`VERBOSE`، `X` (برای «گسترده»)	فعال‌سازی عبارت‌های باقاعده خوانا (verbose REs)، که می‌توان آن‌ها را منظم‌تر و قابل‌فهم‌تر سازمان‌دهی کرد.

re.I
re.IGNORECASE: تطبیق بدون حساسیت به بزرگی و کوچکی حروف انجام می‌شود؛ کلاس‌های نویسه و رشته‌های لفظی، حروف را با چشم‌پوشی از بزرگی و کوچکی تطبیق می‌دهند. برای مثال، [A-Z] حروف کوچک را نیز تطبیق می‌دهد. تطبیق کامل یونیکد نیز کار می‌کند، مگر اینکه از پرچم ASCII برای غیرفعال‌سازی تطبیق‌های غیر ASCII استفاده شود. هنگامی که الگوهای یونیکد [a-z] یا [A-Z] به همراه پرچم IGNORECASE استفاده شوند، آن‌ها ۵۲ حرف ASCII و ۴ حرف غیر ASCII دیگر را تطبیق خواهند داد: 'İ' (U+0130، حرف بزرگ لاتین I با نقطه بالا)، 'ı' (U+0131، حرف کوچک لاتین i بدون نقطه)، 'ſ' (U+017F، حرف کوچک لاتین s بلند) و 'K' (U+212A، علامت کلوین). Spam با 'Spam'، 'spam'، 'spAM' یا 'ſpam' تطبیق خواهد داشت (مورد آخر فقط در حالت یونیکد تطبیق داده می‌شود). این تبدیل به حروف کوچک، locale فعلی را در نظر نمی‌گیرد؛ اگر پرچم LOCALE را نیز تنظیم کنید، در نظر خواهد گرفت.

re.L

re.LOCALE

تطبیق \w، \W، \b، \B و تطبیق بدون حساسیت به بزرگی و کوچکی حروف را به جای پایگاه داده‌ی یونیکد، به locale جاری وابسته می‌کند.

locale ها قابلیتی از کتابخانه‌ی C هستند که برای کمک به نوشتن برنامه‌هایی در نظر گرفته شده‌اند که تفاوت‌های زبانی را در نظر می‌گیرند. برای مثال، اگر در حال پردازش متن فرانسویِ کدگذاری‌شده هستید، می‌خواهید بتوانید \w+ را برای تطبیق واژه‌ها بنویسید، اما \w در الگوهای بایتی فقط با کلاس نویسه‌ی [A-Za-z] تطبیق می‌کند؛ بنابراین با بایت‌های متناظر با é یا ç تطبیق نمی‌کند. اگر سامانه‌ی شما به‌درستی پیکربندی شده باشد و یک locale فرانسوی انتخاب شده باشد، برخی تابع‌های C به برنامه اعلام می‌کنند که بایت متناظر با é نیز باید یک نویسه‌ی حرفی در نظر گرفته شود. تنظیم پرچم LOCALE هنگام کامپایل یک عبارت باقاعده باعث می‌شود شیء کامپایل‌شده‌ی حاصل از این تابع‌های C برای \w استفاده کند؛ این کار کندتر است، اما همچنین باعث می‌شود \w+ همان‌طور که انتظار می‌رود با واژه‌های فرانسوی تطبیق کند. استفاده از این پرچم در پایتون ۳ توصیه نمی‌شود، زیرا سازوکار locale بسیار غیرقابل‌اعتماد است، در هر زمان فقط یک «فرهنگ» را مدیریت می‌کند و فقط با localeهای ۸بیتی کار می‌کند. تطبیق یونیکد در پایتون ۳ برای الگوهای یونیکدی (str) به‌طور پیش‌فرض فعال است و می‌تواند localeها/زبان‌های مختلف را مدیریت کند.

re.M

re.MULTILINE

(^ و $ هنوز توضیح داده نشده‌اند؛ آن‌ها در بخش فرانویسه‌های بیشتر معرفی خواهند شد.)

معمولاً ^ تنها در ابتدای رشته تطابق دارد، و $ تنها در پایان رشته و دقیقاً پیش از خط جدید (در صورت وجود) در پایان رشته تطابق دارد. هنگامی که این پرچم تعیین شده باشد، ^ در ابتدای رشته و در ابتدای هر خط درون رشته، دقیقاً پس از هر خط جدید، تطابق دارد. به‌طور مشابه، فرانویسه‌ی $ یا در پایان رشته یا در پایان هر خط (دقیقاً پیش از هر خط جدید) تطابق دارد.

re.S
re.DOTALL: باعث می‌شود نویسه‌ی خاص '.' با هر نویسه‌ای، از جمله خط جدید، مطابقت کند؛ بدون این پرچم، '.' با هر چیزی به‌جز خط جدید مطابقت خواهد کرد.

re.A
re.ASCII: باعث می‌شود \w، \W، \b، \B، \s و \S به‌جای تطبیق کامل یونیکد، تطبیق فقط ASCII را انجام دهند. این موضوع فقط برای الگوهای یونیکدی معنادار است و برای الگوهای بایتی نادیده گرفته می‌شود.

re.X

re.VERBOSE

این پرچم به شما امکان می‌دهد عبارت‌های باقاعده خواناتری بنویسید، زیرا انعطاف‌پذیری بیشتری در نحوه قالب‌بندی آن‌ها در اختیار شما قرار می‌دهد. هنگامی که این پرچم مشخص شده باشد، فضای سفید درون رشته عبارت باقاعده نادیده گرفته می‌شود، مگر وقتی که فضای سفید در یک کلاس نویسه باشد یا پیش از آن یک بک‌اسلش خنثی‌نشده قرار داشته باشد؛ این امر به شما امکان می‌دهد عبارت باقاعده را واضح‌تر سازمان‌دهی و تورفتگی‌گذاری کنید. این پرچم همچنین به شما امکان می‌دهد کامنت‌هایی را درون یک عبارت باقاعده قرار دهید که توسط موتور نادیده گرفته می‌شوند؛ کامنت‌ها با یک '#' مشخص می‌شوند که نه در یک کلاس نویسه باشد و نه پیش از آن یک بک‌اسلش خنثی‌نشده قرار داشته باشد.

برای مثال، در اینجا یک عبارت باقاعده آمده است که از re.VERBOSE استفاده می‌کند؛ ببینید چقدر خواندن آن آسان‌تر است؟

charref = re.compile(r"""
 &[#]                # Start of a numeric entity reference
 (
     0[0-7]+         # Octal form
   | [0-9]+          # Decimal form
   | x[0-9a-fA-F]+   # Hexadecimal form
 )
 ;                   # Trailing semicolon
""", re.VERBOSE)

بدون تنظیم verbose، RE به این شکل خواهد بود:

charref = re.compile("&#(0[0-7]+"
                     "|[0-9]+"
                     "|x[0-9a-fA-F]+);")

در مثال بالا، از الحاق خودکار رشته‌های لفظی در پایتون برای شکستن عبارت باقاعده به قطعات کوچک‌تر استفاده شده است، اما درک آن هنوز از نسخه‌ای که از re.VERBOSE استفاده می‌کند، دشوارتر است.

قدرت بیشتر الگوها¶

تاکنون تنها بخشی از قابلیت‌های عبارت‌های باقاعده را بررسی کرده‌ایم. در این بخش، برخی فرانویسه‌های جدید و چگونگی استفاده از گروه‌ها برای بازیابی بخش‌هایی از متنی که تطبیق داده شده است را بررسی خواهیم کرد.

فرانویسه‌های بیشتر¶

هنوز برخی از فرانویسه‌ها پوشش داده نشده‌اند. بیشتر آن‌ها در این بخش پوشش داده خواهند شد.

برخی از فرانویسه‌های باقی‌مانده که مورد بحث قرار خواهند گرفت، :dfn:` شرط‌های با عرض صفر <zero-width assertions>` هستند. آن‌ها باعث نمی‌شوند موتور در رشته پیشروی کند؛ در عوض، اصلاً هیچ نویسه‌ای مصرف نمی‌کنند و صرفاً موفق یا ناموفق می‌شوند. برای مثال، \b ادعایی است مبنی بر اینکه موقعیت فعلی در یک مرز کلمه قرار دارد؛ موقعیت به‌هیچ‌وجه توسط \b تغییر نمی‌کند. این بدان معناست که شرط‌های با عرض صفر هرگز نباید تکرار شوند، زیرا اگر یک بار در یک مکان مشخص تطابق داشته باشند، بدیهی است که می‌توانند بی‌نهایت بار تطابق یابند.

|

جایگزینی، یا عملگر «یا». اگر A و B عبارت‌های باقاعده باشند، A|B با هر رشته‌ای که با A یا B مطابقت داشته باشد، مطابقت می‌کند. | اولویت بسیار پایینی دارد تا هنگام جایگزینی بین رشته‌های چند نویسه‌ای به‌طور معقولی کار کند. Crow|Servo با 'Crow' یا 'Servo' مطابقت می‌کند، نه با 'Cro'، یک 'w' یا یک 'S'، و 'ervo'.

برای تطبیق '|' به‌صورت لفظی، از \| استفاده کنید، یا آن را داخل یک کلاس نویسه قرار دهید، مانند [|].

^

در ابتدای سطرها تطابق می‌یابد. مگر اینکه پرچم MULTILINE تنظیم شده باشد، این فقط در ابتدای رشته تطابق خواهد یافت. در حالت MULTILINE، این بلافاصله پس از هر خط جدید در داخل رشته نیز تطابق می‌یابد.

برای مثال، اگر می‌خواهید کلمه From فقط در ابتدای یک خط تطابق داده شود، عبارت باقاعده‌ای که باید استفاده کنید ^From است.

>>> print(re.search('^From', 'From Here to Eternity'))
<re.Match object; span=(0, 4), match='From'>
>>> print(re.search('^From', 'Reciting From Memory'))
None

برای تطبیق یک '^' لفظی، از \^ استفاده کنید.

$

در پایان یک خط تطابق پیدا می‌کند؛ پایان خط به‌صورت پایان رشته یا هر مکانی که پس از آن یک نویسه‌ی خط جدید باشد تعریف می‌شود.

>>> print(re.search('}$', '{block}'))
<re.Match object; span=(6, 7), match='}'>
>>> print(re.search('}$', '{block} '))
None
>>> print(re.search('}$', '{block}\n'))
<re.Match object; span=(6, 7), match='}'>

برای تطبیق '$' به‌صورت لفظی، از \$ استفاده کنید یا آن را درون یک کلاس نویسه قرار دهید، مانند [$].

\A

فقط در ابتدای رشته مطابقت می‌کند. هنگامی که حالت MULTILINE فعال نباشد، \A و ^ عملاً یکسان هستند. در حالت MULTILINE، این دو متفاوت هستند: \A همچنان فقط در ابتدای رشته مطابقت می‌کند، اما ^ ممکن است در هر جای داخل رشته که پس از یک نویسه‌ی خط جدید قرار داشته باشد، مطابقت کند.

\z

فقط در انتهای رشته مطابقت می‌کند.

\Z

همان \z است. برای سازگاری با نسخه‌های قدیمی پایتون.

\b

مرز کلمه. این یک شرط با عرض صفر (zero-width assertion) است که فقط در آغاز یا پایان یک کلمه تطابق می‌یابد. یک کلمه به‌عنوان دنباله‌ای از نویسه‌های الفبایی-عددی تعریف می‌شود، بنابراین پایان یک کلمه با فضای خالی یا نویسه‌ای غیرالفبایی-عددی مشخص می‌شود.

مثال زیر فقط زمانی class را تطبیق می‌دهد که یک کلمه کامل باشد؛ وقتی درون کلمه‌ای دیگر قرار داشته باشد، تطبیق داده نخواهد شد.

>>> p = re.compile(r'\bclass\b')
>>> print(p.search('no class at all'))
<re.Match object; span=(3, 8), match='class'>
>>> print(p.search('the declassified algorithm'))
None
>>> print(p.search('one subclass is'))
None

دو نکته‌ی ظریف وجود دارد که باید هنگام استفاده از این دنباله‌ی خاص آن‌ها را به‌خاطر بسپارید. اول، این بدترین تداخل میان رشته‌های لفظی پایتون و دنباله‌های عبارت باقاعده است. در رشته‌های لفظی پایتون، \b نویسه‌ی پس‌بر (backspace) با مقدار ASCII ۸ است. اگر از رشته‌های خام استفاده نمی‌کنید، پایتون \b را به یک پس‌بر (backspace) تبدیل می‌کند و عبارت باقاعده‌ی شما آن‌طور که انتظار دارید تطابق نخواهد کرد. مثال زیر همانند عبارت باقاعده‌ی قبلی ما به نظر می‌رسد، اما 'r' را از ابتدای رشته‌ی عبارت باقاعده حذف می‌کند.

>>> p = re.compile('\bclass\b')
>>> print(p.search('no class at all'))
None
>>> print(p.search('\b' + 'class' + '\b'))
<re.Match object; span=(0, 7), match='\x08class\x08'>

دوم، داخل یک کلاس نویسه، جایی که این ادعا کاربردی ندارد، \b نشان‌دهنده‌ی نویسه‌ی پس‌بر (backspace) است، برای سازگاری با مقادیر لفظی رشته‌ای پایتون.

\B

یک شرط با عرض صفر (zero-width assertion) دیگر، این متضاد \b است و فقط زمانی مطابقت می‌کند که موقعیت فعلی در مرز واژه نباشد.

گروه‌بندی¶

اغلب نیاز دارید اطلاعات بیشتری بیش از صرفاً اینکه آیا عبارت باقاعده تطابق داشته است یا خیر، به دست آورید. از عبارات باقاعده اغلب برای تجزیه رشته‌ها با نوشتن یک عبارت باقاعده تقسیم‌شده به چند زیرگروه که با اجزای مختلف مورد نظر تطابق دارند، استفاده می‌شود. برای مثال، یک خط سرآیند RFC-822 به یک نام سرآیند و یک مقدار تقسیم می‌شود که با یک ':' از هم جدا شده‌اند؛ مانند این:

From: author@example.com
User-Agent: Thunderbird 1.5.0.9 (X11/20061227)
MIME-Version: 1.0
To: editor@example.com

این مورد را می‌توان با نوشتن یک عبارت باقاعده مدیریت کرد که با کل خط سرآیند تطابق دارد و دارای یک گروه است که با نام سرآیند تطابق دارد، و گروه دیگری که با مقدار سرآیند تطابق دارد.

گروه‌ها با فرانویسه‌های '(' و ')' مشخص می‌شوند. '(' و ')' تقریباً همان معنایی را دارند که در عبارات ریاضی دارند؛ آن‌ها عبارات درون خود را با هم گروه‌بندی می‌کنند، و شما می‌توانید محتوای یک گروه را با یک کمیت‌گذار (quantifier)، مانند *، +، ? یا {m,n} تکرار کنید. برای مثال، (ab)* با صفر یا چند تکرار از ab مطابقت می‌کند.

>>> p = re.compile('(ab)*')
>>> print(p.match('ababababab').span())
(0, 10)

گروه‌های مشخص‌شده با '(' و ')' همچنین اندیس‌های آغاز و پایان متنی را که تطبیق می‌دهند ضبط می‌کنند؛ این را می‌توان با ارسال یک آرگومان به group()، start()، end() و span() بازیابی کرد. گروه‌ها از ۰ شماره‌گذاری می‌شوند. گروه ۰ همیشه وجود دارد؛ این گروه کل RE است، بنابراین تمام متدهای شیء تطبیق گروه ۰ را به‌عنوان آرگومان پیش‌فرض خود دارند. در ادامه خواهیم دید که چگونه گروه‌هایی را بیان کنیم که بازه‌ی متنی را که تطبیق می‌دهند ضبط نمی‌کنند.

>>> p = re.compile('(a)b')
>>> m = p.match('ab')
>>> m.group()
'ab'
>>> m.group(0)
'ab'

زیرگروه‌ها از چپ به راست، از ۱ به بعد شماره‌گذاری می‌شوند. گروه‌ها می‌توانند تودرتو باشند؛ برای تعیین شماره، کافی است نویسه‌های پرانتز باز را از چپ به راست بشمارید.

>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'

می‌توان چندین شماره گروه را به‌صورت همزمان به group() ارسال کرد، که در این صورت یک تاپل شامل مقادیر متناظر برای آن گروه‌ها برمی‌گرداند.

>>> m.group(2,1,2)
('b', 'abc', 'b')

متد groups() یک تاپل شامل رشته‌های تمام زیرگروه‌ها، از ۱ تا هر تعداد که وجود داشته باشد، برمی‌گرداند.

>>> m.groups()
('abc', 'b')

بازارجاع‌ها در یک الگو به شما امکان می‌دهند مشخص کنید که محتوای یک گروه ثبت‌کننده پیشین نیز باید در موقعیت فعلی در رشته یافت شود. برای مثال، اگر محتوای دقیق گروه ۱ در موقعیت فعلی یافت شود، \1 موفق می‌شود و در غیر این صورت شکست می‌خورد. به یاد داشته باشید که مقادیر لفظی رشته در پایتون نیز از یک بک‌اسلش و سپس اعداد برای امکان گنجاندن نویسه‌های دلخواه در رشته استفاده می‌کنند، بنابراین هنگام به‌کارگیری بازارجاع‌ها در یک RE، حتماً از یک رشته خام استفاده کنید.

برای مثال، عبارت باقاعده زیر کلمات تکراری در یک رشته را تشخیص می‌دهد.

>>> p = re.compile(r'\b(\w+)\s+\1\b')
>>> p.search('Paris in the the spring').group()
'the the'

این‌گونه بازارجاع‌ها (backreferences) معمولاً صرفاً برای جست‌وجو در یک رشته چندان مفید نیستند --- قالب‌های متنی کمی وجود دارند که داده‌ها را به این شکل تکرار می‌کنند --- اما به‌زودی متوجه خواهید شد که هنگام انجام جایگزینی‌های رشته‌ای بسیار مفید هستند.

گروه‌های غیرثبت‌کننده و نام‌دار¶

عبارات باقاعده مفصل ممکن است از گروه‌های زیادی استفاده کنند، هم برای گرفتن زیررشته‌های موردنظر و هم برای گروه‌بندی و ساختاردهی خود عبارت باقاعده. در عبارات باقاعده پیچیده، پیگیری شماره‌های گروه دشوار می‌شود. دو قابلیت وجود دارند که به حل این مشکل کمک می‌کنند. هر دوی آن‌ها از یک سینتکس مشترک برای افزونه‌های عبارت باقاعده استفاده می‌کنند، بنابراین ابتدا آن را بررسی خواهیم کرد.

Perl 5 به دلیل افزودنی‌های قدرتمندش به عبارت‌های باقاعده استاندارد به‌خوبی شناخته شده است. برای این قابلیت‌های جدید، توسعه‌دهندگان Perl نمی‌توانستند متانویسه‌های تک‌کلیدی جدید یا دنباله‌های خاص جدیدی را که با \ آغاز می‌شوند انتخاب کنند، بدون آنکه عبارت‌های باقاعده Perl را به‌شکلی گیج‌کننده از REهای استاندارد متفاوت کنند. برای مثال، اگر آن‌ها & را به‌عنوان یک متانویسه جدید انتخاب می‌کردند، عبارت‌های قدیمی فرض می‌کردند که & یک نویسه معمولی است و آن را با نوشتن \& یا [&] خنثی نمی‌کردند.

راه‌حلی که توسعه‌دهندگان Perl انتخاب کردند، استفاده از (?...) به‌عنوان سینتکس گسترش بود. ? بلافاصله پس از یک پرانتز یک خطای سینتکسی بود، زیرا ? هیچ چیزی برای تکرار نداشت؛ بنابراین این موضوع هیچ مشکل سازگاری‌ای ایجاد نکرد. نویسه‌های بلافاصله پس از ? نشان می‌دهند که کدام گسترش استفاده می‌شود، بنابراین (?=foo) یک چیز است (یک ادعای پیش‌نگر مثبت (positive lookahead assertion)) و (?:foo) چیز دیگری است (یک گروه غیرثبت‌کننده (non-capturing group) شامل زیرعبارت foo).

پایتون از چندین افزونه‌ی پرل پشتیبانی می‌کند و یک سینتکس افزونه را به سینتکس افزونه‌ی پرل اضافه می‌کند. اگر اولین نویسه پس از علامت سؤال P باشد، می‌دانید که این یک افزونه‌ی مختص پایتون است.

اکنون که سینتکس کلی گسترش را بررسی کردیم، می‌توانیم به قابلیت‌هایی بازگردیم که کار با گروه‌ها را در عبارات باقاعده‌ی پیچیده ساده می‌کنند.

گاهی ممکن است بخواهید از یک گروه برای مشخص کردن بخشی از یک عبارت باقاعده استفاده کنید، اما مایل به بازیابی محتوای گروه نباشید. می‌توانید این موضوع را با استفاده از یک گروه غیرثبت‌کننده (non-capturing group) به‌صراحت بیان کنید: (?:...)، که در آن می‌توانید ... را با هر عبارت باقاعده دیگری جایگزین کنید.

>>> m = re.match("([abc])+", "abc")
>>> m.groups()
('c',)
>>> m = re.match("(?:[abc])+", "abc")
>>> m.groups()
()

به‌جز این واقعیت که نمی‌توانید محتوای آنچه را که گروه با آن مطابقت کرده است بازیابی کنید، گروه غیرثبت‌کننده دقیقاً مانند گروه ثبت‌کننده رفتار می‌کند؛ می‌توانید هر چیزی را درون آن قرار دهید، آن را با یک فرانویسه‌ی تکرار مانند * تکرار کنید و آن را درون گروه‌های دیگر (ثبت‌کننده یا غیرثبت‌کننده) تودرتو کنید. (?:...) به‌ویژه هنگام تغییر یک الگوی موجود مفید است، زیرا می‌توانید بدون آنکه نحوه‌ی شماره‌گذاری همه‌ی گروه‌های دیگر تغییر کند، گروه‌های جدیدی اضافه کنید. لازم است ذکر شود که هیچ تفاوت عملکردی در جستجو میان گروه‌های ثبت‌کننده و غیرثبت‌کننده وجود ندارد؛ هیچ‌یک از این دو شکل سریع‌تر از دیگری نیست.

ویژگی مهم‌تر، گروه‌های نام‌گذاری‌شده است: به‌جای ارجاع به آن‌ها با شماره‌ها، می‌توان گروه‌ها را با یک نام ارجاع داد.

سینتکس یک گروه نام‌دار یکی از افزونه‌های خاص پایتون است: (?P<name>...). name، همان‌طور که پیداست، نام گروه است. گروه‌های نام‌دار دقیقاً مانند گروه‌های ثبت‌کننده رفتار می‌کنند و علاوه بر این، نامی را به یک گروه مرتبط می‌سازند. متدهای شیء تطبیق که با گروه‌های ثبت‌کننده سروکار دارند، همگی یا اعداد صحیحی را می‌پذیرند که با شماره به گروه ارجاع می‌دهند یا رشته‌هایی را که شامل نام گروه موردنظر هستند. گروه‌های نام‌دار همچنان شماره‌گذاری می‌شوند، بنابراین می‌توانید اطلاعات مربوط به یک گروه را به دو روش بازیابی کنید:

>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'
>>> m.group(1)
'Lots'

علاوه بر این، می‌توانید گروه‌های نام‌گذاری‌شده را با groupdict() به‌عنوان یک دیکشنری بازیابی کنید:

>>> m = re.match(r'(?P<first>\w+) (?P<last>\w+)', 'Jane Doe')
>>> m.groupdict()
{'first': 'Jane', 'last': 'Doe'}

گروه‌های نام‌گذاری‌شده مفید هستند، زیرا به شما اجازه می‌دهند به‌جای اینکه مجبور باشید اعداد را به‌خاطر بیاورید، از نام‌هایی که به‌راحتی به‌خاطر سپرده می‌شوند استفاده کنید. در اینجا یک نمونه RE از ماژول imaplib آمده است:

InternalDate = re.compile(r'INTERNALDATE "'
        r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'
        r'(?P<year>[0-9][0-9][0-9][0-9])'
        r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'
        r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'
        r'"')

بدیهی است که بازیابی m.group('zonem') بسیار آسان‌تر است، به‌جای اینکه مجبور باشید به یاد داشته باشید که گروه ۹ را بازیابی کنید.

سینتکس ارجاع به عقب (backreference) در عبارتی مانند (...)\1 به شماره‌ی گروه اشاره می‌کند. طبیعتاً گونه‌ای وجود دارد که به‌جای شماره از نام گروه استفاده می‌کند. این یک افزونه‌ی دیگر از پایتون است: (?P=name) نشان می‌دهد که محتوای گروهی به نام name باید دوباره در موقعیت فعلی تطبیق داده شود. عبارت باقاعده برای یافتن کلمات تکراری، \b(\w+)\s+\1\b را همچنین می‌توان به‌صورت \b(?P<word>\w+)\s+(?P=word)\b نوشت:

>>> p = re.compile(r'\b(?P<word>\w+)\s+(?P=word)\b')
>>> p.search('Paris in the the spring').group()
'the the'

ادعاهای پیش‌نگر (Lookahead assertions)¶

یک شرط با عرض‌صفر (zero-width assertion) دیگر، ادعای پیش‌نگر (lookahead assertion) است. ادعاهای پیش‌نگر در هر دو صورت مثبت و منفی در دسترس هستند و به این شکل‌اند:

(?=...): ادعای پیش‌نگر مثبت . این ادعا در صورتی موفق می‌شود که عبارت باقاعده‌ی داخلی، که در اینجا با ... نمایش داده شده است، در موقعیت فعلی با موفقیت تطبیق یابد، و در غیر این صورت ناموفق می‌شود. اما، پس از اینکه عبارت داخلی آزمایش شد، موتور تطبیق به هیچ وجه جلو نمی‌رود؛ بقیه‌ی الگو دقیقاً در همان‌جایی که ادعا شروع شده بود آزمایش می‌شود.
(?!...): ادعای پیش‌نگر منفی (negative lookahead assertion). این ادعا نقطه مقابل ادعای مثبت است؛ اگر عبارت درون آن در موقعیت فعلی رشته مطابقت نداشته باشد، موفق می‌شود.

برای ملموس‌تر کردن این موضوع، موردی را بررسی می‌کنیم که در آن یک پیش‌نگری (lookahead) مفید است. یک الگوی ساده را برای تطبیق یک نام پرونده و تقسیم آن به نام پایه و پسوند، که با . از هم جدا شده‌اند، در نظر بگیرید. برای مثال، در news.rc، news نام پایه است و rc پسوند نام پرونده است.

الگو برای تطبیق این بسیار ساده است:

.*[.].*$

توجه داشته باشید که . باید به‌صورت خاصی با آن رفتار شود، زیرا یک فرانویسه است؛ بنابراین داخل یک کلاس نویسه قرار گرفته است تا فقط همان نویسه‌ی خاص را تطبیق دهد. همچنین به $ پایانی توجه داشته باشید؛ این مورد اضافه شده است تا اطمینان حاصل شود که تمام باقی‌مانده‌ی رشته باید در پسوند گنجانده شود. این عبارت باقاعده با foo.bar و autoexec.bat و sendmail.cf و printers.conf تطبیق دارد.

اکنون، مسئله را کمی پیچیده‌تر در نظر بگیرید؛ اگر بخواهید نام پرونده‌هایی را تطبیق دهید که پسوندشان bat نیست، چه؟ چند تلاش نادرست:

.*[.][^b].*$

نخستین تلاش در بالا سعی می‌کند bat را با این شرط که نخستین نویسه‌ی پسوند یک b نباشد، مستثنا کند. این اشتباه است، زیرا الگو نیز با foo.bar مطابقت ندارد.

.*[.]([^b]..|.[^a].|..[^t])$

هنگامی که سعی کنید راه‌حل اول را با الزام تطابق یکی از حالت‌های زیر اصلاح کنید، عبارت آشفته‌تر می‌شود: نویسه اول پسوند b نباشد؛ نویسه دوم a نباشد؛ یا نویسه سوم t نباشد. این عبارت foo.bar را می‌پذیرد و autoexec.bat را رد می‌کند، اما به یک پسوند سه‌حرفی نیاز دارد و نام پرونده‌ای با پسوند دوحرفی مانند sendmail.cf را نمی‌پذیرد. در تلاش برای اصلاح آن، بار دیگر الگو را پیچیده خواهیم کرد.

.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$

در سومین تلاش، دومین و سومین نویسه هر دو اختیاری شده‌اند تا امکان تطبیق پسوندهایی که کوتاه‌تر از ۳ نویسه هستند، مانند sendmail.cf فراهم شود.

الگو اکنون واقعاً پیچیده شده است، که همین موضوع خواندن و درک آن را دشوار می‌کند. بدتر از آن، اگر مسئله تغییر کند و بخواهید هر دو bat و exe را به‌عنوان پسوند مستثنا کنید، الگو حتی پیچیده‌تر و گیج‌کننده‌تر می‌شود.

یک پیش‌نگر منفی (negative lookahead) تمام این سردرگمی را برطرف می‌کند:

.*[.](?!bat$)[^.]*$

منظور از پیش‌نگری منفی (negative lookahead) این است: اگر عبارت bat در این نقطه مطابقت نداشته باشد، بقیه‌ی الگو امتحان می‌شود؛ اگر bat$ مطابقت داشته باشد، کل الگو شکست خواهد خورد. $ پایانی لازم است تا اطمینان حاصل شود که موردی مانند sample.batch، که پسوند آن فقط با bat شروع می‌شود، مجاز خواهد بود. [^.]* اطمینان حاصل می‌کند که الگو در صورت وجود چند نقطه در نام پرونده کار می‌کند.

مستثنی کردن یک پسوند نام پرونده دیگر اکنون آسان است؛ کافی است آن را به‌عنوان یک جایگزین درون ادعا اضافه کنید. الگوی زیر نام پرونده‌هایی را که به bat یا exe ختم می‌شوند، مستثنی می‌کند:

.*[.](?!bat$|exe$)[^.]*$

تغییر رشته‌ها¶

تا این مرحله، ما صرفاً جست‌وجوهایی را روی یک رشته‌ی ثابت انجام داده‌ایم. عبارت‌های باقاعده همچنین معمولاً برای اصلاح رشته‌ها به روش‌های مختلف، با استفاده از متدهای الگوی زیر به کار می‌روند:

متد/ویژگی	هدف
`split()`	رشته را به یک فهرست تقسیم می‌کند، به‌گونه‌ای که در هر جایی که RE تطابق داشته باشد، تقسیم می‌شود
`sub()`	تمام زیررشته‌هایی را که عبارت باقاعده با آن‌ها مطابقت دارد، پیدا کنید و آن‌ها را با رشته دیگری جایگزین کنید
`subn()`	همان کار `sub()` را انجام می‌دهد، اما رشته جدید و تعداد جایگزینی‌ها را برمی‌گرداند

جداسازی رشته‌ها¶

متد split() یک الگو، رشته را در هر جایی که عبارت باقاعده تطابق داشته باشد از هم جدا می‌کند و فهرستی از تکه‌ها را برمی‌گرداند. این متد مشابه متد split() رشته‌ها است، اما در جداکننده‌هایی که می‌توانید بر اساس آن‌ها تقسیم کنید، عمومیت بسیار بیشتری فراهم می‌کند؛ متد split() رشته فقط از تقسیم بر اساس فضای سفید یا یک رشته ثابت پشتیبانی می‌کند. همان‌طور که انتظار دارید، یک تابع re.split() در سطح ماژول نیز وجود دارد.

.split(string[, maxsplit=0]): string را بر اساس تطابق‌های عبارت باقاعده جدا می‌کند. اگر از پرانتزهای ثبت‌کننده (capturing parentheses) در عبارت باقاعده استفاده شود، محتویات آن‌ها نیز به‌عنوان بخشی از فهرست حاصل برگردانده می‌شود. اگر maxsplit غیرصفر باشد، حداکثر maxsplit جداسازی انجام می‌شود.

شما می‌توانید با ارسال یک مقدار برای maxsplit، تعداد جداسازی‌های انجام‌شده را محدود کنید. هنگامی که maxsplit غیرصفر باشد، حداکثر maxsplit جداسازی انجام خواهد شد و باقی‌مانده‌ی رشته به‌عنوان آخرین عنصر فهرست بازگردانده می‌شود. در مثال زیر، جداکننده هر دنباله‌ای از نویسه‌های غیرالفبایی-عددی است.

>>> p = re.compile(r'\W+')
>>> p.split('This is a test, short and sweet, of split().')
['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']
>>> p.split('This is a test, short and sweet, of split().', 3)
['This', 'is', 'a', 'test, short and sweet, of split().']

گاهی شما نه‌تنها به این علاقه‌مندید که متن بین جداکننده‌ها چیست، بلکه نیاز دارید بدانید جداکننده چه بوده است. اگر در RE از پرانتزهای گیرنده استفاده شود، مقادیر آن‌ها نیز به‌عنوان بخشی از فهرست برگردانده می‌شوند. فراخوانی‌های زیر را مقایسه کنید:

>>> p = re.compile(r'\W+')
>>> p2 = re.compile(r'(\W+)')
>>> p.split('This... is a test.')
['This', 'is', 'a', 'test', '']
>>> p2.split('This... is a test.')
['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']

تابع سطح ماژول re.split()، RE را برای استفاده به‌عنوان اولین آرگومان اضافه می‌کند، اما در غیر این صورت یکسان است.

>>> re.split(r'[\W]+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split(r'([\W]+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split(r'[\W]+', 'Words, words, words.', 1)
['Words', 'words, words.']

جستجو و جایگزینی¶

یکی دیگر از وظایف رایج، پیدا کردن همه‌ی تطابق‌های یک الگو و جایگزینی آن‌ها با رشته‌ای متفاوت است. متد sub() یک مقدار جایگزینی را می‌گیرد، که می‌تواند رشته یا تابع باشد، و نیز رشته‌ای را که باید پردازش شود.

.sub(replacement, string[, count=0])

رشته‌ی حاصل از جایگزینی چپ‌ترین رخدادهای غیرهم‌پوشان عبارت باقاعده در string با جایگزین replacement را برمی‌گرداند. اگر الگو یافت نشود، string بدون تغییر برگردانده می‌شود.

آرگومان اختیاری count حداکثر تعداد رخدادهای الگو برای جایگزینی است؛ count باید یک عدد صحیح غیرمنفی باشد. مقدار پیش‌فرض ۰ به معنای جایگزینی تمام رخدادها است.

در اینجا یک مثال ساده از استفاده از متد sub() آمده است. این مثال نام رنگ‌ها را با کلمه colour جایگزین می‌کند:

>>> p = re.compile('(blue|white|red)')
>>> p.sub('colour', 'blue socks and red shoes')
'colour socks and colour shoes'
>>> p.sub('colour', 'blue socks and red shoes', count=1)
'colour socks and red shoes'

متد subn() همان کار را انجام می‌دهد، اما یک تاپل دوتایی شامل مقدار رشته‌ی جدید و تعداد جایگزینی‌های انجام‌شده را بازمی‌گرداند:

>>> p = re.compile('(blue|white|red)')
>>> p.subn('colour', 'blue socks and red shoes')
('colour socks and colour shoes', 2)
>>> p.subn('colour', 'no colours at all')
('no colours at all', 0)

تطابق‌های خالی تنها زمانی جایگزین می‌شوند که مجاور یک تطابق خالی پیشین نباشند.

>>> p = re.compile('x*')
>>> p.sub('-', 'abxd')
'-a-b--d-'

اگر replacement یک رشته باشد، هرگونه دنباله‌ی خنثی‌سازی با بک‌اسلش در آن پردازش می‌شود. یعنی \n به یک نویسه‌ی خط جدید تبدیل می‌شود، \r به یک بازگشت به ابتدای سطر تبدیل می‌شود، و غیره. دنباله‌های خنثی‌سازی ناشناخته مانند \& دست‌نخورده باقی می‌مانند. بازارجاع‌ها (backreferences)، مانند \6، با زیررشته‌ای که گروه متناظر در عبارت باقاعده آن را تطبیق داده است جایگزین می‌شوند. این امکان را به شما می‌دهد تا بخش‌هایی از متن اصلی را در رشته‌ی جایگزینی حاصل بگنجانید.

این مثال با کلمه section و به دنبال آن رشته‌ای که در { و } محصور شده است مطابقت می‌کند و section را به subsection تغییر می‌دهد:

>>> p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)
>>> p.sub(r'subsection{\1}','section{First} section{second}')
'subsection{First} subsection{second}'

همچنین سینتکسی برای ارجاع به گروه‌های نام‌دار وجود دارد، همان‌طور که با سینتکس (?P<name>...) تعریف شده است. \g<name> از زیررشته‌ی مطابقت‌داده‌شده توسط گروهی به نام name استفاده می‌کند، و \g<number> از شماره‌ی گروه متناظر استفاده می‌کند. بنابراین \g<2> معادل \2 است، اما در رشته‌ی جایگزینی مانند \g<2>0 مبهم نیست. (\20 به‌عنوان ارجاعی به گروه ۲۰ تفسیر می‌شود، نه ارجاعی به گروه ۲ که به دنبال آن نویسه‌ی لفظی '0' آمده است.) همه‌ی جایگزینی‌های زیر معادل هستند، اما از هر سه شکل رشته‌ی جایگزینی استفاده می‌کنند.

>>> p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)
>>> p.sub(r'subsection{\1}','section{First}')
'subsection{First}'
>>> p.sub(r'subsection{\g<1>}','section{First}')
'subsection{First}'
>>> p.sub(r'subsection{\g<name>}','section{First}')
'subsection{First}'

replacement همچنین می‌تواند یک تابع باشد، که کنترل حتی بیشتری به شما می‌دهد. اگر replacement یک تابع باشد، تابع برای هر رخداد غیرهم‌پوشان pattern فراخوانی می‌شود. در هر فراخوانی، یک آرگومان شیء تطبیق برای تطبیق به تابع داده می‌شود و می‌تواند از این اطلاعات برای محاسبه رشته جایگزینی مورد نظر و برگرداندن آن استفاده کند.

در مثال زیر، تابع جایگزینی اعداد مبنای ده را به مبنای شانزده تبدیل می‌کند:

>>> def hexrepl(match):
...     "Return the hex string for a decimal number"
...     value = int(match.group())
...     return hex(value)
...
>>> p = re.compile(r'\d+')
>>> p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')
'Call 0xffd2 for printing, 0xc000 for user code.'

هنگام استفاده از تابع re.sub() در سطح ماژول، الگو به‌عنوان اولین آرگومان ارسال می‌شود. الگو می‌تواند به‌صورت یک شیء یا یک رشته ارائه شود؛ اگر نیاز به تعیین پرچم‌های عبارت باقاعده دارید، باید یا از یک شیء الگو به‌عنوان اولین پارامتر استفاده کنید، یا از تغییردهنده‌های تعبیه‌شده در رشته الگو استفاده کنید، برای مثال sub("(?i)b+", "x", "bbbb BBBB") مقدار 'x x' را برمی‌گرداند.

مشکلات رایج¶

عبارات باقاعده برای برخی از کاربردها ابزار قدرتمندی هستند، اما رفتار آن‌ها از برخی جهات شهودی نیست و گاهی آن‌طور که ممکن است انتظار داشته باشید رفتار نمی‌کنند. این بخش به برخی از رایج‌ترین دام‌ها اشاره می‌کند.

از متدهای رشته استفاده کنید¶

گاهی استفاده از ماژول re یک اشتباه است. اگر در حال تطبیق یک رشته ثابت یا یک کلاس نویسه واحد هستید و از هیچ‌یک از قابلیت‌های re مانند پرچم IGNORECASE استفاده نمی‌کنید، ممکن است به قدرت کامل عبارات باقاعده نیازی نباشد. رشته‌ها چندین متد برای انجام عملیات روی رشته‌های ثابت دارند و معمولاً بسیار سریع‌تر هستند، زیرا پیاده‌سازی آن‌ها یک حلقه‌ی C کوچک واحد است که برای همین منظور بهینه‌سازی شده است، نه موتور بزرگ و عمومی‌تر عبارات باقاعده.

یک مثال ممکن است جایگزین کردن یک رشته ثابت با رشته‌ای دیگر باشد؛ برای مثال، ممکن است بخواهید word را با deed جایگزین کنید. re.sub() به نظر می‌رسد تابع مناسبی برای این کار باشد، اما متد replace() را در نظر بگیرید. توجه داشته باشید که replace() نیز word را درون کلمات جایگزین می‌کند و swordfish را به sdeedfish تبدیل می‌کند، اما عبارت باقاعده‌ی ساده‌ی word نیز همین کار را انجام می‌داد. (برای جلوگیری از اعمال جایگزینی بر بخش‌هایی از کلمات، الگو باید \bword\b باشد تا وجود یک مرز کلمه در هر دو طرف word الزامی شود. این کار فراتر از توانایی‌های replace() است.)

یک کار رایج دیگر، حذف تمام رخدادهای یک نویسه از یک رشته یا جایگزینی آن با یک نویسه‌ی دیگر است. ممکن است این کار را با چیزی مانند re.sub('\n', ' ', S) انجام دهید، اما translate() قادر به انجام هر دو کار است و سریع‌تر از هر عملیات عبارت باقاعده خواهد بود.

به‌طور خلاصه، پیش از مراجعه به ماژول re، در نظر بگیرید که آیا مسئله شما می‌تواند با یک متد رشته‌ای سریع‌تر و ساده‌تر حل شود.

match() در برابر search()¶

تابع match() فقط بررسی می‌کند که آیا RE در ابتدای رشته مطابقت دارد یا خیر، در حالی که search() رشته را برای یافتن یک مطابقت به سمت جلو پیمایش می‌کند. مهم است که این تمایز را در نظر داشته باشید. به یاد داشته باشید، match() فقط مطابقت موفقی را گزارش می‌کند که از ۰ شروع شود؛ اگر مطابقت از صفر شروع نشود، match() آن را گزارش نخواهد کرد.

>>> print(re.match('super', 'superstition').span())
(0, 5)
>>> print(re.match('super', 'insuperable'))
None

از سوی دیگر، search() رشته را به سمت جلو پیمایش می‌کند و اولین تطابقی را که پیدا کند گزارش می‌دهد.

>>> print(re.search('super', 'superstition').span())
(0, 5)
>>> print(re.search('super', 'insuperable').span())
(2, 7)

گاهی ممکن است وسوسه شوید که همچنان از re.match() استفاده کنید و فقط .* را به ابتدای عبارت باقاعده‌ی خود اضافه کنید. در برابر این وسوسه مقاومت کنید و به‌جای آن از re.search() استفاده کنید. کامپایلر عبارت باقاعده، عبارت‌های باقاعده را تا حدی تحلیل می‌کند تا فرایند جست‌وجو برای تطبیق را سرعت بخشد. یکی از این تحلیل‌ها مشخص می‌کند که اولین نویسه‌ی یک تطبیق باید چه باشد؛ برای مثال، الگویی که با Crow شروع می‌شود باید تطبیق را با یک 'C' آغاز کند. این تحلیل به موتور اجازه می‌دهد رشته را به‌سرعت برای یافتن نویسه‌ی آغازین پیمایش کند و تنها در صورتی که یک 'C' یافت شود، تطبیق کامل را بیازماید.

افزودن .* این بهینه‌سازی را بی‌اثر می‌کند و به پیمایش تا پایان رشته و سپس پس‌گرد برای یافتن تطابق برای بقیه‌ی RE نیاز دارد. در عوض از re.search() استفاده کنید.

حریصانه در برابر غیرحریصانه¶

هنگام تکرار یک عبارت باقاعده، مانند a*، رفتار حاصل این است که تا حد ممکن از الگو مصرف می‌شود. این واقعیت اغلب هنگامی که در حال تلاش برای تطبیق یک جفت از جداکننده‌های متوازن هستید، شما را گرفتار می‌کند، مانند کروشه‌های زاویه‌ای که یک برچسب HTML را احاطه کرده‌اند. الگوی ساده برای تطبیق یک برچسب HTML به دلیل ماهیت حریصانه‌ی .* کار نمی‌کند.

>>> s = '<html><head><title>Title</title>'
>>> len(s)
32
>>> print(re.match('<.*>', s).span())
(0, 32)
>>> print(re.match('<.*>', s).group())
<html><head><title>Title</title>

عبارت باقاعده با '<' در '<html>' مطابقت می‌کند، و .* باقی‌مانده‌ی رشته را مصرف می‌کند. با این حال، هنوز بخش‌های بیشتری از عبارت باقاعده باقی مانده است، و > نمی‌تواند در پایان رشته مطابقت کند، بنابراین موتور عبارت باقاعده باید نویسه‌به‌نویسه عقب‌گرد کند تا اینکه تطابقی برای > بیابد. تطابق نهایی از '<' در '<html>' تا '>' در '</title>' ادامه دارد، که این چیزی نیست که شما می‌خواهید.

در این حالت، راه‌حل استفاده از کمیت‌گذارهای غیرحریص *?، +?، ?? یا {m,n}? است، که تا حد امکان متن کمی را تطبیق می‌دهند. در مثال بالا، بلافاصله پس از تطبیق اولین '<'، تلاش برای تطبیق '>' انجام می‌شود، و وقتی این تلاش شکست می‌خورد، موتور هر بار یک نویسه جلو می‌رود و در هر مرحله برای تطبیق '>' دوباره تلاش می‌کند. این دقیقاً نتیجه درست را تولید می‌کند:

>>> print(re.match('<.*?>', s).group())
<html>

(توجه داشته باشید که تجزیه‌ی HTML یا XML با عبارت‌های باقاعده دشوار است. الگوهای سریع و سرسری حالت‌های رایج را پوشش می‌دهند، اما HTML و XML حالت‌های خاصی دارند که عبارت باقاعده‌ی بدیهی را از کار می‌اندازند؛ تا وقتی که عبارت باقاعده‌ای بنویسید که تمام حالت‌های ممکن را پوشش دهد، الگوها بسیار پیچیده خواهند شد. برای چنین کارهایی از یک ماژول پارسر HTML یا XML استفاده کنید.)

استفاده از re.VERBOSE¶

احتمالاً تاکنون متوجه شده‌اید که عبارات باقاعده نمادگذاری بسیار فشرده‌ای هستند، اما چندان خوانا نیستند. عبارات باقاعده با پیچیدگی متوسط می‌توانند به مجموعه‌های بلندی از بک‌اسلش‌ها، پرانتزها و فرانویسه‌ها تبدیل شوند، که خواندن و درک آن‌ها را دشوار می‌سازد.

برای چنین عبارت‌های باقاعده‌ای، تعیین پرچم re.VERBOSE هنگام کامپایل عبارت باقاعده می‌تواند مفید باشد، زیرا به شما امکان می‌دهد عبارت باقاعده را واضح‌تر قالب‌بندی کنید.

پرچم re.VERBOSE چندین اثر دارد. فضای خالی در عبارت باقاعده که داخل یک کلاس نویسه نباشد نادیده گرفته می‌شود. این بدان معناست که عبارتی مانند dog | cat معادل dog|cat با خوانایی کمتر است، اما [a b] همچنان با نویسه‌های 'a'، 'b' یا یک فاصله مطابقت خواهد کرد. علاوه بر این، می‌توانید کامنت‌هایی را نیز داخل یک عبارت باقاعده قرار دهید؛ کامنت از یک نویسه # تا خط جدید بعدی ادامه می‌یابند. هنگامی که با رشته‌های سه‌نقل‌قولی استفاده شود، این امر امکان می‌دهد عبارت‌های باقاعده به‌صورت مرتب‌تری قالب‌بندی شوند:

pat = re.compile(r"""
 \s*                 # Skip leading whitespace
 (?P<header>[^:]+)   # Header name
 \s* :               # Whitespace, and a colon
 (?P<value>.*?)      # The header's value -- *? used to
                     # lose the following trailing whitespace
 \s*$                # Trailing whitespace to end-of-line
""", re.VERBOSE)

این بسیار خواناتر از این است:

pat = re.compile(r"\s*(?P<header>[^:]+)\s*:(?P<value>.*?)\s*$")

بازخورد¶

عبارات باقاعده موضوعی پیچیده هستند. آیا این سند به شما کمک کرد تا آن‌ها را درک کنید؟ آیا بخش‌هایی مبهم بودند، یا مشکلاتی که با آن‌ها مواجه شدید و در اینجا پوشش داده نشده‌اند؟ در این صورت، لطفاً پیشنهادهای بهبود را به پیگیری مشکلات (issue tracker) ارسال کنید.

کامل‌ترین کتاب درباره عبارت‌های باقاعده تقریباً با قطعیت کتاب Mastering Regular Expressions اثر Jeffrey Friedl است که توسط O'Reilly منتشر شده است. متأسفانه، این کتاب منحصراً بر گونه‌های عبارت‌های باقاعده در Perl و Java تمرکز دارد و اصلاً هیچ مطلبی درباره پایتون ندارد، بنابراین به‌عنوان مرجعی برای برنامه‌نویسی پایتون مفید نخواهد بود. (نخستین ویرایش این کتاب ماژول regex پایتون را پوشش می‌داد که اکنون حذف شده است و کمک چندانی به شما نخواهد کرد.) امانت گرفتن آن را از کتابخانه خود در نظر داشته باشید.