✅ پرفورمنس و استفاده از منابع واقعا داره پیشرفت خوبی میکنه
اجرای مدل ۷۰ بیلیون پارامتری روی یک کارت گرافیک ۴ گیگابایتی

لینک خبر + کد
@lython

کد تقلب برای دوستاران گیت
Git Cheat Sheet
لینک
@lython

✅ یکبر برای همیشه OOP رو درک کنیم
مرجع کامل برای برنامه نویسی شی گرا با پایتون

لینک
@lython

کد تقلب برای دوست داران پایتون 🐍
Python cheat sheet
لینک
@lython

❤️یک کتابخانه منبع باز برای مدیریت بهتر مدل های بزرگ زبانی
‏vLLM ابزاری کاربردی برای استنتاج سریع مدل زبانی بزرگ و ارائه خدمات را از طریق نوآوری هایی مانند PagedAttention برای مدیریت کارآمد حافظه

https://github.com/vllm-project/vllm

@lython

نسخه جدید create-llama به شما امکان می دهد یک برنامه چت مبتنی بر MongoDB را در چند ثانیه راه اندازی کنید!

لینک
@lython

سلام بعد از یه مدت طولانی 😃
امروز یه مخزن باحال داریم که نمونه های مختلفی از آموزش، استنتاج و معیار ها و برنامه هایی که از Deep Speed استفاده میکنه.
حالا deep speed چیه؟
ا DeepSpeed یک کتابخانه نرم‌افزاری متن‌باز است که به منظور بهبود عملکرد مدل‌های یادگیری عمیق توسط تیم تحقیقاتی مایکروسافت توسعه یافته است.

این کتابخانه از تکنیک‌ها و بهینه‌سازی‌های مختلفی برای افزایش سرعت و کارایی مدل‌های یادگیری عمیق استفاده می‌کند. یکی از ویژگی‌های جالب آن، ZeRO-3 نام دارد که به بهبود عملکرد موازی‌سازی GPUها کمک می‌کند.

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

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

لینک DeepSpeed
لینک مخزن مثال ها
@lython

یه شمای عالی از توانایی های مدل های زبانی و انواع های مدل های زبانی
اگه دوستاشتید مقالش رو که دوستان عزیزم زحمت انتشارش رو کشیدن رو هم مطالعه کنید.
لینک مقاله
@lython

Python tools used in ML😃
@lython

✅ ترفند پایتونی:
آیا من میتونم یک عدد بزرگ رو به عنوان متغیر تعریف میکنم ولی وقتی میخوام بخونمش ی طوری جداش کنم که خوندنش هم راحت باشه؟
جواب: میشه، کافیه با استفاده از _ عدد رو جدا کنید تا هم خودتون به راحتی بتونید عدد رو بخونید هم تغییری تو متغیر ایجاد نشه
مثال :
testNum = 10_000_000_000
print(testNum)
>>> 10000000000

@lython

✅اسلاید کامل همه چیز در مورد scipy
با تشکر از نویسندگان😃
@lython

✅ هر وقت صحبت از شیء گرایی و ارث بری میشه پای Mixin هم میاد وسط. اما دقیقا چیه؟ Mixin توی پایتون یک الگو هستش و کدهایی که از این الگو بهره می‌برند کلمه‌ی کلیدی خاصی یا چیز اضافه‌تری ندارند. فرض کنین ما می‌خواهیم یک متد جدید به یک کلاس اضافه کنیم تا `کارایی` یا Functionality اون رو زیاد کنیم. اینجا میشه از Mixin استفاده کرد.
مثلا کلاس‌های زیر رو در نظر بگیرید.

class Vehicle:
    pass

class Car(Vehicle):
    pass

class Van(Vehicle):
    pass

class Motorcycle(Vehicle):
    pass

حالا نیاز داریم که متد play music رو هم به این کلاس ها اضافه کنیم، دوتا راه داریم. اولیش اینه که:

class Vehicle:
    pass

class Car(Vehicle):

    def play_music(self):
        print("play_music")

class Van(Vehicle):

    def play_music(self):
        print("play_music")
    
class Motorcycle(Vehicle):
    pass

اما یک ایرادی وجود داره. اینجا خودمون رو تکرار کردیم. درواقع اومدیم دوبار یک تکه کد رو تکرار کردیم و این از نظر کدینگ وجه خوبی نداره. پس این راه حل ما نیست.
روش دوم اینه بیایم به بیس کلاسمون یعنی Vehicle یک متد تحت عنوان play_music اضافه کنیم.

class Vehicle:
    def play_music(self):
        print("play_music")

class Car(Vehicle):
    pass

class Van(Vehicle):
    pass

class Motorcycle(Vehicle):
    pass

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

class Vehicle:
    pass

class PlayMusicMixin:
    def play_music(self):
        print("play_music")

class Car(Vehicle, PlayMusicMixin):
    pass

class Van(Vehicle, PlayMusicMixin):
    pass

class Motorcycle(Vehicle):
    pass

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

باتشکر از @miladseyfii

@lython

✅ برنامه‌نویسی غیرهمزمان (Asynchronous)

برنامه‌نویسی غیرهمزمان یکی از مفاهیم مهم در توسعه نرم‌افزار است که به شما امکان می‌دهد عملیات‌های مختلف را به طور همزمان و بدون مسدود کردن (Blocking) برنامه اجرا کنید. این روش به ویژه برای بهبود کارایی برنامه‌ها در زمان اجرای عملیات‌های I/O مثل درخواست‌های شبکه، خواندن و نوشتن فایل‌ها ودیگر فرایند ها مفید است.

◀️ مفاهیم کلیدی:

1. حلقه رویداد (Event Loop): هسته اصلی اجرای کدهای غیرهمزمان که مسئول مدیریت وظایف مختلف است.
2. کوروتین (Coroutine): نوع خاصی از تابع که می‌تواند متوقف و از سر گرفته شود. کوروتین‌ها با async def تعریف می‌شوند.
3. انتظار (Await): برای متوقف کردن اجرای یک کوروتین تا تکمیل شدن یک وظیفه دیگر استفاده می‌شود.
4. وظیفه (Task): یک کوروتین زمان‌بندی شده برای اجرا به طور همزمان با سایر وظایف.

◀️ مثال ساده:

import asyncio

async def say_hello():
    print("hello!")
    await asyncio.sleep(1)  # delay simulation
    print("world!")

asyncio.run(say_hello())

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

import asyncio

async def fetch_data(name, delay):
    print(f"started {name}")
    await asyncio.sleep(delay)
    print(f"ended {name}")
    return f"result {name}"

async def main():
    tasks = [
        asyncio.create_task(fetch_data('data 1', 2)),
        asyncio.create_task(fetch_data('data 2', 3)),
        asyncio.create_task(fetch_data('data 3', 1)),
    ]
    results = await asyncio.gather(*tasks)
    print("results:", results)

asyncio.run(main())

@lython

✅موارد مناسب برای استفاده از کوروتین‌ها

◀️ عملیات‌های I/O-محور:
وقتی برنامه شما نیاز به اجرای تعداد زیادی عملیات I/O مانند خواندن و نوشتن فایل، ارتباطات شبکه‌ای (مثل درخواست‌های HTTP)، ارتباط با پایگاه‌های داده، و غیره دارد، کوروتین‌ها می‌توانند به طور همزمان این عملیات‌ها را مدیریت کنند بدون اینکه برنامه مسدود شود.

◀️ انتظار برای منابع خارجی:
زمانی که برنامه شما نیاز دارد منتظر پاسخ از سرورهای خارجی، دیتابیس‌ها یا سایر منابع باشد. استفاده از await در کوروتین‌ها به برنامه اجازه می‌دهد که در حین انتظار برای این پاسخ‌ها به اجرای سایر کدها ادامه دهد.

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

◀️ زمانبندی و تأخیر در اجرای کد:
اگر نیاز دارید تا اجرای کدها را با تأخیر خاصی انجام دهید یا عملیات‌های دوره‌ای را برنامه‌ریزی کنید، کوروتین‌ها می‌توانند با استفاده از asyncio.sleep و سایر امکانات asyncio این کارها را به خوبی انجام دهند.
@lython

✅Polymorphism in python

از مهم‌ترین بحث‌ها در شئ‌گرایی میشه به Polymorphism اشاره کرد. معنای این مفهوم یعنی که بتونیم از یک متد یکسان برای انواع آبجکت‌ها استفاده کنیم. کد زیر خودش گویاست.

text = 'Hello World'
numbers = [1, 2, 3]
print(len(text))    # 11
print(len(numbers))    # 3

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

اما در کل سه نوع روش پیاده سازی Polymorphism وجود دارد.
1- Method Overriding
2- Method Overloading
3- Operator Overloading
------------------------------
1-Method Overriding

فرض کنید که کلاس LittleFish از کلاس Animal ارث‌بری می‌کند. در این‌صورت خواهیم داشت.

class Animal:
    def breathe(self):
       print("I breathe oxygen.")

    def feed(self):
       print("I eat food.")

class LittleFish(Animal):
    def feed(self):
       print("I eat plankton.")

نکته‌های جالبی توی تکه کد بالاست. چون کلاس LittleFish از کلاس Animal ارث‌بری کرده پس متد feed جایگزین متد همنامی میشه که در کلاس والد موجوده. اما صرفا برای کلاس LittleFish به این شکل است و متد feed در کلاس LittleFish به اصطلاح Override شده است در مقایسه با متد feed در کلاس Animal. به کد زیر توجه کنید.

LittleFish().feed()   
# I eat plankton.
LittleFish().breathe()
# I breathe oxygen.
Animal().feed()
 # I eat food.

اما همانطور که می‌بینید در سطح کلاس Animal هنوز متد feed همانی است که در آن تعریف شده‌است.

--------------------------
2-Method Overloading
حالا یه بحث دیگه‌ای داریم تحت این عنوان بالا.
این توی پایتون پشتیبانی نمیشه. فرض کنیم توی کلاس Animal یه متد دیگه تحت عنوان breath تعریف می‌کنیم‌. مثال زیر رو ببینید.

class Animal:
    def breathe(self):
        print('I breathe oxygen.')

    def breathe(self):
        print('I breathe O2 + N2.')

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

--------------------------
3- Operator Overloading
این ویژگی بسیار کاربردی و جالب است. درواقع این ویژگی اجازه می‌دهد که عملگرهای (+ - / و ... ) را برای کلاس های جدیدی که ایجاد می‌کنیم بازتعریف کنیم‌.

class Vector:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def __add__(self, other): 
        x = self.x +other.x
        y = self.y + other.y 
        z = self.z + other.z
        return Vector(x, y, z)

درواقع متد add که تعریف کردیم برای این کلاس مثل جمع برداری عمل می‌کند. در واقع عملگر + را برای کلاس وکتور تعریف کردیم. باز هم کد گویای مفهوم هست.

Vec1 = Vector(1, 2 ,3)
vec2 = Vector(1, 1, 1)
vec_add = vec1 + vec2
vec_add.x    # 2
vec_add.y    # 3
vec_add.z    # 4

@lython

Type Hinting in python - Part1
*قابل ذکر است که مطالب این پست از نسخه‌ی ۳.۵ به بعد در پایتون قابل استفاده است.
ابتدا مفهوم static type checker رو بررسی می‌کنیم تا متوجه موضوع بشویم. در ویکی پدیا به روشنی بیان شده است که:

Static type checking is the process of verifying the type safety of a program based on analysis of a program's text (source code).

👨🏻‍💻در واقع safety کد رو از منظر text و نه زمانی که قرار است ران شود بررسی می‌کند، در ادامه نیز می‌بینیم که گاهی اوقات این شیوه تحلیل کد ارور برمی‌گرداند ولی اجرای فایل پایتونی بدون مشکل و باگ است.

👨🏻‍💻برای چک کردن و آنالیز کد خود با استفاده از این روش از ابزار mypy بهره می‌بریم. استفاده از این روش readability کد را افزایش می‌دهد و همچنین روشی اختیاری است.
صورت استفاده از type hinting بدین شکل است:

a: int = 5
b: int = 3.5
تایپ دو متغیر int در نظر گرفته شده است ولی در متغیر b عدد اعشاری ریخته شده است.

👨🏻‍💻دقت شود که run کردن این کد بدون مشکل و ارور است. ولی وقتی در ترمینال فایل پایتون را با دستور mypy اجرا می‌کنیم استاتیک چکینگ شروع می‌شود.
در نهایت این خطا در ترمینال مشاهده می‌شود.
python_file.py:2: error: Incompatible types in assignment (expression has type "float", variable has type "int")
Found 1 error in 1 file ( checked 1 source file)
اجرا بوسیله‌ی mypy خطای Incompatible type می‌دهد که قابل تصور بود.
اما برای توابع، صورت تایپ هینت به شکل زیر است.
def func(inp1: str,  inp2: int,
         inp3: float) -> int:
    print(inp1)
    return int(inp1 + inp2)
دقت شود که  خروجی تایپ مقداری که تابع قرار است برگرداند  نیز بوسیله کارکترهای  <-  مشخص شده است.

👨🏻‍💻دقت شود برای توابعی که فاقد کلمه‌ی کلیدی return هستند باید تایپ None تعریف گردد.
def func(inp1: str, inp2: int,
         inp3: float) -> None:
    print(inp1, inp2, inp3)
دقت شود بوسیله‌ی attribute زیر می‌توان به تایپ توابعی که تعریف کردیم دسترسی پیدا کرد.
print(func.__annotation__)
صورت تایپ هینت‌ها در متغیرها و توابع بررسی شد و نوبت به کلاس‌ها رسیده است. 
برای تعریف تایپ هینت class attributeها بهتر است از  ClassVar  از ماژول typing استفاده شود. البته به شکل دیگری نیز این تعریف رو انجام می‌دهیم. به مثال زیر توجه کنید.
from typing import ClassVar
class Sample:
    var1: int = 25
    var2: ClassVar[str] = "Python"
در این مثال دو کلاس اتریبیوت تعریف شده است که از دو روش تایپ هینت بهره گرفتیم. روش دوم عموما توصیه‌ میشود

@lython

Type Hinting in Python- part 2

✓ اما برای تایپ هینت انواع داده‌ی دیگر مثل list , set و dict ها و ... خواهیم داشت:

x: list[int] = [1]
x: set[int] = {6, 7}
x: dict[str, float] = {"num": 2.0}
x: tuple[str, float] = ("yes", 7.5)

✓ نکته: برای دیکشنری درون آکولاد تایپ key و value  دیکشنری با str و float  مشخص شده است. یعنی دیکشنری که در x ریخته می‌شود باید از این قانون تبعیت کند تا mypy اررور برنگرداند.

✓ دقت شود که کد بالا برای پایتون 3.9 به بعد است و برای نسخه‌های قبل از آن از کد زیر استفاده می‌شود که موارد زیر ابتدا باید از ماژول typing ایمپورت شوند.

from typing import List, Set, Dict, Tuple
x: List[int] = [1]
x: Set[int] = {6, 7}
x: Dict[str, float] = {"field": 2.0}
x: Tuple[int, str, float] = (3, "yes", 7.5)

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

✓ به کد زیر دقت کنید که مفهوم تایپ هینت Any را می‌رساند. Any به معنای هر توع تایپی در نظر گرفته می‌شود. در واقع اگر هیچ تایپی برای متغیری تعریف نگردد، برای آن Any لحاظ می‌گردد. برای مثال می‌توان به متغیر x لیست، دیکشنری کلاس تابع و یا هر ورودی دیگری داد. دو تابع زیر که تعریف شده در واقع از نظر mypy یکی است.

from typing import Any

def func1(x):
    pass

def func2(x: Any):
    pass

✓ اما به نظر بخش جالب ماجرا در تایپ هینت Callable است. این تایپ برای وقتی مفید است که ورودی یک تابع، یک یا چند تابع دیگر است. آنوقت می‌توان توع ورودی را بوسیله‌ی Callable  با mypy چک کرد.
سینتکس آن به شکل زیر است.

Callable[[arg1, arg2, ...], return type]

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

def func1(a: int, b: str) -> None:
    pass

def func2(results: Any) -> None:
    pass

def func3(d: Callable[[int, str], None], c: Callable[[Any], None]) -> None:
    pass

@lython

✅ لیست‌ها در پایتون: مفاهیم پیشرفته

1️⃣ برش (Slicing)

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

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

# برش ساده
print(my_list[2:5])  # خروجی: [2, 3, 4]

# برش با گام
print(my_list[1:8:2])  # خروجی: [1, 3, 5, 7]

# برش از ابتدا تا یک نقطه
print(my_list[:4])  # خروجی: [0, 1, 2, 3]

# برش از یک نقطه تا انتها
print(my_list[5:])  # خروجی: [5, 6, 7, 8, 9]

# برش با گام منفی (برعکس)
print(my_list[::-1])  # خروجی: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

2️⃣ لیست‌های تودرتو (Nested Lists)

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

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

# دسترسی به عنصر خاص در لیست تودرتو
print(nested_list[0][1])  # خروجی: 2

# پیمایش در لیست‌های تودرتو
for sublist in nested_list:
    for item in sublist:
        print(item, end=' ')  # خروجی: 1 2 3 4 5 6 7 8 9

3️⃣ لیست‌های درک شده (List Comprehensions)

لیست‌های درک شده یک راه کوتاه برای ایجاد لیست‌ها هستند.

# ایجاد لیستی از اعداد مربعی
squares = [x**2 for x in range(10)]
print(squares)  # خروجی: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# فیلتر کردن لیست
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # خروجی: [0, 2, 4, 6, 8]

4️⃣ توابع کاربردی برای لیست‌ها

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

    len(): طول لیست را برمی‌گرداند.
    sum(): مجموع عناصر لیست را محاسبه می‌کند.
    min() و max(): کوچک‌ترین و بزرگ‌ترین عنصر لیست را برمی‌گرداند.
    sorted(): لیست را مرتب می‌کند.
    reversed(): لیست را معکوس می‌کند.

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5]

print(len(my_list))  # خروجی: 9
print(sum(my_list))  # خروجی: 36
print(min(my_list))  # خروجی: 1
print(max(my_list))  # خروجی: 9
print(sorted(my_list))  # خروجی: [1, 1, 2, 3, 4, 5, 5, 6, 9]
print(list(reversed(my_list)))  # خروجی: [5, 6, 2, 9, 5, 1, 4, 1, 3]

5️⃣ توابع و متدهای پیشرفته

    index(): اندیس اولین وقوع عنصر مورد نظر را برمی‌گرداند.
    count(): تعداد وقوع یک عنصر را در لیست برمی‌گرداند.
    insert(): یک عنصر را در اندیس مشخصی اضافه می‌کند.
    pop(): عنصر با اندیس مشخصی را حذف و برمی‌گرداند.
    remove(): اولین وقوع عنصر مورد نظر را حذف می‌کند.
    clear(): تمام عناصر لیست را حذف می‌کند.

my_list = [1, 2, 3, 2, 4, 2]

print(my_list.index(2))  # خروجی: 1
print(my_list.count(2))  # خروجی: 3

my_list.insert(3, 'a')
print(my_list)  # خروجی: [1, 2, 3, 'a', 2, 4, 2]

print(my_list.pop(3))  # خروجی: 'a'
print(my_list)  # خروجی: [1, 2, 3, 2, 4, 2]

my_list.remove(2)
print(my_list)  # خروجی: [1, 3, 2, 4, 2]

my_list.clear()
print(my_list)  # خروجی: []

6️⃣ لیست‌های چند بعدی

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

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

# دسترسی به عناصر ماتریس
print(matrix[1][2])  # خروجی: 6

# پیمایش در ماتریس
for row in matrix:
    for item in row:
        print(item, end=' ')  # خروجی: 1 2 3 4 5 6 7 8 9

@lython

✅ تاپل‌ها در پایتون: مفاهیم پیشرفته

1️⃣ تعریف تاپل

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

my_tuple = (1, 2, 3, 'hello', 4.5)
print(my_tuple)  # خروجی: (1, 2, 3, 'hello', 4.5)

2️⃣ دسترسی به عناصر تاپل

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

print(my_tuple[0])  # خروجی: 1
print(my_tuple[3])  # خروجی: hello
print(my_tuple[-1]) # خروجی: 4.5

3️⃣ برش (Slicing)

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

print(my_tuple[1:4])  # خروجی: (2, 3, 'hello')
print(my_tuple[:3])   # خروجی: (1, 2, 3)
print(my_tuple[2:])   # خروجی: (3, 'hello', 4.5)
print(my_tuple[::-1]) # خروجی: (4.5, 'hello', 3, 2, 1)

4️⃣ تاپل‌های تودرتو (Nested Tuples)

تاپل‌ها می‌توانند شامل تاپل‌ها و یا هر نوع داده دیگری باشند که به آن‌ها تاپل‌های تودرتو گفته می‌شود.

nested_tuple = (1, 2, (3, 4), (5, (6, 7)))
print(nested_tuple[2])     # خروجی: (3, 4)
print(nested_tuple[3][1])  # خروجی: (6, 7)
print(nested_tuple[3][1][1]) # خروجی: 7

5️⃣ توابع کاربردی برای تاپل‌ها

پایتون توابع مختلفی را برای کار با تاپل‌ها ارائه می‌دهد:

len(): طول تاپل را برمی‌گرداند.
sum(): مجموع عناصر عددی تاپل را محاسبه می‌کند.
min() و max(): کوچک‌ترین و بزرگ‌ترین عنصر عددی تاپل را برمی‌گرداند.
sorted(): یک لیست مرتب‌شده از عناصر تاپل برمی‌گرداند.

num_tuple = (3, 1, 4, 1, 5, 9, 2, 6)

print(len(num_tuple))  # خروجی: 8
print(sum(num_tuple))  # خروجی: 31
print(min(num_tuple))  # خروجی: 1
print(max(num_tuple))  # خروجی: 9
print(sorted(num_tuple))  # خروجی: [1, 1, 2, 3, 4, 5, 6, 9]

6️⃣ تبدیل لیست به تاپل و برعکس

می‌توانید با استفاده از توابع tuple() و list() بین لیست‌ها و تاپل‌ها تبدیل انجام دهید.

my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # خروجی: (1, 2, 3)

new_list = list(my_tuple)
print(new_list)  # خروجی: [1, 2, 3]

7️⃣ عملیات‌های متداول

عملیات‌هایی مانند الحاق (concatenation) و تکرار (repetition) بر روی تاپل‌ها امکان‌پذیر است.

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# الحاق
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # خروجی: (1, 2, 3, 4, 5, 6)

# تکرار
repeated_tuple = tuple1 * 3
print(repeated_tuple)  # خروجی: (1, 2, 3, 1, 2, 3, 1, 2, 3)

8️⃣ تاپل‌های چند بعدی

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

matrix = ((1, 2, 3),
          (4, 5, 6),
          (7, 8, 9))

# دسترسی به عناصر ماتریس
print(matrix[1][2])  # خروجی: 6

# پیمایش در ماتریس
for row in matrix:
    for item in row:
        print(item, end=' ')  # خروجی: 1 2 3 4 5 6 7 8 9          (4, 5, 6),
          (7, 8, 9))

# دسترسی به عناصر ماتریس
print(matrix[1][2])  # خروجی: 6

# پیمایش در ماتریس
for row in matrix:
    for item in row:
        print(item, end=' ')  # خروجی: 1 2 3 4 5 6 7 8 9

@lython

✅ تفاوت‌های کلیدی بین لیست‌ها و تاپل‌ها

قابلیت تغییر (Mutability)

لیست‌ها:

قابل تغییر (Mutable): لیست‌ها می‌توانند پس از ایجاد تغییر کنند؛ می‌توانید عناصر را اضافه، حذف یا جایگزین کنید.

    my_list = [1, 2, 3]
    my_list[0] = 4  # تغییر اولین عنصر
    my_list.append(5)  # اضافه کردن عنصر جدید
    print(my_list)  # خروجی: [4, 2, 3, 5]

تاپل‌ها:

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

    my_tuple = (1, 2, 3)
    # my_tuple[0] = 4  # این خط خطا می‌دهد

عملکرد (Performance)

لیست‌ها:

کندتر: به دلیل قابلیت تغییر، لیست‌ها دارای سربار (overhead) بیشتری هستند که می‌تواند منجر به کاهش کارایی در برخی موارد شود.

تاپل‌ها:

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

استفاده حافظه (Memory Usage)

لیست‌ها:

مصرف حافظه بیشتر: به دلیل قابلیت تغییر، لیست‌ها برای مدیریت تغییرات به فضای اضافی نیاز دارند.

تاپل‌ها:

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

امنیت داده (Data Integrity)

لیست‌ها:

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

تاپل‌ها:

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

کاربرد (Usage)

لیست‌ها:

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

    my_list = [1, 2, 3]
    my_list.append(4)
    my_list.remove(2)
    print(my_list)  # خروجی: [1, 3, 4]

تاپل‌ها:

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

    my_tuple = (1, 2, 3)
    my_dict = {my_tuple: "value"}  # استفاده از تاپل به عنوان کلید در دیکشنری

عملیات‌های مجاز

لیست‌ها:

پشتیبانی از تمام عملیات‌های تغییرپذیری مانند append(), remove(), insert(), pop(), و غیره.

تاپل‌ها:

پشتیبانی از عملیات دسترسی و شمارش عناصر مانند index() و count(), اما بدون قابلیت تغییر.

ترکیب داده‌ها (Concatenation) و تکرار (Repetition)
هر دو نوع داده از ترکیب و تکرار پشتیبانی می‌کنند، اما ترکیب و تکرار در تاپل‌ها منجر به ایجاد تاپل‌های جدید می‌شود.

# ترکیب
list1 = [1, 2]
list2 = [3, 4]
combined_list = list1 + list2
print(combined_list)  # خروجی: [1, 2, 3, 4]

tuple1 = (1, 2)
tuple2 = (3, 4)
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # خروجی: (1, 2, 3, 4)

# تکرار
repeated_list = list1 * 3
print(repeated_list)  # خروجی: [1, 2, 1, 2, 1, 2]

repeated_tuple = tuple1 * 3
print(repeated_tuple)  # خروجی: (1, 2, 1, 2, 1, 2)

تبدیل بین لیست و تاپل

گاهی اوقات نیاز به تبدیل بین این دو نوع داده وجود دارد.

# لیست به تاپل
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # خروجی: (1, 2, 3)

# تاپل به لیست
my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # خروجی: [1, 2, 3]

نتیجه‌گیری

لیست‌ها برای مواردی مناسب هستند که نیاز به تغییر، اضافه کردن یا حذف عناصر دارید. از لیست‌ها در برنامه‌هایی استفاده کنید که انعطاف‌پذیری داده‌ها مهم است.
تاپل‌ها برای مواردی مناسب هستند که داده‌ها باید ثابت بمانند و بهینه‌سازی عملکرد و استفاده از حافظه مهم است. از تاپل‌ها در مواردی استفاده کنید که داده‌ها نباید تغییر کنند و امنیت داده‌ها حائز اهمیت است

@lython