पायथन-रे: मैं अल्फा कैरेक्टर

Question

से कैसे मेल करूं? मैं नियमित अभिव्यक्ति के साथ अल्फा वर्ण से कैसे मिलान कर सकता हूं। मुझे एक चरित्र चाहिए जो \w में है लेकिन \d में नहीं है। मैं इसे यूनिकोड संगत चाहता हूं इसलिए मैं [a-zA-Z] का उपयोग नहीं कर सकता।

Answer 1

आपके पहले दो वाक्यों में एक दूसरे का विरोधाभास है। "\w में लेकिन \d में नहीं है" अंडरस्कोर शामिल है। मैं आपकी तीसरी वाक्य से मान रहा हूं कि आप अंडरस्कोर नहीं चाहते हैं।

लिफाफा के पीछे एक वेन आरेख का उपयोग करने में मदद करता है।

(1) अक्षर हैं जो \w से मेल नहीं खाते हैं (यानी कुछ भी है कि अल्फा, अंक, या अंडरस्कोर नहीं है नहीं करना चाहती) =>\W
(2) अंक =: चलो हम नहीं करते क्या चाहते हैं पर नजर डालते हैं >\d
(3) को रेखांकित =>_

तो हम नहीं है क्या चाहते चरित्र वर्ग [\W\d_] में कुछ भी है और इसके परिणामस्वरूप हम क्या चाहते हैं चरित्र वर्ग [^\W\d_]

यहाँ में कुछ भी है एक सरल उदाहरण है (पायथन 2.6)।

>>> import re 
>>> rx = re.compile("[^\W\d_]+", re.UNICODE) 
>>> rx.findall(u"abc_def,k9") 
[u'abc', u'def', u'k'] 

इसके अलावा अन्वेषण इस दृष्टिकोण के कुछ quirks का पता चलता है:

>>> import unicodedata as ucd 
>>> allsorts =u"\u0473\u0660\u06c9\u24e8\u4e0a\u3020\u3021" 
>>> for x in allsorts: 
...  print repr(x), ucd.category(x), ucd.name(x) 
... 
u'\u0473' Ll CYRILLIC SMALL LETTER FITA 
u'\u0660' Nd ARABIC-INDIC DIGIT ZERO 
u'\u06c9' Lo ARABIC LETTER KIRGHIZ YU 
u'\u24e8' So CIRCLED LATIN SMALL LETTER Y 
u'\u4e0a' Lo CJK UNIFIED IDEOGRAPH-4E0A 
u'\u3020' So POSTAL MARK FACE 
u'\u3021' Nl HANGZHOU NUMERAL ONE 
>>> rx.findall(allsorts) 
[u'\u0473', u'\u06c9', u'\u4e0a', u'\u3021'] 

U + 3021 (हांग्जो अंक एक) संख्यात्मक रूप में व्यवहार किया जाता है (इसलिए यह w \ मेल खाता है), लेकिन ऐसा लगता है कि अजगर की व्याख्या " अंकों "मतलब" दशमलव अंकों "(श्रेणी एन डी) तो यह मेल नहीं खाता \ घ

U + 2438 (परिक्रमा लैटिन छोटे अक्षर वाई) से मेल खाते हैं \ w

सभी CJK ideographs वर्गीकृत कर रहे हैं नहीं है "अक्षरों" के रूप में और इस तरह से मिलान करें \ w

चाहे उपरोक्त में से कोई भी 3 अंक चिंता का विषय है या नहीं, यह दृष्टिकोण सबसे अच्छा है जिसे आप वर्तमान में जारी किए गए मॉड्यूल से बाहर निकलेंगे। \ P {letter} की तरह सिंटेक्स भविष्य में है।

Answer 2

के बारे में क्या:

\p{L} 

आप संदर्भ के रूप में इस दस्तावेज़ का उपयोग करने के कर सकते हैं: Unicode Regular Expressions

संपादित करें: लगता Python doesn't handle Unicode expressions। इस लिंक में एक नज़र डालें: Handling Accented Characters with Python Regular Expressions -- [A-Z] just isn't good enough (अब सक्रिय नहीं है, इंटरनेट संग्रह करने के लिए लिंक)

एक अन्य संदर्भ:

• re.UNICODE
• python and regular expression with unicode
• Unicode Technical Standard #18: Unicode Regular Expressions

---

के लिए वंशावली, ब्लॉग पर उदाहरण यहां दिए गए हैं:

import re 
string = 'riché' 
print string 
riché 

richre = re.compile('([A-z]+)') 
match = richre.match(string) 
print match.groups() 
('rich',) 

richre = re.compile('(\w+)',re.LOCALE) 
match = richre.match(string) 
print match.groups() 
('rich',) 

richre = re.compile('([é\w]+)') 
match = richre.match(string) 
print match.groups() 
('rich\xe9',) 

richre = re.compile('([\xe9\w]+)') 
match = richre.match(string) 
print match.groups() 
('rich\xe9',) 

richre = re.compile('([\xe9-\xf8\w]+)') 
match = richre.match(string) 
print match.groups() 
('rich\xe9',) 

string = 'richéñ' 
match = richre.match(string) 
print match.groups() 
('rich\xe9\xf1',) 

richre = re.compile('([\u00E9-\u00F8\w]+)') 
print match.groups() 
('rich\xe9\xf1',) 

matched = match.group(1) 
print matched 
richéñ 

Answer 3

आप एक ही अक्षर से मेल करने के लिए निम्न भाव से एक का उपयोग कर सकते हैं:

(?![\d_])\w 

या

\w(?<![\d_]) 

यहाँ मैं \w मेल, लेकिन जाँच करें कि [\d_] से पहले दर्ज नहीं होता है/उस के बाद ।

डॉक्स से:

(?!...) 
Matches if ... doesn’t match next. This is a negative lookahead assertion. For example, Isaac (?!Asimov) will match 'Isaac ' only if it’s not followed by 'Asimov'. 

(?<!...) 
Matches if the current position in the string is not preceded by a match for .... This is called a negative lookbehind assertion. Similar to positive lookbehind assertions, the contained pattern must only match strings of some fixed length and shouldn’t contain group references. Patterns which start with negative lookbehind assertions may match at the beginning of the string being searched.