راهنمای مبتدیان برای لاک پشت پایتون

وقتی بچه بودم، لوگو را یاد می گرفتم، یک زبان برنامه نویسی که شامل یک لاک پشت بود که می توانستید تنها با چند دستور در اطراف صفحه حرکت دهید. به یاد می آورم که وقتی این شی کوچک را روی صفحه نمایش خود کنترل می کردم، احساس می کردم یک نابغه کامپیوتر هستم و این چیزی بود که در وهله اول مرا به برنامه نویسی علاقه مند کرد. کتابخانه لاک پشت پایتون دارای یک ویژگی تعاملی مشابه است که به برنامه نویسان جدید طعم کار با پایتون را می دهد.

در این آموزش شما:

• آشنایی با کتابخانه لاک پشت پایتون
• با نحوه راه اندازی لاک پشت در رایانه خود آشنا شوید
• برنامه نویسی با کتابخانه لاک پشت پایتون
• درک برخی از مفاهیم مهم پایتون و فرمان های turtle
• با استفاده از آنچه آموخته اید، یک بازی کوتاه اما سرگرم کننده بسازید.

اگر در پایتون مبتدی هستید، این آموزش به شما کمک می کند تا اولین قدم های خود را به دنیای برنامه نویسی با کمک کتابخانه لاک پشت پایتون بردارید!

آشنایی با کتابخانه لاک پشت پایتون

Turtle یک کتابخانه از پیش نصب شده پایتون است که کاربران را قادر می سازد تا با ارائه یک بوم مجازی، تصاویر و اشکال ایجاد کنند. قلم روی صفحه ای که برای طراحی استفاده می کنید لاک پشت نامیده می شود و این همان چیزی است که نام کتابخانه را می دهد. به طور خلاصه، کتابخانه لاک پشت پایتون به برنامه نویسان جدید کمک می کند تا به روشی سرگرم کننده و تعاملی احساس کنند که برنامه نویسی با پایتون چگونه است.

لاک پشت عمدتا برای معرفی کودکان به دنیای کامپیوتر استفاده می شود. این یک راه ساده و در عین حال همه کاره برای درک مفاهیم پایتون است. این باعث می شود که بچه ها اولین قدم های خود را در برنامه نویسی پایتون بردارند. همانطور که گفته شد، کتابخانه لاک پشت پایتون به تنهایی به بچه های کوچک محدود نمی شود! همچنین برای بزرگسالانی که دست خود را در پایتون امتحان می کنند بسیار مفید است، که آن را برای مبتدیان پایتون عالی می کند.

با کتابخانه لاک پشت پایتون می توانید انواع مختلفی از اشکال و تصاویر را ترسیم و ایجاد کنید. در اینجا نمونه ای از انواع نقاشی هایی که می توانید با لاک پشت بسازید آورده شده است:

باحال، درست است؟ این تنها یکی از نقاشی های مختلفی است که می توانید با استفاده از کتابخانه لاک پشت پایتون بسازید. اکثر توسعه دهندگان از لاک پشت برای ترسیم اشکال، ایجاد طرح ها و ساخت تصاویر استفاده می کنند. برخی دیگر از لاک پشت برای ایجاد مینی بازی ها و انیمیشن ها استفاده می کنند، درست مانند آنچه در بالا دیدید.

شروع کار با لاک پشت

قبل از ادامه، دو کار مهم وجود دارد که باید انجام دهید تا از این آموزش نهایت استفاده را ببرید:

1. محیط پایتون: مطمئن شوید که با محیط برنامه نویسی خود آشنا هستید. می توانید از برنامه هایی مانند IDLE یا Jupyter Notebook برای برنامه نویسی با لاک پشت استفاده کنید. با این حال، اگر با آنها راحت نیستید، می توانید با REPL برنامه نویسی کنید که در این آموزش از آن استفاده خواهید کرد.

2. نسخه پایتون: اطمینان حاصل کنید که نسخه 3 پایتون را در رایانه خود دارید. در غیر این صورت، می توانید آن را از وب سایت پایتون دانلود کنید. برای راهنمایی در تنظیم چیزها، راهنمای نصب و راه اندازی پایتون 3 را بررسی کنید.

خوبی لاک پشت این است که یک کتابخانه داخلی است، بنابراین نیازی به نصب بسته های جدید ندارید. تنها کاری که باید انجام دهید این است که کتابخانه را به محیط پایتون خود وارد کنید، که در این مورد REPL خواهد بود. هنگامی که برنامه REPL خود را باز کردید، می توانید با تایپ خط کد زیر، پایتون 3 را روی آن اجرا کنید:

>>> python3

این کار پایتون 3 را به برنامه REPL شما فراخوانی می کند و محیط را برای شما باز می کند.

قبل از شروع برنامه نویسی پایتون، باید بدانید که کتابخانه چیست. در دنیای غیر کامپیوتری، کتابخانه مکانی است که انواع مختلف کتاب در آن ذخیره می شود. شما می توانید در هر زمان به این کتاب ها دسترسی داشته باشید، هر اطلاعاتی را که نیاز دارید از آنها بگیرید و آنها را به همان مکان برگردانید.

در دنیای کامپیوتر، یک کتابخانه به همین ترتیب کار می کند. طبق تعریف، کتابخانه مجموعه ای از توابع و روش های مهم است که می توانید برای آسان تر کردن برنامه نویسی خود به آنها دسترسی داشته باشید. کتابخانه لاک پشت پایتون شامل تمام متدها و عملکردهایی است که برای ایجاد تصاویر خود نیاز دارید. برای دسترسی به کتابخانه پایتون، باید آن را به محیط پایتون خود وارد کنید، مانند این:

>>> import turtle

اکنون که لاک پشت را در محیط پایتون خود دارید، می توانید برنامه نویسی را با آن شروع کنید. Turtle یک کتابخانه گرافیکی است، به این معنی که برای اجرای هر دستور ترسیم باید یک پنجره جداگانه (به نام صفحه) ایجاد کنید. شما می توانید این صفحه را با مقداردهی اولیه یک متغیر برای آن ایجاد کنید.

در پایتون، از متغیرهایی برای ذخیره اطلاعاتی استفاده می کنید که بعدا در برنامه خود از آنها استفاده خواهید کرد. وقتی یک متغیر را به آن اختصاص می دهید، مقداردهی اولیه می کنید. از آنجایی که مقدار متغیر ثابت نیست، می تواند چندین بار در طول اجرای برنامه شما تغییر کند.

اکنون، برای باز کردن صفحه لاک پشت، متغیری را برای آن به روش زیر مقداردهی اولیه می کنید:

>>> s = turtle.getscreen()

باید پنجره جداگانه ای را باز کنید:

این پنجره صفحه نمایش نامیده می شود. اینجاست که می توانید خروجی کد خود را مشاهده کنید. شکل مثلثی سیاه کوچک در وسط صفحه لاک پشت نامیده می شود.

در مرحله بعد، متغیر t را مقداردهی اولیه می کنید، که سپس از آن در سراسر برنامه برای ارجاع به لاک پشت استفاده خواهید کرد:

>>> t = turtle.Turtle()

درست مانند صفحه نمایش، می توانید به این متغیر نام دیگری مانند a یا Jane یا حتی my_turtle بدهید، اما در این مورد، به t می چسبید.

شما اکنون صفحه نمایش و لاک پشت خود را دارید. صفحه نمایش به عنوان یک بوم عمل می کند، در حالی که لاک پشت مانند یک قلم عمل می کند. می توانید لاک پشت را طوری برنامه ریزی کنید که در اطراف صفحه حرکت کند. لاک پشت دارای ویژگی های قابل تغییر خاصی مانند اندازه، رنگ و سرعت است. همیشه به یک جهت خاص اشاره می کند و در آن جهت حرکت می کند مگر اینکه چیز دیگری به آن بگویید:

• وقتی بالا می رود، به این معنی است که هنگام حرکت هیچ خطی کشیده نمی شود.
• وقتی پایین است، به این معنی است که یک خط هنگام حرکت کشیده می شود.

در بخش بعدی، روش های مختلف برنامه نویسی با کتابخانه لاک پشت پایتون را بررسی خواهید کرد.

برنامه نویسی با لاک پشت

اولین چیزی که در مورد برنامه نویسی با کتابخانه لاک پشت پایتون یاد خواهید گرفت این است که چگونه لاک پشت را در جهتی که می خواهید حرکت کند. در مرحله بعد، یاد خواهید گرفت که چگونه لاک پشت و محیط آن را سفارشی کنید. در نهایت، چند فرمان اضافی را یاد خواهید گرفت که با آنها می توانید تسک های خاصی را انجام دهید.

حرکت لاک پشت

چهار جهت وجود دارد که لاک پشت می تواند در آن حرکت کند:

• جلو
• عقب
• چپ
• راست

لاک پشت .forward() یا .backward() را در جهتی که رو به آن است حرکت می کند. می توانید این جهت را با چرخاندن .left() یا .right() تا حدی تغییر دهید. می توانید هر یک از این دستورات را به این صورت امتحان کنید:

>>> t.right(90)
>>> t.forward(100)
>>> t.left(90)
>>> t.backward(100)

وقتی این دستورات را اجرا می کنید، لاک پشت نود درجه به راست می چرخد، صد واحد به جلو می رود، نود درجه به چپ می پیچد و صد واحد به عقب حرکت می کند. در تصویر زیر می توانید ببینید:

می توانید از نسخه های کوتاه شده این دستورات نیز استفاده کنید:

• t.rt() به جای () t.right()
• t.fd() به جای t.forward()
• t.lt() به جای t.left()
• t.bk() به جای t.backward()

همچنین می توانید از موقعیت فعلی خود به هر موقعیت دلخواه دیگری روی صفحه خط بکشید. این کار با کمک مختصات انجام می شود:

صفحه نمایش به چهار ربع تقسیم می شود. نقطه ای که لاک پشت در ابتدا در ابتدای برنامه شما قرار می گیرد (0,0) است. به این خانه می گویند. برای انتقال لاک پشت به هر منطقه دیگری روی صفحه، از .goto() استفاده می کنید و مختصات را به این صورت وارد کنید:

>>> t.goto(100,100)

خروجی شما به این شکل خواهد بود:

شما یک خط از موقعیت فعلی خود تا نقطه (100,100) روی صفحه کشیده اید.

برای بازگرداندن لاک پشت به موقعیت خانه خود، موارد زیر را تایپ می کنید:

>>> t.home()

این مانند یک دستور میانبر است که لاک پشت را به نقطه (0,0) برمی گرداند. سریعتر از تایپ کردن t.goto(0,0) است.

ترسیم یک شکل

اکنون که حرکات لاک پشت را می دانید، می توانید به سراغ ساختن اشکال واقعی بروید. می توانید با کشیدن چند ضلعی ها شروع کنید زیرا همه آنها از خطوط مستقیمی تشکیل شده اند که در زوایای خاصی به هم متصل شده اند. در اینجا مثالی وجود دارد که می توانید امتحان کنید:

>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)

خروجی شما به این شکل خواهد بود:

آفرین! شما فقط یک مربع کشیده اید. به این ترتیب می توان لاک پشت را برای ایجاد اشکال و تصاویر مختلف برنامه ریزی کرد.

اکنون، سعی کنید یک مستطیل بکشید و از این کد به عنوان الگو استفاده کنید. به یاد داشته باشید، در یک مستطیل، هر چهار ضلع برابر نیستند. شما باید کد را بر اساس آن تغییر دهید. هنگامی که این کار را انجام دادید، حتی می توانید با افزایش تعداد اضلاع و تغییر زوایای، چند ضلعی های دیگری ایجاد کنید.

ترسیم شکل های از پیش تعیین شده

فرض کنید می خواهید یک دایره بکشید. اگر سعی کنید آن را به همان روشی که مربع را ترسیم کرده اید بکشید، بسیار خسته کننده خواهد بود و باید زمان زیادی را فقط برای آن شکل صرف کنید. خوشبختانه، کتابخانه لاک پشت پایتون راه حلی برای این کار ارائه می دهد. می توانید از یک دستور برای کشیدن یک دایره استفاده کنید:

>>> t.circle(60)

شما یک خروجی مانند این دریافت خواهید کرد:

عدد داخل پرانتز شعاع دایره است. با تغییر مقدار شعاع دایره می توانید اندازه دایره را کم یا زیاد کنید.

به همین ترتیب ، می توانید یک نقطه نیز بکشید ، که چیزی جز یک دایره پر شده نیست. این دستور را تایپ کنید:

>>> t.dot(20)

یک دایره پر شده مانند این خواهید داشت:

عدد داخل براکت ها قطر نقطه است. درست مانند دایره، می توانید با تغییر مقدار قطر نقطه، اندازه نقطه را کم یا زیاد کنید.

کار عالی تا کنون! شما یاد گرفته اید که چگونه لاک پشت را به اطراف حرکت دهید و با آن اشکال مختلف ایجاد کنید. در چند بخش بعدی، خواهید دید که چگونه می توانید لاک پشت و محیط آن را بر اساس نیاز خود سفارشی کنید.

تغییر رنگ صفحه نمایش

به طور پیش فرض، لاک پشت همیشه صفحه ای با پس زمینه سفید باز می کند. با این حال، می توانید رنگ صفحه را در هر زمان با استفاده از دستور زیر تغییر دهید:

>>> turtle.bgcolor("blue")

می توانید "آبی" را با هر رنگ دیگری جایگزین کنید. "سبز" یا "قرمز" را امتحان کنید. نتیجه ای مانند این خواهید گرفت:

شما می توانید از رنگ های مختلف برای صفحه نمایش خود فقط با تایپ شماره کد هگز آنها استفاده کنید. برای کسب اطلاعات بیشتر در مورد استفاده از رنگ های مختلف، مستندات کتابخانه لاک پشت پایتون را بررسی کنید.

تغییر عنوان صفحه نمایش

گاهی اوقات، ممکن است بخواهید عنوان صفحه نمایش خود را تغییر دهید. می توانید آن را شخصی تر کنید، مانند "برنامه لاک پشت من"، یا برای آنچه روی آن کار می کنید مناسب تر کنید، مانند "ترسیم اشکال با لاک پشت". با کمک این دستور می توانید عنوان صفحه نمایش خود را تغییر دهید:

>>> turtle.title("My Turtle Program")

نوار عنوان شما اکنون این را نمایش می دهد:

به این ترتیب می توانید عنوان صفحه نمایش خود را با توجه به اولویت خود تغییر دهید.

تغییر اندازه لاک پشت

می توانید اندازه لاک پشت روی صفحه را افزایش یا کاهش دهید تا بزرگتر یا کوچکتر شود. این فقط اندازه شکل را تغییر می دهد بدون اینکه بر خروجی قلم هنگام ترسیم روی صفحه تأثیر بگذارد. دستورات زیر را تایپ کنید:

>>> t.shapesize(1,5,10)
>>> t.shapesize(10,5,1)
>>> t.shapesize(1,10,5)
>>> t.shapesize(10,1,5)

خروجی های شما به این شکل خواهند بود:

اعداد داده شده پارامترهای اندازه لاک پشت است:

• طول کشش
• عرض کشش
• عرض طرح کلی

شما می توانید اینها را با توجه به اولویت خود تغییر دهید. در مثال بالا ، می توانید تفاوت قابل مشاهده ای در ظاهر لاک پشت مشاهده کنید. برای اطلاعات بیشتر در مورد نحوه تغییر اندازه لاک پشت ، مستندات کتابخانه لاک پشت پایتون را بررسی کنید.

تغییر اندازه قلم

دستور قبلی فقط اندازه لاک پشت را تغییر داد. با این حال، گاهی اوقات، ممکن است نیاز به افزایش یا کاهش ضخامت قلم خود داشته باشید. با استفاده از دستور زیر می توانید این کار را انجام دهید:

>>> t.pensize(5)
>>> t.forward(100)

این منجر به نتیجه ای مانند این می شود:

همانطور که می بینید، اندازه قلم شما اکنون پنج برابر اندازه اصلی است (که یک بود). سعی کنید چند خط دیگر در اندازه های مختلف بکشید و تفاوت ضخامت بین آنها را مقایسه کنید.

تغییر رنگ لاک پشت و قلم

هنگامی که برای اولین بار یک صفحه جدید را باز می کنید، لاک پشت به عنوان یک شکل سیاه شروع می شود و با جوهر سیاه نقاشی می کند. بر اساس نیاز خود، می توانید دو کار انجام دهید:

• تغییر رنگ لاک پشت: با این کار رنگ پر شدن تغییر می کند.
• تغییر رنگ قلم: این کار طرح کلی یا رنگ جوهر را تغییر می دهد.

حتی در صورت تمایل می توانید هر دوی اینها را انتخاب کنید. قبل از اینکه رنگ ها را تغییر دهید، اندازه لاک پشت خود را افزایش دهید تا به شما کمک کند تفاوت رنگ را واضح تر ببینید. این کد را تایپ کنید:

>>> t.shapesize(3,3,3)

اکنون برای تغییر رنگ لاک پشت (یا پر کردن)، موارد زیر را تایپ می کنید:

>>> t.fillcolor("red")

لاک پشت شما به این شکل خواهد بود:

برای تغییر رنگ قلم (یا طرح کلی)، موارد زیر را تایپ کنید:

>>> t.pencolor("green")

لاک پشت شما به این شکل خواهد بود:

برای تغییر رنگ هر دو، موارد زیر را تایپ کنید:

>>> t.color("green", "red")

لاک پشت شما به این شکل خواهد بود:

در اینجا، رنگ اول برای قلم و دومی برای پر کردن است. توجه داشته باشید که تغییر رنگ قلم و پر کردن نیز رنگ لاک پشت روی صفحه را بر این اساس تغییر می دهد.

پر کردن یک تصویر

رنگ آمیزی در یک تصویر معمولا باعث می شود بهتر به نظر برسد، اینطور نیست؟ کتابخانه لاک پشت پایتون به شما این امکان را می دهد که به نقاشی های خود رنگ اضافه کنید. سعی کنید کد زیر را تایپ کنید و ببینید چه اتفاقی می افتد:

>>> t.begin_fill()
>>> t.fd(100)
>>> t.lt(120)
>>> t.fd(100)
>>> t.lt(120)
>>> t.fd(100)
>>> t.end_fill()

هنگامی که این کد را اجرا می کنید، مثلثی دریافت خواهید کرد که با یک رنگ ثابت پر شده است، مانند این:

هنگامی که از .begin_fill()استفاده می کنید، به برنامه خود می گویید که می خواهید یک شکل بسته بکشید که باید پر شود. سپس، از .end_fill() استفاده می کنید تا نشان دهید که ایجاد شکل خود را تمام کرده اید و اکنون می توان آن را پر کرد.

تغییر شکل لاک پشت

شکل اولیه لاک پشت در واقع یک لاک پشت نیست، بلکه یک شکل مثلثی است. با این حال، می توانید ظاهر لاک پشت را تغییر دهید، و برای انجام این کار چند گزینه دارید. با تایپ دستورات زیر می توانید به برخی از آنها نگاهی بیندازید:

>>> t.shape("turtle")
>>> t.shape("arrow")
>>> t.shape("circle")

شکل لاک پشت بر این اساس تغییر می کند، مانند این:

شما چند گزینه دیگر نیز دارید که می توانید آنها را امتحان کنید:

• مربع
• فلش
• دایره
• لاک پشت
• مثلث
• کلاسیک

شکل کلاسیک شکل اصلی است. برای کسب اطلاعات بیشتر در مورد انواع اشکالی که می توانید استفاده کنید، مستندات کتابخانه لاک پشت پایتون را بررسی کنید.

تغییر سرعت قلم

لاک پشت به طور کلی با سرعت متوسطی حرکت می کند. اگر می خواهید سرعت را کاهش یا افزایش دهید تا لاک پشت شما کندتر یا سریعتر حرکت کند، می توانید با تایپ موارد زیر این کار را انجام دهید:

>>> t.speed(1)
>>> t.forward(100)
>>> t.speed(10)
>>> t.forward(100)

این کد ابتدا سرعت را کاهش می دهد و لاک پشت را به جلو حرکت می دهد، سپس سرعت را افزایش می دهد و لاک پشت را دوباره به جلو حرکت می دهد، مانند این:

سرعت می تواند هر عددی از 0 (کندترین سرعت) تا 10 (بالاترین سرعت) باشد. می توانید با کد خود بازی کنید تا ببینید لاک پشت چقدر سریع یا کند حرکت می کند.

سفارشی سازی در یک خط

فرض کنید می خواهید ویژگی های لاک پشت خود را به موارد زیر تنظیم کنید:

• رنگ قلم: بنفش
• رنگ پر کردن: نارنجی
• اندازه قلم: 10
• سرعت قلم: 9

با توجه به آنچه که به تازگی یاد گرفتید، کد باید چیزی شبیه به این باشد:

>>> t.pencolor("purple")
>>> t.fillcolor("orange")
>>> t.pensize(10)
>>> t.speed(9)
>>> t.begin_fill()
>>> t.circle(90)
>>> t.end_fill()

خیلی طولانی است، اما آنقدرها هم بد نیست، درست است؟

حالا، فقط تصور کنید که ده لاک پشت مختلف داشته باشید. تغییر تمام ویژگی های آنها برای شما بسیار خسته کننده خواهد بود! خبر خوب این است که می توانید با تغییر پارامترها تنها در یک خط کد، حجم کار خود را کاهش دهید، مانند این:

>>> t.pen(pencolor="purple", fillcolor="orange", pensize=10, speed=9)
>>> t.begin_fill()
>>> t.circle(90)
>>> t.end_fill()

این به شما نتیجه ای مانند این می دهد:

این یک خط کد کل قلم را تغییر داد، بدون اینکه مجبور باشید هر مشخصه را به صورت جداگانه تغییر دهید. برای کسب اطلاعات بیشتر در مورد این دستور، مستندات کتابخانه لاک پشت پایتون را بررسی کنید.

کارت عالی بود! اکنون که یاد گرفتید لاک پشت و صفحه نمایش خود را سفارشی کنید، به برخی از دستورات مهم دیگر که هنگام طراحی با کتابخانه لاک پشت پایتون مورد نیاز هستند، نگاهی بیندازید.

برداشتن قلم به بالا و پایین

گاهی اوقات، ممکن است بخواهید لاک پشت خود را به نقطه دیگری از صفحه حرکت دهید بدون اینکه چیزی روی خود صفحه بکشید. برای انجام این کار، از .penup() استفاده می کنید. سپس، هنگامی که می خواهید دوباره شروع به طراحی کنید، از .pendown() استفاده می کنید. با استفاده از کدی که قبلا برای ترسیم مربع استفاده کرده اید، به آن ضربه بزنید. سعی کنید کد زیر را تایپ کنید:

>>> t.fd(100)
>>> t.rt(90)
>>> t.penup()
>>> t.fd(100)
>>> t.rt(90)
>>> t.pendown()
>>> t.fd(100)
>>> t.rt(90)
>>> t.penup()
>>> t.fd(100)
>>> t.pendown()

هنگامی که این کد را اجرا می کنید، خروجی شما به این شکل خواهد بود:

در اینجا، شما دو خط موازی به جای مربع با اضافه کردن چند دستور اضافی بین برنامه اصلی به دست آورده اید.

لغو تغییرات

مهم نیست که چقدر مراقب باشید، همیشه احتمال اشتباه کردن وجود دارد. با این حال، نگران نباشید! کتابخانه لاک پشت پایتون به شما این امکان را می دهد که کاری را که انجام داده اید لغو کنید. اگر می خواهید آخرین کاری را که انجام داده اید لغو کنید، موارد زیر را تایپ کنید:

>>> t.undo()

این کار آخرین دستوری را که اجرا کرده اید لغو می کند. اگر می خواهید سه دستور آخر خود را لغو کنید، باید t.undo() را سه بار تایپ کنید.

پاک کردن صفحه نمایش

در حال حاضر، احتمالا از زمانی که این آموزش را شروع کرده اید، چیزهای زیادی روی صفحه نمایش خود دارید. برای ایجاد فضا برای موارد بیشتر، فقط دستور زیر را تایپ کنید:

>>> t.clear()

با این کار صفحه نمایش شما تمیز می شود تا بتوانید به نقاشی ادامه دهید. در اینجا توجه داشته باشید که متغیرهای شما تغییر نمی کنند و لاک پشت در همان موقعیت باقی می ماند. اگر لاک پشت های دیگری غیر از لاک پشت اصلی روی صفحه نمایش خود دارید، نقاشی های آنها پاک نمی شود مگر اینکه به طور خاص آنها را در کد خود فراخوانی کنید.

تنظیم مجدد محیط

همچنین می توانید با دستور بازنشانی از یک صفحه تمیز شروع کنید. صفحه نمایش پاک می شود و تنظیمات لاک پشت همگی به پارامترهای پیش فرض خود بازگردانده می شوند. تنها کاری که باید انجام دهید این است که دستور زیر را تایپ کنید:

>>> t.reset()

این صفحه نمایش را پاک می کند و لاک پشت را به موقعیت اصلی خود برمی گرداند. تنظیمات پیش فرض شما، مانند اندازه، شکل، رنگ و سایر ویژگی های لاک پشت نیز بازیابی خواهد شد.

اکنون که اصول برنامه نویسی با کتابخانه لاک پشت پایتون را یاد گرفتید، برخی از ویژگی های جایزه را که ممکن است بخواهید در حین برنامه نویسی از آنها استفاده کنید، بررسی خواهید کرد.

گذاشتن تمبر

شما می توانید مهر لاک پشت خود را روی صفحه بگذارید که چیزی جز اثر لاک پشت نیست. سعی کنید این کد را تایپ کنید تا ببینید چگونه کار می کند:

>>> t.stamp()
8
>>> t.fd(100)
>>> t.stamp()
9
>>> t.fd(100)

خروجی شما به این شکل خواهد بود:

اعدادی که ظاهر می شوند مکان لاک پشت یا شناسه مهر است. حال، اگر می خواهید تمبر خاصی را حذف کنید، فقط از موارد زیر استفاده کنید:

>>> t.clearstamp(8)

با این کار یکی با شناسه مهر 8 پاک می شود.

شبیه سازی لاک پشت شما

گاهی اوقات، ممکن است لازم باشد بیش از یک لاک پشت روی صفحه نمایش خود داشته باشید. نمونه ای از این موضوع را بعدا در پروژه نهایی خواهید دید. در حال حاضر، می توانید لاک پشت دیگری را با شبیه سازی لاک پشت فعلی خود در محیط خود به دست آورید. سعی کنید این کد را اجرا کنید تا یک لاک پشت کلون ایجاد کنید، c، و سپس هر دو لاک پشت را روی صفحه حرکت دهید:

>>> c = t.clone()
>>> t.color("magenta")
>>> c.color("red")
>>> t.circle(100)
>>> c.circle(60)

خروجی به این شکل خواهد بود:

محشره!

اکنون که ایده ای از برخی از دستورات مهم از کتابخانه لاک پشت پایتون دارید، آماده هستید تا به سراغ چند مفهوم دیگر بروید که باید آنها را درک کنید. این مفاهیم در مورد برنامه نویسی به هر زبانی بسیار مورد نیاز هستند.

استفاده از حلقه ها و دستورات شرطی

هنگامی که وارد برنامه نویسی سطح بالاتر می شوید، اغلب از حلقه ها و دستورات شرطی استفاده می کنید. به همین دلیل است که در این بخش، چند برنامه لاک پشت را مرور خواهید کرد که از این نوع دستورات استفاده می کنند. این به شما یک رویکرد عملی برای درک این مفاهیم می دهد. با این حال، قبل از شروع، در اینجا سه تعریف وجود دارد که باید در نظر داشته باشید:

1. حلقه ها مجموعه ای از دستورالعمل ها هستند که به طور مداوم تکرار می شوند تا زمانی که یک شرط خاص برآورده شود.
2. دستورات شرطی کار خاصی را بر اساس شرایطی انجام می دهند که برآورده شده است.
3. تورفتگی ها برای تعریف بلوک های کد استفاده می شوند، به ویژه هنگام استفاده از حلقه ها و دستورات شرطی. به طور کلی، با ضربه زدن روی کلید Tab روی صفحه کلید، یک تورفتگی ایجاد می کنید.

اکنون، بیایید ادامه دهیم و این دستورات را بررسی کنیم!

حلقه های for

آیا برنامه ای را که برای ایجاد مربع استفاده می کردید به خاطر دارید؟ شما باید یک خط کد را چهار بار تکرار می کردید، مانند این:

>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)
>>> t.fd(100)
>>> t.rt(90)

یک راه بسیار کوتاه تر برای انجام این کار با کمک حلقه for است. سعی کنید این کد را اجرا کنید:

>>> for i in range(4):
...     t.fd(100)
...     t.rt(90)

در اینجا، i مانند شمارنده ای است که از صفر شروع می شود و تا 1 افزایش می یابد. وقتی می گویید در محدوده (4) ، به برنامه می گویید که مقدار این i باید کمتر از 4 باشد. قبل از اینکه i به 4 برسد، برنامه را خاتمه می دهد.

در اینجا به تفکیک نحوه عملکرد برنامه آمده است:

1. در i=0 ، لاک پشت 100 واحد به جلو حرکت می کند و سپس 90 درجه به سمت راست می چرخد.
2. در i=0 + 1=1 ، لاک پشت 100 واحد به جلو حرکت می کند و سپس 90 درجه به سمت راست می چرخد.
3. در i=1 + 1=2، لاک پشت 100 واحد به جلو حرکت می کند و سپس 90 درجه به سمت راست می چرخد.
4. در i=2 + 1=3، لاک پشت 100 واحد به جلو حرکت می کند و سپس 90 درجه به سمت راست می چرخد.

سپس لاک پشت از حلقه خارج می شود. برای بررسی مقدار i، i را تایپ کنید و سپس کلید Enter را فشار دهید. مقدار i برابر با 3 را دریافت خواهید کرد:

>>> i
3

توجه داشته باشید که فضای خالی که قبل از خط 2 و خط 3 در برنامه می آید، تورفتگی است. این نشان می دهد که هر 3 خط یک بلوک کد را تشکیل می دهند. برای کسب اطلاعات بیشتر در مورد حلقه های for در پایتون، حلقه های "for" پایتون (تکرار قطعی) را بررسی کنید.

حلقه های while

حلقه while برای انجام یک کار خاص استفاده می شود در حالی که یک شرط هنوز برآورده شده است. اگر شرایط دیگر برآورده نشود، کد شما فرآیند را خاتمه می دهد. با تایپ این کد می توانید از حلقه while برای ایجاد یک سری حلقه استفاده کنید:

>>> n=10
>>> while n <= 40:
...     t.circle(n)
...     n = n+10

وقتی این کد را اجرا می کنید، حلقه هایی را می بینید که یکی پس از دیگری ظاهر می شوند و هر حلقه جدید بزرگتر از حلقه قبلی خواهد بود:

در اینجا، n به عنوان شمارنده استفاده می شود. شما باید مشخص کنید که چقدر می خواهید مقدار n در هر حلقه افزایش یابد. به این راهنمای کوچک نگاهی بیندازید تا ببینید برنامه چگونه کار می کند:

1. در n=10 ، لاک پشت دایره ای با شعاع 10 واحد می کشد. پس از آن، مقدار n 10 افزایش می یابد.
2. در n=20 ، لاک پشت دایره ای با شعاع 20 واحد می کشد. یک بار دیگر، مقدار n 10 افزایش می یابد.
3. در n=30 ، لاک پشت دایره ای با شعاع 30 واحد می کشد. برای سومین بار، مقدار n 10 افزایش می یابد.
4. در n=40 ، لاک پشت دایره ای با شعاع 40 واحد می کشد. برای آخرین بار، مقدار n 10 افزایش می یابد.
5. در n=50 ، n دیگر کمتر یا مساوی 40 نیست. حلقه خاتمه می یابد.

برای مطالعه بیشتر در مورد حلقه های while، حلقه های "while" پایتون (تکرار نامشخص) را بررسی کنید.

دستورات شرطی

شما از دستورات شرطی برای بررسی صحت یک شرط معین استفاده می کنید. اگر اینطور باشد، دستور مربوطه اجرا می شود. سعی کنید در این برنامه تایپ کنید:

>>> u = input("Would you like me to draw a shape? Type yes or no: ")
>>> if u == "yes":
...     t.circle(50)

input() برای به دست آوردن ورودی از کاربر استفاده می شود. در اینجا، پاسخ کاربر را در زیر متغیر u ذخیره می کند. در مرحله بعد، مقدار u را با شرایط ارائه شده مقایسه می کند و بررسی می کند که آیا مقدار u "بله" است یا خیر. اگر "بله" باشد، برنامه شما یک دایره ترسیم می کند. اگر کاربر چیز دیگری را تایپ کند، برنامه هیچ کاری انجام نمی دهد.

هنگامی که یک جمله دیگر را به دستور if اضافه می کنید، می توانید دو نتیجه را بر اساس درست یا نادرست بودن شرط مشخص کنید. بیایید این را در یک برنامه ببینیم:

>>> u = input("Would you like me to draw a shape? Type yes or no: ")
>>> if u == "yes":
...     t.circle(50)
>>> else:
...     print("Okay")

در اینجا، شما به برنامه می گویید که خروجی خاصی را نمایش دهد حتی زمانی که کاربر "بله" نمی گوید. شما از print() برای نمایش برخی از کاراکترهای از پیش تعریف شده روی صفحه استفاده می کنید.

توجه داشته باشید که کاربر نیازی به تایپ "نه" ندارد. آنها می توانند هر چیز دیگری را تایپ کنند، در این صورت، نتیجه همیشه "Okay" خواهد بود، زیرا شما به صراحت به برنامه نمی گویید که کاربر باید "نه" را تایپ کند. با این حال، نگران نباشید، زیرا می توان آن را برطرف کرد. می توانید یک بند elif اضافه کنید تا چندین شرط و خروجی های مربوطه را در اختیار برنامه قرار دهید، همانطور که در اینجا مشاهده می کنید:

>>> u = input("Would you like me to draw a shape? Type yes or no: ")
>>> if u == "yes":
...     t.circle(50)
>>> elif u == "no":
...     print("Okay")
>>> else:
...     print("Invalid Reply")

همانطور که می بینید، این برنامه اکنون بسته به ورودی دریافتی که دریافت می کند، بیش از یک نتیجه دارد. در اینجا نحوه عملکرد این کد آمده است:

• اگر "بله" را تایپ کنید، کد ورودی را پردازش می کند و طبق دستورالعمل های شما یک دایره می کشد.
• اگر "no" را تایپ کنید، کد "Okay" چاپ می شود و برنامه شما خاتمه می یابد.
• اگر چیز دیگری مانند "Hello" یا "Sandwich" را تایپ کنید، کد "Invalid Reply" را چاپ می کند و برنامه شما خاتمه می یابد.

توجه داشته باشید که این برنامه به حروف کوچک و بزرگ حساس است، بنابراین وقتی آن را امتحان می کنید، مطمئن شوید که رشته ها را بر اساس آن با حروف بزرگ یا کوچک قرار دهید.

برای کسب اطلاعات بیشتر در مورد دستورات شرطی، دستورات شرطی در پایتون را بررسی کنید.

پروژه نهایی: مسابقه لاک پشت های پایتون

تا کنون، شما یاد گرفته اید که چگونه محیط لاک پشت خود را سفارشی کنید، لاک پشت خود را طوری برنامه ریزی کنید که در اطراف صفحه حرکت کند، و از حلقه ها و دستورات شرطی برای بهبود کد خود استفاده کنید. اکنون زمان آن رسیده است که مهمترین بخش سفر برنامه نویسی شما را انجام دهید. در این بخش، با ایجاد یک بازی سرگرم کننده که می توانید با دوستان خود بازی کنید، تمام آنچه را که آموخته اید در یک برنامه پیاده سازی خواهید کرد.

قبل از شروع، در اینجا چیزی است که باید در مورد بازی بدانید:

1. هدف: بازیکنی که لاک پشتش ابتدا به خانه خود می رسد برنده بازی می شود.

2. نحوه بازی:

   • هر بازیکن یک تاس می اندازد تا یک عدد به دست آورد.
   • سپس بازیکن لاک پشت خود را با این تعداد قدم حرکت می دهد.
   • بازیکنان به نوبت می چرخند تا زمانی که یکی از آنها برنده شود.

3. ساختار:

   • هر بازیکن یک لاک پشت داشت که با رنگ متفاوتی نشان داده می شد. شما می توانید بیش از دو بازیکن داشته باشید، اما به خاطر این آموزش، یک بازی دو نفره خواهید ساخت.
   • هر لاک پشت یک موقعیت خانگی دارد که باید به آن برسد.
   • هر بازیکن از یک قالب برای انتخاب تصادفی مقداری برای نوبت خود استفاده می کند. در برنامه شما، قالب با لیستی از اعداد 1 تا 6 نشان داده می شود.

اکنون که منطق بازی را درک کرده اید، می توانید ادامه دهید و شروع به ایجاد آن کنید! ابتدا باید محیط را راه اندازی کنید.

راه اندازی محیط بازی

با وارد کردن کتابخانه لاک پشت پایتون شروع کنید. پس از این، کتابخانه تصادفی داخلی را وارد کنید، که از آن استفاده خواهید کرد و به طور تصادفی یک مورد را از یک لیست انتخاب کنید:

>>> import turtle
>>> import random

هنگامی که این کتابخانه ها با موفقیت به محیط شما فراخوانده شدند، می توانید بقیه برنامه خود را ادامه دهید.

راه اندازی لاک پشت ها و خانه ها

اکنون باید دو لاک پشت را ایجاد کنید که نماینده بازیکنان باشند. هر لاک پشت رنگ متفاوتی خواهد داشت که مربوط به بازیکنان مختلف است. در اینجا، بازیکن یک سبز و بازیکن دوم آبی است:

>>> player_one = turtle.Turtle()
>>> player_one.color("green")
>>> player_one.shape("turtle")
>>> player_one.penup()
>>> player_one.goto(-200,100)
>>> player_two = player_one.clone()
>>> player_two.color("blue")
>>> player_two.penup()
>>> player_two.goto(-200,-100)

هنگامی که لاک پشت ها را ایجاد کرده اید، آنها را در موقعیت های اولیه خود قرار می دهید و مطمئن می شوید که این موقعیت ها در یک راستا قرار دارند. توجه داشته باشید که لاک پشت بازیکن دو را با شبیه سازی لاک پشت بازیکن اول، تغییر رنگ آن و قرار دادن آن در نقطه شروع دیگری ایجاد کرده اید.

اکنون باید خانه هایی برای لاک پشت ها ایجاد کنید. این خانه ها به عنوان نقاط پایان برای هر لاک پشت عمل خواهند کرد. خانه های هر یک از لاک پشت ها با یک دایره نشان داده می شود. در اینجا، باید مطمئن شوید که هر دو خانه از نقطه شروع فاصله دارند:

>>> player_one.goto(300,60)
>>> player_one.pendown()
>>> player_one.circle(40)
>>> player_one.penup()
>>> player_one.goto(-200,100)
>>> player_two.goto(300,-140)
>>> player_two.pendown()
>>> player_two.circle(40)
>>> player_two.penup()
>>> player_two.goto(-200,-100)

پس از ترسیم خانه های مربوطه، لاک پشت ها را به موقعیت اولیه خود برمی گردانید:

محشره! جنبه های بصری بازی شما کامل است. اکنون می توانید قالبی را ایجاد کنید که برای انجام بازی استفاده خواهید کرد.

ایجاد قالب

شما می توانید یک قالب مجازی برای بازی خود با یک لیست ایجاد کنید که دنباله ای مرتب از آیتم ها است. در زندگی واقعی، ممکن است لیست های مواد غذایی و لیست کارهایی را تهیه کنید تا به شما کمک کند سازماندهی کنید. در پایتون، لیست ها به روشی مشابه کار می کنند.

در این صورت، از یک لیست برای ایجاد قالب خود استفاده خواهید کرد. ابتدا لیست اعداد خود را به ترتیب صعودی از 1 تا 6 تعریف می کنید. شما می توانید یک لیست را با دادن نام و سپس محصور کردن موارد آن در پرانتز تعریف کنید، مانند این:

>>> die = [1,2,3,4,5,6]

این لیست اکنون به مرگ شما تبدیل شده است. برای انداختن تاس، تنها کاری که باید انجام دهید این است که سیستم خود را طوری برنامه ریزی کنید که به طور تصادفی عددی را از آن انتخاب کند. عددی که انتخاب می شود به عنوان خروجی قالب در نظر گرفته می شود.

توسعه بازی

وقت آن است که کد را برای بقیه بازی توسعه دهید. در اینجا از حلقه ها و دستورات شرطی استفاده خواهید کرد، بنابراین باید مراقب تورفتگی ها و فاصله ها باشید. برای شروع، نگاهی به مراحلی که برنامه شما برای اجرای بازی باید انجام دهد، بیندازید:

1. مرحله 1: شما با گفتن برنامه خود شروع می کنید تا بررسی کنید که آیا لاک پشت ها به خانه خود رسیده اند یا خیر.
2. مرحله 2: اگر این کار را نکرده اند، به برنامه خود می گویید که به بازیکنان اجازه دهید به تلاش خود ادامه دهند.
3. مرحله 3: در هر حلقه، به برنامه خود می گویید که با انتخاب تصادفی یک عدد از لیست، قالب را بچرخاند.
4. مرحله 4: سپس به آن می گویید که لاک پشت مربوطه را بر اساس آن حرکت دهد، با تعداد مراحل بر اساس نتیجه این انتخاب تصادفی.

این برنامه این روند را تکرار می کند و زمانی که یکی از لاک پشت ها به هدف رسید متوقف می شود. در اینجا کد به نظر می رسد:

>>> for i in range(20):
...     if player_one.pos() >= (300,100):
...             print("Player One Wins!")
...             break
...     elif player_two.pos() >= (300,-100):
...             print("Player Two Wins!")
...             break
...     else:
...             player_one_turn = input("Press 'Enter' to roll the die ")
...             die_outcome = random.choice(die)
...             print("The result of the die roll is: ")
...             print(die_outcome)
...             print("The number of steps will be: ")
...             print(20*die_outcome)
...             player_one.fd(20*die_outcome)
...             player_two_turn = input("Press 'Enter' to roll the die ")
...             die_outcome = random.choice(die)
...             print("The result of the die roll is: ")
...             print(die_outcome)
...             print("The number of steps will be: ")
...             print(20*die_outcome)
...             player_two.fd(20*die_outcome)

خروجی نهایی شما کمی شبیه به این خواهد بود:

به طور خلاصه، این کاری است که کد انجام می دهد:

1. خط 1 یک حلقه for را با محدوده 1 تا 20 تنظیم می کند.

2. خطوط 2 تا 7 بررسی می کنند که آیا هر یک از بازیکنان به هدف خود رسیده اند یا خیر. اگر یکی از آنها داشته باشد، برنامه عبارت مربوطه را چاپ می کند و حلقه را می شکند.

3. خط 8 اگر هیچ یک از بازیکنان برنده نشده باشند، برنامه را به مجموعه مراحل بعدی منتقل می کند.

4. خط 9 بیانیه ای را چاپ می کند که از بازیکن اول می خواهد کلید Enter را فشار دهد تا قالب را بچرخاند.

5. خط 10 یک مقدار تصادفی از قالب لیست می گیرد و آن را در die_outcome ذخیره می کند.

6. خط 11 قبل از نمایش نتیجه انداختن تاس، بیانیه ای را چاپ می کند.

7. خط 12 نتیجه تاس را چاپ می کند.

8. خط 14 این مقدار را در 20 ضرب می کند تا تعداد کلی مراحل مورد نیاز برای تکمیل بازی را کاهش دهد.

9. خط 15 لاک پشت بازیکن را با این تعداد مرحله به جلو حرکت می دهد.

10. خطوط 16 تا 22 این مراحل را برای بازیکن دوم تکرار می کنند.

کل حلقه for تکرار می شود تا زمانی که یکی از لاک پشت های بازیکن به موقعیت نهایی برسد.

به یاد داشته باشید، می توانید بازی را هر طور که می خواهید سفارشی کنید، بنابراین ادامه دهید و با آن بازی کنید! می توانید لاک پشت های بیشتری اضافه کنید، رنگ ها را تغییر دهید، سرعت را تغییر دهید یا حتی موانعی برای به چالش کشیدن بازیکنان خود ایجاد کنید. همه چیز به شما به عنوان توسعه دهنده بازی بستگی دارد!

نتیجه

در این آموزش، نحوه برنامه نویسی با کتابخانه لاک پشت پایتون را یاد گرفتید و برخی از مفاهیم برنامه نویسی بسیار مهم را درک کرده اید. شما می دانید که چگونه با مقداردهی اولیه متغیر، حلقه ها، دستورات شرطی، تورفتگی، لیست ها و عملگرها برخورد کنید. این یک شروع عالی برای شماست، به خصوص اگر در زبان برنامه نویسی پایتون تازه کار هستید!

اکنون می توانید:

• راه اندازی کتابخانه لاک پشت پایتون
• لاک پشت خود را به اطراف حرکت دهید
• لاک پشت و محیط آن را سفارشی کنید
• لاک پشت خود را برنامه ریزی کنید
• استفاده از مفاهیم اولیه برنامه نویسی
• یک بازی بسازید که بتوانید با دوستان خود بازی کنید

اکنون آماده هستید تا وارد برنامه نویسی سطح بالاتر پایتون شوید. برای پیشرفت بیشتر در سفر پایتون، آشنایی با پایتون و 11 نکته مبتدی برای یادگیری برنامه نویسی پایتون را بررسی کنید. فقط به یاد داشته باشید که سخت کار کنید و به تمرین ادامه دهید، و در کمترین زمان متوجه خواهید شد که یک متخصص پایتون هستید!