উত্তর:
এটার মত:
>>> keys = ['a', 'b', 'c']
>>> values = [1, 2, 3]
>>> dictionary = dict(zip(keys, values))
>>> print(dictionary)
{'a': 1, 'b': 2, 'c': 3}ভয়েলা :-) জোড়াযুক্ত নির্মাতা dictএবং zipফাংশন দুর্দান্তভাবে দরকারী: https://docs.python.org/3/library/function.html#func-dict
{thing}একটি set()উপাদান যুক্ত একটি উপাদান নির্মাণ করতে সিনট্যাকটিক চিনি । বেশ কয়েকটি উপাদান সমন্বিত {*iterable}একটি সিনট্যাকটিক চিনি set। {k:v}বা একটি নির্মাণ {**mapping} করবেdict , কিন্তু এটি সিন্টেক্সিকভাবে বেশ স্বতন্ত্র।
{}জন্য সিনট্যাক্স ব্যবহার করি । আসলে আমরা যদি চেষ্টা করি type({})তবে আউটপুট হয় dict। তবে প্রকৃতপক্ষে, যদি আমরা চেষ্টা করি type({thing})তবে আউটপুট হয় set।
{k:v for k, v in zip(keys, values)}। এটি আমরা করতে পারি। +1 টি।
আপনার কাছে কল্পনা করুন:
keys = ('name', 'age', 'food') values = ('Monty', 42, 'spam')নিম্নলিখিত অভিধানটি তৈরি করার সহজ উপায় কী?
dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}
dictনির্মাণকারীzipnew_dict = dict(zip(keys, values))পাইথন 3 এ, জিপ এখন একটি অলস পুনরাবৃত্তিকে ফিরিয়ে দেয় এবং এটি এখন সর্বাধিক পারফরম্যান্ট পদ্ধতি approach
dict(zip(keys, values))প্রত্যেকের জন্য ওয়ান-টাইম গ্লোবাল সন্ধানের প্রয়োজন dictএবং zipএটি কোনও অপ্রয়োজনীয় মধ্যবর্তী ডেটা স্ট্রাকচার গঠন করে না বা ফাংশন অ্যাপ্লিকেশনে স্থানীয় অনুসন্ধানগুলির সাথে মোকাবেলা করতে হবে না।
ডিক কনস্ট্রাক্টর ব্যবহারের নিকটতম রানার্স আপ হ'ল একটি ডিক বোঝার দেশীয় বাক্য গঠন (কোনও তালিকা বোঝা নয়, যেমন অন্যরা ভুলভাবে লিখেছেন):
new_dict = {k: v for k, v in zip(keys, values)}কী বা মানের উপর ভিত্তি করে আপনার যখন মানচিত্র বা ফিল্টার করা দরকার তখন এটি চয়ন করুন।
পাইথন ২-এ zipএকটি তালিকা ফেরত দেয়, অপ্রয়োজনীয় তালিকা তৈরি না করার জন্য izipপরিবর্তে ব্যবহার করুন (জিপের সাথে সংযুক্ত হয়ে কোডটি পরিবর্তনগুলি হ্রাস করতে পারে যখন আপনি পাইথন 3 এ যান)।
from itertools import izip as zipসুতরাং এটি এখনও (2.7):
new_dict = {k: v for k, v in zip(keys, values)}izipথেকে itertoolsহয়ে zipপাইথন 3 izipপাইথন 2 জন্য জিপ বেশী ভালো, এবং 2.6 অথবা নীচের জন্য আদর্শ (কারণ এটা অপ্রয়োজনীয় তালিকা সৃষ্টি এড়াতে):
from itertools import izip
new_dict = dict(izip(keys, values))সব ক্ষেত্রে:
>>> new_dict
{'age': 42, 'name': 'Monty', 'food': 'spam'}যদি আমরা সহায়তাটি dictদেখি তবে আমরা দেখতে পাই এটি বিভিন্ন ধরণের আর্গুমেন্ট গ্রহণ করে:
>>> help(dict)
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
অপ্রয়োজনীয় ডেটা স্ট্রাকচার তৈরি করা এড়িয়ে যাওয়ার সময় সর্বোত্তম পদ্ধতির পুনরাবৃত্তিযোগ্য ব্যবহার করা। পাইথন 2 এ জিপ একটি অপ্রয়োজনীয় তালিকা তৈরি করে:
>>> zip(keys, values)
[('name', 'Monty'), ('age', 42), ('food', 'spam')]পাইথন 3 এ, সমতুল্য হবে:
>>> list(zip(keys, values))
[('name', 'Monty'), ('age', 42), ('food', 'spam')]এবং পাইথন 3 এর zipকেবল একটি পুনরাবৃত্তিযোগ্য বস্তু তৈরি করে:
>>> zip(keys, values)
<zip object at 0x7f0e2ad029c8>যেহেতু আমরা অপ্রয়োজনীয় ডেটা স্ট্রাকচার তৈরি করা এড়াতে চাই, আমরা সাধারণত পাইথন 2 এর এড়াতে চাই zip(যেহেতু এটি একটি অপ্রয়োজনীয় তালিকা তৈরি করে)।
এটি ডিক নির্মাণকারীকে দেওয়া একটি জেনারেটর এক্সপ্রেশন:
generator_expression = ((k, v) for k, v in zip(keys, values))
dict(generator_expression)বা সমতুল্য:
dict((k, v) for k, v in zip(keys, values))এবং এটি ডিক নির্মাণকারীকে দেওয়া একটি তালিকা বোধগম্যতা:
dict([(k, v) for k, v in zip(keys, values)])প্রথম দুটি ক্ষেত্রে, অ-অপারেটিভ (এইভাবে অপ্রয়োজনীয়) গণনার একটি অতিরিক্ত স্তর জিপ পুনরাবৃত্তের উপরে স্থাপন করা হয়, এবং তালিকা বোঝার ক্ষেত্রে, একটি অতিরিক্ত তালিকা অকারণে তৈরি করা হয়। আমি তাদের সকলের কম পারফরম্যান্সের আশা করব এবং অবশ্যই বেশি কিছু হবে না।
উবুন্টু ১.0.০৪-তে নিক দ্বারা সরবরাহিত bit৪ বিট পাইথন ৩.৮.২ এ, দ্রুত থেকে ধীরতম দিকে আদেশ দেওয়া হয়েছে:
>>> min(timeit.repeat(lambda: dict(zip(keys, values))))
0.6695233230129816
>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))
0.6941362579818815
>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))
0.8782548159942962
>>>
>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))
1.077607496001292
>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))
1.1840861019445583dict(zip(keys, values)) এমনকি কী এবং মানগুলির ছোট সেটগুলির সাহায্যে জয়ী হয় তবে বড় সেটগুলির জন্য, কার্য সম্পাদনের পার্থক্য আরও বেশি হয়ে উঠবে।
একজন মন্তব্যকারী বলেছেন:
minপারফরম্যান্স তুলনা করার খারাপ উপায় বলে মনে হচ্ছে। অবশ্যইmeanএবং / অথবাmaxবাস্তব ব্যবহারের জন্য আরও অনেক দরকারী সূচক হবে।
আমরা ব্যবহার করি minকারণ এই অ্যালগরিদমগুলি নির্বিচারক। আমরা সর্বোত্তম অবস্থার অধীনে অ্যালগরিদমের কার্যকারিতা জানতে চাই।
যদি অপারেটিং সিস্টেমটি কোনও কারণে ঝুলে থাকে, তবে আমরা যা তুলনা করার চেষ্টা করছি তার সাথে এর কোনও সম্পর্ক নেই, সুতরাং আমাদের বিশ্লেষণ থেকে আমাদের ধরণের ফলাফলগুলি বাদ দিতে হবে।
যদি আমরা ব্যবহার করি তবে meanএই ধরণের ইভেন্টগুলি আমাদের ফলাফলগুলিকে ব্যাপকভাবে আঁকিয়ে ফেলবে এবং আমরা যদি ব্যবহার maxকরি তবে আমরা কেবলমাত্র চূড়ান্ত ফলাফল পেয়ে যাব - সম্ভবত এই জাতীয় ঘটনা দ্বারা প্রভাবিত।
একজন মন্তব্যকারী আরও বলেছেন:
পাইথন ৩.6.৮-তে, গড় মানগুলি ব্যবহার করে ডিক বোঝাপড়াটি এখনও দ্রুততর হয়, এই ছোট তালিকার জন্য প্রায় 30% 30 বড় তালিকাগুলির জন্য (10 কে র্যান্ডম সংখ্যা),
dictকলটি প্রায় 10% দ্রুত is
আমি অনুমান করি আমরা dict(zip(...10k এলোমেলো সংখ্যার সাথে বোঝাচ্ছি । এটি মোটামুটি অস্বাভাবিক ব্যবহারের ক্ষেত্রে শোনাচ্ছে। এটি বোঝা যায় না যে সর্বাধিক প্রত্যক্ষ কলগুলি বড় ডেটাসেটগুলিতে প্রাধান্য পাবে, এবং যদি ওএস হ্যাংগুলি এই পরীক্ষাটি চালাতে কতক্ষণ সময় নেয়, আপনার সংখ্যাটি আরও ছড়িয়ে দেয় তবে আমি অবাক হব না। এবং আপনি যদি ব্যবহার করেন meanবা maxআমি আপনার ফলাফলগুলি অর্থহীন বিবেচনা করব।
আসুন আমাদের শীর্ষ উদাহরণগুলিতে আরও বাস্তবসম্মত আকারটি ব্যবহার করুন:
import numpy
import timeit
l1 = list(numpy.random.random(100))
l2 = list(numpy.random.random(100))এবং আমরা এখানে দেখতে পাই যে dict(zip(...প্রকৃতপক্ষে প্রায় 20% দ্বারা বড় ডেটাসেটের জন্য দ্রুত চালানো হয়।
>>> min(timeit.repeat(lambda: {k: v for k, v in zip(l1, l2)}))
9.698965263989521
>>> min(timeit.repeat(lambda: dict(zip(l1, l2))))
7.9965161079890095dict(zip(headList, textList))& 1.95 \ অপরাহ্ন জন্য 0,030 microsec {k: v for k, v in zip(headList, textList)}। আমি প্রাক্তনকে পঠনযোগ্যতা এবং গতির জন্য প্রস্তাব করব। স্পষ্টতই এটি সময়সীমার জন্য ন্যূনতম () বনাম গড় () যুক্তিতে আসে।
minপারফরম্যান্স তুলনা করার খারাপ উপায় বলে মনে হচ্ছে। অবশ্যই meanএবং / অথবা maxবাস্তব ব্যবহারের জন্য আরও অনেক দরকারী সূচক হবে।
dictকলটি প্রায় 10% দ্রুত is
এটা চেষ্টা কর:
>>> import itertools
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> adict = dict(itertools.izip(keys,values))
>>> adict
{'food': 'spam', 'age': 42, 'name': 'Monty'}পাইথন 2-তে, তুলনায় এটি মেমরির ব্যবহারে আরও অর্থনৈতিক zip।
zipএ মেমরির ব্যবহারের ক্ষেত্রে ইতিমধ্যে অর্থনৈতিক। docs.python.org/3/library/funifications.html#zip আসলে, আপনি দেখতে পাচ্ছেন যে পাইথন 3 sixব্যবহার করে পাইথন 2 পাইথনহোস্টেড . org / সিক্সzip প্রতিস্থাপন করতে । itertools.izip
আপনি পাইথন dictionary 2.7 এ অভিধান বোঝার জন্য ব্যবহার করতে পারেন:
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> {k: v for k, v in zip(keys, values)}
{'food': 'spam', 'age': 42, 'name': 'Monty'}আরও একটি প্রাকৃতিক উপায় অভিধান বোধগম্যতা ব্যবহার করা হয়
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
dict = {keys[i]: values[i] for i in range(len(keys))}dictঅবজেক্টে রূপান্তর করতে সবচেয়ে ধীরতম , কেন এটি এমন ?, ধন্যবাদ দোস্ত।
অভিধান তৈরি করার আগে যদি আপনার কী বা মানকে রূপান্তর করতে হয় তবে জেনারেটর এক্সপ্রেশন ব্যবহার করা যেতে পারে। উদাহরণ:
>>> adict = dict((str(k), v) for k, v in zip(['a', 1, 'b'], [2, 'c', 3])) দেখে নিন কথ্য পাইথন: কোডের মত Pythonista ।
পাইথন 3.x এর সাথে ডিক বোঝার জন্য যায়
keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
dic = {k:v for k,v in zip(keys, values)}
print(dic)ডিক বোঝার জন্য এখানে আরও একটি উদাহরণ রয়েছে:
>>> print {i : chr(65+i) for i in range(4)}
{0 : 'A', 1 : 'B', 2 : 'C', 3 : 'D'}যাদের সহজ কোড দরকার এবং তাদের সাথে পরিচিত নন zip:
List1 = ['This', 'is', 'a', 'list']
List2 = ['Put', 'this', 'into', 'dictionary']কোডের এক লাইনের মাধ্যমে এটি করা যেতে পারে:
d = {List1[n]: List2[n] for n in range(len(List1))}List1চেয়ে বেশি হলে জোরে জোরে ব্যর্থ হয়List2
for n in range(len(List1))এটি একটি বিরোধী
সর্বোত্তম সমাধানটি এখনও:
In [92]: keys = ('name', 'age', 'food')
...: values = ('Monty', 42, 'spam')
...:
In [93]: dt = dict(zip(keys, values))
In [94]: dt
Out[94]: {'age': 42, 'food': 'spam', 'name': 'Monty'}এটি ট্রান্সপোজ করুন:
lst = [('name', 'Monty'), ('age', 42), ('food', 'spam')]
keys, values = zip(*lst)
In [101]: keys
Out[101]: ('name', 'age', 'food')
In [102]: values
Out[102]: ('Monty', 42, 'spam')আপনি নীচের কোডটি ব্যবহার করতে পারেন:
dict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))তবে তালিকাগুলির দৈর্ঘ্য সমান হবে কিনা তা নিশ্চিত করুন। দৈর্ঘ্যটি একই নয় then জিপ ফাংশনটি দীর্ঘতর স্থানে পরিণত হয় ate
আমি যখন গ্রাফ-সম্পর্কিত সমস্যা সমাধানের চেষ্টা করছিলাম তখন আমার এই সন্দেহ হয়েছিল। আমার যে সমস্যাটি ছিল তা হ'ল আমার একটি খালি সংলগ্ন তালিকাটি সংজ্ঞায়িত করার দরকার ছিল এবং খালি তালিকার সাহায্যে সমস্ত নোডের সূচনা করতে চেয়েছিলাম, এটি যখন আমি ভেবেছিলাম যে এটি কিভাবে দ্রুত পর্যাপ্ত কিনা তা আমি কীভাবে পরীক্ষা করব, আমি বলতে চাইছি এটি জিপ অপারেশন করার জন্য উপযুক্ত হবে কিনা? সাধারণ অ্যাসাইনমেন্টের চেয়ে কী-মান জুটি। বেশিরভাগ সময় পরে, সময় ফ্যাক্টর একটি গুরুত্বপূর্ণ বরফ ব্রেকার। তাই আমি উভয় পদ্ধতির জন্য টাইমিট অপারেশন করেছি।
import timeit
def dictionary_creation(n_nodes):
dummy_dict = dict()
for node in range(n_nodes):
dummy_dict[node] = []
return dummy_dict
def dictionary_creation_1(n_nodes):
keys = list(range(n_nodes))
values = [[] for i in range(n_nodes)]
graph = dict(zip(keys, values))
return graph
def wrapper(func, *args, **kwargs):
def wrapped():
return func(*args, **kwargs)
return wrapped
iteration = wrapper(dictionary_creation, n_nodes)
shorthand = wrapper(dictionary_creation_1, n_nodes)
for trail in range(1, 8):
print(f'Itertion: {timeit.timeit(iteration, number=trails)}\nShorthand: {timeit.timeit(shorthand, number=trails)}')এন_নোডের জন্য = 10,000,000 আমি পেয়েছি,
সংক্ষিপ্ত বিবরণ: 2.825081646999024 শর্টহ্যান্ড: 3.535717916001886
সংক্ষিপ্ত বিবরণ: 5.051560923002398 শর্টহ্যান্ড: 6.255070794999483
সংক্ষিপ্ত বিবরণ: 6.52859034499852 শর্টহ্যান্ড: 8.221581164998497
আইট্রেশন: 8.683652416999394 শর্টহ্যান্ড: 12.599181543999293
সংক্ষিপ্ত বিবরণ: 11.587241565001023 শর্টহ্যান্ড: 15.27298851100204
সংক্ষিপ্ত বিবরণ: 14.816342867001367 শর্টহ্যান্ড: 17.162912737003353
সংক্ষিপ্ত বিবরণ: 16.645022411001264 শর্টহ্যান্ড: 19.976680120998935
আপনি একটি নির্দিষ্ট বিন্দুর পরে পরিষ্কার দেখতে পাচ্ছেন, n_ তম ধাপে পুনরাবৃত্তির পদ্ধতির এন -1_ তম ধাপে শর্টহ্যান্ড পদ্ধতির নেওয়া সময়কে ছাড়িয়ে যায়।
আপনার অভিধানে একটি তালিকা মান যুক্ত করার একটি উদাহরণ এখানে
list1 = ["Name", "Surname", "Age"]
list2 = [["Cyd", "JEDD", "JESS"], ["DEY", "AUDIJE", "PONGARON"], [21, 32, 47]]
dic = dict(zip(list1, list2))
print(dic)আপনার "কী" (তালিকার 1) সর্বদা প্রথম প্যারামিটারে রয়েছে তা নিশ্চিত করুন।
{'Name': ['Cyd', 'JEDD', 'JESS'], 'Surname': ['DEY', 'AUDIJE', 'PONGARON'], 'Age': [21, 32, 47]}আপনি দুটি তালিকার সংমিশ্রণকারী একটি তালিকা দিয়েও চেষ্টা করতে পারেন;)
a = [1,2,3,4]
n = [5,6,7,8]
x = []
for i in a,n:
x.append(i)
print(dict(zip(x[0], x[1])))জিপ ফাংশন ছাড়া পদ্ধতি
l1 = [1,2,3,4,5]
l2 = ['a','b','c','d','e']
d1 = {}
for l1_ in l1:
for l2_ in l2:
d1[l1_] = l2_
l2.remove(l2_)
break
print (d1)
{1: 'd', 2: 'b', 3: 'e', 4: 'a', 5: 'c'}
dictionary = {zip(keys, values)}কাজ করে না যে লক্ষণীয় । আপনাকে স্পষ্টভাবে ঘোষণা করতে হবেdict(...)