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

پایتون چیست؟

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

مفسر پایتون

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

برای استفاده از مفسر پایتون، می‌توانید ترمینال یا خط فرمان خود را باز کرده و دستور python یا python3 را وارد کنید. این کار محیط تعاملی پایتون، موسوم به REPL (Read-Eval-Print Loop)، را فعال می‌کند که در آن می‌توانید به صورت زنده کدها را وارد و اجرا نمایید. این امر به خصوص برای آزمایش قطعات کد، دیباگ کردن یا یادگیری مفاهیم جدید بسیار مفید است.

Hello World در پایتون

یکی از سنت‌های رایج در یادگیری هر زبان برنامه‌نویسی جدید، نوشتن برنامه‌ی "Hello World" است. این برنامه ساده، دروازه‌ای به دنیای برنامه‌نویسی با زبان مورد نظر و در این مورد، پایتون است.

print("Hello, World!")

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

سینتکس (Syntax) پایتون

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

if 5 > 2:
   print("Five is greater than two!")

در این مثال، if یک شرط بررسی می‌کند و اگر شرط درست باشد، خط داخل بلوک تورفتگی (indented block) اجرا می‌شود.

کامنت‌ها (Comments)

کامنت‌گذاری در کدها امری مهم است و به شما و دیگر برنامه‌نویسان کمک می‌کند تا منطق کد را راحت‌تر درک کنید. در پایتون، کامنت‌ها با استفاده از # نوشته می‌شوند و هر متنی که پس از این نماد بیاید توسط مفسر نادیده گرفته می‌شود:

# This is a comment
print("Hello, World!")  
# This prints Hello, World to the console

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

متغیرها (Variables)

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

تعریف متغیر

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

x = 5
y = "Hello, World!"

در اینجا، x یک متغیر عددی است که عدد 5 را نگه‌داری می‌کند و y یک متغیر رشته‌ای است که متن "Hello, World!" را در خود دارد.

چاپ متغیرها

برای دیدن محتوای متغیرها، می‌توان از تابع print استفاده کرد:

print(x)  # 5
print(y)  # Hello, World!

نمونه‌های پیچیده‌تر

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

# Mathematical Operations
a = 10
b = 20
c = a + b
print(c)  # 30
# Strings
first_name = "Loghman"
last_name = "Avand"
full_name = first_name + " " + last_name
print(full_name)  # Loghman Avand
# Lists
numbers = [1, 2, 3, 4, 5]
print(numbers)  # [1, 2, 3, 4, 5]
# Dictionaries
person = {"name": "Alice", "age": 25}
print(person)  # {'name': 'Alice', 'age': 25}

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

نوع داده‌ها (Data Types)

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

• انواع عددی: int (اعداد صحیح) و float (اعداد اعشاری).
• متنی: str برای نگهداری رشته‌های متنی.
• بولین: bool که مقادیر منطقی True و False را دارد.
• لیست: list یک مجموعه مرتب که می‌تواند انواع داده‌ها را شامل شود.
• تاپل: tuple مشابه لیست است اما غیرقابل تغییر.
• ست: set مجموعه‌ای از عناصر منحصر به فرد و بدون ترتیب.
• دیکشنری: dictionary شامل جفت‌های کلید-مقدار برای ذخیره داده‌ها.
  مثال‌هایی از این داده‌ها:

integer = 10
floating_point = 10.5
string = "Hello"
boolean = True
list = [1, 2, 3, 4.5, 'Python']
tuple = (1, 2, 3, 4.5, 'Python')
set = {1, 2, 3, 4.5, 'Python'}
dictionary = {'name': 'Alice', 'age': 30}

اعداد (Numbers)

پایتون با انواع عددی مختلفی کار می‌کند. این انواع شامل اعداد صحیح (int) و اعداد اعشاری (float) است. به این نمونه نگاه کنید:

x = 5    # int
y = 5.0  # float
print(x)
print(y)

Casting در پایتون

Casting به تبدیل نوع داده‌ای به نوع دیگر گفته می‌شود. پایتون این امکان را فراهم می‌کند تا به صورت صریح داده‌ها را از یک نوع به نوع دیگر تبدیل کنید:

x = int(2.8)  # 2
y = float("3")  # 3.0
z = str(2)  # '2'
print(x, y, z)

Casting در پایتون به شما این امکان را می‌دهد که تایپ داده‌های خود را برای عملیات‌های خاص به طور صریح تعیین کنید، مانند تبدیل یک رشته به عدد برای محاسبات ریاضی یا نمایش یک عدد به صورت متنی در خروجی.

رشته‌ها (Strings)

رشته‌ها یکی از انواع داده‌های پرکاربرد در پایتون هستند و برای ذخیره‌سازی و مدیریت داده‌های متنی استفاده می‌شوند. در پایتون، رشته‌ها می‌توانند با استفاده از نقل قول تکی (') یا دوگانه (") ایجاد شوند و هیچ تفاوتی در استفاده از این دو نوع نقل قول وجود ندارد. این امکان به شما اجازه می‌دهد تا با انعطاف بیشتری متن خود را تعریف کنید:

a = "Hello"
b = 'World'
print(a, b)  # Hello World

ترکیب رشته‌ها

یکی از عملیات‌های رایج با رشته‌ها، ترکیب آن‌ها یا همان concatenation است. این کار با استفاده از عملگر + انجام می‌شود:

greeting = "Hello"
name = "Alice"
message = greeting + " " + name + "!"
print(message)  # Hello Alice!

فرمت‌بندی رشته‌ها

پایتون امکانات فراوانی برای فرمت‌بندی رشته‌ها ارائه می‌دهد. از روش‌های قدیمی‌تر مانند % گرفته تا str.format() و فرمت‌بندی f-string که در پایتون 3.6 و بالاتر معرفی شد، می‌توانید داده‌ها را به شیوه‌ای خوانا در رشته‌ها جایگذاری کنید:

name = "Bob"
age = 25
print("My name is %s and I am %d years old." % (name, age))
print("My name is {} and I am {} years old.".format(name, age))
print(f"My name is {name} and I am {age} years old.")

دسترسی به کاراکترها و زیررشته‌ها

می‌توانید به کاراکترهای موجود در یک رشته با استفاده از اندیس دسترسی پیدا کنید و یا بخشی از رشته را با استفاده از slicing استخراج کنید:

text = "Hello, World!"
print(text[7])  # W
print(text[1:5])  # ello

متدهای کاربردی رشته‌ها

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

text = "hello world"
print(text.upper())  # HELLO WORLD
print(text.capitalize())  # Hello world
print(text.replace("hello", "goodbye"))  # goodbye world
print("world" in text)  # True

این متدها تنها نمونه‌هایی از قابلیت‌هایی هستند که رشته‌ها در پایتون برای تسهیل کار با متن ارائه می‌دهند. استفاده از این متدها به شما کمک می‌کند تا کد خود را کارآمدتر و خواناتر نویسید.

بولین (Boolean)

نوع داده‌ بولین (bool) در پایتون می‌تواند دو مقدار True یا False داشته باشد:

x = True
y = False
print(x, y)

لیست‌ها (Lists)

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

تعریف لیست

لیست‌ها با استفاده از براکت‌ها [] تعریف شده و عناصر آن‌ها با کاما , از یکدیگر جدا می‌شوند:

my_list = [1, 2, 3, "Python"]
print(my_list)  # [1, 2, 3, 'Python']

دسترسی به عناصر لیست

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

print(my_list[0])  # 1
print(my_list[3])  # 'Python'

تغییر دادن لیست‌ها

لیست‌ها قابل تغییر هستند، به این معنا که می‌توانید مقادیر آن‌ها را تغییر دهید:

my_list[1] = 'changed'
print(my_list)  # [1, 'changed', 3, 'Python']

افزودن و حذف عناصر

برای افزودن عناصر به لیست، می‌توانید از متدهای append() برای افزودن به انتهای لیست و insert() برای افزودن در مکان خاص استفاده کنید:

my_list.append("new item")
print(my_list)  
# [1, 'changed', 3, 'Python', 'new item']
my_list.insert(2, "inserted")
print(my_list)  
# [1, 'changed', 'inserted', 3, 'Python', 'new item']

برای حذف عناصر، می‌توانید از دستور del, متد remove() برای حذف عنصر مشخص یا pop() برای برداشتن عنصر از انتهای لیست استفاده کنید:

del my_list[1]
print(my_list)  # [1, 'inserted', 3, 'Python', 'new item']
my_list.remove('inserted')
print(my_list)  # [1, 3, 'Python', 'new item']
popped_item = my_list.pop()
print(popped_item)  # 'new item'
print(my_list)  # [1, 3, 'Python']

پیمایش لیست‌ها

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

for item in my_list:
   print(item)

مثال‌های پیشرفته‌تر

لیست‌ها می‌توانند برای پیاده‌سازی ساختارهای داده‌ای پیچیده‌تر مانند لیست‌های تودرتو استفاده شوند:

nested_list = [1, 2, [3, 4, 5], ["a", "b", "c"]]
print(nested_list[2][1])  # 4
print(nested_list[3][0])  # 'a'

این قابلیت‌ها پایتون را به ابزاری قدرتمند برای کار با داده‌های تودرتو و پیچیده تبدیل می‌کنند که در بسیاری از کاربردهای علم داده و برنامه‌نویسی وب مفید است.

تاپل‌ها (Tuples)

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

my_tuple = (1, 2, 3, "Python")
print(my_tuple)  # (1, 2, 3, 'Python')

مثال‌های دیگر از تاپل:

# Empty tuple
empty_tuple = ()
print(empty_tuple)  # ()
# Single element tuple (comma is required)
single_element_tuple = (4,)
print(single_element_tuple)  # (4,)
# Access tuple elements
print(my_tuple[0])  # 1
print(my_tuple[1:3])  # (2, 3)
#Attempting to change the tuple causes an error
#my_tuple[0] = 10 
#TypeError: 'tuple' object does not support item assignment

ست‌ها (Sets)

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

my_set = {1, 2, 3, "Python"}
print(my_set)  # {1, 2, 3, 'Python'}

مثال‌های بیشتر:

# Add element to set
my_set.add("new element")
print(my_set)  # {1, 2, 3, 'Python', 'new element'}
# Remove element
my_set.remove("Python")
print(my_set)  # {1, 2, 3, 'new element'}
# Delete all elements
my_set.clear()
print(my_set)  # set()

دیکشنری‌ها (Dictionaries)

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

my_dict = {"name": "John", "age": 30}
print(my_dict)  {'name': 'John', 'age': 30}

مثال‌های بیشتر:

# Add a new key-value pair
my_dict["location"] = "New York"
print(my_dict)  
# {'name': 'John', 'age': 30, 'location': 'New York'}
# Update available amount
my_dict["age"] = 31
print(my_dict)  
# {'name': 'John', 'age': 31, 'location': 'New York'}
# Delete a key and its value
del my_dict["location"]
print(my_dict)  # {'name': 'John', 'age': 31}
# Accessing elements with the get method
print(my_dict.get("name"))  # John

شرط‌ها (Conditions)

شرط‌ها در پایتون با استفاده از دستورات if, elif و else بررسی می‌شوند. این دستورات به برنامه اجازه می‌دهند که تصمیم‌گیری‌های مختلفی بر اساس شرایط معین انجام دهد:

x = 20
if x > 15:
   print("x is greater than 15")
elif x == 15:
   print("x is 15")
else:
   print("x is less than 15")

حلقه‌ها (Loops)

حلقه‌ها در پایتون برای اجرای تکراری دستورات به کار می‌روند و به برنامه‌نویس اجازه می‌دهند تا کدهایی با تعداد تکرار مشخص یا تا زمانی که شرط خاصی برقرار است اجرا شوند. پایتون دو نوع اصلی حلقه به نام‌های for و while دارد.

حلقه For

حلقه for در پایتون برای تکرار عملیات بر روی مواردی که قابل تکرار هستند (مانند لیست‌ها، رشته‌ها یا شی‌های تولید شده توسط تابع range) استفاده می‌شود. برای مثال:

for i in range(5):
   print(i)

این کد اعداد 0 تا 4 را چاپ می‌کند. تابع range(5) یک شی تکرار شونده تولید می‌کند که اعداد 0 تا 4 را شامل می‌شود. همچنین حلقه‌های for می‌توانند برای تکرار عملیات بر روی لیست‌ها و رشته‌ها نیز استفاده شوند:

words = ['apple', 'banana', 'cherry']
for word in words:
    print(word)
for char in "Hello":
    print(char)

حلقه While

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

i = 0
while i < 5:
   print(i)
   i += 1

این حلقه تا زمانی که i کمتر از 5 باشد ادامه می‌یابد و هر بار مقدار i را چاپ می‌کند و سپس آن را یک واحد افزایش می‌دهد. همچنین حلقه‌های while می‌توانند برای موقعیت‌هایی که تعداد دقیق تکرار‌ها مشخص نیست مفید باشند، به‌طور مثال حلقه زیر نمایش تمام توان‌های دو که کمتر از 1000 هستند را شامل می‌شود:

power = 1
while power < 1000:
    print(power)
    power *= 2

توابع (Functions)

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

تعریف یک تابع ساده

برای تعریف یک تابع، ابتدا کلمه def را نوشته، سپس نام تابع و پرانتزهایی که ممکن است شامل پارامترها باشد. بدنه تابع باید با یک تورفتگی (indentation) نوشته شود:

def greet(name):
    return "Hello " + name
print(greet("Alice"))  # Hello Alice
print(greet("Bob"))    # Hello Bob

پارامترهای تابع

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

def pow(base, exp=2):
   return base ** exp
print(pow(3, 3))  # 27
print(pow(3))     # 9

تشخیص عدد اول

توابع می‌توانند بسیار پیچیده‌تر از مثال‌های بالا باشند. به عنوان مثال، تابعی که چک کند آیا یک عدد اول است یا نه:

def is_prime(number):
    if number <= 1:
        return False
    for i in range(2, int(number**0.5) + 1):
        if number % i == 0:
            return False
    return True
print(is_prime(29))  # True
print(is_prime(30))  # False

توابع با پارامترهای متغیر

گاهی اوقات تعداد پارامترهایی که می‌خواهید به تابع بدهید ممکن است متغیر باشد. پایتون این مورد را با استفاده از *args (برای لیست‌ها) و **kwargs (برای دیکشنری‌ها) پشتیبانی می‌کند:

def print_args(*args, **kwargs):
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f"{key}: {value}")
print_args('apple', 'banana', fruit='orange'
, vegetable='carrot')
# OUTPUT:
# apple
# banana
# fruit: orange
# vegetable: carrot

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

آرایه‌ها (Arrays)

در پایتون، آرایه‌ها (Arrays) به طور مستقیم مانند زبان‌های برنامه‌نویسی دیگر مانند C یا Java پشتیبانی نمی‌شوند، ولی می‌توان با استفاده از لیست‌ها و کتابخانه‌هایی مانند NumPy و ماژول array استاندارد پایتون کارهای مشابهی انجام داد.

استفاده از ماژول array

ماژول array در پایتون برای ذخیره‌سازی آرایه‌هایی از داده‌های یکنواخت بهینه شده است و از نظر کارایی نسبت به لیست‌ها مزیت دارد، مخصوصاً برای آرایه‌های بزرگ:

from array import array
int_array = array('i', [1, 2, 3, 4, 5])
print(int_array)  # array('i', [1, 2, 3, 4, 5])

استفاده از کتابخانه NumPy

NumPy یک کتابخانه قدرتمند برای پایتون است که امکان کار با آرایه‌های بزرگ و چندبعدی را فراهم می‌کند. این کتابخانه برای محاسبات علمی و مهندسی بسیار مناسب است:

arr = np.array([1, 2, 3, 4, 5])
print(arr)  # [1 2 3 4 5]
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr_2d)  # [[1 2 3] [4 5 6]]

عملیات روی آرایه‌ها

هر دو ماژول، array و NumPy، امکانات مختلفی برای عملیات روی آرایه‌ها ارائه می‌دهند. در NumPy، می‌توانید عملیات ریاضیاتی پیچیده‌تری انجام دهید:

# Calculate the average
print(np.mean(arr))  # 3.0
# Total calculation
print(np.sum(arr))  # 15
# Transpose Array
print(np.transpose(arr_2d))  # [[1 4] [2 5] [3 6]]

انتخاب عناصر از آرایه

دسترسی به عناصر و برش‌دهی آرایه‌ها در هر دو ماژول امکان‌پذیر است:

print(arr[1])  # 2
print(arr[2:4])  # [3 4]

جمع‌بندی

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

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

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