यह सरल गेम ट्यूटोरियल आपको पायथन प्रोग्रामिंग के मूल सिद्धांतों का अभ्यास करने में मदद करेगा।
पायथन में "रॉक, पेपर, कैंची" गेम बनाना आपके प्रोग्रामिंग कौशल को बढ़ाने का एक शानदार तरीका है। आप गेम को एक एकल पायथन स्क्रिप्ट के साथ बना सकते हैं, और इसे कमांड लाइन पर खेल सकते हैं।
खेल खिलाड़ी से उनकी पसंद पूछकर शुरू होता है: "रॉक", "पेपर", या "कैंची"। इसके बाद यह उनकी प्रतिक्रिया दर्ज करने की प्रतीक्षा करता है। आप "कंप्यूटर" प्लेयर के खिलाफ गेम खेल सकते हैं, जो स्वचालित रूप से अपनी चाल का चयन करेगा।
खेल में कई राउंड भी शामिल हो सकते हैं। इसलिए अगर आप पहला राउंड हार भी जाते हैं, तब भी आप तीन में से दो जीतने की कोशिश कर सकते हैं!
गेम को कैसे सेट अप करें और खिलाड़ी से उनकी चाल के लिए पूछें
जब खेल शुरू होता है, तो पायथन प्रोग्राम को खिलाड़ी को "रॉक", "पेपर", या "कैंची" दर्ज करने के लिए कहना चाहिए, और खिलाड़ी की प्रतिक्रिया में लेना चाहिए। एक नया गेम सेट करने के लिए, एक .py एक्सटेंशन के साथ एक नई पायथन फ़ाइल बनाकर प्रारंभ करें।
इस ट्यूटोरियल के लिए पूरा कोड में उपलब्ध है एक GitHub रिपॉजिटरी.
- नामक एक नई फाइल बनाएं RockPaperScissors.py.
- किसी भी टेक्स्ट एडिटर, जैसे नोटपैड ++ या विज़ुअल स्टूडियो कोड का उपयोग करके नई पायथन फ़ाइल खोलें।
- फ़ाइल के शीर्ष पर, यादृच्छिक मॉड्यूल आयात करें। कंप्यूटर की बारी के लिए बेतरतीब ढंग से एक चाल का चयन करने के लिए आप इसे बाद में खेल में उपयोग करेंगे।
आयात अनियमित - खिलाड़ी को एक संदेश प्रस्तुत करें, उन्हें रॉक, पेपर या कैंची में से किसी एक में प्रवेश करने के लिए कहें।
उपयोगकर्ता पसंद = इनपुट ("रॉक, पेपर, या कैंची? ")।निचला() - "moveOptions" नामक एक सरणी को प्रारंभ करें जो उपलब्ध चालों की एक सूची संग्रहीत करता है जिसे आप या कंप्यूटर चला सकते हैं।
चाल विकल्प = ['चट्टान', 'कागज़', 'कैंची'] - जब खिलाड़ी एक इनपुट में प्रवेश करता है, तो यह सुनिश्चित करने के लिए इसे मान्य करें कि यह उपलब्ध चालों में से एक है। एक बार जब खिलाड़ी एक वैध चाल दर्ज कर लेता है, तो एक पुष्टिकरण संदेश प्रिंट करें।
जबकि (उपयोगकर्ता पसंद नहीं में चाल विकल्प):
उपयोगकर्ता पसंद = इनपुट ("अमान्य विकल्प। रॉक, पेपर या कैंची होना चाहिए: ")।निचला()
छपाई("")
प्रिंट (च" आपने चुना {यूजरचॉइस}.")
कंप्यूटर के साथ टर्न कैसे लें और मूव्स की तुलना कैसे करें
एक बार जब आप अपनी चाल दर्ज कर लेते हैं, तो कंप्यूटर बेतरतीब ढंग से "रॉक", "पेपर", या "कैंची" का चयन करके अपनी बारी लेगा। खेल को फिर यह निर्धारित करने के लिए कि कौन जीता है, कंप्यूटर की चाल के साथ आपकी चाल की तुलना करनी होगी।
- कंप्यूटर को उपलब्ध चालों की सूची से बेतरतीब ढंग से चयन करने के लिए यादृच्छिक मॉड्यूल का उपयोग करें।
कंप्यूटरचॉइस = रैंडम.चॉइस (मूवऑप्शन)
प्रिंट (f"कंप्यूटर ने चुना {कंप्यूटरचॉइस}.") - कौन जीता है यह निर्धारित करने के लिए आपको कंप्यूटर की चाल के साथ अपनी चाल की तुलना करने की आवश्यकता होगी। आप एक नया शब्दकोश बनाकर ऐसा कर सकते हैं। इस शब्दकोश में प्रत्येक चाल शामिल है (उदाहरण के लिए, "रॉक"), और यह किस चाल से जीतता है या हारता है (उदाहरण के लिए, "रॉक" "कैंची" को हराता है और "पेपर" से हार जाता है)।
चाल = {
'चट्टान': { 'धड़कता है': 'कैंची', 'हारता है': 'कागज़' },
'कैंची': { 'धड़कता है': 'कागज़', 'हारता है': 'चट्टान' },
'कागज़': { 'धड़कता है': 'चट्टान', 'हारता है': 'कैंची' },
} -
पायथन अगर कथन का प्रयोग करें यह जांचने के लिए कि क्या आपकी चाल और कंप्यूटर की चाल का परिणाम बराबरी पर है। अन्यथा, खिलाड़ी की चाल की तुलना कंप्यूटर की चाल से करने के लिए चाल शब्दकोश का उपयोग करें।
एक उदाहरण के रूप में, यदि आपने "रॉक" चुना है, तो चाल [उपयोगकर्ता पसंद] ['बीट्स'] का मान "कैंची" होगा। यदि कंप्यूटर की पसंद "कैंची" थी, तो इसका मतलब है कि आपकी चाल ने उनकी चाल को हरा दिया।अगर userChoice == कंप्यूटरच्वाइस:
प्रिंट (f"आपने और कंप्यूटर दोनों ने चुना {यूजरचॉइस}. यह एक टाई है!")
अन्य:
अगर (चलता है[userChoice]['धड़कता है'] == कंप्यूटरचॉइस):
प्रिंट (एफ"{यूजरचॉइस} धड़कता है {कंप्यूटरचॉइस}. आप जीतते हैं!")
अगर (चलता है[userChoice]['हारता है'] == कंप्यूटरचॉइस):
प्रिंट (एफ"{यूजरचॉइस} से हार जाता है {कंप्यूटरचॉइस}. कंप्यूटर जीतता है!")
मल्टीपल राउंड के बीच प्लेयर और कंप्यूटर के बीच स्कोर कैसे रखें
आप अतिरिक्त राउंड भी जोड़ सकते हैं, जहाँ आप और कंप्यूटर प्रत्येक में तीन-तीन मोड़ लेते हैं।
एक बार जब आप और कंप्यूटर पत्थर, कागज या कैंची उठा लेते हैं, तो गेम आपसे फिर से पूछेगा और आपके स्कोर पर नज़र रखेगा। उस विशेष राउंड को जीतने वाले के आधार पर खिलाड़ी का स्कोर बढ़ता है।
- वर्तमान कोड खिलाड़ी और कंप्यूटर दोनों द्वारा किए गए घुमावों के एकल दौर का प्रतिनिधित्व करता है। एक नए टर्न () फ़ंक्शन के अंदर इम्पोर्ट स्टेटमेंट को छोड़कर सभी मौजूदा कोड जोड़ें। आप "आप जीत गए" के बजाय "आप इस दौर को जीत गए" कहने के लिए तदनुसार आउटपुट संदेश भी बदल सकते हैं:
डीईएफ़मोड़():
उपयोगकर्ता पसंद = इनपुट ("रॉक, पेपर, या कैंची? ")।निचला()चाल विकल्प = ['चट्टान', 'कागज़', 'कैंची']
जबकि (उपयोगकर्ता पसंद नहीं में चाल विकल्प):
उपयोगकर्ता पसंद = इनपुट ("अमान्य विकल्प। रॉक, पेपर या कैंची होना चाहिए: ")।निचला()छपाई("")
प्रिंट (च" आपने चुना {यूजरचॉइस}.")कंप्यूटरचॉइस = रैंडम.चॉइस (मूवऑप्शन)
प्रिंट (f"कंप्यूटर ने चुना {कंप्यूटरचॉइस}.")चाल = {
'चट्टान': { 'धड़कता है': 'कैंची', 'हारता है': 'कागज़' },
'कैंची': { 'धड़कता है': 'कागज़', 'हारता है': 'चट्टान' },
'कागज़': { 'धड़कता है': 'चट्टान', 'हारता है': 'कैंची' },
}अगर userChoice == कंप्यूटरच्वाइस:
प्रिंट (f"आपने और कंप्यूटर दोनों ने चुना {यूजरचॉइस}. यह एक टाई है!")
अन्य:
अगर (चलता है[userChoice]['धड़कता है'] == कंप्यूटरचॉइस):
प्रिंट (एफ"{यूजरचॉइस} धड़कता है {कंप्यूटरचॉइस}. आप इस दौर को जीतते हैं!")अगर (चलता है[userChoice]['हारता है'] == कंप्यूटरचॉइस):
प्रिंट (एफ"{यूजरचॉइस} से हार जाता है {कंप्यूटरचॉइस}. कंप्यूटर जीतता है!") - खिलाड़ी और कंप्यूटर को तीन-तीन मोड़ लेने हैं। फ़ाइल के शीर्ष पर "टर्न" नामक एक वैश्विक चर जोड़ें।
मोड़ = 3 - टर्न () फ़ंक्शन के बाद, लूप के लिए पायथन का उपयोग करें तीन बार दौर दोहराने के लिए। प्रत्येक दौर की शुरुआत में, गोल संख्या को प्रिंट करें। खिलाड़ी और कंप्यूटर को उस दौर के लिए अपनी चाल चलने के लिए कहने के लिए टर्न () फ़ंक्शन को कॉल करें।
मैं सीमा में (बदलता है) के लिए:
छपाई("")
प्रिंट (एफ" गोल {मैं+1}: ")
मोड़() - प्रत्येक राउंड में कौन जीता, इसका ट्रैक रखने के लिए, फ़ाइल के शीर्ष पर प्रत्येक खिलाड़ी के लिए एक स्कोर वैरिएबल जोड़ें। आप इन वेरिएबल्स को टर्न () फ़ंक्शन के अंदर वैल्यू असाइन करेंगे, इसलिए उन्हें ग्लोबल वेरिएबल्स के रूप में उपयोग करना सुनिश्चित करें।
कंप्यूटरस्कोर = 0
प्लेयरस्कोर = 0डीईएफ़मोड़():
वैश्विक कंप्यूटरस्कोर, प्लेयरस्कोर - टर्न () फ़ंक्शन के अंदर, एक बार खिलाड़ी और कंप्यूटर दोनों ने अपनी चाल चल दी, तो विजेता के स्कोर में एक बिंदु जोड़ें। "प्लेयरस्कोर" या "कंप्यूटरस्कोर" वेरिएबल के मान को बढ़ाने के लिए if स्टेटमेंट को संशोधित करें।
अगर (चलता है[userChoice]['धड़कता है'] == कंप्यूटरचॉइस):
प्रिंट (एफ"{यूजरचॉइस} धड़कता है {कंप्यूटरचॉइस}. आप इस दौर को जीतते हैं!")
प्लेयरस्कोर + = 1अगर (चलता है[userChoice]['हारता है'] == कंप्यूटरचॉइस):
प्रिंट (एफ"{यूजरचॉइस} से हार जाता है {कंप्यूटरचॉइस}. कंप्यूटर जीतता है!")
कंप्यूटरस्कोर + = 1 - टर्न () फ़ंक्शन के अंत में, प्रत्येक खिलाड़ी के लिए कुल स्कोर का अपडेट प्रिंट करें।
# राउंड के बाद कुल स्कोर पर अपडेट प्रिंट करें
छपाई("")
प्रिंट (f"स्कोरबोर्ड | खिलाड़ी का स्कोर: {प्लेयरस्कोर} | कंप्यूटर का स्कोर: {कंप्यूटरस्कोर}") - खेल के बिल्कुल अंत में, और लूप के बाद जो खिलाड़ी और कंप्यूटर के घुमावों को दोहराता है, अंतिम विजेता को प्रिंट करें।
छपाई("")अगर (कंप्यूटरस्कोर> प्लेयरस्कोर):
प्रिंट (f"कंप्यूटर जीतता है {कंप्यूटरस्कोर} अंक!")
elif (प्लेयरस्कोर> कंप्यूटरस्कोर):
प्रिंट (च" आप जीतते हैं {प्लेयरस्कोर} अंक!")
अन्य:
प्रिंट (एफ "यह एक टाई है! आप दोनों साथ जीतते हैं {प्लेयरस्कोर} अंक!")
गेम को कैसे रन करें
गेम खेलने के लिए, टर्मिनल या कमांड प्रॉम्प्ट का उपयोग करके पायथन स्क्रिप्ट चलाएँ। अपनी चाल दर्ज करें और कंप्यूटर को अपना बनाने के लिए प्रतीक्षा करें। एक बार जब आप तीन राउंड पूरे कर लेते हैं, तो कार्यक्रम विजेता को प्रदर्शित करेगा।
- एक कमांड प्रॉम्प्ट या टर्मिनल खोलें, और उस फ़ोल्डर में नेविगेट करें जहां आप अपनी पायथन फ़ाइल संग्रहीत कर रहे हैं।
- स्क्रिप्ट चलाने के लिए पायथन कमांड का प्रयोग करें:
अजगररॉक कागज कैंची.py - या तो 'रॉक', 'पेपर', या 'कैंची' दर्ज करके गेम खेलें।
गेम बनाकर पायथन सीखें
"रॉक, पेपर, कैंची" गेम जैसे सरल गेम बनाना प्रोग्रामिंग अवधारणाओं से अधिक परिचित होने का एक शानदार तरीका है। आप पाइथन का उपयोग करके कई अन्य मजेदार गेम बना सकते हैं, जैसे टेक्स्ट-आधारित एडवेंचर गेम।
