دعنا نقدم مثالًا توضيحيًا يستخدم Pandas لتحليل بيانات الأفلام. سنستخدم بيانات IMDb التي تحتوي على معلومات حول الأفلام وتقييماتها.

أولاً، يجب علينا تحميل مكتبة Pandas واستيرادها في بيئة Python:

python
import pandas as pd

ثم، سنقوم بتحميل بيانات الأفلام وتحويلها إلى DataFrame باستخدام Pandas:

python
data = pd.read_csv('imdb_movies.csv')
df = pd.DataFrame(data)

الآن، لنقم ببعض التحليلات البسيطة. سنقوم بطباعة أول 5 صفوف في البيانات باستخدام الأمر head():

python
print(df.head())

ستظهر لك أول 5 صفوف من بيانات الأفلام.

لنفترض أننا نرغب في معرفة عدد الأفلام في كل فئة، يمكننا استخدام الأمر value_counts() وتطبيقه على عمود الفئة (genre):

python
genre_counts = df['genre'].value_counts()
print(genre_counts)

سيتم طباعة عدد الأفلام في كل فئة.

يمكننا أيضًا حساب متوسط تقييم الأفلام باستخدام الأمر mean() على عمود التقييم (avg_rating):

python
avg_rating = df['avg_rating'].mean()
print("Average rating:", avg_rating)

ستظهر لك المتوسط العام لتقييمات الأفلام.

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

عملية الدمج والانضمام تتيح لك دمج جداول مختلفة معًا بناءً على عمود أو مؤشر مشترك. يوفر 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.