عملية الدمج والانضمام تتيح لك دمج جداول مختلفة معًا بناءً على عمود أو مؤشر مشترك. يوفر Pandas وظيفتين لتحقيق ذلك: merge() و join().

لنبدأ بعملية الدمج (merge):

1. استيراد مكتبة Pandas:

python
import pandas as pd

2. إنشاء الجداول الأيسر والأيمن التي ترغب في دمجها:

python
left_table = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
                           'value1': [1, 2, 3, 4]})
                           
right_table = pd.DataFrame({'key': ['B', 'D', 'E', 'F'],
                            'value2': [5, 6, 7, 8]})

ستكون لدينا جدولين، left_table و right_table، وكل منهما يحتوي على عمود يسمى 'key' وعمود آخر.

3. استخدام وظيفة merge لدمج الجداول:

python
merged_table = pd.merge(left_table, right_table, on='key', how='inner')

نستخدم merge() ونمرر الجدول الأيسر والأيمن كمعلمتين ونحدد العمود المشترك بينهما بواسطة on='key'، ونحدد نوع الدمج المطلوب (مثل الدمج الداخلي) باستخدام how='inner'.

4. طباعة الجدول المدموج:

python
print(merged_table)

ستظهر لك الصفوف المدموجة بناءً على العمود المشترك 'key'.

الآن، دعنا نلقي نظرة على عملية الانضمام (join):

1. استيراد مكتبة Pandas:

python
import pandas as pd

2. إنشاء الجداول الأيسر والأيمن التي ترغب في الانضمام:

python
left_table = pd.DataFrame({'key': ['A', 'B', 'C'],
                           'value1': [1, 2, 3]})

right_table = pd.DataFrame({'value2': [4, 5, 6]},
                            index=['A', 'B', 'C'])

ستكون لدينا جدولين، left_table و right_table

، وكل منهما يحتوي على عمود أو مؤشر.

3. استخدام وظيفة join للانضمام بناءً على المؤشر:

python
joined_table = left_table.join(right_table)

نستخدم join() ونمرر الجدول الأيسر والجدول الأيمن، وسيتم الانضمام بناءً على المؤشر المحدد تلقائيًا.

4. طباعة الجدول المنضم:

python
print(joined_table)

ستظهر لك الصفوف المنضمة بناءً على المؤشر المحدد.

هذه هي الخطوات الأساسية لعمليتي الدمج والانضمام في Pandas.

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

فيما يلي خطوات بسيطة لشرح كيفية عمل Shuffle Rows في Pandas:

1. استيراد مكتبة Pandas:

python
import pandas as pd

2. إنشاء الجدول الذي ترغب في تبديل صفوفه:

python
data = pd.DataFrame({'A': [1, 2, 3, 4, 5],
                     'B': [6, 7, 8, 9, 10],
                     'C': [11, 12, 13, 14, 15]})

سنستخدم هذا الجدول كمثال لشرح Shuffle Rows.

3. تطبيق Shuffle Rows باستخدام دالة sample:

python
shuffled_data = data.sample(frac=1)

نستخدم دالة sample() ونمرر معلمة frac=1 للحصول على عينة عشوائية من الصفوف في الجدول بنسبة 100٪. هذا يعني أن جميع الصفوف ستتم تبديلها بشكل عشوائي.

4. طباعة الجدول المقلوب:

python
print(shuffled_data)

ستظهر لك البيانات بعد تبديل صفوفها بشكل عشوائي.

هذه هي الخطوات الأساسية لتنفيذ Shuffle Rows في Pandas باستخدام دالة sample(). يمكنك استخدام هذه الطريقة لتقليب ترتيب صفوف الجدول واستخدامها في تطبيقاتك المختلفة حسب الحاجة.

Shuffle Rows

Run Time في Pandas يشير إلى وقت تنفيذ العمليات والأوامر على البيانات باستخدام مكتبة Pandas. قد يكون من المهم فهم وقت التشغيل لقياس كفاءة الأكواد وتحسين أداء تحليلات البيانات. فيما يلي خطوات بسيطة لقياس وقت التشغيل في Pandas:

1. استيراد مكتبة Pandas:

python
import pandas as pd

2. إنشاء الجدول أو قراءة البيانات من مصدر خارجي:

python
data = pd.read_csv('data.csv')

يتم استخدام هذا المثال لتحميل البيانات من ملف CSV، يمكنك استخدام الطريقة المناسبة لقراءة البيانات حسب نوع المصدر الخاص بك.

3. استخدام دالة المؤشر الزمني لقياس وقت التشغيل:

python
import time

start_time = time.time()

# أكواد العمليات والأوامر على البيانات

end_time = time.time()
execution_time = end_time - start_time

print("وقت التشغيل:", execution_time, "ثانية")

تبدأ هذه الخطوة بتحديد وقت البدء باستخدام start_time = time.time()، ثم تنفذ أكواد العمليات والأوامر على البيانات، وبعد الانتهاء يتم تحديد وقت الانتهاء باستخدام end_time = time.time() ويتم حساب وقت التشغيل بطرح end_time من start_time.

4. طباعة وقت التشغيل:

python
print("وقت التشغيل:", execution_time, "ثانية")

تقوم هذه الخطوة بطباعة وقت التشغيل الذي تم حسابه.

هذه هي الخطوات الأساسية لقياس وقت التشغيل في Pandas باستخدام وقت التشغيل الزمني. يمكنك تضمين هذه الخطوات في برنامجك الخاص وتنفيذها لقياس وقت تنفيذ العمليات والأوامر على البيانات في Pandas.

التعامل مع القيم المفقودة هو جزء مهم من تنظيف البيانات وتحضيرها للتحليل. في Python، يمكننا استخدام مكتبة pandas للتعامل مع القيم المفقودة بطرق مختلفة.

أولاً، يمكننا استخدام الالة isnull() للتحقق من وجود القيم المفقودة في البيانات. هذه الدالة تعيد DataFrame مع القيم البولينية حيث القيم الصحيحة تمثل القيم المفقودة.

ثانياً، يمكننا استخدام الدالة dropna() لإزالة الصفوف أو الأعمدة التي تحتوي على المفقودة.

ثالثاً، يمكننا استخدام الدالة fillna() لملء القيم المفقودة بقيمة معينة أو باستخدام طريقة معينة مثل القيمة السابقة أو القيمة التالية في البيانات.

مثال:

python
import pandas as pd
import numpy as np

# إنشاء DataFrame ببعض القيم المفقودة
df = pd.DataFrame({'A': [1, 2, np.nan], 'B': [5, np.nan, np.nanC': [1, 2, 3]})

print(df)

# التحقق من القيم المفقودة
print(df.isnull())

# إزالة الصفوف التي تحتوي على القيم المفقودة
print(df.dropna())

# ملء القيم المفقودة بقيمة معينة
print(df.fillna(value=0))

# ملء القيم المفقودة بالقيمة السابقة
print(df.fillna(method='ffill'))

# ملء القيم المفقودة بالقيمة التالية
print(df.fillna(method='bfill'))


في هذا المثال، نقوم أولاً بإنشاء DataFrame يحتوي على بعض القيم المفقودة. ثم نستخدم الدالة isnull() للتحقق من القيم المفقودة. بعد ذلك نستخدم الدالة dropna() لإزالة الصفوف التي تحتوي على المفقودة. ثم نستخدم الدالة fillna() لملء القيم المفقودة بقيمة معينة أو باستخدام القيمة السابقة أو ال التالية في البيانات.

SQLite و PostgreSQL هما نظامي لإدارة قواعد البيانات الشهيرين. SQLite هو نظام إدارة قواعد بيانات مضمن خفيف الوزن ويتم استخدامه في العديد من التطبيقات المحمولة والتطبيقات المكتبية. PostgreSQL هو نظام إدارة قواعد بيانات مفتوح المصدر قوي يتم استخدامه في العديد من التطبيقات الكبيرة والمعقدة.

لنبدأ بـ SQLite:

SQLite هو نظام إدارة قواعد بيانات مضمن، مما يعني أنه لا يتطلب خادمًا منفصلاً للعمل. يمكنك إنشاء قاعدة بيانات SQLite بسهولة باستخدام الأمر التالي في Python:

python
import sqlite3
conn = sqlite3.connect('example.db')

هذا الأمر سينشئ قاعدة بيانات جديدة تسمى "example.db". يمكنك الآننشاء جدول جديد في قاعدة البيانات باستخدام الأمر التالي:

python
c = conn.cursor()
c.execute('''CREATE TABLE stocks
             (date text, trans text, symbol text, qty real, price real)''')

هذا الأمر ينشئ جدول جديد يسمى "stocks" مع الأعمدة المحددة.

بالنسبة لـ PostgreSQL:

PostgreSQL هو نظام إدارة قواعد بيانات قوي يتطلب خادمًا منفصلاً للعمل. يمكنك الاتصال بقاعدة بيانات PostgreSQL باستخدام الأمر التالي في Python:

python
import psycopg2
conn = psycopg2.connect(database="mydb", user="myuser", password="mypassword", host="localhost", port="5432")

هذا الأمر يتطلب اسم قاعدة البيانات واسم المستخدم وكلمة المرور وعنوان الخادم ورقم المنفذ. بمجرد الاتصال، يمكنك إنشاء جدول جديد باستخدام الأمر التالي:

python
cur = conn.cursor()
cur.execute('''CREATE TABLE stocks
               (date text, trans text, symbol text, qty real, price real)''')

هذا الأمر ينشئ جدول جديدسمى "stocks" مع الأعمدة المحددة.

تذكر أنه بعد تنفيذ أي تغيير في قاعدة البيانات، يجب عليك دائمًا القيام بالأمر "commit" لحفظ التغييرات:

python
conn.commit()

وأخيرًا، لا تنسى أن تغلق الاتصال بعد الانتهاء من استخدام قاعدة البيانات:

python
conn.close()

أحدث التحديثات والميزات في لغة البرمجة بايثون:

1. إصدار بايثون 3.10: تم إصداره في أكتوبر 2021 ويأتي مع العديد من التحسينات والميزات الجديدة، بما في ذلك:
- Pattern Matching: يوفر نمطًا جديدًا للتطابق يسمح بتحديد تناظر أشكال محددة في البيانات.
- Parametric Type Hints: يتيح توجيهات النوع البارامترية للدوال الجزئية.
- العديد من التحسينات في الأداء والأمان والتوافقية.

2. تحسينات في مكتبات العلم والبيانات: توجد العديد من المكتبات البارزة في مجال العلم والبيانات التي تواصل تحسين وظائفها وأداءها. على سبيل المثال:
- NumPy: تطورت NumPy لدعم العمل مع الصفائف المتجهة والعمليات الرياضية بشكل أفضل.
- pandas: تمت إضافة وظائف جديدة وتحسين أداء مكتبة pandas لتحليل البيانات.
- scikit-learn: توسيع مكتبة scikit-learn لدعم تقنيات التعلم العميق والتعلم العميق المتقدم.

3. تطوير الويب والمايكروسيرفيس: إطارات التطوير الشهيرة مثل Django و Flask ما زالت تتلقى تحسينات وميزات جديدة لتبسيط وتسريع عملية تطوير تطبيقات الويب والمايكروسيرفيس.

4. تحسينات في مجال الذكاء الاصطناعي وتعلم الآلة: بايثون لا تزال لغة قوية في مجالات الذكاء الاصطناعي وتعلم الآلة، وتتلقى العديد من التحسينات والتطورات في هذا المجال. مكتبات مثل TensorFlow و PyTorch تواصل التطور لدعم أحدث التقنيات والنماذج.

5. توسيع استخدام بايثون في مجالات جديدة: يتم استخدام بايثون في مجالات متنوعة مثل تطوير تطبيقات الهاتف المحمول، وتطوير ألعاب الفيديو، وتطبيقات الروبوت، وتطبيقات البلوكتشين، والتحليلات البيانية، والتشفير، وغيرها.

تتناول المقابلة العديد من المواضيع المثيرة للاهتمام حول تطور بايثون وأسباب إنشاء اللغة ورؤية Guido لمستقبلها.

يتناول المحتوى بعض النقاط الرئيسية مثل:

1. تاريخ وخلفية لغة بايثون وما أدى إلى إنشائها.
2. تفاصيل حول بعض التصميمات والمفاهيم الرئيسية في بايثون مثل التحويل الديناميكي والجمل المشروطة والمفاهيم الأساسية الأخرى.
3. أهداف وفلسفة تصميم بايثون وأهمية القراءة السهلة والكتابة البسيطة والكود القابل للفهم.
4. المزايا والتحديات في تطوير لغة برمجة مفتوحة المصدر وكيف تم تطوير وتوسيع مجتمع بايثون.
5. الدور الحالي والمستقبلي لبايثون في مجالات مثل تطوير الويب والذكاء الاصطناعي والعلوم والبيانات.

إنها مقابلة شيقة وتعطي نظرة جيدة على تاريخ وفلسفة بايثون. أتمنى أن يكون المقطع قد قدم لك معلومات قيمة حول لغة بايثون ورؤية مبتكرها.

ماهو الدرس الذي تريدونه غدا ؟

البرمجة غير المتزامنة (Asynchronous programming) هي نمط من أنماط البرمجة يتيح للتطبيقات التعامل مع العديد من الأشياء في نفس الوقت. في البرمجة المتزامنة، يمكن للتطبيقات تنفيذ العديد من الأشياء في نفس الوقت، وهو ما يجعلها مثالية للأنشطة مثل الويب أو القراءة من قاعدة البيانات أو الكتابة فيها، أو أي نشاط آخر يتطلب الانتظار لاستكمال العمليات.

في Python، يمكننا استخدام الوحدة النمطية asyncio لكتابة البرامج غير المتزامنة. تمت إضافة asyncio في Python 3.4 كجزء من مكتبة القياسية، وتم تحسينها في الإصدارات اللاحقة.

ألق نظرة على الكود التالي:

python
import asyncio

async def main():
    print('Hello ...')
    await asyncio.sleep(1)
    print('... World!')

# Python 3.7+
asyncio.run(main())

في الكود أعلاه، نحن نستخدم الكلمة الرئيسية async لتعريف الدالة كدالة غير متزامنة. ثم نستخدم الكلمة الرئيسية await لتعليق تنفيذ الدالة حتى يتم استكمال العملية الأخرى (في هذه الحالة، asyncio.sleep(1)).

الآن، دعنا ننظر إلى مثال أكثر تعقيدا:

python
import asyncio
import time

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)

async def main():
    print(f"started at {time.strftime('%X')}")

    await say_after(1, 'hello')
    await say_after(2, 'world')

    print(f"finished at {time.strftime('%X')}")

# Python 3.7+
asyncio.run(main())

في هذا الكود، لدينا دالة say_after تأخذ وقت الانتظار والرسالة كمعلمات، وتطبع الرسالة بعد الانتظار للوقت المحدد. في الدالة main، نحن ننتظر الانتهاء من say_after قبل الانتقال إلى الخطوة التالية. هذا يعني أن الرسائل ستتم طباعتها بالترتيب، وليس في نفس الوقت، حتى مع استخدام البرمجة غير المتزامنة.

لكن، إذا كنا نريد تنفيذ العديد من الأشياء في نفس الوقت، يمكننا استخدام asyncio.gather. هذا ينفذ الوظائف غير المتزامنة في نفس الوقت، ولا ينتظر الانتهاء من واحدة قبل البدء في الأخرى.

python
import asyncio
import time

async def say_after(delay, what):
    await asyncio.sleep(delay)
    print(what)

async def main():
    task1 = asyncio.create_task(
        say_after(1, 'hello'))

    task2 = asyncio.create_task(
        say_after(2, 'world'))

    print(f"started at {time.strftime('%X')}")

    # Wait until both tasks are completed (should take
    # around 2 seconds.)
    await task1
    await task2

    print(f"finished at {time.strftime('%X')}")

# Python 3.7+
asyncio.run(main())

في هذا الكود، نحن نستخدم asyncio.create_task لإنشاء مهمتين غير متزامنتين، ثم ننتظر الانتهاء من كلتا المهمتين باستخدام await. هذا يعني أن الرسائل ستتم طباعتها في نفس الوقت، وليس بالترتيب.

Good morning programmers

الـ Multithreading والـ Multitasking هما نمطان من أنماط البرمجة تستخدمان لتنفيذ العديد من الأشياء في نفس الوقت.

Multـالithreading يعني تشغيل العديد من الخيوط (threads) في نفس الوقت.ل ك خيط يعمل على مهمة معينة، ويمكن للخيوط أن تتشارك في الذاكرة والموارد الأخرى.

الـ Multitasking يعني تشغيل العديد من المهام (tasks) في نفس الوقت. المهذ ههام يمكن أن تكون عمليات (processes) أو خيوط (threads)، ولكن في كلتا الحالتين، يتم تنفيذها في نفس الوقت.

فالر بقين الـ Multithreading والـ Multitasking يكمن في كيفية تنفيذ الأشياء في نفس الوقت. في الـ Multithreading، يتم تنفيذ الخيوط في نفس العملية، ويمكن تاهقاسم الذاكرة والموارد الأخرى. في الـ Multitasking، يمكن أن تكون المهام عمليات مستقلة، وليس لديها وصول مباشر إلى الذاكرة أو الموارد الأخرى للمهام الأخرى.

الـ asyncio في Python هو نمط آخر من البرمجة يتيح تنفيذ العديد من الأشياء في نفس الوقت. ومع ذلك، بدلاً من استخدام العديد من الخيوط أو العمليات، يستخدم asyncio ما يسمى بالـ coroutines، والتي تتيح لك تعليق واستئناف الوظائف في أي وقت، مما يتيح تنفيذ العديد من الأشياء في نفس الوقت دو النحاجة إلى الخيوط أو العمليات.

إليك مثالاً على كيفية استخدام الـ Multithreading في Python:

python
import threading

def print_numbers():
    for i in range(10):
        print(i)

def print_letters():
    for letter in 'abcdefghij':
        print(letter)

t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_letters)

t1.start()
t2.start()

في هذا المثال، لدينا خيطين: واحد لطباعة الأرقام من 0 إلى 9، والآخر لطباعة الحروف من 'a' إلى 'j'. نستخدم الدالة start لبدء كل خيط، والتي تبدأ بتنفيذ الوظيفة المستهدفة في خيط جديد.

وهنا كيف يمكننا القيام بنفس الشيء باستخدام asyncio:

python
import asyncio

async def print_numbers():
    for i in range(10):
        print(i)
        await asyncio.sleep(1)

async def print_letters():
    for letter in 'abcdefghij':
        print(letter)
        await asyncio.sleep(1)

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.gather(print_numbers(), print_letters()))
loop.close()

في هذا المثال، لدينا نفس الوظائف كما في المثال السابق، ولكننا نستخدم الكلمة الرئيسية async لتعريفها كـ coroutines، ونستخدم الكلمة الرئيسية await لتعليق تنفيذ الـ coroutine حتى يتم استكمال العملية الأخرى (في هذه الحالة، asyncio.sleep(1)). نستخدم asyncio.gather لتنفيذ الـ coroutines في نفس الوقت، ونستخدم loop.run_until_complete لتشغيل الـ event loop حتى يتم استكمال كل الـ coroutines.

Multithreading and multitasking are two programming patterns used to execute multiple tasks concurrently.

Multithreading refers to running multiple threads simultaneously. Each thread works on a specific task, and threads can share memory and other resources.

Multitasking, on the other hand, refers to running multiple tasks concurrently. The tasks can be processes or threads, but in both cases, they are executed simultaneously.

The difference between multithreading and multitasking lies in how things are executed concurrently. In multithreading, threads are executed within the same process and can share memory and other resources. In multitasking, tasks can be independent processes that don't have direct access to each other's memory or resources.

Asyncio in Python is another programming pattern that enables concurrent execution of multiple tasks. However, instead of using multiple threads or processes, asyncio utilizes what are called coroutines, which allow you to suspend and resume functions at any point, enabling the execution of multiple tasks concurrently without the need for threads or processes.

Here's an example of using multithreading in Python:

python
import threading

def print_numbers():
    for i in range(10):
        print(i)

def print_letters():
    for letter in 'abcdefghij':
        print(letter)

t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_letters)

t1.start()
t2.start()

In this example, we have two threads: one for printing numbers from 0 to 9 and another for printing letters from 'a' to 'j'. We use the start function to start each thread, which begins executing the targeted function in a new thread.

And here's how we can achieve the same using asyncio:

python
import asyncio

async def print_numbers():
    for i in range(10):
        print(i)
        await asyncio.sleep(1)

async def print_letters():
    for letter in 'abcdefghij':
        print(letter)
        await asyncio.sleep(1)

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.gather(print_numbers(), print_letters()))
loop.close()

In this example, we have the same functions as before, but we define them as coroutines using the async keyword. We use the await keyword to suspend the execution of the coroutine until the other operation (in this case, asyncio.sleep(1)) is completed. We use asyncio.gather to execute the coroutines concurrently, and we use loop.run_until_complete to run the event loop until all coroutines are completed.