शुरुआत के साथ कितना अच्छा है?

Question

text.startswith('a') 

text[0]=='a' 

की तुलना में बेहतर है?

टेक्स्ट जानना खाली नहीं है और हम केवल इसके पहले चरित्र में रूचि रखते हैं।

Answer 1

मैं दूसरों कि startswith अधिक पठनीय है के साथ सहमत हैं, और आपको लगता है कि उपयोग करना चाहिए। जैसा कि कहा गया है, अगर प्रदर्शन इस तरह के एक विशेष मामले के लिए एक बड़ा मुद्दा है, बेंचमार्क यह:

$ python -m timeit -s 'text="foo"' 'text.startswith("a")' 
1000000 loops, best of 3: 0.537 usec per loop 

$ python -m timeit -s 'text="foo"' 'text[0]=="a"' 
1000000 loops, best of 3: 0.22 usec per loop 

तो text[0] amost के रूप में तेजी से 2.5 गुना है - लेकिन यह एक बहुत जल्दी आपरेशन है; आप प्रणाली के आधार पर प्रति तुलना ~ 0.3 माइक्रोसॉन्ड बचाएंगे। जब तक आप एक महत्वपूर्ण स्थिति में लाखों तुलना नहीं कर रहे हैं, तब भी, मैं अभी भी अधिक पठनीय शुरुआत के साथ जाऊंगा।

Answer 2

text[0] विफल रहता है text कोई रिक्त स्ट्रिंग है:

IronPython 2.6 Alpha (2.6.0.1) on .NET 4.0.20506.1 
Type "help", "copyright", "credits" or "license" for more information. 
>>> text = "" 
>>> print(text.startswith("a")) 
False 
>>> print(text[0]=='a') 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
IndexError: index out of range: 0 

संपादित करें: आप कहते हैं आप "पता" कि text खाली नहीं है ... कैसे विश्वास है आप इस बात का कर रहे हैं, और क्या आप क्या करना चाहते हैं यदि यह है वास्तविकता में खाली है? यदि विफलता उचित है (उदाहरण के लिए इसका मतलब है आपके कोड में एक बग) जो text[0]=='a' के उपयोग को प्रोत्साहित करेगा।

अन्य प्रश्न:

• आप इस के प्रदर्शन के बारे में कैसा संबंध है? यदि यह प्रदर्शन महत्वपूर्ण है, तो अपने विशेष पायथन रनटाइम पर बेंचमार्क करें। मैं पूरी तरह से नहीं देख पाएगा कि (कहें) आयरनपीथन पर एक रूप तेज था और सीपीथॉन पर एक अलग तेज़ था।

• आप (और आपकी टीम) को अधिक पठनीय पाते हैं?

Answer 3

व्यक्तिगत रूप से मैं कहूंगा कि startswith अधिक पठनीय है।

इसके अलावा, अजगर 2.5 से startwith उपसर्गों के एक टपल ले जा सकते हैं देखने के लिए:

>>> "hello world".startswith(("hello","goodbye")) 
True 

Answer 4

हाँ: यह उपयोग में आसान और पढ़ने में आसान है। आप एक से अधिक पत्र के लिए परीक्षण करते समय, जब टुकड़ा करने की क्रिया का उपयोग कर, आप को पता है कितनी देर तक लक्ष्य पाठ है होगा:

haystack = 'Hello, World!' 
needle = 'Hello' 

# The easy way 
result = haystack.startswith(needle) 

# The slightly harder way 
result = haystack[:len(needle)] == needle 

संपादित करें: प्रश्न बदल दिया है लगता है। अब यह कहता है, "पाठ को जानना खाली नहीं है और हम केवल इसके पहले चरित्र में रूचि रखते हैं।" यह इसे काफी अर्थहीन काल्पनिक स्थिति में बदल देता है।

मुझे संदेह है कि प्रश्नकर्ता निष्पादन गति के लिए अपने कोड को "अनुकूलित" करने का प्रयास कर रहा है। यदि ऐसा है, तो मेरा जवाब है: नहीं। जो भी फॉर्म अधिक पठनीय का उपयोग करें और इसलिए, जब आप वापस आना चाहते हैं और अब से एक वर्ष में काम करना है तो अधिक रखरखाव योग्य है। केवल प्रोफाइलिंग करें अगर प्रोफ़ाइल दिखाती है कि कोड की रेखा बाधा बनती है। यह कुछ ओ (एन²) एल्गोरिदम नहीं है। यह एक स्ट्रिंग तुलना है।

Answer 5

questiom के लिए स्टॉक वाक्यांश है: "समयपूर्व अनुकूलन सभी बुराइयों की जड़ है"।

Answer 6

टेक्स्ट [0] == 'ए' प्रदर्शन पर विचार करने में अच्छा है। जब आप इसका उपयोग करते हैं तो आपको सत्यापन जोड़ने की भी आवश्यकता होती है।

Answer 7

text[0] असफल हो सकता है, लेकिन यदि स्ट्रिंग खाली है बराबर text[:1] सुरक्षित है।

यदि आप एक से अधिक वर्णों की तुलना करना चाहते हैं, तो मेरा मानना ​​है कि .startswith() बेहतर है।

Answer 8

PEP 8 स्पष्ट पठनीयता की वजह से, startswith उपयोग करने के लिए कहता है:

- Use ''.startswith() and ''.endswith() instead of string 

टुकड़ा करने की क्रिया उपसर्ग या प्रत्यय के लिए जाँच करने के लिए।

startswith() and endswith() are cleaner and less error prone. For 
    example: 

    Yes: if foo.startswith('bar'): 

    No: if foo[:3] == 'bar': 

Answer 9

def compo2(): 
    n = "abba" 
    for i in range(1000000): 
     n[:1]=="_" 

तेजी से

def compo(): 
    n = "abba" 
    for i in range(1000000): 
     n.startswith("_") 

cProfile रिपोर्ट compo मेरी मशीन पर के लिए 0.954 की तुलना में compo2 के लिए 0.061 है। यदि आप विभिन्न "_mystring" के लिए बहुत सारे उपसर्ग जांच करना चाहते हैं तो यह ब्याज की बात है। सबसे तार अंडरस्कोर तो startswith उपयोग करने से पहले string[:1]== char का उपयोग कर के साथ शुरू नहीं करते हैं तो अपने कोड का अनुकूलन करने के एक विकल्प है। एक असली एप्लिकेशन में इस विधि ने मुझे लगभग 15% सीपीयू समय बचाया।