एक मानक डेक में पाए जाने वाले की तुलना में अधिक जटिल प्लेइंग कार्ड प्रकारों के लिए कक्षाएं बनाने का एक अच्छा तरीका है?

Question

मैं ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के लिए बेहद नया हूं, और एक साधारण कार्ड गेम (जैसा कि पारंपरिक लगता है!) बनाकर अजगर में सीखना शुरू करने की कोशिश कर रहा हूं। मैंने निम्नलिखित उदाहरण किया है जो ठीक काम करता है, और मुझे PlayingCard()कक्षा का एक उदाहरण बनाने के लिए कक्षा के कई उदाहरण बनाने के बारे में सिखाता है Deck():

class PlayingCard(object):
    def __init__(self, suit, val):
        self.suit = suit
        self.value = val

    def print_card(self):
        print("{} of {}".format(self.value, self.suit))

class Deck(object):
    def __init__(self):
        self.playingcards = []
        self.build()

    def build(self):
        for s in ["Spades", "Clubs", "Diamonds", "Hearts"]:
            for v in range(1,14):
                self.playingcards.append(PlayingCard(s,v))

deck = Deck()

मैं अब अधिक जटिल कार्ड के साथ कुछ बनाना चाहता हूं, न कि केवल एक मानक 52 डेक (जिसमें अच्छी तरह से वृद्धि मूल्य हैं)। मेरे मन में जो डेक है वह एकाधिकार कार्ड गेम है:

3 मौलिक प्रकार के कार्ड हैं - कार्रवाई कार्ड, संपत्ति कार्ड और पैसा कार्ड। एक्शन कार्ड अलग-अलग क्रिया करते हैं, प्रॉपर्टी कार्ड अलग-अलग रंग सेट के होते हैं, और मनी कार्ड में अलग-अलग मूल्य हो सकते हैं। इसके अतिरिक्त, संपत्ति कार्ड "वाइल्डकार्ड" हो सकते हैं, और दो सेटों में से एक के हिस्से के रूप में उपयोग किया जा सकता है। अंत में, प्रत्येक कार्ड में एक समतुल्य धन मूल्य (प्रत्येक कार्ड के शीर्ष कोने में इंगित) होता है। किराए के एक्शन कार्डों में, कार्ड केवल कार्ड पर इंगित रंग संपत्ति पर लागू हो सकता है।

मेरा सवाल यह है कि आम तौर पर इस तरह की स्थिति को कैसे संभालना है, और कक्षा-आधारित अजगर कार्यक्रम में इन विभिन्न कार्डों को शामिल करने का एक अच्छा तरीका क्या होगा? मैं अपने ही रखना चाहिए PlayingCard()वर्ग, और बस जैसे कई आदानों, है PlayingCard(type="PROPERTY", value="3M")। या यह इस तरह के रूप अलग कक्षाएं बनाने के लिए बेहतर होगा ActionPlayingCard(), PropertyPlayingCard(), आदि? या कोई बेहतर तरीका है? जैसा कि मैं कहता हूं, मैं यहां अपने सीखने की शुरुआत में हूं, और उच्च स्तर के डिजाइन के संदर्भ में इस प्रकार की स्थितियों को कैसे व्यवस्थित किया जाए।

बहुत धन्यवाद।

Comments

यदि आप पाते हैं कि विभिन्न प्रकार के कार्ड कुछ विशेषताओं को साझा करते हैं, तो आप विरासत, या यहां तक ​​कि सार वर्ग का उपयोग कर सकते हैं। आप फ़ैक्टरी पैटर्न के बारे में पढ़ सकते हैं और उपयोग कर सकते हैं ताकि आप कार्ड के प्रकार को पास कर सकें और उपयुक्त वर्ग का उपयोग किया जा सके

— टॉमेरिकू

@ टोमेरिको आपको इस ओर इशारा करने के लिए धन्यवाद - मैंने आपके द्वारा बताए गए कारखाने पैटर्न के बारे में थोड़ा पढ़ा है। जैसा कि मैं इसे समझता हूं, यह सबसे उपयोगी है जब आप पहले से नहीं जानते हैं कि आपको किस वर्ग की वस्तुओं को बनाने की आवश्यकता होगी (शायद केवल रनटाइम में जानते हुए)। हालाँकि, इस मामले के बाद से मुझे पता है कि पूरे डेक को कैसा दिखना चाहिए (प्रत्येक कार्ड के कितने प्रकार, वे प्रत्येक क्या करते हैं, आदि), क्या फ़ैक्टरी पैटर्न यहां लागू है?

— Teeeeee

Answer 1

जब आप ओओपी के साथ एक समस्या आ रहे हैं , तो आप आमतौर पर व्यवहार और गुणों को पुन: प्रयोज्य तरीके से मॉडल करना चाहते हैं, अर्थात, आपको सार के बारे में सोचना चाहिए और उसी के आधार पर अपनी श्रेणी के पदानुक्रम को व्यवस्थित करना चाहिए।

मैं कुछ इस तरह लिखूंगा:

class Card:
    def __init__(self, money_value=0):
        self.money_value = money_value

class ActionCard(Card):
    def __init__(self, action, money_value=0):
        super().__init__(money_value=money_value)

        self.action = action

class RentActionCard(ActionCard):
    def __init__(self, action, color, money_value=0):
        super().__init__(action, money_value=money_value)

        self.color = color

    def apply(self, property_card):
        if property_card.color != self.color:
            # Don't apply
        # Apply

class PropertyCard(Card):
    def __init__(self, color, money_value=0):
        super().__init__(money_value=money_value)

        self.color = color

class WildcardPropertyCard(PropertyCard):
    def __init__(self, color, money_value=0):
        super().__init__(color, money_value=money_value)

class MoneyCard(Card):
    def __init__(self, money_value=0):
        super().__init__(money_value=money_value)

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

यदि मैं उदाहरण के लिए C # में इस समस्या को मॉडल कर रहा था , तो मैं बिना किसी संदेह के ऊपर दिखाए गए पदानुक्रम का उपयोग कर सकता हूं, क्योंकि मैं विभिन्न प्रकार का प्रतिनिधित्व करने के लिए बहुरूपता पर भरोसा कर सकता हूं और अपने तर्क के प्रवाह का मार्गदर्शन कर सकता हूं कि किस प्रकार के कार्ड का विश्लेषण किया जा रहा है।

अंतिम टिप्पणी की एक जोड़ी:

1. पायथन में बहुत शक्तिशाली बिलिन प्रकार होते हैं, लेकिन अधिकांश समय नए कस्टम प्रकारों का उपयोग करते हैं जो उन पर निर्मित होते हैं जो आपके जीवन को आसान बनाते हैं।
2. आपको पायथन 3 केobject प्रकारों से विरासत में प्राप्त नहीं करना है (जो कि आज तक केवल एक ही बनाए रखा गया है) डिफ़ॉल्ट रूप से विरासत में मिला है।object

लेकिन, दिन के अंत में, एक सही जवाब नहीं है, सबसे अच्छा तरीका दोनों दृष्टिकोणों की कोशिश करना होगा और देखना होगा कि आप किस चीज के साथ सहज हैं।

Answer 2

ये हम "डिजाइन निर्णय" कहते हैं। अक्सर "सही" तरीका राय का विषय है। एक शुरुआत के रूप में, मुझे लगता है कि यह दोनों कार्यान्वयन को देखने के लिए निर्देशात्मक होगा कि वे कैसे काम करते हैं। कोई फर्क नहीं पड़ता कि आप कौन सा व्यापार करते हैं। आपको यह तय करना होगा कि उन व्यापारों में से कौन सा सबसे महत्वपूर्ण है। इस प्रकार के निर्णय लेने से आपको अधिक अनुभव प्राप्त होगा।

Comments

हां, धन्यवाद, मैं ठीक वैसा ही कर रहा हूं जैसा आप कहते हैं - बस उन लोगों के मार्गदर्शन की तलाश कर रहे हैं जो सहज रूप से एक अच्छा दृष्टिकोण जानने के लिए पर्याप्त रूप से अनुभवी हैं, और उम्मीद है कि क्यों समझें।

— तीज

Answer 3

आप इनहेरिटेंस का उपयोग कर सकते हैं। यह वह जगह है जहाँ आप एक मुख्य वर्ग बनाते हैं, फिर भी उप-वर्ग होते हैं जिनमें अभी भी मदर क्लास से फ़ंक्शंस और मान होते हैं, लेकिन उस विशिष्ट वर्ग के लिए अतिरिक्त मान और फ़ंक्शंस भी हो सकते हैं।

class Apple:
    def __init__(self, yearMade):
        pass

    def ring(self):
        print('ring ring')

class iPhone(Apple):
    def __init__(self, number)
        number = number

    def func():
        pass

अब iPhone क्लास में Apple क्लास और अपने स्वयं के फ़ंक्शन के समान कार्य हैं। यदि आप विरासत के बारे में अधिक जानना चाहते हैं तो मैं कुछ शोध करने की सलाह देता हूं।

Comments

@teeeeee जैसा कि प्रत्येक कार्ड का मूल्य होता है, आप उनका व्यापार करने में सक्षम होते हैं और उन्हें निभा सकते हैं, आप इन घटनाओं को संभालने के लिए एक कक्षा में फ़ंक्शंस / प्रक्रियाएँ बना सकते हैं और फिर उप-क्लास में कुछ कार्ड्स के लिए अतिरिक्त विशेषताएँ और फ़ंक्शंस कर सकते हैं।

— MoriartyPy

Answer 4

एकाधिकार के लिए, मैं गेम लैंडिंग बिंदु को डिजाइन करूंगा। कार्ड नहीं। कार्ड केवल वास्तविक दुनिया के लिए लैंडिंग का प्रतिनिधित्व करते हैं।

Comments

कृपया विस्तार से बताएं।

— तीई