🐍 كيفية استخدام `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

🐍 الفرق بين الأنواع القابلة للتغيير (Mutable) وغير القابلة للتغيير (Immutable) في بايثون

فهم الفرق بين الكائنات القابلة للتغيير وغير القابلة للتغيير أمر أساسي لكتابة كود بايثون فعال وتجنب الأخطاء غير المتوقعة، خاصة عند التعامل مع تمرير الكائنات للدوال أو في العمليات المتوازية.

Immutable Types (أنواع غير قابلة للتغيير):
الكائنات التي لا يمكن تغيير قيمتها بعد إنشائها. إذا قمت بتعيين قيمة جديدة لمتغير يحمل كائنًا غير قابل للتغيير، فأنت في الواقع تقوم بإنشاء كائن جديد وتعيين المتغير ليشير إليه.
أمثلة شائعة: int, float, str, tuple, bool, frozenset.

# مثال على Immutable Type (str)
my_string = "Hello"
print(f"Original string: {my_string}, ID: {id(my_string)}")

my_string = my_string + " World" # هذا ينشئ كائن string جديد
print(f"Modified string: {my_string}, ID: {id(my_string)}")

my\_tuple = (1, 2, 3)
print(f"Original tuple: {my_tuple}, ID: {id(my_tuple)}")

my_tuple = my_tuple + (4,) # هذا ينشئ كائن tuple جديد
print(f"Modified tuple: {my_tuple}, ID: {id(my_tuple)}")

Mutable Types (أنواع قابلة للتغيير):
الكائنات التي يمكن تغيير محتواها بعد إنشائها دون الحاجة لإنشاء كائن جديد. التغييرات تتم على الكائن الأصلي مباشرة.
أمثلة شائعة: list, dict, set, bytearray.

# مثال على Mutable Type (list)
my_list = [1, 2, 3]
print(f"Original list: {my_list}, ID: {id(my_list)}")

my_list.append(4) # يتم تعديل الكائن الأصلي
print(f"Modified list: {my_list}, ID: {id(my_list)}")

my_dict = {'a': 1, 'b': 2}
print(f"Original dict: {my_dict}, ID: {id(my_dict)}")

my_dict['c'] = 3 # يتم تعديل الكائن الأصلي
print(f"Modified dict: {my_dict}, ID: {id(my_dict)}")

لماذا هذا مهم؟
عند تمرير كائن Immutable إلى دالة، لا يمكن للدالة تغيير الكائن الأصلي. أما عند تمرير كائن Mutable، فيمكن للدالة تعديله، مما يؤثر على الكائن الأصلي خارج نطاق الدالة.

def modify_immutable(value):
    value = value + 1 # ينشئ قيمة جديدة، ولا يؤثر على الأصل
    return value

def modify_mutable(items):
    items.append(10) # يعدل القائمة الأصلية

x = 5
print(f"Before modify_immutable: x = {x}")
x = modify_immutable(x)
print(f"After modify_immutable: x = {x}") # x يتغير لأننا قمنا بإعادة تعيينه

my_list_func = [1, 2]
print(f"Before modify_mutable: my_list_func = {my_list_func}")
modify_mutable(my_list_func)
print(f"After modify_mutable: my_list_func = {my_list_func}") # القائمة الأصلية تتغير

#Python #Programming #Tutorial #Mutable #Immutable #DataTypes

🐍 شرح النصوص (Strings) وطرق تشكيلها (F-strings)

النصوص (Strings) هي تسلسلات من الحروف، وهي من أنواع البيانات الأساسية في بايثون. تُستخدم لتخزين وعرض المعلومات النصية.

التعريف الأساسي للنصوص:
يمكن تعريف النصوص باستخدام علامات الاقتباس المفردة (') أو المزدوجة (").

my_string_single = 'مرحباً بالعالم!'
my_string_double = "Hello, World!"
print(my_string_single)
print(my_string_double)

تشكيل النصوص باستخدام F-strings:
F-strings (Formatted string literals) هي طريقة حديثة وفعالة لتضمين المتغيرات والتعبيرات داخل النصوص مباشرة. تبدأ بكتابة الحرف 'f' قبل علامة الاقتباس.

name = "علي"
age = 30

# استخدام f-string لتضمين المتغيرات
greeting = f"مرحباً، اسمي {name} وعمري {age} سنة."
print(greeting)

# يمكن أيضاً تضمين تعبيرات داخل f-strings
calculation = f"نتائج عملية الجمع: {5 + 7}"
print(calculation)

#Python #PythonArabs #Strings #Fstrings #Tutorial

🐍 شرح القوائم (Lists) وأهم دوالها

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

# إنشاء قائمة
my_list = [1, "hello", 3.14, True]
print(my_list)

# الوصول للعناصر (indexing يبدأ من 0)
print(my_list[1]) # Output: hello

# تغيير عنصر
my_list[0] = 100
print(my_list) # Output: [100, 'hello', 3.14, True]

# إضافة عنصر في النهاية
my_list.append("new item")
print(my_list)

# إدراج عنصر في موقع محدد
my_list.insert(1, "inserted")
print(my_list)

# حذف عنصر بالقيمة
my_list.remove(3.14)
print(my_list)

# حذف عنصر بالموقع (index)
popped_item = my_list.pop() # يحذف ويرجع العنصر الأخير
print(popped_item)
print(my_list)

del my_list[0] # يحذف العنصر في الموقع 0
print(my_list)

# طول القائمة
print(len(my_list))

# البحث عن عنصر (يرجع True أو False)
print("hello" in my_list)

# فرز القائمة (ترتيب تصاعدي)
numbers = [3, 1, 4, 1, 5, 9, 2]
numbers.sort()
print(numbers)

# عكس ترتيب القائمة
numbers.reverse()
print(numbers)

# مسح كل عناصر القائمة
# my_list.clear()
# print(my_list)

#Python #Lists #Programming #Tutorial #PythonArabs

🐍 شرح الصفوف (Tuples) والفرق بينها وبين القوائم

تُعد الصفوف (Tuples) والقوائم (Lists) من هياكل البيانات الأساسية في بايثون لتخزين مجموعات من العناصر. ومع ذلك، هناك فرق جوهري بينهما: القوائم قابلة للتغيير (mutable) بينما الصفوف غير قابلة للتغيير (immutable).

متى نستخدم الصفوف؟

نستخدم الصفوف عندما نريد التأكد من أن البيانات المخزنة داخلها لن تتغير بعد إنشائها. هذا يجعلها مفيدة لتخزين البيانات الثابتة مثل إحداثيات جغرافية، أو قيم تكوين، أو عند إعادة قيم متعددة من دالة.

# تعريف صف (Tuple)
coordinates = (10.5, 20.3)

# تعريف قائمة (List)
my_list = [1, 2, 3]

# محاولة تغيير عنصر في الصف - سيؤدي إلى خطأ
# coordinates[0] = 5.0  # TypeError: 'tuple' object does not support item assignment

# تغيير عنصر في القائمة - مسموح به
my_list[0] = 5
print(my_list) # Output: [5, 2, 3]

# الوصول للعناصر في الصف
print(coordinates[0]) # Output: 10.5

# يمكن فك حزم الصفوف مباشرة
x, y = coordinates
print(f"X: {x}, Y: {y}") # Output: X: 10.5, Y: 20.3

#Python #Tuples #Lists #Programming #Tutorial

🐍 شرح القواميس (Dictionaries) وطرق التعامل معها

القواميس في بايثون هي هياكل بيانات غير مرتبة وقابلة للتغيير (mutable) وتسمح بتخزين البيانات على شكل أزواج من المفاتيح (keys) والقيم (values). كل مفتاح يجب أن يكون فريدًا وغير قابل للتغيير (immutable)، بينما يمكن أن تكون القيم من أي نوع بيانات.

# إنشاء قاموس
student = {
    "name": "Ahmed",
    "age": 20,
    "major": "Computer Science",
    "grades": [90, 85, 92]
}

# الوصول إلى قيمة باستخدام المفتاح
print(student["name"])  # Output: Ahmed
print(student.get("age")) # Output: 20

# إضافة عنصر جديد
student["university"] = "Cairo University"
print(student)

# تعديل قيمة موجودة
student["age"] = 21
print(student)

# حذف عنصر
del student["major"]
print(student)

# الحصول على المفاتيح فقط
print(student.keys()) # Output: dict_keys(['name', 'age', 'grades', 'university'])

# الحصول على القيم فقط
print(student.values()) # Output: dict_values(['Ahmed', 21, [90, 85, 92], 'Cairo University'])

# الحصول على أزواج المفاتيح والقيم
print(student.items()) # Output: dict_items([('name', 'Ahmed'), ('age', 21), ('grades', [90, 85, 92]), ('university', 'Cairo University')])

# التحقق مما إذا كان المفتاح موجودًا
print("name" in student) # Output: True
print("email" in student) # Output: False

# طول القاموس
print(len(student)) # Output: 4

#Python #PythonAr #Dictionaries #Programming #Tutorial

✨ مطابقة الأنماط (Pattern Matching) في بايثون 3.10+

تعرف على ميزة مطابقة الأنماط الجديدة (match/case) التي تم تقديمها في بايثون 3.10، وكيف يمكنها تبسيط الكود الخاص بك.

def http_status(status):
    match status:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500:
            return "Internal Server Error"
        case _:
            return "Unknown Status"

print(http_status(200))
print(http_status(404))
print(http_status(999))

تسمح لك عبارة `match/case` بمقارنة قيمة بمتعددة أنماط مختلفة. إنها تشبه عبارة `switch` في لغات أخرى، لكنها أكثر قوة حيث يمكنها مطابقة هياكل البيانات المعقدة أيضًا. في هذا المثال، نستخدمها لتعيين رسالة نصية لحالة HTTP.

['#Python', '#Python310', '#PatternMatching', '#Programming', '#Tutorial']

مقدمة في مكتبة asyncio 🐍

تعلم أساسيات البرمجة غير المتزامنة في بايثون باستخدام مكتبة asyncio.

import asyncio

async def say_hello(name):
    print(f'Hello, {name}!')
    await asyncio.sleep(1)
    print(f'Goodbye, {name}!')

async def main():
    await asyncio.gather(
        say_hello('Alice'),
        say_hello('Bob')
    )

if __name__ == '__main__':
    asyncio.run(main())

تسمح لك asyncio بكتابة كود متزامن (concurrent) باستخدام تركيبات `async` و `await`. في هذا المثال، تقوم الدالة `say_hello` بالطباعة والانتظار لمدة ثانية. الدالة `main` تشغل دالتين `say_hello` بشكل متزامن باستخدام `asyncio.gather`، مما يعني أنهما يمكن أن تعملا في نفس الوقت دون حظر التنفيذ الرئيسي.

['#Python', '#Asyncio', '#Programming', '#Concurrency', '#Tutorial']

🚀 إنشاء والتعامل مع DataFrames في Pandas

هذا الدليل السريع سيساعدك على البدء في إنشاء ومعالجة هياكل البيانات الأساسية في Python باستخدام مكتبة Pandas.

import pandas as pd

# إنشاء DataFrame من قاموس
data = {'col1': [1, 2, 3], 'col2': ['A', 'B', 'C']}
df_from_dict = pd.DataFrame(data)
print('DataFrame من قاموس:\n', df_from_dict)

# إنشاء DataFrame من قائمة قوائم
data_list = [[10, 'X'], [20, 'Y'], [30, 'Z']]
df_from_list = pd.DataFrame(data_list, columns=['Numbers', 'Letters'])
print('\nDataFrame من قائمة قوائم:\n', df_from_list)

# الوصول إلى عمود
print('\nالوصول إلى عمود col1:', df_from_dict['col1'])

# الوصول إلى صف (باستخدام iloc)
print('\nالوصول إلى الصف الأول (index 0):\n', df_from_list.iloc[0])

# تصفية البيانات
print('\nتصفية الصفوف حيث Numbers > 15:\n', df_from_list[df_from_list['Numbers'] > 15])

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

['#Python', '#Pandas', '#DataFrame', '#DataScience', '#Programming', '#Tutorial']

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

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

🚀 فك شيفرة الـ Lambda في بايثون! 🚀

هل سبق لك أن رأيت دوال قصيرة ومجهولة في بايثون وتساءلت عن سرها؟ إنها دوال Lambda! دعنا نكتشفها معًا.

add_five = lambda x: x + 5
print(add_five(10))

multiply = lambda x, y: x * y
print(multiply(3, 7))

دوال Lambda هي دوال صغيرة تُعرف بكلمة 'lambda'. تُستخدم عادةً للتعبيرات البسيطة التي تحتاج إلى دالة لفترة قصيرة. يمكن أن تأخذ أي عدد من الوسائط، ولكن يمكن أن تحتوي على تعبير واحد فقط. في المثال الأول، عرفنا دالة lambda تأخذ 'x' وتضيف إليه 5. في المثال الثاني، تأخذ 'x' و 'y' وتضربهما.

['#Python', '#Lambda', '#Programming', '#Code', '#Tutorial', '#بايثون', '#برمجة']

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

✨ التلاعب بالبيانات باستخدام 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', '#تعلم_بايثون', '#علم_البيانات']