وقتی شروع به برنامهنویسی با پایتون میکنیم، یکی از اولین چیزهایی که باید بلد باشیم این هست که چطور کد نوشته شده رو اجرا کنیم. در واقع تا زمانی که برنامه اجرا نشه، نمیتونیم ببینیم کدی که نوشتیم درست کار میکنه یا نه. به همین دلیل آشنایی با روش اجرای پایتون در VS Code یکی از پایهایترین مهارتها برای شروع کار با این ویرایشگر محسوب میشه.
به طور کلی وقتی درباره اجرای برنامه پایتون در Visual Studio Code صحبت میکنیم، منظور این هست که فایل پایتون نوشته شده توسط ما به مفسر پایتون داده بشه تا اون کد رو اجرا کنه و نتیجهاش نمایش داده بشه. این نتیجه معمولا به صورت متن داخل ترمینال نمایش داده میشه که بهش خروجی برنامه پایتون در ترمینال گفته میشه.
فرض کنین یه فایل ساده پایتون ساختیم به اسم:
hello.py
داخل این فایل میتونیم یه برنامه خیلی ساده بنویسیم:
hello.py
مشاهده خروجی
1
print("Hello World")
مشاهده بیشتر
حالا وقتی این فایل اجرا میشه، مفسر پایتون این دستور رو میخونه و نتیجه رو نمایش میده:
Hello World
همین فرآیند ساده در واقع پایهی اجرای اسکریپت پایتون محسوب میشه.
در محیط VS Code چند روش مختلف برای اجرای فایل Python در VS Code وجود داره. مثلا میشه برنامه رو با دکمه Run اجرا کرد، یا میشه از ترمینال داخلی استفاده کرد. هر کدوم از این روشها کاربرد خودشون رو دارن و توی ادامه به صورت جداگانه بررسی میشن، اما در این بخش فقط میخوایم درک کلی از اجرای کد پایتون در VS Code داشته باشیم.
وقتی یک فایل پایتون رو اجرا میکنیم، در واقع چند اتفاق پشت صحنه میفته. اول VS Code فایل رو به مفسر Python ارسال میکنه. مفسر هم خط به خط کد رو میخونه و اجرا میکنه. هر جا که دستور چاپ، ورودی یا محاسبه وجود داشته باشه، نتیجه اون در ترمینال نمایش داده میشه. به همین دلیل معمولا بعد از اجرای برنامه، ترمینال VS Code به صورت خودکار باز میشه تا خروجی برنامه رو ببینیم.
برای مثال اگه این برنامه ساده رو اجرا کنیم:
python
مشاهده خروجی
1
name = "Ali"
2
print("Hello", name)
مشاهده بیشتر
خروجی در ترمینال چیزی شبیه این میشه:
Hello Ali
این یعنی اجرای برنامه Python با موفقیت انجام شده.
در ابتدای یادگیری پایتون معمولا از برنامههای خیلی ساده برای تست اجرای برنامه پایتون استفاده میشه. برنامههایی مثل Hello World یا چند دستور ساده چاپ، کمک میکنن مطمئن بشیم محیط برنامهنویسی به درستی تنظیم شده و اجرای برنامهها بدون مشکل انجام میشه.
در ادامه مباحث، مرحله به مرحله با جزئیات بیشتری میبینیم که چطور باید مفسر Python رو در VS Code انتخاب کنیم، چطور با دکمه Run برنامه رو اجرا کنیم، و همینطور چطور فایل پایتون رو از طریق ترمینال داخلی VS Code اجرا کنیم. هر کدوم از این روشها بخشی از فرآیند کامل اجرای برنامه پایتون در این محیط هستن و کمک میکنن راحتتر برنامههای خودمون رو تست و اجرا کنیم.
وقتی درباره اجرای کد پایتون در VS Code صحبت میکنیم، یک نکته مهم وجود داره که خیلی از افراد در ابتدای کار بهش توجه نمیکنن و اون هم انتخاب مفسر پایتون هست. در واقع هر برنامه پایتون برای اجرا شدن باید توسط یک برنامه دیگه به نام Python Interpreter خونده و اجرا بشه. این مفسر همون چیزیه که کدهای نوشته شده رو پردازش میکنه و نتیجه اجرای اونها رو در قالب خروجی برنامه پایتون در ترمینال نمایش میده.
در محیط Visual Studio Code ممکن هست چند نسخه مختلف از پایتون روی سیستم نصب شده باشه. مثلا ممکنه نسخه 3.10 و 3.11 همزمان روی سیستم وجود داشته باشن، یا حتی چند محیط مجازی (Virtual Environment) برای پروژههای مختلف ساخته شده باشه. در چنین شرایطی VS Code باید بدونه که برای اجرای فایل Python در VS Code از کدوم مفسر استفاده کنه.
به همین دلیل یکی از اولین مراحل قبل از اجرای برنامه پایتون در Visual Studio Code این هست که مفسر مناسب رو انتخاب کنیم. اگر مفسر اشتباه انتخاب بشه ممکنه برنامه اجرا نشه یا برخی کتابخانهها در دسترس نباشن. برای مثال ممکنه در یک پروژه کتابخانهای نصب کرده باشیم، اما چون VS Code از یک interpreter دیگه استفاده میکنه، اون کتابخانه پیدا نشه و خطا نمایش داده بشه.
برای انتخاب interpreter پایتون در VS Code معمولا از نوار پایین محیط VS Code استفاده میشه. در این قسمت نسخه پایتونی که در حال حاضر فعال هست نمایش داده میشه. با کلیک روی اون، لیستی از مفسرهای موجود در سیستم نمایش داده میشه و میتونیم یکی از اونها رو انتخاب کنیم.
بعد از انجام این مرحله، VS Code از همون مفسر برای اجرای اسکریپت پایتون استفاده میکنه. یعنی فرقی نمیکنه بعدا برنامه رو با اجرای پایتون با دکمه Run اجرا کنیم یا از اجرای پایتون در ترمینال VS Code استفاده کنیم، در هر دو حالت همون interpreter انتخاب شده برای اجرای برنامه استفاده میشه.
برای مثال فرض کنین یک فایل ساده پایتون داریم:
python
مشاهده خروجی
1
print("Python is running in VS Code")
مشاهده بیشتر
وقتی این فایل اجرا میشه، مفسر انتخاب شده این دستور رو پردازش میکنه و نتیجه اون در ترمینال نمایش داده میشه. در این حالت میتونیم مطمئن بشیم که اجرای برنامه Python با Run و Terminal بر اساس همون مفسری انجام میشه که در VS Code تنظیم کردیم.
یکی از نکات مهم در تنظیم مفسر Python در VS Code این هست که این تنظیم معمولا در سطح پروژه هم قابل اعمال هست. یعنی اگر برای یک پروژه خاص مفسر مشخصی انتخاب کنیم، VS Code در دفعات بعدی هم همون مفسر رو برای اجرای برنامههای همون پروژه استفاده میکنه. این موضوع مخصوصا زمانی مهم میشه که روی چند پروژه مختلف با نسخههای متفاوت پایتون کار میکنیم.
در عمل وقتی محیط VS Code به درستی تنظیم شده باشه و interpreter مناسب انتخاب شده باشه، مراحل بعدی مثل اجرای برنامههای ساده در VS Code، اجرای Hello World یا تست برنامهها خیلی راحتتر انجام میشه.
در بخشهای بعدی به صورت عملی میبینیم که چطور میتونیم برنامهها رو اجرا کنیم، خروجی برنامه رو در ترمینال VS Code مشاهده کنیم و بعد از تغییر کد، برنامه رو دوباره اجرا کنیم تا نتیجه تغییرات رو ببینیم. انتخاب صحیح مفسر در اینجا نقش پایهای داره و باعث میشه کل فرآیند اجرای برنامه پایتون در Visual Studio Code بدون مشکل انجام بشه.
یکی از سادهترین و سریعترین روشهایی که تقریبا همه مبتدیها اول سراغش میرن، استفاده از دکمه Run هست. این دکمه عملا اجرا کردن فایل رو راحتتر میکنه و نیاز نیست هر بار خودمون دستور اجرای برنامه رو توی ترمینال وارد کنیم. به همین خاطر خیلی از افراد برای اجرای برنامه پایتون در Visual Studio Code مخصوصا برنامههای ساده یا تستی، اول از همین روش استفاده میکنن.
دکمه Run معمولا بالای سمت راست پنجره کد دیده میشه. وقتی روی اون کلیک میکنیم، VS Code همون فایلی که الان باز هست رو با استفاده از مفسری که قبلا انتخاب کردیم اجرا میکنه. یعنی این دکمه خودش نمیاد interpreter انتخاب کنه، بلکه فقط از همونی که قبلا تنظیم شده استفاده میکنه. به همین دلیل تنظیم درست انتخاب interpreter پایتون در VS Code همیشه قبل از این مرحله هست.
فرض کنین یه فایل ساده به نام test.py باز کردیم و داخلش این کد رو نوشتیم:
test.py
مشاهده خروجی
1
print("Hello from Run Button")
مشاهده بیشتر
وقتی روی Run کلیک میکنیم، VS Code فایل رو اجرا میکنه و خروجی به صورت خودکار پایین صفحه داخل ترمینال VS Code ظاهر میشه:
Hello from Run Button
به همین ترتیب، هر زمانی که روی Run کلیک کنیم، یعنی داریم اجرای اسکریپت پایتون رو با سادهترین روش ممکن انجام میدیم. نکته مهم اینجاست که این روش برای تستهای سریع، اجرای چند دستور ساده پایتون و حتی اجرای یک برنامه خیلی کوچک کاملا مناسب و راحت هست.
یکی از ویژگیهای خوب Run اینه که وقتی کد رو تغییر میدیم، خیلی راحت میتونیم دوباره روی دکمه کلیک کنیم تا اجرای کد پایتون بعد از ویرایش انجام بشه و نتیجه جدید رو ببینیم. مثلا اگر برنامه رو به شکل زیر تغییر بدیم:
python
مشاهده خروجی
1
name = "Sara"
2
print("Hello", name)
مشاهده بیشتر
کافیه یک بار دیگه دکمه Run رو بزنیم و خروجی جدید رو بلافاصله توی ترمینال ببینیم. این فرآیند کمک میکنه مرحله به مرحله کد رو تست کنیم و از درست کار کردن اون مطمئن بشیم.
در واقع Run بیشتر برای جاهایی مناسب هست که بخوایم بدون هیچ تنظیم و دستور اضافی برنامه رو اجرا کنیم. مخصوصا وقتی داریم روی برنامههای مقدماتی کار میکنیم، مثل اجرای Hello World پایتون در VS Code یا مثلا وقتی میخوایم فقط مطمئن بشیم محیط VS Code درست تنظیم شده و برنامه اجرا میشه. این روش باعث میشه کاربر بدون درگیر شدن با دستورات ترمینال، فقط با یک کلیک به مرحله تست اجرای برنامه پایتون برسه.
نکته دیگه اینه که دکمه Run بهصورت خودکار یک Terminal مخصوص اجرا ایجاد میکنه که فقط وظیفه نمایش خروجی برنامه پایتون در ترمینال رو داره. بنابراین نیازی نیست خودمون ترمینال جدید باز کنیم یا دستور بزنیم. همین موضوع باعث میشه روش اجرای پایتون با Run سریعتر و سادهتر از روشهای دیگه باشه.
در بخشهای بعدی که به اجرای فایل Python از طریق ترمینال داخلی VS Code و تفاوت اجرای کد پایتون با Run و Terminal میرسیم، دقیقتر میبینیم که این روش چه تفاوتهایی با اجرای دستی برنامه داره. اما در همین حد بدونیم که Run مناسب کارهای سریع و تستی هست و برای آشنایی اولیه با روش اجرای پایتون در VS Code گزینه خیلی خوبی محسوب میشه.
در نهایت، استفاده از Run باعث میشه تسلط به اجرای فایلها در VS Code راحتتر شکل بگیره و قبل از رفتن سراغ موضوعاتی مثل اجرای پایتون در ترمینال، یا تست چند برنامه ساده، ذهنمون با فرآیند اجرای خودکار برنامهها آشنا بشه.
یکی از روشهای مهم برای اجرای کد پایتون در VS Code استفاده از ترمینال داخلی این ویرایشگر هست. در این روش به جای استفاده از دکمه Run، خودمون دستور اجرای برنامه رو داخل ترمینال وارد میکنیم. این کار کمک میکنه درک بهتری از نحوه اجرای واقعی برنامههای پایتون داشته باشیم، چون دقیقا همون کاری انجام میشه که در محیطهای خط فرمان هم اتفاق میفته.
VS Code یک ترمینال داخلی داره که بدون خروج از محیط ویرایشگر میتونیم از اون استفاده کنیم. این ترمینال در واقع همون محیط Command Line سیستم هست که داخل VS Code نمایش داده میشه و میتونیم با اون اجرای اسکریپت پایتون یا حتی اجرای دستورات دیگه رو انجام بدیم.
برای اجرای فایل پایتون از طریق ترمینال داخلی VS Code ابتدا باید ترمینال رو باز کنیم. این کار معمولا از منوی Terminal یا با میانبر صفحهکلید انجام میشه. بعد از باز شدن ترمینال، باید مطمئن بشیم که داخل پوشهای هستیم که فایل پایتون ما داخلش قرار داره.
فرض کنین فایلی به نام hello.py داریم. داخل این فایل یک برنامه ساده نوشتیم:
hello.py
مشاهده خروجی
1
print("Hello World from Terminal")
مشاهده بیشتر
حالا برای اجرای پایتون در ترمینال VS Code کافیه دستور زیر رو وارد کنیم:
python hello.py
یا در بعضی سیستمها ممکنه از یکی از دستورات زیر استفاده بشه:
python3 hello.py
py hello.py
بعد از اجرای این دستور، مفسر پایتون فایل رو اجرا میکنه و نتیجه در همون ترمینال نمایش داده میشه. این همون جایی هست که خروجی برنامه پایتون در ترمینال قابل مشاهدهست:
Hello World from Terminal
به این ترتیب، بدون استفاده از دکمه Run تونستیم اجرای فایل Python در VS Code رو به صورت مستقیم انجام بدیم.
یکی از مزیتهای این روش این هست که کنترل بیشتری روی فرآیند اجرا داریم. برای مثال اگر بخوایم پارامترهایی به برنامه بدیم، مسیر فایلها رو مشخص کنیم یا چند اسکریپت رو پشت سر هم اجرا کنیم، ترمینال گزینه بسیار منعطفتری نسبت به اجرای خودکار با Run محسوب میشه. به همین دلیل بسیاری از برنامهنویسان حرفهای ترجیح میدن برای اجرای برنامه پایتون در Visual Studio Code بیشتر از ترمینال استفاده کنن.
نکته جالب اینه که چه از اجرای برنامه Python با Run و Terminal استفاده کنیم و چه از ترمینال، در نهایت هر دو روش یک کار انجام میدن: یعنی فایل پایتون رو به مفسر ارسال میکنن تا اجرا بشه. تنها تفاوت در نحوه شروع اجرای برنامهست.
وقتی از ترمینال استفاده میکنیم، فرآیند اجرا شفافتر دیده میشه و بهتر متوجه میشیم که روش اجرای پایتون در VS Code در پشت صحنه چطور کار میکنه. همین موضوع باعث میشه درک بهتری از اجرای برنامهها داشته باشیم، مخصوصا وقتی بعدها بخوایم پروژههای بزرگتر رو اجرا یا مدیریت کنیم.
در ادامه مباحث، تفاوت بین اجرای کد پایتون با Run و Terminal در Visual Studio Code رو دقیقتر بررسی میکنیم تا مشخص بشه هر کدوم در چه شرایطی کاربرد بیشتری دارن و کدوم روش برای سناریوهای مختلف مناسبتر هست.
برای اجرای کد پایتون در برنامه visual studio code عملا دو روش اصلی داریم: اجرای پایتون با دکمه Run و اجرای پایتون در ترمینال VS Code. در نگاه اول ممکنه اینطور به نظر برسه که این دو روش کاملا متفاوت هستن، اما در واقع از نظر فنی هر دو یک کار انجام میدن و اون هم اجرای فایل Python در VS Code با استفاده از مفسر انتخابشده هست.
چه از Run استفاده کنیم چه از ترمینال، در نهایت فایل ما به همون مفسری ارسال میشه که در مرحله انتخاب interpreter پایتون در VS Code مشخص کردیم. یعنی تنظیم مفسر Python در VS Code پایه و اساس هر دو روش هست و بدون اون، اجرای برنامه پایتون در Visual Studio Code درست انجام نمیشه.
تفاوت اصلی در «کنترل» و «شفافیت فرآیند اجرا» هست. وقتی از Run استفاده میکنیم، VS Code خودش به صورت خودکار فایل باز شده رو اجرا میکنه و خروجی برنامه پایتون در ترمینال نمایش داده میشه، بدون اینکه ما دستور خاصی وارد کنیم. این روش برای اجرای برنامههای ساده در VS Code، مخصوصا زمانی که در حال تست اجرای برنامه پایتون هستیم، سریع و کاربردی هست. مثلا برای اجرای Hello World پایتون در VS Code یا اجرای چند دستور ساده پایتون برای بررسی درست بودن محیط، Run کاملا کافی هست.
فرض کنین این کد رو داریم:
script.py
مشاهده خروجی
1
print("Run Mode")
مشاهده بیشتر
با یک کلیک روی Run، برنامه اجرا میشه و خروجی در ترمینال ظاهر میشه. همه چیز سریع و بدون درگیری با جزئیات انجام میشه.
اما در روش اجرای فایل پایتون از طریق ترمینال داخلی VS Code ، خودمون دستور اجرا رو وارد میکنیم:
python script.py
اینجا ما دقیقا میبینیم چه دستوری اجرا میشه، از چه مسیر فایل خونده میشه و حتی میتونیم آرگومان به برنامه بدیم:
python script.py test
این سطح از کنترل باعث میشه ترمینال برای پروژههای جدیتر یا وقتی که میخوایم رفتار برنامه رو دقیقتر بررسی کنیم مناسبتر باشه. مخصوصا وقتی بحث اجرای اسکریپت پایتون با ورودیهای مختلف یا اجرای پشت سر هم چند فایل مطرح باشه.
از نظر اجرای کد پایتون بعد از ویرایش هم هر دو روش مشابه هستن. چه Run رو بزنیم چه دوباره دستور python رو وارد کنیم، در هر دو حالت اجرای دوباره فایل پایتون بعد از تغییر کد در VS Code انجام میشه. تفاوت فقط در اینه که در Run این کار با کلیک انجام میشه و در ترمینال با تکرار دستور.
یک تفاوت مهم دیگه در درک عمیقتر روش اجرای پایتون در VS Code هست. وقتی از ترمینال استفاده میکنیم، بهتر متوجه میشیم که پشت صحنه اجرای برنامه Python با Run و Terminal چه اتفاقی میفته. این موضوع برای کسانی که میخوان از سطح آموزش اجرای کد پایتون در VS Code برای مبتدیها عبور کنن و وارد فضای حرفهایتر بشن اهمیت داره.
در واقع میشه اینطور جمعبندی کرد که Run بیشتر برای سرعت و راحتی طراحی شده و ترمینال برای انعطاف و کنترل بیشتر. اگر فقط میخوایم بدونیم چگونه فایل پایتون را در Visual Studio Code اجرا کنیم و سریع نتیجه رو ببینیم، Run گزینه خوبی هست. اما اگر بخوایم حرفهایتر کار کنیم، آرگومان بدیم، چند اسکریپت رو مدیریت کنیم یا ساختار پروژه رو بهتر بفهمیم، اجرای پایتون در ترمینال VS Code انتخاب منطقیتری هست.
در نهایت این دو روش رقیب هم نیستن، بلکه مکمل هم هستن. کسی که نحوه انتخاب مفسر Python در VS Code برای اجرای برنامهها رو بلد باشه و هر دو روش اجرا رو تمرین کرده باشه، هم در روش تست صحیح اجرا شدن اولین برنامه پایتون در VS Code مسلط میشه و هم برای پروژههای بزرگتر آمادگی بیشتری خواهد داشت.
یکی از پایهایترین چیزهایی که باید باهاش آشنا بشیم اینه که خروجی برنامه دقیقا کجا نمایش داده میشه. چه از دکمه Run استفاده کنیم و چه برنامه رو از طریق ترمینال اجرا کنیم، در نهایت VS Code همه پیامها، نتایج چاپشده و خطاهای برنامه رو داخل همون ترمینال داخلی خودش نشون میزه. این بخش مثل یک پنجره اجرای زنده هست که تمام رفتارهای برنامه رو برامون نمایش میده.
مثلا وقتی یک فایل Python رو داخل VS Code اجرا میکنیم و چنین کدی داریم:
python
مشاهده خروجی
1
print("Hello from VS Code Terminal")
مشاهده بیشتر
بعد از اجرا (چه Run باشه چه دستور python داخل ترمینال)، خروجی به شکل مستقیم در بخش Terminal ظاهر میشه:
Hello from VS Code Terminal
این سادهترین حالت خروجی برنامه پایتون در ترمینال VS Code هست و چون بخش Terminal همیشه پایین محیط ویرایشگر قرار داره، میشه حین اجرای برنامه خیلی راحت اتفاقات داخل برنامه رو بررسی کرد.
نکته مهم اینه که در هر دو روش اجرای برنامه Python با Run و Terminal، نمایش خروجی کاملا مشابه انجام میشه. یعنی VS Code فرقی نمیذاره که شما از Run استفاده کردین یا دستور python script.py رو نوشتین؛ در هر دو حالت، نتیجه اجرا، خطاها، چاپها و هر نوع پیام دیگری داخل همون پنجره ترمینال دیده میشه. این موضوع باعث میشه زمان تست اجرای برنامه پایتون یا حتی اجرای چند دستور ساده پایتون در مراحل اولیه یادگیری، تجربه کاربری یکسانی داشته باشیم.
اگر قبلا انتخاب interpreter پایتون در VS Code درست انجام شده باشه، ترمینال دقیقا همون نسخه پایتون رو اجرا میکنه که انتخابش کردین. مثلا اگر یک بار با پایتون نسخه 3.10 کدی رو اجرا کنین و بار دیگر نسخه 3.12 انتخاب بشه، خروجی ممکنه متفاوت باشه و این تفاوت در ترمینال کاملا مشخص میشه. این موضوع در پروژههایی که به نسخه خاصی از پایتون تکیه دارن اهمیت بیشتری پیدا میکنه.
برای اینکه ارتباط بین ویرایش کد و نمایش نتیجه رو بهتر حس کنیم، تصور کنین که برنامه به شکل زیر تغییر پیدا کنه:
python
مشاهده خروجی
1
name = "Sara"
2
print("Hello", name)
مشاهده بیشتر
بعد از تغییر کد، اگر دوباره Run رو کلیک کنیم یا دستور اجرای اسکریپت پایتون رو در ترمینال وارد کنیم، ترمینال بلافاصله خروجی جدید رو نشون میزه:
Hello Sara
این یعنی اجرای کد پایتون بعد از ویرایش به شکلی کاملا واضح و لحظهای در ترمینال قابل مشاهده هست و همین باعث میشه فهمیدن رفتار واقعی برنامه خیلی راحتتر بشه.
ترمینال VS Code فقط برای نمایش خروجی نیست؛ وقتی بخوایم چند برنامه ساده رو پشت سر هم اجرا کنیم یا بخوایم رفتار برنامهها رو با ورودیهای مختلف تست کنیم، داشتن یک خروجی تمیز و متمرکز خیلی کمک میکنه. مثلا برای تمرین اجرای چند برنامه ساده Python در Visual Studio Code میتونیم چند فایل مختلف رو اجرا کنیم و خروجی هر کدوم رو در ترمینال ببینیم، بدون اینکه نیاز باشه پنجره دیگهای باز کنیم.
در نهایت، ترمینال VS Code مثل یک داشبورد اجرای زنده عمل میکنه. هر چیزی که مربوط به اجرای برنامه پایتون باشه—از چاپهای ساده مثل اجرای Hello World گرفته تا بررسی خطاها و خروجیهای پیشرفتهتر—در همین قسمت دیده میشه. همین موضوع باعث میشه دیدن و فهمیدن رفتار برنامه در تمام مراحل از جمله تست صحیح اجرا شدن اولین برنامه پایتون و اجرای برنامههای ساده در VS Code کاملا شفاف و قابل پیگیری باشه.
وقتی محیط VS Code رو برای اجرای برنامه پایتون آماده میکنیم و مراحل مربوط به انتخاب interpreter پایتون در VS Code و نصب افزونهها رو انجام میدیم، یکی از سادهترین و مطمئنترین روشها برای اینکه مطمئن بشیم همهچیز درست کار میکنه اینه که چند تا دستور ساده پایتون رو اجرا کنیم. این کار مثل یه تست سریع هست که بهمون نشون میده که آیا اجرای کد پایتون در VS Code بدون مشکل انجام میشه یا نه. این مرحله معمولا قبل از اینکه وارد پروژههای جدیتر بشیم یا بخوایم اجرای فایل Python در VS Code رو به شکل کامل شروع کنیم، انجام میشه.
برای این تست، لازم نیست کد پیچیدهای بنویسیم. یک فایل پایتون جدید میسازیم مثلا test.py و چند دستور خیلی ساده داخلش قرار میدیم، مثل:
test.py
مشاهده خروجی
1
print("Test OK")
2
x = 10
3
y = 3
4
print("Sum:", x + y)
مشاهده بیشتر
این دستورات نه پیچیدهان نه به چیزی وابسته هستن، و دقیقا برای همین مناسب تست اجرای برنامه پایتون هستن. وقتی این فایل رو اجرا میکنیم، چه با اجرای پایتون با دکمه Run و چه از طریق اجرای پایتون در ترمینال VS Code، بلافاصله در خروجی ترمینال میفهمیم آیا همهچیز درست تنظیم شده یا نه. اگر خروجی برنامه پایتون در ترمینال بدون خطا نمایش داده بشه، یعنی تنظیم مفسر Python در VS Code درست انجام شده و میتونیم با خیال راحت ادامه بدیم.
خروجی هم معمولا چیزی شبیه اینه:
Test OK
Sum: 13
این تست ساده کمک میکنه مطمئن بشیم که VS Code فایل رو درست اجرا میکنه، مفسر انتخابشده بدون مشکل فعاله و تعامل بین ادیتور و پایتون روی سیستم به درستی برقرار شده. این مرحله جزء قدمهای اصلی در آموزش اجرای کد پایتون در VS Code برای مبتدیها محسوب میشه، ولی حتی کاربران حرفهای هم وقتی یه محیط جدید تنظیم میکنن از همین روش استفاده میکنن تا قبل از شروع کار اصلی، صحت عملکرد محیط رو بررسی کنن.
موقع اجرای این دستورات ساده، فرقی نداره از روش Run استفاده کنیم یا ترمینال؛ هر دو روش نتیجه رو در همون بخش ترمینال نشون میدن. تفاوت فقط در نحوه اجراست، نه در نوع خروجی. مثلا اگر بخوایم همین فایل رو با ترمینال اجرا کنیم، کافی هست دستور زیر رو بزنیم:
python test.py
این روش مخصوصا زمانی خوبه که بخوایم از نظر مسیر پروژه یا نسخه پایتون مطمئنتر عمل کنیم، چون اجرای اسکریپت پایتون از طریق ترمینال کنترل بیشتری بهمون میده.
اجرای این دستورات ساده به درد زمانی هم میخوره که بخوایم مطمئن بشیم اجرای کد پایتون بعد از ویرایش درست انجام میشه. مثلا اگر عددها رو عوض کنیم:
x = 20
y = 5
و فایل رو ذخیره کنیم و دوباره اجرا کنیم، اگر خروجی جدید:
Sum: 25
به درستی نمایش داده بشه، یعنی VS Code فایل رو درست ذخیره کرده، نسخه درست رو اجرا کرده و نتیجه اجرا هم بهدرستی در ترمینال نمایش داده شده. این بخش همون چیزی هست که در روش تست صحیح اجرا شدن اولین برنامه پایتون در VS Code اهمیت پیدا میکنه.
بهطور کلی، اجرای چند دستور ساده مثل همین مثالها باعث میشه هم بفهمیم برنامه اجرا میشه، هم رفتار ترمینال رو بهتر بشناسیم، هم با روش اجرای پایتون در VS Code بیشتر آشنا بشیم. در نهایت، این مرحله یک جور تمرین مقدماتی برای اجرای برنامههای ساده در VS Code هست و کمک میکنه بعدا وقتی وارد پروژههای پیچیدهتر شدیم، کمتر با خطاهای اولیه یا ایرادهای تنظیمات روبهرو بشیم.
وقتی داریم روی یک فایل Python کار میکنیم، طبیعی هست که بارها کد رو تغییر بدیم، یک بخشش رو اصلاح کنیم یا بخوایم رفتار برنامه رو بهتر بفهمیم. برای همین، اجرای مجدد برنامه پایتون بعد از تغییر کد یکی از رایجترین کارهایی هست که موقع اجرای کد پایتون در VS Code انجام میدیم. تفاوتش با اجرای اولیه برنامه اینه که اینبار میخوایم مطمئن بشیم خروجی جدید دقیقا مطابق تغییری هست که اعمال کردیم. VS Code هم این موضوع رو خیلی راحت و بیدردسر برای ما انجام میده.
اگر برنامه رو با اجرای پایتون با دکمه Run اجرا کنیم، بعد از هر تغییری فقط کافی هست که اول فایل رو ذخیره کنیم و دکمه Run رو دوباره بزنیم تا فایل با مفسری که قبلا انتخاب کردیم اجرا بشه. اینجا همون نقش انتخاب interpreter پایتون در VS Code اهمیت پیدا میکنه، چون نسخه صحیح پایتون باید دوباره فایل رو اجرا کنه. مثلا اگر در اولین اجرا این کد رو داشتیم:
script.py
مشاهده خروجی
1
print("Hello World")
مشاهده بیشتر
و بعد بخوایم متن چاپشده رو تغییر بدیم:
script.py
مشاهده خروجی
1
print("Hello VS Code!")
مشاهده بیشتر
فقط کافی هست فایل رو ذخیره کنیم و Run رو دوباره کلیک کنیم تا خروجی جدید در ترمینال VS Code ظاهر بشه. این رفتار ساده باعث میشه روند تست و اصلاح برنامه سریع انجام بشه و هر بار لازم نباشه کار پیچیدهای بکنیم.
اگر اجرای برنامه رو از طریق اجرای پایتون در ترمینال VS Code انجام داده باشیم، فرآیند باز هم همینقدر ساده هست. فایل رو ذخیره میکنیم و دستور قبلی رو دوباره وارد میکنیم:
python script.py
این کار باعث میشه نسخه بهروز شده فایل اجرا بشه و تکرار اجرای اسکریپت پایتون دقیقا همون چیزی رو نشون بده که بعد از ویرایش انتظار داریم. روش ترمینال بیشتر برای زمانی خوبه که بخوایم دقیقتر کنترل کنیم کد از کجا اجرا میشه، یا بخوایم مسیرها و ورودیها رو مدیریت کنیم.
یکی از نکات مهم این بخش اینه که VS Code همیشه نسخه ذخیرهشده فایل رو اجرا میکنه. یعنی اگر بعد از تغییر کد فایل رو ذخیره نکنیم، ممکنه خروجی قدیمی نمایش داده بشه. برای همین برای اجرای کد پایتون در VS Code همیشه تاکید میشه که بعد از هر تغییر، فایل رو ذخیره کنین و بعد اجرا رو تکرار کنین.
برای اینکه موضوع واضحتر بشه، تصور کنین این کد رو داریم:
python
مشاهده خروجی
1
number = 5
2
print(number * 2)
مشاهده بیشتر
بعد از اجرا، خروجی ترمینال چیزی شبیه خروجی زیر خواهد بود.:
10
حالا اگر مقدار number رو تغییر بدیم:
number = 8
و دوباره اجرا کنیم، خروجی میشه:
16
این تفاوت خروجی دقیقا نشون میده که VS Code نسخه جدید فایل رو اجرا کرده و اجرای کد پایتون بعد از ویرایش درست انجام شده. همین رفتار پایهای هست که باعث میشه در تمرین اجرای چند برنامه ساده Python در Visual Studio Code، خطاهای اولیه کمتر و روند یادگیری روانتر باشه.
در مجموع، اجرای دوباره فایل پایتون بعد از تغییر کد در VS Code هیچ تفاوت تکنیکی با اجرای اولیه نداره، اما اهمیتش در اینه که بفهمیم تعامل بین ویرایشگر، مفسر و ترمینال درست کار میکنه.
در مجموع، یادگیری اجرای کد پایتون در VS Code در چند مرحله ساده ولی مهم انجام میشه و هر کدوم از بخشهایی که بررسی کردیم در واقع یک حلقه از یک زنجیره کامل هست. وقتی این مراحل پشت سر هم انجام بشن، به شکل کامل یاد میگیریم چگونه فایل پایتون را در Visual Studio Code اجرا کنیم و خروجی برنامه رو به درستی بررسی کنیم.
در ابتدا با مفهوم کلی اجرای برنامه پایتون در Visual Studio Code آشنا شدیم و دیدیم که VS Code فقط یک ویرایشگر نیست، بلکه میتونه محیط مناسبی برای نوشتن، اجرا و بررسی اسکریپتهای پایتون باشه. بعد از اون مرحله مهم تنظیم مفسر Python در VS Code و انتخاب interpreter پایتون در VS Code مطرح شد، چون بدون انتخاب مفسر مناسب عملا امکان اجرای اسکریپت پایتون وجود نداره.
در ادامه دو روش اصلی برای اجرا بررسی شد. روش اول اجرای پایتون با دکمه Run بود که سریعترین راه برای اجرای یک فایل هست و بیشتر برای زمانی استفاده میشه که میخوایم برنامه رو سریع تست کنیم. روش دوم هم اجرای پایتون در ترمینال VS Code یا همون اجرای فایل پایتون از طریق ترمینال داخلی VS Code مرحله به مرحله بود که در اون دستور اجرای فایل مثل python filename.py مستقیما در ترمینال نوشته میشه.
بعد از اون درباره تفاوت اجرای کد پایتون با Run و Terminal در Visual Studio Code صحبت کردیم. در عمل هر دو روش برنامه رو اجرا میکنن، اما تفاوت اصلی در نحوه کنترل اجرای برنامه و میزان دسترسی به محیط ترمینال هست.
وقتی برنامه اجرا میشه، نتیجه در خروجی برنامه پایتون در ترمینال نمایش داده میشه. در واقع ترمینال داخلی VS Code جایی هست که میتونیم نتیجه اجرای کد، پیامهای چاپ شده و حتی خطاهای احتمالی رو ببینیم. همین موضوع باعث میشه نحوه مشاهده خروجی برنامه پایتون در ترمینال VS Code یکی از مهارتهای پایه در کار با این محیط باشه.
برای اینکه مطمئن بشیم محیط به درستی کار میکنه، چند مثال ساده برای اجرای چند دستور ساده پایتون اجرا کردیم. این کار نوعی تست اجرای برنامه پایتون محسوب میشه و کمک میکنه بفهمیم ارتباط بین ویرایشگر، مفسر و ترمینال به درستی برقرار شده.
در مرحله بعد دیدیم وقتی کد تغییر میکنه، باید برنامه دوباره اجرا بشه تا نتیجه جدید دیده بشه. این همون اجرای دوباره فایل پایتون بعد از تغییر کد در VS Code یا به طور سادهتر اجرای کد پایتون بعد از ویرایش هست که در روند واقعی برنامهنویسی خیلی زیاد اتفاق میفته.
در نهایت با چند مثال عملی وارد مرحله اجرای برنامههای ساده در VS Code شدیم. این تمرینها که شامل اجرای Hello World پایتون در VS Code، چاپ متغیرها یا انجام محاسبات ساده هستن، کمک میکنن مهارت اجرای اسکریپت پایتون در محیط VS Code کاملا تثبیت بشه.
به طور خلاصه، وقتی این مراحل پشت سر هم انجام بشن، کاربر نهتنها با روش اجرای پایتون در VS Code آشنا میشه، بلکه میتونه با اطمینان برنامههای خودش رو اجرا کنه، خروجیها رو بررسی کنه و بعد از هر تغییر در کد دوباره برنامه رو اجرا کنه. همین مهارت پایه، در ادامه مسیر یادگیری پایتون و کار با پروژههای واقعی نقش خیلی مهمی داره.