पाइथन

Question

में फोल्डिंग द्वारा यूनिकोड स्ट्रिंग मिलान को कार्यान्वित करने के लिए मेरे पास एक वृद्धिशील खोज को लागू करने वाला एक एप्लिकेशन है। मेरे पास मिलान करने के लिए यूनिकोड तारों की एक सूची है और उन्हें किसी दिए गए "कुंजी" स्ट्रिंग से मिलान करें; एक कैटलॉग स्ट्रिंग एक "हिट" है यदि इसमें कुंजी के सभी वर्ण शामिल हैं, क्रम में, और कैटलॉग स्ट्रिंग में कुंजी वर्ण क्लस्टर होने पर यह बेहतर रैंक किया जाता है।

वैसे भी, यह ठीक काम करता है और वास्तव में यूनिकोड से मेल खाता है, ताकि "Ost" "Ost Blocket" या "आर Ost" या "आर ö घ सेंट एन" से मेल खाएगी।

वैसे भी, अब मैं फोल्डिंग को कार्यान्वित करना चाहता हूं, क्योंकि कुछ ऐसे मामले हैं जहां कैटलॉग कैरेक्टर जैसे "á" या "é" और मुख्य वर्ण "ए" या "ई" के बीच अंतर करना उपयोगी नहीं है।

उदाहरण के लिए: "ओले" "Olé"

से मेल खाना चाहिए मैं कैसे सबसे अच्छा अजगर में इस यूनिकोड-तह मिलान लागू करते हैं? दक्षता महत्वपूर्ण है क्योंकि मुझे छोटी, दिए गए कुंजी पर हजारों कैटलॉग तारों से मेल खाना पड़ेगा।

इसे इसे ascii में बदलना नहीं है; वास्तव में, एल्गोरिदम की आउटपुट स्ट्रिंग यूनिकोड हो सकती है। इसमें एक चरित्र छोड़ना इसे अलग करने से बेहतर है।

---

मुझे नहीं पता कि कौन सा जवाब स्वीकार करना है, क्योंकि मैं दोनों का थोड़ा सा उपयोग करता हूं। एनकेएफडी अपघटन को लेना और संयोजन अंकों को हटाने का लगभग पूरा तरीका है, मैं केवल कुछ कस्टम लिप्यंतरण जोड़ता हूं। यहाँ मॉड्यूल है, क्योंकि यह अब दिखता है: (चेतावनी, यूनिकोड वर्ण इनलाइन, शामिल हैं के बाद से यह बहुत अच्छा है कि जिस तरह से संपादित करने के लिए।)

# -*- encoding: UTF-8 -*- 

import unicodedata 
from unicodedata import normalize, category 

def _folditems(): 
    _folding_table = { 
     # general non-decomposing characters 
     # FIXME: This is not complete 
     u"ł" : u"l", 
     u"œ" : u"oe", 
     u"ð" : u"d", 
     u"þ" : u"th", 
     u"ß" : u"ss", 
     # germano-scandinavic canonical transliterations 
     u"ü" : u"ue", 
     u"å" : u"aa", 
     u"ä" : u"ae", 
     u"æ" : u"ae", 
     u"ö" : u"oe", 
     u"ø" : u"oe", 
    } 

    for c, rep in _folding_table.iteritems(): 
     yield (ord(c.upper()), rep.title()) 
     yield (ord(c), rep) 

folding_table = dict(_folditems()) 

def tofolded(ustr): 
    u"""Fold @ustr 

    Return a unicode str where composed characters are replaced by 
    their base, and extended latin characters are replaced by 
    similar basic latin characters. 

    >>> tofolded(u"Wyłącz") 
    u'Wylacz' 
    >>> tofolded(u"naïveté") 
    u'naivete' 

    Characters from other scripts are not transliterated. 

    >>> tofolded(u"Ἑλλάς") == u'Ελλας' 
    True 

    (These doctests pass, but should they fail, they fail hard) 
    """ 
    srcstr = normalize("NFKD", ustr.translate(folding_table)) 
    return u"".join(c for c in srcstr if category(c) != 'Mn') 

if __name__ == '__main__': 
    import doctest 
    doctest.testmod() 

(और, वास्तविक मिलान के लिए करता है, तो है कि किसी को दिलचस्पी: मैं मुड़ा का निर्माण मेरे सभी सूची के लिए तार पहले से है, और पहले से ही उपलब्ध सूची वस्तु उर्फ ​​संपत्ति में मुड़ा हुआ संस्करणों डाल)

Answer 1

आप thisstrip_accents समारोह का उपयोग कर सकते लहजे दूर करने के लिए:

http://pypi.python.org/pypi/Unidecode

यह है:

def strip_accents(s): 
    return ''.join((c for c in unicodedata.normalize('NFD', unicode(s)) if unicodedata.category(c) != 'Mn')) 

>>> strip_accents(u'Östblocket') 
'Ostblocket' 

Answer 2

इस पर एक नज़र डालें:। ftp://alan.smcvt.edu/hefferon/unicode2ascii.py

शायद पूरा नहीं हुआ है, लेकिन मिल सकता है आप शुरू कर दिया।

Answer 3

एक सामान्य प्रयोजन समाधान (विशेष रूप से खोज सामान्यीकरण और पैदा मल के लिए) unidecode मॉड्यूल है पर्ल के लिए पाठ :: यूनिडोड मॉड्यूल का एक बंदरगाह। यह पूरा नहीं हुआ है, लेकिन यह लैटिन-व्युत्पन्न पात्रों का अनुवाद करता है जो मुझे मिल सकता है, लैटिन में सिरिलिक, चीनी, आदि का अनुवाद करता है और यहां तक ​​कि पूर्ण-चौड़ाई वाले वर्णों को सही तरीके से संभालता है।

यह शायद एक अच्छा विचार है बस सभी पात्रों आप अंतिम आउटपुट में है या उन्हें एक पूरक के साथ बदलने के लिए नहीं करना चाहती पट्टी है (उदाहरण के लिए "äßœ$""assoe$" को unidecoded किया जाएगा, ताकि आप गैर अक्षर या अंक पट्टी करना चाह सकते हैं)।पात्रों के लिए यह अनुवाद कर लेकिन जाएगा चाहिए नहीं (जैसे कि, § =>SS और € =>EU) आप इनपुट को साफ करने की जरूरत है:

input_str = u'äßœ$' 
input_str = u''.join([ch if ch.isalnum() else u'-' for ch in input_str]) 
input_str = str(unidecode(input_str)).lower() 

यह एक डमी प्रतिस्थापन के साथ सभी गैर अक्षरांकीय अक्षर की जगह लेंगे और फिर स्ट्रिंग को टाइप करें और इसे लोअरकेस में बदल दें।

Answer 4

क्या इस एक के बारे में:

normalize('NFKD', unicode_string).encode('ASCII', 'ignore').lower() 

यहाँ से लिया (स्पेनिश) http://python.org.ar/pyar/Recetario/NormalizarCaracteresUnicode

Answer 5

अपने आवेदन के लिए, मैं पहले से ही एक अलग टिप्पणी में इस को संबोधित: मैं एक यूनिकोड करना चाहते हैं परिणाम और अनचाहे वर्ण अनछुए छोड़ दें।

उस मामले में, यह करने के लिए सही तरीका अपनी ताकत केवल प्राथमिक ताकत पर तुलना करने के लिए सेट है, जो इस तरह पूरी तरह से विशेषक की उपेक्षा के साथ एक UCA कोलेटर वस्तु बनाने के लिए है।

मैं दिखाता हूं कि this answer में पर्ल का उपयोग करके इसे कैसे किया जाए। पहली कॉललेटर ऑब्जेक्ट आपको आवश्यक ताकत पर है, जबकि दूसरा टाई ब्रेकिंग के लिए उच्चारण मानता है।

आप ध्यान देंगे कि इन तुलनाओं को बनाने में कोई तार नहीं पहुंचा है: मूल डेटा छूटा हुआ है।