کامپایلر و مفسر چیستند و چه تفاوتی دارند؟ با اجرای یک برنامه در Python و C#، مراحل کامپایل، ساخت فایل اجرایی و اجرای کد را بهصورت عملی یاد بگیرید.
در این مقاله چه چیزی یاد میگیریم؟
در بخش سوم مقاله ششم، با دو برنامه ساده و چند آزمایش واقعی میبینیم کامپایل کردن و اجرا کردن چه تفاوتی دارند. خروجی Python و C# را خودتان بررسی میکنید و میفهمید چرا تغییر کد بدون Build لزوماً نتیجه اجرا را تغییر نمیدهد.
- نقش Compiler، Interpreter و Runtime
- کامپایل Python به Bytecode با
py_compile - ساخت و اجرای پروژه C# با ابزار
dotnet - آزمایش تفاوت Build و Run با
--no-build - ایجاد و اصلاح خطاهای ساختاری در دو زبان
مقدمه: چرا اجرای دو برنامه مشابه با هم فرق دارد؟
حالا یک سؤال جدید داریم:
چرا برای اجرای بعضی برنامهها ابتدا باید آنها را Build کنیم، اما بعضی دیگر را مستقیماً اجرا میکنیم؟
برای پیدا کردن پاسخ، قرار است یک برنامه ساده را با دو زبان Python و C# بنویسیم و مراحل اجرای آنها را مقایسه کنیم.
در پایان مقاله میتوانید:
- تفاوت Compiler و Interpreter را توضیح دهید.
- یک فایل Python را جداگانه کامپایل و اجرا کنید.
- یک پروژه C# بسازید و Build کنید.
- تفاوت Build و Run را با یک آزمایش واقعی مشاهده کنید.
کامپایلر و مفسر دقیقاً چه هستند؟
قبل از شروع آزمایش، فقط دو مفهوم را بشناسیم.
Compiler یا کامپایلر چیست؟
تعریف کامپایلر
کامپایلر نرمافزاری است که کد نوشتهشده در یک زبان برنامهنویسی را به نمایش دیگری تبدیل میکند.
برای مثال، میتواند کد منبع را به کد ماشین یا یک زبان میانی تبدیل کند.
فرض کنید برنامهای نوشتهایم که دو عدد را جمع میکند.
کامپایلر ممکن است کد ما را بررسی و خروجی جدیدی تولید کند که برای مراحل بعدی اجرا مناسب است.
Interpreter یا مفسر چیست؟
مفسر نرمافزاری است که اجرای برنامه را با تفسیر دستورالعملهای آن انجام میدهد.
این دستورالعملها ممکن است مستقیماً از ساختار کد منبع یا از یک نمایش میانی مانند Bytecode دریافت شوند.
نکته مهم
مفسر الزاماً کد را خطبهخط از فایل متنی نمیخواند و اجرا نمیکند.
بعضی محیطهای اجرایی هم از کامپایلر و هم از مفسر استفاده میکنند.
پس بهتر است بهجای اینکه زبانها را به دو گروه کاملاً جدا تقسیم کنیم، مسیر اجرای واقعی آنها را بررسی کنیم.
آزمایش اول: کامپایل و اجرای یک برنامه Python
بیایید همان برنامه ساده جمع دو عدد را بنویسیم.
فایل Python بسازید
Python را از وبسایت رسمی نصب کنید، اگر از قبل نصب نیست.
یک پوشه جدید ایجاد کنید و داخل آن فایلی با نام زیر بسازید:
hello.py
کد زیر را داخل فایل قرار دهید:
print(10 + 5)
حالا ترمینال را در همان پوشه باز کنید و اجرا کنید:
python hello.py
خروجی:
15
دستور متناسب با سیستم شما
در بعضی سیستمها لازم است بهجای python از python3 یا py استفاده کنید. در دستورهای بعدی هم همان نام دستور مناسب سیستم خودتان را به کار ببرید.
تا اینجا همهچیز شبیه مقالههای قبلی است.
اما میخواهیم این بار برنامه را بدون اجرای کد آن، کامپایل کنیم.
کامپایل Python به Bytecode
دستور زیر را اجرا کنید:
python -m py_compile hello.py
اگر خطایی وجود نداشته باشد، این دستور معمولاً چیزی در ترمینال نمایش نمیدهد.
اما اتفاق جالبی افتاده است!
به پوشه پروژه نگاه کنید.
باید پوشهای با نام زیر ایجاد شده باشد:
__pycache__
داخل آن فایلی با پسوند .pyc مشاهده میکنید.
نام دقیق فایل به نسخه و پیادهسازی Python بستگی دارد.
این فایل چیست؟
این فایل حاوی Bytecode تولیدشده برای CPython است.
یعنی Python کد ما را به یک نمایش میانی تبدیل کرده است.
اما هنوز دستور print برنامه را اجرا نکردهایم!
این نکته مهم است:
کامپایل شدن کد الزاماً به معنای اجرا شدن آن نیست.
دستور py_compile کد را کامپایل میکند، درحالیکه اجرای python hello.py برنامه را واقعاً اجرا میکند.
همچنین فایل .pyc همان Machine Code قابلاجرای مستقیم توسط CPU نیست.
نتیجه آزمایش اول
ما در Python هم یک مرحله کامپایل داریم.
پس این تصور که «Python هیچ کامپایلری ندارد و فقط کد را مستقیماً تفسیر میکند» دقیق نیست.
در پیادهسازی CPython، کد به Bytecode تبدیل میشود و سپس ماشین مجازی Python آن را اجرا میکند.
آزمایش دوم: همان برنامه را با C# اجرا کنیم
حالا میخواهیم همان عملیات جمع را با C# انجام دهیم.
برای این تمرین باید .NET SDK روی سیستم شما نصب باشد.
اگر نصب نیست، میتوانید آن را از وبسایت رسمی .NET دریافت کنید.
برای بررسی نصب، ترمینال را باز کرده و بنویسید:
dotnet --version
اگر شماره نسخه نمایش داده شد، ابزار .NET SDK در دسترس است.
ساخت پروژه C#
دستور زیر را اجرا کنید:
dotnet new console -n DevMindsCompilerDemo
این دستور یک پروژه Console جدید برای ما میسازد.
وارد پوشه پروژه شوید:
cd DevMindsCompilerDemo
حالا فایل Program.cs را باز کرده و محتوای آن را با کد زیر جایگزین کنید:
Console.WriteLine(10 + 5);
این برنامه هم مانند نسخه Python فقط دو عدد را جمع و نتیجه را نمایش میدهد.
Build کردن برنامه
در همان پوشه پروژه، دستور زیر را اجرا کنید:
dotnet build
اگر همهچیز درست باشد، پیامی مبنی بر موفقیت Build مشاهده میکنید.
حالا به پوشه زیر در پروژه سر بزنید:
bin/Debug/
داخل آن معمولاً پوشهای با نام نسخه Target Framework مشاهده خواهید کرد.
برای مثال، نام این پوشه میتواند شبیه net10.0 باشد؛ اما نسخه واقعی به SDK و تنظیمات پروژه شما بستگی دارد.
در این مسیر، فایلی با نام زیر وجود دارد:
DevMindsCompilerDemo.dll
این DLL چه چیزی دارد؟
در مسیر متداول اجرای .NET، کامپایلر C# کد منبع را به دستورالعملهای میانی به نام CIL تبدیل میکند.
فایل DLL تولیدشده میتواند شامل این دستورالعملها و اطلاعات دیگری مانند Metadata باشد.
توجه به خروجی Build
DLL الزاماً به معنای کد ماشین Native نیست. خروجی معمول Build در .NET را نباید با برنامهای که کاملاً به دستورالعملهای مخصوص پردازنده تبدیل شده، یکسان بدانیم.
اجرای برنامه
حالا دستور زیر را اجرا کنید:
dotnet run --no-build
خروجی:
15
عبارت --no-build به .NET میگوید پیش از اجرا، دوباره پروژه را Build نکند و از خروجی ساختهشده استفاده کند.
در مدل رایج .NET، محیط اجرا با کمک JIT بخشهای لازم از CIL را به کد Native تبدیل میکند و برنامه اجرا میشود.
پس مسیر سادهشده چنین است:
C# Source Code → C# Compiler → CIL → .NET Runtime / JIT → اجرای برنامه
آزمایش جالبتر: اگر کد را تغییر دهیم ولی Build نکنیم چه میشود؟
این آزمایش یکی از مهمترین قسمتهای مقاله است.
فایل Program.cs را دوباره باز کنید.
عدد ۵ را به ۷ تغییر دهید:
Console.WriteLine(10 + 7);
فایل را ذخیره کنید.
حالا بدون اجرای Build جدید این دستور را وارد کنید:
dotnet run --no-build
چه عددی نمایش داده میشود؟
در وضعیت معمول این آزمایش، هنوز عدد زیر را مشاهده میکنید:
15
چرا ۱۷ نمایش داده نشد؟
زیرا فایل Source Code را تغییر دادهایم، اما خروجی ساختهشده برنامه هنوز بهروزرسانی نشده است.
حالا این دو دستور را اجرا کنید:
dotnet build
dotnet run --no-build
خروجی جدید:
17
این بار Build جدید انجام شده و تغییرات کد وارد خروجی برنامه شدهاند.
چه چیزی یاد گرفتیم؟
Build و Run یک مفهوم نیستند.
Build
خروجی موردنیاز پروژه را میسازد یا بهروزرسانی میکند.
Run
برنامه ساختهشده را اجرا میکند.
البته دستور معمولی dotnet run در شرایط رایج خودش قبل از اجرا Build موردنیاز را انجام میدهد.
ما عمداً از --no-build استفاده کردیم تا این دو مرحله را جداگانه مشاهده کنیم.
مقایسه Python و C#: چه تفاوتی دیدیم؟
حالا بیایید نتیجه دو آزمایش را کنار هم قرار دهیم.
| ویژگی | Python با CPython | C# با .NET |
|---|---|---|
| کد منبع | فایل .py | فایل .cs |
| کامپایل معمول | به Python Bytecode | به CIL |
| خروجی میانی | میتواند در فایل .pyc ذخیره شود | معمولاً داخل Assembly مانند DLL |
| محیط اجرا | CPython | .NET Runtime |
| روش رایج اجرا | اجرای Bytecode توسط ماشین مجازی | تبدیل CIL به Native با JIT |
| دستور نمونه | python hello.py | dotnet run |
این جدول فقط دو مسیر اجرایی رایج را مقایسه میکند.
Python پیادهسازیهای دیگری هم دارد و .NET نیز از روشهای دیگری مانند Native AOT پشتیبانی میکند.
بنابراین نمیتوان گفت یک زبان برنامهنویسی همیشه و در تمام محیطها فقط یک روش اجرا دارد.
نتیجه مهم: Compiler و Interpreter دو روش یا نقش فنی هستند، نه دو برچسب کاملاً انحصاری برای زبانهای برنامهنویسی.
چالش عملی: خودتان خطای کامپایل ایجاد کنید!
حالا نوبت شماست.
خطای Python
کد فایل hello.py را به شکل زیر تغییر دهید:
print(10 + )
سپس دستور زیر را اجرا کنید:
python -m py_compile hello.py
چه اتفاقی میافتد؟
Python خطای SyntaxError گزارش میکند، زیرا کد از نظر ساختاری کامل نیست.
خطا را اصلاح کنید و دوباره کامپایل بگیرید.
خطای C#
فایل Program.cs را تغییر دهید:
Console.WriteLine(10 + );
حالا اجرا کنید:
dotnet build
آیا Build موفق میشود؟
خیر. کامپایلر یک خطای مربوط به ساختار کد گزارش میکند.
خطا را اصلاح کنید و دوباره Build بگیرید.
خودتان تفاوت را توضیح دهید
بدون مراجعه به متن مقاله به این سه سؤال پاسخ دهید:
- آیا Python هم مرحله کامپایل دارد؟
- آیا فایل DLL معمولی تولیدشده توسط .NET الزاماً Machine Code است؟
- چرا بعد از تغییر کد C#، دستور
dotnet run --no-buildممکن است نتیجه قبلی را نمایش دهد؟
اگر توانستید این سه سؤال را پاسخ دهید و آزمایشها را انجام دهید، هدف اصلی مقاله را یاد گرفتهاید.
یک تمرین با هوش مصنوعی
میتوانید این پرامپت را به دستیار AI بدهید:
پرامپت پیشنهادی
«من با Python و C# دو برنامه ساده ساختهام. میخواهم تفاوت Compiler، Interpreter و Runtime را بهتر بفهمم. از من پنج سؤال عملی بپرس و بعد از هر پاسخ، آن را بررسی کن. پاسخ سؤال بعدی را زودتر نمایش نده.»
این روش کمک میکند مفاهیم را بهجای حفظ کردن، واقعاً یاد بگیرید.
جمعبندی: کامپایل کردن و اجرا کردن دو مرحله متفاوتاند
در این مقاله دو آزمایش واقعی انجام دادیم.
در Python با استفاده از py_compile یک فایل Bytecode ساختیم.
در C# با استفاده از dotnet build خروجی پروژه را تولید کردیم و با dotnet run --no-build آن را اجرا کردیم.
همچنین مشاهده کردیم که تغییر Source Code الزاماً به معنای تغییر فوری خروجی Buildشده نیست.
حالا میدانیم:
- Compiler کد را از یک نمایش به نمایش دیگر تبدیل میکند.
- Interpreter دستورالعملهای برنامه را در یک محیط اجرایی تفسیر و اجرا میکند.
- Runtime امکانات و زیرساخت لازم برای اجرای برنامه را فراهم میکند.
- Build و Run لزوماً یک عملیات واحد نیستند.
مهمتر از همه، دیگر نباید زبانهای برنامهنویسی را صرفاً با برچسب «کامپایلری» و «تفسیری» قضاوت کنیم.
روش اجرای واقعی یک برنامه به زبان، پیادهسازی و محیط اجرای آن بستگی دارد.
منابع پیشنهادی
- Python Documentation — py_compile — ساخت فایل Bytecode
- Microsoft Learn — Managed Execution Process — نحوه اجرای برنامههای .NET
- Microsoft Learn — dotnet build — ساخت خروجی پروژه
- Microsoft Learn — dotnet run — اجرای پروژه
در بخش چهارم چه یاد میگیریم؟
حالا که اولین برنامه را نوشتهایم و میدانیم کد چگونه اجرا میشود، به یکی از مهمترین سؤالهای شروع مسیر برنامهنویسی میرسیم:
کدام زبان برنامهنویسی را یاد بگیریم؟ Python، C# یا JavaScript؟
در بخش چهارم، همین مسئله ساده را با چند زبان پیادهسازی و تفاوتهای آنها را بررسی میکنیم تا بتوانید مسیر مناسبتری برای یادگیری انتخاب کنید.
نظرات ۰
تجربه یا سؤال خود را درباره این مقاله با دیگران به اشتراک بگذارید.
هنوز نظری ثبت نشده. اولین نفر باشید!
ثبت نظر جدید
برای ارسال نظر وارد حساب شوید. اکانت ندارید؟ ثبت نام کنید