⚡ المعامل الثلاثي في بايثون: اختصر أكوادك! ⚡

تعلم كيف تستخدم المعامل الثلاثي (Ternary Operator) في بايثون لكتابة شروط مختصرة وأنيقة بدلاً من جمل if/else التقليدية.

age = 20
status = "بالغ" if age >= 18 else "قاصر"
print(status)

المعامل الثلاثي يسمح لك بتعيين قيمة لمتغير بناءً على شرط معين في سطر واحد. الصيغة هي: `value_if_true if condition else value_if_false`.

['#بايثون', '#برمجة', '#معامل_ثلاثي', '#Python', '#Coding']

💡 شرح Type Hinting لتوثيق الكود في بايثون

تعلم كيف تجعل كود بايثون الخاص بك أكثر وضوحًا وقابلية للقراءة باستخدام Type Hinting. هذه الميزة تساعد في اكتشاف الأخطاء مبكرًا وتسهل التعاون بين المطورين.

def greet(name: str) -> str:
    return "Hello, " + name

user_name: str = "Alice"
print(greet(user_name))

في هذا المثال، نستخدم Type Hinting لتحديد أن الدالة `greet` تتوقع معاملًا من نوع `str` (نص) وتعيد قيمة من نوع `str`. كما نحدد أن المتغير `user_name` هو من نوع `str`. هذا يساعد أدوات التحليل الثابت (static analysis tools) مثل MyPy على التحقق من صحة أنواع البيانات في كودك.

['#Python', '#TypeHinting', '#Programming', '#Coding', '#Developer', '#بايثون', '#برمجة', '#توثيق_الكود']

🚀 التعامل مع التعبيرات النمطية (Regular Expressions) في بايثون

تعلم كيف تستخدم مكتبة `re` في بايثون للبحث عن الأنماط النصية واستبدالها ومعالجتها بكفاءة.

import re

text = "My email is user@example.com and my friend's is test.user@domain.co.uk."

# البحث عن عناوين البريد الإلكتروني
email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
emails = re.findall(email_pattern, text)
print(f"Found emails: {emails}")

# استبدال جزء من النص
new_text = re.sub(r'example.com', 'mycompany.org', text)
print(f"Modified text: {new_text}")

# التحقق من وجود نمط
if re.search(r'friend', text):
    print("The word 'friend' was found.")
else:
    print("The word 'friend' was not found.")

في هذا المثال، نستخدم `re.findall` للعثور على جميع عناوين البريد الإلكتروني المطابقة للنمط المحدد. نستخدم `re.sub` لاستبدال جزء من النص (اسم النطاق). وأخيرًا، نستخدم `re.search` للتحقق مما إذا كانت كلمة معينة موجودة في النص. التعبيرات النمطية قوية جدًا لمعالجة النصوص.

['#بايثون', '#برمجة', '#تعبيرات_نمطية', '#Regex', '#Python', '#Coding', '#نص']

💡 نصيحة بايثون سريعة: استخدام `enumerate` لعد العناصر! 💡

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

my_list = ['تفاحة', 'موز', 'كرز']

for index, value in enumerate(my_list):
    print(f"العنصر رقم {index + 1}: {value}")

الدالة `enumerate()` تضيف عدادًا إلى قابل للتكرار (مثل القوائم) وتعيده ككائن `enumerate`. يمكنك بعد ذلك استخدام هذا الكائن في حلقة `for` للحصول على كل من الفهرس والقيمة في كل تكرار، مما يجعل الكود أكثر وضوحًا.

['#بايثون', '#برمجة', '#نصائح_برمجة', '#enumerate', '#PythonTips', '#Coding']

💡 تحسين أداء Python باستخدام Decorators 🚀

تعلم كيف تجعل دوالك أكثر كفاءة وقابلية للقراءة باستخدام Decorators في Python.

def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"الدالة {func.__name__} استغرقت {end_time - start_time:.4f} ثانية")
        return result
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(2)
    print("الوظيفة البطيئة اكتملت!")

slow_function()

الـ Decorator هو نمط تصميم يسمح لك بإضافة وظائف جديدة إلى دالة موجودة مسبقاً دون تعديل هيكلها. في هذا المثال، الـ decorator `timer` يقيس وقت تنفيذ الدالة المزينة به `@timer`.

['#Python', '#Programming', '#Coding', '#Decorators', '#PythonTips', '#LearnToCode', '#SoftwareDevelopment']

✨ نصيحة بايثون سريعة: استخدام `enumerate` بفعالية ✨

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

my_list = ['تفاحة', 'موزة', 'كرز']

for index, value in enumerate(my_list):
    print(f"العنصر في الفهرس {index} هو: {value}")

# يمكنك أيضًا تحديد فهرس البداية:
for index, value in enumerate(my_list, start=1):
    print(f"العنصر رقم {index} هو: {value}")

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

['#بايثون', '#برمجة', '#نصائح_بايثون', '#enumerate', '#PythonTips', '#Coding']

🚀 تحسين أداء Python باستخدام Decorators!

هل تريد جعل كود Python الخاص بك أسرع وأكثر تنظيمًا؟ تعرف على Decorators وكيف يمكنها مساعدتك في ذلك!

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"الدالة {func.__name__} استغرقت {end_time - start_time:.4f} ثانية")
        return result
    return wrapper

@timer
def my_slow_function(n):
    time.sleep(n)
    return "انتهى!"

print(my_slow_function(2))

الـ Decorators في Python تسمح لك بتعديل أو تعزيز سلوك الدوال أو الأصناف بطريقة نظيفة. في هذا المثال، الـ decorator `timer` يقيس الوقت الذي تستغرقه دالة معينة للتنفيذ دون الحاجة لتعديل الكود الأصلي للدالة نفسها. الرمز `@timer` هو طريقة مختصرة لتطبيق الـ decorator.

['#Python', '#Programming', '#Coding', '#Tutorial', '#Decorators', '#PythonTips', '#LearnToCode']

💡 نصيحة بايثون: استخدام walrus operator (:=) 🐍

هل تعبت من تكرار المتغيرات في بايثون؟ إليك طريقة مختصرة وفعالة باستخدام عامل التعيين والتحقق (walrus operator)!

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

if (n := len(data)) > 3:
    print(f"القائمة طويلة! عدد العناصر: {n}")

# مقارنة مع الطريقة التقليدية:
# length = len(data)
# if length > 3:
#     print(f"القائمة طويلة! عدد العناصر: {length}")

عامل walrus operator (:=) يسمح لك بتعيين قيمة لمتغير ضمن تعبير شرطي أو حلقي. هذا يقلل من تكرار الكود ويجعله أكثر قابلية للقراءة، كما هو موضح في المثال حيث يتم تعيين طول القائمة للمتغير 'n' في نفس سطر جملة 'if'.

['#بايثون', '#برمجة', '#نصائح_بايثون', '#walrus_operator', '#PythonTips', '#coding']

🚀 تحسين أداء 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']

💡 نصيحة بايثون سريعة: استخدام underscore `_` 💡

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

print(10 + 5)
print(_)

for _ in range(3):
    print('مرحباً')

result = 100
# لا نحتاج للمتغير result لاحقاً، لذا نستخدم _
_ = result
print(f'قيمة المتغير المخفية: {_}')

في بايثون، يُستخدم `_` بعدة طرق:
1. في المترجم التفاعلي (REPL)، يشير `_` إلى نتيجة آخر تعبير تم تقييمه.
2. يُستخدم `_` كاسم متغير مؤقت أو غير مهم، خاصة في حلقات التكرار عندما لا نحتاج لقيمة العداد.
3. يُستخدم أحياناً لتجاهل قيمة معينة عند فك التعبئة (unpacking) أو لتخزين قيمة مؤقتة لا يتم استخدامها لاحقاً.

['#بايثون', '#برمجة', '#نصائح_بايثون', '#PythonTips', '#Coding']

💡 استدعاء الدوال بشكل ديناميكي في بايثون 🐍

هل تحتاج إلى استدعاء دالة بناءً على اسمها كسلسلة نصية؟ إليك طريقة سهلة وفعالة في بايثون!

def greet(name):
    return f"Hello, {name}!"

def say_goodbye(name):
    return f"Goodbye, {name}!"

function_name = "greet"
argument = "World"

# الحصول على الدالة من خلال اسمها
func = globals().get(function_name)

if func:
    result = func(argument)
    print(result)
else:
    print(f"Function '{function_name}' not found.")

function_name_2 = "say_goodbye"
func_2 = globals().get(function_name_2)

if func_2:
    result_2 = func_2("Alice")
    print(result_2)
else:
    print(f"Function '{function_name_2}' not found.")

نستخدم `globals().get(function_name)` للحصول على مرجع للدالة من خلال اسمها كسلسلة نصية. `globals()` يعيد قاموساً بجميع المتغيرات والدوال المعرفة على المستوى العام. `.get()` آمن لأنه يعيد `None` إذا لم يتم العثور على المفتاح (اسم الدالة) بدلاً من إطلاق استثناء.

['#بايثون', '#برمجة', '#PythonTips', '#DynamicCalls', '#Coding']

📚 تحسين استخدام الـ List Comprehensions في بايثون! 🚀

هل تريد كتابة أكواد بايثون أكثر إيجازًا وقوة؟ الـ List Comprehensions هي أداتك السحرية! ✨ دعنا نستكشف طريقة لتحسين استخدامها.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_squares = [x**2 for x in numbers if x % 2 == 0]
print(even_squares)

في هذا المثال، ننشئ قائمة `even_squares` تحتوي على مربعات الأعداد الزوجية فقط من القائمة الأصلية `numbers`، كل ذلك في سطر واحد أنيق! هذا يجعل الكود أسهل للقراءة وأكثر فعالية.

['#بايثون', '#برمجة', '#ListComprehensions', '#PythonTips', '#Coding']

✨ نصيحة بايثون سريعة: استخدام underscore (_) في بايثون 🐍

هل تساءلت يومًا عن معنى الـ underscore (_) في أكواد بايثون؟ إليك شرح موجز لاستخداماته المتعددة والمفيدة!

print(1000000)
print(1_000_000)

x, _ = (1, 2)
print(x)

# في حلقة تكرارية، لتجاهل قيمة
for _ in range(3):
    print("مرحباً!")

# في بعض المكتبات، للإشارة إلى متغير خاص أو غير مستخدم
class MyClass:
    def __init__(self):
        self._private_var = 10
        self.__mangled_var = 20

    def _protected_method(self):
        print("هذه دالة محمية")

    def __private_method(self):
        print("هذه دالة خاصة")

obj = MyClass()
print(obj._private_var)
obj._protected_method()

الـ underscore (_) له استخدامات متنوعة في بايثون:
1. **فواصل للأرقام:** لتسهيل قراءة الأرقام الكبيرة (مثل 1_000_000).
2. **تجاهل القيم:** عند فك حزم (unpacking) القيم وتريد تجاهل بعضها (مثل x, _ = (1, 2)).
3. **حلقات التكرار:** لتجاهل قيمة المتغير في كل دورة من حلقة تكرارية (مثل for _ in range(3)).
4. **اصطلاح للتسمية:** يستخدم المبرمجون الـ underscore كاصطلاح للإشارة إلى متغيرات أو دوال خاصة (private) أو محمية (protected) لا يُفترض الوصول إليها مباشرة من خارج الكلاس، على الرغم من أن بايثون لا تفرض ذلك بقوة.

['#بايثون', '#برمجة', '#نصائح_برمجية', '#PythonTips', '#Coding']

🚀 تحسين سرعة الدوال في بايثون باستخدام `lru_cache`

هل تعاني من بطء بعض الدوال التي تستدعيها مراراً وتكراراً بنفس المدخلات؟ دعنا نكتشف كيف يمكن لـ `lru_cache` تسريعها!

from functools import lru_cache
import time

@lru_cache(maxsize=None)
def slow_function(n):
    """دالة بطيئة تحاكي عملية مكلفة."""
    time.sleep(1) # محاكاة عملية تستغرق وقتاً
    return n * 2

# الاستدعاء الأول (سيستغرق وقتاً)
start_time = time.time()
result1 = slow_function(5)
end_time = time.time()
print(f"الاستدعاء الأول: {result1}, الوقت المستغرق: {end_time - start_time:.2f} ثانية")

# الاستدعاء الثاني بنفس المدخلات (سيكون سريعاً جداً)
start_time = time.time()
result2 = slow_function(5)
end_time = time.time()
print(f"الاستدعاء الثاني: {result2}, الوقت المستغرق: {end_time - start_time:.2f} ثانية")

# استدعاء بمدخلات مختلفة (سيستغرق وقتاً مجدداً)
start_time = time.time()
result3 = slow_function(10)
end_time = time.time()
print(f"الاستدعاء الثالث: {result3}, الوقت المستغرق: {end_time - start_time:.2f} ثانية")

الديكور `@lru_cache(maxsize=None)` يقوم بتخزين نتائج استدعاءات الدالة. عندما تُستدعى الدالة مرة أخرى بنفس المدخلات، يتم إرجاع النتيجة المخزنة مباشرة بدلاً من إعادة حسابها، مما يؤدي إلى تسريع كبير في الأداء، خاصة للدوال التي تتطلب عمليات حسابية معقدة أو مكلفة.

['#بايثون', '#برمجة', '#تحسين_الأداء', '#lru_cache', '#PythonTips', '#Coding']

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

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

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']

💡 تحسين سرعة الدوال في بايثون باستخدام @lru_cache ✨

هل تعاني من بطء بعض الدوال في بايثون؟ تعرف على طريقة سحرية لتسريعها باستخدام التخزين المؤقت للنتائج!

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(30))
print(fibonacci(35))

المُزخرف `@lru_cache` يقوم بتخزين نتائج استدعاءات الدالة. إذا تم استدعاء الدالة بنفس المعاملات مرة أخرى، يتم إرجاع النتيجة المخزنة بدلاً من إعادة حسابها، مما يسرع الأداء بشكل كبير، خاصة للدوال العودية أو التي تستغرق وقتاً طويلاً.

['#بايثون', '#برمجة', '#تطوير', '#Python', '#Coding', '#Optimization', '#lru_cache']

💡 نصائح بايثون: استخدام `enumerate` لسهولة الوصول للفهرس والقيمة 💡

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

my_list = ['تفاحة', 'موزة', 'كرز']

for index, value in enumerate(my_list):
    print(f'الفهرس: {index}, القيمة: {value}')

الدالة `enumerate()` تأخذ أي كائن قابل للتكرار (مثل القائمة) وتعيد كائن `enumerate` الذي ينتج أزواجًا تحتوي على الفهرس والقيمة لكل عنصر في الكائن الأصلي. هذا يغنينا عن الحاجة إلى متغير عداد منفصل.

['#بايثون', '#برمجة', '#نصائح_بايثون', '#enumerate', '#PythonTips', '#Coding']