ادامه پارت ۲: جستجوی دودویی (Binary Search) در آرایه 🔍📈

جستجوی دودویی یکی از کارآمدترین روش‌ها برای یافتن یک عنصر در یک آرایه مرتب‌شده است. این روش از رویکرد "تقسیم و تسخیر" (Divide and Conquer) استفاده می‌کند و پیچیدگی زمانی آن به صورت لگاریتمی است.

چگونه جستجوی دودویی کار می‌کند؟ 🤔

1. ابتدا، عنصر میانی (وسط) آرایه را پیدا کنید.
2. اگر عنصر مورد نظر کمتر از عنصر میانی است، جستجو را در نیمه چپ آرایه ادامه دهید.
3. اگر عنصر مورد نظر بیشتر از عنصر میانی است، جستجو را در نیمه راست آرایه ادامه دهید.
4. اگر عنصر میانی برابر با عنصر مورد نظر است، جستجو به پایان می‌رسد و اندیس آن بازگردانده می‌شود.
5. این فرآیند را تا زمانی که عنصر مورد نظر پیدا شود یا آرایه به بخش‌های کوچکتر تقسیم شود ادامه دهید.

پیچیدگی زمانی 🔄

پیچیدگی زمانی جستجوی دودویی O(log n) است، که بسیار سریع‌تر از جستجوی خطی با پیچیدگی O(n) است، به شرطی که آرایه مرتب باشد.

مثال کد:
در اینجا یک پیاده‌سازی از جستجوی دودویی در پایتون آمده است:

def binary_search(arr, value):
    low = 0
    high = len(arr) - 1
    
    while low <= high:
        mid = (low + high) // 2
        
        if arr[mid] == value:
            return mid
        elif arr[mid] < value:
            low = mid + 1
        else:
            high = mid - 1
    
    return -1  # در صورتی که عنصر پیدا نشود

arr = [10, 20, 30, 40, 50, 60]
index = binary_search(arr, 40)  # خروجی: 3
print("Index of 40:", index)

در این مثال، ابتدا آرایه مرتب شده arr داریم. سپس از تابع binary_search برای یافتن عنصر 40 استفاده می‌کنیم. این تابع مقدار 3 را که اندیس عنصر 40 است، بازمی‌گرداند.

نکات مهم در مورد جستجوی دودویی ⚠️

- آرایه مرتب: جستجوی دودویی تنها در آرایه‌های مرتب‌شده کار می‌کند. اگر آرایه شما مرتب نیست، ابتدا باید آن را مرتب کنید (مثلاً با استفاده از الگوریتم‌های مرتب‌سازی).
- پیچیدگی زمانی: این روش به خصوص برای آرایه‌های بزرگ بسیار کارآمد است و می‌تواند زمان جستجو را به شدت کاهش دهد.

جمع‌بندی 🎯

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

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

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#آرایه‌ها #جستجوی_دودویی #ساختمان_داده‌ها #برنامه‌نویسی #پایتون #آموزش

پارت ۳: لیست‌های پیوندی تک‌پیوندی 🔗📘

سلام دوستان! 🌟 در پارت سوم از سری آموزش‌های "آرایه‌ها و لیست‌های پیوندی"، به بررسی یکی از ساختارهای داده‌ای مهم به نام لیست‌های پیوندی تک‌پیوندی (Singly Linked Lists) می‌پردازیم. لیست‌های پیوندی یک ساختار داده‌ای قدرتمند و منعطف هستند که در بسیاری از کاربردهای برنامه‌نویسی استفاده می‌شوند. بیایید شروع کنیم! 🚀

لیست پیوندی تک‌پیوندی چیست؟ 🤔

یک لیست پیوندی تک‌پیوندی مجموعه‌ای از نودها (Node) است که هر نود شامل دو بخش است:
1. داده (Data): مقداری که می‌خواهیم در لیست ذخیره کنیم.
2. اشاره‌گر (Pointer): اشاره‌گری که به نود بعدی در لیست اشاره می‌کند.

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

تفاوت لیست پیوندی با آرایه‌ها ⚖️

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

پیاده‌سازی لیست پیوندی تک‌پیوندی در پایتون 🛠️

در اینجا یک پیاده‌سازی ساده از لیست پیوندی تک‌پیوندی در پایتون آمده است.

class Node:
    def __init__(self, data):
        self.data = data  # ذخیره داده
        self.next = None  # اشاره‌گر به نود بعدی

class LinkedList:
    def __init__(self):
        self.head = None  # سر لیست (شروع لیست)

    def insert_at_end(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node

    def display(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

# مثال استفاده
ll = LinkedList()
ll.insert_at_end(10)
ll.insert_at_end(20)
ll.insert_at_end(30)
ll.display()  # خروجی: 10 -> 20 -> 30 -> None

در این پیاده‌سازی:
- کلاس Node یک نود ساده را تعریف می‌کند که شامل داده و اشاره‌گر به نود بعدی است.
- کلاس LinkedList ساختار لیست پیوندی را تعریف می‌کند و شامل متدهایی برای اضافه کردن نود در انتهای لیست (insert_at_end) و نمایش لیست (display) است.

مزایا و معایب لیست‌های پیوندی تک‌پیوندی ⚠️

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

2. معایب ⚠️
- دسترسی خطی: برای دسترسی به یک عنصر خاص باید از ابتدای لیست شروع کنید، که می‌تواند زمان‌بر باشد.
- استفاده بیشتر از حافظه: هر نود به یک اشاره‌گر اضافی نیاز دارد که حافظه بیشتری مصرف می‌کند.

نتیجه‌گیری 🎯

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

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

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

پارت ۴: عملیات پایه روی لیست‌های پیوندی تک‌پیوندی 🔄🔗

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

۱. درج (Insertion) در لیست پیوندی ✏️

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

پیچیدگی زمانی:
- درج در ابتدای لیست O(1) است.
- درج در انتهای لیست O(n) است (زیرا باید تا انتهای لیست پیمایش کنیم).
- درج در وسط لیست O(n) است (زیرا باید محل دقیق درج را پیدا کنیم).

مثال کد:

class LinkedList:
    def __init__(self):
        self.head = None

    def insert_at_beginning(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node

    def insert_at_end(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node

    def insert_after(self, prev_node, data):
        if prev_node is None:
            print("Previous node must be in the list.")
            return
        new_node = Node(data)
        new_node.next = prev_node.next
        prev_node.next = new_node

ll = LinkedList()
ll.insert_at_beginning(10)
ll.insert_at_end(20)
ll.insert_after(ll.head, 15)  # درج 15 بعد از نود 10
ll.display()  # خروجی: 10 -> 15 -> 20 -> None

۲. حذف (Deletion) از لیست پیوندی ❌

حذف یک نود نیز به چند حالت انجام می‌شود:
1. حذف از ابتدای لیست: نود سر لیست حذف می‌شود و اشاره‌گر سر به نود بعدی منتقل می‌شود.
2. حذف از انتهای لیست: نود آخر لیست حذف می‌شود و اشاره‌گر نود قبلی به None تغییر می‌کند.
3. حذف از وسط لیست: نودی که باید حذف شود، از لیست برداشته می‌شود و اشاره‌گر نود قبلی به نود بعدی آن متصل می‌شود.

پیچیدگی زمانی:
- حذف از ابتدای لیست O(1) است.
- حذف از انتهای لیست O(n) است.
- حذف از وسط لیست O(n) است.

مثال کد:

class LinkedList:
    def delete_node(self, key):
        current = self.head

        if current and current.data == key:
            self.head = current.next
            current = None
            return

        prev = None
        while current and current.data != key:
            prev = current
            current = current.next

        if current is None:
            return

        prev.next = current.next
        current = None

ll = LinkedList()
ll.insert_at_end(10)
ll.insert_at_end(20)
ll.insert_at_end(30)
ll.delete_node(20)  # حذف نود با مقدار 20
ll.display()  # خروجی: 10 -> 30 -> None

۳. جستجو (Search) در لیست پیوندی 🔍

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

پیچیدگی زمانی: جستجو در لیست پیوندی O(n) است.

مثال کد:

class LinkedList:
    def search(self, key):
        current = self.head
        while current:
            if current.data == key:
                return True
            current = current.next
        return False

ll = LinkedList()
ll.insert_at_end(10)
ll.insert_at_end(20)
ll.insert_at_end(30)
found = ll.search(20)  # خروجی: True
print("Found 20:", found)

۴. به‌روزرسانی (Update) نود در لیست پیوندی 🔄

به‌روزرسانی به معنای تغییر مقدار یک نود خاص در لیست پیوندی است. برای این کار باید نود مورد نظر را پیدا کرده و داده آن را تغییر دهیم.

پیچیدگی زمانی: به‌روزرسانی O(n) است.

مثال کد:

class LinkedList:
    def update(self, old_data, new_data):
        current = self.head
        while current:
            if current.data == old_data:
                current.data = new_data
                return True
            current = current.next
        return False

ll = LinkedList()
ll.insert_at_end(10)
ll.insert_at_end(20)
ll.insert_at_end(30)
updated = ll.update(20, 25)  # تغییر مقدار نود 20 به 25
ll.display()  # خروجی: 10 -> 25 -> 30 -> None

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

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

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

پارت ۵: لیست‌های پیوندی دوپیوندی و حلقوی 🔗🔄

سلام دوستان! 🌟 در پارت پنجم از سری آموزش‌های "آرایه‌ها و لیست‌های پیوندی"، به بررسی دو نوع دیگر از لیست‌های پیوندی، یعنی لیست‌های پیوندی دوپیوندی (Doubly Linked Lists) و لیست‌های پیوندی حلقوی (Circular Linked Lists) می‌پردازیم. این ساختارها در مواقع خاصی می‌توانند بسیار مفید باشند. بیایید شروع کنیم! 🚀

۱. لیست پیوندی دوپیوندی (Doubly Linked List) چیست؟ ↔️

در لیست پیوندی دوپیوندی، هر نود شامل سه بخش است:
1. داده (Data): مقداری که می‌خواهیم ذخیره کنیم.
2. اشاره‌گر به نود قبلی (Prev Pointer): اشاره‌گری که به نود قبلی اشاره می‌کند.
3. اشاره‌گر به نود بعدی (Next Pointer): اشاره‌گری که به نود بعدی اشاره می‌کند.

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

مزایا:
- پیمایش در هر دو جهت (پیش‌روی و پس‌روی).
- حذف و درج نودها ساده‌تر است زیرا اشاره‌گر نود قبلی در دسترس است.

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

پیاده‌سازی ساده لیست پیوندی دوپیوندی در پایتون:

class Node:
    def __init__(self, data):
        self.data = data
        self.prev = None  # اشاره‌گر به نود قبلی
        self.next = None  # اشاره‌گر به نود بعدی

class DoublyLinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node
            new_node.prev = current

    def display_forward(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("None")

    def display_backward(self):
        current = self.head
        while current.next:
            current = current.next
        while current:
            print(current.data, end=" -> ")
            current = current.prev
        print("None")

# مثال استفاده
dll = DoublyLinkedList()
dll.append(10)
dll.append(20)
dll.append(30)
dll.display_forward()  # خروجی: 10 -> 20 -> 30 -> None
dll.display_backward() # خروجی: 30 -> 20 -> 10 -> None

۲. لیست پیوندی حلقوی (Circular Linked List) چیست؟ 🔁

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

مزایا:
- امکان پیمایش بی‌پایان در لیست.
- مناسب برای برنامه‌هایی که به چرخش دائمی نیاز دارند.

معایب:
- نیاز به مدیریت دقیق حلقه‌ها برای جلوگیری از حلقه‌های بی‌پایان.
- پیچیدگی بیشتر در برخی از عملیات‌ها مثل حذف نودها.

پیاده‌سازی ساده لیست پیوندی حلقوی در پایتون:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class CircularLinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = self.head
        else:
            current = self.head
            while current.next != self.head:
                current = current.next
            current.next = new_node
            new_node.next = self.head

    def display(self):
        if not self.head:
            return
        current = self.head
        while True:
            print(current.data, end=" -> ")
            current = current.next
            if current == self.head:
                break
        print(f"Back to {self.head.data}")

# مثال استفاده
cll = CircularLinkedList()
cll.append(10)
cll.append(20)
cll.append(30)
cll.display()  # خروجی: 10 -> 20 -> 30 -> Back to 10

۳. کاربردهای خاص لیست‌های پیوندی دوپیوندی و حلقوی 📊

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


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

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

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

پارت ۶: پروژه عملی ساده 🛠️🎯

سلام دوستان! 🌟 در پارت ششم از سری آموزش‌های "آرایه‌ها و لیست‌های پیوندی"، به پیاده‌سازی یک پروژه عملی ساده خواهیم پرداخت. این پروژه به ما کمک می‌کند تا مفاهیم یادگرفته شده از لیست‌های پیوندی را به کار ببریم و به تسلط بیشتری در این ساختار داده‌ای برسیم. بیایید شروع کنیم! 🚀

پروژه: ساخت یک دفترچه تلفن ساده با استفاده از لیست پیوندی 📞📚

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

مرحله ۱: تعریف کلاس‌های لازم 🏗️

ابتدا کلاس‌های مورد نیاز را تعریف می‌کنیم. شامل کلاس نود (Node) و کلاس لیست پیوندی (LinkedList).

class ContactNode:
    def __init__(self, name, phone_number):
        self.name = name
        self.phone_number = phone_number
        self.next = None

class PhoneBook:
    def __init__(self):
        self.head = None

    def add_contact(self, name, phone_number):
        new_contact = ContactNode(name, phone_number)
        if self.head is None:
            self.head = new_contact
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_contact

    def delete_contact(self, name):
        current = self.head
        prev = None
        while current:
            if current.name == name:
                if prev:
                    prev.next = current.next
                else:
                    self.head = current.next
                return True
            prev = current
            current = current.next
        return False

    def search_contact(self, name):
        current = self.head
        while current:
            if current.name == name:
                return current.phone_number
            current = current.next
        return None

    def display_contacts(self):
        current = self.head
        while current:
            print(f"Name: {current.name}, Phone Number: {current.phone_number}")
            current = current.next

مرحله ۲: استفاده از دفترچه تلفن 📝

اکنون با استفاده از کلاس PhoneBook، چندین تماس به دفترچه تلفن اضافه کرده، آن‌ها را جستجو و حذف خواهیم کرد و تمام تماس‌ها را نمایش خواهیم داد.

# ایجاد دفترچه تلفن و افزودن تماس‌ها
phone_book = PhoneBook()
phone_book.add_contact("Alice", "123-456-7890")
phone_book.add_contact("Bob", "987-654-3210")
phone_book.add_contact("Charlie", "555-123-4567")

# نمایش تمام تماس‌ها
print("Contacts:")
phone_book.display_contacts()

# جستجوی یک تماس
print("\nSearching for Bob's number:")
number = phone_book.search_contact("Bob")
print(f"Bob's Number: {number}")

# حذف یک تماس
print("\nDeleting Charlie's contact:")
deleted = phone_book.delete_contact("Charlie")
if deleted:
    print("Charlie has been deleted.")
else:
    print("Charlie was not found.")

# نمایش تماس‌ها پس از حذف
print("\nContacts after deletion:")
phone_book.display_contacts()

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

(⚠️ابنجا کیلیک کن تا بیشتر یاد بگیری⚠️)

#پروژه #دفترچه_تلفن #لیست_پیوندی #برنامه‌نویسی #ساختمان_داده‌ها #پایتون #آموزش

سری پنجم: گراف‌ها (Graphs) 🕸️
پارت ۶: تمرین و پروژه عملی 🚀

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

پروژه عملی: مسیریابی در نقشه 🗺️

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

مراحل پروژه:

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

2. پیاده‌سازی نمایندگی گراف:
- استفاده از لیست مجاورت برای نمایندگی گراف.
- تعریف کلاس برای گراف و اضافه کردن گره‌ها و یال‌ها.

   class Graph:
       def __init__(self):
           self.graph = {}

       def add_vertex(self, vertex):
           if vertex not in self.graph:
               self.graph[vertex] = {}

       def add_edge(self, u, v, weight):
           if u not in self.graph:
               self.add_vertex(u)
           if v not in self.graph:
               self.add_vertex(v)
           self.graph[u][v] = weight
           self.graph[v][u] = weight  # برای گراف بدون جهت
   

3. پیاده‌سازی الگوریتم‌های مسیریابی:
- استفاده از الگوریتم دیکسترا برای یافتن کوتاه‌ترین مسیر بین دو نقطه.
- پیاده‌سازی الگوریتم دیکسترا:

   import heapq

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

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

           if current_distance > distances[u]:
               continue

           for neighbor, weight in graph.graph[u].items():
               distance = current_distance + weight

               if distance < distances[neighbor]:
                   distances[neighbor] = distance
                   heapq.heappush(priority_queue, (distance, neighbor))

       return distances
   

4. اجرای پروژه:
- تعریف گراف با مکان‌ها و مسیرها.
- یافتن کوتاه‌ترین مسیر بین دو نقطه با استفاده از الگوریتم دیکسترا.

   # تعریف گراف
   g = Graph()
   g.add_edge('A', 'B', 1)
   g.add_edge('A', 'C', 4)
   g.add_edge('B', 'C', 2)
   g.add_edge('B', 'D', 5)
   g.add_edge('C', 'D', 1)

   # یافتن کوتاه‌ترین مسیر از 'A' به سایر نقاط
   distances = dijkstra(g, 'A')
   print(distances)
   

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


تمرین‌های تکمیلی ✏️

1. مسئله کوتاه‌ترین مسیر:
- پیاده‌سازی الگوریتم فلوید-وارشال برای یافتن همه‌به‌همه مسیرها در گراف.

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

3. گراف‌های جهت‌دار:
- پیاده‌سازی و تحلیل الگوریتم‌های جستجو و مسیریابی برای گراف‌های جهت‌دار.


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

(برای بیشتر یاد گفتن اینجا کلیک کن)

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

ارسال پارامترهای یک کلاس به کلاس دیگر در پایتون 🐍

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

مثال: ارسال پارامترهای یک کلاس به کلاس دیگر

class ClassA:
    def __init__(self, param1, param2):
        self.param1 = param1
        self.param2 = param2

class ClassB:
    def __init__(self, class_a_instance):
        self.param1 = class_a_instance.param1
        self.param2 = class_a_instance.param2
    
    def display_params(self):
        print(f"Param1: {self.param1}, Param2: {self.param2}")

# ایجاد یک شیء از کلاس A
a = ClassA(10, 20)

# ارسال شیء کلاس A به کلاس B
b = ClassB(a)

# نمایش مقادیر پارامترها در کلاس B
b.display_params()

توضیحات:

1. ClassA:
- این کلاس دو پارامتر param1 و param2 را دریافت کرده و آن‌ها را به عنوان ویژگی‌های (Attributes) شیء ذخیره می‌کند.

2. ClassB:
- این کلاس به عنوان ورودی یک شیء از نوع ClassA دریافت می‌کند و مقادیر param1 و param2 آن شیء را در خودش ذخیره می‌کند.
- متد display_params مقادیر این پارامترها را چاپ می‌کند.

3. نحوه استفاده:
- ابتدا یک شیء از کلاس A با مقادیر خاصی ایجاد می‌شود.
- سپس این شیء به کلاس B ارسال شده و مقادیر آن استخراج و در کلاس B مورد استفاده قرار می‌گیرد.

خروجی:

Param1: 10, Param2: 20

به همین سادگی می‌توانید پارامترهای یک کلاس را به کلاس دیگری ارسال کرده و از آن‌ها استفاده کنید! 😎

⚠️کلیک کن تا بیشتر یاد بگیری⚠️


#Python #برنامه‌نویسی #آموزش_پایتون #کلاس_ها #OOP

🚀 آموزش فریمورک Pyramid - پارت 1: مقدمه و نصب

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

🎯 اهداف پارت 1:
- معرفی فریمورک Pyramid
- نصب و پیکربندی اولیه
- ایجاد اولین برنامه وب ساده

1️⃣ نصب و پیکربندی
برای شروع کار با Pyramid، ابتدا باید آن را نصب کنیم. این کار را می‌توان با استفاده از pip انجام داد.

pip install "pyramid==2.0"

> 💡 نکته: بهتر است از یک محیط مجازی (virtual environment) استفاده کنید تا وابستگی‌های پروژه‌تان جدا از دیگر پروژه‌ها باشد.

برای ایجاد یک محیط مجازی:

python -m venv myenv
source myenv/bin/activate  # برای کاربران لینوکس یا مک
myenv\Scripts\activate  # برای کاربران ویندوز

سپس Pyramid را نصب کنید.

2️⃣ ایجاد اولین پروژه Pyramid
بعد از نصب Pyramid، حالا می‌خواهیم یک پروژه جدید ایجاد کنیم. با استفاده از دستورات زیر می‌توانید یک پروژه جدید به نام myproject بسازید:

pcreate -s starter myproject

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


📢 برای دیدن ادامه آموزش‌ها به کانال ما بپیوندید: [python3]

#پایتون #آموزش_پایتون #برنامه‌نویسی #Pyramid #وب #توسعه_وب

پارت ۱: معادله دیفرانسیل و کاربردهای آن

معادله دیفرانسیل چیست؟

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

انواع معادلات دیفرانسیل

1. معادلات دیفرانسیل معمولی (ODE): این معادلات مشتقات نسبت به یک متغیر مستقل را شامل می‌شوند. به عنوان مثال:

dy/dx = y

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

2. معادلات دیفرانسیل جزئی (PDE): این معادلات مشتقات جزئی نسبت به چندین متغیر مستقل را شامل می‌شوند. به عنوان مثال:

∂²u/∂t² = c² ∂²u/∂x²

که معادله موج است.

کاربردهای معادلات دیفرانسیل

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

1. فیزیک: برای مدل‌سازی حرکت اجسام، دینامیک سیالات و انتقال حرارت. به عنوان مثال، معادله حرکت نیوتن:

m d²x/dt² = F

2. مهندسی: در تحلیل و طراحی سیستم‌های کنترل، مدارهای الکتریکی و مکانیک. برای مثال، معادله RLC:

L d²i(t)/dt² + R di(t)/dt + (1/C) i(t) = 0

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

4. اقتصاد: در تحلیل فرآیندهای اقتصادی مانند رشد اقتصادی و تغییرات قیمت‌ها.

مثال ساده

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

dy/dt = -ky

که در آن k یک ثابت مثبت است و این معادله مدل‌کننده کاهش نمایی است.

برای اطلاعات بیشتر و آموزش‌های کاربردی، به کانال ما "Python3" مراجعه کنید: [Python3]

#معادله_دیفرانسیل #آموزش_پایتون #ریاضیات

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

در این پارت، به پیاده‌سازی معادلات دیفرانسیل با استفاده از پایتون خواهیم پرداخت. برای این منظور از کتابخانه‌های علمی محبوب مانند NumPy و SciPy استفاده خواهیم کرد. در این مثال، معادله دیفرانسیل ساده‌ای را حل خواهیم کرد.

۱. نصب کتابخانه‌های مورد نیاز 🛠️

ابتدا باید مطمئن شویم که کتابخانه‌های NumPy و SciPy نصب شده‌اند. اگر این کتابخانه‌ها را نصب نکرده‌اید، با استفاده از دستورات زیر در ترمینال خود آنها را نصب کنید:

pip install numpy scipy matplotlib

۲. تعریف معادله دیفرانسیل 📉

برای این مثال، معادله دیفرانسیل زیر را در نظر می‌گیریم:

Ky_ = dy /dt

که در آن( k ) یک ثابت مثبت است. این معادله به شکل ساده‌ای می‌تواند کاهش نمایی را مدل‌سازی کند.

۳. کدنویسی معادله دیفرانسیل 📜

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

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

# تعریف ثابت
k = 0.3

# تعریف تابع معادله دیفرانسیل
def model(y, t):
    dydt = -k * y
    return dydt

# شرایط اولیه
y0 = 5

# تعریف بازه زمانی
t = np.linspace(0, 20, 100)

# حل معادله دیفرانسیل
solution = odeint(model, y0, t)

# رسم نمودار
plt.plot(t, solution)
plt.xlabel('زمان (t)')
plt.ylabel('y(t)')
plt.title('حل معادله دیفرانسیل')
plt.grid(True)
plt.show()

۴. توضیحات ✏️

1. وارد کردن کتابخانه‌ها: با استفاده از import، کتابخانه‌های مورد نیاز را وارد کردیم.
2. تعریف تابع مدل: تابع model معادله دیفرانسیل را تعریف می‌کند.
3. تعریف شرایط اولیه و بازه زمانی: شرایط اولیه و بازه زمانی برای حل معادله دیفرانسیل تعیین می‌شود.
4. حل معادله دیفرانسیل: با استفاده از odeint معادله دیفرانسیل حل می‌شود.
5. رسم نمودار: با استفاده از matplotlib نمودار حل معادله دیفرانسیل رسم می‌شود.

برای مشاهده آموزش‌های بیشتر و کاربردی، به کانال ما "Python3" مراجعه کنید: [Python3]

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

پارت ۳: پیاده‌سازی پروژه واقعی با معادله دیفرانسیل

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

۱. تعریف مسئله پروژه 🔍

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

dT/dt = -k * (T - T_ambient)

که در آن:
- T دمای سیستم است.
- T_ambient دمای محیط است.
- k یک ثابت مثبت است که سرعت کاهش دما را مشخص می‌کند.

۲. نوشتن کد پایتون برای پروژه 📜

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

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

# پارامترها
k = 0.1  # ثابت کاهش دما
T_ambient = 20  # دمای محیط

# تابع معادله دیفرانسیل
def model(T, t):
    dTdt = -k * (T - T_ambient)
    return dTdt

# شرایط اولیه
T0 = 100  # دمای اولیه سیستم

# بازه زمانی
t = np.linspace(0, 50, 200)

# حل معادله دیفرانسیل
solution = odeint(model, T0, t)

# رسم نمودار
plt.plot(t, solution)
plt.xlabel('زمان (ثانیه)')
plt.ylabel('دما (درجه سانتی‌گراد)')
plt.title('کاهش دما در سیستم گرمایشی')
plt.grid(True)
plt.show()

۳. توضیحات کد 📝

1. تعریف پارامترها: مقادیر ثابت‌های k و T_ambient را مشخص می‌کنیم.
2. تعریف تابع مدل: تابع model معادله دیفرانسیل را پیاده‌سازی می‌کند و نرخ تغییر دما را محاسبه می‌کند.
3. تعریف شرایط اولیه و بازه زمانی: شرایط اولیه برای دما و بازه زمانی شبیه‌سازی تعیین می‌شود.
4. حل معادله دیفرانسیل: با استفاده از odeint، معادله دیفرانسیل حل می‌شود.
5. رسم نمودار: نمودار تغییرات دما بر اساس زمان رسم می‌شود تا روند کاهش دما را مشاهده کنیم.

۴. نتیجه‌گیری 🎯

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

برای دیدن آموزش‌های بیشتر و کاربردی، به کانال ما "Python3" مراجعه کنید: [Python3]

#پروژه_پایتون #معادله_دیفرانسیل #آموزش_پایتون #مدل‌سازی

پارت ۱: مقدمه‌ای بر ساخت صفحات گرافیکی با پایتون 🎨🐍

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

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

۲. آشنایی با کتابخانه‌های گرافیکی پایتون 🛠️

۲.۱. Tkinter
یکی از قدیمی‌ترین و پرکاربردترین کتابخانه‌ها برای ساخت رابط گرافیکی در پایتون، Tkinter است. این کتابخانه به صورت پیش‌فرض همراه پایتون نصب می‌شود و به شما اجازه می‌دهد به راحتی پنجره‌های گرافیکی بسازید.
ویژگی‌های بارز Tkinter:
- ساخت فرم‌های ساده و کاربردی
- مناسب برای پروژه‌های کوچک و میان‌رده
- سادگی و انعطاف بالا

نصب Tkinter
اگر Tkinter روی سیستم شما نصب نیست، می‌توانید آن را با دستور زیر نصب کنید:

pip install tk

مثال ساده از Tkinter
در این مثال ساده، یک پنجره گرافیکی ایجاد می‌کنیم:

import tkinter as tk

window = tk.Tk()  # ساخت پنجره اصلی
window.title("صفحه گرافیکی با Tkinter")  # عنوان پنجره
window.geometry("400x300")  # اندازه پنجره

label = tk.Label(window, text="سلام دنیا!", font=("Arial", 14))
label.pack()

window.mainloop()  # اجرای بی‌نهایت برنامه

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

نصب Pygame
برای نصب Pygame از دستور زیر استفاده کنید:

pip install pygame

مثال ساده از Pygame
در این مثال، یک پنجره بازی ساده ایجاد می‌کنیم:

import pygame

pygame.init()

window = pygame.display.set_mode((400, 300))  # اندازه پنجره
pygame.display.set_caption("صفحه گرافیکی با Pygame")

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    window.fill((0, 128, 255))  # رنگ پس‌زمینه
    pygame.display.flip()  # بروزرسانی پنجره

pygame.quit()

۳. معرفی دیگر کتابخانه‌های گرافیکی
به جز Tkinter و Pygame، کتابخانه‌های دیگری نیز برای ساخت صفحات گرافیکی با پایتون وجود دارند. برخی از این کتابخانه‌ها عبارت‌اند از:
- Kivy: مناسب برای ساخت اپلیکیشن‌های موبایل
- PyQt: مناسب برای ساخت رابط‌های کاربری پیچیده

در پارت بعدی، به طور عمیق‌تر وارد جزئیات ساخت گرافیک با هر یک از این کتابخانه‌ها خواهیم شد! 🎨

(رو اینجا بزن تا بیشتر یاد بگیری)

#پایتون #آموزش_پایتون #برنامه‌نویسی #ساخت_صفحه_گرافیکی #Tkinter #Pygame #کدنویسی

پارت ۲: جزئیات ساخت صفحات گرافیکی با Tkinter و Pygame 🎮📊

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

۱. ساخت صفحات گرافیکی پیشرفته‌تر با Tkinter 🖥️

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

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

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

import tkinter as tk

# ساخت پنجره اصلی
window = tk.Tk()
window.title("فرم با Tkinter")
window.geometry("400x200")

# برچسب و ورودی متن
label = tk.Label(window, text="نام خود را وارد کنید:")
label.pack()

entry = tk.Entry(window)
entry.pack()

# تابعی برای نمایش متن ورودی
def show_name():
    name = entry.get()  # گرفتن ورودی کاربر
    result_label.config(text=f"سلام، {name}!")

# دکمه‌ای برای تایید و نمایش نتیجه
button = tk.Button(window, text="نمایش نام", command=show_name)
button.pack()

# برچسبی برای نمایش نتیجه
result_label = tk.Label(window, text="")
result_label.pack()

window.mainloop()

۱.۲. استفاده از Canvas برای رسم اشکال
اگر بخواهید اشکال مختلفی را رسم کنید (مثل دایره، مربع یا خط)، می‌توانید از Canvas استفاده کنید.

مثال: رسم اشکال ساده

import tkinter as tk

window = tk.Tk()
window.title("رسم اشکال با Tkinter")

canvas = tk.Canvas(window, width=400, height=300)
canvas.pack()

# رسم یک خط
canvas.create_line(50, 50, 200, 50, fill="blue", width=3)

# رسم یک دایره
canvas.create_oval(50, 100, 150, 200, fill="red")

# رسم یک مستطیل
canvas.create_rectangle(200, 100, 300, 200, fill="green")

window.mainloop()

۱.۳. شخصی‌سازی بیشتر: تغییر رنگ‌ها و فونت‌ها
با Tkinter، به راحتی می‌توانید رنگ‌ها، فونت‌ها و اندازه المان‌های مختلف را شخصی‌سازی کنید. در مثال بالا، رنگ‌ها و اندازه خط را برای اشکال تعریف کردیم. شما همچنین می‌توانید از تنظیمات بیشتر مثل تغییر فونت استفاده کنید.

۲. کار با Pygame برای ساخت بازی‌های دوبعدی 🎮

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

۲.۱. اضافه کردن یک شی متحرک
برای شروع، یک شیء ساده مانند یک مربع یا دایره را اضافه می‌کنیم و آن را در صفحه حرکت می‌دهیم.

مثال: ایجاد یک مربع متحرک

import pygame

pygame.init()

window = pygame.display.set_mode((400, 300))
pygame.display.set_caption("مربع متحرک با Pygame")

# رنگ‌ها
white = (255, 255, 255)
blue = (0, 0, 255)

# موقعیت و اندازه مربع
x, y = 50, 50
width, height = 50, 50
speed = 5

running = True
while running:
    pygame.time.delay(50)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # گرفتن کلیدهای فشرده شده برای حرکت
    keys = pygame.key.get_pressed()
    
    if keys[pygame.K_LEFT]:
        x -= speed
    if keys[pygame.K_RIGHT]:
        x += speed
    if keys[pygame.K_UP]:
        y -= speed
    if keys[pygame.K_DOWN]:
        y += speed

    window.fill(white)  # پاک کردن صفحه
    pygame.draw.rect(window, blue, (x, y, width, height))  # رسم مربع
    pygame.display.update()  # به‌روزرسانی صفحه

pygame.quit()

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

مثال: بررسی برخورد مربع با مرزهای صفحه

import pygame

pygame.init()

window = pygame.display.set_mode((400, 300))
pygame.display.set_caption("برخورد در Pygame")

white = (255, 255, 255)
blue = (0, 0, 255)

x, y = 50, 50
width, height = 50, 50
speed = 5

running = True
while running:
    pygame.time.delay(50)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

ادامه کد بالا ☝️

keys = pygame.key.get_pressed()
    
    if keys[pygame.K_LEFT] and x > 0:
        x -= speed
    if keys[pygame.K_RIGHT] and x < 400 - width:
        x += speed
    if keys[pygame.K_UP] and y > 0:
        y -= speed
    if keys[pygame.K_DOWN] and y < 300 - height:
        y += speed

    window.fill(white)
    pygame.draw.rect(window, blue, (x, y, width, height))
    pygame.display.update()

pygame.quit()

۳. جمع‌بندی 📋

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

در پارت سوم، با کتابخانه‌های دیگر مثل Kivy و PyQt آشنا خواهیم شد و به مواردی مانند ساخت اپلیکیشن‌های موبایل و رابط‌های کاربری پیچیده می‌پردازیم.

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

#پایتون #آموزش_پایتون #برنامه‌نویسی #ساخت_صفحه_گرافیکی #Tkinter #Pygame #کدنویسی #طراحی_رابط_کاربری

پارت ۳: ساخت اپلیکیشن‌های پیچیده با Kivy و PyQt 📱💻

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

۱. ساخت اپلیکیشن‌های چندسکویی با Kivy 📱🌐

Kivy یک چارچوب چندسکویی متن‌باز است که به شما اجازه می‌دهد با یک کد واحد، اپلیکیشن‌هایی برای اندروید، iOS، ویندوز، لینوکس و macOS بسازید. این کتابخانه برای ساخت اپلیکیشن‌های موبایل و دسکتاپ با رابط کاربری لمسی مناسب است.

۱.۱. نصب Kivy
برای شروع کار با Kivy، کافی است با دستور زیر آن را نصب کنید:

pip install kivy

۱.۲. ویژگی‌های کلیدی Kivy
- چندسکویی بودن: با یک بار نوشتن کد می‌توانید اپلیکیشن را بر روی پلتفرم‌های مختلف اجرا کنید.
- رابط کاربری انعطاف‌پذیر: Kivy با پشتیبانی از طراحی گرافیکی پیشرفته و ویجت‌های متنوع، برای ساخت اپلیکیشن‌های تعاملی مناسب است.
- مناسب برای صفحات لمسی: Kivy به طور خاص برای ساخت اپلیکیشن‌هایی که با صفحات لمسی کار می‌کنند طراحی شده است.

۱.۳. قابلیت‌های مهم Kivy
- ویجت‌های متنوع: شامل دکمه‌ها، لیست‌ها، اسلایدرها، تب‌ها و ... .
- پشتیبانی از OpenGL ES: برای رندرینگ سه‌بعدی و گرافیک‌های پیچیده.
- قابلیت سفارشی‌سازی کامل: شما می‌توانید ویجت‌های خود را تعریف و سفارشی‌سازی کنید.

۱.۴. ساخت اپلیکیشن موبایل با Kivy
با استفاده از Kivy و ابزارهایی مثل Buildozer، می‌توانید اپلیکیشن خود را به فرمت APK برای اندروید تبدیل کنید. Buildozer فرآیند تبدیل کد پایتون به فایل نصب اندروید را برای توسعه‌دهندگان آسان کرده است.

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

۲. ساخت رابط‌های کاربری حرفه‌ای با PyQt 🎛️

PyQt یک کتابخانه معروف برای ساخت رابط‌های کاربری گرافیکی (GUI) پیچیده و پیشرفته است. این کتابخانه رابطی برای استفاده از Qt Framework است که یکی از قدرتمندترین ابزارها برای توسعه رابط‌های گرافیکی دسکتاپی محسوب می‌شود.

۲.۱. نصب PyQt
برای شروع کار با PyQt، با استفاده از دستور زیر آن را نصب کنید:

pip install PyQt5

۲.۲. ویژگی‌های کلیدی PyQt
- طراحی رابط کاربری پیشرفته: PyQt برای ساخت برنامه‌های دسکتاپی حرفه‌ای با المان‌های گرافیکی پیچیده مناسب است.
- ویجت‌های متنوع: PyQt شامل تعداد زیادی ویجت است که به شما امکان می‌دهد رابط‌های گرافیکی پیچیده بسازید.
- قابلیت استفاده از Qt Designer: ابزاری برای طراحی گرافیکی رابط کاربری بدون نیاز به کدنویسی.

۲.۳. قابلیت‌های مهم PyQt
- پشتیبانی از منوها، نوار ابزار و پنجره‌های چندگانه: برای ساخت برنامه‌های حرفه‌ای و کاربرپسند.
- سیستم سیگنال و اسلات: این سیستم امکان ارتباط بین ویجت‌ها را به سادگی فراهم می‌کند.
- پشتیبانی از طراحی با ابزار گرافیکی (Qt Designer): می‌توانید به راحتی با ابزار Qt Designer رابط کاربری طراحی کنید و سپس به پایتون تبدیل کنید.

۲.۴. ساخت اپلیکیشن دسکتاپ با PyQt
یکی از نقاط قوت PyQt این است که به شما امکان می‌دهد برنامه‌های پیچیده با رابط‌های کاربری غنی بسازید. با استفاده از ابزارهایی مانند Qt Designer، می‌توانید بدون نیاز به کدنویسی زیاد، رابط‌های کاربری حرفه‌ای و زیبایی طراحی کنید.

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

جمع‌بندی 📋

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

(از این آموزشای جالب اینجا پره)

#پایتون #Kivy #PyQt #برنامه‌نویسی #اپلیکیشن_موبایل #طراحی_رابط_کاربری #دسکتاپ #اپلیکیشن

پارت 1 - قسمت 1: آشنایی با الگوریتم "Exponentiation by Squaring"

موضوع:
"Exponentiation by Squaring" یک روش بسیار سریع و کارآمد برای محاسبه توان اعداد است، مخصوصاً زمانی که توان عدد بزرگ باشد. این روش از تکنیک "تقسیم و غلبه" استفاده می‌کند تا محاسبات را به حداقل برساند.



چرا به این الگوریتم نیاز داریم؟
فرض کنید می‌خواهید عدد 2 را به توان 10 برسانید. روش عادی این است که عدد 2 را ده بار در خودش ضرب کنید:

2 × 2 × 2 × 2 × 2 × 2 × 2 × 2 × 2 × 2

اما این روش برای توان‌های بزرگ بسیار کند می‌شود. الگوریتم "Exponentiation by Squaring" این مشکل را حل می‌کند و با تکرارهای کمتر، به نتیجه می‌رسد.



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



مثال ساده:
فرض کنید می‌خواهیم عدد 2 را به توان 10 برسانیم. این‌گونه عمل می‌کنیم:
1. توان 10 زوج است، پس عدد 2 به توان 5 را محاسبه می‌کنیم و سپس در خودش ضرب می‌کنیم.
2. توان 5 فرد است، پس یک ضرب اضافه می‌کنیم و توان 4 را حل می‌کنیم.
3. توان 4 زوج است، پس عدد 2 به توان 2 را محاسبه می‌کنیم و در خودش ضرب می‌کنیم.
4. توان 2 زوج است، پس عدد 2 به توان 1 را محاسبه می‌کنیم و در خودش ضرب می‌کنیم.



کد الگوریتم در پایتون:

def exponentiation_by_squaring(base, power):
    result = 1
    while power > 0:
        if power % 2 == 1:  # اگر توان فرد باشد
            result *= base
        base *= base  # توان را نصف می‌کنیم
        power //= 2  # توان را تقسیم بر 2 می‌کنیم
    return result

# مثال: محاسبه 2 به توان 10
print(exponentiation_by_squaring(2, 10))

خروجی کد بالا برابر است با:

1024

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



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

🔗(برای آموزش های کاربردی بیشتر اینجا کلیک کن)

پارت 1 - قسمت 2: کاربردهای پیشرفته "Exponentiation by Squaring"

موضوع:
در این قسمت با کاربردهای پیشرفته‌تر الگوریتم "Exponentiation by Squaring" آشنا می‌شویم. همچنین یاد می‌گیریم که چگونه این الگوریتم را در شرایط مختلف مثل توان‌های منفی یا عملیات مدولار به کار ببریم.



کاربرد 1: محاسبه توان‌های منفی
فرض کنید می‌خواهید عدد 2 را به توان -3 برسانید. توان منفی به این معنی است که باید معکوس عدد را به توان مثبت برسانیم. به عبارت ساده:
2^(-3) = 1 / (2^3)

این الگوریتم می‌تواند با یک تغییر کوچک توان‌های منفی را نیز مدیریت کند.

مثال:

def exponentiation_by_squaring(base, power):
    if power < 0:  # اگر توان منفی باشد
        base = 1 / base
        power = -power
    result = 1
    while power > 0:
        if power % 2 == 1:  # اگر توان فرد باشد
            result *= base
        base *= base  # توان را نصف می‌کنیم
        power //= 2
    return result

# مثال: محاسبه 2 به توان -3
print(exponentiation_by_squaring(2, -3))

خروجی:

0.125

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

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

مثال:
فرض کنید می‌خواهید 2^10 را باقیمانده 5 محاسبه کنید:

def exponentiation_by_squaring_mod(base, power, mod):
    result = 1
    base %= mod  # ابتدا مقدار اولیه را باقیمانده می‌گیریم
    while power > 0:
        if power % 2 == 1:  # اگر توان فرد باشد
            result = (result * base) % mod
        base = (base * base) % mod  # توان را نصف می‌کنیم و باقیمانده می‌گیریم
        power //= 2
    return result

# مثال: محاسبه 2 به توان 10 باقیمانده 5
print(exponentiation_by_squaring_mod(2, 10, 5))

خروجی:

4

مزیت عملیات مدولار:
1. جلوگیری از افزایش بیش از حد اندازه اعداد.
2. کاربرد در مسائل امنیتی و رمزنگاری، مانند الگوریتم RSA.



کاربرد 3: مثال واقعی و ترکیب توابع
فرض کنید یک تابع نیاز دارید که به صورت ترکیبی توان اعداد مثبت، منفی و عملیات مدولار را انجام دهد. می‌توانید موارد بالا را ترکیب کنید:

def advanced_exponentiation(base, power, mod=None):
    if power < 0:  # اگر توان منفی باشد
        base = 1 / base
        power = -power
    result = 1
    if mod:
        base %= mod
    while power > 0:
        if power % 2 == 1:
            result = (result * base) % mod if mod else result * base
        base = (base * base) % mod if mod else base * base
        power //= 2
    return result

# مثال: محاسبه 2 به توان -3 باقیمانده 7
print(advanced_exponentiation(2, -3, 7))

خروجی:

5

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

🔗(برای آموزش های کاربردی بیشتر اینجا کلیک کن)

پارت 2 - قسمت 1: کاربردهای Exponentiation by Squaring در مسائل واقعی

موضوع:
در این قسمت با چند مثال واقعی که از الگوریتم "Exponentiation by Squaring" استفاده می‌کنند آشنا می‌شویم. یکی از مهم‌ترین کاربردها، در رمزنگاری و محاسبات بسیار بزرگ است.



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

مثال:
فرض کنید بخواهیم \( 7^{23} \mod 33 \) را محاسبه کنیم:

def rsa_example(base, power, mod):
    result = 1
    base %= mod  # ابتدا مقدار اولیه را باقیمانده می‌گیریم
    while power > 0:
        if power % 2 == 1:  # اگر توان فرد باشد
            result = (result * base) % mod
        base = (base * base) % mod  # توان را نصف می‌کنیم و باقیمانده می‌گیریم
        power //= 2
    return result

# محاسبه 7 به توان 23 باقیمانده 33
print(rsa_example(7, 23, 33))

خروجی:

31

توضیح:
در رمزنگاری RSA، این عملیات برای رمزگذاری پیام‌ها به کار می‌رود، چرا که می‌تواند محاسبات بسیار بزرگی را با سرعت و دقت بالا انجام دهد.



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

مثال:

def population_growth(base, years):
    result = 1
    while years > 0:
        if years % 2 == 1:  # اگر تعداد سال‌ها فرد باشد
            result *= base
        base *= base  # سال‌ها را نصف می‌کنیم
        years //= 2
    return result

# جمعیت اولیه 100، نرخ رشد 2 برابر در هر سال، محاسبه جمعیت پس از 20 سال
initial_population = 100
growth_rate = 2
years = 20

final_population = initial_population * population_growth(growth_rate, years)
print(final_population)

خروجی:

104857600

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



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



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

🔗(برای آموزش های کاربردی بیشتر اینجا کلیک کن)