क्या एक शब्दकोश "टेम्पलेट" बनाना संभव है?

Question

मैं एक प्रकार का नुस्खा चयनकर्ता बना रहा हूं और एक एकीकृत शब्दकोश टेम्पलेट बनाने के लिए देख रहा हूं।

menu_item_var = {'name': "Menu Item", 'ing': (ingredients)} 

मैं name और ing पुन: लिखने हर menu_item_var के लिए, समय की खातिर और एक गलत कुंजी की संभावना आपदा के लिए लेकर चिंतित हूं: मैं वर्तमान में कुछ इस तरह की है। मुझे पता है कि मैं Menu Item को tuple, मेंमिटा सकता हूं और for लूप को शब्दकोशों को सुरक्षित बनाने के लिए लूप चला सकता हूं, लेकिन से dict पर मूल menu_item_var को परिवर्तित नहीं करेगा। क्या ऐसा करने का एक "स्मार्ट" तरीका है?

Answer 1

मैं शायद एक वर्ग बनाने और कुछ इस तरह के लिए बजाय OOP का उपयोग करने में रखने का सुझाव देते चाहते हैं।

class Recipe: 
    def __init__(self,name,ingredients): 
     self.name = name 
     self.ingredients = ingredients 
    def __str__(self): 
     return "{name}: {ingredients}".format(name=self.name,ingredients=self.ingredients) 

toast = Recipe("toast",("bread")) 
sandwich = Recipe("sandwich",("bread","butter","ham","cheese","butter","bread")) 

चूंकि आपका "टेम्पलेट" अधिक से अधिक जटिल हो जाता है, यह केवल डेटा परिभाषा से अधिक हो जाता है और तर्क की आवश्यकता होती है। कक्षा का उपयोग करने से आप इसे समाहित कर सकते हैं।

उदाहरण के लिए, हमारे सैंडविच के ऊपर 2 रोटी और 2 बटर हैं। हम आंतरिक रूप से इस पर नज़र रखने के है, इसलिए की तरह चाहते हो सकता है:

class Recipe: 
    def __init__(self,name,ingredients): 
     self.name = name 
     self.ingredients = {} 
     for i in ingredients: 
      self.addIngredient(i) 
    def addIngredient(self, ingredient): 
     count = self.ingredients.get(ingredient,0) 
     self.ingredients[ingredient] = count + 1 
    def __str__(self): 
     out = "{name}: \n".format(name=self.name) 
     for ingredient in self.ingredients.keys(): 
      count = self.ingredients[ingredient] 
      out += "\t{c} x {i}\n".format(c=count,i=ingredient) 
     return out 

sandwich = Recipe("sandwich",("bread","butter","ham","cheese","butter","bread")) 
print str(sandwich) 

कौन सा हमें देता है:

sandwich: 
    2 x butter 
    1 x cheese 
    1 x ham 
    2 x bread 

Answer 2

ऐसा करने के कई बहुत ही सरल तरीके हैं। सबसे आसान तरीका है कि मैं सोच सकता हूं कि उस शब्दकोश वस्तु को वापस करने के लिए केवल एक फ़ंक्शन बनाना होगा।

def get_menu_item(item, ingredients): 
    return {'name': item, 'ing': ingredients} 

बस इस तरह इसे कहते ...

menu_item_var = get_menu_item("Menu Item", (ingredients)) 

संपादित करें: संपादित, लगातार कोड स्टाइल का उपयोग करने के PEP8 प्रति।

Answer 3

वैकल्पिक रूप से therearetwoosingoose क्या सुझाव दिया है,

>>> menu_item = lambda name, ing: {'name': name, 'ing': ing} 
>>> sandwich = menu_item('sandwich', ['cheese', 'tomato']) 

अब सैंडविच है:

>>> sandwich 
{'name': 'sandwich', 'ing': ['cheese', 'tomato']} 

Answer 4

शब्दकोश कुंजी-मान मैपिंग, आम तौर पर एक लचीला संरचना के लिए इस्तेमाल किया जा सकता है। कक्षा के उदाहरण गुणों के समूह के साथ ऑब्जेक्ट होते हैं, आमतौर पर जब आपके पास कई ऑब्जेक्ट होते हैं जिनमें सभी की समान संरचना होती है।

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

collections.namedtuple इस तरह के वर्ग का निर्माण और उपयोग करने का एक बेहद हल्का तरीका है (जिसका उदाहरण केवल फ़ील्ड के एक विशेष सेट के साथ ऑब्जेक्ट्स है)। उदाहरण:

>>> from collections import namedtuple 
>>> MenuItem = namedtuple('MenuItem', ['name', 'ing']) 
>>> thing = MenuItem("Pesto", ["Basil", "Olive oil", "Pine nuts", "Garlic"]) 
>>> print thing 
MenuItem(name='Pesto', ing=['Basil', 'Olive oil', 'Pine nuts', 'Garlic']) 
>>> thing.name 
'Pesto' 
>>> thing.ing 
['Basil', 'Olive oil', 'Pine nuts', 'Garlic'] 

"नकारात्मक" यह है कि वे अभी भी tuples, और इतने अपरिवर्तनीय हैं।मेरे अनुभव में आमतौर पर छोटे साधारण सादे-डेटा ऑब्जेक्ट्स के लिए एक अच्छी बात होती है, लेकिन यह आपके दिमाग में उपयोग के लिए एक कमी हो सकती है।

Answer 5

आप कोशिश करते हैं और json और स्ट्रिंग प्रक्षेप का उपयोग एक बहुत ही बुनियादी dict खाका बनाने के लिए कर सकते हैं:

import json 
template = '{"name": "Menu Item", "ing": %s }' 

def render(value): 
    return json.loads(template % json.dumps(value)) 

render([1,2,3]) 
>> {u'ing': [1, 2, 3], u'name': u'Menu Item'}