python - google - how to find someone's name by phone number for free




सूची लुकअप से हमेशा स्कूल लुकअप हमेशा बेहतर क्यों होते हैं? (2)

मुझे पता है कि सूचियों के तहत सी सरणी का उपयोग किया गया है, जिसने मुझे निष्कर्ष निकाला है कि कुछ वस्तुओं के साथ सूची में लुकअप एक शब्दकोश में बेहतर होगा (सरणी में कुछ तत्वों को एक्सेस करना हैश की गणना करने से तेज़ है)।

कुछ सरणी तत्वों तक पहुंच सस्ता, निश्चित है, लेकिन कंप्यूटिंग == पाइथन में आश्चर्यजनक रूप से हेवीवेट है। अपने दूसरे ग्राफ में उस स्पाइक को देखें? यह वहां दो इन्स के लिए कंप्यूटिंग == की लागत है।

आपकी सूची लुकअप को आपके ट्रुक लुकअप करने से बहुत अधिक == गणना करने की आवश्यकता है।

इस बीच, कंप्यूटिंग हैश बहुत सारी वस्तुओं के लिए एक भारी हेवीवेट ऑपरेशन हो सकती है, लेकिन यहां शामिल सभी चींटियों के लिए, वे सिर्फ खुद को हैश करते हैं। (-1 हैश टू -2, और बड़े पूर्णांक (तकनीकी रूप से long ) छोटे पूर्णांक के लिए हैश होगा, लेकिन यह यहां लागू नहीं होता है।)

डिक्ट लुकअप वास्तव में पाइथन में बुरा नहीं है, खासकर जब आपकी चाबियाँ लगातार स्याही की श्रृंखला होती हैं। यहां सभी चींटियों के लिए हैश, और पाइथन चेनिंग के बजाए एक कस्टम ओपन एड्रेसिंग स्कीम का उपयोग करता है, इसलिए आपकी सभी चाबियां स्मृति में लगभग उतनी ही जटिल होती हैं जैसे कि आप एक सूची का उपयोग करते थे (जो कहने के लिए, चाबियों के अंत में पॉइंटर्स PyDictEntry एस की एक संगत श्रृंखला में)। लुकअप प्रक्रिया तेज है, और आपके परीक्षण मामलों में, यह हमेशा पहली जांच पर दायां कुंजी हिट करती है।

ठीक है, ग्राफ 2 में स्पाइक पर वापस जाएं। दूसरे ग्राफ में 1024 प्रविष्टियों पर लुकअप समय में स्पाइक इसलिए है क्योंकि सभी छोटे आकारों के लिए, जिन पूर्णांक को आप ढूंढ रहे थे वे सभी <= 256 थे, इसलिए वे सभी की सीमा के भीतर गिर गई सीपीथन का छोटा पूर्णांक कैश। पायथन के संदर्भ कार्यान्वयन -5 से 256 तक सभी पूर्णांक के लिए कैनोलिक पूर्णांक ऑब्जेक्ट्स को शामिल करता है। इन पूर्णांकों के लिए, पाइथन कंप्यूटिंग == की (आश्चर्यजनक हेवीवेट) प्रक्रिया के माध्यम से जाने से बचने के लिए त्वरित सूचक तुलना का उपयोग करने में सक्षम था। बड़े पूर्णांक के लिए, तर्क in अब एक ही ऑब्जेक्ट नहीं था जो कि रंग में मिलान करने वाले पूर्णांक के रूप में था, और पायथन को पूरी == प्रक्रिया से गुजरना पड़ा।

मैं एक लुकअप टेबल के रूप में एक शब्दकोश का उपयोग कर रहा था, लेकिन मुझे आश्चर्य हुआ कि मेरे आवेदन के लिए एक सूची बेहतर होगी - मेरी लुकअप टेबल में प्रविष्टियों की मात्रा इतनी बड़ी नहीं थी। मुझे पता है कि सूचियों के तहत सी सरणी का उपयोग किया गया है, जिसने मुझे निष्कर्ष निकाला है कि कुछ वस्तुओं के साथ सूची में लुकअप एक शब्दकोश में बेहतर होगा (सरणी में कुछ तत्वों को एक्सेस करना हैश की गणना करने से तेज़ है)।

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

तो यहां सवाल आता है: सूची लुकअप इतनी खराब क्यों करती है? मैं क्या खो रहा हूँ?

एक तरफ सवाल पर, मेरा ध्यान बुलाया कुछ और लगभग 1000 प्रविष्टियों के बाद dict Look समय में थोड़ा "असंतोष" था। मैंने इसे दिखाने के लिए अकेले ताना लुकअप समय प्लॉट किया।

ps1 मुझे ओ (एन) बनाम ओ (1) सरणी और हैश तालिकाओं के लिए अमूर्त समय के बारे में पता है, लेकिन आमतौर पर यह मामला है कि एक सरणी पर पुनरावृत्त तत्वों की एक छोटी संख्या हैश तालिका का उपयोग करने से बेहतर है।

ps2 यहां कोड है जो मैंने dict और सूची लुकअप टाइम्स की तुलना करने के लिए उपयोग किया था:

import timeit

lengths = [2 ** i for i in xrange(15)]

list_time = []
dict_time = []
for l in lengths:
    list_time.append(timeit.timeit('%i in d' % (l/2), 'd=range(%i)' % l))
    dict_time.append(timeit.timeit('%i in d' % (l/2),
                                   'd=dict.fromkeys(range(%i))' % l))
    print l, list_time[-1], dict_time[-1]

ps3 पायथन 2.7.13 का उपयोग कर


आप कहते हैं "एक सरणी में कुछ तत्वों को एक्सेस करना हैश की गणना करने से तेज़ है"।

तारों के लिए एक सरल हैशिंग नियम केवल एक योग (अंत में एक मॉड्यूल के साथ) हो सकता है। यह एक शाखा रहित ऑपरेशन है जो चरित्र तुलना के साथ अनुकूलता से तुलना कर सकता है, खासकर जब उपसर्ग पर एक लंबा मिलान होता है।





python-internals