मैं कुछ ऐसा करना चाहता हूं:
foo = {'foo':1,'zip':2,'zam':3,'bar':4}
if ("foo","bar") in foo:
#do stuffमैं कैसे जाँचूँ कि क्या दोनों 'फू' और 'बार' तानाशाह में हैं?
मैं कुछ ऐसा करना चाहता हूं:
foo = {'foo':1,'zip':2,'zam':3,'bar':4}
if ("foo","bar") in foo:
#do stuffमैं कैसे जाँचूँ कि क्या दोनों 'फू' और 'बार' तानाशाह में हैं?
जवाबों:
ठीक है, आप ऐसा कर सकते हैं:
>>> if all (k in foo for k in ("foo","bar")):
... print "They're there!"
...
They're there!setयह बेहतर है। हमेशा की तरह ... इसे
if {"foo", "bar"} <= myDict.keys(): ...यदि आप अभी भी पायथन 2 पर हैं, तो आप कर सकते हैं
if {"foo", "bar"} <= myDict.viewkeys(): ...यदि आप अभी भी एक बहुत पुराने अजगर <= 2.6 पर हैं, तो आप setडिक्टेट पर कॉल कर सकते हैं , लेकिन यह सेट बनाने के लिए पूरे डिक्टेट पर पुनरावृति करेगा, और यह धीमा है:
if set(("foo", "bar")) <= set(myDict): ...set(("foo","bar")) <= myDict.keys()अस्थायी सेट से बचा जाता है, इसलिए बहुत तेज है। मेरे परीक्षण के लिए यह सब उसी गति के बारे में है जब क्वेरी 10 आइटम थी। यह धीमी हो जाती है क्योंकि क्वेरी बड़ी हो जाती है।
if {'foo', 'bar'} <= set(myDict): ...
डी और क्यू के लिए अपने स्वयं के मूल्यों में रखो
>>> from timeit import Timer
>>> setup='''from random import randint as R;d=dict((str(R(0,1000000)),R(0,1000000)) for i in range(D));q=dict((str(R(0,1000000)),R(0,1000000)) for i in range(Q));print("looking for %s items in %s"%(len(q),len(d)))'''
>>> Timer('set(q) <= set(d)','D=1000000;Q=100;'+setup).timeit(1)
looking for 100 items in 632499
0.28672504425048828
#This one only works for Python3
>>> Timer('set(q) <= d.keys()','D=1000000;Q=100;'+setup).timeit(1)
looking for 100 items in 632084
2.5987625122070312e-05
>>> Timer('all(k in d for k in q)','D=1000000;Q=100;'+setup).timeit(1)
looking for 100 items in 632219
1.1920928955078125e-05d.viewkeys()को बनाना है set(q) <= d.viewkeys()।
Python 2.7.5है d.keys()विधि भी।
set(q) <= ...
TypeError: can only compare to a set। माफ़ करना! :))
d.viewkeys() >= set(q):। मैं यह जानने की कोशिश कर रहा था कि आदेश क्यों मायने रखता है!
आपको एक सेट में बाईं ओर लपेटने की आवश्यकता नहीं है। आप ऐसा कर सकते हैं:
if {'foo', 'bar'} <= set(some_dict):
passयह भी all(k in d...)समाधान से बेहतर प्रदर्शन करता है ।
का उपयोग करते हुए सेट:
if set(("foo", "bar")).issubset(foo):
#do stuffवैकल्पिक रूप से:
if set(("foo", "bar")) <= set(foo):
#do stuffset(d)के रूप में ही है set(d.keys())(मध्यवर्ती सूची के बिना जो d.keys()निर्माण करता है)
इस बारे में कैसा है:
if all([key in foo for key in ["foo","bar"]]):
# do stuff
passall।
मुझे लगता है कि यह सबसे स्मार्ट और पिथोनिक है।
{'key1','key2'} <= my_dict.keys()जबकि मुझे एलेक्स मार्टेली का जवाब पसंद है, यह मुझे पाइथोनिक नहीं लगता। यही है, मैंने सोचा कि पायथोनिक होने का एक महत्वपूर्ण हिस्सा आसानी से समझा जा सकता है। उस लक्ष्य के साथ,<= समझना आसान नहीं है।
हालांकि यह अधिक वर्ण है, issubset()कार्ल वायगटलैंड के उत्तर के रूप में सुझाए गए उपयोग से अधिक समझ में आता है। चूँकि वह विधि किसी शब्दकोश को एक तर्क के रूप में उपयोग कर सकती है, एक छोटा, समझने योग्य समाधान है:
foo = {'foo': 1, 'zip': 2, 'zam': 3, 'bar': 4}
if set(('foo', 'bar')).issubset(foo):
#do stuffमैं इसके {'foo', 'bar'}स्थान पर उपयोग करना चाहता हूं set(('foo', 'bar')), क्योंकि यह छोटा है। हालांकि, यह समझ में नहीं आता है और मुझे लगता है कि शब्दकोष होने के नाते ब्रेसिज़ बहुत आसानी से भ्रमित हो जाते हैं।
एलेक्स मार्टेली का समाधान set(queries) <= set(my_dict) सबसे छोटा कोड है, लेकिन यह सबसे तेज़ नहीं हो सकता है। क्यू = लेन (प्रश्न) और डी = लेन (my_dict) मान लें।
यह दो सेट बनाने के लिए O (Q) + O (D) लेता है, और फिर (एक उम्मीद!) केवल O (min (Q, D)) को सब्सेट टेस्ट करने के लिए करता है - यह मानते हुए कि पायथन सेट लुक-अप करता है। is O (1) - यह सबसे खराब स्थिति है (जब उत्तर सत्य हो)।
Hughdbrown (एट अल?) का जनरेटर समाधान all(k in my_dict for k in queries) का सबसे खराब स्थिति O (Q) है।
जटिल कारक:
(1) सेट-आधारित गैजेट में छोरों को सभी सी-स्पीड पर किया जाता है, जबकि कोई भी आधारित गैजेट बाईटेकोड पर लूपिंग होता है।
(2) किसी भी आधारित गैजेट का कॉलर क्वेरी आइटम ऑर्डर करने के लिए विफलता के प्रायिकता के किसी भी ज्ञान का उपयोग करने में सक्षम हो सकता है जबकि सेट-आधारित गैजेट इस तरह के नियंत्रण की अनुमति नहीं देता है।
हमेशा की तरह, यदि गति महत्वपूर्ण है, तो परिचालन स्थितियों के तहत बेंचमार्किंग एक अच्छा विचार है।
आप उपयोग कर सकते हैं ) .issubset ( के रूप में अच्छी तरह से
>>> {"key1", "key2"}.issubset({"key1":1, "key2":2, "key3": 3})
True
>>> {"key4", "key2"}.issubset({"key1":1, "key2":2, "key3": 3})
False
>>>लैम्बडा के उपयोग के बारे में कैसे?
if reduce( (lambda x, y: x and foo.has_key(y) ), [ True, "foo", "bar"] ): # do stuffमामले में आप चाहते हैं:
फिर:
from operator import itemgetter
foo = {'foo':1,'zip':2,'zam':3,'bar':4}
keys = ("foo","bar")
getter = itemgetter(*keys) # returns all values
try:
values = getter(foo)
except KeyError:
# not both keys exist
pass>>> if 'foo' in foo and 'bar' in foo:
... print 'yes'
...
yesजेसन, () पायथन में आवश्यक नहीं हैं।
बस मेरा इस पर ध्यान देना, दो विधियां हैं जो सभी दिए गए विकल्पों को समझना आसान है। तो मेरे मुख्य मानदंड में बहुत पठनीय कोड है, असाधारण रूप से तेज कोड नहीं। कोड को समझने के लिए, मैं दी गई संभावनाओं को पसंद करता हूं:
यह तथ्य कि "var <= var2.keys ()" नीचे मेरे परीक्षण में तेजी से निष्पादित होता है, मैं इसे पसंद करता हूं।
import timeit
timeit.timeit('var <= var2.keys()', setup='var={"managed_ip", "hostname", "fqdn"}; var2= {"zone": "test-domain1.var23.com", "hostname": "bakje", "api_client_ip": "127.0.0.1", "request_data": "", "request_method": "GET", "request_url": "hvar2p://127.0.0.1:5000/test-domain1.var23.com/bakje", "utc_datetime": "04-Apr-2019 07:01:10", "fqdn": "bakje.test-domain1.var23.com"}; var={"managed_ip", "hostname", "fqdn"}')
0.1745898080000643
timeit.timeit('var.issubset(var2)', setup='var={"managed_ip", "hostname", "fqdn"}; var2= {"zone": "test-domain1.var23.com", "hostname": "bakje", "api_client_ip": "127.0.0.1", "request_data": "", "request_method": "GET", "request_url": "hvar2p://127.0.0.1:5000/test-domain1.var23.com/bakje", "utc_datetime": "04-Apr-2019 07:01:10", "fqdn": "bakje.test-domain1.var23.com"}; var={"managed_ip", "hostname", "fqdn"};')
0.2644960229999924यह निर्धारित करने के मामले में कि क्या केवल कुछ कुंजियाँ मेल खाती हैं, यह काम करता है:
any_keys_i_seek = ["key1", "key2", "key3"]
if set(my_dict).intersection(any_keys_i_seek):
# code_here
passएक और विकल्प खोजने के लिए कि क्या केवल कुछ कुंजियाँ मेल खाती हैं:
any_keys_i_seek = ["key1", "key2", "key3"]
if any_keys_i_seek & my_dict.keys():
# code_here
passयह पता लगाने के लिए एक अन्य विकल्प है कि क्या सभी चाबियाँ एक तानाशाही में हैं:
dict_to_test = { ... } # dict
keys_sought = { "key_sought_1", "key_sought_2", "key_sought_3" } # set
if keys_sought & dict_to_test.keys() == keys_sought:
# yes -- dict_to_test contains all keys in keys_sought
# code_here
pass>>> ok
{'five': '5', 'two': '2', 'one': '1'}
>>> if ('two' and 'one' and 'five') in ok:
... print "cool"
...
coolयह काम करने लगता है
()कि पहले मूल्यांकन Trueकिया जाएगा और उसके बाद परिणाम आएगा, जो तब जांच करेगा True in ok। यह वास्तव में कैसे काम करता है ?!