search

Sarah111-AHM / Semsmah

2 stars 0 forks source link

Pandas #17

Open Sarah111-AHM opened 1 year ago

Sarah111-AHM commented 1 year ago

In : obj = pd.Series([4, 7, -5, 3]) In : obj Out: 04 17 dtype: int64

الكود الذي تم عرضه يستخدم مكتبة Pandas في Python لإنشاء "سلسلة" (Series)، وهي هيكل بيانات يتيح لنا تخزين وتنظيم بيانات من نوع واحد في صورة قائمة مفردات مفهرسة.

في السطر الأول، تم إنشاء السلسلة باستخدام pd.Series()، وتم تمرير قائمة مفردات تحتوي على الأرقام 4 و 7 و -5 و 3 كوسيط pd.Series().

في السطر الثاني، تم عرض السلسلة المنشأة باستخدام print()، والتي تمثل السلسلة الناتجة التي تحتوي على الأرقام 4 و 7 و -5 و 3 كقيم، وعلى كل قيمة تم تعيين فهرس محدد يبدأ من الصفر ويزيد بمعدل واحد لكل قيمة متتالية. وأخيراً، يوضح dtype: int64 نوع البيانات المخزنة في السلسلة وهي الأرقام صحيحة بحجم 64 بت.

الصيغة التي تم استخدامها لإنشاء السلسلة هي:

pd.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)

حيث:

هناك عدة أمثلة على استخدام صيغة pd.Series() لإنشاء سلاسل، وفيما يلي بعض الأمثلة:

Ex1: إنشاء سلسلة من قائمة مفردات

import pandas as pd

my_list = [10, 20, 30, 40, 50]
my_series = pd.Series(data=my_list)

print(my_series)

Ex2: إنشاء سلسلة من قاموس

import pandas as pd

my_dict = {'A': 10, 'B': 20, 'C': 30, 'D': 40, 'E': 50}
my_series = pd.Series(data=my_dict)

print(my_series)

Ex3: إنشاء سلسلة مع تحديد الفهرس

import pandas as pd

my_list = [10, 20, 30, 40, 50]
my_index = ['a', 'b', 'c', 'd', 'e']
my_series = pd.Series(data=my_list, index=my_index)

print(my_series)

Ex4: إنشاء سلسلة مع تحديد نوع البيانات

import pandas as pd

my_list = [10, 20, 30, 40, 50]
my_series = pd.Series(data=my_list, dtype=float)

print(my_series)

Ex5: إنشاء سلسلة مع تحديد الاسم

import pandas as pd

my_list = [10, 20, 30, 40, 50]
my_series = pd.Series(data=my_list, name='My Series')

print(my_series)

انشاء سلسلة مع تحديد ال copy

يمكن استخدام الخيار copy في صيغة pd.Series() لتحديد ما إذا كان يتم نسخ البيانات أثناء إنشاء السلسلة أم لا. وفيما يلي مثال على إنشاء سلسلة مع تحديد قيمة copy:

import pandas as pd

my_list = [10, 20, 30, 40, 50]
my_series = pd.Series(data=my_list, copy=True)

print(my_series)

في هذا المثال، تم تحديد copy=True لاستخدام النسخة المستقلة من البيانات في إنشاء السلسلة. ويمكن تحديد copy=False لاستخدام الإشارة إلى البيانات الأصلية في إنشاء السلسلة. ويتم استخدام قيمة الافتراضية copy=False إذا لم يتم تحديد أي قيمة لخيار copy.

انشاء سلسلة مع تحديد ال fastpath

يمكن استخدام الخيار fastpath في صيغة pd.Series() لتحديد ما إذا كان يتم تفعيل مسار سريع لإنشاء السلسلة أم لا. ومن المهم ملاحظة أن هذا الخيار يستخدم في حالات معينة فقط، ويمكن تركه ليتم تحديده تلقائيًا. وفيما يلي مثال على إنشاء سلسلة مع تحديد قيمة fastpath:

import pandas as pd

my_list = [10, 20, 30, 40, 50]
my_series = pd.Series(data=my_list, fastpath=True)
print(my_series)

في هذا المثال، تم تحديد fastpath=True لتفعيل مسار الإنشاء السريع للسلسلة. ويمكن تحديد fastpath=False لعدم تفعيل هذا المسار. ويتم استخدام قيمة الافتراضية fastpath=False إذا لم يتم تحديد أي قيمة لخيار fastpath.

obj.values Out[13]: array([ 4, 7, -5, 3]) In [14]: obj.index # like range(4) Out[14]: RangeIndex(start=0, stop=4, step=1) اشرح الكود السابق

الكود الذي تم عرضه يتعلق بالسلسلة التي تم إنشاؤها باستخدام مكتبة Pandas في Python، والتي تحتوي على قائمة من الأرقام.

عند استخدام obj.values، يتم استرداد مصفوفة NumPy تحتوي على القيم في السلسلة. في الحالة الحالية، ستحتوي المصفوفة على الأرقام 4 و 7 و -5 و 3.

عند استخدام obj.index، يتم استرداد الفهرس الذي تم استخدامه لإنشاء السلسلة. في الحالة الحالية، سيكون الفهرس من نوع RangeIndex ويتكون من الأرقام التسلسلية 0 و 1 و 2 و 3، حيث يبدأ من الرقم 0 وينتهي بالرقم 3، ويتزايد بمقدار 1. يشبه هذا الفهرس التعبير range(4) في Python.

الصيغة المستخدمة في المثال لإنشاء السلسلة هي pd.Series(data=[4, 7, -5, 3])، حيث تم تمرير قائمة المدخلات [4, 7, -5, 3] إلى الخاصية data في الدالة pd.Series() لإنشاء السلسلة. لم يتم تحديد الفهرس بشكل صريح، لذلك تم إنشاء فهرس افتراضي من نوع RangeIndex. ويتكون هذا الفهرس من الأرقام التسلسلية 0 و 1 و 2 و 3، حيث يبدأ من الرقم 0 وينتهي بالرقم 3، ويتزايد بمقدار 1.

الصيغة الكاملة للكود المذكور هي:

obj = pd.Series(data=[4, 7, -5, 3])
print(obj.values)
print(obj.index)

وتنتج النتائج التالية:

[ 4  7 -5  3]
RangeIndex(start=0, stop=4, step=1)

يتم استخدام pd.Series(data=[4, 7, -5, 3]) لإنشاء سلسلة باستخدام قائمة المدخلات [4, 7, -5, 3]. ويتم استخدام obj.values لاسترداد مصفوفة NumPy تحتوي على القيم في السلسلة و obj.index لاسترداد الفهرس الذي تم استخدامه لإنشاء السلسلة.

label: In [15]: obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c']) In [16]: obj2 Out[16]: d4 b7 a -5 c3 dtype: int64 In [17]: obj2.index Out[17]: Index(['d', 'b', 'a', 'c'], dtype='object') اشرح الكود السابق

الكود المذكور يتعلق بإنشاء سلسلة جديدة باستخدام مكتبة Pandas في Python، والتي تحتوي على قائمة من الأرقام وبعض التسميات (labels) لكل عنصر في القائمة.

تم استخدام pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c']) لإنشاء السلسلة الجديدة، فيه يتم تمرير قائمة المدخلات [4, 7, -5, 3] وتسميات الفهرس ['d', 'b', 'a', 'c'] إلى الدالة pd.Series().

تظهر النتيجة في Out[16]، حيث يتم عرض السلسلة التي تحتوي على الأرقام [4, 7, -5, 3]، وتظهر التسميات (labels) التي تم تعيينها سابقًا، وهي d و b و a و c.

يتم استخدام obj2.index لاسترداد الفهرس الذي تم استخدامه لإنشاء السلسلة، والذي يتضمن التسميات التي تم تعيينها سابقًا، وهي ['d', 'b', 'a', 'c']، كما يتم عرض نوع الفهرس dtype='object' في النتيجة التي تظهر في Out[17].

الصيغة المستخدمة في الكود المذكور هي:

obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
print(obj2)
print(obj2.index)

تم استخدام pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c']) لإنشاء سلسلة باستخدام قائمة المدخلات [4, 7, -5, 3] وتسميات الفهرس ['d', 'b', 'a', 'c']. ويتم استخدام print(obj2) لعرض السلسلة التي تحتوي على الأرقام [4, 7, -5, 3] وتسميات الفهرس التي تم تعيينها سابقًا، ويتم استخدام print(obj2.index) لاسترداد الفهرس الذي تم استخدامه لإنشاء السلسلة، والذي يتضمن التسميات التي تم تعيينها سابقًا، ويتم عرض نوع الفهرس dtype='object'.

الكود المذكور يتعلق بإنشاء سلسلة جديدة باستخدام مكتبة Pandas في Python، والتي تحتوي على قائمة من الأرقام وبعض التسميات (labels) لكل عنصر في القائمة.

تم استخدام pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c']) لإنشاء السلسلة الجديدة، حيث تم تمرير قائمة المدخلات [4, 7, -5, 3] وتسميات الفهرس ['d', 'b', 'a', 'c'] إلى الدالة pd.Series().

ظهرت النتيجة في Out[16]، حيث يتم عرض السلسلة التي تحتوي على الأرقام [4, 7, -5, 3]، وتظهر التسميات (labels) التي تم تعيينها سابقًا، وهي d و b و a و c، وتظهر أيضًا النوع dtype للأرقام في السلسلة والذي هو int64.

تم استخدام obj2.index لاسترداد الفهرس الذي تم استخدامه لإنشاء السلسلة، والذي يتضمن التسميات التي تم تعيينها سابقًا، وهي ['d', 'b', 'a', 'c']، ويتم عرض نوع الفهرس dtype='object' في النتيجة التي تظهر في Out[17].

الصيغة المستخدمة لإنشاء السلسلة هي:

obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])

تم استخدام الدالة pd.Series() لإنشاء سلسلة جديدة، وتم تمرير قائمة المدخلات [4, 7, -5, 3] وتسميات الفهرس ['d', 'b', 'a', 'c'] كمدخلات إلى الدالة. تم حفظ السلسلة الجديدة في المتغير obj2.

In [18]: obj2['a'] Out[18]: -5 In [19]: obj2['d'] = 6 In [20]: obj2[['c', 'a', 'd']] Out[20]: c3 a -5 d6 dtype: int64

تم استخدام الكود التالي لإنشاء وتعديل السلسلة:

obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c']) # إنشاء السلسلة
obj2['a'] # الوصول إلى قيمة العنصر الذي يحمل التسمية 'a'
obj2['d'] = 6 # تعديل قيمة العنصر الذي يحمل التسمية 'd'
obj2[['c', 'a', 'd']] # الوصول إلى عدة عناصر باستخدام التسميات

تم استخدام pd.Series() لإنشاء سلسلة جديدة مع تحديد التسميات لكل عنصر في القائمة. ثم تم استخدام obj2['a'] للوصول إلى قيمة العنصر الذي يحمل التسمية 'a'، وتم استخدام obj2['d'] = 6 لتعديل قيمة العنصر الذي يحمل التسمية 'd' وجعله يساوي 6. وأخيرًا، تم استخدام obj2[['c', 'a', 'd']] للوصول إلى العناصر التي تحمل التسميات 'c' و'a' و'd'، ويتم عرض قيم تلك العناصر في النتيجة المعروضة في Out[20].

In [21]: obj2[obj2 > 0] Out[21]: d6 b7 c3 dtype: int64 In [22]: obj2 * 2 Out[22]: d 12 b 14 a -10 c6 dtype: int64 In [23]: np.exp(obj2) Out[23]: d 403.428793 b 1096.633158 a 0.006738 c 20.085537 dtype: float64

تم استخدام الكود التالي لإجراء عمليات على السلسلة المنشأة في الأسئلة السابقة:

import pandas as pd
import numpy as np

# إنشاء السلسلة
obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])

# الوصول إلى العناصر التي تحمل قيم إيجابية
obj2[obj2 > 0]

# ضرب كل قيمة في السلسلة بالعدد 2
obj2 * 2

# حساب الأس العشري لكل قيمة في السلسلة
np.exp(obj2)

تم استيراد مكتبتي Pandas و NumPy في البداية، ثم تم استخدام pd.Series() لإنشاء السلسلة الجديدة مع تحديد التسميات لكل عنصر في القائمة. ثم تم استخدام obj2[obj2 > 0] للوصول إلى العناصر التي تحمل قيم إيجابية، وتم استخدام obj2 * 2 لضرب كل قيمة في السلسلة بالعدد 2، وأخيرًا تم استخدام np.exp(obj2) لحساب الأس العشري لكل قيمة في السلسلة، ويتم عرض النتائج في Out[21] و Out[22] و Out[23] على التوالي.

In [24]: 'b' in obj2 Out[24]: True

In [25]: 'e' in obj2 Out[25]: False

يمكن استخدام الدمج (Dictionary) لإنشاء سلسلة جديدة في Pandas باستخدام الكود التالي:

import pandas as pd

# إنشاء الدمج
data = {'a': 0., 'b': 1., 'c': 2.}

# إنشاء السلسلة
obj = pd.Series(data)

# التحقق من وجود عنصر بتسمية معينة في السلسلة
'b' in obj

يتم إنشاء الدمج data بتحديد قيم لكل تسمية، ثم يتم استخدام pd.Series() لإنشاء السلسلة الجديدة مباشرة من الدمج. ويتم استخدام 'b' in obj للتحقق من وجود عنصر في السلسلة بتسمية 'b'.

يمكنك استخدام الدمج (Dictionary) لإنشاء سلسلة جديدة في Pandas، حيث يمكن أن تمثل القيم في الدمج القيم في السلسلة، والتسميات في الدمج تمثل التسميات في السلسلة. يمكن إنشاء السلسلة باستخدام الكود التالي:

import pandas as pd

# إنشاء الدمج
data = {'a': 0., 'b': 1., 'c': 2.}

# إنشاء السلسلة
obj = pd.Series(data)

# الوصول إلى العنصر الذي يحمل التسمية 'b'
obj['b']

# التحقق من وجود عنصر بتسمية معينة في السلسلة
'e' in obj

يتم إنشاء الدمج data بتحديد قيم لكل تسمية، ويمكن تغيير هذه القيم حسب الحاجة. ثم يتم استخدام pd.Series() لإنشاء السلسلة الجديدة مباشرة من الدمج. يمكن الوصول إلى قيم العناصر في السلسلة باستخدام التسميات المحددة في الدمج، مثل obj['b'] للوصول إلى القيمة المحددة للتسمية 'b' في السلسلة. كما يمكن التحقق من وجود عنصر في السلسلة باستخدام in، مثل 'e' in obj للتحقق من وجود عنصر في السلسلة بتسمية 'e'.

In [26]: sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000} In [27]: obj3 = pd.Series(sdata) In [28]: obj3 Out[28]: Ohio 35000 Oregon 16000 Texas 71000 Utah 5000 dtype: int64

تم إنشاء سلسلة جديدة باستخدام الدمج sdata وتحديد قيم لكل تسمية، وذلك باستخدام الكود التالي:

import pandas as pd

# إنشاء الدمج
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}

# إنشاء السلسلة
obj3 = pd.Series(sdata)

# عرض السلسلة
print(obj3)

يتم إنشاء الدمج sdata بتحديد قيم لكل تسمية، ثم يتم استخدام pd.Series() لإنشاء السلسلة الجديدة مباشرة من الدمج. يتم عرض النتيجة في Out[28] وهي تحتوي على القيم والتسميات التي تم تحديدها، بالإضافة إلى النوع dtype الذي يحدد نوع البيانات في السلسلة.

الصيغة المستخدمة لإنشاء السلسلة المذكورة في السؤال السابق هي كالتالي:

import pandas as pd

# إنشاء الدمج
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}

# إنشاء السلسلة
obj3 = pd.Series(sdata)

# عرض السلسلة
print(obj3)

يتم إنشاء الدمج sdata بتحديد قيم لكل تسمية، وذلك باستخدام القوسين المتعامدين {} وفاصلة للفصل بين كل تسمية وقيمتها. ثم يتم استخدام pd.Series() لإنشاء السلسلة الجديدة مباشرة من الدمج، ويتم تخزينها في متغير obj3. وأخيراً يتم عرض قيم السلسلة باستخدام print()، وتظهر النتيجة في Out[28] في السؤال السابق.

In [29]: states = ['California', 'Ohio', 'Oregon', 'Texas']
In [30]: obj4 = pd.Series(sdata, index=states)

In [31]: obj4 Out[31]: California Ohio NaN 35000.0 16000.0 71000.0 Oregon Texas dtype: float64

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

import pandas as pd

# إنشاء الدمج
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}

# تحديد تسميات إضافية
states = ['California', 'Ohio', 'Oregon', 'Texas']

# إنشاء السلسلة
obj4 = pd.Series(sdata, index=states)

# عرض السلسلة
print(obj4)

يتم تحديد تسميات إضافية باستخدام مصفوفة states التي تحتوي على التسميات التي تود إضافتها إلى السلسلة الجديدة. ويتم استخدام pd.Series() لإنشاء السلسلة الجديدة مباشرة من الدمج sdata، مع تحديد التسميات الإضافية باستخدام الخيار index وتحديد مصفوفة الـ states. ومن هذا التحديد، يتم إضافة تسمية "California" مع قيمة NaN إلى السلسلة الجديدة لأنها لم تكن موجودة في الدمج الأصلي. ويتم عرض قيم السلسلة الجديدة باستخدام print()، وتظهر النتيجة في Out[31] في السؤال السابق.

data: In [32]: pd.isnull(obj4) Out[32]: California True Ohio Oregon Texas dtype: bool False False False In [33]: pd.notnull(obj4) Out[33]:

California    False
Ohio           True
Oregon         True
Texas          True
dtype: bool

Series also has these as instance methods: In [34]: obj4.isnull() Out[34]: California True Ohio Oregon Texas dtype: bool False False False

الكود الذي تم ذكره يستخدم بعض الدوال في الـPandas لتحليل السلسلة obj4، وإظهار القيم المفقودة فيها. يتم ذلك باستخدام الكود التالي:

import pandas as pd

# إنشاء السلسلة
obj4 = pd.Series(sdata, index=states)

# يتم اختبار قيم السلسلة عن طريق الدوال `isnull()` و `notnull()`
print(pd.isnull(obj4))
print(pd.notnull(obj4))
print(obj4.isnull())

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

بشكل عام، تستخدم دالة isnull() للتحقق من وجود القيم المفقودة في البيانات. فعند استخدام هذه الدالة، يتم إرجاع سلسلة جديدة تحتوي على True في المواضع التي تحتوي فيها السلسلة الأصلية على قيم مفقودة، و False في المواضع التي تحتوي فيها السلسلة الأصلية على قيم.

من جهة أخرى، تستخدم دالة notnull() للتحقق من وجود القيم الصحيحة في البيانات، أو للتحقق من عدم وجود القيم المفقودة في البيانات. وعند استخدام هذه الدالة، يتم إرجاع سلسلة جديدة تحتوي على True في المواضع التي تحتوي فيها السلسلة الأصلية على قيم صحيحة، و False في المواضع التي تحتوي فيها السلسلة الأصلية على قيم مفقودة.

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

الصيغة الأساسية المستخدمة في كتابة المثال السابق هي استخدام دالة isnull() و notnull() كأسلوب لفحص البيانات والتحقق من وجود القيم المفقودة أو القيم الصحيحة في السلسلة. وقد تم استخدام هذه الدوال على السلسلة obj4 بما يلي:

import pandas as pd

# إنشاء السلسلة
obj4 = pd.Series(sdata, index=states)

# استخدام دالة `isnull()` للتحقق من وجود القيم المفقودة في السلسلة
pd.isnull(obj4)

# استخدام دالة `notnull()` للتحقق من وجود القيم الصحيحة في السلسلة
pd.notnull(obj4)

# استخدام دالة `isnull()` للتحقق من وجود القيم المفقودة في السلسلة بشكل آخر
obj4.isnull()

In [35]: obj3 Out[35]: Ohio 35000 Oregon 16000 Texas 71000 Utah 5000 dtype: int64 In [36]: obj4 Out[36]: California Ohio NaN 35000.0 16000.0 71000.0 Oregon Texas dtype: float64 In [37]: obj3 + obj4 Out[37]: California Ohio Oregon Texas Utah dtype: float64 NaN 70000.0 32000.0 142000.0 NaN

Certainly! Here's an example of how isnull() and notnull() can be used in data analysis:

Suppose you have a dataset with information about employees in a company, including their age, salary, and job title. However, some of the data is missing (i.e. there are null values) for certain employees. You want to analyze the data to see if there are any patterns or relationships between the variables, but first you need to handle the missing data.

You can use isnull() to find out which rows have missing data, and then decide how to handle those rows. For example, you might choose to drop the rows with missing data, or fill in the missing values with the mean or median of the corresponding column.

Here's some sample code that demonstrates how isnull() and notnull() can be used in this scenario:

import pandas as pd

# Read in the data
data = pd.read_csv('employee_data.csv')

# Check for missing data
null_data = data[data.isnull().any(axis=1)]
print(null_data)

# Drop rows with missing data
clean_data = data.dropna()

# Fill in missing data with the mean salary
mean_salary = data['Salary'].mean()
data['Salary'].fillna(mean_salary, inplace=True)

# Analyze the data
# ... (code to analyze the data goes here)

In this example, data.isnull() returns a DataFrame with the same shape as data, where each element is either True if the corresponding value in data is NaN (i.e. missing), or False otherwise. We then use any(axis=1) to check if any of the elements in each row are True. This returns a boolean Series indicating which rows have missing data.

We then use dropna() to remove the rows with missing data, or fillna() to fill in the missing values with the mean salary. Finally, we can analyze the cleaned data with whatever statistical techniques are appropriate for the research question at hand.

By using isnull() and notnull() to handle missing data, we can ensure that our analysis is based on complete and accurate information, which can lead to more reliable and informative results.

الكود السابق يوضح كيفية استخدام العمليات الحسابية في الـ Pandas Series، وذلك باستخدام العملية الحسابية + بين سلسلتين مختلفتين obj3 و obj4، والتي تحتوي على بيانات مختلفة. يتم إجراء العملية الحسابية ضمن السطور 35-37 في الكود كما يلي:

# إنشاء سلسلة obj3
obj3 = pd.Series([35000, 16000, 71000, 5000], index=['Ohio', 'Oregon', 'Texas', 'Utah'])

# إنشاء سلسلة obj4
obj4 = pd.Series([np.nan, 35000, 16000, 71000, np.nan], index=['California', 'Ohio', 'Oregon', 'Texas', 'Nevada'])

# إجراء العملية الحسابية بين السلسلتين obj3 و obj4
obj3 + obj4

يتم إنشاء سلسلتين obj3 و obj4 في الأسطر 35-36، وتحتوي كل منهما على قيم مختلفة. تحتوي obj3 على قيم رقمية صحيحة، في حين أن obj4 تحتوي على بعض القيم المفقودة (NaN) بالإضافة إلى بعض القيم الصحيحة.

يتم إجراء العملية الحسابية بين السلسلتين باستخدام العملية الحسابية + في السطر 37، ويتم إنشاء سلسلة جديدة تحتوي على نتائج العملية الحسابية. يتم عرض هذه السلسلة في السطور 38-42، وتحتوي على قيم مختلفة تشمل بعض القيم المفقودة (NaN) وبعض القيم الصحيحة.

وبالتالي، يمكن استخدام العمليات الحسابية في الـ Pandas Series لإجراء العمليات الحسابية والرياضية بين سلسلتين مختلفتين، بينما يتم التعامل مع القيم المفقودة باستخدام قيم المفقودة (NaN).

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'], 'year': [2000, 2001, 2002, 2001, 2002, 2003], 'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]} frame = pd.DataFrame(data)

الكود الذي تم تقديمه يستخدم مكتبة pandas في بايثون لإنشاء DataFrame، وهو عبارة عن جدول يحتوي على بيانات مرتبطة ببعضها البعض.

تم إنشاء DataFrame جديد يسمى "frame" باستخدام البيانات الموجودة في القاموس "data". يحتوي هذا القاموس على مفاتيح "state" و "year" و "pop"، وقيمها هي قوائم تحتوي على بيانات الولاية والسنة والسكان على التوالي.

يتم تمرير القاموس "data" إلى دالة DataFrame() التي تنشئ DataFrame جديدًا باستخدام القيم الموجودة في القاموس.

الشكل الأصلي للبيانات المستخدمة لإنشاء DataFrame هو:

state = ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada']
year = [2000, 2001, 2002, 2001, 2002, 2003]
pop = [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]
data = {'state': state, 'year': year, 'pop': pop}

لإنشاء الكود السابق، تم استيراد مكتبة pandas في بايثون باستخدام الأمر التالي:

import pandas as pd

ثم تم إنشاء قاموس "data" الذي يحتوي على البيانات التي سيتم إدخالها إلى DataFrame. على سبيل المثال، يمكن إنشاء هذا القاموس باستخدام الأمر التالي:

data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}

ثم يتم إنشاء DataFrame باستخدام البيانات الموجودة في القاموس "data" باستخدام الأمر التالي:

frame = pd.DataFrame(data)

يتم تخزين DataFrame الجديد في متغير يسمى "frame" ويمكن استخدام هذا المتغير لإجراء عمليات مختلفة على البيانات.

rows: In [46]: frame.head() Out[46]: pop state year 0 1.5 Ohio 2000 1 1.7 Ohio 2001 2 3.6 Ohio 2002 3 2.4 Nevada 2001 4 2.9 Nevada 2002 If you specify a sequence of

إذا قمت بتحديد تسلسل (sequence) من أرقام الصفوف (rows)، يمكنك استخدام الأمر iloc في DataFrame لاسترداد هذه الصفوف. على سبيل المثال، إذا أردت استرداد الصفوف 1 و 3 و 5، يمكنك استخدام الأمر التالي:

selected_rows = frame.iloc[[1, 3, 5]]

ستتم استرداد الصفوف 1 و 3 و 5 فقط ويتم تخزينها في DataFrame جديد يسمى "selected_rows"، ويمكن استخدامه لإجراء العمليات اللازمة عليه.

To select specific columns from a DataFrame, you can use indexing with the column names or column labels. There are several ways to do this:

  1. Using square brackets: You can use square brackets [ ] with the column names to select one or more columns from the DataFrame. For example, the following code selects the "state" and "pop" columns from the "frame" DataFrame:

    specific_cols = frame[['state', 'pop']]

  2. Using dot notation: If the column names are valid Python variable names, you can use dot notation to select columns. For example, the following code selects the "state" column from the "frame" DataFrame using dot notation:

    state_col = frame.state

  3. Using the loc accessor: You can use the loc accessor with the row and column labels to select specific rows and columns from the DataFrame. For example, the following code selects the "state" and "pop" columns from the first three rows of the "frame" DataFrame:

    specific_cols = frame.loc[0:2, ['state', 'pop']]

Note that when selecting specific columns from a DataFrame, a new DataFrame is created that contains only the selected columns. This new DataFrame can then be used for further analysis or manipulation.

In [51]: frame2['state'] Out[51]: one Ohio two Ohio three Ohio four Nevada five Nevada six Nevada Name: state, dtype: object In [52]: frame2.year Out[52]: one 2000 two 2001 three 2002 four 2001 five 2002 six 2003 Name: year, dtype: int64

الكود السابق يقوم بإنشاء DataFrame باستخدام قاموس من القواميس كمدخلات. ويحتوي الـ DataFrame الناتج على عمودين، الأول يسمى "state" ويحتوي على سلسلة النصوص (dtype: object) التي تمثل الولاية التي ينتمي إليها كل من العناصر في القاموس. والعمود الثاني يسمى "year" ويحتوي على سلسلة الأرقام (dtype: int64) التي تمثل السنة التي ينتمي إليها كل من العناصر في القاموس.

وبالتحديد، فإن الصفوف (العناصر) في الـ DataFrame تمثلت بمفاتيح القاموس (one, two, three, four, five, six)، في حين تم تسمية الأعمدة باستخدام النصوص "state" و "year" على التوالي.

ويمكن الوصول إلى العمود "state" باستخدام الفهرسة المستخدمة في القواميس (frame2['state'])، في حين يمكن الوصول إلى العمود "year" باستخدام الفهرسة المستخدمة في الصفوف (frame2.year).

بالإضافة إلى العمليات المذكورة في الإجابة السابقة، يمكن القيام بعدد من العمليات الأخرى على DataFrame المنشأ باستخدام العديد من الوظائف المتاحة في مكتبة Pandas.

على سبيل المثال، يمكن إضافة عمود جديد إلى DataFrame باستخدام الفهرسة المستخدمة في القواميس، على النحو التالي:

frame2['population'] = [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]

والذي ينشئ عمودًا جديدًا يسمى "population" يحتوي على قائمة الأعداد التي تم تحديدها.

كما يمكن تغيير اسماء الصفوف أو الأعمدة باستخدام الوظائف المخصصة لذلك، مثل:

frame2 = frame2.rename(index={'one': 'First', 'two': 'Second'},
                       columns={'state': 'Location', 'year': 'Year'})

والذي يقوم بتغيير اسم الصف "one" إلى "First" واسم الصف "two" إلى "Second"، بالإضافة إلى تغيير اسم العمود "state" إلى "Location" واسم العمود "year" إلى "Year".

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

يمكن أيضًا القيام بعمليات الفرز والتصفية على DataFrame باستخدام الوظائف المتاحة في مكتبة Pandas. على سبيل المثال، يمكن ترتيب الصفوف في DataFrame حسب قيمة عمود محدد باستخدام الوظيفة sort_values()، مثل:

frame2 = frame2.sort_values(by='year')

والتي ترتب الصفوف في DataFrame حسب قيمة عمود "year".

كما يمكن التصفية (التصفية العمودية) في DataFrame باستخدام الوظيفة groupby()، مثل:

grouped = frame2.groupby('state')

والتي تقوم بتصفية DataFrame حسب قيمة عمود "state"، وتنشئ كائنًا يحتوي على مجموعات (groups) من DataFrame المرتبطة بقيم محددة في عمود "state".

بالإضافة إلى ذلك، يمكن القيام بعمليات التحويل على DataFrame باستخدام الوظائف المتاحة في مكتبة Pandas. على سبيل المثال، يمكن إضافة عمود جديد يحتوي على ناتج عملية بين عمودين موجودين في DataFrame باستخدام الوظيفة apply()، مثل:

frame2['income'] = frame2.apply(lambda row: row.year * 1000, axis=1)

والتي تنشئ عمودًا جديدًا يحتوي على ناتج ضرب قيمة العمود "year" في 1000 لكل صف في DataFrame.

وبالإضافة إلى ذلك، يمكن القيام بعمليات التحليل الإحصائي على DataFrame باستخدام الوظائف المتاحة في مكتبة Pandas، مثل الحسابات الإحصائية الأساسية (مثل المتوسط والانحراف المعياري والحدود العلوية والسفلية) والرسوم البيانية (مثل الرسوم الخطية والشريطية والدائرية والمربعة وغيرها).

وبالإضافة إلى ذلك، يمكن استخدام مكتبة Pandas للتعامل مع ملفات البيانات المختلفة، مثل CSV وExcel وSQL وغيرها، والتعامل مع البيانات المفقودة وتنظيف البيانات وتحويل البيانات وغيرها من العمليات الأخرى المتعلقة بإدارة البيانات.

In [53]: frame2.loc['three'] Out[53]: year 2002 state Ohio pop 3.6 debt NaN Name: three, dtype: object

الكود السابق يقوم باستخدام الوظيفة loc[] للوصول إلى صف محدد في DataFrame. وفي هذه الحالة، يتم الوصول إلى الصف الذي يحمل المفتاح (الفهرس) "three" باستخدام frame2.loc['three']. والنتيجة هي سلسلة تحتوي على قيم الصف الذي يحمل المفتاح "three"، والتي تتضمن قيمة العمود "year" والتي تساوي 2002، وقيمة العمود "state" والتي تساوي "Ohio"، وقيمة العمود "pop" والتي تساوي 3.6، وقيمة العمود "debt" والتي تساوي NaN (تمثل قيمة مفقودة أو غير معروفة). وتمثل العبارة "Name: three, dtype: object" اسم السلسلة ونوع البيانات في السلسلة، حيث يشير "object" إلى أن السلسلة تحتوي على قيم من نوع الكائنات.

Can you explain how to use loc[] to access a specific row?

Yes, sure! loc[] is a powerful function in Pandas that can be used to access a specific row or a subset of rows in a dataframe based on their labels. Here's how to use loc[] to access a specific row:

frame2.loc['three']

In the above code, frame2.loc['three'] returns the row with the label "three" in the dataframe frame2. The returned data is in the form of a Pandas Series object, which contains the values of all the columns for the row with the label "three".

If you want to access multiple rows, you can pass a list of labels to loc[], like this:

frame2.loc[['one', 'three', 'five']]

This code will return a dataframe containing the rows with the labels "one", "three", and "five".

You can also use loc[] to access a subset of rows based on a condition. For example, if you want to access all the rows where the value of the "state" column is "Ohio", you can do it like this:

frame2.loc[frame2['state'] == 'Ohio']

This code will return a dataframe containing all the rows where the value of the "state" column is "Ohio".

How can I access a specific column using loc[]?

You can use loc[] to access a specific column in a dataframe by specifying the column label inside the square brackets. Here's an example:

frame2.loc[:, 'state']

In the above code, : is used to specify that all rows should be included, and 'state' is the label of the column that you want to access. The output will be a Pandas Series object containing the values of the column with label 'state'.

If you want to access multiple columns, you can pass a list of column labels inside the square brackets, like this:

frame2.loc[:, ['state', 'year', 'pop']]

This code will return a dataframe containing only the columns with labels 'state', 'year', and 'pop'.

You can also use loc[] to access specific rows and columns at the same time. For example, to access the value in the "pop" column for the row with the label "three", you can do it like this:

frame2.loc['three', 'pop']

This code will return the value 3.6, which is the value of the "pop" column for the row with the label "three".

الشفرة الأولى:

frame2['debt'] = 16.5

تعيّن قيمة ثابتة مساوية لـ 16.5 لجميع الصفوف في عمود "debt". يتم ذلك عن طريق استخدام اسم العمود "debt" كمفتاح للوصول إلى العمود، ثم تعيين القيمة المراد تعيينها باستخدام الرقم 16.5.

الشفرة الثانية:

frame2['debt'] = np.arange(6.)

تعيّن قيم متزايدة بشكل خطي من 0 إلى 5 لجميع الصفوف في عمود "debt". يتم ذلك عن طريق استخدام اسم العمود "debt" كمفتاح للوصول إلى العمود، ثم تعيين القيم المراد تعيينها باستخدام np.arange(6.)، وهي وظيفة NumPy تنشئ مصفوفة من القيم المتزايدة بشكل خطي من 0 إلى 5.

الصيغة الأساسية لكتابة هذه الأكواد هي استخدام اسم العمود كمفتاح للوصول إلى العمود، ثم تعيين القيمة المراد تعيينها باستخدام العملية المناسبة. في الشفرة الأولى، تم استخدام الرقم 16.5 لتعيين قيم ثابتة، في حين استخدمت الشفرة الثانية وظيفة NumPy np.arange(6.) لتعيين قيم متزايدة بشكل خطي من 0 إلى 5.

In [58]: val = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five']) In [59]: frame2['debt'] = val In [60]: frame2 Out[60]: year state pop debt one 2000 Ohio 1.5 NaN two 2001 Ohio 1.7 -1.2 three 2002 Ohio 3.6 NaN four 2001 Nevada 2.4 -1.5 five 2002 Nevada 2.9 -1.7 six 2003 Nevada 3.2 NaN

الكود السابق يقوم بإنشاء سلسلة Pandas جديدة باستخدام البيانات [-1.2, -1.5, -1.7] والفهرس ['two', 'four', 'five']، ثم يستخدم هذه السلسلة لتعيين قيم المنتج المتطابقة في عمود "debt" في dataframe frame2. وتتم عملية التعيين باستخدام اسم العمود "debt" كمفتاح للوصول إلى العمود، ثم تعيين القيم باستخدام السلسلة المناسبة.

بناءً على الكود السابق، يتم تعيين القيم -1.2 و -1.5 و -1.7 في العمود "debt" للصفوف المحددة في الفهرس ['two', 'four', 'five']، ويتم تعيين NaN (ممثلة لـ Not a Number) في الصفوف الأخرى. هذا يعني أن القيم في عمود "debt" للصفوف التي لا تحمل أحد هذه الفهارس سوف تكون NaN.

وبالتالي، عند عرض dataframe frame2 بعد تعيين القيم، يتم عرض NaN في الصفوف التي لم يتم تعيين القيم، والعناصر المطابقة في الصفوف التي تحمل الفهرس ['two', 'four', 'five'] يتم تعيين القيم -1.2 و -1.5 و -1.7.

column equals 'Ohio': In [61]: frame2['eastern'] = frame2.state == 'Ohio' In [62]: frame2 Out[62]: year state pop debt eastern one 2000 Ohio 1.5 NaN True two 2001 Ohio 1.7 -1.2 True three 2002 Ohio 3.6 NaN True four 2001 Nevada 2.4 -1.5 False five 2002 Nevada 2.9 -1.7 False six 2003 Nevada 3.2 NaN False New columns cannot be created wi

الكود السابق يستخدم لإضافة عمود جديد إلى DataFrame باستخدام Pandas library في Python.

يفعل الكود الاتي:

وبما أن العمود الجديد تم إنشاؤه باستخدام العملية المنطقية == ، فإن القيمة في العمود الجديد تكون True إذا كان الصف يحتوي على "Ohio" في العمود state ، و False في غير ذلك.

In [63]: del frame2['eastern'] In [64]: frame2.columns Out[64]: Index(['year', 'state', 'pop', 'debt'], dtype='object')

الكود السابق يستخدم لحذف العمود الذي يسمى 'eastern' من DataFrame باستخدام Pandas library في Python.

يفعل الكود الاتي:

وكما يظهر في النتيجة، تم حذف العمود 'eastern' بنجاح من DataFrame ويحتوي الآن على الأعمدة year وstate وpop وdebt فقط.

dicts: In [65]: pop = {'Nevada': {2001: 2.4, 2002: 2.9}, ....: 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}} If the nested dict is passed to the DataFrame, pandas will interpr

الكود السابق يقوم بإنشاء قاموس متداخل (nested dictionary) باستخدام Python.

يفعل الكود الاتي:

وعند تمرير القاموس المتداخل 'pop' إلى DataFrame في Pandas، سيتم فهم هذا القاموس على أنه يحتوي على بيانات في شكل جدول، حيث يتم تفسير المفاتيح الرئيسية ('Nevada' و 'Ohio') على أنها تمثل أسماء الصفوف والمفاتيح الفرعية ('2001' و '2002' و '2000') تمثل أسماء الأعمدة. ومن ثم، يتم إنشاء DataFrame بعنوان الصفوف 'Nevada' و 'Ohio' وأسماء الأعمدة '2001' و '2002' و '2000'، وتملأ الخلايا بالقيم الموجودة في القاموس المتداخل.

In [66]: frame3 = pd.DataFrame(pop) In [67]: frame3 Out[67]: Nevada Ohio 2000 NaN 1.5

2001     2.4   1.7
2002     2.9   3.6

You can transpose the Da

الكود السابق يستخدم Pandas library في Python لإنشاء DataFrame جديد باستخدام القاموس المتداخل 'pop'.

يفعل الكود الاتي:

ومن النتيجة، يمكن ملاحظة أن هناك بعض الخلايا التي تحتوي على NaN، وذلك لأن بعض القيم في القاموس المتداخل لم يتم تحديدها. وبإمكاننا أيضًا تحويل DataFrame باستخدام الدالة T (transpose) لتبادل أسماء الصفوف والأعمدة.

Can you show me how to transpose the DataFrame?

بالطبع! يمكن تحويل DataFrame باستخدام الدالة T (transpose) في Pandas. يقوم هذا بتبديل بين أسماء الصفوف والأعمدة.

فيما يلي مثال على كيفية تحويل frame3 باستخدام الدالة T:

In [68]: frame3_T = frame3.T
In [69]: frame3_T
Out[69]:
        2000  2001  2002
    Nevada   NaN   2.4   2.9
    Ohio     1.5   1.7   3.6

يتم إنشاء DataFrame جديد بعنوان frame3_T باستخدام الدالة T على frame3. تم تبديل أسماء الصفوف ('Nevada' و 'Ohio') والأعمدة ('2000' و '2001' و '2002')، حيث أصبحت أسماء الصفوف هي أسماء الأعمدة السابقة والعكس صحيح. وتملأ الخلايا بالقيم الموجودة في frame3.

ومن النتيجة، يمكن ملاحظة أنه يمكن الوصول إلى قيم الخلايا باستخدام اسم الولاية وسنة المطابقة كما هو موضح في القاموس الأصلي 'pop'. على سبيل المثال، يمكن الوصول إلى عدد سكان ولاية Ohio في عام 2001 باستخدام frame3_T.loc['Ohio', 2001].

Can I transpose a DataFrame with missing values?

نعم ، يمكن تحويل DataFrame مع قيم مفقودة (missing values) باستخدام الدالة T في Pandas. تحويل DataFrame يعني تبديل بين أسماء الصفوف والأعمدة ولا يؤثر على وجود القيم المفقودة.

في الواقع ، يمكن استخدام الدالة T لإظهار البيانات بشكل أكثر وضوحًا عند العمل مع بيانات كبيرة. على سبيل المثال ، إذا كان لدينا DataFrame كبير جدًا يحتوي على العديد من الأعمدة والصفوف ، فقد يكون من الصعب قراءة البيانات أحيانًا. وباستخدام الدالة T ، يمكن تبسيط القراءة والتحليل.

على الرغم من ذلك ، يجب ملاحظة أن تحويل DataFrame لا يعالج القيم المفقودة تلقائيًا. ولذلك ، قد يتم تبديل بعض القيم المفقودة في DataFrame بعد تحويلها إلى DataFrame جديدة.

How can I handle missing values when transposing a DataFrame?

عند تحويل DataFrame باستخدام الدالة T في Pandas، يمكن استخدام الوظائف المتاحة للتعامل مع القيم المفقودة بعد التحويل.

على سبيل المثال، يمكن استخدام الدالة fillna() لتعويض القيم المفقودة بقيم محددة. يمكن استخدام هذه الدالة على DataFrame قبل أو بعد التحويل.

فيما يلي مثال على كيفية استخدام fillna() لتعويض القيم المفقودة على DataFrame قبل التحويل:

In [70]: frame3_filled = frame3.fillna(0)
In [71]: frame3_filled_T = frame3_filled.T
In [72]: frame3_filled_T
Out[72]:
        2000  2001  2002
    Nevada   0.0   2.4   2.9
    Ohio     1.5   1.7   3.6

في هذا المثال، تم استخدام fillna() لتعويض القيم المفقودة بصفر (0) على DataFrame الأصلي frame3. ثم تم تحويل الـDataFrame المعالج باستخدام الدالة T وتم تخزينه في frame3_filled_T.

ومن النتيجة، يمكن ملاحظة أن القيم المفقودة في frame3 تم استبدالها بصفر (0) وتم تحويل الـDataFrame بنجاح.

In [68]: frame3.T
Out[68]:
        2000  2001  2002
Nevada   NaN   2.4   2.9
Ohio     1.5   1.7   3.6

The keys in the inner dicts are

الكود السابق يقوم باستدعاء الدالة T في Pandas لتحويل DataFrame frame3، ومن ثم يتم عرض الـDataFrame المحول.

يفعل الكود الاتي:

ومن النتيجة، يمكن ملاحظة أن المفاتيح الداخلية للقاموس المتداخل ('2000' و '2001' و '2002') أصبحت أسماء الصفوف في DataFrame الناتج، بينما أصبحت المفاتيح الرئيسية ('Nevada' و 'Ohio') هي أسماء الأعمدة في DataFrame الناتج. كما يمكن ملاحظة وجود NaN في خلية Nevada في العام 2000 لأن القيمة في القاموس المتداخل لم تكن محددة.

In [69]: pd.DataFrame(pop, index=[2001, 2002, 2003]) Out[69]: Nevada Ohio 2001 2.4 1.7 2002 2.9 3.6 2003 NaN NaN

الكود المذكور ينشئ DataFrame جديد باستخدام قاموس 'pop' كمصدر للبيانات، ولكن يحدد فهرسًا جديدًا للصفوف باستخدام القائمة [2001، 2002، 2003].

يفعل الكود الاتي:

ومن النتيجة، يمكن ملاحظة أن DataFrame الجديد يحتوي على الأعمدة 'Nevada' و 'Ohio' والصفوف '2001' و '2002' و '2003'. علاوة على ذلك، يمكن ملاحظة وجود قيم NaN في الخلايا في الصف الأخير لأن القيم غير محددة في القاموس المتداخل لهذا العام.

way: In [70]: pdata = {'Ohio': frame3['Ohio'][:-1], ....: 'Nevada': frame3['Nevada'][:2]} In [71]: pd.DataFrame(pdata) Out[71]: Nevada Ohio 2000 NaN 1.5 2001 2.4 1.7 For a complete list of thin

الكود المذكور يقوم بإنشاء DataFrame جديد باستخدام بيانات محددة من DataFrame الأصلي frame3.

يفعل الكود الاتي:

ومن النتيجة، يمكن ملاحظة أن DataFrame الجديد يحتوي على الأعمدة 'Nevada' و 'Ohio' والصفوف '2000' و '2001'. كما يمكن ملاحظة وجود NaN في الخلية Nevada في العام 2000 لأن القيمة في القاموس المتداخل لم تكن محددة.

In [72]: frame3.index.name = 'year'; frame3.columns.name = 'state' In [73]: frame3 Out[73]: state Nevada Ohio year 2000 NaN 1.5 2001 2.4 1.7 2002 2.9 3.6 As with Series, the values a

الكود المذكور يعين اسماء لصفوف DataFrame frame3 باستخدام الخاصية index.name ولأعمدة باستخدام الخاصية columns.name.

يفعل الكود الاتي:

ومن النتيجة، يمكن ملاحظة أن DataFrame frame3 يحتوي على الأعمدة "Nevada" و "Ohio" والصفوف "2000" و "2001" و "2002"، وتم تسمية الأعمدة باسم "state" والصفوف بـ "year". هذا يجعل عملية التعامل مع DataFrame أكثر وضوحًا ويمكن استخدام الأسماء الجديدة في العمليات اللاحقة.

ndarray: In [74]: frame3.values Out[74]: array([[ nan, 1.5],

       [ 2.4,  1.7],
       [ 2.9,  3.6]])

If the DataFrame’s columns are different dtypes, the dtype of the values array will be chosen to accommodate all of the columns: In [75]: frame2.values Out[75]: array([[2000, 'Ohio', 1.5, nan], [2001, 'Ohio', 1.7, -1.2], [2002, 'Ohio', 3.6, nan], [2001, 'Nevada', 2.4, -1.5], [2002, 'Nevada', 2.9, -1.7], [2003, 'Nevada', 3.2, nan]], dtype=object)

الكود المذكور يستخدم الخاصية values للحصول على مصفوفة NumPy التي تمثل البيانات الموجودة في DataFrame.

يفعل الكود الاتي:

ومن النتيجة، يمكن ملاحظة أن المصفوفة الناتجة مماثلة لـDataFrame المستخدمة، ولكنها تمثل بيانات NumPy بدلاً من كائن DataFrame. يمكن أيضًا ملاحظة أن في حالة DataFrame متعددة الأنواع، فإن النوع الذي يتم اختياره يكون "object"، مما يعني أن النوع يمكن أن يكون أي شيء.

2D ndarray dict of arrays, lists, or tuples NumPy structured/record array dict of Series dict of dicts List of dicts or Series List of lists or tuples Another DataFrame NumPy MaskedArray Index Objects Notes A matrix of data, passing optional row and column labels Each sequence becomes a column in the DataFrame; all sequences must be the same length Treated as the “dict of arrays” case Each value becomes a column; indexes from each Series are unioned together to form the result’s row index if no explicit index is passed Each inner dict becomes a column; keys are unioned to form the row index as in the “dict of Series” case Each item becomes a row in the DataFrame; union of dict keys or Series indexes become the DataFrame’s column labels Treated as the “2D ndarray” case The DataFrame’s indexes are used unless different ones are passed Like the “2D ndarray” case except masked values become NA/missing in the DataFrame resu

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

الأنماط الشائعة لإنشاء DataFrame في Pandas هي:

يمكن استخدام الخيارات المذكورة أعلاه لإنشاء DataFrame في Pandas بناءً على نوع البيانات المتاحة والأسلوب الأكثر ملاءمة لتمثيل هذه البيانات. على سبيل المثال، يمكن استخدام القاموس (dict) لإنشاء DataFrame من البيانات المجمعة من مصادر مختلفة، أو استخدام مصفوفة NumPy ثنائية الأبعاد (2D ndarray) للبيانات المتقطعة، وما إلى ذلك.

  1. مصفوفة NumPy ثنائية الأبعاد (2D ndarray): يمكن إنشاء DataFrame باستخدام مصفوفة NumPy ثنائية الأبعاد مثل الآتي:
import pandas as pd
import numpy as np

data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
df = pd.DataFrame(data, columns=['col1', 'col2', 'col3'], index=['row1', 'row2', 'row3'])
print(df)
  1. قاموس (dict) يحتوي على مصفوفات، قوائم، أو tuples: يمكن إنشاء DataFrame باستخدام قاموس (dict) يحتوي على مصفوفات، قوائم، أو tuples مثل الآتي:
data = {'col1': [1, 2, 3], 'col2': (4, 5, 6), 'col3': np.array([7, 8, 9])}
df = pd.DataFrame(data)
print(df)
  1. مصفوفة NumPy مرتبة/مسجلة (structured/record array): يمكن إنشاء DataFrame باستخدام مصفوفة NumPy مرتبة/مسجلة مثل الآتي:
data = np.array([(1, 2.0, 'A'), (2, 3.5, 'B'), (3, 4.2, 'C')], dtype=[('col1', 'i4'), ('col2', 'f4'), ('col3', 'U1')])
df = pd.DataFrame(data)
print(df)
  1. قاموس (dict) يحتوي على Series: يمكن إنشاء DataFrame باستخدام قاموس (dict) يحتوي على Series مثل الآتي:
data = {'col1': pd.Series([1, 2, 3]), 'col2': pd.Series([4, 5, 6]), 'col3': pd.Series([7, 8, 9])}
df = pd.DataFrame(data)
print(df)
  1. قاموس (dict) يحتوي على قواميس (dicts): يمكن إنشاء DataFrame باستخدام قاموس (dict) يحتوي على قواميس (dicts) مثل الآتي:
data = {'col1': {'row1': 1, 'row2': 2, 'row3': 3}, 'col2': {'row1': 4, 'row2': 5, 'row3': 6}, 'col3': {'row1': 7, 'row2': 8, 'row3': 9}}
df = pd.DataFrame(data)
print(df)
  1. قائمة (List) يحتوي على قواميس (dicts) أو Series: يمكن إنشاء DataFrame باستخدام قائمة (List) يحتوي على قواميس (dicts) أو Series مثل الآتي:
data = [{'col1': 1, 'col2': 4, 'col3': 7}, {'col1': 2, 'col2': 5, 'col3': 8}, {'col1': 3, 'col2': 6, 'col3': 9}]
df = pd.DataFrame(data)
print(df)
  1. قائمة (List) يحتوي على قوائم (lists) أو tuples: يمكن إنشاء DataFrame باستخدام قائمة (List) يحتوي على قوائم (lists) أو tuples مثل الآتي:
data = [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
df = pd.DataFrame(data, columns=['col1', 'col2', 'col3'], index=['row1', 'row2', 'row3'])
print(df)
  1. DataFrame آخر: يمكن إنشاء DataFrame من DataFrame آخر مثل الآتي:
df1 = pd.DataFrame({'col1': [1, 2, 3], 'col2': [4, 5, 6], 'col3': [7, 8, 9]})
df2 = pd.DataFrame({'col4': [10, 11, 12], 'col5': [13, 14, 15], 'col6': [16, 17, 18]})
df = pd.concat([df1, df2], axis=1)
print(df)
  1. مصفوفة NumPy معتمدة (MaskedArray): يمكن إنشاء DataFrame باستخدام مصفوفة NumPy معتمدة (MaskedArray) مثل الآتي:
data = np.ma.array([[1, 2, 3], [4, np.ma.masked, 6], [7, 8, 9]], mask=[[False, False, False], [False, True, False], [False, False, False]])
df = pd.DataFrame(data, columns=['col1', 'col2', 'col3'], index=['row1', 'row2', 'row3'])
print(df)