המבנה DataFrame (לפעמים נקרא לו בקיצור df) יכול להכיל עמודות שכל אחת מסוג שונה. ניתן לחשוב על זה כמו על טבלת SQL.
ניתן ליצור DataFrame מ:
- numpy.ndarray חד-ממדי או דו-ממדי
- list
- dictionary
- Series
- DataFrame אחר
- Structured ndarray
- Record ndarray
כשיוצרים DataFrame ניתן להעביר יחד עם הערכים גם index שהוא התוויות של השורות, ו-columns שהם התוויות של העמודות. אם למשל יוצרים DataFrame מ-Series ומעבירים גם אינדקסים, אז רק מהאינדקסים שצוינו יווצר ה-DataFrame וכל שאר המידע לא יועבר ל-DataFrame.
אם לא מעבירים אינדקסים ו-columns הם יווצרו אוטומטית על פי המידע הנכנס.
הערה:
עבור python>=3.6 עם pandas>=0.23:
כאשר ה-data הוא dict ולא מספקים columns, ה-columns ב-DataFrame יהיו לפי הסדר שהופיע ב-dict
עבור python<3.6 או pandas<0.23:
ה-columns ימויינו בסדר לקסיקלי (לפי סדר האותיות והמספרים) לפי ה-keys שב-dict.
כדי לבדוק את גרסת ה-python נכתוב בשורת הפקודה:
python --version
כדי לבדוק את גרסת ה-pandas נכתוב:
pd.__version__
כדי לראות מידע על ה-DataFrame ניתן להשתמש בפונקציה:
df.info()
יצירת DataFrame מ-dict of Series
האינדקסים יהיו איחוד של האינדקסים של ה-Series שהיו ב-dict. ה-columns יהיו שמות המפתחות של ה-dicts.לדוגמה:
>>> d = {'one': pd.Series([1., 2., 3.], index=['a', 'b', 'c']), 'two': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])} >>> df = pd.DataFrame(d) >>> df one two a 1.0 1.0 b 2.0 2.0 c 3.0 3.0 d NaN 4.0 >>> df.index Index(['a', 'b', 'c', 'd'], dtype='object') >>> df.columns Index(['one', 'two'], dtype='object')
ניתן ליצור df מאינדקסים מסוימים מתוך ה-Sereis או מ-columns מסוימים:
>>> pd.DataFrame(d, index=['c', 'a', 'b']) one two c 3.0 3.0 a 1.0 1.0 b 2.0 2.0 >>> pd.DataFrame(d, columns=['one']) one a 1.0 b 2.0 c 3.0
אם בוחרים אינדקסים או columns שלא קיימים נקבל NaN באותם המקומות:
>>> pd.DataFrame(d, index=['c', 'a', 'b', 'f'], columns=['one', 'two','three']) one two three c 3.0 3.0 NaN a 1.0 1.0 NaN b 2.0 2.0 NaN f NaN NaN NaN
יצירת DataFrame מ-dict of ndarrays / lists
כשיוצרים df ממערכים או רשימות חובה שהמערכים/הרשימות יהיו באותו אורך אחרת נקבל שגיאה. בנוסף, אם מציינים במפורש את האינדקסים, חובה שמספר האינדקסים יהיה כאורך המערכים.רשימות, אחרת גם פה נקבל שגיאה.>>> d = {'one': [1., 2., 3., 4.], 'two': [10., 20., 30., 40.]} >>> pd.DataFrame(d) one two 0 1.0 10.0 1 2.0 20.0 2 3.0 30.0 3 4.0 40.0 >>> pd.DataFrame(d, index =['a','b','c','d']) one two a 1.0 10.0 b 2.0 20.0 c 3.0 30.0 d 4.0 40.0
ניתן גם להשתמש בפונקציה DataFrame.from_dict כדי ליצור DataFrame מ-dict of dicts או dict of arrray-like. מה שמיוחד בפונקתיה הזו הוא שאפשר לקבוע האם ה-keys של ה-dict יהיו שמות העמודות או שמות השורות, וכך כיוון ה-DataFrame משתנה. קובעים זאת ע"י הפרמטר orient. בדיפולט הוא columns ואם נקבע אותו ל-index אז ה-keys יהיו שמות השורות.
לדוגמה:
>>> pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])])) A B 0 1 4 1 2 5 2 3 6 >>> pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])]), orient='index') 0 1 2 A 1 2 3 B 4 5 6
יצירת DataFrame מ-structured or record data
דומה למקרה של יצירת df מ-dict של מערכים:>>> data = np.zeros((2, ), dtype=[('A', 'i4'), ('B', 'f4'), ('C', 'a10')]) >>> data[:] = [(1, 2., 'Hello'), (2, 3., "pandas")] >>> pd.DataFrame(data) A B C 0 1 2.0 b'Hello' 1 2 3.0 b'pandas' >>> pd.DataFrame(data, index=['aa','bb']) A B C aa 1 2.0 b'Hello' bb 2 3.0 b'pandas' >>> pd.DataFrame(data, columns=['C','B','A']) C B A 0 b'Hello' 2.0 1 1 b'pandas' 3.0 2
יצירת DataFrame מ-list of dicts
דומה ליצירה של df מ-list of Series:>>> data = [{'a': 1, 'b': 2}, {'a': 10, 'b': 20, 'c': 30}] >>> pd.DataFrame(data) a b c 0 1 2 NaN 1 10 20 30.0 >>> pd.DataFrame(data, index=['one','two']) a b c one 1 2 NaN two 10 20 30.0 >>> pd.DataFrame(data, columns=['a','c']) a c 0
יצירת DataFrame מ-Series
אם יוצרים df מ-Series נקבל df עם אותם ערכים ואותם אינדקסים ויהיה לו עמודה אחת בשם של ה-Series. אם אין ל-Series שם העמודות יקבלו שמות מ-0 והלאה.>>> s = pd.Series([12, 34, 56]) >>> pd.DataFrame(s) 0 0 12 1 34 2 56 >>> s.name = 'mySeries' >>> pd.DataFrame(s) mySeries 0 12 1 34
2 56
עבודה עם עמודות
העבודה עם עמודות היא די אינטואיטיבית. להלן כמה דוגמאות פשוטות:>>> df = pd.DataFrame({'one':[1, 2, 3]}, index = ['a', 'b', 'c']) >>> df one a 1 b 2 c 3 >>> df['two'] = df['one'] * 2 >>> df one two a 1 2 b 2 4 c 3 6 >>> df['three'] = df['one'] ** 2 >>> df one two three a 1 2 1 b 2 4 4 c 3 6 9 >>> df['flag'] = df['one'] > 2 >>> df one two three flag a 1 2 1 False b 2 4 4 False c 3 6 9 True
מחיקת עמודה
מחיקת עמודה מתבצעת ע"י del:>>> del df['flag'] >>> df one two three a 1 2 1 b 2 4 4 c 3 6 9
מחיקת עמודה ולקיחה של התוכן שלה למשתנה אחר מתבצעת ע"י pop:
>>> a = df.pop('two') >>> a a 2 b 4 c 6 Name: two, dtype: int64 >>> df one three a 1 1 b 2 4 c 3 9
יצירת עמודות
אם יוצרים עמודה עם ערך אחד הערך נכנס לכל תאי העמודה:
>>> df['four'] = 4 >>> df['txt'] = 'Israel' >>> df one three four txt a 1 1 4 Israel b 2 4 4 Israel c 3 9 4 Israel
ניתן להכניס מערך numpy.ndarray לתוך עמודה.
אם המערך לא יהיה באורך של העמודה תתקבל שגיאה.
לעומת זאת, אם נכניס Series שהוא לא באורך של העמודה, לא תתקבל שגיאה. אם ה-Series קצר הערכים החסרים יהיו NaN. אם הוא ארוך, רק הערכים עם אותו אינדקסים יכנסו.
>>> d = np.array([10,20,30]) >>> e = pd.Series([1,2,3,4], index = ['a','b','c','d']) >>> c = pd.Series([10,20], index = ['a','b']) >>> df['small'] = c >>> df['arr'] = d >>> df['long'] = e >>> df one three four txt small arr long a 1 1 4 Israel 10.0 10 1 b 2 4 4 Israel 20.0 20 2 c 3 9 4 Israel NaN 30 3
כשיוצרים עמודות הן מתווספות לסוף ה-DataFrame. ניתן להכניס עמודות במיקומים אחרים ע"י הפונקציה insert:
>>> df.insert(1,'two', df['one']*2) >>> df one two three four txt small arr long a 1 2 1 4 Israel 10.0 10 1 b 2 4 4 4 Israel 20.0 20 2 c 3 6 9 4 Israel NaN 30 3
עד כאן להפעם.
אם אהבתם, תכתבו משהו למטה...