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

هل سئمت من تكرار نفس المتغيرات في Python؟ تعرف على عامل التعيين المُقوّس (Walrus Operator) الذي يسمح لك بتعيين قيمة لمتغير كجزء من تعبير!

def greet(name):
    if (n := len(name)) > 3:
        print(f"Hello, {name}! Your name is long ({n} characters).")

greet('Alice')
greet('Bob')

في هذا المثال، نقوم بتعيين طول الاسم للمتغير `n` باستخدام `:=` داخل جملة `if`. هذا يجعل الكود أقصر وأكثر قابلية للقراءة لأنه يتجنب حساب الطول مرتين.

['#Python', '#Programming', '#WalrusOperator', '#CodeTips', '#PythonTricks']

🚀 استكشاف قوائم بايثون: الشرائح (Slicing) 🚀

هل تريد استخراج أجزاء معينة من القوائم في بايثون بكفاءة؟ تعلم فن الشرائح (Slicing) مع هذا المثال السريع!

my_list = [10, 20, 30, 40, 50, 60, 70, 80]
# استخراج العناصر من الفهرس 2 إلى 5 (غير شامل)
sub_list1 = my_list[2:5]
print(f"العناصر من 2 إلى 5: {sub_list1}")

# استخراج العناصر من البداية حتى الفهرس 3 (غير شامل)
sub_list2 = my_list[:3]
print(f"العناصر حتى الفهرس 3: {sub_list2}")

# استخراج العناصر من الفهرس 4 حتى النهاية
sub_list3 = my_list[4:]
print(f"العناصر من الفهرس 4: {sub_list3}")

# استخراج العناصر بخطوة 2
sub_list4 = my_list[::2]
print(f"العناصر بخطوة 2: {sub_list4}")

# عكس القائمة باستخدام الشرائح
reversed_list = my_list[::-1]
print(f"القائمة المعكوسة: {reversed_list}")

تسمح لك الشرائح (Slicing) في بايثون بإنشاء قوائم فرعية جديدة من قائمة موجودة عن طريق تحديد نقاط البداية والنهاية والخطوة. الصيغة العامة هي `[start:stop:step]`. إذا تم حذف `start`، يبدأ من البداية. إذا تم حذف `stop`، يستمر حتى النهاية. `step` يحدد مقدار التقدم. استخدام `[::-1]` يعكس القائمة.

['#بايثون', '#برمجة', '#تعلم_بايثون', '#قوائم_بايثون', '#شرائح_بايثون', '#Python', '#Programming', '#PythonTips']

✨ نصائح بايثون: التعامل مع الأخطاء بذكاء! 🐍

هل سئمت من توقف برنامجك بسبب الأخطاء غير المتوقعة؟ تعلم كيف تتعامل معها بفعالية باستخدام try-except في بايثون.

try:
    # الكود الذي قد يسبب خطأ
    result = 10 / 0
    print(result)
except ZeroDivisionError:
    print("خطأ: لا يمكن القسمة على صفر!")
except Exception as e:
    print(f"حدث خطأ غير متوقع: {e}")
finally:
    print("تم الانتهاء من محاولة التنفيذ.")

كتلة `try` تحتوي على الكود الذي تريد تجربته. إذا حدث خطأ، ينتقل التنفيذ إلى كتلة `except` المناسبة. يمكنك تحديد أنواع أخطاء مختلفة (`ZeroDivisionError`, `ValueError`, إلخ) أو استخدام `Exception` عام. كتلة `finally` تُنفذ دائمًا، سواء حدث خطأ أم لا، وهي مفيدة لتنظيف الموارد.

['#بايثون', '#برمجة', '#تعلم_بايثون', '#Python', '#Programming', '#ErrorHandling', '#TryExcept']

✨ تعلم البرمجة بلغة بايثون: المتغيرات وأنواع البيانات ✨

مرحباً بكم في أول درس عملي لتعلم البرمجة باستخدام لغة بايثون! سنتعرف اليوم على أساسيات هامة: المتغيرات وأنواع البيانات.

name = "أحمد"
age = 30
height = 1.75
is_student = False

print(f"الاسم: {name}")
print(f"العمر: {age}")
print(f"الطول: {height}")
print(f"هل هو طالب؟ {is_student}")

print(type(name))
print(type(age))
print(type(height))
print(type(is_student))

في هذا الكود، قمنا بتعريف متغيرات لتخزين أنواع مختلفة من البيانات: نص (string)، عدد صحيح (integer)، عدد عشري (float)، وقيمة منطقية (boolean). الدالة `type()` تساعدنا في معرفة نوع البيانات التي يحتوي عليها كل متغير. هذه هي اللبنات الأساسية لأي برنامج!

['#بايثون', '#برمجة', '#تعلم_البرمجة', '#متغيرات', '#أنواع_البيانات', '#Python', '#Programming', '#LearnToCode']

🚀 تبسيط التعامل مع القوائم في بايثون!

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

my_list = [1, 2, 3, 4, 5]
first_three = my_list[:3]
print(first_three)

نستخدم هنا 'تقطيع القوائم' (List Slicing) في بايثون. `my_list[:3]` تعني 'خذ العناصر من البداية حتى العنصر ذي الفهرس 3 (ولكن لا تشمله)'. إنها طريقة أنيقة لاستخراج أجزاء من القوائم.

['#بايثون', '#برمجة', '#قوائم', '#خدع_بايثون', '#Python', '#Programming', '#Lists', '#PythonTips']

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

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

print('Hello, World!')
# للتنقل السريع بين الأسطر
# Ctrl + Up/Down (في بعض المحررات)

# لتحديد كتلة من الكود
# Shift + Up/Down

# لنسخ سطر
# Ctrl + C (مع تحديد السطر)

# للصق سطر
# Ctrl + V

# للتراجع
# Ctrl + Z

# لإعادة الإجراء
# Ctrl + Y

هذه الاختصارات شائعة في معظم محررات النصوص وبيئات التطوير المتكاملة (IDEs). تساعد في التنقل السريع، تحديد الكود، النسخ، اللصق، والتراجع، مما يوفر وقتًا وجهدًا كبيرين.

['#بايثون', '#برمجة', '#تطوير', '#اختصارات', '#تعلم_بايثون', '#Python', '#Programming', '#Developer']

⚡️ إدارة الملفات بكفاءة في بايثون! ⚡️

هل تحتاج إلى التعامل مع الملفات والمجلدات في بايثون؟ إليك طريقة سهلة وفعالة باستخدام وحدة `os`.

import os

# الحصول على المسار الحالي
current_directory = os.getcwd()
print(f"المسار الحالي: {current_directory}")

# إنشاء مجلد جديد
new_folder_name = "my_new_folder"
os.makedirs(new_folder_name, exist_ok=True)
print(f"تم إنشاء المجلد: {new_folder_name}")

# قائمة بجميع الملفات والمجلدات في المسار الحالي
all_items = os.listdir(current_directory)
print(f"محتويات المسار الحالي: {all_items}")

# التحقق مما إذا كان المسار ملفاً أو مجلداً
if os.path.isdir(new_folder_name):
    print(f"'{new_folder_name}' هو مجلد.")
elif os.path.isfile(new_folder_name):
    print(f"'{new_folder_name}' هو ملف.")

# حذف مجلد (يجب أن يكون فارغاً)
# os.rmdir(new_folder_name)
# print(f"تم حذف المجلد: {new_folder_name}")

# حذف ملف (مثال)
# file_to_delete = "my_file.txt"
# if os.path.exists(file_to_delete):
#     os.remove(file_to_delete)
#     print(f"تم حذف الملف: {file_to_delete}")

تسمح لك وحدة `os` في بايثون بالتفاعل مع نظام التشغيل، بما في ذلك إدارة الملفات والمجلدات. يمكنك الحصول على المسار الحالي، إنشاء مجلدات جديدة، سرد محتويات المجلدات، والتحقق من أنواع المسارات. استخدم `os.makedirs` لإنشاء مجلدات (بما في ذلك المجلدات الأصلية إذا لزم الأمر) مع `exist_ok=True` لتجنب الأخطاء إذا كان المجلد موجوداً بالفعل. `os.listdir` يعطيك قائمة بجميع العناصر داخل المسار المحدد. `os.path.isdir` و `os.path.isfile` للتحقق من نوع المسار. تذكر أن `os.rmdir` يحذف المجلدات الفارغة فقط، بينما `os.remove` يحذف الملفات.

['#بايثون', '#برمجة', '#تطوير', '#ملفات', '#نصائح_برمجية', '#Python', '#Programming', '#FileManagement']

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

✨ تلميح بايثون: استخدام `enumerate` للحصول على الفهرس والقيمة معًا! 🚀

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

my_list = ['apple', 'banana', 'cherry']

for index, value in enumerate(my_list):
    print(f"Index: {index}, Value: {value}")

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

['#Python', '#Programming', '#CodingTips', '#LearnToCode', '#PythonTips', '#enumerate']

✨ التلاعب بالبيانات باستخدام Pandas: دليلك السريع! 🐼

هل تتعامل مع جداول البيانات في بايثون؟ Pandas هي أداتك السحرية! تعلم كيف تبدأ بسرعة.

import pandas as pd

data = {'Name': ['Alice', 'Bob', 'Charlie', 'David'],
        'Age': [25, 30, 35, 40],
        'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']}

df = pd.DataFrame(data)

print('DataFrame الأصلي:')
print(df)

print('\nالأسماء فقط:')
print(df['Name'])

print('\nالأشخاص الذين تزيد أعمارهم عن 30:')
print(df[df['Age'] > 30])

في هذا المثال، نقوم بإنشاء DataFrame بسيط باستخدام Pandas. ثم نعرض DataFrame بأكمله، ونختار عمود 'Name' فقط، ونقوم بتصفية الصفوف لعرض الأشخاص الذين تزيد أعمارهم عن 30 عامًا. Pandas تجعل معالجة البيانات سهلة وفعالة.

['#Python', '#Pandas', '#DataAnalysis', '#DataScience', '#Programming', '#Tutorial', '#تعلم_بايثون', '#علم_البيانات']

✨ تخصيص معالجة الأخطاء في بايثون 🐍

تعلم كيف تجعل برنامجك أكثر قوة ومرونة عن طريق التعامل مع الأخطاء بطرق مبتكرة باستخدام كتل `try`, `except`, `else`, و `finally`.

def divide_numbers(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("خطأ: لا يمكن القسمة على صفر!")
        result = None
    except TypeError:
        print("خطأ: يجب أن تكون المدخلات أرقامًا!")
        result = None
    else:
        print(f"النتيجة هي: {result}")
    finally:
        print("تم الانتهاء من محاولة القسمة.")

divide_numbers(10, 2)
divide_numbers(10, 0)
divide_numbers(10, 'a')

كتلة `try` تحتوي على الكود الذي قد يسبب خطأ. `except` تلتقط أنواعًا محددة من الأخطاء وتعالجها. `else` تُنفذ إذا لم يحدث أي خطأ في `try`. `finally` تُنفذ دائمًا، سواء حدث خطأ أم لا، وهي مفيدة لتنظيف الموارد.

['#بايثون', '#برمجة', '#دروس_بايثون', '#معالجة_الأخطاء', '#Python', '#Programming', '#ErrorHandling']

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

🚀 شرح مبسط لمعالجة الأخطاء في بايثون!

هل سئمت من توقف برنامجك فجأة؟ تعلم كيف تتعامل مع الأخطاء بذكاء باستخدام try-except في بايثون.

def divide_numbers(a, b):
    try:
        result = a / b
        print(f"النتيجة هي: {result}")
    except ZeroDivisionError:
        print("خطأ: لا يمكنك القسمة على صفر!")
    except TypeError:
        print("خطأ: تأكد أن المدخلات أرقام صحيحة.")
    finally:
        print("انتهت عملية القسمة.")

divide_numbers(10, 2)
divide_numbers(10, 0)
divide_numbers(10, "a")

نستخدم كتلة `try` لتجربة الكود الذي قد يسبب خطأ. إذا حدث خطأ، يتم الانتقال إلى كتلة `except` المناسبة (مثل `ZeroDivisionError` أو `TypeError`) لتنفيذ كود بديل. كتلة `finally` تُنفذ دائمًا، سواء حدث خطأ أم لا، وهي مفيدة لتنظيف الموارد.

['#بايثون', '#برمجة', '#تعلم_البرمجة', '#معالجة_الأخطاء', '#Python', '#Programming', '#ErrorHandling']

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

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

import re

text = "Hello, world!"

# بدون Walrus Operator
match = re.search(r'world', text)
if match:
    print(f"Found: {match.group()}")

# مع Walrus Operator (:=)
if (match := re.search(r'world', text)):
    print(f"Found: {match.group()}")

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

['#Python', '#WalrusOperator', '#CodingTips', '#Programming', '#Python38']

✨ فهم ميزة 'Walrus Operator' في بايثون 🐍

هل سبق لك أن شعرت أن كود بايثون الخاص بك يمكن أن يكون أقصر وأكثر وضوحًا؟ تعرف على "عامل الفظ" (Walrus Operator) وكيف يمكنه تبسيط تعيين المتغيرات داخل التعبيرات!

import re

text = "Hello, world!"

if match := re.search(r"world", text):
    print(f"Found 'world' at index {match.start()}")
else:
    print("Not found")

# بدون عامل الفظ، ستبدو هكذا:
# match = re.search(r"world", text)
# if match:
#     print(f"Found 'world' at index {match.start()}")
# else:
#     print("Not found")

عامل الفظ (:=) يسمح لك بتعيين قيمة لمتغير كجزء من تعبير. في المثال، يتم البحث عن كلمة 'world' في النص، وإذا تم العثور عليها، يتم تخزين نتيجة البحث في المتغير `match` ويتم استخدام هذا المتغير مباشرة في جملة `if`. هذا يجعل الكود أكثر إيجازًا، خاصة في حالات مثل التحقق من الشروط وتعيين القيم في نفس الوقت.

['#Python', '#Programming', '#WalrusOperator', '#CodingTips', '#LearnPython', '#بايثون', '#برمجة']

⚡️ اختصارات لوحة المفاتيح في بايثون 🐍

هل تعلم أن استخدام اختصارات لوحة المفاتيح يمكن أن يسرع عملك بشكل كبير أثناء كتابة كود بايثون؟ إليك بعض الاختصارات الأساسية التي ستغير طريقة عملك!

print('Hello, World!')
# Ctrl+D: نسخ السطر الحالي
# Ctrl+X: قص السطر الحالي
# Ctrl+C: نسخ السطر الحالي (إذا لم يتم تحديد شيء)
# Ctrl+V: لصق السطر
# Ctrl+Z: التراجع عن آخر إجراء
# Ctrl+Y: إعادة آخر إجراء تم التراجع عنه
# Ctrl+Shift+K: حذف السطر الحالي
# Alt+Up/Down: نقل السطر الحالي لأعلى/لأسفل
# Ctrl+Alt+Up/Down: نسخ السطر الحالي لأعلى/لأسفل

هذه الاختصارات تعتمد على بيئة التطوير المتكاملة (IDE) أو محرر النصوص الذي تستخدمه (مثل VS Code, PyCharm, Sublime Text). قم بتجربتها لتكتشف مدى فعاليتها في تسريع عملية البرمجة.

['#بايثون', '#برمجة', '#اختصارات', '#تطوير', '#Python', '#Programming', '#Shortcuts', '#Development']

🚀 تنظيم الكود باستخدام الدوال في بايثون

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

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

message = greet("World")
print(message)

def add_numbers(a, b):
    return a + b

result = add_numbers(5, 3)
print(f"The sum is: {result}")

الدوال (functions) تسمح لك بتجميع مجموعة من الأوامر لأداء مهمة معينة. يمكنك استدعاء الدالة عدة مرات، مما يقلل التكرار ويجعل الكود أسهل في الفهم والصيانة. في المثال، قمنا بإنشاء دالة `greet` للترحيب ودالة `add_numbers` لجمع رقمين.

['#بايثون', '#برمجة', '#دوال', '#تنظيم_الكود', '#Python', '#Programming', '#Functions', '#CodeOrganization']

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

هل سئمت من البحث البطيء في القوائم والنصوص؟ إليك حيلة سريعة باستخدام `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']

💡 نصيحة بايثون: استخدام Walrus Operator (:=) 🚀

هل سئمت من تكرار المتغيرات في شروطك؟ عامل Walrus الجديد في بايثون (:=) يحل هذه المشكلة بذكاء!

import re

text = "Hello, world!"
if (match := re.search(r"world", text)): 
    print(f"Found: {match.group()}")
else:
    print("Not found")

عامل Walrus (:=) يسمح لك بتعيين قيمة لمتغير داخل تعبير. في هذا المثال، نبحث عن كلمة 'world' في النص. إذا تم العثور عليها، يتم تعيين نتيجة البحث للمتغير 'match' ثم يتم استخدام 'match' مباشرة في جملة if. هذا يجعل الكود أقصر وأكثر قابلية للقراءة.

['#Python', '#Programming', '#CodingTips', '#Developer', '#Python3', '#WalrusOperator']

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

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

print('Hello, World!')
# اختصارات شائعة:
# Ctrl+C: نسخ
# Ctrl+V: لصق
# Ctrl+X: قص
# Ctrl+Z: تراجع
# Ctrl+S: حفظ
# Ctrl+F: بحث
# Ctrl+Shift+F: بحث شامل
# Ctrl+A: تحديد الكل
# Ctrl+B: تشغيل الكود (في بعض البيئات)
# Ctrl+D: حذف السطر الحالي (في بعض البيئات)
# Alt+Shift+Up/Down: نسخ السطر لأعلى/لأسفل (في بعض البيئات)

هذه الاختصارات تختلف قليلاً بين محررات الأكواد وبيئات التطوير المتكاملة (IDEs). قم بتجربة هذه الاختصارات في بيئتك المفضلة لتسريع عملية كتابة الكود وتعديله.

['#بايثون', '#برمجة', '#اختصارات', '#لوحة_المفاتيح', '#تطوير', '#Python', '#Programming', '#Shortcuts']