آموزش پایتون به زبان ساده قسمت نهم

آموزش کار با زبان برنامه‌نویسی پایتون (بخش نهم)

آموزش پایتون به زبان ساده

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

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

در این قسمت قصد داریم به بررسی Pygame بپردازیم. درواقع Pygame مجموعه‌ای از ماجول‌ها است که با هدف ساده‌سازی روند توسعه بازی‌های ساده طراحی‌شده‌اند. این ماجول‌ها از سایت PyGame قابل دریافت هستند. به گفته توسعه‌دهندگان این مجموعه: «Pygame کتابخانه‌ای مستقل از پلتفرم است که برای ساده‌سازی توسعه نرم‌افزارهای مالتی‌مدیا نظیر، بازی‌ها، توسط زبان پایتون طراحی شده است. Pygame برای اجرا به زبان برنامه‌نویسی پایتون و کتابخانه مالتی‌مدیای SDL نیاز دارد.» برای نصب Pygame روی اوبونتو به سادگی می‌توانید با مراجعه به Synaptic بسته نرم‌افزاری آن را با نام python-pygame دانلود کنید یا در ترمینال دستور زیر را وارد کنید:

sudo apt-get install python-pygame

صفحه بازی

برای شروع کار، فهرست ۱ را در ویرایشگر متن دلخواهتان وارد کنید و با نام game1.py آن را ذخیره کنید. در خط ۳ این برنامه ما Pygame را import می‌کنیم تا توابع و مقادیر آن را در اختیار داشته باشیم. پس از آن و در خط ۵ ماجول os را وارد می‌کنیم. هدف اصلی از به‌کار بردن ماجول os در خط ۶ مشخص می‌شود. جایی که ما با مقداردهی یکی از مقادیر متغیر environment از ماجول os (که از جنس لیست است) تعیین می‌کنیم پنجره مربوط به برنامه بازی ما درست در وسط صفحه نمایش باز شود. پس از آن در خط ۸ کد Pygame را راه‌اندازی یا به اصطلاح initialize می‌کنیم. این کار باعث می‌شود، پنجره مربوط به بازی ما تولید شده و در وسط صفحه به نمایش درآید. در مرحله بعد و در خط شماره ۱۰ اندازه این پنجره را برابر ۸۰۰×۶۰۰ و در خط ۱۱ عنوان پنجره را برابر عبارت “Pygame Test 1” تنظیم می‌کنیم. در نهایت، با اجرای یک حلقه به انتظار یک رویداد (در اینجا فشرده شدن کلیدهای ماوس یا کلیدی از صفحه کلید) می‌نشینیم. نخستین برنامه‌ای که ما با کمک Pygame نوشته‌ایم، هیچ عملیات خاصی انجام نمی‌دهد و تنها هدف ما از آوردن این مثال آشنایی با روش راه‌اندازی و تنظیم خصوصیات ابتدایی پنجره برنامه نظیر اندازه و عنوان پنجره بود. آنچه در این‌جا مهم است درک شیء screen به عنوان یک «ظرف» یا Container است. در اصطلاح Pygame به آن سطح یا Surface گفته می‌شود. این شیء به نوعی نقش یک برگه کاغذ را بازی خواهد کرد که ما ترسیمات مورد نظرمان را روی آن انجام می‌دهیم.

#! /usr/bin/env python
# importing modules
import pygame
from pygame.locals import *
import os
os.environ[‹SDL_VIDEO_CENTERED›]=›۱›
# Initializing the game 
pygame.init()
# screen setup
screen = pygame.display.set_mode((800,600))
pygame.display.set_caption(‹Pygame Test 1›)
doloop=1
while doloop:
    if pygame.event.wait().type in (KEYDOWN ,\ MOUSEBUTTONDOWN):
        break

فهرست ۱- کد ساده‌ای برای ایجاد یک صفحه Pygame

اکنون می‌توانیم به تدریج قابلیت‌ها و تنظیماتی را به این برنامه بیافزاییم. برای شروع از تغییر پس زمینه برنامه شروع می‌کنیم. برای تنظیم رنگ در ماجول‌های Pygame مجبور هستیم مقادیر RGB یا قرمز، سبز و آبی رنگ را تعیین کنیم. برای ساده‌تر شدن این کار می‌توانید از نرم‌افزاری به نام colorname استفاده کنید که از طریق مرکز نرم‌افزار اوبونتو قابل نصب است. به کمک این نرم‌افزار تعیین مقادیر RGB هر رنگ دلخواه از طریق یک چرخ رنگ به سادگی امکان‌پذیر خواهد شد. برای تنظیم رنگ پس‌زمینه کافی است، پس از دستور import خط زیر را اضافه کنید:

Background = 208 , 202 , 104

این کار رنگی آجری را به متغیر Background (که از جنس توپل است) نسبت خواهد داد. آن‌گاه پس از دستور  pygame.display.set_caption دو خط زیر را اضافه کنید:

screen.fill(Background)
screen.display.update()

متد ()screen.fill تنظیم رنگ صفحه را بر عهده دارد و متد ()update باعث اعمال تنظیم انجام شده به صفحه در حال نمایش خواهد شد. 

نمایش متن

اکنون زمان آن رسیده است که چند سطر متن را به پنجره برنامه اضافه کنیم. درست بعد از تعریف رنگ پس‌زمینه دستور زیر را برای تنظیم رنگ پیش‌زمینه به سفید وارد کنید:

FontForeground = 255 , 255 , 255

اگر برنامه را در این وضعیت اجرا کنید، اتفاق خاصی رخ نخواهد داد، زیرا ما تا‌کنون تنها رنگ متن را تعیین کرده‌ایم. برای نوشتن متن روی screen یا همان پنجره برنامه، خطوط زیر را بین دو دستور ()screen.fill  و ()pygame.display.update وارد کنید.

font = pygame.font.Font(None , 27)
text = font.render(‘Here is some text’ ,
True , FontForeground , Background)
textrect = text.get_rect()
screen.blit(text,textrect)

شکل 1- قراردادن متن روی یک صفحه Pygame

این برنامه را با عنوان game2.py ذخیره کرده و اجرا کنید. برنامه شما اکنون باید شبیه فهرست ۲ باشد. برای نوشتن متن ما ابتدا در خط ۱۵ متد Font را فراخوانده و ۲ آرگومان را به آن پاس کرده‌ایم. نخستین آرگومان نام فونت و دومی اندازه آن خواهد بود. در اینجا ما از None برای نام فونت استفاده کرده‌ایم که باعث می‌شود سیستم از فونت پیش‌فرض خود استفاده کند.
پس از آن و در خط ۱۶ متد ()font.render را به‌کار برده‌ایم که چهار آرگومان دارد. این چهار آرگومان به ترتیب عبارتند از متن موردنظر، استفاده یا عدم استفاده از anti-aliasing، رنگ پیش‌زمینه متن و در نهایت رنگ پس‌زمینه آن. برای قرار دادن متن روی screen از واسطی به نام مستطیل یا Rectangle استفاده می‌کنیم. در خط ۱۸ با استفاده از تابع ()text.get_rect مستطیل مربوط به متن را ایجاد کرده‌ایم. درک این روند بسیار مهم است، زیرا اغلب اشیایی که از این به بعد با آن‌ها سروکار خواهیم داشت، مستطیل خواهند بود.

پس از آن ما مستطیل حاوی متن را روی screen قرار داده (خط ۱۹) و تغییرات را اعمال کرد‌ه‌ایم. اما blit چیست و چرا از چنین نام عجیب و غریبی استفاده می‌شود؟ ریشه‌های این نام به سال‌های ۱۹۷۰ و دوران زیراکس پارک (جایی که بسیاری از تکنولوژی‌های امروزی را مدیون دانشمندان و نوآوران فعال در آن هستیم) باز می‌گردد. این اصطلاح در واقع خلاصه Bitmap Block Transfer است. وظیفه این دستور قرار دادن یک بلوک تصویری روی یک پس‌زمینه است.

#! /usr/bin/env python
# importing modules
import pygame
from pygame.locals import *
import os
os.environ[‹SDL_VIDEO_CENTERED›]=›۱›
Background = 208,202,104
FontForeground = 255,255,255
# Initializing the game 
pygame.init()
# screen setup
screen = pygame.display.set_mode((800,600))
pygame.display.set_caption(‹Pygame Test 2›)
screen.fill(Background)
font=pygame.font.Font(None,27)
text=font.render(‹Here is some text›,True,\
FontForeground,Background)
textrect=text.get_rect()
screen.blit(text,textrect)
pygame.display.update()
doloop=1
while doloop:
    if pygame.event.wait().type in (KEYDOWN ,\ MOUSEBUTTONDOWN):
        break

فهرست ۲

اما اگر بخواهیم متن ما درست در وسط پنجره برنامه ظاهر شود، چه باید کرد؟ در چنین صورتی کافی است بین دستور ()text.get_rect (خط‌ ۱۸) و screen.blit (خط ۱۹) این دو خط را اضافه کنید:

textRect.centerx = screen.get_rect().centerx
textRect.centery = screen.get_rect().centery

همان‌گونه که مشاهده می‌کنید، خود screen هم در واقع یک مستطیل است که ما به کمک متد ()get_rect مشخصات آن و به ویژه x و y مرکز آن را استخراج کرده‌ایم و آن‌ها را به مختصات مرکز مستطیل متن نسبت داده‌ایم.
دوباره برنامه را اجرا کنید. این بار مشاهده خواهید کرد که همانند شکل‌۱ پس از اجرای آن، متن Here is some text درست در وسط پنجره برنامه ظاهر می‌شود. با استفاده از متدهای (set_bold(True و (set_italic(True درست پس از قسمت pygame.font.Font می‌توانید به متن حالت توپر یا مایل را نیز نسبت دهید.

اگر به خاطر داشته باشید، پیش‌تر گفتیم که برای تنظیم فونت متن از متد ()pygame.font.Font استفاده می‌کنیم که دو آرگومان فونت و اندازه را دریافت می‌کند. مشکل اینجا است که ما نمی‌توانیم از محل قرارگیری و نصب فونت‌های مختلف روی سیستم‌های متفاوت اطلاع پیدا کنیم یا درباره حالتی خاص مطمئن باشیم. خوشبختانه pygame این امکان را با پیش‌بینی متدی به نام match_font حل کرده است. در فهرست‌۳ شما قطعه کدی را مشاهده می‌کنید که می‌تواند به عنوان مثال، محل قرارگیری فونت Courier New را برای ما چاپ کند. این کد در سیستم نگارنده آدرس usr/share/fonts/truetype/freefont/FreeMono.ttf را باز‌می‌گرداند که ممکن است در سیستم شما مقدار دیگری باشد. اگر فونت Courier New روی سیستم نصب نشده باشد، این کد مقدار None را بازخواهد گرداند. اما اگر فرض کنیم این فونت روی سیستم نصب شده باشد، می‌توان مقدار برگشتی این تابع را مانند قطعه کد زیر برای تنظیم فونت برنامه به کار برد:

courier = pygame.font.match_font(‘Courier New’)
font = pygame.font.Font(courier , 27)

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

گرافیک

اگرچه متن‌ها زیبا هستند، اما گرافیک‌ها از آن‌ها زیباترند. در اینجا به توضیح نحوه کار اسپرایت‌ها (Sprite) در pygame خواهیم پرداخت. اسپرایت‌ها تصاویر دو بعدی ساده‌ای هستند که در نرم‌افزارهای گرافیکی برای نمایش اجزای بازی مورد استفاده قرار می‌گیرند. برای استفاده از گرافیک‌ها در برنامه بازی خودتان، توسط نرم‌افزاری نظیر GIMP یا ابزارهای مشابه تصویری شبیه یک آدمک را در یک فایل ۵۰ × ۵۰ پیکسل ترسیم کنید. رنگ پس‌زمینه تصویر را به حالت شفاف (Transparent) تغییر دهید و فایل را با نام stick.png در پوشه‌ای که فایل‌های کد برنامه در آن قرار دارند، ذخیره کنید. توجه کنید که حتماً حالت پس‌زمینه تصویر را روی Transparent تنظیم کنید تا هنگام نمایش و حرکت اسپرایت روی پس‌زمینه تنها تصویر آدمک دیده شود، نه یک مربع ۵۰ × ۵۰ سفید رنگ.

import pygame
from pygame.locals import *
print pygame.font.match_font(‹Courier New›)

فهرست ۳- کدی برای تعیین محل یک فونت خاص

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

#! /usr/bin/env python
# importing modules
import pygame
from pygame.locals import *
import os
import sys
os.environ[‹SDL_VIDEO_CENTERED›]=›۱›
Background = 0,255,127
FontForeground = 255,255,255
# Initializing the game 
pygame.init()
# screen setup
screen = pygame.display.set_mode((400,300))
pygame.display.set_caption(‹Pygame Sprite Test›)
screen.fill(Background)
class Sprite(pygame.sprite.Sprite):
    def __init__(self,position):
        pygame.sprite.Sprite.__init__(self)
        # get the screen rectangle
        self.screen = pygame.display.get_surface().get_rect()
        # Variable to store privious position
        self.oldsprite=(0,0,0,0)
        self.image=pygame.image.load(‹stick.png›)
        self.rect=self.image.get_rect()
        self.rect.x=position[0]
        self.rect.y=position[1]
     def update(self,amount):
        # make a copy of current rectangle
        self.oldsprite = self.rect
        # Moving the rectangle
        self.rect = self.rect.move(amount)
        # Check the border
        if self.rect.x <0:
            self.rect.x=0
        elif self.rect.x > (self.screen.width – self.rect.width):
            self.rect.x = self.screen.width – self.rect.width
        if self.rect.y < 0:
            self.rect.y=0
        elif self.rect.y > (self.screen.height – self.rect.height):
            self.rect.y = self.screen.height – self.rect.height
character = Sprite((screen.get_rect().x , screen.get_rect().y))
screen.blit(character.image,character.rect)
blank=pygame.Surface((character.rect.width,character.rect.height))
blank.fill(Background)
pygame.display.update()
doloop=1
while doloop:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            sys.exit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                character.update([-10,0])
            elif event.key == pygame.K_UP:
                character.update([0,-10])
            elif event.key == pygame.K_RIGHT:
                character.update([10,0])
            elif event.key == pygame.K_DOWN:
                character.update([0,10])
            elif event.key == pygame.K_q:
                doloop=0
        # Erase old position
        screen.blit(blank,character.oldsprite)
        # Draw new
        screen.blit(character.image,character.rect)
        # Update modified positions
        pygame.display.update([character.oldsprite,character.rect])

فهرست ۴ – حرکت دادن یک کاراکترروی صفحه Pygame

شکل 2- صفحه بازی ایجاد شده توسط کد فهرست 4

تابع update که در خط ۲۷ تعریف شده است، وظیفه حرکت دادن اسپرایت و پرکردن محل قبلی آن با یک فضای خالی (پاک کردن اسپرایت) را برعهده خواهد داشت. این تابع همچنین عدم خروج اسپرایت از صفحه را کنترل می‌کند.  پس از پایان تعریف کلاس، ما نمونه‌ای از کلاس را در خط ۴۱ با نام character ایجاد کرده و با تابع blit روی صفحه نمایش داده‌ایم (خط‌۴۲). پس از آن شیء blank یا پاک کننده ایجاد شده و تابع update ماجول display  به اجرا در می‌آید. پس از آن در خطوط ۴۷ تا ۶۷ یک حلقه بی‌پایان ایجاد شده و با کنترل ورودی کاربر، آدمک ساخته شده روی صفحه نمایش به حرکت در خواهد آمد. کارهای بسیار پیچیده‌تری با pygame قابل انجام است  به عنوان مثال، این ماجول دارای توابعی برای کنترل برخورد اسپرایت‌ها (مثلاً برخورد گلوله با شخصیت بازی)، نگه‌داری امتیازها و افزودن جلوه‌های صوتی و‌… نیز دارد. اما هدف ما آشنا‌کردن شما با مبانی کار با این ماجول بود و امیدواریم که توانسته باشیم حس کنجکاوی شما را برای آگاهی بیشتر برانگیخته باشیم.

یک فایل جدید ایجاد کنید و محتویات فهرست ۴ را در آن وارد کرده و آن را با نام game4.py  ذخیره کنید. با اجرای این کد شما آدمک متحرک را روی پس‌زمینه‌ای به رنگ سبز تیره مشاهده خواهید کرد که به کلیدهای جهت‌نما واکنش نشان داده و به دستور شما حرکت خواهد کرد.  بخش اول این کد، شبیه مثال‌های قبلی و شامل خطوطی برای import ماجول‌های موردنیاز و تنظیم رنگ و عنوان صفحه بازی است. پس از آن در خط ۱۶ کلاسی را برای کنترل و مدیریت اسپرایت یا گرافیک دلخواهمان تعریف کرده‌ایم. در ابتدای کلاس و با تعریف تابع __init__ ما اسپرایت را راه‌اندازی می‌کنیم. غالب کارهای ساخت اسپرایت به کمک متد اصلی pygame.sprite.Sprite.__init__   که در خود pygame تعریف شده است (خط ۱۸) به انجام می‌رسد. پس از آن در خط ۲۰ سطح یا Surface بازی را تعریف کرده و آن را screen نامیده‌ایم. بعدها به کمک شیء screen می‌توانیم کنترل کنیم که اسپرایت از صفحه بازی خارج نشود. سپس در خط ۲۳ با تابع pygame.image.load فایل تصویر آدمک ساخته شده را به اسپرایت نسبت داده‌ایم. اگر فایل برنامه و فایل تصویر در یک پوشه نباشند، باید آدرس کامل فایل تصویری در این تابع قید شود. پس از آن در خط‌های ۲۵ و ۲۶ موقعیت x , y  اسپرایت توسط متغیر position که به تابع پاس شده است،تنظیم می‌شود.

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

بیشتر بدانید ...

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

. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
بیشتر بدانید ...

آموزش پایتون به زبان ساده قسمت هشتم

آموزش کار با زبان برنامه‌نویسی پایتون (بخش هشتم)

آموزش پایتون به زبان ساده

سکون و ایستایی در دنیای نرم‌افزار مترادف مرگ است. همه نرم‌افزارها برای ادامه حیات‌ خود محتاج به روزآوری و افزوده شدن قابلیت‌ها و ویژگی‌های جدید هستند. در این میان با گسترش کاربرد و نفوذ کامپیوترها در جنبه‌های مختلف زندگی ما، زبان‌های برنامه‌نویسی بیش از سایر نرم‌افزارها به این پویایی و تحول نیاز دارند. بر همین اساس، زبان پایتون نیز به‌صورت مداوم در حال بازبینی و بهینه‌سازی است. در این مورد خاص و با توجه به حجم عظیم تغییرات ایجاد شده در نسخه X.3، بنیاد نرم‌افزار پایتون (Python Software Foundation) تصمیم گرفته، ارتقا به سری جدید را به تدریج انجام دهد‌، یعنی روند توسعه سری جدید در کنار سری جاری و به‌صورت همزمان انجام می‌پذیرد تا زمانی که بنیاد به این نتیجه برسد، بیشتر کاربران آمادگی انتقال به سری جدید را دارند. در این قسمت تصمیم گرفتیم، به معرفی مختصر خصوصیات و تفاوت‌های نسل جدید پایتون با نسل قبل بپردازیم.

نسل سوم

همان‌گونه که پیش‌تر اشاره شد، در حال‌حاضر توسعه پایتون در دو مسیر موازی در حال انجام است. گروه نخست توسعه‌دهندگان همچنان به کار روی سری دوم پایتون (۲.x) مشغول هستند که به‌دلیل قدمت و سابقه بیشتر، پرطرفدارتر است. در حال حاضر بیشتر فریم‌ورک‌ها و کتابخانه‌های رایج و پراستفاده برای این سری توسعه داده شده و پیاده‌سازی می‌شوند. تمام مثال‌ها و برنامه‌هایی که تا‌کنون معرفی کرده‌ایم نیز از همین سری استفاده می‌کنند.
 این نسل از زبان پایتون در اکتبر سال ۲۰۰۰ معرفی شد و اکنون به نسخه ۱/۷/۲رسیده است. گروه دوم توسعه‌دهندگان به کار روی نسل جدید این زبان، یعنی پایتون ۳.x می‌پردازند که تا‌کنون نسخه ۲/۳ آن نیز منتشر شده است. در این سری وان روسوم (Guido van Rossum) خالق پایتون، تصمیم گرفته به بازنگری اساسی در تمام جنبه‌های این زبان برنامه نویسی و حذف Backward Compatibility (پشتیبانی از اجرای کدهای نوشته شده با نسل دوم این زبان) بپردازد.

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

دستور PRINT

یکی از مهم‌ترین و پرکاربردترین بخش‌های پایتون که در این نسخه دستخوش تغییرات اساسی شده، دستور print است. در نسخه‌های ۲.x این زبان به راحتی می‌توانستیم آیتم مورد نظر را به فرم زیر چاپ کنیم:

print “This is a test”

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

print (“This is a test”)

هرچند این تغییر به ظاهر ساده است، اما در ادامه خواهیم دید که تغییرات دستور print به همین موارد خلاصه نخواهد شد.

قالب‌بندی و جای‌گذاری متغیرها

در نسخه قبلی پایتون ما از کدهایی برای قالب‌بندی و جای‌گذاری متغیرها در یک رشته استفاده می‌کردیم (همانند شکل۱). اگرچه این عبارت در پایتون ۲/۳ نیز به درستی کار خواهد کرد، اما این وضعیت در حال تغییر است، زیرا توابع قالب‌بندی %s و %d در نسخه‌های آینده حذف خواهند شد و سیستم نگارشی {x} جایگزین آن خواهد (شکل‌۲). در این روش عبارت‌های معرفی شده به عنوان آرگومان‌های متد format، به ترتیب جایگزین {x}ها خواهند شد. همان‌طور که مشاهده می‌کنید، خوانایی این روش جدید بسیار بیشتر از حالت قبلی ارجاع به متغیرها و قالب‌بندی آن‌ها است.

اعداد

در سری ۲.x پایتون عبارت ۰.۲/۵ حاصلی برابر با۵.۲ داشت. اما اگر از عبارتی مانند ۲/۵ استفاده می‌کردید، به‌واسطه تبدیل نتیجه به فرمت عدد صحیح (به‌واسطه عدد صحیح بودن هر دو عملوند عبارت ۲/۵) حاصلی برابر ۲ دریافت می‌کردید. در سری ۳.x پایتون استفاده از هر دو فرم قبلی نتیجه‌ای برابر با ۵.۲ ایجاد خواهد کرد. و در صورتی که نیاز داشته باشید تقسیم را به‌صورت صحیح و بدون اجزای اعشاری انجام دهید، باید از فرمت ۵//۲ استفاده کنید.

دستور INPUT 

در سری ۲.x  پایتون، دستور input  تنها ورودی‌های عددی را می‌پذیرفت و در صورت ورود رشته‌ها همانند شکل ۳ با پیغام خطا روبه‌رو می‌شدیم. برای دریافت رشته‌ها از کاربر مجبور بودیم از دستور raw_input استفاده کنیم. اما در سری ۳.x دستور input با تمام ورودی‌ها همانند رشته رفتار می‌کند و در صورتی که به دریافت اعداد نیاز داشته باشید، باید ورودی‌های دستور input را به صورت دستی به عدد تبدیل کنید.

نامساوی و شرطی‌ها

در سری ۲.x پایتون برای کنترل نامساوی‌بودن عبارت‌ها از عملگر <> استفاده می‌شد، اما این شیوه در سری ۳.x دیگر مجاز نیست و به جای آن باید از عملگر != استفاده کرد.  نکته دیگر این‌که در سری ۲.x در صورت مقایسه دو عملوند از نوع مختلف (مثلاً مقایسه یک رشته با یک عدد صحیح) همانند شکل ۴ نتیجه‌ای برابر با false یا نادرست بازگردانده می‌شد. به عبارت دیگر، خطایی رخ نمی‌داد. اما در سری ۳.x باید حتماً، از یکسان بودن (به عبارت کلی‌تر، قابل مقایسه بودن) عملگرها اطمینان حاصل کرد. در غیر این صورت، همانند شکل ۵ با خطای Type Error مواجه خواهیم شد.

سایر تغییرات

انواع داده بنیادین در پایتون نیز دستخوش تغییر شده‌اند. دو نوع داده int و long در قالب یک نوع داده، یعنی int ادغام شده‌اند و متدهای مربوط به دیکشنری‌ها نظیر ()dict.keys به جای بازگرداندن یک لیست، نوع جدیدی به نام view را باز می‌گردانند. تابعی نظیر ()range هم به جای یک لیست یک شمارنده یا Iterator را باز می‌گرداند. 
همچنین تغییرات فراوانی نیز در کتابخانه‌های استاندارد پایتون ایجاد شده است. به عنوان مثال، می‌توان به حذف توابع مربوط به گوفر (gopherlib) و جایگزین شدن md5 با hashlib اشاره کرد. البته، همان‌طور که در ابتدا نیز اشاره شد، تغییرات ایجاد شده بسیار زیاد بوده و توضیح  کامل همه آن‌ها در این مقاله نمی‌گنجد.

تبدیل برنامه‌ها به سری جدید

سری ۳.x  پایتون با ابزاری برای تبدیل کدهای سری‌های قبلی به سری جدید همراه شده است. اگرچه این ابزار در همه موارد به درستی عمل نمی‌کند، اما در بسیاری از موارد شما را به هدف بسیار نزدیک خواهد کرد. این ابزار نام معنی‌دار ۲to3 را یدک می‌کشد. در لینوکس برای استفاده از این ابزار از طریق ترمینال دستور زیر را وارد می‌کنیم:

۲to3 [-w] <input_file.py<

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

sudo apt-get install python3

این ابزار در ماشین‌های ویندوزی با نام ۲to3.py در پوشه c:\Python3x\Tools\Scripts قرار دارد و برای استفاده از آن باید از خط فرمان و در پوشه گفته شده دستور زیر را صادر کرد:

<python.exe   ۲to3.py  [-w]  <input_file.py

این برنامه در حالت عادی تنها تغییرات لازم را برای تبدیل کد، روی صفحه نمایش چاپ خواهد کرد و فایل را تغییر نخواهد داد. استفاده از سوییچ اختیاری –w باعث می‌شود، تغییرات مورد نیاز به فایل اصلی اعمال شود. در صورت استفاده از این سوییچ یک نسخه پشتیبان از فایل تهیه شده و تغییرات موردنیاز به طور مستقیم به فایل اعمال می‌شود. 

آیا باید به سری ۳.x مهاجرت کنیم؟

تغییرات سینتکس در همه نسخه‌های جدید زبان‌های برنامه‌نویسی به چشم می‌خورد. میان‌برهایی نظیر += ممکن است به سادگی کار ما را در هنگام کدنویسی ساده‌تر کنند. اما همین تغییرات ساده سینتکس جنبه‌های منفی نیز در خود دارند. درباره زبان پایتون نیز به دلیل همین تغییرات (گاهی ساده) در سینتکس، بسیاری از ماجول‌ها و کدهایی که قبلاً استفاده می‌کردیم، در برنامه‌هایی که با سری ۳.x پایتون نوشته می‌شوند، قابل استفاده نیستند. به عنوان نمونه می‌توان به کتابخانه‌های ElementTree اشاره کرد که در بخش مربوط به xml از آن استفاده کردیم. اما با تمام این مشکلات نباید از مهاجرت به سری ۳.x پایتون نا امید شد.

خوشبختانه پایتون سری ۲.x (حداقل از نسخه ۶/۲ به بعد) در عین سازگاری با نسخه‌های قبلی، از تمام سینتکس‌های مورد نیاز برای نوشتن کد به سبک سری ۳.x پشتیبانی می‌کند (فهرست ۶). پیشنهاد می‌کنیم که از همین حالا نوشتن کد به سبک سری   ۳.x را آغاز کرده و اگر می‌توانید تنها به کتابخانه استاندارد پایتون بسنده کنید و به ماجول‌های دیگر رجوع نکنید، حتماً به  ۳.x  پایتون مهاجرت کنید. 

به کمک ابزار انتقالی که پیش‌تر از آن صحبت کردیم، تقریباً می‌توانید به سادگی تمام مجموعه کدهایی را که تا‌کنون نوشته‌اید، به سری ۳.x ارتقا دهید. اما حتی اگر نیازمند کتابخانه‌هایی هستید که هنوز به سری ۳.x منتقل نشده‌اند، همواره گوشه چشمی به این سری جدید داشته باشید. زیرا دیر یا زود کدهای موردنظر شما نیز به سری ۳.x ترجمه خواهند شد. 

مطالعه بیشتر

برای آشنایی بیشتر با تغییرات و نحوه مهاجرت به این سری جدید می‌توانید به منابع زیر مراجعه کنید:

– http://wiki.python.org/moin/Python2orPython3
– http://docs.python.org/release/3.1.2/whatsnew/3.0.html
– http://docs.python.org/library/2to3.html 
– http://diveintopython3.org

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

بیشتر بدانید ...

آموزش پایتون به زبان ساده قسمت هفتم

آموزش کار با زبان برنامه‌نویسی پایتون (بخش هفتم)

آموزش پایتون به زبان ساده

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

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

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

برای استفاده از یک سیستم کلاینت/ سرور ابتدایی‌ترین کار، اتصال از ماشین کلاینت به ماشین سرور است. ما این کار را از طریق یک پایپ (pipe) یا یک سوکت (socket) ‌انجام می‌دهیم. اگر در دوران کودکی با قوطی‌های خالی کنسرو، تلفن ساخته باشید،‌ به سادگی می‌توانید اصول این کار را درک کنید. در این تلفن‌ها ارتباط بین دو قوطی خالی (سرور و کلاینت) از طریق یک رشته (اتصال یا connection) که به سوراخی در انتهای هر قوطی (سوکت) متصل است، برقرار می‌شود. ایده سوکت‌ها و اتصال بین کلاینت و سرور دقیقاً به همین شکل است. کلاینت اتصال (connection) مستقیمی به سرور دارد که این اتصال به سوکت معینی با شماره پورت مشخص در سرور متصل می‌شود.

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

  1.   یک سوکت بساز

  2. نام ماشین میزبان سرور را بپرس

  3.   یک پورت انتخاب کن

  4.   سوکت را به کامپیوتر میزبان در پورت مشخص متصل کن

  5.   منتظر یک اتصال باش

  6.   اگر اتصال برقرار شد:

  7.   اتصال را قبول کن

  8.   دریافت اتصال را اعلام کن

  9.   اتصال را قطع کن

    کد واقعی چنین سروری در فهرست ۱ آورده شده است.

#!/usr/bin/env python

#server1.py

import socket

soc=socket.socket()

hostname=socket.gethostname()

print “My hostname is “, hostname

port =21005

soc.bind((hostname,port))

soc.listen(5)

while True:

    con,address = soc.accept()     

    print “I,m now connected to “ , address

    con.send(“Hello and Goodbye”)

    con.close()

فهرست ۱- ساده‌ترین نمونه یک سرور

در خط ۳  ماجول سوکت را Import  کرده‌ایم، سپس یک سوکت ساخته‌ایم. تابع socket() که برای ساخت سوکت مورد استفاده قرار می‌گیرد، تعدادی آرگومان اختیاری دارد که کمی بعد‌تر به آن اشاره خواهیم کرد. پس از آن با کمک تابع gethostname() نام ماشینی که این سرور را اجرا می‌کند، به دست آورده‌ایم. تابع bind() که در خط ۸ از آن استفاده کرده‌ایم، آدرس و پورت موردنظر را به سوکت نسبت می‌دهد. در حالت پیش‌فرض (شبکه‌های مبتنی بر IPv4) آرگومان ورودی این تابع باید یک توپل دوتایی محتوای نام ماشین میزبان و شماره پورت (hostname,port) باشد. در انتها و در خط ۹ با تابع listen() در انتظار برقراری یک اتصال نشسته‌ایم. سوکتی را که خود اقدام به برقراری ارتباط نمی‌کند و در انتظار اتصال سایر سوکت‌ها می‌ماند «سوکت گوش دهنده» یا Listener Socket می‌نامند. آرگومان تابع listen() تعیین کننده حداکثر تعداد سوکت‌های در صف انتظار برای اتصال به سوکت «گوش دهنده» است و بیشترین مقدار ممکن برای آن به سیستم مورد استفاده بستگی دارد.

پس از آن سرور در یک حلقه بی‌پایان، در صورت برقراری اتصال آن را می‌پذیرد (خط ۱۱)، دریافت اتصال را اعلام می‌کند (خط ۱۲)، پیغامی را به کلاینت ارسال کرده (خط ۱۳) و اتصال را قطع می‌کند (خط ۱۴). همان‌طور که مشاهده می‌کنید، خروجی تابع accept() یک توپل دوتایی محتوای شیء سوکت متقاضی اتصال (con) و آدرس آن (address) است. ما برای ارسال اطلاعات و قطع ارتباط به این دو نیاز خواهیم داشت. 

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

#!/usr/bin/env python
#clinet1.py

import socket
soc=socket.socket()
hostname=socket.gethostname()
port = 21005

soc.connect((hostname,port))
print soc.recv(1024)
soc.close

فهرست ۲- ساده‌ترین نمونه یک کلاینت

برخلاف سوکت‌های گوش‌دهنده که باید توسط تابع bind() به یک پورت یا آدرس بچسبند، سوکت‌هایی که قصد برقراری تماس را دارند، از تابع connect() استفاده خواهند کرد. در خط ۹ مشاهده می‌کنید که تابع connect() نیز همانند تابع bind() از یک توپل محتوای نام میزبان و شماره پورت برای برقراری اتصال استفاده می‌کند.  در خط  ۱۰ نیزتابع recv() نیز برای دریافت اطلاعات از اتصال برقرار شده مورد استفاده قرار می‌گیرد. در این تابع آرگومان داده شده اندازه بافر است که درواقع تعیین‌کننده حداکثر اندازه بلوک داده‌ای است که می‌تواند یک‌باره دریافت شود. این آرگومان برای هماهنگی بهتر با سخت‌افزارها و پروتکل‌های شبکه بهتر است توانی از ۲ مثلاً ۴۰۹۶ باشد.

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

#!/usr/bin/env python
# server2.py
from socket import *
import sys
import os
BUFSIZ = 4096
HOST = ““
PORT = 29876
ADDR = (HOST,PORT)
class ServCmd:
   def __init__(self):
       self.serv = socket(AF_INET,SOCK_STREAM)
       self.serv.bind((ADDR))
       self.cli = None
       self.listeningloop  = ۰
       self.processingloop = 0
       self.run()
   def run(self):
       self.listeningloop = 1
       while self.listeningloop:
           self.listen()
           self.processingloop = 1
           while self.processingloop:
               self.procCmd()
           self.cli.close()
       self.serv.close()
   def listen(self):
       self.serv.listen(5)
       print “Listening for Client”
       cli,addr = self.serv.accept()
       self.cli = cli
       print “Connected to “, addr
   def procCmd(self):
        cmd = self.cli.recv(BUFSIZ)
        if not cmd:
           return
        print “Received command: “, cmd
        self.servCmd(cmd)
        if self.processingloop: 
           proc = os.popen(cmd)
           outp = proc.read()
           if outp:
               self.cli.send(outp)
           else   :
               self.cli.send(“OK”)
   def servCmd(self,cmd):
       cmd = cmd.strip()
       if cmd == “GOODBYE”: 
           self.processingloop = 0
if __name__ == “__main__”:
   serv = ServCmd()
فهرست ۳-  نسخه پیشرفته‌تر یک سرور

خروجی این برنامه‌ها کاملاً قابل پیش‌بینی است. در سمت سرور خروجی چیزی همانند شکل ۱ و در سمت کلاینت فقط عبارت Hello and Goodbye خواهد بود ( نام میزبان یاشماره IP در سیستم شما به احتمال زیاد متفاوت خواهد بود).
همان‌طور که مشاهده کردید، پیاده‌سازی چنین نمونه محدودی بسیار ساده است. در مرحله بعدی قصد داریم سروری بسازیم که قادر به انجام کار مفیدی به جز سلام و خداحافظی باشد. کد این سرور را در فهرست ۳ مشاهده می‌کنید.

در خطوط ۶ الی ۹ و پس از import کردن ماجول‌های مورد نظر (در قسمت‌های بعدی درباره ماجول‌های os و sys بیشتر صحبت خواهیم کرد)، تعدادی متغیر را برای استفاده‌های بعدی مقداردهی کرده‌ایم. متغیر BUFSIZ  اندازه بافر مورد استفاده را برای دریافت اطلاعات ورودی از سمت کلاینت تعیین می‌کند. همچنین ما پورتی را که روی آن به انتظار اتصال خواهیم بود، در خط ۸ تعریف کرده‌ایم و پس از آن توپلی را برای نگه‌داری نام کامپیوتر میزبان و شماره پورت به‌وجود آورده‌ایم.

سپس در خط ۱۰ کلاسی با نام ServCmd تعریف کرده‌ایم و در تابع ()__init__ سوکت را ساخته و آن را به نام و آدرس فعلی متصل می‌کنیم. در خط ۱۲ مشاهده می‌کنید که این بار برای ساخت سوکت دو آرگومان به آن ارسال کرده‌ایم. 

همان‌گونه که پیش‌تر نیز اشاره کردیم، تابع سازنده سوکت چهار آرگومان عددی اختیاری دارد که نخستین آن‌ها تعیین کننده نوع آدرس‌دهی سوکت است. زیرا نحوه آدرس‌دهی در شبکه‌های یونیکس، IPv4 و IPv6 با یکدیگر متفاوت است. حالت پیش‌فرض این آرگومان مقدار عددی ۲ یا شبکه‌های مبتنی بر IPv4 است. آرگومان دوم تعیین کننده نوع خود سوکت است و در واقع بیان کننده فرمت انتقال اطلاعات روی اتصال ایجاد شده توسط این سوکت است. حالت پیش‌فرض آن عدد ۱ یا انتقال اطلاعات از طریق جریان (Stream) است. آرگومان‌های سوم و چهارم فراتر از مجال این مقاله هستند. در مثال این قسمت به جای آرگومان‌های عددی برای خواناتر بودن کد، از ثابت‌هایی استفاده شده که توسط خود ماجول Socket در دسترس قرار می‌گیرند. این ثابت‌های عددی، یعنی AF_INET و SOCK_STREAM توسط ماجول socket تعریف و مقداردهی می‌شوند. به عبارت دیگر، دستور خط ۱۲ در واقع معادل (self.serv=socket (2,1 خواهد بود.

#!/usr/bin/env python
# client2.py

from socket import *
from time import time
from time import sleep
import sys
BUFSIZE=4096

class CmdLine:
    def __init__(self,host):
        self.HOST=host
        self.PORT=29876
        self.ADDR=(self.HOST,self.PORT)
        self.sock=None
    def makeConnection(self):
        self.sock=socket(AF_INET,SOCK_STREAM)
        self.sock.connect(self.ADDR)
    def sendCmd(self,cmd):
        self.sock.send(cmd)
    def getResult(self):
        data=self.sock.recv(BUFSIZE)
        print data

if __name__==”__main__”:
    conn=CmdLine(“localhost”)
    conn.makeConnection()
    conn.sendCmd(“ls -al”)
    conn.getResult()
    conn.sendCmd(“GOODBYE”)

فهرست ۴- نسخه پیشرفته‌تر یک کلاینت

سپس با تعریف تابع Run (در خط ۱۸) روی ورودی‌های سوکت مورد‌نظر به انتظار اتصال و دریافت دستور خواهیم نشست. در خط ۲۷ تابعی برای شنود پورت و آدرس مورد نظر تعریف کرده‌ایم. 

آدرس و شی کلاینت مربوط به سوکت متصل‌شونده را در خط ۳۰ و به کمک تابع ()accept دریافت کرده‌ایم. توجه کنید که برای در دسترس بودن شی سوکت متصل شونده در تمام قسمت‌های کد، در خط ۳۱ آن را به یکی از خاصیت‌های شی ServCmd تبدیل کرده‌ایم. در خط ۳۳ تابعی برای پردازش دستورات دریافتی ایجاد شده است.

در بخش اول این تابع وجود یا عدم وجود ورودی را چک کرده‌ایم. اگر دستوری دریافت شده باشد آن را به تابع ()servCmd ارسال می‌کنیم. به تفاوت میان ServCmd که یک کلاس است با تابع ()servCmd که در همان کلاس تعریف شده است دقت کنید.

if __name__ == “__main__”:
conn=CmdLine(‘localhost’)
conn.makeConnection()
loop=1
while loop:
cmd=raw_input(“Enter a command:”)
if  cmd==”finish:
loop=0
else:
conn.sendCmd(cmd)
con.getResult()
فهرست ۵- کد جایگزین برای حفظ ارتباط کلاینت و سرور

این تابع به کمک متد ()strip در خط ۴۷ که مختص نوع داده رشته است، فضاهای خالی احتمالی در ابتدا و انتهای رشته را حذف کرده و دستور را بصورت خالص بازمی‌گرداند. همچنین در صورت دریافت دستور GOODBYE  چرخه اجرای برنامه را متوقف می‌کند. هنگامی که دستوری را از جانب کلاینت دریافت کردیم، از تابع ()popen متعلق به ماجول os برای پردازش آن استفاده می‌کنیم (خط۴۰ ). این تابع در واقع یک پوسته خط فرمان ایجاد کرده و دستور دریافتی را در آن اجرا می‌کند. 

 حال نوبت کدهای سمت کلاینت است که آن‌ها را در فهرست ۴ مشاهده می‌کنید. این کدها بسیار ساده‌تر از کدهای سمت سرور هستند. در اینجا از همه قسمت‌ها به جز بخش ارسال دستور صرف‌نظر می‌کنیم، زیرا خود شما دیگر می‌توانید آن‌ها را تجزیه و تحلیل کنید. در قسمت ارسال دستور و در خط ۲۳۴ دستور ساده‌ ls را برای دریافت فهرست فایل‌های موجود در سمت سرور اجرا کرده‌ایم (در صورت استفاده از ماشین‌های ویندوزی باید آن را به dir تغییر دهید).

اگر می‌خواهید برنامه کلاینت شما ارتباط با سرور را قطع نکند و بتوانید دستورات دیگری را نیز با این سیستم امتحان کنید، کافی است خطوط ۲۵ تا ۳۰ فایل کلاینت را با قطعه کدهای فهرست ۵ تعویض کنید. در این صورت در یک حلقه دائمی تا زمانی که شما دستور finish را صادر نکرده باشید، دستورات جدید از شما پرسیده شده و روی سرور اجرا خواهند شد. 
با این مثال‌های ساده شما به‌صورت عملی با مفهوم برنامه‌های کلاینت‌/ سرور آشنا شده‌اید و می‌توانید برنامه‌هایی را به‌صورت توزیع شده روی کامپیوترهای شبکه خود به اجرا درآورید. در بخش‌های بعدی مجموعه و با تکمیل مباحث مربوط به تعامل پایتون و  سیستم‌عامل بهتر خواهید توانست قابلیت‌های سیستم‌های کلاینت‌/ سرور را مورد استفاده قرار دهید.

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

بیشتر بدانید ...

چرا پایتون یاد بگیریم؟

چرا پایتون ؟ Python basic tutorial

. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
بیشتر بدانید ...

آموزش پایتون به زبان ساده قسمت ششم

آموزش کار با زبان برنامه‌نویسی پایتون (بخش ششم)

آموزش پایتون به زبان ساده

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

شروع

برنامه Boa Constructor را اجرا کنید و در قاب Editor تمام زبانه‌ها به‌جز Shell و اکسپلورر را با استفاده از ترکیب‌کلیدهای CTRL + W ببندید. با این کار مطمئن می‌شویم، کار را از پایه و روی فایل‌های تازه شروع کرده‌ایم. حال با کلیک دکمه wx.App یک پروژه جدید بسازید. در صورت نیاز به راهنمایی به مقاله شماره قبل مراجعه کنید.  پیش از هر کار دیگری، Frame1 را با نام  FrameMain.py و App1 را با نام Gui2.py ذخیره کنید. در حالی‌که زبانه GUI2 در قاب Editor انتخاب شده است، به نوار ابزارها مراجعه کنید و در زبانه New و با کلیک دکمه wx.Frame که درست در کنار wx.App قرار گرفته است، یک قاب یا پنجره دیگر به پروژه اضافه کنید. اطمینان حاصل کنید که زبانه Application در زیر ستون Module همانند شکل‌۱ هر دو فریم را نمایش می‌دهد.

حال به فریم جدید مراجعه کرده و آن را با نامدFrameSecond.py ذخیره کنید. سپس FrameMain را در Designer باز کنید و از زبانه Container/Layout در قاب اصلی،  یک wx.Panel به آن اضافه کنید. اندازه آن را طوری تنظیم کنید که تمام فریم را بپوشاند. حال باید برخی از خصوصیات فریم را دستکاری کنیم. در قاب Inspector و در زبانه Objs شیء  Frame را انتخاب کنید و در زبانه Constr مقدار title را به Main Frame تبدیل کنید. در انتهای مقاله درباره قوانین نام‌گذاری صحبت خواهیم کرد. با کلیک علامت تیک آیتم Size اندازه فریم را به ۴۰۰×۳۴۰ تغییر‌دهید. با کلیک روی این علامت، لیستی باز می‌شود که در آن مقدار Height باید برابر ۳۴۰ و مقدار Width برابر چهارصد تنظیم شود (به شکل ۲ دقت کنید).

حال زبانه Props را کلیک کرده و مقدار خاصیت Centered را به wx.BOTH تنظیم کنید. دکمه Post را  (شکل یک تیک که تغییرات انجام شده را به فایل اصلی اعمال می‌کرد) کلیک کرده و کل پروژه را ذخیره کنید. حال با کلیک دکمه زردرنگ مثلثی برنامه را اجرا کنید. فریم اصلی برنامه ما باید درست در وسط صفحه نمایش و با عنوان Main Frame ظاهر شود. فعلاً برنامه را با کلیک دکمه Close در قسمت بالا و سمت راست پنجره ببندید.

دوباره فریم Main Frame را در Designer باز کنید. از زبانه Buttons قاب اصلی، دو دکمه wx.Button را به فریم اضافه کنید، به گونه‌ای که یکی  در نزدیکی مرکز فریم و یکی بالای دیگری قرار بگیرند. دکمه بالایی را انتخاب کرده و با استفاده از قاب Inspector و زبانه Constr نام آن را به btnShowNew و خاصیت Label آن را به «Show the other frame» تنظیم کنید. با استفاده از ترکیب کلیدهای Shift و کلیدهای جهت‌نما، اندازه دکمه را به گونه‌ای تنظیم کنید که تمام نوشته Label آن قابل رؤیت باشد، سپس از ترکیب CTRL و کلیدهای جهت‌نما برای بازگرداندن آن به مرکز فریم استفاده کنید. حال دکمه پایینی را انتخاب کرده و همانند دکمه قبلی نام آن را btnExit و Label آن را برابر Exit تنظیم کنید. تغییرات را با دکمه Post (که آیکون آن شبیه یک تیک است) به فایل‌های محتوای کد ارسال کرده و برای مشاهده تغییرات برنامه را دوباره اجرا کنید. ظاهر برنامه شما باید همانند شکل ۳ باشد. اکنون برنامه را ببندید. 

رویدادها

به احتمال برای شما هم تعجبی نداشته است که دکمه Exit هنوز کار نمی‌کند و عملیات بستن برنامه را باید با دکمه Close نوار عنوان برنامه انجام دهید. غالب برنامه‌های مبتنی بر GUI از سیستم هدایت رویداد (Event Driven) استفاده می‌کنند. در این روش، برنامه به‌صورت مداوم رویدادهای سیستم را نظیر کلیک‌ها، ضربه‌های کلید، حرکات ماوس، تغییر زمان و…  بررسی می‌کند و اگر با رویدادی مواجه شود که برای آن عملیاتی تعریف شده باشد، آن عملیات را به اجرا در خواهد آورد، پس دلیل کار نکردن دکمه‌های برنامه ما این است که هنوز عملکردی را به رویداد کلیک آن‌ها نسبت نداده‌ایم.

 برای نسبت دادن عملکردهای مناسب به دکمه‌ها، فریم اصلی برنامه را در Designer باز کرده، سپس دکمه بالایی را انتخاب کرده و در قاب Inspector به زبانه Evts مراجعه کنید. روی ButtonEvent کلیک کرده، سپس روی wx.EVT_BUTTON دوبار کلیک کنید. دقت کنید که اکنون در قسمت زیرین عبارت OnBtnShowNewButton ظاهر خواهد شد (شکل‌‌۴). سپس این روال را برای دکمه Exit اجرا کرده و اطمینان حاصل کنید که عبارت OnBtnExitButton در قسمت زیرین بخش Evts قاب Inspector به نمایش درآمده است. تغییرات را Post کرده و فایل‌ها را ذخیره کنید. پس از آن به قاب Editor رفته و به قسمت انتهایی کد مربوط به FarmeMain مراجعه کنید.

در این‌صورت باید دو «متدی» را که به تازگی برای دکمه‌ها ساخته‌اید، ببینید. اکنون زمان آن رسیده که به سراغ فریم دوم برویم. فریم FramwSecond را که در ابتدای کار ساخته بودید، در Designer باز کرده و نام آن را به FrameSecond و عنوان آن را به Second Frame تنظیم کنید. به احتمال دیگر می‌دانید که خاصیت Name اسمی است که ما در کدهایمان برای ارجاع به اشیا از آن استفاده می‌کنیم و Label یا Title عنوانی است که روی شیء و برای کاربر نمایش داده می‌شود. اندازه فریم را به ۱۸۰ ×۴۰۰ و وضعیت Centered را روی wx.BOTH تنظیم کنید. یک دکمه wx.BUTTON به فرم اضافه کرده و آن را در وسط قسمت پایینی فریم قرار دهید. نام این دکمه را به btnFSExit و Label آن را به Exit تبدیل کنید و در نهایت مانند دکمه‌های قبلی، یک رویداد کلیک برای آن تعریف کنید. حال یک کنترل از نوع wx.StaticText به بخش بالایی فریم اضافه کرده و نام آن را به stHiThere و Label آن را به «Hi There . . . I›m the second frame !» تبدیل کنید. با مراجعه به زبانه Props و برداشتن تیک کنار Fonts  فونت این برچسب متنی را به Sans با اندازه ۱۴ و Weight آن را به wxBOLD تنظیم کنید. حال این نوشته را درست به وسط قسمت بالایی فریم ببرید. برای این کار می‌توانید در قسمت Position از زبانه Constr با تنظیم مقادیر X و Y محل این متن را تعیین کنید. فریم شما باید همانند شکل ۵ باشد.

چسباندن اجزا

حال که ظاهر اجزای مختلف برنامه را آماده کرده‌ایم، زمان آن رسیده تا چسبی را که تمام این اجزا را به هم متصل می‌کند، به‌وجود آوریم. در قاب Editor روی زبانه GUI2 کلیک کنید و در قسمت زیرین زبانه Source را انتخاب کنید. در زیر خطی که دستور Import  FrameMain را در خود دارد، خطی دیگر با دستور import FrameSecond اضافه کنید. تغییرات را ذخیره کرده و حالا زبانه FrameMain را فعال کنید و در زیر خط محتوای دستور import wx شما نیز خط زیر را اضافه کنید:

 import FrameSecond
اکنون کد را به سمت پایین پیمایش کنید تا خط زیر را بیابید. 
def __init__(self,parent):
در زیر خط محتوای دستور
self._init_ctrls(parent)
 شما نیز خطی را با دستور زیر وارد کنید.
self.Fs=FrameSecond.FrameSecond(self)
حال در زیر بخش تعریف توابع کلیک، یعنی
 def OnBtnShowNewButton(self,event) 
با قرار دادن یک علامت # دستور ()event.Skip را به کامنت تبدیل کنید و دو خط زیر را به ادامه آن بیافزایید.
self.Fs.Show()
self.Hide()
در انتها و در قسمت مربوط به متد OnBtnExitButton دوباره دستور event.Skip() را به کامنت تبدیل کرده و خط زیر را اضافه کنید:
self.Close()

چرا؟

اما تمام این‌ها برای چیست؟ در ابتدا ما باید اطمینان می‌یافتیم که برنامه ما «می‌داند» که ما قصد داریم از دو فرم استفاده کنیم و به همین دلیل بود که با دستور import هر دو فریم FrameMain و FrameSecond را در فایل GUI2 وارد کردیم. پس از آن دوباره با دستور import FrameSecond ارجاعی به فریم دوم را در کدهای FrameMain ایجاد کردیم تا بعدها بتوانیم از آن استفاده کنیم. به عبارت دیگر، می‌خواستیم FrameMain هم از وجود FrameSecond آگاه شود. در بخش _init_ ما برای راحتی کار، متغیری به نام Fs تعریف کردیم که محتوای فریم FrameSecond است. پس از  آن و در متد مربوط به کلیک دکمه ShowNew را تعریف کردیم که در صورت کلیک شدن این دکمه، فریم دوم نمایش داده شده و فریم اول یا اصلی مخفی شود. در آخر هم تعیین کردیم که با کلیک دکمه Exit برنامه بسته شود.

حال به سراغ کدهای فریم FrameSecond می‌رویم. تغییراتی که باید در این کدها اعمال شود به نسبت اندک است. در قسمت مربوط به متد __init__ خطی مانند زیر اضافه کنید:

self.parent=parent
این کار متغیری به نام  parent  ایجاد می‌کند که به فرم والد FrameSecond (فریمی که آن را صدا زده است) اشاره می‌کند. پس از آن در زیر متد مربوط به رویداد کلیک روی دکمه FSExit دستور event.Skip() را به کامنت تبدیل کرده و دو خط زیر را اضافه کنید:
self.parent.Show()
self.Hide()
حتماً به خاطر دارید که ما هنگام نمایش FrameSecond فریم اصلی، یعنی FrameMain را مخفی کردیم. به همین دلیل، هنگام بسته شدن FrameSecond باید دوباره FrameMain  را (که با نام parent معرفی شده بود) دوباره به نمایش درآوریم. حال برنامه را اجرا کنید. اگر همه چیز به درستی پیش رفته باشد، شما باید بتوانید با کلیک دکمه btnShowNew فریم اصلی را مخفی و فریم دوم را ظاهر کنید و با کلیک دکمه Exit در فریم دوم، به حالت قبل بازگردید. دکمه Exit در فریم اول هم تمام برنامه را خواهد بست.

قوانین نام‌گذاری

پیش‌تر گفته بودیم که درباره قوانین نام‌گذاری بیشتر صحبت خواهیم کرد. با نام‌گذاری درست کنترل‌های یک برنامه، کد شما خود به خود مستند‌سازی خواهد شد. به عبارت دیگر، با استفاده از نام‌های درست درک سازوکار برنامه و عملکرد بخش‌های مختلف آن برای سایر «افراد» (استفاده‌کنندگان، ویرایش‌کنندگان یا توسعه دهندگان همکار) ساده‌تر خواهد شد. اگر شما نام‌های پیش‌فرض کنترل‌ها نظیر StaticText1، button1 یا هر چیز دیگری را بپذیرید، در حین ساخت یک فرم پیچیده که شامل تعداد زیادی متن و دکمه و… است، به یقین با مشکل و سردرگمی مواجه خواهید شد. تازه این به شرطی است که شما تنها کسی باشید که با کد سروکار دارید. اگر کسی پس از شما قصد ادامه کار با این کد را داشته باشد، مشکل چندین برابر خواهد شد. بنابراین، پیشنهاد می‌شود که برای برطرف کردن این مشکل از نام‌گذاری دو قسمتی استفاده کنید. بخش اول، باید نوع کنترل را مشخص کند و بخش دوم باید به‌صورت خلاصه عملکرد آن را بیان کند. نام‌هایی که ما در این برنامه استفاده کردیم، نظیر btnExit یا FrameSecond نمونه‌هایی از این سیستم هستند. دو بخش نام‌ها می‌توانند با یک “_” از یکدیگر جدا شوند یا تنها با کوچک و بزرگ نوشتن حروف اول هر بخش.

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

بیشتر بدانید ...

Python for Data Science

این دوره برای فراگرفتن نحوه استفاده از ابزارهای قدرتمند منبع بازی (open-source) همچون: Python,Pandas,Git,Matplotlib که در تجزیه و تحلیل و تجسم مجموعه داده های پیچیده استفاده میشوند، می باشد

درباره این دوره

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

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

python

jupyter notebooks

pandas

numpy

matplotlib

git

و بسیاری از ابزارهای دیگر و همچنین خواهید آموخت:

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

شما این ابزارها را در زمینه حل مسائل علمی اطلاعات خواهید آموخت.

 

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

 

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

ملاقات با مربیان

بیشتر بدانید ...

پردازش در حوزه فرکانس

بیشتر بدانید ...

آموزش پایتون به زبان ساده قسمت پنجم

آموزش کار با زبان برنامه‌نویسی پایتون (بخش پنجم)

آموزش پایتون به زبان ساده

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

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

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

  PyGTK:
این جعبه ابزار در واقع wrapper یا پوسته‌ای است که به دور ابزار گرافیکی GTK+ پیچیده می‌شود تا آن را برای پایتون قابل استفاده سازد. ابزار GTK+ خود مادر تمام برنامه‌ها و پنجره‌های میزکار Gnome است و برنامه‌های ساخته شده با PyGTK هم دقیقاً ظاهری همانند برنامه‌های میزکار Gnome خواهد داشت. برای این جعبه ابزار، IDE خاصی وجود ندارد، اما طراحی ظاهر برنامه و فرم‌های آن برمبنای این جعبه ابزار (بدون امکان ویرایش یا ایجاد کد) توسط برنامه‌هایی نظیر Glade و Gazpacho در میزکار Gnome امکان‌پذیر است.

  PyQt: 
این جعبه ابزار نیز wrapper یا پوسته‌ای است که به دور ابزار گرافیکی Qt پیچیده می‌شود تا آن را برای پایتون قابل استفاده سازد. ابزار Qt ابزاری است که کل میزکار KDE بر مبنای آن بنا شده است و برنامه‌های تولید شده با PyQT نیز دقیقاً ظاهری همانند برنامه‌های میزکار KDE خواهد داشت. برای کار با این جعبه ابزار می‌توانید از IDE قدرتمند eric  در میزکار KDE استفاده کنید.
  wxPython:
این جعبه ابزار براساس wxWidget ساخته شده و یکی از قدرتمندترین جعبه ابزارهای طراحی رابط بصری است. مهم‌ترین مزیت آن مستقل بودن از پلتفرم و ظاهر بومی برنامه‌های تولید شده با آن است. IDE قدرتمند Boa Constructor یکی از بهترین گزینه‌ها برای توسعه رابط بصری کاربر با زبان پایتون است که در مطالب این قسمت و قسمت بعدی نیز از همین برنامه استفاده خواهد شد.
نصب ابزارها
همان‌طور که به احتمال متوجه شده‌اید، برای ادامه این مبحث به Boa Constructor  و WxPython نیاز خواهیم داشت. برای نصب آن‌ها به Software Center اوبونتو رفته و از طریق بخش‌های Developer Tools و پس از آن Graphic Interface Design نرم‌افزار Boa Constructor را نصب کنید. معمولاً انتخاب این بسته برای نصب، به نصب خود به خود WxPython نیز منجر خواهد شد. همچنین می‌توانید در خط فرمان دستورات زیر را تایپ کنید:

sudo apt-get install boa-constructor
sudo apt-get install python-wxversion

در هر دو حالت پس از وارد کردن گذرواژه سیستم، دانلود و نصب نرم‌افزارها آغاز خواهد شد. پس از اتمام کار نصب از طریق منوی Application، سپس گزینه Programming برنامه Boa Constructor را اجرا کنید. ظاهر برنامه پس از اجرا همانند شکل ۱ خواهد بود.

همان‌گونه که مشاهده می‌کنید این برنامه از سه پنجره یا به اصطلاح فریم تشکیل شده است. قاب یا فریم بالایی قاب ابزار یا Tool Frame نامیده می‌شود. قاب سمت چپ پایینی، قاب بازرسی یا Inspector Frame و قاب سمت راست پایین، قاب ویرایشگر یا Editor Frame است. قاب ابزار زبانه‌های متعددی مانند New، Container/Layout و… دارد. از این قاب می‌توانید برای ایجاد پروژه‌های جدید، افزودن قاب یا پنجره به پروژه‌‌های موجود یا افزودن کنترل‌های مختلف به قاب‌ها استفاده کنید. قاب بازرسی پس از افزودن قاب‌ها و کنترل‌های مختلف به پروژه بسیار مورد استفاده قرار خواهد گرفت. به‌صورت معمول این قاب ساختار درختی و روابط بین کنترل‌های مختلف را به ما نشان خواهد داد و در نهایت قاب ویرایشگر، امکان ویرایش کد، ذخیره پروژه و کارهایی از این قبیل را فراهم خواهد کرد. برای شروع کار ما ابتدا به سراغ قاب ابزارها خواهیم رفت. در زبانه New گزینه‌های مختلفی برای شروع کار وجود دارد اما در این بخش ما تنها از دکمه‌های پنجم و ششم، یعنی wx.App و wx.Frame استفاده خواهیم کرد. آیتم نخست، یعنی wx.App امکان ساخت یک پروژه کامل را فراهم می‌کند که از دو فایل Frame و Application تشکیل شده است و خود Boa این دو فایل را نیز به‌صورت خودکار تولید می‌کند. دکمه دوم یا wx.Frame امکان افزودن یک فرم به پروژه موجود را فراهم می‌کند. پر کاربردترین ابزارها در زبانه دوم یا Container/Layout ابزار wx.Panel (اولین آیتم از سمت چپ) و انواع مختلف کنترل کننده اندازه یا Sizer (دکمه‌های دوم تا ششم از سمت راست) هستند. در زبانه Basic Controls شما کنترل‌های متداول نظیر جعبه متن، جعبه چک، کنترل‌های لیست و… را مشاهده خواهید کرد و زبانه Utilities نیز برای دسترسی به ابزارهای منو و تایمر مورد استفاده قرار خواهد گرفت.
قبل از شروع کار با Boa لازم است به دو نکته کوچک، اما مهم توجه کنید. نخست این‌که برخی کنترل‌ها در پنجره طراحی یا Designer قابل جابه‌جایی نیستند. در صورت روبه‌رو شدن با چنین مشکلی، پس از انتخاب آن‌ها از ترکیب کلیدهای Ctrl و جهت‌نما برای حرکت دادن آن‌ها استفاده کنید. نکته دیگر این‌که هنگام قرار دادن یک کنترل از جنس panel روی یک فریم، پنل به سادگی دیده نخواهد شد. در این‌صورت به دنبال مربع‌های کوچک سیاه رنگی روی فریم بگردید یا از طریق قاب بازرسی و زبانه اشیا یا Objs این کنترل را انتخاب کنید.

شروع کار
برای مرحله اول، در قاب ابزار و در زبانه New دکمه wx.App را کلیک کنید تا یک پروژه جدید ایجاد شود. در این حالت دو زبانه جدید یکی با نام *(App1)* دیگری با نام *(Frame1)* به قاب ویرایشگر شما اضافه خواهد شد. مناسب‌ترین اقدام در این زمان ذخیره کردن پروژه ایجاد شده است. این کار را از زبانه *(Frame1)* آغاز می‌کنیم. در قاب ویرایشگر، دکمه Save را بزنید و این فایل را در یک پوشه دلخواه با نام Frame1.py ذخیره کنید. همان‌طور که مشاهده می‌کنید نام زبانه به Frame1 تغییر خواهد کرد. علامت‌های *()* به معنای ذخیره نشدن تغییرات زبانه جاری است. همین کار را برای زبانه *(App1)* نیز انجام دهید. 

 در قاب ویرایشگر به غیر از دکمه Save چندین دکمه مهم دیگر نیز وجود دارد که یکی از آن‌ها دکمه Run Application (به شکل یک مثلث زرد رنگ) برای اجرای برنامه است. در حال حاضر، حتی بدون یک خط کدنویسی نیز برنامه شما قابل اجرا است. با زدن همین دکمه شما می‌توانید نتیجه اجرای برنامه (که یک پنجره ساده و خالی است) را ببینید. در صورتی‌که شما در حال ویرایش یک فایل مربوط به یک قاب یا فریم باشید (همانند Frame 1) دکمه‌های دیگری نیز به نوار ابزارها افزوده می‌شود که مهم‌ترین آن‌ها دکمه Frame Designer است (برای یافتن نام هر یک از دکمه‌ها، نشانگر ماوس را روی آن‌ها برده و کمی صبر کنید(. فشردن این دکمه شمارا به حالت طراحی می‌برد که در این وضعیت می‌توانید ظاهر فرم موردنظر را به دلخواه و با استفاده از ابزارهای گرافیکی تغییر دهید. روی این دکمه کلیک کنید تا با ظاهری همانند شکل ۲ روبه‌رو شوید.

فرم نمایش داده شده در واقع بستری است که می‌توانید کنترل‌های دلخواه خود را به آن اضافه کنید. نخستین آیتمی که باید به فرم اضافه کنید، یک کنترل از نوع پنل است. یک رسم نانوشته در توسعه رابط‌های گرافیکی وجود دارد که شما را از قرار دادن مستقیم هر کنترلی به‌جز پنل روی یک فریم منع می‌کند. پس در قاب ابزارها به زبانه Container/Layout بروید. روی دکمه wx.Panel  وسپس در محل دلخواهی از فریم کلیک کنید. اگر کار را به درستی انجام داده باشید، فریم ۱ باید به صورت شکل ۳ دارای تعدادی مربع سیاه رنگ کوچک باشد.
همان‌طور که پیش‌تر هم هشدار داده بودیم، خطوط بدنه پنل دیده نمی‌شود و برای ویرایش و جابه‌جایی آن باید به دنبال این ۸ مربع کوچک بگردید. برای تغییر اندازه پنل می‌توانید از این مربع‌ها استفاده کنید. در این تمرین ما می‌خواهیم پنل تمام سطح فریم را پوشش دهد. فریم را کمی کوچک‌تر و پنل را اندکی بزرگ‌تر کنید تا پنل تمام سطح فریم را پوشش دهد. حال پنلی در اختیار داریم که سایر کنترل‌ها روی آن قرار داده خواهند شد. اگر فریم را کمی جابه جا کنید، خواهید دید که دو دکمه جدید به نوار ابزار قاب ویرایشگر اضافه شده است. یکی به شکل یک تیک و با نام Post  و دیگری به شکل ضربدر با نام Cancel.
کلیک دکمه Post باعث می‌شود تا از حالت Design خارج شوید و تغییرات اعمال شده در فریم به صورت کدهای پایتون به فایل آن منتقل شود. البته هنوز وظیفه ذخیره کردن فایل به عهده خود شما است. دکمه Post دیگری هم روی قاب بازرسی دیده می‌شود که بعدها به آن خواهیم پرداخت. دکمه Post را کلیک کنیدو پس از آن  دوباره به حالت Design برگردید و در قاب ابزارها به زبانه دکمه‌ها یا Buttons مراجعه کنید. روی نخستین دکمه سمت راست (wx.Button) کلیک و آن را جایی تقریباً در مرکز فریم قرار دهید.در این حالت فریم شما باید شبیه شکل ۴ باشد. همانند پنل، ۸ مربع کوچک برای تغییر اندازه دکمه در اطراف آن وجود دارد. اگر برای جابه‌جا کردن دکمه با مشکل مواجه شدید، براساس توضیح داده شده، از ترکیب کلیدهای Ctrl و جهت‌نما استفاده کنید.

اکنون زمان آن رسیده که به سراغ قاب بازرسی برویم. در حالی‌که کنترل دکمه در حالت انتخاب است، به سراغ این قاب و زبانه Constr می‌رویم. در این قسمت می‌توانید مشخصات و خواص کنترل انتخاب شده را ویرایش کنید. فعلاً نام کنترل دکمه را به btnShowDialog و برچسب یا Label آن را به Click Me! تغییر دهید. ظاهر زبانه Constr باید همانند شکل ۵ باشد.

ما به بقیه تنظیمات این زبانه کاری نداریم و به طور مستقیم به سراغ زبانه Objs می‌رویم. در این زبانه شما تمام کنترل‌های استفاده شده و روابط والد و فرزندی آن‌ها را مشاهده خواهید کرد. همان‌گونه که در شکل ۶ مشاهده می‌کنید، کنترل دکمه فرزند پنل و پنل خود فرزند فریم است. با زدن دکمه Post در قاب بازرسی تغییرات را به فایل اعمال کرده و آن را ذخیره کنید. دوباره به حالت Design بازگشته و به زبانه Objs از قاب بازرسی مراجعه کنید. اگر فریم انتخاب نشده است آن را انتخاب کرده و به زبانه Constr بروید. در آنجا عنوان فریم را به My First GUI تغییر دهید. تغییرات را Post کرده، سپس فایل را ذخیره کنید. 

در ادامه با استفاده از مثلث زرد رنگ Run Application برنامه را اجرا کنید. فرمی همانند شکل ۷ ظاهر خواهد شد، اما کلیک دکمه وسط فرم، هیچ عکس‌العملی ایجاد نخواهد کرد، زیرا ما هنوز هیچ عملکردی را به آن دکمه نسبت نداده‌ایم. برای این کار ما باید یک رویداد یا Event را تعریف کرده و به دکمه نسبت بدهیم. پنجره فعلی را بسته و دوباره به حالت Design بروید. پس از کلیک و انتخاب دکمه، به زبانه Evts در قاب بازرسی مراجعه کنید. از لیست سمت چپ ButtonEvent را انتخاب کرده و از لیست سمت راست wx.EVT_BUTTON را دوبار کلیک کنید. همان‌گونه که در شکل‌ ۸  مشاهده می‌کنید، در زیر پنجره رویدادی با نام OnBtnShowDialog ساخته شده است. تغییرات را Post و ذخیره کنید. در پایین‌ترین قسمت قاب ویرایشگر باید تابعی با نام OnBtnShowDialog ساخته شده باشد. کاری که اکنون می‌خواهیم انجام دهیم، فراخوانی یک جعبه متن یا MessageBox است که متنی را برای ما به نمایش درآورد. در اینجا ما از تابع داخلی wx.MessageBox  استفاده می‌کنیم. در قاب ویرایشگرکدهای زیر را در یک خط جایگزین event.Skip() کنید:
wx.MessageBox(“You clicked the button !” , “Info”,wx.ICON_QUESTION)

تغییرات را ذخیره کرده و با مثلث زردرنگ برنامه را اجرا کنید. این بار کلیک دکمه وسط فرم باید پیغامی همانند شکل ۹ را به نمایش درآورد. توجه کنید که آیکون علامت سؤال ممکن است با توجه به تنظیمات ظاهر سیستم شما شکل متفاوتی داشته باشد. در تابع MessageBox سه آرگومان وارد شده به ترتیب عبارتند از، متن پیغام، عنوان پنجره پیغام و نوع آیکون مورد استفاده. برای تنظیم آیکون گزینه‌های دیگری نظیر wx.ICON_EXCLAMATION ، wx.ICON_INFORMATION و wx.ICON_ERROR را نیز در اختیار دارید که می‌توانید آن‌ها را نیز به سادگی امتحان کنید.

این مثال در عین سادگی، نخستین برنامه کامل شما بر مبنای یک رابط بصری بود. در قسمت بعدی با امکانات wxPython و Boa Constructor  بیشتر  آشنا خواهیم شد و نمونه‌های پیچیده‌تری را پیاده خواهیم کرد.

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

بیشتر بدانید ...

ساده ترین راه آموزش پایتون

برنامه نویسی , کاربردی , کامپیوتر , مهندسی

اگر به فکر یادگیری پایتون هستید، احتمال دارد فرآیند راه‌اندازی و آماده‌سازی سیستم به این منظور به حدی برای‌تان پیچیده و کسالت‌آور باشد که در میانه کار به صورت کلی از آن منصرف شوید. پیش از هر چیز لازم است پایتون را روی کامپیوتر خود نصب کنید، سپس یاد بگیرید که چطور با خطوط دستور کد‌ها را پردازش نمایید، نحوه‌ی بهره‌گیری از «Interactive Shell» را فرا بگیرید و بیاموزید که چطور یک IDE پایتون را تنظیم و آماده‌ی استفاده کنید.

حال ناگفته نماند که به جای طی کردن فرآیند پیچیده‌ی بالا می‌توانید در گام نخست و برای آغاز یادگیری به سراغ یک «پوسته‌ی تعاملی آنلاین» (Online Interactive Shell) بروید و هیچ‌یک از دردسرهایی که گفته شد را تحمل نکنید. منظور از پوسته‌ی تعاملی آنلاین، در اصل وبسایت‌هایی هستند که به شما اجازه می‌دهند کدهای پایتون را در آنها نوشته، بلافاصله اجرایشان کنید و نتیجه‌ی حاصله را ببینید. وقتی از چنین سرویس‌هایی استفاده می‌کنید دیگر نیاز به نصب هیچ ابزاری روی رایانه نیست و تنها یک مرورگر وب کار شما را راه می‌اندازد؛ در ادامه قصد داریم به تعدادی از بهترین سایت‌ها در زمینه‌ی ذکر شده بپردازیم.

یکی از مهم‌ترین دلایل برتری «Python Anywhere» نسبت به دیگر ابزارهای مشابه، پشتیبانی این فضا از «IPython» است. IPython به عنوان جایگزین پیشرفته‌تر «مفسر» (interpreter) پیش‌فرض پایتون شناخته می‌شود. با Python Anywhere امکانات جذابی در اختیار شما قرار می‌گیرد؛ مثلاً می‌توانید بخش کوچکی از حروف یک دستور را نوشته و با فشردن کلید Tab آن را کامل کنید یا متغیرها و متدهای یک آبجکت را در لحظه و به صورت یکجا ببینید.

البته شاید هیچ‌یک از امکاناتی که در بالا به آنها اشاره شد برای یک فرد کاملاً مبتدی ضروری نباشند، و اگر شما نیز در همین سطح هستید توصیه می‌کنیم چند هفته‌ای را به مطالعه و فراگیری مباحث پایه پرداخته و سپس به سراغ تمرین در محیط Python Anywhere بیائید؛ محیطی که به منظور آموزش با راندمان بسیار بالا طراحی و پیاده‌سازی شده است.

ابن ابزار کاملا مناسب کاربرانی با تجربه‌ی قبلی برنامه‌نویسی اما در زبان‌هایی به جز پایتون است. رابط کاربری «Python Fiddle» بسیار ساده و راحت طراحی شده. اما مهم‌ترین مزیت آن در ارائه‌ی تعداد زیادی نمونه کد با قابلیت استفاده آسان محسوب می‌شود. با بهره‌گیری از نوار ابزار سمت چپ، تعدادی از نکات و ترفند‌های جذاب پایتون را فرا خواهید گرفت. همچنین امکان نوشتن کد شخصی، اجرا و دیدن نتایج در پایین صفحه وجود دارد.

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

«Repl.it» از «REPL» با ترکیب حروف اول عبارت «Read-Eval-Print Loop» به معنای همان پوسته‌ی تعاملی، ساخته شده است. این ابزار بسیاری از زبان‌ها مانند «Python 2.x» یا «Python 3.x» را پشتیبانی می‌کند. به همین دلیل اگر حتی علاقه‌ای به استفاده از پایتون ندارید، امکان یادگیری C#، جاوا، «روبی» (Ruby) یا «Lua» و حتی «ES6» در این محیط وجود دارد.

یکی از جذاب‌ترین ویژگی‌های این سرویس امکان اعمال تغییرات گسترده به دلخواه کاربر است. کاربر می‌تواند رنگ پس‌زمینه‌، اندازه‌ی فونت و شیوه‌ی چیدمان تورفتگی کدها را تغییر دهد یا قابلیت «کامل‌ کردن خودکار» (autocomplete) را فعال نماید. رابط کاربری بسیار ساده است. همچنین اگر در Repl.it حساب کاربری بسازید، امکان ذخیره کدها و فراخوانی‌شان در آینده وجود دارد.

«Trinket» یکی از دیگر گزینه‌های قدرتمندی است که در اختیار دارید؛ بسیاری از ویژگی‌های این سرویس مانند سایر سرویس‌هایی هستند که در بالا به آنها پرداختیم، با این حال دو مزیت منحصر به فرد را می‌توان برای Trinket‌ قائل شد. اولین مزیت اینکه با استفاده از رابط کاربری آن که از زبانه‌ها پشتیبانی به عمل می‌آورد می‌توانید به صورت همزمان چندین اسکرپیت را باز و اجرا کنید. مزیت دوم هم قابلیت جاسازی – embed – کردن زبانه‌های سرویس مورد بحث در صفحات سایت کاربر است.

ناگفته نماند که اگر بخواهید از Trinket‌ به صورت رایگان استفاده کنید، تنها قادر هستید بر مبنای Python 2.x در آن کد بنویسید. برای بهره‌گیری از Python 3.x به صورت کامل، باید هزینه‌ای را به صورت ماهیانه یا سالیانه بپردازید و اشتراک غیر رایگان تهیه کنید.

«Ideone» به عنوان یک ابزار عمومی برای تمام زبان‌های برنامه‌نویسی طراحی شده است. به دلیل این‌که این سرویس آموزشی ویژه‌ی یک زبان نیست، امکانات پیشرفته‌ای ارائه نمی‌کند. جالب است بدانید Ideone از بیش از ۶۰ زبان پشتیبانی می‌نماید و امکان دسته‌بندی کد به صورت شخصی، سری و عمومی وجود دارد.

نوشتن کد در این ابزار محدودیت‌هایی به شرح زیر ایجاد می‌کند.

  • بیشینه‌ی ۱۰ ثانیه برای تفسیر / کامپایل
  • بیشینه‌ی ۵ یا ۱۵ ثانیه عملیات اجرا (به ترتیب برای کاربران مهمان یا ثبت‌نام شده)
  • حداکثر ۲۵۶ مگابایت رم برای اجرای کد در اختیار خواهید داشت
  • عدم اتصال به اینترنت و عدم امکان ایجاد فایل‌های جدید

در کل Ideone گزینه‌ای مناسب برای آزمایش سریع یک کد در هر زبانی است. اگر مایلید تخصصی‌تر کار خود را دنبال کنید، بهتر است دنبال گزینه‌های دیگر معرفی شده در بالا بروید.

«Python Tutor» گرچه یک پوسته‌ی تعاملی پایتون نیست، به محض نوشتن، کد را تحلیل و تصویری از منطق آن ارائه می‌کند. در نتیجه با به پایان رسیدن هر خط دستور، امکان دیدن نتایج از ابتدا تا انتها وجود دارد.

این سرویس برای تازه‌کاران یک هدیه‌ی ویژه است. امکان مشاهده‌ی تاثیر هر دستور بر متغیر‌ها و دیگر موارد کار یپدا کردن باگ‌ها و رفع آنها را بسیار ساده کرده. ضمناً اگر بخواهیم صادق باشیم، باید بگوئیم با این ابزار بیش از هر سرویس دیگری با منطق زبان پایتون آشنا خواهید شد و آن را درک خواهید کرد.

شاید متوجه شوید که Python Tutor به یک حالت آزمایشی «برنامه‌نویسی زنده» (Live Programming) مجهز است. به این معنی که به محض نوشتن، دستور تحلیل و به روز رسانی می‌گردد.

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

بیشتر بدانید ...