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

۱. مدیریت اعضای لیست: فراتر از append

یاد گرفتیم که با `append()` یک آیتم به انتهای لیست اضافه کنیم. اما ابزارهای بسیار بیشتری برای مدیریت اعضا وجود دارد.

افزودن اعضا

• insert(index, value): یک آیتم را در اندیس مشخصی اضافه می‌کند.
• extend(iterable): اعضای یک لیست (یا هر شیء تکرارپذیر دیگر) را به انتهای لیست فعلی اضافه می‌کند.

fruits = ['apple', 'banana', 'cherry']
# اضافه کردن در اندیس 1
fruits.insert(1, 'orange')
print(f"After insert: {fruits}")

# اضافه کردن یک لیست دیگر به انتهای آن
more_fruits = ['mango', 'pineapple']
fruits.extend(more_fruits)
print(f"After extend: {fruits}")

حذف اعضا

• remove(value): اولین آیتم با مقدار مشخص شده را حذف می‌کند.
• pop(index): آیتم موجود در اندیس مشخص را حذف **و آن را برمی‌گرداند**. اگر اندیس ندهید، آیتم آخر را حذف می‌کند.
• clear(): تمام اعضای لیست را حذف کرده و آن را خالی می‌کند.

items = ['book', 'pen', 'pencil', 'pen']
items.remove('pen') # فقط اولین 'pen' حذف می‌شود
print(f"After remove: {items}")

removed_item = items.pop(1) # حذف 'pencil' در اندیس 1
print(f"After pop: {items}")
print(f"Removed item: {removed_item}")

items.clear()
print(f"After clear: {items}")

۲. برش‌دهی (Slicing): استخراج زیرلیست‌ها

برش‌دهی یک تکنیک فوق‌العاده قدرتمند برای انتخاب بخشی از یک لیست است. فرمت کلی آن list[start:stop:step] است.

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# از اندیس 2 تا قبل از 5
print(f"numbers[2:5] -> {numbers[2:5]}")

# از ابتدا تا قبل از اندیس 4
print(f"numbers[:4] -> {numbers[:4]}")

# از اندیس 6 تا انتها
print(f"numbers[6:] -> {numbers[6:]}")

# کل لیست با گام‌های 2 تایی
print(f"numbers[::2] -> {numbers[::2]}")

# معکوس کردن لیست
print(f"numbers[::-1] -> {numbers[::-1]}")

۳. مرتب‌سازی و کپی‌کردن

دو عملیات بسیار رایج که درک تفاوت‌های ظریف آن‌ها اهمیت زیادی دارد.

مرتب‌سازی: `sort()` در مقابل `sorted()`

grades = [88, 95, 72, 100, 85]
sorted_grades = sorted(grades)
print(f"Original list: {grades}")
print(f"New sorted list: {sorted_grades}")

grades.sort(reverse=True) # مرتب‌سازی نزولی خود لیست
print(f"Original list after .sort(): {grades}")

کپی کردن: ارجاع در مقابل کپی واقعی

این یکی از مفاهیم حیاتی در پایتون است. وقتی می‌نویسید list_b = list_a شما یک کپی جدید نمی‌سازید، بلکه فقط یک نام دیگر به همان لیست در حافظه می‌دهید.

original = [1, 2, 3]
reference_copy = original # این یک کپی نیست!
true_copy = original.copy() # روش صحیح کپی کردن

reference_copy.append(4)
print(f"Original list: {original}") # لیست اصلی هم تغییر کرد!
print(f"Reference copy: {reference_copy}")
print(f"True copy: {true_copy}") # این کپی دست نخورده باقی مانده

۱. تاپل (Tuple): لیستِ تغییرناپذیر

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

چگونه یک تاپل بسازیم؟

# یک تاپل شامل انواع داده مختلف
my_tuple = ("apple", 3.14, 100, True)
print(my_tuple)

# دسترسی به اعضا درست مانند لیست‌ها با اندیس
print(f"عضو اول: {my_tuple[0]}")
print(f"عضو آخر: {my_tuple[-1]}")

# تلاش برای تغییر یک عضو که با خطا مواجه می‌شود
# اگر این خط را از کامنت خارج کنید، برنامه خطا می‌دهد
# my_tuple[0] = "banana" 

چرا از تاپل استفاده کنیم؟

شاید بپرسید وقتی لیست وجود دارد، چرا به یک ساختار محدودتر نیاز داریم؟

• امنیت داده: وقتی می‌خواهید مطمئن باشید داده‌های شما در طول برنامه به هیچ وجه تغییر نمی‌کنند (مثلاً مختصات جغرافیایی یک نقطه یا روزهای هفته).
• کمی بهینه‌تر: پایتون می‌تواند تاپل‌ها را کمی سریع‌تر از لیست‌ها پردازش کند، چون ساختار ساده‌تری دارند.

۲. مجموعه (Set): کیسه‌ای از اعضای یکتا

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

چگونه یک مجموعه بسازیم؟

# ساخت یک مجموعه با اعضای تکراری
numbers_list = [1, 2, 3, 2, 4, 3, 5, 1]
unique_numbers_set = set(numbers_list)
print(f"لیست اولیه: {numbers_list}")
print(f"مجموعه ساخته شده (بدون تکرار): {unique_numbers_set}")

# افزودن و حذف کردن اعضا
unique_numbers_set.add(6)   # افزودن عدد 6
print(f"بعد از افزودن 6: {unique_numbers_set}")

unique_numbers_set.remove(1) # حذف کردن عدد 1
print(f"بعد از حذف 1: {unique_numbers_set}")

عملیات ریاضی روی مجموعه‌ها

قدرت واقعی مجموعه‌ها در انجام عملیات ریاضی مانند اجتماع، اشتراک و تفاضل است.

set_A = {1, 2, 3, 4}
set_B = {3, 4, 5, 6}

# Union (اجتماع: تمام اعضای هر دو مجموعه)
print(f"اجتماع A | B: {set_A | set_B}")

# Intersection (اشتراک: اعضای مشترک)
print(f"اشتراک A & B: {set_A & set_B}")

# Difference (تفاضل: اعضایی که در A هستند ولی در B نیستند)
print(f"تفاضل A - B: {set_A - set_B}")

۱. آناتومی یک دیکشنری: کلید و مقدار چیست؟

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

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

۲. مثال عملی: ساخت دیکشنری خودرو

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

Car = {
    "brand": "Ford",
    "model": "Mustang",
    "year": 1964,
    "colors": ["قرمز", "مشکی", "سفید"],
    "is_automatic": True
}

# دسترسی به مقادیر با استفاده از کلید
print(f"برند خودرو: {Car['brand']}")
print(f"سال ساخت: {Car['year']}")
print(f"رنگ‌های موجود: {Car['colors']}")

# دسترسی به یکی از رنگ‌ها (عضو دوم لیست)
print(f"دومین رنگ در لیست: {Car['colors'][1]}")

# افزودن یک زوج کلید-مقدار جدید
Car["engine"] = "V8"
print(f"دیکشنری بعد از افزودن موتور: {Car}")

# تغییر مقدار یک کلید موجود
Car["year"] = 1965
print(f"سال ساخت آپدیت شده: {Car['year']}")

۳. متدهای پرکاربرد دیکشنری

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

d = {'a': 1}; d.clear() # d becomes {}

d1 = {'a': 1}; d2 = d1.copy()

keys = ['a', 'b']; d = dict.fromkeys(keys, 0) # {'a': 0, 'b': 0}

d = {'a': 1}; print(d.get('a')); print(d.get('b', 'Not Found'))

d = {'a': 1, 'b': 2}; print(d.items()) # dict_items([('a', 1), ('b', 2)])

d = {'a': 1, 'b': 2}; print(d.keys()) # dict_keys(['a', 'b'])

d = {'a': 1, 'b': 2}; val = d.pop('a'); print(val) # 1

d = {'a': 1, 'b': 2}; item = d.popitem(); print(item) # ('b', 2)

d = {'a': 1}; d.setdefault('b', 2); print(d) # {'a': 1, 'b': 2}

d1 = {'a': 1}; d2 = {'b': 2}; d1.update(d2); print(d1)

d = {'a': 1, 'b': 2}; print(d.values()) # dict_values([1, 2])

۱. لیست‌های تودرتو (Nested Lists): ساخت ماتریس

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

# یک ماتریس ۳x۳
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# دسترسی به یک ردیف کامل (ردیف دوم با ایندکس ۱)
print(f"ردیف دوم ماتریس: {matrix[1]}")

# دسترسی به یک عنصر خاص (عنصر سوم از ردیف دوم)
# ایندکس اول برای ردیف (سطر) و ایندکس دوم برای ستون است
element = matrix[1][2]
print(f"عنصر در سطر ۱، ستون ۲: {element}")

# تغییر مقدار یک عنصر
matrix[0][0] = 99
print(f"ماتریس پس از تغییر: {matrix}")

۲. لیست دیکشنری‌ها (List of Dictionaries): پایگاه داده کوچک شما

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

users = [
    {
        "id": 1,
        "name": "علی رضایی",
        "email": "ali.rezaei@example.com"
    },
    {
        "id": 2,
        "name": "مریم احمدی",
        "email": "maryam.ahmadi@example.com"
    }
]

# دسترسی به کاربر اول (یک دیکشنری کامل)
first_user = users[0]
print(f"کاربر اول: {first_user}")

# دسترسی به نام کاربر دوم
second_user_name = users[1]["name"]
print(f"نام کاربر دوم: {second_user_name}")

# پیمایش و چاپ اطلاعات کاربران
print("\nلیست ایمیل کاربران:")
for user in users:
    print(f"- {user['email']}")

۳. دیکشنری‌های پیچیده: مدل‌سازی یک شیء کامل

گاهی یک دیکشنری به تنهایی می‌تواند حاوی لیست‌ها یا دیکشنری‌های دیگر به عنوان مقدار (value) باشد. این ساختار برای مدل‌سازی یک شیء واحد با جزئیات پیچیده و چندلایه عالی است.

student_profile = {
    "student_id": "S40510",
    "full_name": "سارا کریمی",
    "major": "مهندسی نرم‌افزار",
    "courses": ["مبانی برنامه‌نویسی", "ساختمان داده", "طراحی الگوریتم"],
    "contact": {
        "email": "sara.k@university.ac.ir",
        "phone": "09120001122"
    }
}

# دسترسی به لیست درس‌ها
courses_list = student_profile["courses"]
print(f"لیست دروس: {courses_list}")

# دسترسی به دومین درس
second_course = student_profile["courses"][1]
print(f"دومین درس: {second_course}")

# دسترسی به ایمیل دانشجو (دسترسی به مقدار در دیکشنری تودرتو)
email = student_profile["contact"]["email"]
print(f"ایمیل: {email}")

# اضافه کردن یک درس جدید به لیست
student_profile["courses"].append("هوش مصنوعی")
print(f"لیست دروس آپدیت شده: {student_profile['courses']}")

وظایف شما (Tasks)

بر اساس صورت مسئله، کد پایتون را بنویسید که مراحل زیر را انجام دهد:

1. گام اول: ساخت ساختار داده
   • یک دیکشنری اصلی به نام course_data بسازید.
   • برای اطلاعات اصلی دوره (کد و واحد) از یک تاپل استفاده کنید.
   • برای اطلاعات استاد از یک دیکشنری تودرتو استفاده کنید.
   • برای لیست دانشجویان از یک لیست تودرتو که هر عضو آن یک دیکشنری است، استفاده کنید.
   • برای تگ‌ها از یک مجموعه (Set) استفاده کنید.
2. گام دوم: دسترسی به داده‌ها
   • کد دوره را از ساختار داده استخراج و چاپ کنید.
   • ایمیل استاد را چاپ کنید.
   • نام دانشجوی دوم را چاپ کنید.
3. گام سوم: اصلاح و افزودن داده
   • یک دانشجوی جدید با شماره دانشجویی "S9903" و نام "نگار محمودی" به لیست دانشجویان اضافه کنید.
   • تگ "علوم کامپیوتر" را به مجموعه تگ‌ها اضافه کنید.
   • ایمیل استاد را به "h.akbari@university.edu" تغییر دهید.
4. گام چهارم (چالش): پیمایش و گزارش‌گیری
   • با استفاده از یک حلقه، لیستی از تمام شماره‌های دانشجویی (`student_id`) ثبت‌نام شده در کلاس را استخراج کرده و چاپ کنید.

۲. عملگرهای انتسابی (Assignment Operators)

این عملگرها برای تخصیص (مقداردهی) یک مقدار به یک متغیر استفاده می‌شوند. علاوه بر عملگر ساده $=$, عملگرهای ترکیبی نیز وجود دارند که یک عملیات محاسباتی را با انتساب ترکیب می‌کنند.

x = 10
print(f"مقدار اولیه x: {x}")

x += 3  # معادل است با: x = x + 3
print(f"بعد از += 3: {x}")

x -= 4  # معادل است با: x = x - 4
print(f"بعد از -= 4: {x}")

x *= 2  # معادل است با: x = x * 2
print(f"بعد از *= 2: {x}")

x /= 3  # معادل است با: x = x / 3
print(f"بعد از /= 3: {x}")

۳. عملگرهای مقایسه‌ای (Comparison Operators)

این عملگرها دو مقدار را با هم مقایسه کرده و نتیجه را به صورت یک مقدار بولی (True یا False) برمی‌گردانند. این عملگرها در ساختارهای کنترلی مانند if بسیار پرکاربرد هستند.

x = 10
y = 12

print(f"{x} == {y} is {x == y}")  # برابر
print(f"{x} != {y} is {x != y}")  # نابرابر
print(f"{x} > {y} is {x > y}")    # بزرگتر
print(f"{x} < {y} is {x < y}")    # کوچکتر
print(f"{x} >= 10 is {x >= 10}") # بزرگتر یا مساوی
print(f"{y} <= 10 is {y <= 10}") # کوچکتر یا مساوی

۴. عملگرهای منطقی (Logical Operators)

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

x = 5
y = 10

# and: هر دو شرط باید درست باشند
print(f"({x} > 3) and ({y} < 15) is {(x > 3) and (y < 15)}") 

# or: حداقل یکی از شرط‌ها باید درست باشد
print(f"({x} > 10) or ({y} < 15) is {(x > 10) or (y < 15)}")

# not: نتیجه عبارت بولی را معکوس می‌کند
print(f"not({x} > 3) is {not(x > 3)}")

۵. عملگرهای هویتی (Identity Operators)

این عملگرها برای مقایسه هویت دو شیء به کار می‌روند، یعنی بررسی می‌کنند که آیا دو متغیر به یک شیء یکسان در حافظه اشاره دارند یا خیر. این با عملگر == که محتوای دو شیء را مقایسه می‌کند، متفاوت است.

list_a = ["apple", "banana"]
list_b = ["apple", "banana"]
list_c = list_a

# is: آیا دو متغیر به یک شیء یکسان اشاره دارند؟
print(f"list_a is list_b: {list_a is list_b}")  # False, چون دو شیء مجزا در حافظه هستند
print(f"list_a is list_c: {list_a is list_c}")  # True, چون c فقط نام دیگری برای list_a است

# is not: آیا دو متغیر به اشیاء متفاوتی اشاره دارند؟
print(f"list_a is not list_b: {list_a is not list_b}")

# مقایسه محتوا با ==
print(f"list_a == list_b: {list_a == list_b}")  # True, چون محتوای آنها یکسان است

۶. عملگرهای عضویت (Membership Operators)

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

my_list = ["apple", "banana", "cherry"]
my_dict = {"name": "Ali", "age": 30}

# in: آیا مقدار در دنباله وجود دارد؟
print(f"'banana' in my_list is {'banana' in my_list}")
print(f"'orange' in my_list is {'orange' in my_list}")
print(f"'name' in my_dict is {'name' in my_dict}") # در دیکشنری‌ها، عضویت در کلیدها بررسی می‌شود

# not in: آیا مقدار در دنباله وجود ندارد؟
print(f"'orange' not in my_list is {'orange' not in my_list}")

اضافه کردن else (در غیر این صورت...)

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

بلوک else فقط زمانی اجرا می‌شود که شرط if برقرار نباشد.

مثال: تکمیل سناریوی رای دادن

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

age = 15

if age >= 18:
    print("شما مجاز به رای دادن هستید.")
else:
    print("متاسفانه شما هنوز به سن قانونی برای رای دادن نرسیده‌اید.")

print("بررسی صلاحیت به پایان رسید.")

مثال عملی: تشخیص زوج یا فرد بودن عدد

یکی از کاربردهای کلاسیک if...else، تشخیص زوج یا فرد بودن یک عدد با استفاده از عملگر باقی‌مانده (%) است. اگر باقی‌مانده تقسیم یک عدد بر ۲ برابر با صفر باشد، آن عدد زوج است.

number = 17

# بررسی باقی‌مانده تقسیم بر 2
if number % 2 == 0:
    print(f"عدد {number} زوج است.")
else:
    print(f"عدد {number} فرد است.")

نکته حیاتی: خروجی `input()` همیشه یک رشته (string) است!

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

مثال: تلاش برای انجام محاسبات روی ورودی

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

age_str = input("سن خود را وارد کنید: ")

# تلاش برای جمع کردن یک رشته با یک عدد
result = age_str + 5 
print(result)

سن خود را وارد کنید: 25
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
TypeError: can only concatenate str (not "int") to str

راه حل: تبدیل نوع داده (Type Casting)

برای حل مشکل بالا، باید رشته دریافت شده از input() را به نوع داده عددی مورد نظر (مانند int برای عدد صحیح یا float برای عدد اعشاری) تبدیل کنیم. این کار با استفاده از توابعی به همین نام‌ها انجام می‌شود.

# دریافت سن به صورت رشته
age_str = input("سن خود را وارد کنید: ")

# تبدیل رشته به عدد صحیح (integer)
age_num = int(age_str)

# حالا محاسبات به درستی انجام می‌شود
future_age = age_num + 5
print(f"شما 5 سال دیگر {future_age} ساله خواهید شد.")

سن خود را وارد کنید: 25
شما 5 سال دیگر 30 ساله خواهید شد.

روش خلاصه‌تر

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

# دریافت و تبدیل نوع در یک خط
height = float(input("قد خود را به متر وارد کنید (مثال: 1.75): "))
print(f"قد شما {height} متر است.")

مثال کامل: یک محاسبه‌گر ساده سن

بیایید تمام مفاهیم را در یک برنامه کوچک ترکیب کنیم که سال تولد کاربر را گرفته و سن تقریبی او را محاسبه می‌کند.

# 1. دریافت نام کاربر (رشته)
name = input("نام شما چیست؟ ")

# 2. دریافت سال تولد و تبدیل به عدد
birth_year = int(input("در چه سالی (میلادی) به دنیا آمده‌اید؟ "))

# 3. سال فعلی (برای سادگی فرض می‌کنیم 2026 است)
current_year = 2026

# 4. محاسبه سن
age = current_year - birth_year

# 5. نمایش نتیجه نهایی
print(f"سلام {name}! شما تقریباً {age} سال سن دارید.")

نام شما چیست؟ سارا
در چه سالی (میلادی) به دنیا آمده‌اید؟ 1995
سلام سارا! شما تقریباً 31 سال سن دارید.

ویژگی‌های کلیدی و قوانین ساختار شرطی

بر اساس درخواست دقیق شما، بیایید قوانین این ساختار را مرور کنیم:

• شروع همیشه با if است: یک زنجیره شرطی همیشه و فقط با یک دستور if آغاز می‌شود.
• تعداد دلخواه elif: شما می‌توانید هر تعداد elif که نیاز دارید (از صفر تا بی‌نهایت) در زنجیره خود داشته باشید تا تمام حالات ممکن را پوشش دهید.
• دستور else اختیاری در انتها: می‌توانید یک دستور else در انتهای زنجیره داشته باشید تا به عنوان یک حالت "پیش‌فرض" یا "catch-all" عمل کند. این دستور کاملاً اختیاری است.
• اجرای فقط یک بلوک: مهم‌ترین نکته این است که در کل زنجیره if/elif/else، حداکثر یک بلوک کد اجرا خواهد شد؛ یعنی اولین بلوکی که شرط آن برقرار باشد.

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

بر اساس قوانینی که گفتیم، شما می‌توانید ساختارهای شرطی مختلفی بسازید:

1. فقط if

برای انجام یک کار فقط در صورت برقراری یک شرط خاص و نادیده گرفتن آن در غیر این صورت.

temperature = 32
if temperature > 30:
    print("هوا گرم است، یک لیوان آب خنک بنوشید.")
# اگر شرط برقرار نباشد، هیچ اتفاقی نمی‌افتد

2. ساختار if...else

برای انتخاب بین دو مسیر انحصاری.

is_logged_in = False
if is_logged_in:
    print("به داشبورد خود خوش آمدید.")
else:
    print("لطفاً ابتدا وارد حساب کاربری خود شوید.")

3. ساختاری که با elif تمام می‌شود (بدون else)

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

command = "start"

if command == "start":
    print("سرویس در حال اجرا شدن است...")
elif command == "stop":
    print("سرویس متوقف شد.")
elif command == "restart":
    print("سرویس در حال راه‌اندازی مجدد است...")
# اگر command مقداری غیر از اینها باشد، هیچ پیامی چاپ نمی‌شود

کد کامل راه‌حل

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

# یک لیست خالی برای ذخیره اطلاعات کاربر
user_data = []

print("--- به سیستم ثبت نام خوش آمدید ---")

# --- مرحله 1: ثبت نام ---
full_name = input("نام و نام خانوادگی خود را وارد کنید: ")
age = input("سن خود را وارد کنید: ")
username_reg = input("یک نام کاربری برای خود انتخاب کنید: ")
password_reg = input("یک رمز عبور قوی انتخاب کنید: ")

# افزودن اطلاعات به لیست
user_data.append(full_name)
user_data.append(age)
user_data.append(username_reg)
user_data.append(password_reg)

print("\nثبت نام با موفقیت انجام شد! اکنون وارد شوید.")
print("------------------------------------------")

# --- مرحله 2: ورود ---
print("\n--- لطفاً برای ورود اطلاعات خود را وارد کنید ---")
username_login = input("نام کاربری: ")
password_login = input("رمز عبور: ")

# --- مرحله 3: بررسی و اعتبارسنجی ---

# ابتدا بررسی می‌کنیم که ورودی‌ها خالی نباشند
if username_login == "" or password_login == "":
    print("\nخطا: نام کاربری و یا رمز عبور نمی‌تواند خالی باشد.")

# سپس اطلاعات را با داده‌های ذخیره شده در لیست مقایسه می‌کنیم
# نام کاربری در خانه شماره 2 و رمز عبور در خانه شماره 3 لیست است
elif username_login == user_data[2] and password_login == user_data[3]:
    print(f"\nورود موفق! سلام {user_data[0]}، خوش آمدید!")
    
# اگر هیچ‌کدام از شرایط بالا برقرار نبود
else:
    print("\nخطا: نام کاربری یا رمز عبور اشتباه است.")

--- به سیستم ثبت نام خوش آمدید ---
نام و نام خانوادگی خود را وارد کنید: علی رضایی
سن خود را وارد کنید: 28
یک نام کاربری برای خود انتخاب کنید: ali_re
یک رمز عبور قوی انتخاب کنید: Python123

ثبت نام با موفقیت انجام شد! اکنون وارد شوید.
------------------------------------------

--- لطفاً برای ورود اطلاعات خود را وارد کنید ---
نام کاربری: ali_re
رمز عبور: Python123

ورود موفق! سلام علی رضایی، خوش آمدید!

تجزیه و تحلیل کد

ترتیب منطقی شرط‌ها

ما از ساختار if/elif/else استفاده کردیم تا منطق را به درستی پیاده کنیم:

1. if: اولین و مهم‌ترین بررسی، خالی نبودن فیلدهاست. اگر کاربر چیزی وارد نکند، برنامه نباید اصلاً به سراغ مقایسه برود.
2. elif: تنها در صورتی که شرط اول (خالی بودن) برقرار نباشد، این شرط اجرا می‌شود و مقایسه اصلی را انجام می‌دهد.
3. else: اگر ورودی‌ها خالی نبودند (شرط if رد شده) و با اطلاعات ما نیز مطابقت نداشتند (شرط elif رد شده)، پس حتماً اطلاعات اشتباه وارد شده‌اند.

حلقه for روی چه چیزهایی کار می‌کند؟ (Iterables)

حلقه for می‌تواند روی هر شیء "قابل پیمایش" (Iterable) کار کند. بیایید چند نمونه رایج را ببینیم:

۱. پیمایش روی رشته (String)

حلقه for کاراکتر به کاراکتر روی رشته حرکت می‌کند.

for char in "Python":
    print(char)

۲. پیمایش روی دیکشنری (Dictionary)

به صورت پیش‌فرض، حلقه for روی کلیدهای دیکشنری پیمایش می‌کند. اما می‌توانیم مقادیر یا جفت‌های کلید-مقدار را نیز پیمایش کنیم.

student = {
    "name": "Sara",
    "course": "Computer Science",
    "id": 987
}

# پیمایش روی کلیدها (پیش‌فرض)
print("--- Keys ---")
for key in student:
    print(key)

# پیمایش روی مقادیر با .values()
print("\n--- Values ---")
for value in student.values():
    print(value)
    
# پیمایش روی جفت‌های کلید-مقدار با .items()
print("\n--- Items ---")
for key, value in student.items():
    print(f"{key}: {value}")

ایجاد دنباله‌های عددی با تابع range()

اگر بخواهیم یک قطعه کد را به تعداد مشخصی تکرار کنیم، تابع range() بهترین ابزار ماست. این تابع یک دنباله از اعداد تولید می‌کند.

• range(stop): اعدادی از 0 تا یکی کمتر از stop تولید می‌کند.
• range(start, stop): اعدادی از start تا یکی کمتر از stop.
• range(start, stop, step): اعدادی از start تا stop با گام‌های step.

# چاپ اعداد 0 تا 4
for i in range(5):
    print(i, end=" ") # end=" " باعث می‌شود خروجی در یک خط باشد

print("\n--------------------")

# چاپ اعداد 2 تا 6
for i in range(2, 7):
    print(i, end=" ")
    
print("\n--------------------")

# چاپ اعداد زوج از 0 تا 10
for i in range(0, 11, 2):
    print(i, end=" ")

کنترل پیشرفته جریان حلقه

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

دستور break (شکستن حلقه)

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

numbers = [1, 5, 8, -3, 10, 12]

# پیدا کردن اولین عدد منفی و توقف
for num in numbers:
    if num < 0:
        print("اولین عدد منفی پیدا شد:", num)
        break # از حلقه خارج شو
    print("بررسی عدد:", num)

دستور continue (پرش به تکرار بعدی)

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

# چاپ فقط اعداد فرد
for i in range(1, 11):
    if i % 2 == 0: # اگر عدد زوج بود
        continue   # این دور را رد کن و به سراغ عدد بعدی برو
    print(i)

بلوک else در حلقه for

یک قابلیت جالب در پایتون این است که حلقه `for` می‌تواند یک بلوک `else` داشته باشد. این بلوک تنها در صورتی اجرا می‌شود که حلقه به صورت کامل و طبیعی (بدون برخورد به `break`) به پایان برسد.

my_list = [1, 3, 5, 7]
search_item = 8

for item in my_list:
    if item == search_item:
        print(f"آیتم {search_item} پیدا شد.")
        break
else:
    # این کد فقط زمانی اجرا می‌شود که حلقه تمام شود و break رخ ندهد
    print(f"آیتم {search_item} در لیست وجود ندارد.")

خطرناک‌ترین تله: حلقه‌های بی‌نهایت (Infinite Loops)

نمونه یک حلقه بی‌نهایت (این کد را با احتیاط اجرا کنید)

i = 1
while i > 0:
    print("این پیام تا ابد چاپ می‌شود...")
    # چون مقدار i هرگز تغییر نمی‌کند، شرط i > 0 همیشه True است

اگر برنامه‌تان در یک حلقه بی‌نهایت گیر کرد، در اکثر ترمینال‌ها و محیط‌های برنامه‌نویسی می‌توانید با فشردن کلیدهای Ctrl + C اجرای آن را متوقف کنید.

چه زمانی از `while` به جای `for` استفاده کنیم؟

قانون کلی این است:

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

کاربرد ۱: اعتبارسنجی ورودی کاربر (Input Validation)

این یکی از رایج‌ترین کاربردهای حلقه `while` است. ما می‌خواهیم از کاربر ورودی بگیریم و تا زمانی که ورودی معتبری وارد نکرده، این کار را تکرار کنیم.

user_input = ""

while user_input.lower() != "yes":
    user_input = input("آیا با قوانین موافق هستید؟ (yes/no): ")

print("عالی! شما موافقت کردید.")

آیا با قوانین موافق هستید؟ (yes/no): maybe
آیا با قوانین موافق هستید؟ (yes/no): no
آیا با قوانین موافق هستید؟ (yes/no): OK
آیا با قوانین موافق هستید؟ (yes/no): yes
عالی! شما موافقت کردید.

کاربرد ۲: حلقه‌های بازی (Game Loops)

در بسیاری از بازی‌ها، حلقه اصلی بازی تا زمانی که کاربر بازی را ترک نکرده یا شرایط باخت/برد محقق نشده، ادامه پیدا می‌کند. مثلاً در یک بازی حدس عدد، حلقه تا زمانی که عدد درست حدس زده نشده، تکرار می‌شود.

کنترل پیشرفته جریان در حلقه `while`

درست مانند حلقه `for`، در حلقه `while` نیز می‌توانیم از دستورات `break`, `continue` و بلوک `else` استفاده کنیم.

`break`, `continue`, و `else` در `while`

منطق این دستورات دقیقاً مشابه حلقه `for` است:

• break: حلقه را فوراً متوقف می‌کند.
• continue: دور فعلی حلقه را متوقف کرده و به ابتدای حلقه (بررسی شرط) می‌پرد.
• else: تنها زمانی اجرا می‌شود که حلقه به صورت طبیعی (با False شدن شرط) به پایان برسد و نه با دستور break.

# مثالی ترکیبی
# برنامه یک عدد از کاربر می‌گیرد. اگر منفی بود، آن را نادیده می‌گیرد
# اگر صفر بود، متوقف می‌شود. در غیر این صورت، آن را چاپ می‌کند

print("اعداد مثبت را وارد کنید (برای خروج 0 را وارد کنید):")
while True: # یک حلقه که به ظاهر بی‌نهایت است
    num_str = input("> ")
    if not num_str.isdigit():
        print("لطفا فقط عدد وارد کنید.")
        continue # به ابتدای حلقه برگرد

    num = int(num_str)
    
    if num == 0:
        break # حلقه را بشکن
    
    print(f"شما عدد {num} را وارد کردید.")

print("برنامه تمام شد.")

مثال کاربردی: ساخت یک منوی ساده

فرض کنید می‌خواهیم برنامه‌ای بنویسیم که یک منو را به کاربر نمایش می‌دهد و منتظر دستور او می‌ماند. این برنامه باید تا زمانی که کاربر صراحتاً گزینه "خروج" را انتخاب نکرده، به کار خود ادامه دهد.

while True:
    print("\n--- منوی اصلی ---")
    print("1. نمایش پیام خوشامدگویی")
    print("2. محاسبه توان دو یک عدد")
    print("q. خروج از برنامه")

    choice = input("لطفا گزینه خود را انتخاب کنید: ")

    if choice == '1':
        print("\n*** سلام! به برنامه ما خوش آمدید. ***")
    elif choice == '2':
        num_str = input("عددی را برای محاسبه توان دو وارد کنید: ")
        if num_str.isdigit():
            num = int(num_str)
            print(f"\n*** توان دوی عدد {num} برابر است با {num ** 2} ***")
        else:
            print("\n*** ورودی نامعتبر! لطفاً فقط عدد وارد کنید. ***")
    elif choice.lower() == 'q':
        print("\n*** از برنامه خارج شدید. خدانگهدار! ***")
        break  # نقطه خروج اصلی از حلقه
    else:
        print("\n*** گزینه نامعتبر! لطفا دوباره تلاش کنید. ***")

--- منوی اصلی ---
1. نمایش پیام خوشامدگویی
2. محاسبه توان دو یک عدد
q. خروج از برنامه
لطفا گزینه خود را انتخاب کنید: 1

*** سلام! به برنامه ما خوش آمدید. ***

--- منوی اصلی ---
1. نمایش پیام خوشامدگویی
2. محاسبه توان دو یک عدد
q. خروج از برنامه
لطفا گزینه خود را انتخاب کنید: 2
عددی را برای محاسبه توان دو وارد کنید: 5

*** توان دوی عدد 5 برابر است با 25 ***

--- منوی اصلی ---
1. نمایش پیام خوشامدگویی
2. محاسبه توان دو یک عدد
q. خروج از برنامه
لطفا گزینه خود را انتخاب کنید: q

*** از برنامه خارج شدید. خدانگهدار! ***

چرا این الگو اینقدر مفید است؟

شاید بپرسید چرا از یک متغیر "پرچم" (flag) استفاده نکنیم؟ مثلاً:

running = True
while running:
    choice = input("> ")
    if choice == 'q':
        running = False
    else:
        # process other choices
        pass

while True:
    choice = input("> ")
    if choice == 'q':
        break
    else:
        # process other choices
        pass

هر دو روش کار می‌کنند، اما الگوی while True چندین مزیت دارد:

• خوانایی و صراحت (Clarity): نیت شما کاملاً روشن است. while True یعنی "این حلقه قرار است برای همیشه اجرا شود" و if ... break دقیقاً نشان می‌دهد که نقطه خروج کجاست.
• انعطاف‌پذیری (Flexibility): شما می‌توانید چندین شرط break در نقاط مختلف حلقه داشته باشید. این کار مدیریت شرط‌های خروج پیچیده را بسیار آسان‌تر می‌کند.
• کد کمتر (Less Boilerplate): شما نیازی به تعریف و مدیریت یک متغیر پرچم اضافی (مانند `running`) ندارید. کد شما کوتاه‌تر و مستقیم‌تر می‌شود.

کاربردهای رایج دستور `pass`

استفاده از `pass` یک تکنیک استاندارد در طول فرآیند توسعه نرم‌افزار است.

۱. طراحی ساختار توابع و کلاس‌ها

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

# تعریف ساختار کلی برنامه بدون پیاده‌سازی جزئیات

def connect_to_database(db_name):
    # TODO: کد اتصال به دیتابیس را اینجا بنویس
    pass

def get_user_data(user_id):
    # TODO: منطق دریافت اطلاعات کاربر
    pass

class UserProfile:
    # TODO: تعریف مشخصات و متدهای کاربر
    pass

استفاده از کامنت‌هایی مانند # TODO در کنار pass یک روش بسیار خوب برای یادآوری کارهایی است که باید در آینده انجام دهید.

۲. جای خالی در شرط‌ها و حلقه‌ها

گاهی در یک زنجیره if/elif/else، می‌دانید که باید یک شرط خاص را در نظر بگیرید، اما هنوز نمی‌خواهید برای آن کدی بنویسید.

user_role = "guest"

if user_role == "admin":
    # کدهای مربوط به ادمین
    print("دسترسی کامل")
elif user_role == "editor":
    # هنوز برای نقش ویرایشگر تصمیمی نگرفته‌ایم
    pass
else:
    print("دسترسی محدود")

۳. نادیده گرفتن استثناها (با احتیاط!)

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

try:
    # تلاش برای حذف فایلی که ممکن است وجود نداشته باشد
    import os
    os.remove("temporary_file.tmp")
except FileNotFoundError:
    # اگر فایل وجود نداشت، اشکالی ندارد. هیچ کاری نکن.
    pass

تفاوت کلیدی: `pass` در مقابل `continue`

یک اشتباه رایج، یکی دانستن `pass` و `continue` است. این دو دستور کاملاً متفاوت هستند:

• pass: یک پرکننده جای خالی است. هیچ کاری نمی‌کند و مفسر به سادگی به خط بعدی کد در همان بلوک می‌رود.
• continue: فقط در حلقه‌ها (`for` و `while`) معنا دارد. اجرای دور فعلی حلقه را متوقف کرده و به ابتدای حلقه می‌پرد تا دور بعدی را شروع کند.

مثال مقایسه‌ای

بیایید اعداد ۰ تا ۴ را پیمایش کنیم و ببینیم این دو دستور چه تأثیری روی عدد ۲ دارند.

for i in range(5):
    if i == 2:
        pass # هیچ اتفاقی نمی‌افتد
    print(i)

for i in range(5):
    if i == 2:
        continue # به ابتدای حلقه بپر
    print(i)

کد کامل بازی

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

# 1. وارد کردن کتابخانه مورد نیاز برای تولید عدد تصادفی
import random

# 2. تولید یک عدد صحیح تصادفی بین 1 و 100 و ذخیره آن
# این کار فقط یک بار و قبل از شروع حلقه انجام می‌شود
secret_number = random.randint(1, 100)
guess_count = 0

print("به بازی حدس اعداد خوش آمدید!")
print("من یک عدد بین 1 تا 100 انتخاب کرده‌ام. آیا می‌توانی آن را حدس بزنی؟")

# 3. استفاده از الگوی while True برای تکرار بازی تا زمان حدس درست
while True:
    # 4. دریافت حدس از کاربر به صورت رشته
    user_guess_str = input("\nحدس خود را وارد کنید: ")
    guess_count += 1 # افزایش شمارنده حدس‌ها

    # 5. اعتبارسنجی ورودی: آیا ورودی کاربر فقط از اعداد تشکیل شده؟
    if user_guess_str.isdigit():
        # اگر بله، آن را به عدد صحیح تبدیل کن
        user_guess_num = int(user_guess_str)
    else:
        # اگر نه، یک پیام خطا بده و با continue به ابتدای حلقه برگرد
        print("خطا: لطفاً فقط عدد وارد کنید!")
        continue

    # 6. مقایسه حدس کاربر با عدد مخفی
    if user_guess_num < secret_number:
        print("عدد من بزرگتر است! دوباره تلاش کن.")
    elif user_guess_num > secret_number:
        print("عدد من کوچکتر است! دوباره تلاش کن.")
    else:
        # اگر حدس درست بود
        print(f"🎉 تبریک می‌گویم! شما برنده شدید! عدد مخفی {secret_number} بود.")
        print(f"شما در {guess_count} تلاش موفق شدید.")
        break # 7. شکستن حلقه و پایان بازی

به بازی حدس اعداد خوش آمدید!
من یک عدد بین 1 تا 100 انتخاب کرده‌ام. آیا می‌توانی آن را حدس بزنی؟

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

حدس خود را وارد کنید: 75
عدد من کوچکتر است! دوباره تلاش کن.

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

حدس خود را وارد کنید: 68
عدد من کوچکتر است! دوباره تلاش کن.

حدس خود را وارد کنید: 65
🎉 تبریک می‌گویم! شما برنده شدید! عدد مخفی 65 بود.
شما در 5 تلاش موفق شدید.

تجزیه و تحلیل کد

• مرحله ۱ و ۲: با import random ابزار لازم را فراهم کرده و با random.randint(1, 100) یک عدد مخفی فقط برای یک بار قبل از شروع بازی ایجاد می‌کنیم. متغیر `guess_count` هم برای شمردن تعداد تلاش‌ها صفر می‌شود.
• مرحله ۳: حلقه while True بازی را در یک وضعیت تکرار مداوم قرار می‌دهد. این حلقه تنها زمانی متوقف می‌شود که دستور break اجرا شود.
• مرحله ۵: این بخش بسیار حیاتی است. چون input() همیشه رشته برمی‌گرداند، ما نمی‌توانیم مستقیماً آن را با عدد مقایسه کنیم. ابتدا با متد .isdigit() چک می‌کنیم که آیا رشته ورودی شامل کاراکترهای عددی است یا خیر. اگر نبود، با continue از ادامه اجرای کد در این دور صرف‌نظر کرده و به ابتدای حلقه می‌پریم تا دوباره از کاربر ورودی بگیریم.
• مرحله ۶: این قلب تپنده منطق بازی است. با یک زنجیره if/elif/else، حدس کاربر را با عدد مخفی مقایسه کرده و پیام مناسب را چاپ می‌کنیم.
• مرحله ۷: اگر کاربر عدد را درست حدس بزند (بلوک else)، پیام موفقیت‌آمیز چاپ شده و دستور break حلقه while را می‌شکند و برنامه به پایان می‌رسد.

کد کامل بازی

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

import random

# 1. تنظیمات اولیه بازی
words = ["پایتون", "برنامه", "کامپیوتر", "توسعه", "کتابخانه", "متغیر"]
secret_word = random.choice(words)
lives = 6
guessed_letters = []
# ایجاد لیستی از خط تیره به طول کلمه مخفی
display_word = ["_" for _ in secret_word]

print("به بازی حدس کلمه خوش آمدید!")
print("کلمه مورد نظر", len(secret_word), "حرف دارد.")

# 2. حلقه اصلی بازی
while lives > 0 and "_" in display_word:
    # 3. نمایش وضعیت فعلی به کاربر
    print("\n" + " ".join(display_word))
    print(f"حروف حدس زده شده: {', '.join(guessed_letters)}")
    print(f"شما {lives} جان دیگر دارید.")

    # 4. دریافت حدس از کاربر و اعتبارسنجی
    guess = input("یک حرف حدس بزنید: ").lower()

    if len(guess) != 1 or not guess.isalpha():
        print("ورودی نامعتبر است. لطفاً فقط یک حرف وارد کنید.")
        continue

    if guess in guessed_letters:
        print("شما این حرف را قبلاً حدس زده‌اید. یک حرف دیگر را امتحان کنید.")
        continue
    
    # اضافه کردن حرف جدید به لیست حروف حدس زده شده
    guessed_letters.append(guess)

    # 5. بررسی وجود حرف در کلمه مخفی
    if guess in secret_word:
        print(f"آفرین! حرف '{guess}' در کلمه وجود دارد.")
        # جایگزینی خط تیره با حرف صحیح در تمام موقعیت‌ها
        for index, letter in enumerate(secret_word):
            if letter == guess:
                display_word[index] = guess
    else:
        print(f"متأسفم، حرف '{guess}' در کلمه نیست.")
        lives -= 1 # کاهش یک جان

# 6. پایان بازی: بررسی شرط برد یا باخت
if "_" not in display_word:
    print(f"\n🎉 تبریک! شما برنده شدید. کلمه صحیح '{secret_word}' بود.")
else:
    print(f"\n💥 بازی تمام شد! شما باختید. کلمه صحیح '{secret_word}' بود.")

به بازی حدس کلمه خوش آمدید!
کلمه مورد نظر 6 حرف دارد.

_ _ _ _ _ _
حروف حدس زده شده: 
شما 6 جان دیگر دارید.
یک حرف حدس بزنید: ب

آفرین! حرف 'ب' در کلمه وجود دارد.

_ _ _ ب _ _
حروف حدس زده شده: ب
شما 6 جان دیگر دارید.
یک حرف حدس بزنید: ر
متأسفم، حرف 'ر' در کلمه نیست.

_ _ _ ب _ _
حروف حدس زده شده: ب, ر
شما 5 جان دیگر دارید.
یک حرف حدس بزنید: ه
متأسفم، حرف 'ه' در کلمه نیست.
...
🎉 تبریک! شما برنده شدید. کلمه صحیح 'کتابخانه' بود.

تجزیه و تحلیل کد

• display_word = ["_" for _ in secret_word]: این یک تکنیک پایتونی به نام "List Comprehension" است. این کد یک لیست می‌سازد که به ازای هر حرف در secret_word، یک آیتم "_" در آن قرار می‌دهد. راه ساده‌تر آن استفاده از یک حلقه for است، اما این روش خلاصه‌تر است.
• " ".join(display_word): این متد، تمام اعضای لیست display_word را به هم می‌چسباند و بین آن‌ها یک فاصله (" ") قرار می‌دهد. این کار برای نمایش زیباتر وضعیت کلمه به کاربر است.
• while lives > 0 and "_" in display_word: شرط حلقه دو بخشی است. بازی تا زمانی ادامه پیدا می‌کند که کاربر هم جان داشته باشد (lives > 0) و هم هنوز جای خالی ("_") در کلمه نمایشی وجود داشته باشد.
• enumerate(secret_word): این تابع قدرتمند در پایتون، هنگام پیمایش یک لیست یا رشته، هم اندیس (شماره موقعیت) و هم مقدار هر آیتم را به ما می‌دهد. ما از این ویژگی برای پیدا کردن تمام موقعیت‌های حرف حدس زده شده و به‌روزرسانی display_word استفاده می‌کنیم.
• بررسی برد/باخت: پس از اتمام حلقه، با بررسی اینکه آیا هنوز "_" در display_word وجود دارد یا نه، می‌توانیم بفهمیم که کاربر برده (هیچ "_" باقی نمانده) یا باخته است.

ابزار نصب: `pip`

پایتون یک ابزار مدیریت پکیج داخلی به نام `pip` (مخفف Pip Installs Packages) دارد که معمولاً همراه با خود پایتون نصب می‌شود. `pip` مسئول اتصال به PyPI، دانلود پکیج مورد نظر شما و نصب صحیح آن بر روی سیستم شماست.

ساختار استاندارد دستور نصب بسیار ساده است:

pip install نام-پکیج

برای مثال، برای نصب کتابخانه محبوب numpy که برای محاسبات عددی استفاده می‌شود، دستور زیر را در ترمینال یا Command Prompt اجرا می‌کنیم:

pip install numpy

چالش دسترسی و راه‌حل: استفاده از میرور (Mirror)

گاهی اوقات، دسترسی مستقیم به سرورهای اصلی PyPI که در خارج از کشور قرار دارند، ممکن است با کندی یا قطعی همراه باشد. اینجاست که "میرورها" یا "آینه‌ها" به کمک ما می‌آیند.

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

1. سرعت بسیار بالاتر: چون سرور در داخل کشور است، دانلود پکیج‌ها با سرعت بسیار بیشتری انجام می‌شود.
2. پایداری و قابلیت اطمینان: این سرورها تحت تأثیر محدودیت‌های اینترنتی بین‌المللی قرار نمی‌گیرند و دسترسی پایدارتری را فراهم می‌کنند.

نحوه نصب با استفاده از میرور

برای اینکه به `pip` بگوییم به جای سرور اصلی PyPI از یک میرور استفاده کند، از یک فلگ (flag) به نام -i یا --index-url در دستور خود استفاده می‌کنیم. در ادامه چند نمونه از میرورهای ایرانی معتبر و دستور نصب با آن‌ها آمده است:

میرور Runflare

pip install -i https://mirror-pypi.runflare.com/simple نام-پکیج

میرور ابرآروان (Chabokan سابق)

pip install --index-url https://mirror2.chabokan.net/pypi/simple/ نام-پکیج

میرور لیارا

pip install -i https://package-mirror.liara.ir/repository/pypi/simple نام-پکیج

مثال‌های عملی

فرض کنید می‌خواهیم چند کتابخانه معروف را با استفاده از میرور Runflare نصب کنیم:

• نصب `numpy` (محاسبات علمی):

  pip install -i https://mirror-pypi.runflare.com/simple numpy

• نصب `pandas` (تحلیل داده):

  pip install -i https://mirror-pypi.runflare.com/simple pandas

• نصب `flask` (ساخت وب اپلیکیشن‌های ساده):

  pip install -i https://mirror-pypi.runflare.com/simple flask

• نصب `django` (ساخت وب اپلیکیشن‌های پیشرفته):

  pip install -i https://mirror-pypi.runflare.com/simple django

۲. ارسال اطلاعات به تابع (آرگومان‌ها)

اغلب اوقات، می‌خواهیم اطلاعاتی را به تابع ارسال کنیم تا بر اساس آن اطلاعات، کاری را انجام دهد. به این اطلاعات ورودی آرگومان (Argument) گفته می‌شود. متغیرهایی که در تعریف تابع این اطلاعات را دریافت می‌کنند، پارامتر (Parameter) نام دارند.

تابع با یک آرگومان

# 'name' یک پارامتر است
def greet_user(name):
    print(f"سلام، {name} عزیز!")

# "علی" و "مریم" آرگومان‌هایی هستند که به تابع ارسال می‌شوند
greet_user("علی")
greet_user("مریم")

سلام، علی عزیز!
سلام، مریم عزیز!

تابع با چند آرگومان

می‌توانید هر تعداد آرگومان که نیاز دارید به تابع ارسال کنید. ترتیب ارسال آرگومان‌ها مهم است.

# این تابع سه پارامتر دارد: نام، نام خانوادگی و سن
def show_user_info(first_name, last_name, age):
    print(f"نام: {first_name}")
    print(f"نام خانوادگی: {last_name}")
    print(f"سن: {age}")

show_user_info("محمدحسین", "سلیمانی", 30)

نام: محمدحسین
نام خانوادگی: سلیمانی
سن: 30

۳. مقدار پیش‌فرض برای پارامترها

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

def describe_pet(pet_name, animal_type="سگ"):
    print(f"من یک حیوان خانگی به نام {pet_name} دارم.")
    print(f"او یک {animal_type} است.")

# فراخوانی بدون ارسال آرگومان برای animal_type (از مقدار پیش‌فرض استفاده می‌شود)
describe_pet("رکسی")
print("-" * 20)
# فراخوانی با ارسال آرگومان برای animal_type (مقدار پیش‌فرض نادیده گرفته می‌شود)
describe_pet("برفی", "گربه")

من یک حیوان خانگی به نام رکسی دارم.
او یک سگ است.
--------------------
من یک حیوان خانگی به نام برفی دارم.
او یک گربه است.

۴. ارسال لیست و دریافت خروجی (Return)

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

# این تابع یک لیست از اعداد را می‌گیرد و بزرگترین عدد را بازمی‌گرداند
def find_max(numbers):
    if not numbers: # اگر لیست خالی باشد
        return None # مقدار None را بازمی‌گرداند

    maximum = numbers[0]
    for number in numbers:
        if number > maximum:
            maximum = number
    return maximum

my_scores = [88, 95, 72, 100, 91]
# فراخوانی تابع و ذخیره مقدار بازگشتی در یک متغیر
highest_score = find_max(my_scores) 

print(f"لیست نمرات من: {my_scores}")
print(f"بالاترین نمره من {highest_score} است.")

# یک مثال دیگر
empty_list = []
result = find_max(empty_list)
print(f"بزرگترین عدد در لیست خالی: {result}")

لیست نمرات من: [88, 95, 72, 100, 91]
بالاترین نمره من 100 است.
بزرگترین عدد در لیست خالی: None

۵. دستور `pass` در توابع

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

def calculate_taxes():
    # TODO: منطق محاسبه مالیات بعدا در اینجا نوشته خواهد شد
    pass

def send_email_report():
    # منطق ارسال ایمیل هنوز پیاده‌سازی نشده است
    pass

# برنامه بدون خطا اجرا می‌شود
print("در حال طراحی ساختار برنامه...")
calculate_taxes() # این تابع هیچ کاری انجام نمی‌دهد
send_email_report() # این تابع هم همینطور
print("طراحی اولیه کامل شد.")

۶. مستندسازی توابع (Docstrings)

یک تمرین حرفه‌ای و بسیار خوب این است که برای توابع خود مستندات بنویسید. این کار با استفاده از یک رشته چندخطی (محصور در سه علامت نقل قول """) درست بعد از خط تعریف تابع انجام می‌شود. این رشته به عنوان Docstring شناخته می‌شود و توضیح می‌دهد که تابع چه کاری انجام می‌دهد.

def square(number):
    """
    این تابع یک عدد را به عنوان ورودی دریافت کرده
    و توان دوم (مجذور) آن را بازمی‌گرداند.
    """
    return number * number

# می‌توانیم با استفاده از تابع help() این مستندات را مشاهده کنیم
help(square)

Help on function square in module __main__:

square(number)
    این تابع یک عدد را به عنوان ورودی دریافت کرده
    و توان دوم (مجذور) آن را بازمی‌گرداند.

۲. چگونه از یک ماژول استفاده کنیم؟

حالا می‌توانیم از ماژولی که ساختیم در یک فایل پایتون دیگر استفاده کنیم. برای این کار از کلمه کلیدی import استفاده می‌کنیم.

مرحله ۲: یک فایل جدید دیگر در همان پوشه (directory) که فایل mymodule.py را ذخیره کردید، ایجاد کنید. نام این فایل را main.py بگذارید و کد زیر را در آن بنویسید.

# file: main.py

# وارد کردن ماژول mymodule
import mymodule

# استفاده از تابع و دیکشنری داخل ماژول
# توجه کنید که باید نام ماژول را قبل از نام تابع/متغیر بیاوریم
mymodule.greeting("رضا")

age = mymodule.person1["age"]
print(f"سن شخص مورد نظر {age} سال است.")

مرحله ۳: فایل main.py را اجرا کنید. خروجی به شکل زیر خواهد بود:

سلام، رضا!
سن شخص مورد نظر 28 سال است.

همانطور که می‌بینید، با استفاده از نقطه (dot notation)، توانستیم به تابع greeting و دیکشنری person1 که در ماژول mymodule تعریف شده بودند، دسترسی پیدا کنیم.

۳. تغییر نام ماژول با کلمه کلیدی `as`

شما می‌توانید با استفاده از کلمه کلیدی as، یک نام مستعار یا کوتاه‌تر برای ماژول وارد شده انتخاب کنید. این کار به خصوص برای ماژول‌هایی با نام‌های طولانی بسیار مفید است.

# file: main.py (نسخه جدید)

import mymodule as mx

mx.greeting("شیوا")

country = mx.person1["country"]
print(f"کشور: {country}")

سلام، شیوا!
کشور: ایران

۴. ماژول‌های داخلی پایتون (Built-in)

پایتون دارای تعداد زیادی ماژول داخلی است که توابع و ابزارهای بسیار مفیدی را ارائه می‌دهند و شما نیازی به ساختن آن‌ها ندارید. قبلاً با ماژول random در بازی حدس اعداد آشنا شدیم. ماژول‌های پرکاربرد دیگری مانند math برای عملیات ریاضی پیشرفته و datetime برای کار با تاریخ و زمان وجود دارند.

import math

# استفاده از عدد پی (pi) از ماژول math
x = math.pi
print(f"مقدار عدد پی: {x}")

# استفاده از تابع sqrt (جذر) از ماژول math
y = math.sqrt(64)
print(f"جذر عدد 64 برابر است با: {y}")

مقدار عدد پی: 3.141592653589793
جذر عدد 64 برابر است با: 8.0

۵. وارد کردن بخش‌های خاصی از یک ماژول

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

مزیت این روش این است که هنگام استفاده از آن تابع یا متغیر، دیگر نیازی به نوشتن نام ماژول ندارید.

# فقط دیکشنری person1 را از ماژول mymodule وارد کن
from mymodule import person1

# دیگر نیازی به نوشتن mymodule.person1 نیست
print(f"نام شخص: {person1['name']}")

# اگر تلاش کنیم از تابع greeting استفاده کنیم، خطا دریافت خواهیم کرد
# چون آن را وارد نکرده‌ایم
# greeting("تست")  # <-- این خط باعث NameError می‌شود

نام شخص: سارا

همچنین می‌توانید هنگام وارد کردن یک بخش خاص، با استفاده از as برای آن نام مستعار انتخاب کنید:

from mymodule import greeting as greet_user

greet_user("دنیا")

سلام، دنیا!

۲. ساختار پایه `try...except`

ساختار اصلی به این صورت است:

• بلوک `try`: کدی که ممکن است خطا ایجاد کند در این قسمت قرار می‌گیرد.
• بلوک `except`: اگر در بلوک `try` خطایی رخ دهد، اجرای آن بلوک متوقف شده و کد داخل بلوک `except` اجرا می‌شود. اگر خطایی رخ ندهد، این بلوک نادیده گرفته می‌شود.

حالا بیایید مثال قبلی را بازنویسی کنیم:

try:
    age = int(input("لطفا سن خود را وارد کنید: "))
    birth_year = 2026 - age
    print(f"شما متولد سال {birth_year} هستید.")
except:
    print("خطا! لطفا فقط عدد صحیح وارد کنید.")

print("اجرای برنامه ادامه پیدا کرد...")

اگر این کد را اجرا کرده و یک متن وارد کنید، خروجی به شکل زیر خواهد بود:

لطفا سن خود را وارد کنید: بیست
خطا! لطفا فقط عدد صحیح وارد کنید.
اجرای برنامه ادامه پیدا کرد...

۳. مدیریت خطاهای خاص

استفاده از except به تنهایی (که به آن bare except می‌گویند) تمام خطاها را مدیریت می‌کند. این کار معمولاً ایده خوبی نیست، زیرا ممکن است خطاهایی را که انتظارشان را ندارید (و نشانه باگ در برنامه شما هستند) نیز مخفی کند.

روش بهتر این است که نوع خطایی را که انتظار دارید، مشخص کنید. مثلاً در مثال بالا، ما منتظر خطای ValueError هستیم.

try:
    numerator = int(input("عدد صورت کسر را وارد کنید: "))
    denominator = int(input("عدد مخرج کسر را وارد کنید: "))
    result = numerator / denominator
    print(f"نتیجه تقسیم: {result}")
except ValueError:
    print("خطا: لطفا فقط عدد وارد کنید.")
except ZeroDivisionError:
    print("خطا: تقسیم بر صفر ممکن نیست!")

در این کد:

• اگر کاربر متن وارد کند، بلوک except ValueError اجرا می‌شود.
• اگر کاربر برای مخرج عدد صفر را وارد کند، بلوک except ZeroDivisionError اجرا می‌شود.

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

try:
    # ... کد مشابه بالا ...
except (ValueError, ZeroDivisionError):
    print("ورودی نامعتبر است یا تقسیم بر صفر انجام شده است.")

۴. بلوک `else` (اجرا در صورت عدم وجود خطا)

گاهی اوقات می‌خواهیم بخشی از کد، فقط و فقط اگر هیچ خطایی در بلوک try رخ نداد، اجرا شود. برای این کار از بلوک else استفاده می‌کنیم.

try:
    age = int(input("لطفا سن خود را وارد کنید: "))
except ValueError:
    print("خطا! لطفا فقط عدد صحیح وارد کنید.")
else:
    # این بخش فقط در صورت موفقیت بلوک try اجرا می‌شود
    birth_year = 2026 - age
    print(f"شما متولد سال {birth_year} هستید.")

۵. بلوک `finally` (اجرا در هر صورت)

بلوک finally یک ویژگی بسیار مهم دارد: کد داخل آن همیشه اجرا می‌شود، چه در بلوک try خطایی رخ بدهد و چه ندهد.

این بلوک معمولاً برای "عملیات پاکسازی" (cleanup actions) مانند بستن یک فایل یا قطع اتصال از یک پایگاه داده استفاده می‌شود، کارهایی که باید تحت هر شرایطی انجام شوند.

try:
    numerator = int(input("عدد صورت کسر را وارد کنید: "))
    denominator = int(input("عدد مخرج کسر را وارد کنید: "))
    result = numerator / denominator
    print(f"نتیجه تقسیم: {result}")
except ZeroDivisionError:
    print("خطا: تقسیم بر صفر ممکن نیست!")
finally:
    # این کد همیشه اجرا می‌شود
    print("محاسبه پایان یافت.")

اگر عدد `0` را برای مخرج وارد کنید، خروجی به این شکل خواهد بود:

عدد صورت کسر را وارد کنید: 10
عدد مخرج کسر را وارد کنید: 0
خطا: تقسیم بر صفر ممکن نیست!
محاسبه پایان یافت.

و اگر ورودی معتبر باشد:

عدد صورت کسر را وارد کنید: 10
عدد مخرج کسر را وارد کنید: 2
نتیجه تقسیم: 5.0
محاسبه پایان یافت.

همانطور که می‌بینید، بلوک `finally` در هر دو حالت اجرا شد.

۲. کد کامل برنامه

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

import math # مرحله ۱: وارد کردن کتابخانه ریاضی

print("ماشین حساب مهندسی خوش آمدید!")

while True:
    # مرحله ۲: نمایش منو در هر بار اجرای حلقه
    print("\nعملیات مورد نظر خود را انتخاب کنید:")
    print("1. جمع (+)")
    print("2. تفریق (-)")
    print("3. ضرب (*)")
    print("4. تقسیم (/)")
    print("5. توان (x^y)")
    print("6. جذر (√x)")
    print("7. سینوس (sin(x))")
    print("8. کسینوس (cos(x))")
    print("9. تانژانت (tan(x))")
    print("10. فاکتوریل (x!)")
    print("0. خروج")

    # مرحله ۳: دریافت انتخاب کاربر
    choice = input("کد عملیات را وارد کنید (0-10): ")

    # مرحله ۴: بررسی شرط خروج
    if choice == '0':
        print("خداحافظ!")
        break # شکستن حلقه و پایان برنامه

    # مرحله ۵: دریافت اعداد با مدیریت خطای کامل
    try:
        # عملیاتی که به دو عدد نیاز دارند
        if choice in ('1', '2', '3', '4', '5'):
            num1 = float(input("عدد اول را وارد کنید: "))
            num2 = float(input("عدد دوم را وارد کنید: "))
        # عملیاتی که به یک عدد نیاز دارند
        elif choice in ('6', '7', '8', '9', '10'):
            num1 = float(input("عدد را وارد کنید: "))
        else:
            print("خطا: انتخاب شما نامعتبر است. لطفا یک عدد بین 0 تا 10 وارد کنید.")
            continue # پرش به ابتدای حلقه

        # مرحله ۶: انجام محاسبات
        if choice == '1':
            result = num1 + num2
            print(f"نتیجه: {num1} + {num2} = {result}")
        elif choice == '2':
            result = num1 - num2
            print(f"نتیجه: {num1} - {num2} = {result}")
        elif choice == '3':
            result = num1 * num2
            print(f"نتیجه: {num1} * {num2} = {result}")
        elif choice == '4':
            # مدیریت خطای تقسیم بر صفر
            if num2 == 0:
                print("خطا: تقسیم بر صفر ممکن نیست!")
            else:
                result = num1 / num2
                print(f"نتیجه: {num1} / {num2} = {result}")
        elif choice == '5':
            result = math.pow(num1, num2)
            print(f"نتیجه: {num1} به توان {num2} = {result}")
        elif choice == '6':
            result = math.sqrt(num1)
            print(f"نتیجه: جذر {num1} = {result}")
        elif choice == '7':
            # توجه: توابع مثلثاتی در پایتون ورودی را بر حسب رادیان می‌گیرند
            result = math.sin(num1)
            print(f"نتیجه: سینوس {num1} (رادیان) = {result}")
        elif choice == '8':
            result = math.cos(num1)
            print(f"نتیجه: کسینوس {num1} (رادیان) = {result}")
        elif choice == '9':
            result = math.tan(num1)
            print(f"نتیجه: تانژانت {num1} (رادیان) = {result}")
        elif choice == '10':
            # فاکتوریل فقط برای اعداد صحیح مثبت تعریف شده است
            if num1 < 0 or num1 != int(num1):
                 print("خطا: فاکتوریل فقط برای اعداد صحیح غیرمنفی تعریف شده است.")
            else:
                result = math.factorial(int(num1))
                print(f"نتیجه: فاکتوریل {int(num1)} = {result}")

    except ValueError:
        print("خطا: ورودی نامعتبر! لطفاً فقط عدد وارد کنید.")
    except Exception as e:
        # گرفتن هر خطای پیش‌بینی نشده دیگر
        print(f"یک خطای غیرمنتظره رخ داد: {e}")

۳. تجزیه و تحلیل کد

• `import math`: در همان ابتدا، کتابخانه `math` را برای دسترسی به توابع ریاضی پیشرفته مانند pow, sqrt, sin و... وارد کرده‌ایم.
• بلوک اصلی `try...except`: تقریباً تمام منطق دریافت ورودی و محاسبه درون یک بلوک `try` بزرگ قرار گرفته است. این کار تضمین می‌کند که اگر کاربر در هر مرحله از وارد کردن اعداد، یک مقدار غیرعددی (مثلاً "hello") تایپ کند، برنامه به جای crash کردن، به بلوک except ValueError رفته و پیام خطای مناسب را نمایش می‌دهد.
• `continue`: دقت کنید که اگر کاربر یک انتخاب نامعتبر برای عملیات داشته باشد (مثلاً عدد 12)، یک پیام خطا چاپ شده و سپس دستور continue اجرا می‌شود. این دستور باعث می‌شود اجرای فعلی حلقه متوقف شده و برنامه مستقیماً به ابتدای حلقه while برگردد تا منو دوباره نمایش داده شود.
• مدیریت خاص تقسیم بر صفر: برای عملیات تقسیم، قبل از انجام محاسبه، با یک `if` ساده چک می‌کنیم که آیا مخرج (num2) صفر است یا نه. این یک نمونه از مدیریت خطای منطقی قبل از بروز استثنا است.
• ورودی رادیان: یک نکته مهم در مورد توابع مثلثاتی (sin, cos, tan) در اکثر زبان‌های برنامه‌نویسی این است که زاویه را بر حسب رادیان دریافت می‌کنند، نه درجه. ما این نکته را در پیام خروجی به کاربر یادآوری کرده‌ایم.

چالش برای شما

سعی کنید این ماشین حساب را بهبود دهید:

1. تبدیل درجه به رادیان: یک گزینه به منو اضافه کنید که ابتدا عدد را از کاربر بر حسب درجه بگیرد، آن را با استفاده از تابع math.radians() به رادیان تبدیل کند و سپس نتیجه سینوس یا کسینوس را محاسبه کند.
2. افزودن لگاریتم: قابلیت محاسبه لگاریتم (math.log() یا math.log10()) را به ماشین حساب اضافه کنید.
3. رابط کاربری بهتر: سعی کنید بعد از هر محاسبه، صفحه ترمینال را پاک کنید تا خروجی تمیزتر باشد. (نکته: برای این کار باید از ماژول os استفاده کنید: import os و سپس os.system('cls') برای ویندوز یا os.system('clear') برای لینوکس/مک).

۲. فرمت‌دهی تاریخ به رشته با ()strftime

متد strftime() (مخفف String Format Time) یک شیء تاریخ را می‌گیرد و آن را بر اساس "کدهای فرمت" که شما مشخص می‌کنید، به یک رشته متنی زیبا تبدیل می‌کند. این کدها با علامت % شروع می‌شوند.

import datetime

now = datetime.datetime.now()

# مثال ۱: فرمت رایج YYYY-MM-DD
formatted_date_1 = now.strftime("%Y-%m-%d")
print(f"فرمت ۱: {formatted_date_1}")
# خروجی نمونه: 2026-03-23

# مثال ۲: فرمت کامل با نام روز و ماه
formatted_date_2 = now.strftime("امروز %A، %d %B سال %Y")
print(f"فرمت ۲: {formatted_date_2}")
# خروجی نمونه: امروز Monday، 23 March سال 2026
# نکته: نام روزها و ماه‌ها به صورت پیش‌فرض انگلیسی هستند.

# مثال ۳: فرمت زمان ۱۲ ساعته با AM/PM
formatted_date_3 = now.strftime("%I:%M:%S %p")
print(f"فرمت ۳: {formatted_date_3}")
# خروجی نمونه: 10:30:55 AM

مرجع کامل کدهای فرمت ()strftime

جدول زیر لیست کاملی از کدهای فرمت را که می‌توانید در strftime() استفاده کنید، نشان می‌دهد.

۳. خواندن تاریخ از رشته با ()strptime

گاهی اوقات شما یک تاریخ را به صورت متن (مثلاً از ورودی کاربر یا یک فایل) دریافت می‌کنید و می‌خواهید آن را به یک شیء datetime تبدیل کنید تا بتوانید روی آن محاسبات انجام دهید. تابع strptime() (مخفف String Parse Time) این کار را انجام می‌دهد.

import datetime

date_string = "30-07-2025 15:45"

# فرمت باید دقیقاً با رشته بالا مطابقت کند
date_format = "%d-%m-%Y %H:%M"

try:
    # تبدیل رشته به شیء datetime
    date_object = datetime.datetime.strptime(date_string, date_format)
    print(f"شیء تاریخ ایجاد شده: {date_object}")
    print(f"سال آن: {date_object.year}")
except ValueError:
    print("خطا: فرمت رشته با فرمت مشخص شده مطابقت ندارد.")

۴. محاسبات زمانی با timedelta

یکی از قابلیت‌های فوق‌العاده ماژول datetime، انجام محاسبات روی تاریخ‌ها است. برای این کار از شیء timedelta استفاده می‌کنیم که یک "بازه زمانی" را نشان می‌دهد.

import datetime

now = datetime.datetime.now()
print(f"زمان حال: {now.strftime('%Y-%m-%d')}")

# محاسبه تاریخ ۵۰ روز آینده
future_date = now + datetime.timedelta(days=50)
print(f"تاریخ ۵۰ روز بعد: {future_date.strftime('%Y-%m-%d')}")

# محاسبه تاریخ ۱۰ هفته و ۲ روز قبل
past_date = now - datetime.timedelta(weeks=10, days=2)
print(f"تاریخ ۱۰ هفته و ۲ روز قبل: {past_date.strftime('%Y-%m-%d')}")

# محاسبه تفاوت بین دو تاریخ
birthday = datetime.datetime(2027, 1, 1)
time_to_birthday = birthday - now
print(f"زمان باقی‌مانده تا آن تاریخ: {time_to_birthday}")
print(f"فقط {time_to_birthday.days} روز دیگر باقی مانده است!")

۲. بهترین روش کار با فایل‌ها: دستور with

بعد از اتمام کار با یک فایل، باید آن را ببندیم تا منابع سیستم آزاد شوند. اگر فراموش کنیم فایل را ببندیم، ممکن است باعث بروز مشکلاتی در برنامه شود. پایتون یک راه بسیار زیبا و امن برای مدیریت این موضوع ارائه می‌دهد: بلوک with.

# ساختار کلی استفاده از with
with open("my_file.txt", "w") as file:
    # تمام کدهایی که با فایل کار می‌کنند
    # در این بلوک با تورفتگی نوشته می‌شوند.
    file.write("سلام دنیا!")
# در این نقطه، پایتون به طور خودکار فایل را بسته است.

۳. خواندن محتوای فایل (Reading)

فرض کنید فایلی به نام greetings.txt در کنار فایل پایتون خود داریم که محتوای زیر را دارد:

Hello Python
Welcome to file handling
Enjoy learning!

بهترین راه برای خواندن این فایل، استفاده از یک حلقه for است:

try:
    with open("greetings.txt", "r") as file:
        print("محتوای فایل:")
        for line in file:
            # هر خط از فایل در متغیر line قرار می‌گیرد
            # .strip() کاراکترهای اضافی مثل خط جدید (\n) را از ابتدا و انتهای رشته حذف می‌کند
            print(line.strip()) 
except FileNotFoundError:
    print("خطا: فایل مورد نظر پیدا نشد.")

۴. نوشتن در فایل (Writing)

برای نوشتن در فایل از متد .write() استفاده می‌کنیم. به یاد داشته باشید که این متد به طور خودکار به خط بعدی نمی‌رود و شما باید در صورت نیاز، کاراکتر خط جدید (\n) را خودتان اضافه کنید.

shopping_list = ["شیر", "نان", "تخم مرغ", "کره"]

with open("shopping.txt", "w") as file:
    file.write("لیست خرید من:\n") # \n برای رفتن به خط بعد
    for item in shopping_list:
        file.write(f"- {item}\n")

print("فایل shopping.txt با موفقیت ایجاد و نوشته شد.")

پس از اجرای این کد، فایلی به نام shopping.txt با محتوای لیست خرید ایجاد خواهد شد.

۵. اضافه کردن به انتهای فایل (Appending)

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

# فرض کنید فایل shopping.txt از قبل وجود دارد

with open("shopping.txt", "a") as file:
    file.write("- عسل\n")
    file.write("- پنیر\n")

print("موارد جدید به لیست خرید اضافه شد.")

اگر فایل shopping.txt را باز کنید، خواهید دید که "عسل" و "پنیر" به انتهای لیست قبلی اضافه شده‌اند.

۲. ساختار یک کلاس در پایتون

یک کلاس با کلمه کلیدی class و سپس نام کلاس (که طبق قرارداد با حرف بزرگ شروع می‌شود) تعریف می‌شود.

class Car:
    # ویژگی‌ها (Attributes) و متدها (Methods) در اینجا تعریف می‌شوند
    pass

۳. متد `__init__`: سازنده (Constructor)

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

۴. پارامتر `self`: ارجاع به خود شیء

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

وقتی می‌نویسیم self.color = "white"، در واقع داریم می‌گوییم: "رنگِ این شیء خاص را برابر با سفید قرار بده". وقتی شما یک شیء می‌سازید (مثلاً pride = Car(...))، پایتون به صورت خودکار ارجاع به شیء pride را به جای self قرار می‌دهد.

۵. مثال جامع: ساخت کلاس `Car`

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

بخش اول: تعریف کلاس

class Car:
    # 1. متد سازنده (__init__)
    # وقتی یک ماشین جدید می‌سازیم، این متد اجرا می‌شود
    def __init__(self, brand, model, year):
        # 2. تعریف ویژگی‌ها (Attributes)
        # self به این شیء خاص اشاره دارد
        self.brand = brand
        self.model = model
        self.year = year
        self.speed = 0 # سرعت اولیه همه ماشین‌ها صفر است

    # 3. تعریف متدها (Methods - رفتارها)
    def accelerate(self, amount):
        """سرعت ماشین را به مقدار مشخص شده افزایش می‌دهد."""
        self.speed += amount
        print(f"گاز دادیم! سرعت فعلی: {self.speed} km/h")

    def brake(self, amount):
        """سرعت ماشین را به مقدار مشخص شده کاهش می‌دهد."""
        self.speed -= amount
        if self.speed < 0:
            self.speed = 0
        print(f"ترمز کردیم! سرعت فعلی: {self.speed} km/h")
        
    def display_info(self):
        """اطلاعات کامل ماشین را نمایش می‌دهد."""
        print(f"مشخصات خودرو: {self.year} {self.brand} {self.model}")

بخش دوم: ساختن اشیاء (Instances) از روی کلاس

حالا که نقشه را داریم، می‌توانیم ماشین‌های واقعی بسازیم!

# ساخت اولین شیء (نمونه) از کلاس Car
pride = Car("Saipa", "131", 1398)

# ساخت دومین شیء از همان کلاس
peugeot = Car("Peugeot", "206", 1401)

بخش سوم: استفاده از اشیاء

حالا می‌توانیم به ویژگی‌های هر ماشین دسترسی پیدا کنیم و متدهای آن را فراخوانی کنیم.

# دسترسی به ویژگی‌های پراید
print(f"مدل ماشین اول: {pride.model}") # خروجی: 131

# فراخوانی متدهای پژو
peugeot.display_info() # خروجی: مشخصات خودرو: 1401 Peugeot 206
peugeot.accelerate(80) # خروجی: گاز دادیم! سرعت فعلی: 80 km/h
peugeot.accelerate(30) # خروجی: گاز دادیم! سرعت فعلی: 110 km/h
peugeot.brake(40)      # خروجی: ترمز کردیم! سرعت فعلی: 70 km/h

print("-" * 20)

# فراخوانی متدهای پراید
pride.display_info()   # خروجی: مشخصات خودرو: 1398 Saipa 131
pride.accelerate(50)   # خروجی: گاز دادیم! سرعت فعلی: 50 km/h

# توجه کنید که سرعت پراید و پژو کاملاً مستقل از هم هستند
print(f"سرعت نهایی پراید: {pride.speed}")
print(f"سرعت نهایی پژو: {peugeot.speed}")

۲. کلاس فرزند: `Student`

یک دانشجو، یک "شخص" است، اما ویژگی‌های اضافی مانند شماره دانشجویی و رشته تحصیلی دارد. پس کلاس `Student` از `Person` ارث‌بری می‌کند.

• سینتکس ارث‌بری: نام کلاس والد را داخل پرانتز بعد از نام کلاس فرزند قرار می‌دهیم: class Student(Person):.
• تابع `super()`: برای اینکه ویژگی‌های کلاس والد (first_name, last_name) مقداردهی شوند، باید سازنده (__init__) کلاس والد را فراخوانی کنیم. بهترین راه برای این کار استفاده از super().__init__(...) است.
• بازنویسی متد (Overriding): ما می‌خواهیم متد display_info اطلاعات دانشجو را هم نمایش دهد. پس آن را در کلاس فرزند دوباره تعریف می‌کنیم. می‌توانیم ابتدا نسخه والد را با super().display_info() اجرا کنیم و سپس اطلاعات جدید را اضافه کنیم.

class Student(Person):
    def __init__(self, first_name, last_name, student_id, major):
        # فراخوانی سازنده کلاس والد (Person) برای مقداردهی نام و نام خانوادگی
        super().__init__(first_name, last_name)
        
        # اضافه کردن ویژگی‌های جدید مختص دانشجو
        self.student_id = student_id
        self.major = major

    # بازنویسی متد display_info برای نمایش اطلاعات کامل‌تر
    def display_info(self):
        super().display_info() # ابتدا متد والد را اجرا می‌کند
        print(f"  شماره دانشجویی: {self.student_id}")
        print(f"  رشته تحصیلی: {self.major}")

۳. ارث‌بری چند سطحی: `Employee` و `Professor`

حالا یک ساختار کمی پیچیده‌تر ایجاد می‌کنیم. یک استاد، نوعی کارمند است و یک کارمند، نوعی شخص است. (Professor -> Employee -> Person)

کلاس `Employee` (فرزند `Person`)

class Employee(Person):
    def __init__(self, first_name, last_name, employee_id, department):
        super().__init__(first_name, last_name)
        self.employee_id = employee_id
        self.department = department

    def display_info(self):
        super().display_info()
        print(f"  شماره کارمندی: {self.employee_id}")
        print(f"  دپارتمان: {self.department}")

کلاس `Professor` (فرزند `Employee`)

این کلاس تمام ویژگی‌های `Employee` (و در نتیجه `Person`) را به ارث می‌برد و ویژگی‌های جدید خود را اضافه می‌کند.

class Professor(Employee):
    def __init__(self, first_name, last_name, employee_id, department, academic_rank):
        # فراخوانی سازنده کلاس والد (Employee)
        super().__init__(first_name, last_name, employee_id, department)
        self.academic_rank = academic_rank
        self.courses = [] # لیستی برای دروسی که تدریس می‌کند

    def add_course(self, course_name):
        self.courses.append(course_name)
        print(f"درس '{course_name}' به لیست دروس دکتر {self.last_name} اضافه شد.")

    # بازنویسی مجدد برای نمایش کامل‌ترین اطلاعات
    def display_info(self):
        super().display_info()
        print(f"  مرتبه علمی: {self.academic_rank}")
        print(f"  دروس تدریسی: {', '.join(self.courses) if self.courses else 'هنوز درسی ارائه نشده'}")

۴. استفاده از کلاس‌های ساخته شده

حالا از این کلاس‌ها اشیاء مختلف می‌سازیم و می‌بینیم که هر کدام چگونه رفتار می‌کنند.

# ساخت یک شیء از نوع Professor
prof1 = Professor("علی", "رضایی", 95102, "مهندسی کامپیوتر", "دانشیار")
prof1.add_course("برنامه‌نویسی پیشرفته")
prof1.add_course("هوش مصنوعی")

print("---------------------------------")

# ساخت یک شیء از نوع Student
student1 = Student("مریم", "احمدی", 401123, "علوم کامپیوتر")

# نمایش اطلاعات هر شخص
print("اطلاعات استاد:")
prof1.display_info()

print("\n---------------------------------\n")

print("اطلاعات دانشجو:")
student1.display_info()

درس 'برنامه‌نویسی پیشرفته' به لیست دروس دکتر رضایی اضافه شد.
درس 'هوش مصنوعی' به لیست دروس دکتر رضایی اضافه شد.
---------------------------------
اطلاعات استاد:
نام: علی رضایی
  شماره کارمندی: 95102
  دپارتمان: مهندسی کامپیوتر
  مرتبه علمی: دانشیار
  دروس تدریسی: برنامه‌نویسی پیشرفته, هوش مصنوعی

---------------------------------

اطلاعات دانشجو:
نام: مریم احمدی
  شماره دانشجویی: 401123
  رشته تحصیلی: علوم کامپیوتر