چیزایی که درباره خط فرمان پایتون باید بدونیم

خط فرمان در پایتون

بازم سلامی دوباره از اینکه دوباره دارین با خیالی راحت مطلبونو می خونید؛ امیدوارم همراه لذت ببرید و همه چی رو از ما یاد بگیرین.

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

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

• خط فرمان چیه؟
• تولد اولین سیستم عامل ها
• خط فرمان در سیستم عامل های یونیکسی
• خط فرمان در پایتون
• خروجی ها در پایتون
• ورودی ها  در پایتون
• ارتباط با خط فرمان سیستمی در پایتون
• نحوه نوشتن یک خط فرمان ساده با پایتون

خط فرمان چیه؟

خیلی زوده بخوایم بگیم خط فرمان چیه؟! نه بهتره با سؤال کارو شروع نکنیم چون اگه قرار باشه با سؤال شروع کنیم یک هویی می‌بینیم مطلب تموم شد نه چون باید از صفر شروع کنیم؛ بریم به گذشته و همانند مطلب پای کیوت از لحظه متولد شدن رایانه ها بگیم اینکه ساختارشون چه شکلی بود؟ چطوری اطلاعاتو نگه داری می کردن توش و ...؟

رایانه ها در گذشته

در گذشته های خیلی دور اما نه چندان دور رایانه ها بسیار بزرگ بودند؛ به طور مثال یک رایانه اندازش کل یک کلاس درسو می‌گرفت و فقط کارش محاسبه بود همین!

این رایانه ها خیلی حجیم بودن و اصلاً شکل خوشگلی هم نداشتن! به قول معروف بی ریخت بودن خوب چطوری اطلاعاتو ذخیره می کردن اوایل؟

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

قضیه باگ چطوری به وجود اومد؟

 در میان این رایانه ها محققان دیدند یکی از رایانه ها چراقاش مشکل داره رفتن و لامپو باز کردند و یک سوسک دیدن! و از اونجا بود که هر مشکلی در دنیای رایانه دیده میشد می‌گفتند سوسک یا همون bug که ما بهش بدون ترجمه می گیم باگ ( مثلاً فلان برنامه باگ داشت و …).

ذخیره سازی آنالوگ کم کم به دیجیتال تبدیل شد

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

بعد از ظهور اولین رایانه ها کم کم توسعه پیدا کردن و انقدر پیشرفت کردن که میشد اون موقع روی نوارهایی مخصوص اطلاعات ۰ و ۱ رو ذخیره کرد و این بود که کم کم جای آنالوگ رو تو اکثر بخش‌ها گرفت.

کار با رایانه های اون زمانا

باید بگم اون موقع اگه می بودید از وضع ناراضی می شدین چرا؟ چون اون موقع‌ها اصلاً سیستم عاملی وجود نداشت و شما باید مثلاً فلان قطعه رو تو قطعه دیگه می گذاشتید تا صفر و یک انتقال پیدا کنند وای عجب چیز وحشتناکی بوده اون زمان؛ این وضعیت سخت و دشوار تا ظهور اولین سیستم عامل ها ادامه داشت.

اساس کار رایانه ها

خوبه قبلش از اینکه به خط فرمان و چیستی اون بپردازیم بدونیم که برنامه نویسی اون موقع‌ها وجود نداشت بلکه توسعه دهندها با ارسال کد صفر و یک برنامه می ساختن؛ از اون موقع تا الان همه رایانه ها از سه چیز اصلی و اساسی پیروی می‌کردند و می کنن:

• ورودی: خوب باید گفت از اون موقع تا الان رایانه ها برای دریافت اطلاعات دستگاه‌های ورودی داشتند از جمله صفحه‌کلید (همون کیبورد خودمون)، موس (به زبان شیرین فارسی موشی)، میکروفن و … ما با این‌ها اطلاعات رو وارد می‌کردیم و سپس این اطلاعات به صورت صفر و یک وارد پردازشگر مرکزی می‌شد (همون CPU که مخفف عبارت Centeral Proccesing Unit ).

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

خوب دونستیم اساس کار کل رایانه های جهان تو همین سه تاست که خیلی هم چیز مهمیه و اگه کسی اینو بلاخره یاد نگیره یا یادنداشته باشه اوضاع خوبی در علم رایانه نداره!

ظهور اولین زبان های برنامه نویسی

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

کم کم سیستم‌ها و رایانه ها به همراه پردازنده ها (همون پردازشگر مرکزی یا CPU) گسترده شدن و توسعه یافتن؛ بعدها این برنامه‌های ساده هم که فقط صفر و یک بودن توسعه پیدا کردن و پلتفرم هایی کوچک رو به اسم مفسر ساختن.

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

روند توسعه زبان اسمبلی

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

زبان اسمبلی AT&T که در آزمایشگاه بل که مال مخترع تلفن (الکساندر گراهابر) بود به سرعت توسعه می یافت و در‌واقع الان هم به عنوان یک زبان اسمبلی استاندارد شناخته میشه و اکثر زبان‌های برنامه نویسی جهان به این زبان کامپایل میشن.

این زبان اسمبلی جای دیگر اسمبلی ها رو گرفت الا یک زبان اسمبلی که خالص ترینشون بود و میشد باهاش همه چی رو از صفر ساخت و تنها زبان اسمبلی بود که فایل اجرایی خالص یا اصطلاحاً Flat Binary تحویل می داد.

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

تولد اولین سیستم عامل ها

خوب اون موقع روند توسعه سیستم عاملا داشت خوب پیش می‌رفت تقریباً داشت عالی پیش می‌رفت؛ اولین سیستم عاملای اون به تقریب میشه گفت در ارتش کشور آمریکا به وجود آمدند اما خیلی ابتدایی بودن یعنی چندتا خط فرمان بیش نبودند که همه الان منقرض شدن؛ محققان بالاخره تونستن اون زمان بیان از این سیستم عاملایی که با اسمبلی نوشته شده بود کپی بگیرن و اونو برای خودشون توسعه بدن؛ ممکنه زیاد اسم آزمایشگاه عزیز بل رو شنیده باشین؟

 باید بدونین این آزمایشگاه مهد علم رایانه بوده و زبان‌های اسمبلی AT&T، زبان برنامه نویسی سی و سیستم عامل یونیکس اونجا توسعه پیدا کردن.

  سیستم عامل یونیکس اون زمان توسط کسانی که زبان سی رو طراحی کرده بودن توسعه پیدا می‌کرد و اونها همراه بهش می افزودند؛ این سیستم عامل یک سری خط فرمان‌های ساده مثل لینوکس های امروزی رو داشته که اساس کل سیستم عامل های اون زمان همین بود.

جایگاه خط فرمان در سیستم عامل ها

اگه یک برنامه نویس آماتور باشین ممکنه اصلاً اسم یونیکسو حتی یک بار هم نشنیده اید ولی اگه راجع سیستم عامل های اون زمان بگن چه شکلی بود حداقل راجع سیستم عامل ام اس داس می دونین.

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

 داس قطعاً امکاناتش کمتر از سیستم عامل یونیکس بود چون اولاً بعد یونیکس ظهور کرد دوماً یونیکس توسط کسانی که زبان سی رو ساخته بودند توسعه پیدا می‌کرد اما داس اینگونه نبود.

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

سیستم عامل هایی که در خانواده داس قرار نمی گیرن بیشتر بر پایه یونیکس ساخته شدن یا شبیه به یونیکس هستن (بهشون میگن شبه یونیکس از جمله لینوکس، مینیکس و …).

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

خط فرمان در سیستم عامل های یونیکسی

حالا دوست دارم در این قسمت بگم خط فرمان‌ها در سیستم عامل های تحت یونیکس چه شکلی اند؟

 خوب پاسخ سؤال خیلی روشنه اولاً در طول زمان سیستم عامل های زیادی بر پایه یونیکس بنا شدند که هر کدومشون هسته مخصوص خودشونو داشتند اما تا حد امکان اون استاندارد های مربوطو رعایت می کردن:

• همشون از یک برنامه جدا از هسته به عنوان خط فرمان استفاده می کردن
• اکثر سیستم عامل های یونیکسی و شبه یونیکسی از برنامه بش Bash برای خط فرمان استفاده می کردن
• خط فرمان مالتی تسک بود یعنی تمام سیستم عامل های یونیکسی بر خلاف داس که فقط تک پروسه ای بود میشد چند تا پروسه خط فرمانی داخل یونیکس ایجاد نمود بدون اینکه تغییری در پروسه های دیگه رخ بده.
• بش نه تنها برنامه خط فرمانی یونیکس شد بلکه یک زبان دستوری هم به همین نام داخلش توسعه داده شد که در‌واقع به راحتی در هر سیستم یونیکسی قابل اجرا بود.

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

بخش های خط فرمان

خوب هر نرم افزاری در رایانه ممکنه از بخش‌هایی ساخته شده باشه و خط فرمانم از این قضیه مستثنا نیست؛ بخش‌های یک خط فرمان در همه سیستم عاملا:

• بخش Prompt Line: خطیه که ممکنه شامل نام هاست، نام حساب کاربری، مسیر پوشه ای خط فرمان و یا درایوی که خط فرمان داخلشه باشه و از آخر تهش از علامت هایی نظیر ”>”، “#”، “$” استفاده میشه.
• بخش ورودی متن فرمان: این بخش ورودی محسوب میشه و با زدن دکمه Enter صفحه‌کلید بالافاصله یک خط فرمان میاد پایین‌تر و در بین دو خط برنامه یا دستور مورد نظر به همون شکلی که فراخونی شده اجرا میشه.
• بخش اجرای برنامه یا خروجی فرمان: وقتی شما دستوری رو وارد می‌کنین ابتدا داده‌ها به یک رشته تبدیل میشه بعد تکه‌تکه میشه و در هسته سیستم عامل (در هسته های میکرو و کوچک البته) یا در برنامه خط فرمان تفسیر میشه سپس توسط بخش اجرایی هسته سیستم عامل به اجرا در میاد و خروجیشو به اشتراک می گذاره.

آرگومان ها چیه دیگه؟

یک مثال ساده می‌زنم مثلاً ما یک دستوری در سیستم عامل یونیکس داریم به اسم ls که کارش لیست کردن فایل‌ها و پوشه های مسیر هست؛ اگه همین عبارت ls رو بدون هیچ پسوندی با فاصله وارد کنیم به ما فقط لیست فایلا و پوشه های مسیری که هستیم رو نشون میده اما اگه بعدش با یک فاصله خالی اسم مسیر رو بنویسیم همون مسیری که نوشتیم رو برامون لیست می کنه به دستور ls میگن کامند یا Command و به مسیری که بعدش نوشتیم می گن آرگومان یا Argument.

به طور مثال دستور ls رو بدون آرگومان وارد می کنیم:

ls

حالا با آرگومان واردش می کنیم:

ls /

 دستور ls در سیستم‌های داسی مثل ام اس داس و ویندوز dir هستش یعنی به جای ls باید نوشت dir برای لیست کردنه فایل‌ها و پوشه ها.

خط فرمان در زبان برنامه نویسی پایتون

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

جهت مشاهده مطالبی بیشتر ما رو در لرنیا بلاگ دنبال کنین.

تصور و نگرش تازه کارها و کسانی که اصلاً نمی خوان پایتون رو ببینند اینهز که پایتون فقط یک زبان ساده خط فرمانی (به قول خودمون کنسولی) هست.

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

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

خوب خروجی ها در پایتون چه شکلیین؟

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

خروجی با تابع print

 خروجی به جرأت می شه گفت مهم‌ترین بخش خط فرمانه که بدون اون اصلاً خط فرمان معنی نداره ولی با وجود ورودی ها معنی دار میشه و همچنین وجود پردازش.

با تابع print به طور معمول میشه خروجی رو نمایش داد؛ اگه دوست دارین متن خروجی رو در کنسول رنگی کنید حتماً از ماژول سبک termcolor استفاده کنین.

مثلاً می‌خواهیم یک خوش آمد گویی نمایش بدیم:

print (“Welcome to Learniaa”)

خروجی مثال بالا:

تابع print همه نوع داده رو پشتیبانی می کنه اما اگر با نوعی شروع بشه کل داده‌های بعدی هم باید بر اساس همین نوع پیش بره:

print (3*98)

خروجی مثال بالا:

به طور مثال ما جز عدد داخل تابع بالا نمی تونیم وارد کنیم مگر اینکه باز به عدد تبدیلش کنیم یا مثال زیر جز نوع رشته نمیشه نوع دیگه ای بهش اضافه کرد مگر اینکه به رشته تبدیل بشه:

print (“Hello World”+str(2*6))

خروجی مثال بالا:

اما یک تکنیک خوب هستش که بدون نیاز به تبدیل واحد میشه باهاش چند نوعو کنار هم گذاشت و نمایش داد:

print (“Your score in Learniaa is”,12*6543/2)

خروجی همین برنامه:

خروجی رنگی با ماژول termcolor

 روش‌های متفاوتی هست که بشه باهاش متن کنسولی رو رنگ کرد اما یکی از بهترین یا بهترین روش رنگ کردنش نصب termcolor هست که با دستور زیر میشه ردیفش کرد:

pip install termcolor

حالا یک مثالی ساده می زنیم:

from termcolor import colored

print (colored (“Welcome to Learniaa”,”red”)

print (colored (“ABCDEF”,”green”))

خروجی مثال بالا:

خوب پس ما خیلی راحت می تونیم متن کنسولی رو رنگ کنیم با یک مثال دیگه حتی میشه چندتا متنو در یک print پشت سرهم رنگ کنیم:

print(colored(“A”,”green”)+colored(“B”,”red”)+colored(“C”,”blue”))

ورودی ها در پایتون

خوب حالا رسیدیم به ورودی ها؛ تو زبان برنامه نویسی پایتون میشه خیلی راحت با تابع input ورودی رو به صورت رشته از کاربر دریافت کرد و اونو تو متغییر یا یک خروجی نمایشش داد.

چندتا مثال خوب

می‌خواهیم نام کاربر رو گرفته و اونو نمایش بدیم:

name = input (“What is your name? “)

print (“Welcome”,name,”to Learniaa”)

خوب حالا می‌خواهیم انواع تبدیل واحد ها رو مثال بزنیم؛ البته قبلش باید بدونیم که نوع ها در زبان برنامه نویسی پایتون چندتاست و چه شکلی میشه باهاش تبدیل واحد کرد:

• نوع int: یک عدد صحیح هستش که برای تبدیل کردن دیگر نوع ها بهش میشه از تابع int استفاده کرد.
• نوع str: رشته‌ها که خاصیت محاسباتی ندارن از str استفاده می کنن و میشه با تابع مخصوص خودش که نامش str هست نوع های دیگه رو بهش تبدیل کرد.
• نوع float: همانند int قابلیت محاسباتی داره ولی اعشاری هست؛ با تابع همنامش میشه داده‌ها رو به نوع اعشاری تبدیل کرد.
• نوع long: بزرگ‌تر از نوع int هست و حافظه بیشتری داره.

خب حالا یک مثالی خوب نمره‌های یک دانش آموزو بگیر سپس با عبارت exit بیا از حلقه تکرار بیرون و نمره کل به علاوه معدل دانش آموزو نشون بده (این مثال به شما کمک می کنه که چطوری یک خط فرمان بسازین):

i = 0

s = 0

while True:

    score = input ("> ")

    if score=='exit': break

    else:

        s+=float(score)

        i+=1

print ("Your score is",s)

print ("Your avg is",s/i)

خروجی مثال بالا:

ارتباط با خط فرمان سیستمی

تو زبان برنامه نویسی پایتون خیلی راحت میشه با خط فرمان سیستمی ارتباط داشت اونم بدون هیچ زحتمی!

تابع system در ماژول os

یکی از متداول ترین روش هاش استفاده از تابع system هستش که مشابهش دقیقاً تو سی پلاس پلاس system نام داره:

import os

os.system (“echo Hello Learniaa”)

خروجی مثال بالا در‌واقع دستور echo رو که مربوط به خط فرمان سیستمی هستش رو اجرا می کنه و آرگومان هاش که Hello Learniaa هستن رو چاپ می کنه.

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

import platform

if platform.system()==”Windows”:

    os.system (“cls”)

else:

    os.system (“clear”)

دستور clear در سیستم‌های یونیکسی کارش پاک کردن صفحه نمایش کنسولی هستش و مشابهش دستور cls در سیستم‌های ویندوزی است.

ارتباط مستقیم با هسته سیستم عامل با تابع call در ماژول subprocess

مثالای قبلی فقط با برنامه بش یا cmd برای اجرای دستورات ارتباط برقرار می‌کردند که گزینه مناسبی به باطن برای توسعه یک برنامه مثل بش یا cmd نبودن.

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

import subprocess as sub

sub.call ([‘echo’,’Hello’,’World’])

خوب خروجی مثال بالا قطعاً هیچ فرقی با مثال زیر نداره از لحاظ نمایشی:

import os

os.system (“echo Hello World”)

اما فرق اصلیش اینه که مثال اولی مستقیم دستور رو به هسته سیستم عامل تحویل میده و سرعتش قطعاً بیشتره ولی مثال پایین میاد اول دستور رو تحویل بش یا cmd میده بعد این دو به هسته سیستم عامل مورد نظر دستورات رو ارسال می کنن که خیلی ممکنه کندتر از subprocess.call به نظر بیاد.

نحوه ساختن یک خط فرمان ساده با پایتون

while True:

    cmd = input (“>”)

    if cmd==”hello”:

        print (“Hello World!”)

    elif cmd==”bye”:

        print (“Bye bye!”)

مثال بالا یک برنامه خط فرمان هستش با دو دستور hello و bye که با زبان برنامه نویسی پایتون نوشته شده.

خوب امیدوارم لذت برده باشید پس دنبال کردن مطالبونو تو لرنیا بلاگ فراموش نکنین.