मैं तानाशाह से मूल्यों की सूची कैसे प्राप्त कर सकता हूं?

Question

मैं पायथन में एक तानाशाह के मूल्यों की सूची कैसे प्राप्त कर सकता हूं?

जावा में, एक सूची के रूप में मानचित्र के मूल्यों को प्राप्त करना उतना ही आसान है जितना कि करना list = map.values();। मैं सोच रहा था कि क्या पायथन से मूल्यों की सूची प्राप्त करने के लिए पायथन में एक समान सरल तरीका है।

Answer 1

हाँ यह पाइथन 2 में ठीक वही बात है :

d.values()

में अजगर 3 (जहां dict.valuesएक रिटर्न दृश्य शब्दकोश के मूल्यों के बजाय):

list(d.values())

Comments

@Muhd Python डॉक्स में हमेशा सब कुछ होता है: docs.python.org/2/library/stdtypes.html

— jamylak

या, वैकल्पिक रूप से [d[k] for k in d]जो python2.x और 3.x दोनों के लिए काम करता है ( कृपया सलाह दें, मैं वास्तव में यह सुझाव नहीं दे रहा हूं कि आप इसका उपयोग करें )। आमतौर पर आपको वास्तव में मूल्यों की सूची की आवश्यकता नहीं होती है, इसलिए d.values()यह ठीक है।

— mgilson

थोड़ा "बेहतर" लिंक (आपके द्वारा पोस्ट किए गए पृष्ठ पर एक विशिष्ट स्थान के लिए): docs.python.org/2/library/stdtypes.html#dict.values

— mgilson

या d.itervalues()शब्दकोश मूल्यों के एक पुनरावृत्तिकर्ता को लौटाने और एक सूची से बचने के लिए।

— 101

@figs प्रश्न "मूल्यों की सूची" है, लेकिन हां, यदि आप पायथन 2 पर एक शब्दकोश को पुनरावृत्त कर रहे हैं, तो निश्चित रूप से उपयोग करें d.itervalues()और ज्यादातर मामलों में आपको केवल पुनरावृति और अभ्यस्त सूची की आवश्यकता होगी।

— जामिलाक

Answer 2

आप * ऑपरेटर का उपयोग डिक्सेस_पुल्क्स को अनपैक करने के लिए कर सकते हैं :

>>> d = {1: "a", 2: "b"}
>>> [*d.values()]
['a', 'b']

या सूची वस्तु

>>> d = {1: "a", 2: "b"}
>>> list(d.values())
['a', 'b']

Comments

अच्छा समाधान, मुझे पता था कि आप इसे कुंजियों के साथ कर सकते हैं लेकिन मूल्यों के साथ नहीं, यह जानने के लिए अच्छा है: डी

— टिम्बस कैलिन

का ठंडा नया प्रयोग* operator

— जैमिलक

Answer 3

एक होना चाहिए - और अधिमानतः केवल एक - स्पष्ट तरीका यह करने के लिए।

इसलिए list(dictionary.values())है एक ही रास्ता है ।

फिर भी, पायथन 3 को देखते हुए, क्या जल्दी है?

[*L]बनाम [].extend(L)।list(L)

small_ds = {x: str(x+42) for x in range(10)}
small_df = {x: float(x+42) for x in range(10)}

print('Small Dict(str)')
%timeit [*small_ds.values()]
%timeit [].extend(small_ds.values())
%timeit list(small_ds.values())

print('Small Dict(float)')
%timeit [*small_df.values()]
%timeit [].extend(small_df.values())
%timeit list(small_df.values())

big_ds = {x: str(x+42) for x in range(1000000)}
big_df = {x: float(x+42) for x in range(1000000)}

print('Big Dict(str)')
%timeit [*big_ds.values()]
%timeit [].extend(big_ds.values())
%timeit list(big_ds.values())

print('Big Dict(float)')
%timeit [*big_df.values()]
%timeit [].extend(big_df.values())
%timeit list(big_df.values())

Small Dict(str)
256 ns ± 3.37 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
338 ns ± 0.807 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
336 ns ± 1.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Small Dict(float)
268 ns ± 0.297 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
343 ns ± 15.2 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
336 ns ± 0.68 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Big Dict(str)
17.5 ms ± 142 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
16.5 ms ± 338 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
16.2 ms ± 19.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Big Dict(float)
13.2 ms ± 41 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
13.1 ms ± 919 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
12.8 ms ± 578 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

इंटेल (आर) कोर (टीएम) i7-8650U CPU @ 1.90GHz पर किया।

# Name                    Version                   Build
ipython                   7.5.0            py37h24bf2e0_0

परिणाम

1. छोटे शब्दकोशों के * operatorलिए जल्दी है
2. बड़े शब्दकोशों के लिए जहां यह मायने रखता list()है, शायद थोड़ा तेज है

Comments

list(L), cuz "एक होना चाहिए - और अधिमानतः केवल एक - स्पष्ट तरीका यह करने के लिए।"

— उफोस

प्रस्तावित के अनुसार, @Ufos

— रोनाल्ड ल्यूक

Answer 4

नीचे दिए गए उदाहरण का अनुसरण करें -

songs = [
{"title": "happy birthday", "playcount": 4},
{"title": "AC/DC", "playcount": 2},
{"title": "Billie Jean", "playcount": 6},
{"title": "Human Touch", "playcount": 3}
]

print("====================")
print(f'Songs --> {songs} \n')
title = list(map(lambda x : x['title'], songs))
print(f'Print Title --> {title}')

playcount = list(map(lambda x : x['playcount'], songs))
print(f'Print Playcount --> {playcount}')
print (f'Print Sorted playcount --> {sorted(playcount)}')

# Aliter -
print(sorted(list(map(lambda x: x['playcount'],songs))))

Answer 5

out: dict_values([{1:a, 2:b}])

in:  str(dict.values())[14:-3]    
out: 1:a, 2:b

विशुद्ध रूप से दृश्य उद्देश्यों के लिए। एक उपयोगी उत्पाद का उत्पादन नहीं करता है ... केवल तभी उपयोगी होता है जब आप एक लंबे शब्दकोश को एक पैरा प्रकार के रूप में मुद्रित करना चाहते हैं।