पायथन टर्टल मॉड्यूल के साथ आकृतियाँ बनाना

पाइथॉन भाषा के बारे में हमारी बुनियादी समझ यह जानना है कि हम फ़ंक्शंस को प्रोग्राम कर सकते हैं, पायथन लूप्स की मदद से पुनरावृत्तियों को पेश कर सकते हैं, और यह तय कर सकते हैं कि सशर्त कथनों की मदद से कौन सा प्रोग्राम निष्पादित करना है if, elifऔर else. लेकिन पाइथॉन उससे कहीं अधिक शक्तिशाली है; यह फ़ाइलों तक पहुंच और प्रक्रिया कर सकता है, दिलचस्प गेम बना सकता है, वैज्ञानिक अवधारणाओं का अनुकरण कर सकता है, बड़े डेटा को संसाधित कर सकता है, मशीन लर्निंग मॉडल तैयार कर सकता है, और भी बहुत कुछ!

इस लेख में, हम पायथन मॉड्यूल टर्टल का उपयोग करके ग्राफिकल आउटपुट बनाने के लिए पायथन का उपयोग करेंगे। यह एक शुरुआती-अनुकूल ट्यूटोरियल है जो पायथन का उपयोग करके आकृतियाँ और प्रोग्राम चित्र बनाना सिखाता है। आगे बढ़ने के लिए, पायथन के बुनियादी सिद्धांतों की गहन समझ होना आवश्यक है: बुनियादी कथन, लूप, कक्षाएं और ऑब्जेक्ट, और एक्सेसिंग मॉड्यूल।

पायथन का कछुआ मॉड्यूल

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

from turtle import *

अब, आइए हम पायथन आधिकारिक दस्तावेज़ीकरण के माध्यम से इस मॉड्यूल के बारे में गहराई से जानें:

कछुआ मूल आदेश

जैसा कि ऊपर लिंक किए गए दस्तावेज़ से देखा जा सकता है, मूल आदेश जो हम अपने कछुए को दे सकते हैं वे निम्नलिखित हैं:

• forward() यह फ़ंक्शन कछुए को एक विशिष्ट दूरी से आगे बढ़ने के लिए कहता है। यह एक पूर्णांक मान को तर्क के रूप में लेता है।
• backward()यह फ़ंक्शन कछुए को एक विशिष्ट दूरी से पीछे की ओर जाने के लिए कहता है। यह एक पूर्णांक मान को तर्क के रूप में भी लेता है।
• left()यह कछुए को एक निश्चित कोण से बाईं ओर मुड़ने के लिए कहता है जिसे तर्क के रूप में फ़ंक्शन में पारित किया गया है।
• right()यह कछुए को एक निश्चित कोण से दाईं ओर मुड़ने के लिए कहता है जिसे तर्क के रूप में फ़ंक्शन में पारित किया गया है।
• color() यह उस स्ट्रिंग के अनुसार कछुए का रंग बदल देगा जो इस फ़ंक्शन को एक तर्क के रूप में पारित किया गया है (उदाहरण के लिए, “गुलाबी”)। रंगों के नाम यहां से प्राप्त किए जा सकते हैं यहाँ.
• width() यह सूचक की चौड़ाई को पूर्णांक मान से बदल देगा
• exitonclick() यह हमें स्क्रीन पर क्लिक करके, हमारे कोड के आउटपुट के रूप में उत्पन्न स्क्रीन को बंद करने की अनुमति देगा।

निम्नलिखित कोड चलाएँ, और इसे अपनी आवश्यकताओं के अनुसार बदलें यह समझने के लिए कि उपरोक्त प्रत्येक फ़ंक्शन को कॉल करने पर कछुआ क्या करता है।

from turtle import *
color("pink")
width(5)
forward(100)
left(45)

color("blue")
width(4)
forward(100)
left(45)
forward(20)

color("red")
width(4)
forward(60)
left(45)
backward(50)

color("yellow")
width()
forward(100)
right(45)

exitonclick()

OOP टर्टल ग्राफ़िक्स का उपयोग करना

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

आगे बढ़ने के लिए, कक्षाओं और वस्तुओं की बुनियादी स्तर की समझ होना महत्वपूर्ण है, विशेष रूप से वस्तुओं को उनके गुणों और विधियों के साथ कैसे बनाया जा सकता है।

आइए अपना कछुआ और स्क्रीन ऑब्जेक्ट बनाएं:

from turtle import Turtle, Screen

my_turtle = Turtle()
print(my_turtle)

जैसा कि ऊपर स्क्रीनशॉट से देखा जा सकता है, कछुआ ऑब्जेक्ट बनाया गया है, और उसका स्थान परिभाषित किया गया है। अब हम अपने कछुए को अनुकूलित करने के लिए दस्तावेज़ का उपयोग करेंगे।

हम निम्नलिखित कोड का उपयोग करके अपने कछुए के आकार, रंग और चौड़ाई को परिभाषित करेंगे:

my_turtle.shape("turtle")
my_turtle.color("coral1")
my_turtle.width(4)

आइए हम स्क्रीन ऑब्जेक्ट को भी परिभाषित करें और इसे कस्टमाइज़ करें।

screen = Screen()
screen.title('Drawing Shapes with Turtle Module')
screen.bgcolor("white")
screen.exitonclick()

स्क्रीन ऑब्जेक्ट को ऊपर परिभाषित किया गया है, और उसका शीर्षक और पृष्ठभूमि रंग तदनुसार सेट किए गए हैं। अब, आइए इस ट्यूटोरियल के मुख्य लक्ष्य की ओर बढ़ें!

आकृतियाँ बनाना

अब हम सीखेंगे कि अपने अनुकूलित कछुए के साथ विभिन्न आकृतियाँ कैसे बनाएं!

त्रिकोण

पहली आकृति जो हम बनाएंगे वह एक त्रिभुज है। इसे उन बुनियादी कार्यों का उपयोग करके तैयार किया जा सकता है जिनकी हमने ऊपर चर्चा की है: आगे और दाएं। हम जानते हैं कि एक त्रिभुज में 3 भुजाएँ होती हैं, और एक समबाहु त्रिभुज के लिए, प्रत्येक भुजा के बीच का कोण 60 होता है। हम कोड की निम्नलिखित पंक्तियों का उपयोग करके इस त्रिभुज को बना सकते हैं:

my_turtle.forward(200)
my_turtle.right(120)
my_turtle.forward(200)
my_turtle.right(120)
my_turtle.forward(200)
my_turtle.right(120)

जैसा कि देखा जा सकता है, हमने अपने कछुए की मदद से सफलतापूर्वक एक त्रिकोण बनाया है। ध्यान दें कि हमने वह कोण निर्धारित किया है जिससे कछुआ दाईं ओर जाता है, 120, तो इसका मतलब यह होगा कि शेष कोण जो त्रिभुज का आंतरिक कोण बनेगा, 180 – 120 = 60 होगा। यह हमारा लक्ष्य था। हम अगले आकार के लिए भी इसी तरह काम करेंगे।

वर्ग

अब हम अपने कछुए का उपयोग एक वर्ग बनाने के लिए करेंगे। चूँकि एक वर्ग की 4 भुजाएँ होती हैं, इसलिए जब भी हम सही विधि का उपयोग कर रहे हों तो हम 360/4 = 90º के कोण के साथ, 4 बार आगे बढ़ने की विधि का उपयोग करेंगे। आइए हम भी कछुए का रंग बदलकर गहरा फ़िरोज़ा कर दें (कछुआ रंग)

यहाँ एक वर्ग बनाने के लिए हमारा कोड है:

my_turtle.color("dark turquoise")
my_turtle.forward(200)
my_turtle.right(90)
my_turtle.forward(200)
my_turtle.right(90)
my_turtle.forward(200)
my_turtle.right(90)
my_turtle.forward(200)
my_turtle.right(90)

पंचकोण

इसके बाद, हम एक पंचकोण बनाएंगे, जो 5-भुजाओं वाली आकृति है, जिसकी प्रत्येक भुजा के बीच का कोण 108 के बराबर है। इसका मतलब है कि बाहरी कोण 72 के बराबर होगा। हम उपरोक्त को अपने कोड में कोड करेंगे, इस बार 5 भुजाओं के लिए कोड की 5 पंक्तियों का उपयोग करेंगे। हम अपने कछुए का रंग भी बदल देंगे.

my_turtle.color("spring green")
my_turtle.forward(150)
my_turtle.right(72)
my_turtle.forward(150)
my_turtle.right(72)
my_turtle.forward(150)
my_turtle.right(72)
my_turtle.forward(150)
my_turtle.right(72)
my_turtle.forward(150)
my_turtle.right(72)

जैसा कि आप उपरोक्त कोड ब्लॉक में देख सकते हैं, हमने आगे की गति को 200 से घटाकर 150 कर दिया है ताकि पेंटागन को स्क्रीन के भीतर खींचा जा सके।

एल्गोरिथम का निर्माण

हमने एक त्रिभुज, एक वर्ग और एक पंचभुज बनाने के लिए कछुए मॉड्यूल का उपयोग किया है। जैसा कि हम ऊपर से देख सकते हैं, हम आसानी से एक पैटर्न का पता लगा सकते हैं। कछुआ जितनी तरफ है उतनी ही आगे और दाईं ओर चलता है। एक त्रिभुज, इस प्रकार तीन-तरफा आकृति बनाने के लिए, कछुआ आगे बढ़ता है, फिर दाएँ, फिर आगे, फिर दाएँ, फिर आगे और फिर दाएँ, आगे और दाएँ के कुल 3 सेट। एक वर्ग के लिए, एक ही सेट को चार बार क्रियान्वित किया जाता है, अर्थात, आकृति में जितनी भुजाएँ होती हैं। और इसी प्रकार एक पंचकोण के लिए भी। इस प्रकार, हम आवर्ती आगे और सही कार्यों का एक पैटर्न स्थापित कर सकते हैं। जब भी कछुआ आगे बढ़ता है तो हम तय की गई दूरी का एक निश्चित मान निर्धारित कर सकते हैं। जहां तक ​​सही विधि से दिए गए कोण की बात है तो जिस प्रकार कथनों को कितनी बार दोहराया जाए यह आकृति में भुजाओं की संख्या पर निर्भर करता है, उसी प्रकार कोण भी भुजाओं की संख्या से निर्धारित होता है। इस बाह्य कोण की गणना निम्नलिखित सूत्र द्वारा आसानी से की जा सकती है:

बाहरी कोण = 360 / भुजाओं की संख्या

एक त्रिभुज का बाह्य कोण 360/3 = 120 होगा। एक वर्ग का बाह्य कोण 360/4 = 90 होगा, इत्यादि। इसका उपयोग सही विधि से फीड करने के लिए किया जाएगा।

फ़ंक्शन को परिभाषित करना

अब हम एक सामान्य फ़ंक्शन को परिभाषित करेंगे जो आकृति बनाने के लिए किसी आकृति की भुजाओं की संख्या लेता है। यदि हम तर्क के रूप में 3 देते हैं, तो यह एक त्रिभुज बनाएगा। यदि हम तर्क के रूप में 8 देते हैं, तो यह एक अष्टकोण इत्यादि बनाएगा।

def draw_shapes(num_sides):
    angle = 360 / num_sides
    for i in range(num_sides):
        my_turtle.forward(50)
        my_turtle.right(angle)

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

my_turtle.color("pale violet red")
draw_shapes(8)

एक सीमा के भीतर आकृतियाँ बनाना

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

आइए हम प्रत्येक आकृति को अलग-अलग रंग से बनाने का प्रावधान भी जोड़ें। उसके लिए, हम रंगों की एक सूची बनाएंगे, और सूची में रंगों के माध्यम से लूप भी लूप करेगा।

my_colors = ("dark gray", "hot pink", "midnight blue", "orange", "indigo", "dark sea green", "tan", "pale violet red", "sky blue", "spring green")

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

def draw_shapes(num_sides):
    angle = 360 / num_sides
    my_turtle.color(my_colors(3-num_sides))
    for i in range(num_sides):
        my_turtle.forward(75)
        my_turtle.right(angle)

for shape_size_n in range(3,11):
    draw_shapes(shape_size_n)

निष्कर्ष

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