آموزش استفاده از ماژول EasyList در پایتون 📚

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



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



نصب و راه‌اندازی ⚙️

برای استفاده از این ماژول، کافی است کد آن را در برنامه خود کپی کرده و از آن استفاده کنید. هیچ نصب خاصی نیاز نیست. فقط باید مطمئن شوید که کد ماژول در فایل پایتون شما قرار دارد.

برای استفاده از این ماژول، آن را به شکل زیر وارد کنید:

from easylist import EasyList  # وارد کردن ماژول

عملکردهای اصلی ماژول

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

1. افزودن عنصر به لیست ➕
با استفاده از عملگر + می‌توانید به راحتی یک عنصر جدید به انتهای لیست اضافه کنید:

   my_list = EasyList([1, 2, 3, 4])
   my_list + 5  # لیست به [1, 2, 3, 4, 5] تبدیل می‌شود
   

2. حذف عنصر از لیست ➖
عملگر - برای حذف یک عنصر از لیست استفاده می‌شود:

   my_list - 3  # لیست به [1, 2, 4] تبدیل می‌شود
   

3. اعمال تابع به تمام عناصر لیست ✨
با استفاده از عملگر * می‌توانید یک تابع را به تمامی عناصر لیست اعمال کنید:

   my_list * (lambda x: x * 2)  # لیست به [2, 4, 8] تبدیل می‌شود
   

4. مرتب‌سازی لیست 🔢
برای مرتب‌سازی لیست می‌توانید از عملگر ~ استفاده کنید:

   my_list ~  # لیست به [1, 2, 3, 4] مرتب می‌شود
   

5. معکوس کردن لیست 🔄
برای معکوس کردن لیست، از عملگر - استفاده کنید:

   my_list -  # لیست به [4, 3, 2, 1] معکوس می‌شود
   

6. یافتن بزرگترین عنصر از لیست 🏆
برای پیدا کردن بیشترین مقدار در لیست، از عملگر & استفاده کنید:

   max_value = my_list & None  # 4
   

7. یافتن کوچکترین عنصر از لیست 🌱
برای پیدا کردن کوچکترین مقدار در لیست، از عملگر | استفاده کنید:

   min_value = my_list | None  # 1
   

8. ترکیب دو لیست 🔗
برای ترکیب دو لیست، از عملگر & استفاده کنید:

   my_list2 = EasyList([5, 6, 7])
   combined_list = my_list & my_list2  # لیست ترکیب شده [1, 2, 3, 4, 5, 6, 7]
   

9. فیلتر کردن لیست با تابع دلخواه 🔍
از عملگر ^ برای فیلتر کردن لیست با استفاده از یک تابع خاص می‌توانید استفاده کنید:

   my_list ^ (lambda x: x > 2)  # لیست به [3, 4] فیلتر می‌شود
   

10. حذف تکراری‌ها 🧹
برای حذف تکراری‌ها از لیست، از عملگر @ استفاده کنید:

   my_list @ None  # لیست به [1, 2, 3, 4] تبدیل می‌شود
   

تست ماژول (مثال کامل) 🧑‍💻
برای مشاهده نحوه عملکرد تمامی این ویژگی‌ها، از کد زیر استفاده کنید:

from easylist import EasyList

def test():
    my_list = EasyList([1, 2, 3, 4, 5, 5])
    print("Test 1 - Add:", my_list + 6)
    print("Test 2 - Remove:", my_list - 3)
    print("Test 3 - Multiply (apply function):", my_list * (lambda x: x * 2))
    print("Test 4 - Sort:", my_list ~)
    print("Test 5 - Reverse:", my_list -)
    print("Test 6 - Max:", my_list & None)
    print("Test 7 - Min:", my_list | None)
    
    my_list2 = EasyList([6, 7, 8])
    print("Test 8 - Combine two lists:", my_list & my_list2)
    print("Test 9 - Filter (> 4):", my_list ^ (lambda x: x > 4))
    print("Test 10 - Remove duplicates:", my_list @ None)
    
test()

نتیجه‌گیری ✨

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


#پایتون #آموزش_پایتون #کدنویسی

خود فایل ☝️

پارت 1: آموزش SQL با پایتون (پایه)

👨‍💻 SQL یا Structured Query Language زبان استانداردی برای کار با پایگاه‌های داده است که به ما اجازه می‌دهد داده‌ها را ایجاد، خواندن، بروزرسانی و حذف کنیم (CRUD operations). در این پارت، می‌خواهیم SQL را در پایتون به کمک کتابخانه sqlite3 یاد بگیریم. این کتابخانه برای کار با پایگاه داده‌های SQLite در پایتون بسیار مفید است و در اکثر سیستم‌ها به صورت پیش‌فرض نصب شده است.

1️⃣ شروع کار با sqlite3

برای شروع، باید ابتدا کتابخانه sqlite3 را وارد کنیم:

import sqlite3

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

# اتصال به پایگاه داده (اگر فایل پایگاه داده وجود نداشته باشد، ساخته می‌شود)
conn = sqlite3.connect('example.db')

# ایجاد یک cursor برای اجرای دستورات SQL
cursor = conn.cursor()

در کد بالا:
- example.db نام فایل پایگاه داده است.
- اگر فایل پایگاه داده با این نام وجود نداشته باشد، به صورت خودکار ایجاد خواهد شد.
- cursor یک شی است که می‌توان از آن برای اجرای دستورات SQL استفاده کرد.

2️⃣ ایجاد یک جدول جدید

برای ایجاد یک جدول در پایگاه داده، از دستور SQL CREATE TABLE استفاده می‌کنیم. فرض کنید می‌خواهیم یک جدول برای ذخیره اطلاعات کاربر مانند نام، سن و ایمیل ایجاد کنیم:

# ایجاد یک جدول جدید
cursor.execute('''CREATE TABLE IF NOT EXISTS users (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    name TEXT,
                    age INTEGER,
                    email TEXT)''')

# ذخیره تغییرات در پایگاه داده
conn.commit()

در این کد:
- IF NOT EXISTS به این معناست که اگر جدول قبلاً ایجاد شده باشد، دوباره ایجاد نمی‌شود.
- id یک ستون است که به عنوان کلید اصلی (Primary Key) برای هر رکورد استفاده می‌شود و به طور خودکار افزایش می‌یابد (AUTOINCREMENT).

3️⃣ وارد کردن داده‌ها در جدول

حالا که جدول خود را ایجاد کرده‌ایم، می‌توانیم داده‌ها را به آن وارد کنیم. از دستور SQL INSERT INTO استفاده می‌کنیم:

# وارد کردن داده‌ها در جدول
cursor.execute("INSERT INTO users (name, age, email) VALUES (?, ?, ?)", ('Ali', 25, '[email protected]'))

# ذخیره تغییرات
conn.commit()

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

4️⃣ خواندن داده‌ها از جدول

برای خواندن داده‌ها از جدول، از دستور SQL SELECT استفاده می‌کنیم:

# خواندن داده‌ها از جدول
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()

# نمایش داده‌ها
for row in rows:
    print(row)

در این کد:
- SELECT * FROM users تمام داده‌های جدول users را انتخاب می‌کند.
- fetchall() تمام نتایج را به صورت یک لیست از تاپل‌ها برمی‌گرداند.

5️⃣ بستن اتصال

پس از انجام تمام عملیات، بهتر است که اتصال به پایگاه داده را ببندیم:

# بستن اتصال به پایگاه داده
conn.close()

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

🔜 در پارت بعدی، به بررسی دستورات پیشرفته‌تر SQL و نحوه بروزرسانی و حذف داده‌ها خواهیم پرداخت.

#SQL #Python #SQLite #Database

پارت 2: آموزش SQL با پایتون (بروزرسانی و حذف داده‌ها)

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

1️⃣ بروزرسانی داده‌ها (UPDATE)

اگر بخواهیم داده‌ای را که قبلاً وارد کرده‌ایم، تغییر دهیم، از دستور **UPDATE** استفاده می‌کنیم. مثلاً فرض کنید می‌خواهیم سن کاربری که نامش "Ali" است را تغییر دهیم.

# بروزرسانی داده‌ها
cursor.execute("UPDATE users SET age = ? WHERE name = ?", (30, 'Ali'))

# ذخیره تغییرات
conn.commit()

در این کد:
- SET age = ? به این معناست که مقدار سن تغییر می‌کند.
- WHERE name = ? مشخص می‌کند که فقط رکوردهایی که نام آن‌ها "Ali" است تغییر خواهند کرد.
- مانند قبل، برای جلوگیری از تزریق SQL از ? استفاده کرده‌ایم و مقادیر را به صورت پارامتر می‌فرستیم.

2️⃣ حذف داده‌ها (DELETE)

برای حذف داده‌ها از پایگاه داده، از دستور **DELETE** استفاده می‌کنیم. فرض کنید می‌خواهیم رکورد کاربری که نامش "Ali" است را حذف کنیم.

# حذف داده‌ها
cursor.execute("DELETE FROM users WHERE name = ?", ('Ali',))

# ذخیره تغییرات
conn.commit()

در این کد:
- DELETE FROM users تمام داده‌ها را از جدول users حذف می‌کند.
- WHERE name = ? به این معناست که فقط رکوردهایی که نام آن‌ها "Ali" است حذف می‌شوند.

⚠️ توجه داشته باشید که دستور DELETE بدون استفاده از WHERE، تمام رکوردها را حذف می‌کند. پس باید حتماً دقت کنید که از WHERE به درستی استفاده کنید تا فقط رکوردهای مورد نظر حذف شوند.

3️⃣ حذف تمام داده‌ها از جدول (Truncate)

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

# حذف تمام داده‌ها از جدول
cursor.execute("DELETE FROM users")

# ذخیره تغییرات
conn.commit()

یا برای حذف ساختار جدول و داده‌ها:

# حذف جدول از پایگاه داده
cursor.execute("DROP TABLE IF EXISTS users")

# ذخیره تغییرات
conn.commit()

در اینجا:
- DELETE FROM users تمام داده‌ها را از جدول حذف می‌کند، اما ساختار جدول باقی می‌ماند.
- DROP TABLE IF EXISTS users جدول users را به طور کامل حذف می‌کند، حتی اگر داده‌ها داخل آن باشند.

4️⃣ جستجوی داده‌ها با شرط‌های مختلف

برای جستجوی داده‌ها به صورت خاص‌تر، می‌توانیم اSELECTSELECT** با شرط‌های مختلWHERE*WHERE**، **LIKE**، و **ORDER BY** استفاده کنیم. به عنوان مثال، فرض کنید می‌خواهیم کاربران را بر اساس سن مرتب کنیم:

# جستجو و مرتب‌سازی داده‌ها
cursor.execute("SELECT * FROM users ORDER BY age DESC")
rows = cursor.fetchall()

# نمایش داده‌ها
for row in rows:
    print(row)

در این کد:
- ORDER BY age DESC داده‌ها را بر اساس سن به صورت نزولی مرتب می‌کند.
- برای مرتب‌سازی صعودی از ASC استفاده می‌شود که به طور پیش‌فرض است.

5️⃣ بستن اتصال

در نهایت، پس از انجام عملیات‌های مورد نظر، باید اتصال به پایگاه داده را ببندیم:

# بستن اتصال به پایگاه داده
conn.close()

📚 **خلاصه پارت 2**:
- در این پارت یاد گرفتیم که چگونه UPDATE با دستور **UPDATE** بروزرسانی کنیم.
- نحوه حذف DELETE با دستور **DELETE** بررسی کردیم.
- برای حذف تمام داده‌ها یا DELETEز دDROP*DELETE** و **DROP** استفاده کردیم.
- یاد گرفتیم که چگونه داده‌ها را جستجو کرده و مرتب کنیم.

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

#SQL #Python #SQLite #Database

پارت 1: مفاهیم اولیه گراف‌ها
🎓 گراف چیست؟
گراف یک ساختار ریاضی است که شامل:
- رأس‌ها (📍): نقاطی که اطلاعات را نمایش می‌دهند.
- یال‌ها (🔗): خطوطی که ارتباط بین رأس‌ها را نشان می‌دهند.

💡 انواع گراف‌ها:
1. جهت‌دار (➡️): یال‌ها دارای جهت هستند.
2. بدون جهت (🔄): یال‌ها بدون جهت‌اند.
3. وزن‌دار (🔢): هر یال یک وزن یا هزینه دارد.
4. غیر وزن‌دار (➖): یال‌ها بدون وزن هستند.



🔍 کاربردهای گراف‌ها:
- مسیریابی (🚗)
- شبکه‌های اجتماعی (👥)
- تحلیل شبکه‌ها (🌐)
- حل مسائل ریاضی (📐)


🎯 نمایش گراف‌ها:
1. ماتریس مجاورت (📊):
- هر سطر و ستون نشان‌دهنده یک رأس است.
- مقدار 1 یا وزن نشان‌دهنده وجود یال بین دو رأس است.

مثال (برای گراف وزن‌دار):

   0 3 0  
   3 0 7  
   0 7 0  
   

2. لیست مجاورت (📋):
- لیستی از رأس‌های متصل به هر رأس نگهداری می‌شود.

مثال:

   1 -> [(2, 3)]  
   2 -> [(1, 3), (3, 7)]  
   3 -> [(2, 7)]  
   

✨ کد نمونه در پایتون:

# تعریف گراف وزن‌دار با لیست مجاورت
graph = {
    '1': [('2', 3)],
    '2': [('1', 3), ('3', 7)],
    '3': [('2', 7)]
}
print("Graph:", graph)

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



#گراف #برنامه‌نویسی #آموزش_تلگرام #الگوریتم_گراف #یادگیری

پارت 2: الگوریتم‌های پیمایش گراف
یکی از مهم‌ترین بخش‌های کار با گراف‌ها، پیمایش (Traversal) است. با پیمایش گراف می‌توان به اطلاعات مختلف دست یافت، مانند:
- بررسی اتصال رأس‌ها (🔗).
- یافتن مسیر بین رأس‌ها (🚶‍♂️).
- تحلیل داده‌های گراف (📊).



🎯 انواع پیمایش گراف:
1. پیمایش عرضی (BFS - Breadth First Search):
- گراف را به صورت لایه‌لایه (📏) پیمایش می‌کند.
- از یک رأس شروع کرده و ابتدا رأس‌های مجاور را بررسی می‌کند.
- مناسب برای پیدا کردن کوتاه‌ترین مسیر.

💡 مراحل BFS:
1. رأس شروع را در یک صف (Queue) قرار دهید.
2. رأس جاری را بازدید کرده و رأس‌های مجاور را به صف اضافه کنید.
3. تا خالی شدن صف، مراحل را تکرار کنید.

✨ کد BFS در پایتون:

   from collections import deque

   def bfs(graph, start):
       visited = set()
       queue = deque([start])
       while queue:
           node = queue.popleft()
           if node not in visited:
               print(node, end=" ")
               visited.add(node)
               queue.extend(graph[node])

   # تعریف گراف
   graph = {
       '1': ['2', '3'],
       '2': ['4', '5'],
       '3': ['6'],
       '4': [],
       '5': [],
       '6': []
   }
   print("BFS:", end=" ")
   bfs(graph, '1')
   

2. پیمایش عمقی (DFS - Depth First Search):
- گراف را به صورت عمقی (🔍) پیمایش می‌کند.
- ابتدا رأس شروع و سپس رأس‌های فرزندان هر رأس بررسی می‌شوند.
- مناسب برای بررسی تمام مسیرهای ممکن.

💡 مراحل DFS:
1. رأس شروع را به یک پشته (Stack) اضافه کنید.
2. رأس جاری را بازدید کرده و رأس‌های فرزند را به پشته اضافه کنید.
3. تا خالی شدن پشته، مراحل را تکرار کنید.

✨ کد DFS در پایتون:

   def dfs(graph, start, visited=None):
       if visited is None:
           visited = set()
       visited.add(start)
       print(start, end=" ")
       for neighbor in graph[start]:
           if neighbor not in visited:
               dfs(graph, neighbor, visited)

   # تعریف گراف
   graph = {
       '1': ['2', '3'],
       '2': ['4', '5'],
       '3': ['6'],
       '4': [],
       '5': [],
       '6': []
   }
   print("DFS:", end=" ")
   dfs(graph, '1')
   

📚 جمع‌بندی:
- BFS برای پیدا کردن کوتاه‌ترین مسیر مناسب است.
- DFS برای جستجوی عمیق و بررسی همه مسیرها به‌کار می‌رود.
در پارت بعدی با الگوریتم‌های پیشرفته مثل دایکسترا و درخت پوشای کمینه آشنا خواهیم شد.


#پیمایش_گراف #BFS #DFS #الگوریتم_گراف #آموزش_تلگرام

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



🎯 الگوریتم‌های یافتن کوتاه‌ترین مسیر
1. الگوریتم دایکسترا (Dijkstra):
- برای گراف‌های وزن‌دار با یال‌های مثبت مناسب است.
- کوتاه‌ترین مسیر از یک رأس به تمام رأس‌های دیگر را پیدا می‌کند.

💡 مراحل:
1. مقدار فاصله از رأس شروع به خود را 0 و بقیه رأس‌ها را بی‌نهایت قرار دهید.
2. رأس‌هایی که بازدید نشده‌اند را بررسی کرده و مسیر کوتاه‌تر را به‌روزرسانی کنید.
3. تا بازدید از تمام رأس‌ها، مراحل را تکرار کنید.

✨ کد دایکسترا در پایتون:

   import heapq

   def dijkstra(graph, start):
       distances = {node: float('inf') for node in graph}
       distances[start] = 0
       priority_queue = [(0, start)]

       while priority_queue:
           current_distance, current_node = heapq.heappop(priority_queue)

           if current_distance > distances[current_node]:
               continue

           for neighbor, weight in graph[current_node].items():
               distance = current_distance + weight
               if distance < distances[neighbor]:
                   distances[neighbor] = distance
                   heapq.heappush(priority_queue, (distance, neighbor))

       return distances

   # تعریف گراف
   graph = {
       '1': {'2': 4, '3': 1},
       '2': {'4': 1},
       '3': {'2': 2, '4': 5},
       '4': {}
   }
   print("Shortest distances:", dijkstra(graph, '1'))
   

2. الگوریتم بلمن-فورد (Bellman-Ford):
- برای گراف‌های وزن‌دار با یال‌های مثبت و منفی مناسب است.
- همچنین حلقه‌های منفی (Negative Cycles) را تشخیص می‌دهد.

💡 مراحل:
1. فاصله از رأس شروع را به 0 و بقیه رأس‌ها را بی‌نهایت قرار دهید.
2. برای تمام یال‌ها، مسیرها را بهینه کنید.
3. در صورت وجود بهینه‌سازی اضافی پس از n-1 بار، حلقه منفی وجود دارد.


🎯 درخت پوشای کمینه (Minimum Spanning Tree)
1. الگوریتم کروسکال (Kruskal):
- برای یافتن درختی که همه رأس‌ها را با کمترین هزینه متصل کند.
- ابتدا یال‌ها را بر اساس وزن مرتب کرده و یکی‌یکی اضافه می‌کند.
- از اتحاد و یافتن (Union-Find) برای جلوگیری از حلقه استفاده می‌کند.

2. الگوریتم پریم (Prim):
- مشابه کروسکال، اما از یک رأس شروع می‌کند و رأس‌های متصل‌شده را گسترش می‌دهد.



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

امیدوارم این آموزش مفید بوده باشد! 🙌



#دایکسترا #بلمن_فورد #درخت_پوشا #الگوریتم_گراف #آموزش_تلگرام

؟

🎓 آموزش الگوریتم مرتب‌سازی رادیکس (پارت 1)

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



🌟 الگوریتم رادیکس چیست؟
الگوریتم Radix Sort یک روش مرتب‌سازی غیرمقایسه‌ای است.
این روش به جای مقایسه عناصر، اعداد را بر اساس ارقامشان مرتب می‌کند، از رقم کم‌ارزش‌تر (Least Significant Digit) به رقم پرارزش‌تر (Most Significant Digit) یا برعکس.

✅ این الگوریتم مناسب داده‌هایی است که به صورت عددی یا رشته‌ای (مانند اعداد کارت بانکی یا کد پستی) هستند.



🧠 ایده اصلی پشت Radix Sort
ایده ساده است:
1. ابتدا اعداد را بر اساس رقم یکان مرتب می‌کنیم.
2. سپس بر اساس رقم دهگان، صدگان، و الی آخر.
3. در نهایت، لیستی مرتب خواهیم داشت! 🎉



💡 چرا Radix Sort مهم است؟
1. سریع‌تر از بسیاری از الگوریتم‌ها: اگر داده‌ها توزیع مناسبی داشته باشند، رادیکس می‌تواند عملکرد بهتری نسبت به الگوریتم‌های مقایسه‌ای مانند Quick Sort یا Merge Sort داشته باشد.
2. پیاده‌سازی ساده برای داده‌های خاص: اگر طول داده‌ها محدود باشد، این روش بسیار کارآمد است.



🎯 کاربردهای Radix Sort
- مرتب‌سازی شماره حساب‌ها
- مرتب‌سازی کدهای پستی
- سیستم‌های بانکی و تجاری


🧩 در پارت بعدی...
در پارت 2، به مراحل و نحوه عملکرد الگوریتم رادیکس همراه با مثال واقعی می‌پردازیم!
حتماً دنبال کنید و یادگیری را ادامه دهید. 🌱

بزن رو این تا بیشتر یاد بگیری

#آموزش_پایتون #مرتب_سازی #RadixSort #الگوریتم #پایتون #برنامه_نویسی

🎓 آموزش الگوریتم مرتب‌سازی رادیکس (پارت ۲)

🔰 مراحل و نحوه عملکرد الگوریتم رادیکس

در پارت قبل با مفهوم کلی Radix Sort آشنا شدیم. حالا در این بخش می‌خواهیم مراحل اجرای این الگوریتم را با توضیحات و یک مثال کاربردی بررسی کنیم. 🛠️


🌟 مراحل اجرای Radix Sort
1️⃣ شناسایی بیشترین رقم عدد:
ابتدا طول بزرگ‌ترین عدد را پیدا می‌کنیم (تعداد ارقام). این به ما می‌گوید که چند مرحله نیاز به مرتب‌سازی داریم.

2️⃣ مرتب‌سازی بر اساس ارقام (از راست به چپ):
- ابتدا اعداد را بر اساس رقم یکان مرتب می‌کنیم.
- سپس به رقم دهگان، صدگان و ... می‌رویم.

3️⃣ استفاده از مرتب‌سازی پایدار (Stable Sort):
در هر مرحله، باید از یک روش مرتب‌سازی پایدار (مثل Counting Sort) استفاده کنیم، تا ترتیب قبلی حفظ شود.

4️⃣ تکرار تا رسیدن به رقم بیشینه:
این فرآیند تا مرتب شدن کامل ادامه پیدا می‌کند.



🧠 مثال: مرتب‌سازی لیست [170, 45, 75, 90, 802, 24, 2, 66]

#### 🔹 مرحله ۱: مرتب‌سازی بر اساس رقم یکان
اعداد را بر اساس رقم یکان مرتب می‌کنیم:
[170, 802, 2, 24, 45, 75, 66, 90]

🔹 مرحله ۲: مرتب‌سازی بر اساس رقم دهگان
اعداد را بر اساس رقم دهگان مرتب می‌کنیم:
[802, 2, 24, 45, 66, 170, 75, 90]

🔹 مرحله ۳: مرتب‌سازی بر اساس رقم صدگان
اعداد را بر اساس رقم صدگان مرتب می‌کنیم:
[2, 24, 45, 66, 75, 90, 170, 802]

✅ اکنون لیست مرتب‌شده نهایی داریم:
[2, 24, 45, 66, 75, 90, 170, 802] 🎉



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



🧩 در پارت بعدی...
در پارت ۳، کدنویسی الگوریتم Radix Sort در پایتون را گام به گام بررسی می‌کنیم. آماده شوید تا کد بنویسیم! 👩‍💻👨‍💻



🔗 بزن رو این تا بیشتر یاد بگیری

#آموزش_پایتون #مرتب_سازی #RadixSort #الگوریتم #پایتون #برنامه_نویسی

🎓 آموزش الگوریتم مرتب‌سازی رادیکس (پارت ۳)

🔰 پیاده‌سازی Radix Sort در پایتون

در این بخش با هم کدنویسی الگوریتم Radix Sort را در پایتون انجام می‌دهیم. با یک رویکرد ساده و گام‌به‌گام پیش می‌رویم تا همه چیز کاملاً شفاف و قابل‌فهم باشد.

🌟 کد Radix Sort گام‌به‌گام

1️⃣ مرتب‌سازی کمکی با Counting Sort
ابتدا یک تابع برای مرتب‌سازی پایدار (Stable Sort) براساس رقم خاص (یکان، دهگان و ...) ایجاد می‌کنیم.

def counting_sort(arr, exp):
    n = len(arr)
    output = [0] * n  # آرایه خروجی
    count = [0] * 10  # آرایه شمارش (اعداد 0 تا 9)

    # شمارش تعداد وقوع هر رقم
    for i in range(n):
        index = (arr[i] // exp) % 10
        count[index] += 1

    # تغییر آرایه شمارش برای یافتن موقعیت هر عنصر
    for i in range(1, 10):
        count[i] += count[i - 1]

    # ساخت آرایه خروجی
    i = n - 1
    while i >= 0:
        index = (arr[i] // exp) % 10
        output[count[index] - 1] = arr[i]
        count[index] -= 1
        i -= 1

    # کپی آرایه خروجی به آرایه اصلی
    for i in range(n):
        arr[i] = output[i]

2️⃣ تابع اصلی Radix Sort
حال، یک تابع اصلی ایجاد می‌کنیم که از تابع Counting Sort استفاده کرده و داده‌ها را مرحله به مرحله مرتب می‌کند.

def radix_sort(arr):
    # یافتن بزرگ‌ترین عدد برای تعیین تعداد ارقام
    max_num = max(arr)
    exp = 1  # مقدار اولیه (یکان)

    # مرتب‌سازی برای هر رقم (یکان، دهگان، ...)
    while max_num // exp > 0:
        counting_sort(arr, exp)
        exp *= 10

3️⃣ آزمایش الگوریتم با مثال
حالا الگوریتم خود را روی یک مجموعه داده اجرا می‌کنیم.

if __name__ == "__main__":
    arr = [170, 45, 75, 90, 802, 24, 2, 66]
    print("قبل از مرتب‌سازی:", arr)
    radix_sort(arr)
    print("بعد از مرتب‌سازی:", arr)

🧪 خروجی کد:

قبل از مرتب‌سازی: [170, 45, 75, 90, 802, 24, 2, 66]  
بعد از مرتب‌سازی: [2, 24, 45, 66, 75, 90, 170, 802]

🎉 الگوریتم به‌درستی اجرا شد و لیست مرتب شد!



🔑 نکات کدنویسی:
- دقت کنید که Counting Sort مرتب‌سازی پایدار است، یعنی ترتیب اعداد با مقدار یکسان حفظ می‌شود.
- این الگوریتم زمانی کارآمد است که تعداد ارقام بزرگ‌تر از تعداد کل مقایسه‌ها در الگوریتم‌های دیگر نباشد.



🧩 در پارت بعدی...
در پارت ۴، به تحلیل زمان اجرا، پیچیدگی زمانی و فضایی، و مزایا و معایب الگوریتم Radix Sort می‌پردازیم. حتماً همراه ما باشید! 🌟



🔗 بزن رو این تا بیشتر یاد بگیری

#آموزش_پایتون #مرتب_سازی #RadixSort #الگوریتم #پایتون #برنامه_نویسی

🎓 آموزش الگوریتم مرتب‌سازی رادیکس (پارت ۴)

🔰 تحلیل و بررسی Radix Sort

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



🌟 پیچیدگی زمانی Radix Sort

✅ حالت عادی (Average Case):
اگر تعداد عناصر لیست n و بیشترین طول ارقام d باشد:

O(n * d)

یعنی زمان اجرا خطی است، به شرطی که تعداد ارقام d کوچک باشد.

✅ حالت بدترین (Worst Case):
مشابه حالت عادی:

O(n * d)

✅ حالت بهترین (Best Case):
باز هم همان پیچیدگی:

O(n * d)

🌟 پیچیدگی فضایی (Space Complexity):
Radix Sort به دلیل استفاده از آرایه کمکی (مثل آرایه شمارش)، به فضای اضافی نیاز دارد:

O(n + k)

که k تعداد مقدارهای ممکن در هر رقم است (برای اعداد دهدهی، معمولاً 10).



🌟 مزایا و معایب Radix Sort

✅ مزایا:
1. پیچیدگی زمانی خطی: در داده‌هایی با تعداد رقم کم، Radix Sort عملکرد سریعی دارد.
2. مرتب‌سازی پایدار: ترتیب عناصر مشابه حفظ می‌شود، که در مسائل خاص مفید است.
3. عدم نیاز به مقایسه: برخلاف Quick Sort یا Merge Sort، این الگوریتم بر اساس مقایسه عمل نمی‌کند.

❌ معایب:
1. نیاز به فضای اضافی: استفاده از آرایه‌های کمکی باعث مصرف حافظه بیشتری می‌شود.
2. محدودیت داده‌ها: این الگوریتم برای داده‌های با طول زیاد (مثل رشته‌های بسیار بزرگ) کارآمد نیست.
3. وابستگی به تعداد ارقام: اگر تعداد ارقام زیاد باشد، Radix Sort ناکارآمد می‌شود.

🌟 چه زمانی از Radix Sort استفاده کنیم؟
- داده‌های عددی بزرگ با ارقام کم: مانند کدهای پستی، شماره حساب‌ها و ...
- وقتی نیاز به مرتب‌سازی پایدار داریم: چون ترتیب عناصر با مقدار برابر حفظ می‌شود.
- وقتی مقایسه‌ها در مرتب‌سازی گران است: مثل داده‌های خاص که مقایسه‌ی مستقیم دشوار است.



🧩 نتیجه‌گیری
Radix Sort یک الگوریتم قدرتمند و کارآمد برای مرتب‌سازی اعداد است، مخصوصاً در شرایطی که تعداد ارقام محدود باشد. با این حال، اگر به فضای زیادی نیاز نداشته باشید یا داده‌های خاصی دارید، ممکن است الگوریتم‌های دیگر مانند Quick Sort یا Merge Sort انتخاب بهتری باشند.



🔗 بزن رو این تا بیشتر یاد بگیری

#آموزش_پایتون #مرتب_سازی #RadixSort #الگوریتم #پایتون #برنامه_نویسی

شبکه‌های عصبی مصنوعی: مغز ماشینی دنیای مدرن 🧠🤖

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



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

ساختار کلی:
1. لایه ورودی (Input Layer): داده‌های خام (مثل تصویر، صدا، یا عدد) وارد این لایه می‌شوند.
2. لایه‌های پنهان (Hidden Layers): این لایه‌ها همان‌جایی هستند که جادو رخ می‌دهد. در هر گره (یا نورون)، داده‌ها با وزن‌ها ضرب شده، جمع شده و از یک تابع غیرخطی (فعال‌سازی) عبور می‌کنند.
3. لایه خروجی (Output Layer): نتیجه نهایی (مثل پیش‌بینی یک کلاس یا تولید یک مقدار عددی) از این لایه به دست می‌آید.



چگونه یک نورون مصنوعی کار می‌کند؟
بیایید یک نورون ساده را بررسی کنیم:
1. هر نورون ورودی‌هایی از نورون‌های قبلی می‌گیرد (مثل داده خام یا خروجی یک نورون دیگر).
2. این ورودی‌ها با مقادیری به نام وزن‌ها (Weights) ضرب می‌شوند. وزن‌ها نشان می‌دهند که هر ورودی چقدر مهم است.
3. خروجی حاصل از وزن‌ها جمع می‌شود و یک مقدار بایاس (Bias) به آن اضافه می‌شود.
4. نتیجه به یک تابع فعال‌سازی (Activation Function) داده می‌شود تا غیرخطی شود. این مرحله بسیار مهم است، زیرا به مدل امکان می‌دهد مسائل پیچیده را حل کند.

فرمول ریاضی یک نورون:

import numpy as np

# داده‌های ورودی (مثال: ویژگی‌های یک داده)
inputs = np.array([1.2, 2.3, 3.4])  # x1, x2, x3

# وزن‌های هر ورودی (چقدر هر ورودی مهم است)
weights = np.array([0.5, -0.7, 0.9])  # w1, w2, w3

# مقدار بایاس (bias)
bias = 1.0  # مقدار ثابت اضافه‌شده

# محاسبه خروجی نورون
# 1. ضرب هر ورودی در وزن مربوطه
weighted_sum = np.dot(inputs, weights)  # مجموع وزن‌دار x1*w1 + x2*w2 + x3*w3

# 2. افزودن بایاس
weighted_sum += bias  # مجموع وزن‌دار به‌علاوه بایاس

# 3. اعمال تابع فعال‌سازی (برای غیرخطی‌سازی)
def activation_function(x):
    return 1 / (1 + np.exp(-x))  # تابع سیگموید (نمونه‌ای از توابع فعال‌سازی)

output = activation_function(weighted_sum)  # نتیجه نهایی نورون

# چاپ خروجی
print(f"Weighted Sum: {weighted_sum}")
print(f"Neuron Output: {output}")

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



اتفاقات پشت پرده: محاسبات روی سخت‌افزار
1. سخت‌افزار محاسباتی:
شبکه‌های عصبی نیازمند حجم زیادی از محاسبات موازی هستند. اینجا جایی است که پردازنده‌ها (CPU) و واحدهای پردازش گرافیکی (GPU/TPU) وارد عمل می‌شوند:
- CPU (واحد پردازش مرکزی): وظایف سریالی و عملیات منطقی را اجرا می‌کند. مناسب برای کارهای سبک و کنترل کلی سیستم.
- GPU (واحد پردازش گرافیکی): طراحی‌شده برای پردازش موازی. ایده‌آل برای انجام محاسبات ماتریسی سنگین در شبکه‌های عصبی.
- TPU (واحد پردازش تنسوری): سخت‌افزار خاص گوگل برای شتاب‌دهی به محاسبات یادگیری ماشین. سرعت بسیار بالایی در عملیات ماتریسی دارد.

2. محاسبات ماتریسی:
- هر لایه از شبکه عصبی را می‌توان به شکل یک ضرب ماتریسی بزرگ در نظر گرفت. به همین دلیل GPU‌ها و TPU‌ها در این زمینه کارآمد هستند.
- مثال:
اگر لایه‌ای 1000 ورودی و 500 نورون داشته باشد ضرب ماتریسی میشود.

3. بهینه‌سازی حافظه:
برای اجرای مدل‌های بزرگ، حافظه بهینه استفاده می‌شود. بچ‌پردازش (Batch Processing) به مدل کمک می‌کند تا داده‌ها را به دسته‌های کوچک‌تر تقسیم کرده و پردازش کند.



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

1. فاز پیش‌رو (Forward Pass):
- داده از لایه‌های شبکه عبور می‌کند و خروجی تولید می‌شود.
- هر نورون ورودی را پردازش کرده و خروجی را به نورون بعدی ارسال می‌کند.

2. محاسبه خطا (Loss Calculation):
- خطا (Loss) میزان اختلاف بین خروجی مدل و مقدار واقعی (برچسب) را نشان می‌دهد.
- توابعی مثل MSE یا Cross-Entropy برای محاسبه خطا استفاده می‌شوند.

3. فاز پس‌انتشار (Backward Pass):
- با استفاده از الگوریتم پس‌انتشار (Backpropagation)، خطا به عقب شبکه منتقل می‌شود.
- گرادیان نزولی (Gradient Descent) وزن‌ها را به‌گونه‌ای به‌روزرسانی می‌کند که خطا کاهش یابد.



سوال مهم: چرا شبکه‌های عصبی اینقدر قدرتمند هستند؟
1. توانایی یادگیری غیرخطی: به لطف توابع فعال‌سازی، شبکه‌های عصبی می‌توانند روابط پیچیده غیرخطی را یاد بگیرند.
2. مقیاس‌پذیری: شبکه‌های عصبی بزرگ‌تر و عمیق‌تر می‌توانند وظایف پیچیده‌تری را انجام دهند.
3. تنوع کاربرد: از تشخیص تصویر گرفته تا پردازش زبان طبیعی (NLP) و پیش‌بینی سری‌های زمانی.



چالش‌ها و محدودیت‌ها:
1. نیاز به داده‌های زیاد برای آموزش.
2. مصرف منابع محاسباتی بالا.
3. حساسیت به تنظیمات هایپرپارامترها.



مثالی واقعی: شناسایی دست‌نوشته با شبکه عصبی
فرض کنید می‌خواهید اعداد دست‌نوشته را شناسایی کنید:
1. ورودی: تصویر 28x28 پیکسلی از یک عدد.
2. لایه‌های پنهان: نورون‌ها ویژگی‌هایی مثل خطوط و منحنی‌ها را شناسایی می‌کنند.
3. خروجی: یکی از 10 عدد (0 تا 9).



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

مثال

import numpy as np

# ======= توابع فعال‌سازی برای هر نورون =======
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def relu(x):
    return np.maximum(0, x)

# ======= تعریف نورون‌ها به صورت توابع مستقل =======
def neuron_1(inputs, weights, bias):
    return relu(np.dot(inputs, weights) + bias)

def neuron_2(inputs, weights, bias):
    return sigmoid(np.dot(inputs, weights) + bias)

def neuron_3(inputs, weights, bias):
    return np.tanh(np.dot(inputs, weights) + bias)

def neuron_4(inputs, weights, bias):
    return np.exp(-np.abs(np.dot(inputs, weights) + bias))

# ======= تنظیمات شبکه =======
np.random.seed(42)

# تعداد نورون‌های هر لایه
input_neurons = 2
hidden_neurons = [3, 3, 3, 3]  # چهار لایه پنهان با مجموع 12 نورون
output_neurons = 2

# ======= وزن‌ها و بایاس‌ها =======
weights = {
    "layer_1": np.random.randn(input_neurons, hidden_neurons[0]),
    "layer_2": np.random.randn(hidden_neurons[0], hidden_neurons[1]),
    "layer_3": np.random.randn(hidden_neurons[1], hidden_neurons[2]),
    "layer_4": np.random.randn(hidden_neurons[2], hidden_neurons[3]),
    "output": np.random.randn(hidden_neurons[3], output_neurons)
}

biases = {
    "layer_1": np.random.randn(hidden_neurons[0]),
    "layer_2": np.random.randn(hidden_neurons[1]),
    "layer_3": np.random.randn(hidden_neurons[2]),
    "layer_4": np.random.randn(hidden_neurons[3]),
    "output": np.random.randn(output_neurons)
}

# ======= ورودی اولیه =======
inputs = np.array([0.5, -1.5])

# ======= فاز پیش‌رو (Forward Pass) =======
# لایه 1
layer_1_output = np.array([
    neuron_1(inputs, weights["layer_1"][:, 0], biases["layer_1"][0]),
    neuron_2(inputs, weights["layer_1"][:, 1], biases["layer_1"][1]),
    neuron_3(inputs, weights["layer_1"][:, 2], biases["layer_1"][2])
])

# لایه 2
layer_2_output = np.array([
    neuron_2(layer_1_output, weights["layer_2"][:, 0], biases["layer_2"][0]),
    neuron_3(layer_1_output, weights["layer_2"][:, 1], biases["layer_2"][1]),
    neuron_4(layer_1_output, weights["layer_2"][:, 2], biases["layer_2"][2])
])

# لایه 3
layer_3_output = np.array([
    neuron_1(layer_2_output, weights["layer_3"][:, 0], biases["layer_3"][0]),
    neuron_3(layer_2_output, weights["layer_3"][:, 1], biases["layer_3"][1]),
    neuron_4(layer_2_output, weights["layer_3"][:, 2], biases["layer_3"][2])
])

# لایه 4
layer_4_output = np.array([
    neuron_2(layer_3_output, weights["layer_4"][:, 0], biases["layer_4"][0]),
    neuron_3(layer_3_output, weights["layer_4"][:, 1], biases["layer_4"][1]),
    neuron_4(layer_3_output, weights["layer_4"][:, 2], biases["layer_4"][2])
])

# لایه خروجی
output = np.array([
    neuron_1(layer_4_output, weights["output"][:, 0], biases["output"][0]),
    neuron_2(layer_4_output, weights["output"][:, 1], biases["output"][1])
])

# ======= نمایش خروجی =======
print("Input:", inputs)
print("Layer 1 Output:", layer_1_output)
print("Layer 2 Output:", layer_2_output)
print("Layer 3 Output:", layer_3_output)
print("Layer 4 Output:", layer_4_output)
print("Final Output:", output)

پارت ۱: مقدمات پیشرفته حلقه for (قسمت ۱/۴)

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

---

1. مفهوم for در پایتون
برخلاف زبان‌هایی مثل C++ یا Java که از شاخص‌ها استفاده می‌کنند، پایتون از Iterable Objects استفاده می‌کند. یعنی:
- حلقه for مستقیماً با مقادیر مجموعه کار می‌کند، نه صرفاً شاخص‌ها.
- هر چیزی که قابل تکرار (Iterable) باشد، می‌تواند در حلقه for پیمایش شود.

2. ساختار کلی حلقه for

for variable in iterable:
    # دستورات

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

مثال پایه‌ای:

names = ['Alice', 'Bob', 'Charlie']
for name in names:
    print(name)

خروجی:

Alice  
Bob  
Charlie

---

3. پیمایش روی اعداد با range()
تابع range() ابزاری قدرتمند برای تولید توالی عددی است.

مثال:

for i in range(5):  # تولید اعداد از 0 تا 4
    print(i)

خروجی:

0  
1  
2  
3  
4

تخصیص محدوده در range():
تابع range() سه پارامتر دارد:
- شروع (اختیاری): عدد شروع (پیش‌فرض ۰).
- پایان: عدد انتهایی (این عدد شامل نمی‌شود).
- گام (اختیاری): فاصله بین اعداد.

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

for i in range(2, 10, 2):  # تولید اعداد ۲، ۴، ۶، ۸
    print(i)

---

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

for _ in range(5):
    pass  # حلقه اجرا می‌شود ولی کاری انجام نمی‌دهد

---

ادامه دارد...
در قسمت دوم، با حلقه‌های تو در تو و ابزارهای حرفه‌ای مانند enumerate آشنا خواهیم شد.

برای دیدن پارت های بعدی و آموزش های بیشتر در این چنل عضو شوید

پارت ۱: مقدمات پیشرفته حلقه for (قسمت ۲/۴)

در این قسمت، به موضوعات پیشرفته‌تر مانند حلقه‌های تو در تو (Nested Loops) و استفاده از ابزارهای حرفه‌ای مثل enumerate و zip می‌پردازیم. این موارد به شما کمک می‌کند از حلقه for به شیوه‌ای بهینه‌تر استفاده کنید.

---

1. حلقه‌های تو در تو (Nested Loops)
گاهی اوقات برای پردازش داده‌های چندلایه (مثل لیست‌های تو در تو)، نیاز به حلقه‌های تو در تو دارید.

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

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

for row in matrix:
    for item in row:
        print(item, end=" ")  # نمایش همه اعداد در یک خط

خروجی:

1 2 3 4 5 6 7 8 9

مثال: محاسبه مجموع عناصر

total = 0
for row in matrix:
    for item in row:
        total += item
print(f"Total: {total}")

خروجی:

Total: 45

---

2. پیمایش همراه با اندیس (Index) با enumerate
تابع enumerate امکان پیمایش همزمان مقدار و اندیس هر عنصر را می‌دهد.

مثال:

names = ['Alice', 'Bob', 'Charlie']
for index, name in enumerate(names):
    print(f"{index}: {name}")

خروجی:

0: Alice  
1: Bob  
2: Charlie

کاربرد: پیدا کردن موقعیت یک عنصر خاص

numbers = [10, 20, 30, 40]
for index, num in enumerate(numbers):
    if num == 30:
        print(f"Found 30 at index {index}")
        break

خروجی:

Found 30 at index 2

---

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

مثال:

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]

for name, age in zip(names, ages):
    print(f"{name} is {age} years old.")

خروجی:

Alice is 25 years old.  
Bob is 30 years old.  
Charlie is 35 years old.

---

4. ترکیب enumerate و zip برای پیمایش پیشرفته
می‌توانید enumerate و zip را با هم ترکیب کنید تا اندیس‌ها و مقادیر چند مجموعه را همزمان مدیریت کنید.

مثال:

for index, (name, age) in enumerate(zip(names, ages)):
    print(f"{index}: {name} - {age}")

خروجی:

0: Alice - 25  
1: Bob - 30  
2: Charlie - 35

---

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

برای دیدن پارت های بعدی و آموزش های بیشتر در این چنل عضو شوید

پارت ۱: مقدمات پیشرفته حلقه for (قسمت ۳/۴)

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

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

- مثال: فیلتر کردن اعداد زوج

numbers = [1, 2, 3, 4, 5, 6]  
for num in numbers:  
    if num % 2 == 0:  
        print(num)  

خروجی:
۲
۴
۶

- مثال: فیلتر کردن رشته‌های طولانی‌تر از ۳ کاراکتر

words = ['cat', 'dog', 'elephant', 'fox']  
for word in words:  
    if len(word) > 3:  
        print(word)  

خروجی:
elephant

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

- مثال: بررسی وجود یک عنصر

numbers = [10, 20, 30, 40]  
target = 30  

found = False  
for num in numbers:  
    if num == target:  
        found = True  
        break  

if found:  
    print("Number found!")  
else:  
    print("Number not found!")  

خروجی:
Number found!

۳. معرفی List Comprehension
List Comprehension یکی از روش‌های کوتاه و قدرتمند برای تولید یا فیلتر کردن لیست‌ها است.

- مثال ۱: تولید یک لیست جدید با اعداد زوج

numbers = [1, 2, 3, 4, 5, 6]  
even_numbers = [num for num in numbers if num % 2 == 0]  
print(even_numbers)  

خروجی:
[2, 4, 6]

- مثال ۲: تولید مقادیر مربع یک لیست

numbers = [1, 2, 3, 4, 5]  
squares = [num**2 for num in numbers]  
print(squares)  

خروجی:
[1, 4, 9, 16, 25]

۴. Nested List Comprehension (پیشرفته)
می‌توانید لیست‌های تو در تو را با استفاده از List Comprehension پردازش کنید.

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

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

flattened = [item for row in matrix for item in row]  
print(flattened)  

خروجی:
[1, 2, 3, 4, 5, 6, 7, 8, 9]

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

برای دیدن پارت های بعدی و آموزش های بیشتر در این چنل عضو شوید