पायथन स्ट्रिंग्स

Question

मामले को अनदेखा करें मामले को अनदेखा करते हुए पायथन में स्ट्रिंग की तुलना करने का सबसे आसान तरीका क्या है?

बेशक कोई भी कर सकता है (str1.lower() < = str2.lower()), लेकिन इससे दो अतिरिक्त अस्थायी तार (स्पष्ट आवंटन/जी-सी ओवरहेड के साथ) बनाया गया।

मुझे लगता है कि मैं सी के stricmp() के बराबर की तलाश में हूं।

[कुछ और संदर्भ अनुरोध किया, तो मैं एक छोटी सी उदाहरण के साथ प्रदर्शित होगी:]

मान लीजिए आप तार के एक looong सूची क्रमबद्ध करना चाहते हैं। आप बस theist.sort() करते हैं। यह ओ (एन * लॉग (एन)) स्ट्रिंग तुलना और कोई मेमोरी प्रबंधन नहीं है (क्योंकि सभी तार और सूची तत्व कुछ प्रकार के स्मार्ट पॉइंटर्स हैं)। तुम खुश हो।

अब, आप ऐसा करना चाहते हैं, लेकिन मामले को अनदेखा करें (चलो सरल बनाएं और कहें सभी तार एसीआईआई हैं, इसलिए स्थानीय मुद्दों को अनदेखा किया जा सकता है)। आपList.sort (key = lambda s: s.lower()) कर सकते हैं, लेकिन फिर आप प्रति तुलना दो नए आवंटन का कारण बनते हैं, साथ ही डुप्लिकेट (निम्न) स्ट्रिंग्स के साथ कचरा-कलेक्टर बोझ करते हैं। प्रत्येक ऐसे मेमोरी-प्रबंधन शोर ऑर्डर-ऑफ-परिमाण सरल स्ट्रिंग तुलना की तुलना में धीमी है।

अब, एक जगह में stricmp() - जैसे फ़ंक्शन के साथ, आप करते हैं: theList.sort (cmp = stricmp) और यह जितना तेज़ और स्मृति-अनुकूल है list.sort() के रूप में। आप फिर से खुश हैं

समस्या किसी भी पायथन आधारित केस-असंवेदनशील तुलना में अंतर्निहित स्ट्रिंग डुप्लीकेट शामिल है, इसलिए मुझे सी-आधारित तुलना (शायद मॉड्यूल स्ट्रिंग में) खोजने की उम्मीद थी।

ऐसा कुछ भी नहीं मिला, इसलिए सवाल यहां है। (उम्मीद है कि यह प्रश्न स्पष्ट करता है)।

Answer 1

अपने स्पष्टीकरण के जवाब में ...

आप ctypes का उपयोग ग समारोह "strcasecmp" निष्पादित करने के लिए कर सकता है। पाइथन 2.5 में Ctypes शामिल है। यह डीएलएल और libc जैसे साझा पुस्तकालयों को कॉल करने की क्षमता प्रदान करता है। यहाँ एक त्वरित उदाहरण (लिनक्स पर पायथन; Win32 मदद के लिए लिंक देखें) है:

from ctypes import * 
libc = CDLL("libc.so.6") // see link above for Win32 help 
libc.strcasecmp("THIS", "this") // returns 0 
libc.strcasecmp("THIS", "THAT") // returns 8 

भी strcasecmp documentation

नहीं वास्तव में यकीन है कि यह किसी भी तेज़ या धीमे (परीक्षण नहीं किया है) संदर्भ के लिए चाहते हो सकता है, लेकिन यह मामला असंवेदनशील स्ट्रिंग तुलना करने के लिए सी फ़ंक्शन का उपयोग करने का एक तरीका है।

~~~~~~~~~~~~~~

ActiveState Code - Recipe 194371: Case Insensitive Strings एक केस संवेदी स्ट्रिंग वर्ग बनाने के लिए एक नुस्खा है।यह कुछ जल्दी के लिए मारने पर थोड़ा सा हो सकता है, लेकिन यदि आप अक्सर उनका उपयोग करने की योजना बनाते हैं तो आपको केस असंवेदनशील तारों को संभालने का एक आम तरीका प्रदान कर सकता है।

Answer 2

मुझे पूरा यकीन है कि आपको या तो .lower() का उपयोग करना होगा या नियमित अभिव्यक्ति का उपयोग करना होगा। मुझे अंतर्निहित केस-असंवेदनशील स्ट्रिंग तुलना फ़ंक्शन से अवगत नहीं है।

import re 
p = re.compile('^hello$', re.I) 
p.match('Hello') 
p.match('hello') 
p.match('HELLO') 

Answer 3

इस तरह आप फिर से साथ यह करना होता है ।

Answer 4

आप str उपवर्ग और अपने खुद के केस-insenstive स्ट्रिंग वर्ग बनाने लेकिन IMHO कि अत्यंत मूर्ख हो सकता है और कहीं अधिक मुसीबत बनाने की तुलना में यह लायक है होगा सकता है:

Answer 5

सामयिक या यहाँ तक कि बार-बार तुलना के लिए, कुछ अतिरिक्त स्ट्रिंग वस्तुओं चाहिए नहीं मामले के रूप में लंबे समय से इस अपने मूल कोड के अंतरतम पाश में नहीं होगा के रूप में या आपके पास पर्याप्त डेटा वास्तव में प्रदर्शन प्रभाव नोटिस की जरूरत नहीं है । देखें कि आप क्या करते हैं: "बेवकूफ" तरीके से चीजें करना बहुत कम बेवकूफ है यदि आप इसे कम करते हैं।

यदि आप गंभीरता से बहुत सारे और बहुत सारे टेक्स्ट केस की तुलना करना चाहते हैं-असंवेदनशील रूप से आप अंततः तारों के लोअरकेस संस्करणों को अंतिम रूप देने और पुन: निर्माण से बचने के लिए, या पूरे डेटा को लोअरकेस में सामान्यीकृत करने के लिए रख सकते हैं। यह निश्चित रूप से डेटा सेट के आकार पर निर्भर करता है। यदि अपेक्षाकृत कुछ सुइयों और एक बड़े घास के मैदान हैं, तो संकलित regexp वस्तुओं के साथ सुइयों की जगह एक समाधान है। यदि ठोस उदाहरण देखने के बिना कहना मुश्किल है।

Answer 6

आपके इच्छित कार्य के बराबर कोई भी निर्मित नहीं है।

आप अपने स्वयं के फ़ंक्शन को लिख सकते हैं जो एक ही समय में प्रत्येक अक्षर को .lower() में परिवर्तित करता है ताकि दोनों तारों को डुप्लिकेट करने से बच सकें, लेकिन मुझे यकीन है कि यह बहुत सीपीयू-गहन और बेहद अक्षम होगा।

आप बहुत देर तक तार (इतने लंबे समय है कि एक स्मृति समस्या अगर दोहराया पैदा कर सकता है) के साथ काम कर रहे हैं जब तक तो मैं इसे सरल रखने के लिए और

str1.lower() == str2.lower() 

का प्रयोग करेंगे आप ठीक हो जाएगा

Answer 7

आप कर रहे हैं यह एक अत्यधिक प्रदर्शन के प्रति संवेदनशील आवेदन की एक बहुत-अक्सर-निष्पादित रास्ते में तुलना का उपयोग कर? वैकल्पिक रूप से, क्या आप इसे तारों पर चल रहे हैं जो आकार में मेगाबाइट हैं? यदि नहीं, तो आप प्रदर्शन के बारे में चिंता नहीं करनी चाहिए और सिर्फ .lower() विधि का उपयोग करें।

निम्नलिखित कोड को दर्शाता है कि एक कर केस-संवेदी दो श्रृंखलाएं जिनमें प्रत्येक का आकार लगभग एक मेगाबाइट मेरी 1.8GHz डेस्कटॉप कंप्यूटर पर 0.009 के बारे में सेकंड लेता है पर .lower बुला() द्वारा की तुलना:

from timeit import Timer 

s1 = "1234567890" * 100000 + "a" 
s2 = "1234567890" * 100000 + "B" 

code = "s1.lower() < s2.lower()" 
time = Timer(code, "from __main__ import s1, s2").timeit(1000) 
print time/1000 # 0.00920499992371 on my machine 

वास्तव में इस कोड का एक अत्यंत महत्वपूर्ण, प्रदर्शन महत्वपूर्ण अनुभाग है, तो मैं सी में एक समारोह लेखन और, अपने अजगर कोड से यह बुला के बाद से है कि आप वास्तव में एक कुशल केस-संवेदी खोज करने की अनुमति देगा सलाह देते हैं। सी एक्सटेंशन मॉड्यूल लिखने पर विवरण यहां पाया जा सकता है: https://docs.python.org/extending/extending.html

Answer 8

मुझे केस-असंवेदनशील तुलना करने का कोई अन्य अंतर्निहित तरीका नहीं मिल रहा है: python cook-book recipe निम्न() का उपयोग करता है।

हालांकि आप जब Turkish I problem की वजह से तुलना के लिए कम उपयोग करते हुए सावधान रहना होगा। दुर्भाग्य से तुर्की के लिए पायथन का प्रबंधन अच्छा नहीं है। ı मुझे परिवर्तित कर दिया गया है, लेकिन मुझे ı में परिवर्तित नहीं किया गया है। मैं i में परिवर्तित हो गया है, लेकिन मैं İ में परिवर्तित नहीं किया गया है।

Answer 9

आप प्रत्येक स्ट्रिंग अनुवाद कर सकें एक बार लोअरकेस --- lazily केवल जब आप इसकी आवश्यकता है, या यदि आप जानते हैं प्रकार के लिए एक Prepass के रूप में आप तार का पूरा संग्रह छँटाई हो जाएगा। वहाँ वास्तविक डेटा सॉर्ट किया जा रहा करने के लिए इस तुलना कुंजी संलग्न करने के लिए कई तरीके हैं, लेकिन इन तकनीकों एक अलग अंक में संबोधित किया जाना चाहिए।

ध्यान दें कि इस तकनीक का उपयोग न केवल ऊपरी/निचले केस के मुद्दों को संभालने के लिए किया जा सकता है, बल्कि अन्य प्रकार के सॉर्टिंग जैसे लोकेल विशिष्ट सॉर्टिंग, या "लाइब्रेरी-शैली" शीर्षक सॉर्टिंग के लिए जो प्रमुख लेखों को अनदेखा करता है और अन्यथा डेटा को सामान्य करता है इसे छंटनी से पहले।

Answer 10

महंगा-से-गणना कुंजी का उपयोग करके मूल्यों की सूचियों को क्रमबद्ध करने के लिए अनुशंसित मुहावरे तथाकथित "सजाए गए पैटर्न" के लिए अनुशंसित मुहावरे है। इसमें मूल सूची से (कुंजी, मान) tuples की एक सूची बनाने में बस शामिल है, और उस सूची को सॉर्ट करें। तो फिर यह कुंजी को खत्म करने और हल कर मानों की सूची प्राप्त करने के लिए मामूली बात है:

>>> original_list = ['a', 'b', 'A', 'B'] 
>>> decorated = [(s.lower(), s) for s in original_list] 
>>> decorated.sort() 
>>> sorted_list = [s[1] for s in decorated] 
>>> sorted_list 
['A', 'a', 'B', 'b'] 

या आप एक-लाइनर्स पसंद करते हैं:

>>> sorted_list = [s[1] for s in sorted((s.lower(), s) for s in original_list)] 
>>> sorted_list 
['A', 'a', 'B', 'b'] 

तुम सच में कम बुला की लागत के बारे में चिंता है() , आप बस हर जगह (कम स्ट्रिंग, मूल स्ट्रिंग) के tuples स्टोर कर सकते हैं। ट्यूपल्स पाइथन में सबसे सस्ता प्रकार के कंटेनर हैं, वे भी हैंशबल हैं ताकि उन्हें डिक्शनरी कुंजियों, सेट सदस्यों, आदि के रूप में इस्तेमाल किया जा सके।

Answer 11

आपका प्रश्न यह दर्शाता है कि आपको यूनिकोड की आवश्यकता नहीं है। निम्न कोड स्निपेट आज़माएं; यदि यह आप के लिए काम करता है, आपका काम हो गया:

Python 2.5.2 (r252:60911, Aug 22 2008, 02:34:17) 
[GCC 4.3.1] on linux2 
Type "help", "copyright", "credits" or "license" for more information. 
>>> import locale 
>>> locale.setlocale(locale.LC_COLLATE, "en_US") 
'en_US' 
>>> sorted("ABCabc", key=locale.strxfrm) 
['a', 'A', 'b', 'B', 'c', 'C'] 
>>> sorted("ABCabc", cmp=locale.strcoll) 
['a', 'A', 'b', 'B', 'c', 'C'] 

स्पष्टीकरण: मामले में यह पहली नजर में स्पष्ट नहीं है, locale.strcoll str.lower या locale.strxfrm से परहेज, समारोह आप की जरूरत हो रहा है "डुप्लिकेट" स्ट्रिंग्स।

Answer 12

यहाँ एक बेंचमार्क दिखाया जा रहा है कि str.lower का उपयोग कर स्वीकार जवाब के प्रस्तावित विधि (libc.strcasecmp) की तुलना में तेजी है:

235886 words in list 
simple sort: 483.59 msec/pass 
sort with key=str.lower: 1064.70 msec/pass 
sort with cmp=libc.strcasecmp: 5487.86 msec/pass 

तो, str.lower साथ संस्करण:

#!/usr/bin/env python2.7 
import random 
import timeit 

from ctypes import * 
libc = CDLL('libc.dylib') # change to 'libc.so.6' on linux 

with open('/usr/share/dict/words', 'r') as wordlist: 
    words = wordlist.read().splitlines() 
random.shuffle(words) 
print '%i words in list' % len(words) 

setup = 'from __main__ import words, libc; gc.enable()' 
stmts = [ 
    ('simple sort', 'sorted(words)'), 
    ('sort with key=str.lower', 'sorted(words, key=str.lower)'), 
    ('sort with cmp=libc.strcasecmp', 'sorted(words, cmp=libc.strcasecmp)'), 
] 

for (comment, stmt) in stmts: 
    t = timeit.Timer(stmt=stmt, setup=setup) 
    print '%s: %.2f msec/pass' % (comment, (1000*t.timeit(10)/10)) 

मेरी मशीन पर ठेठ बार यहां तक ​​कि सबसे तेज़ नहीं है, बल्कि यहां सभी प्रस्तावित समाधानों का सबसे पोर्टेबल और पायथनिक भी है। मैंने स्मृति उपयोग को प्रोफाइल नहीं किया है, लेकिन मूल पोस्टर ने अभी भी इसके बारे में चिंता करने के लिए एक अनिवार्य कारण नहीं दिया है। साथ ही, कौन कहता है कि libc मॉड्यूल में एक कॉल किसी भी तार डुप्लिकेट नहीं करता है?

एनबी: lower() स्ट्रिंग विधि का लोकेल-आश्रित होने का भी लाभ है। अपने स्वयं के "अनुकूलित" समाधान लिखते समय शायद आपको सही नहीं मिल रहा है। फिर भी, पाइथन में बग और गायब सुविधाओं के कारण, इस तरह की तुलना आपको यूनिकोड संदर्भ में गलत परिणाम दे सकती है।

Answer 13

बस str().lower() विधि का उपयोग करें, जब तक कि उच्च-प्रदर्शन महत्वपूर्ण न हो - उस मामले में उस सॉर्टिंग विधि को सी एक्सटेंशन के रूप में लिखें।

"How to write a Python Extension" एक सभ्य परिचय की तरह लगता है ..

ज्यादा दिलचस्प, This guide ctypes लाइब्रेरी का उपयोग तुलना एक बाहरी सी मॉड्यूल लेखन बनाम (CTYPE काफी-काफी सी विस्तार की तुलना में धीमी है)।

Answer 14

जब मानक लाइब्रेरी में कुछ समर्थित नहीं है, तो मैं हमेशा एक पीपीपीआई पैकेज की तलाश करता हूं। वर्चुअलाइजेशन और आधुनिक लिनक्स वितरण की सर्वव्यापीता के साथ, अब मैं पायथन एक्सटेंशन से बच नहीं पा रहा हूं। पीआईआईसीयू बिल फिट करने लगता है: https://stackoverflow.com/a/1098160/3461

अब एक विकल्प भी है जो शुद्ध पायथन है।यह अच्छी तरह से परीक्षण किया है: https://github.com/jtauber/pyuca

---

पुराना जवाब:

मैं नियमित अभिव्यक्ति समाधान की तरह। यहां एक फ़ंक्शन है जिसे आप किसी भी फ़ंक्शन में कॉपी और पेस्ट कर सकते हैं, पाइथन के ब्लॉक स्ट्रक्चर सपोर्ट के लिए धन्यवाद।

def equals_ignore_case(str1, str2): 
    import re 
    return re.match(re.escape(str1) + r'\Z', str2, re.I) is not None 

जब से मैं बजाय खोज के मिलान का उपयोग करने मैं नियमित अभिव्यक्ति के लिए एक कैरेट (^) जोड़ने की जरूरत नहीं किया।

नोट: यह केवल समानता की जांच करता है, जिसे कभी-कभी आवश्यक होती है। मैं यह कहने के लिए अब तक नहीं जाऊंगा कि मुझे यह पसंद है।

Answer 15

यह सवाल 2 बहुत अलग बातें पूछ रहा है:

1. अजगर में तार की तुलना करने के मामले की अनदेखी के लिए सबसे आसान तरीका क्या है?
2. मुझे लगता है कि मैं सी के stricmp() के बराबर की तलाश में हूं।

चूंकि # 1 का उत्तर बहुत पहले से दिया गया है (यानी: str1.lower() < str2.lower()) मैं # 2 का जवाब दूंगा।

def strincmp(str1, str2, numchars=None): 
    result = 0 
    len1 = len(str1) 
    len2 = len(str2) 
    if numchars is not None: 
     minlen = min(len1,len2,numchars) 
    else: 
     minlen = min(len1,len2) 
    #end if 
    orda = ord('a') 
    ordz = ord('z') 

    i = 0 
    while i < minlen and 0 == result: 
     ord1 = ord(str1[i]) 
     ord2 = ord(str2[i]) 
     if ord1 >= orda and ord1 <= ordz: 
      ord1 = ord1-32 
     #end if 
     if ord2 >= orda and ord2 <= ordz: 
      ord2 = ord2-32 
     #end if 
     result = cmp(ord1, ord2) 
     i += 1 
    #end while 

    if 0 == result and minlen != numchars: 
     if len1 < len2: 
      result = -1 
     elif len2 < len1: 
      result = 1 
     #end if 
    #end if 

    return result 
#end def 

केवल इस फ़ंक्शन का उपयोग करें जब यह समझ में आता है कि कई उदाहरणों में लोअरकेस तकनीक बेहतर होगी।

मैं केवल एसीआई स्ट्रिंग के साथ काम करता हूं, मुझे यकीन नहीं है कि यह यूनिकोड के साथ कैसे व्यवहार करेगा।

Answer 16

import re 
if re.match('tEXT', 'text', re.IGNORECASE): 
    # is True