📦 تبسيط كتابة الكلاسات باستخدام Dataclasses

بدلاً من كتابة الدوال المتكررة مثل \_\_init\_\_ و \_\_repr\_\_ يدوياً، توفر مكتبة dataclasses (التي أُضيفت في إصدار 3.7) طريقة مختصرة واحترافية لتعريف الكلاسات التي تهدف لتخزين البيانات، مما يقلل من الـ Boilerplate code ويجعل الكود أكثر قابلية للقراءة.

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    quantity: int = 0

    def total\_cost(self) -> float:
        return self.price * self.quantity

# إنشاء كائن جديد (Object)
item = Product(name="Laptop", price=1200.5, quantity=2)

# طباعة الكائن (توليد \_\_repr\_\_ تلقائياً)
print(item)  # Output: Product(name='Laptop', price=1200.5, quantity=2)

# حساب التكلفة الإجمالية
print(f"Total: {item.total\_cost()}")

أهم المميزات:
1. توليد دوال \_\_init\_\_ و \_\_repr\_\_ و \_\_eq\_\_ تلقائياً.
2. دعم القيم الافتراضية للـ Attributes.
3. تحسين وضوح الكود وسهولة صيانته.
4. توافق تام مع الـ Type Hinting.

#Python #PythonArabs #Programming #Tips #CleanCode

🚀 استخدام List Comprehensions لكتابة كود أكثر نظافة

بدلاً من استخدام الحلقات التكرارية (For Loops) التقليدية لإنشاء القوائم، توفر بايثون ميزة List Comprehensions التي تجعل الكود أكثر اختصاراً وكفاءة في سطر واحد.

# الطريقة التقليدية باستخدام for loop
numbers = [1, 2, 3, 4, 5, 6]
even\_numbers = []

for num in numbers:
    if num % 2 == 0:
        even\_numbers.append(num)

# الطريقة المختصرة باستخدام List Comprehension
even\_numbers\_v2 = [num for num in numbers if num % 2 == 0]

print(even\_numbers\_v2)  # Output: [2, 4, 6]

تساعد هذه التقنية في تحسين أداء الكود (Performance) وزيادة قابليته للقراءة (Readability)، حيث يتم دمج عملية التكرار والفلترة (Filtering) في تعبير برمجي واحد وبسيط.

#Python_Arabs #Python #Programming #CleanCode #Tips

🚀 تحسين أداء الكود باستخدام List Comprehension

تُعد الـ List Comprehension من أقوى ميزات لغة Python، حيث تتيح لك إنشاء القوائم (Lists) بطريقة مختصرة وفعالة بدلاً من استخدام حلقات Loops التقليدية التي تستهلك أسطرًا أكثر.

# الطريقة التقليدية باستخدام for loop
numbers = [1, 2, 3, 4, 5]
squared\_numbers = []

for n in numbers:
    squared\_numbers.append(n * 2)

# الطريقة المختصرة باستخدام List Comprehension
# [expression for item in iterable]
squared\_numbers\_short = [n * 2 for n in numbers]

# إضافة شرط (Filtering) لجلب الأرقام الزوجية فقط
even\_squared = [n * 2 for n in numbers if n % 2 == 0]

print(f"Squared: {squared\_numbers\_short}")
print(f"Even Squared: {even\_squared}")

#Python_Arabs #Python #Programming #CleanCode #Tips

📦 تبسيط التعامل مع البيانات باستخدام Dataclasses

توفر مكتبة dataclasses في بايثون طريقة فعالة لإنشاء الكائنات (Objects) المخصصة لتخزين البيانات، حيث تقوم تلقائيًا بإنشاء الدوال الأساسية مثل \_\_init\_\_ و \_\_repr\_\_ و \_\_eq\_\_ مما يقلل من كتابة الكود المكرر (Boilerplate Code).

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    quantity: int = 0

    def get\_total\_value(self) -> float:
        return self.price * self.quantity

# إنشاء كائن جديد بسهولة
item1 = Product(name="Laptop", price=1200.5, quantity=5)
item2 = Product(name="Smartphone", price=800.0)

print(item1)  # مخرجات تلقائية واضحة بفضل \_\_repr\_\_
print(f"Total Value: {item1.get\_total\_value()}")

# المقارنة بين كائنين تعتمد على القيم وليس مرجع الذاكرة
item3 = Product(name="Laptop", price=1200.5, quantity=5)
print(item1 == item3)  # True

#Python_Arabs #Python #Tips #Programming #SoftwareEngineering

🐍 كيفية استخدام `enumerate` في بايثون

تُتيح لك دالة enumerate الحصول على الفهرس (index) والقيمة (value) أثناء المرور على عناصر قائمة (list) أو أي تسلسل آخر في بايثون.

fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
    print(f"Index: {index}, Fruit: {fruit}")

#Python #PythonArabs #enumerate #Tutorial #Tips

الفرق بين `is` و `==` في بايثون 🐍

في بايثون، قد يبدو أن `is` و `==` يقومان بنفس الوظيفة عند المقارنة، لكنهما يختلفان جوهريًا. دعنا نوضح الفرق.

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(f"a == b: {a == b}")  # هل القيم متساوية؟
print(f"a is b: {a is b}")    # هل يشيران لنفس الكائن في الذاكرة؟
print(f"a is c: {a is c}")    # هل يشيران لنفس الكائن في الذاكرة؟

`==` يتحقق مما إذا كانت قيم الكائنين متساوية. أما `is` فيتحقق مما إذا كان المتغيران يشيران إلى نفس الكائن (نفس الموقع في الذاكرة). في المثال، `a` و `b` لهما نفس القيم لذا `a == b` صحيح، لكنهما كائنان منفصلان لذا `a is b` خاطئ. بينما `c` يشير إلى نفس الكائن الذي تشير إليه `a`، لذا `a is c` صحيح.

['#بايثون', '#برمجة', '#Python', '#IsVsEquals', '#Tips']

💡 Tip Python: استخدام setdefault() لتبسيط القواميس! 💡

هل سئمت من التحقق مرارًا وتكرارًا مما إذا كان المفتاح موجودًا في القاموس قبل إضافته؟ دعنا نستخدم `setdefault()` لجعل الكود الخاص بك أكثر أناقة وكفاءة!

my_dict = {'a': 1, 'b': 2}

# استخدام setdefault لإضافة مفتاح جديد أو الحصول على قيمته
value_c = my_dict.setdefault('c', 3) # 'c' غير موجود، لذا يتم إضافته بالقيمة 3
print(f"القيمة المضافة أو الموجودة: {value_c}")
print(f"القاموس بعد الإضافة: {my_dict}")

# استخدام setdefault لمفتاح موجود
value_a = my_dict.setdefault('a', 10) # 'a' موجود، لذا لا يتم تغيير قيمته
print(f"القيمة الموجودة (لم تتغير): {value_a}")
print(f"القاموس بعد محاولة إضافة مفتاح موجود: {my_dict}")

الدالة `setdefault(key, default_value)` مفيدة جدًا. إذا كان المفتاح `key` موجودًا بالفعل في القاموس، فإنها تُرجع قيمته. أما إذا لم يكن المفتاح موجودًا، فإنها تُضيف المفتاح بالقيمة `default_value` المحددة ثم تُرجع هذه القيمة. هذا يجنبك الحاجة إلى جملة `if` للتحقق من وجود المفتاح.

['#Python', '#Tips', '#Programming', '#DataStructures', '#Dictionaries', '#PythonTricks', '#Code', '#Tutorial']

✨ استكشاف مكتبة `collections` في بايثون ✨

هل تبحث عن هياكل بيانات أكثر كفاءة وتخصصًا في بايثون؟ مكتبة `collections` هي الحل! دعنا نكتشف بعض أدواتها المفيدة.

from collections import Counter, defaultdict, deque

# Counter: عد العناصر
my_list = ['a', 'b', 'a', 'c', 'b', 'a']
counts = Counter(my_list)
print(f"Counter: {counts}") # Output: Counter: Counter({'a': 3, 'b': 2, 'c': 1})

# defaultdict: قاموس بقيم افتراضية
default_dict = defaultdict(int) # القيمة الافتراضية هي 0 للأعداد الصحيحة
default_dict['apple'] += 1
default_dict['banana']
print(f"defaultdict: {default_dict}") # Output: defaultdict: defaultdict(<class 'int'>, {'apple': 1, 'banana': 0})

# deque: قائمة مزدوجة النهاية (سريعة الإضافة والحذف من الطرفين)
double_ended_queue = deque([1, 2, 3])
double_ended_queue.appendleft(0)
double_ended_queue.append(4)
print(f"deque: {double_ended_queue}") # Output: deque: deque([0, 1, 2, 3, 4])

تُقدم مكتبة `collections` في بايثون هياكل بيانات متخصصة تتجاوز القوائم والقواميس القياسية. `Counter` مفيد لعد تكرار العناصر، `defaultdict` يبسط التعامل مع القواميس التي تحتاج قيمًا افتراضية، و `deque` يوفر عمليات إضافة وحذف سريعة من كلا طرفي التسلسل.

['#بايثون', '#برمجة', '#Python', '#Collections', '#DataStructures', '#Tips']

✨ تحسين أداء Python: استخدام Walrus Operator 🐍

هل تريد كتابة كود Python أكثر إيجازًا وكفاءة؟ اكتشف كيف يمكن لمشغل Walrus (:=) مساعدتك في تبسيط عمليات الإسناد والتحقق في سطر واحد!

from math import sqrt

numbers = [16, 25, 36, 49, 64]

# الطريقة التقليدية
for num in numbers:
    root = sqrt(num)
    if root > 5:
        print(f"The square root of {num} is {root}")

# باستخدام Walrus Operator
print('\n--- Using Walrus Operator ---')
for num in numbers:
    if (root := sqrt(num)) > 5:
        print(f"The square root of {num} is {root}")

مشغل Walrus (:=) يسمح لك بإسناد قيمة لمتغير كجزء من تعبير. في المثال، نقوم بحساب الجذر التربيعي وإسناده للمتغير `root` في نفس الوقت الذي نتحقق فيه مما إذا كانت قيمته أكبر من 5، مما يجعل الكود أقصر وأكثر قابلية للقراءة.

['#Python', '#برمجة', '#WalrusOperator', '#Tips', '#CodeOptimization', '#LearnToCode']

✨ تحسين أداء Python: استخدام List Comprehensions 🐍

هل تريد كتابة كود Python أكثر إيجازًا وكفاءة؟ تعرف على قوة List Comprehensions!

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

# مقارنة مع حلقة for التقليدية:
# squares_old = []
# for x in numbers:
#     squares_old.append(x**2)
# print(squares_old)

List Comprehensions توفر طريقة مختصرة لإنشاء القوائم. بدلاً من كتابة حلقة 'for' كاملة، يمكنك إنشاء قائمة جديدة بناءً على قائمة موجودة في سطر واحد، مما يجعل الكود أسهل في القراءة وأكثر فعالية.

['#Python', '#برمجة', '#ListComprehensions', '#تطوير', '#Tips']

🚀 تحسين أداء Python: استخدام Walrus Operator (:=) 🚀

هل تعلم أن Python 3.8 قدمت طريقة جديدة لكتابة الأكواد بشكل أكثر إيجازًا وكفاءة؟ تعرف على Walrus Operator!

data = [1, 2, 3, 4, 5]

if (n := len(data)) > 3:
    print(f"القائمة تحتوي على {n} عناصر، وهذا أكثر من 3.")

Walrus Operator (:=) يسمح لك بتعيين قيمة لمتغير كجزء من تعبير. في هذا المثال، قمنا بحساب طول القائمة وتخزينه في المتغير 'n' ثم التحقق مما إذا كانت قيمته أكبر من 3، كل ذلك في سطر واحد. هذا يجعل الكود أقصر وأسهل في القراءة.

['#Python', '#Programming', '#Tips', '#Coding', '#WalrusOperator', '#Python38']

🚀 تحسين أداء Python: استخدام List Comprehensions

هل تبحث عن طريقة لكتابة كود Python أنظف وأسرع؟ دعنا نتعرف على List Comprehensions!

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

List Comprehensions توفر طريقة مختصرة لإنشاء القوائم. بدلاً من كتابة حلقة `for` تقليدية، يمكنك كتابة نفس المنطق في سطر واحد، مما يجعل الكود أكثر قابلية للقراءة وأحيانًا أسرع.

['#Python', '#برمجة', '#ListComprehensions', '#تطوير', '#Tips']

🚀 تحسين أداء Python: فهم GIL

هل تساءلت يومًا لماذا قد لا تستفيد برامج Python المتعددة الخيوط (multithreaded) بشكل كامل من المعالجات متعددة النوى؟ 🤔 دعنا نتعمق في Global Interpreter Lock (GIL) وكيف يؤثر على أداء Python.

import threading
import time

def count_down(n):
    while n > 0:
        n -= 1

start_time = time.time()

# بدون GIL (نظريًا، في CPython هو موجود)
# يمكن تشغيل هذه المهام بالتوازي الحقيقي على نوى مختلفة

thread1 = threading.Thread(target=count_down, args=(10000000,))
thread2 = threading.Thread(target=count_down, args=(10000000,))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

end_time = time.time()
print(f"الوقت المستغرق: {end_time - start_time:.4f} ثانية")

# ملاحظة: في CPython، بسبب GIL، ستعمل هذه الخيوط بشكل تسلسلي غالبًا،
# مما يحد من الاستفادة من المعالجات متعددة النوى للمهام التي تستهلك وحدة المعالجة المركزية.

Global Interpreter Lock (GIL) هو آلية في CPython (التنفيذ الأكثر شيوعًا لبايثون) تمنع أكثر من خيط واحد (thread) من تنفيذ بايت كود Python في نفس الوقت داخل عملية واحدة. هذا يعني أنه حتى لو كان لديك معالج متعدد النوى، فإن خيوط Python التي تستهلك وحدة المعالجة المركزية (CPU-bound) لن تعمل بالتوازي الحقيقي. بالنسبة للمهام التي تعتمد على الإدخال/الإخراج (I/O-bound)، مثل قراءة الملفات أو طلبات الشبكة، يكون GIL أقل تأثيرًا لأنه يحرر القفل أثناء انتظار عمليات الإدخال/الإخراج.

['#Python', '#GIL', '#Programming', '#Performance', '#Multithreading', '#CPython', '#Tips', '#Tutorial']

✨ تحسين أداء Python: فهم GIL 🐍

هل تساءلت يومًا لماذا قد لا تستفيد برامج Python متعددة الخيوط (multithreaded) بشكل كامل من وحدات المعالجة المركزية (CPU) متعددة النوى؟ الجواب يكمن في Global Interpreter Lock (GIL). دعنا نتعمق!

import threading
import time

def countdown(n):
    while n > 0:
        n -= 1

start_time = time.time()
# تشغيل دالتين في خيطين منفصلين (ولكن GIL يحد من التوازي الحقيقي)
thread1 = threading.Thread(target=countdown, args=(10000000,))
thread2 = threading.Thread(target=countdown, args=(10000000,))

thread1.start()
thread2.start()

thread1.join()
thread2.join()

end_time = time.time()
print(f"الوقت المستغرق: {end_time - start_time:.4f} ثانية")

Global Interpreter Lock (GIL) هو آلية في CPython (التطبيق الأكثر شيوعًا لبايثون) تمنع خيطًا واحدًا فقط من تنفيذ كود بايثون في كل مرة، حتى على المعالجات متعددة النوى. هذا يعني أنه بالنسبة للمهام التي تعتمد بكثافة على وحدة المعالجة المركزية (CPU-bound)، فإن استخدام الخيوط المتعددة قد لا يؤدي إلى تسريع كبير. للحصول على توازي حقيقي للمهام التي تعتمد على وحدة المعالجة المركزية، فكر في استخدام وحدات (multiprocessing) بدلاً من الخيوط (threading).

['#Python', '#GIL', '#Programming', '#CPython', '#Multithreading', '#Performance', '#Tips']

💡 اختصارات سحرية في بايثون! 🐍

هل سئمت من كتابة الأكواد الطويلة؟ اكتشف بعض الحيل السريعة في بايثون لتجعل حياتك كمبرمج أسهل!

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

# بدون اختصار
new_list_long = []
for item in my_list:
    new_list_long.append(item * 2)

# مع اختصار (List Comprehension)
new_list_short = [item * 2 for item in my_list]

print(new_list_long)
print(new_list_short)

الكود الأول يوضح الطريقة التقليدية لإنشاء قائمة جديدة بمضاعفة عناصر القائمة الأصلية. الكود الثاني يستخدم 'List Comprehension'، وهي طريقة بايثونية مختصرة وأنيقة لإنشاء قوائم بناءً على قوائم موجودة، مما يجعل الكود أقصر وأكثر قابلية للقراءة.

['#بايثون', '#برمجة', '#Python', '#Coding', '#ListComprehension', '#Tips']

🚀 تسريع عمليات البحث في بايثون! 🚀

هل سئمت من البحث البطيء في القوائم والنصوص؟ إليك حيلة سريعة باستخدام `in`!

my_list = list(range(1000000))
search_item = 999999

# الطريقة التقليدية (أبطأ)
if search_item in my_list:
    print("العنصر موجود (بالطريقة التقليدية)")

# طريقة أسرع باستخدام set (للبحث المتكرر)
my_set = set(my_list)
if search_item in my_set:
    print("العنصر موجود (باستخدام set)")

عند البحث عن عنصر في قائمة كبيرة، قد يستغرق الأمر وقتًا طويلاً. تحويل القائمة إلى `set` (مجموعة) قبل البحث يجعل العملية أسرع بكثير، خاصة إذا كنت ستقوم بالبحث عدة مرات، لأن البحث في المجموعات يتم في وقت ثابت (O(1)) تقريبًا، بينما في القوائم يعتمد على حجم القائمة (O(n)).

['#بايثون', '#برمجة', '#تطوير', '#Python', '#Programming', '#Tips']