יצירת Pandas DataFrame: צלילה מעמיקה לאתחול מבנה נתונים

ברוכים הבאים לעולם של מניפולציה של נתונים עם פייתון! בליבה של כמעט כל משימת ניתוח נתונים נמצאת ספריית Pandas, ואבן הפינה שלה היא ה-DataFrame. חשבו על DataFrame כגרסה חכמה, חזקה וגמישה של גיליון אלקטרוני או טבלת מסד נתונים, שחיה ממש בתוך סביבת הפייתון שלכם. זהו הכלי העיקרי לניקוי, טרנספורמציה, ניתוח והצגה חזותית של נתונים. אבל לפני שתוכלו לבצע את כל קסם הנתונים הזה, עליכם קודם כל לשלוט באומנות יצירת DataFrame. האופן שבו אתם מאתחלים את מבנה הנתונים הבסיסי הזה יכול להכין את הבמה לכל הניתוח שלכם.

מדריך מקיף זה מיועד לקהל עולמי של אנליסטים, מדענים ומהנדסים שאפתנים ומנוסים בתחום הנתונים. נחקור את השיטות הנפוצות והחזקות ביותר ליצירת Pandas DataFrames מאפס. בין אם הנתונים שלכם נמצאים במילון, ברשימה, במערך NumPy או בפורמט אחר, מאמר זה יספק לכם את הידע והדוגמאות המעשיות לאתחל את ה-DataFrames שלכם בביטחון וביעילות. בואו נבנה את היסודות שלנו.

מהו בדיוק Pandas DataFrame?

לפני שנתחיל לבנות, בואו נבהיר מה אנחנו בונים. Pandas DataFrame הוא מבנה נתונים טבלאי דו-ממדי, משתנה בגודלו והטרוגני מבחינה פוטנציאלית. בואו נפשט את זה:

• דו-ממדי: יש לו שורות ועמודות, בדיוק כמו גיליון אלקטרוני.
• משתנה בגודלו: ניתן להוסיף או להסיר שורות ועמודות לאחר יצירת ה-DataFrame.
• הטרוגני: לעמודות יכולים להיות סוגי נתונים שונים. לדוגמה, עמודה אחת יכולה להכיל מספרים (שלמים או עשרוניים), אחרת יכולה להכיל טקסט (מחרוזות), ושלישית יכולה להכיל תאריכים או ערכים בוליאניים (True/False).

ל-DataFrame יש שלושה מרכיבים עיקריים:

1. הנתונים: הערכים בפועל המוחזקים בתוך המבנה, מאורגנים בשורות ועמודות.
2. האינדקס: התוויות עבור השורות. אם לא תספקו אינדקס, Pandas יוצר אינדקס ברירת מחדל שמתחיל מ-0. האינדקס מספק דרך עוצמתית לגשת לנתונים וליישר אותם.
3. העמודות: התוויות עבור העמודות. אלה חיוניות לגישה לסדרות נתונים ספציפיות בתוך ה-DataFrame.

הבנת מבנה זה היא המפתח להבנת אופן היצירה והתפעול של DataFrames ביעילות.

היסוד: ייבוא Pandas

קודם כל. כדי להשתמש ב-Pandas, עליכם לייבא את הספרייה לסקריפט או למחברת הפייתון שלכם. המוסכמה המקובלת אוניברסלית, שאומצה על ידי אנשי מקצוע ברחבי העולם, היא לייבא אותה עם הכינוי pd. כינוי פשוט זה הופך את הקוד שלכם לקריא ותמציתי יותר.

import pandas as pd
import numpy as np # לעתים קרובות נעשה שימוש לצד Pandas, אז אנחנו נייבא אותו גם כן.

בשורה אחת זו, פתחתם את מלוא העוצמה של ספריית Pandas. עכשיו, בואו נעבור לליבה של מדריך זה: יצירת DataFrames.

שיטות יצירה עיקריות: מפשוט למורכב

הבנאי pd.DataFrame() הוא רב-תכליתי להפליא. הוא יכול לקבל סוגים שונים של קלט. כעת נחקור את השיטות החיוניות ביותר, ונעבור מהנפוצות ביותר למקרים מיוחדים יותר.

1. יצירת DataFrame ממילון של רשימות או מערכים

זו כנראה השיטה הנפוצה והאינטואיטיבית ביותר ליצירת DataFrame. אתם מתחילים עם מילון פייתון שבו המפתחות יהפכו לשמות העמודות, והערכים יהיו רשימות (או מערכי NumPy או סדרות Pandas) המכילות את הנתונים עבור כל עמודה.

איך זה עובד: Pandas ממפה כל מפתח מילון לכותרת עמודה וכל רשימת ערכים לשורות של אותה עמודה. דרישה קריטית כאן היא שכל הרשימות חייבות להיות באורך זהה, מכיוון שכל רשימה מייצגת עמודה שלמה של נתונים.

דוגמה:

בואו ניצור DataFrame המכיל מידע על ערים שונות ברחבי העולם.

# נתונים מאורגנים לפי עמודה city_data = { 'City': ['טוקיו', 'דלהי', 'שנגחאי', 'סאו פאולו', 'מומבאי'], 'Country': ['יפן', 'הודו', 'סין', 'ברזיל', 'הודו'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } # יצירת DataFrame df_from_dict = pd.DataFrame(city_data) print(df_from_dict)

פלט:

         City Country  Population_Millions  Is_Coastal
0       טוקיו   יפן                 37.3        True
1       דלהי   הודו                 32.0       False
2    שנגחאי   סין                 28.5        True
3   סאו פאולו  ברזיל                 22.4       False
4      מומבאי   הודו                 20.9        True

נקודת מפתח: שיטה זו מושלמת כאשר הנתונים שלכם מאורגנים באופן טבעי לפי תכונה או קטגוריה. היא נקייה, קריאה ומתרגמת ישירות את המבנה של המילון שלכם לפורמט טבלאי.

2. יצירת DataFrame מרשימה של מילונים

שיטה חלופית ועוצמתית באותה מידה היא להשתמש ברשימה שבה כל רכיב הוא מילון. במבנה זה, כל מילון מייצג שורה אחת, והמפתחות שלו מייצגים את שמות העמודות עבור הנתונים של אותה שורה.

איך זה עובד: Pandas חוזרת על הרשימה. עבור כל מילון, היא יוצרת שורה חדשה. מפתחות המילון משמשים לקביעת העמודות. שיטה זו גמישה להפליא מכיוון שאם מילון חסר מפתח, Pandas תמלא אוטומטית את התא הזה בשורה המתאימה עם NaN (Not a Number), שהוא הסמן הסטנדרטי לנתונים חסרים ב-Pandas.

דוגמה:

בואו נציג את אותם נתוני עיר, אך הפעם מובנים כרשימה של רשומות.

# נתונים מאורגנים לפי שורה (רשומה) records_data = [ {'City': 'טוקיו', 'Country': 'יפן', 'Population_Millions': 37.3, 'Is_Coastal': True}, {'City': 'דלהי', 'Country': 'הודו', 'Population_Millions': 32.0, 'Is_Coastal': False}, {'City': 'שנגחאי', 'Country': 'סין', 'Population_Millions': 28.5}, {'City': 'סאו פאולו', 'Country': 'ברזיל', 'Population_Millions': 22.4, 'Is_Coastal': False}, {'City': 'קהיר', 'Country': 'מצרים', 'Timezone': 'EET'} # שימו לב למבנה השונה ] # יצירת DataFrame df_from_list_of_dicts = pd.DataFrame(records_data) print(df_from_list_of_dicts)

פלט:

         City Country  Population_Millions  Is_Coastal Timezone
0       טוקיו   יפן                 37.3        True      NaN
1       דלהי   הודו                 32.0       False      NaN
2    שנגחאי   סין                 28.5         NaN      NaN
3   סאו פאולו  ברזיל                 22.4       False      NaN
4       קהיר   מצרים                  NaN         NaN      EET

שימו לב כיצד Pandas טיפלה באי-עקביות בחן. הערך 'Is_Coastal' עבור שנגחאי הוא NaN מכיוון שהוא היה חסר מהמילון שלה. עמודה חדשה 'Timezone' נוצרה עבור קהיר, עם NaN עבור כל הערים האחרות. זה הופך אותה לבחירה מצוינת לעבודה עם נתונים חצי-מובנים, כגון תגובות JSON מממשקי API.

נקודת מפתח: השתמשו בשיטה זו כאשר הנתונים שלכם מגיעים כסדרה של רשומות או תצפיות. היא חזקה בטיפול בנתונים חסרים ובשינויים במבנה הרשומה.

3. יצירת DataFrame ממערך NumPy

עבור אלה שעובדים במחשוב מדעי, למידת מכונה או כל תחום הכולל פעולות מספריות כבדות, נתונים מקורם לעתים קרובות במערכי NumPy. Pandas בנויה על גבי NumPy, מה שהופך את האינטגרציה בין השניים לחלקה ויעילה ביותר.

איך זה עובד: אתם מעבירים מערך NumPy דו-ממדי לבנאי pd.DataFrame(). כברירת מחדל, Pandas תיצור אינדקסים ועמודות מבוססי מספרים שלמים. עם זאת, אתם יכולים (וכדאי) לספק תוויות משמעותיות באמצעות הפרמטרים index ו-columns.

דוגמה:

בואו ניצור DataFrame ממערך NumPy בגודל 5x4 שנוצר באופן אקראי, המייצג קריאות חיישנים לאורך זמן.

# יצירת מערך NumPy בגודל 5x4 עם נתונים אקראיים data_np = np.random.rand(5, 4) # הגדרת תוויות עמודות ואינדקס columns = ['Sensor_A', 'Sensor_B', 'Sensor_C', 'Sensor_D'] index = pd.to_datetime(['2023-10-27 10:00', '2023-10-27 10:01', '2023-10-27 10:02', '2023-10-27 10:03', '2023-10-27 10:04']) # יצירת DataFrame df_from_numpy = pd.DataFrame(data=data_np, index=index, columns=columns) print(df_from_numpy)

פלט (המספרים האקראיים שלכם יהיו שונים):

                           Sensor_A  Sensor_B  Sensor_C  Sensor_D
2023-10-27 10:00:00  0.123456  0.987654  0.555555  0.111111
2023-10-27 10:01:00  0.234567  0.876543  0.666666  0.222222
2023-10-27 10:02:00  0.345678  0.765432  0.777777  0.333333
2023-10-27 10:03:00  0.456789  0.654321  0.888888  0.444444
2023-10-27 10:04:00  0.567890  0.543210  0.999999  0.555555

בדוגמה זו, הצגנו גם תכונה עוצמתית: שימוש ב-DatetimeIndex עבור נתוני סדרות זמן, שפותח מערך עצום של יכולות ניתוח מבוססות זמן ב-Pandas.

נקודת מפתח: זוהי השיטה היעילה ביותר מבחינת זיכרון ליצירת DataFrame מנתונים מספריים הומוגניים. זוהי הבחירה הסטנדרטית בעת ממשק עם ספריות כמו NumPy, Scikit-learn או TensorFlow.

4. יצירת DataFrame מרשימה של רשימות

שיטה זו דומה מבחינה רעיונית ליצירה ממערך NumPy אך משתמשת ברשימות פייתון סטנדרטיות. זוהי דרך פשוטה להמיר נתונים טבלאיים המאוחסנים בפורמט רשימה מקוננת.

איך זה עובד: אתם מספקים רשימה שבה כל רשימה פנימית מייצגת שורת נתונים. כמו במערכי NumPy, מומלץ מאוד לציין את שמות העמודות באמצעות הפרמטר columns לצורך בהירות.

דוגמה:

# נתונים כרשימה של שורות product_data = [ ['P001', 'מחשב נייד', 1200.00, 'אלקטרוניקה'], ['P002', 'עכבר', 25.50, 'אלקטרוניקה'], ['P003', 'כיסא שולחן', 150.75, 'רהיטים'], ['P004', 'מקלדת', 75.00, 'אלקטרוניקה'] ] # הגדרת שמות עמודות column_names = ['ProductID', 'ProductName', 'Price_USD', 'Category'] # יצירת DataFrame df_from_list_of_lists = pd.DataFrame(product_data, columns=column_names) print(df_from_list_of_lists)

פלט:

  ProductID ProductName  Price_USD     Category
0      P001      מחשב נייד    1200.00  אלקטרוניקה
1      P002       עכבר      25.50  אלקטרוניקה
2      P003  כיסא שולחן     150.75    רהיטים
3      P004    מקלדת      75.00  אלקטרוניקה

נקודת מפתח: זוהי שיטה פשוטה ויעילה כאשר הנתונים שלכם כבר מובנים כרשימה של שורות, כגון בעת קריאה מפורמט קובץ שאין לו כותרות.

אתחול מתקדם: התאמה אישית של ה-DataFrame שלכם

מעבר לאספקת הנתונים הגולמיים, הבנאי pd.DataFrame() מציע מספר פרמטרים לשליטה במבנה ובמאפיינים של ה-DataFrame החדש שלכם מרגע היווצרותו.

ציון האינדקס

כבר ראינו את הפרמטר `index` בפעולה. האינדקס הוא חלק חיוני ב-DataFrame, המספק תוויות לשורות המשמשות לחיפושים מהירים, יישור נתונים ועוד. בעוד ש-Pandas מספקת אינדקס מספרי ברירת מחדל (0, 1, 2, ...), הגדרת אינדקס משמעותי יכולה להפוך את הנתונים שלכם לקלים יותר לעבודה.

דוגמה: בואו נעשה שימוש חוזר בדוגמת המילון של רשימות שלנו, אך נגדיר את העמודה `City` כאינדקס בעת היצירה.

city_data = { 'Country': ['יפן', 'הודו', 'סין', 'ברזיל', 'הודו'], 'Population_Millions': [37.3, 32.0, 28.5, 22.4, 20.9], 'Is_Coastal': [True, False, True, False, True] } city_names = ['טוקיו', 'דלהי', 'שנגחאי', 'סאו פאולו', 'מומבאי'] # יצירת DataFrame עם אינדקס מותאם אישית df_with_index = pd.DataFrame(city_data, index=city_names) print(df_with_index)

פלט:

          Country  Population_Millions  Is_Coastal
טוקיו       יפן                 37.3        True
דלהי       הודו                 32.0       False
שנגחאי    סין                 28.5        True
סאו פאולו  ברזיל                 22.4       False
מומבאי      הודו                 20.9        True

כעת, אתם יכולים לגשת לנתוני שורה באמצעות תוויות משמעותיות אלה, למשל, עם df_with_index.loc['טוקיו'].

שליטה בסוגי נתונים (`dtype`)

Pandas טובה למדי בהסקת סוגי נתונים (למשל, זיהוי מספרים, טקסט ובוליאנים). עם זאת, לפעמים אתם צריכים לאכוף סוג נתונים ספציפי עבור עמודה כדי להבטיח יעילות זיכרון או לאפשר פעולות ספציפיות. הפרמטר `dtype` נותן לכם שליטה זו.

דוגמה: תארו לעצמכם שיש לנו מספרי מזהה מוצר שנראים כמו מספרים אך יש להתייחס אליהם כטקסט (מחרוזות).

data = { 'ProductID': [101, 102, 103], 'Stock': [50, 75, 0] } # יצירת DataFrame תוך ציון dtype עבור 'ProductID' df_types = pd.DataFrame(data, dtype={'ProductID': str, 'Stock': 'int32'}) print(df_types.dtypes)

פלט:

ProductID    object
Stock         int32
dtype: object

שימו לב ש-`str` ב-Pandas מיוצג כ-`object`. על ידי הגדרה מפורשת של ה-`dtype`, אנו מונעים מ-Pandas להתייחס ל-`ProductID` כמספר, מה שעלול להוביל לחישובים שגויים או לבעיות מיון בהמשך. שימוש בסוגי מספרים שלמים ספציפיים יותר כמו `int32` במקום ברירת המחדל `int64` יכול גם לחסוך משמעותית בזיכרון עם מערכי נתונים גדולים.

תרחישים מעשיים ושיטות עבודה מומלצות

בחירת שיטת היצירה הנכונה תלויה בפורמט המקורי של הנתונים שלכם. הנה מדריך החלטות פשוט:

• האם הנתונים שלכם נמצאים בעמודות (למשל, רשימה אחת לכל תכונה)? השתמשו במילון של רשימות. זה מתאים באופן טבעי.
• האם הנתונים שלכם הם סדרה של רשומות (למשל, מממשק JSON API)? השתמשו ברשימה של מילונים. היא מצטיינת בטיפול בשדות חסרים או נוספים ברשומות.
• האם הנתונים שלכם מספריים ונמצאים ברשת (למשל, מחישוב מדעי)? השתמשו במערך NumPy. זוהי האפשרות בעלת הביצועים הטובים ביותר עבור מקרה שימוש זה.
• האם הנתונים שלכם נמצאים בפורמט טבלה פשוט שורה אחר שורה ללא כותרות? השתמשו ברשימה של רשימות וספקו את שמות העמודות בנפרד.

מלכודות נפוצות שיש להימנע מהן

1. אורכים לא שווים במילון של רשימות: זוהי שגיאה נפוצה. בעת יצירת DataFrame ממילון של רשימות, לכל רשימה חייב להיות בדיוק אותו מספר רכיבים. אם לא, Pandas תעלה `ValueError`. ודאו תמיד שנתוני העמודות שלכם באורך שווה לפני היצירה.
2. התעלמות מהאינדקס: להסתמך על אינדקס ברירת המחדל מבוסס 0 זה בסדר עבור מקרים רבים, אך אם לנתונים שלכם יש מזהה טבעי (כגון מזהה מוצר, מזהה משתמש או חותמת זמן ספציפית), הגדרתו כאינדקס מההתחלה יכולה לפשט את הקוד שלכם בהמשך.
3. שכחת סוגי נתונים: לתת ל-Pandas להסיק סוגים עובד ברוב המקרים, אך עבור מערכי נתונים גדולים או עמודות עם סוגים מעורבים, הביצועים עלולים להיפגע. היו פרואקטיביים לגבי הגדרת `dtype` עבור עמודות שצריכות להיות מטופלות כקטגוריות, מחרוזות או סוגים מספריים ספציפיים כדי לחסוך בזיכרון ולמנוע שגיאות.

מעבר לאתחול: יצירת DataFrames מקבצים

בעוד שמדריך זה מתמקד ביצירת DataFrames מאובייקטי פייתון בזיכרון, חשוב לדעת שברוב התרחישים בעולם האמיתי, הנתונים שלכם יגיעו מקובץ חיצוני. Pandas מספקת חבילה של פונקציות קריאה מותאמות במיוחד למטרה זו, כולל:

• pd.read_csv(): עבור קבצי ערכים מופרדים בפסיקים, סוס העבודה של ייבוא נתונים.
• pd.read_excel(): לקריאת נתונים מגיליונות אלקטרוניים של Microsoft Excel.
• pd.read_json(): לקריאת נתונים מקבצי JSON או מחרוזות.
• pd.read_sql(): לקריאת התוצאות של שאילתת מסד נתונים ישירות לתוך DataFrame.
• pd.read_parquet(): לקריאה מפורמט הקובץ Parquet היעיל והמכוון לעמודות.

פונקציות אלה הן הצעד ההגיוני הבא במסע ה-Pandas שלכם. שליטה בהן תאפשר לכם לקלוט נתונים כמעט מכל מקור למבנה DataFrame עוצמתי.

מסקנה: היסוד שלכם לשליטה בנתונים

ה-Pandas DataFrame הוא מבנה הנתונים המרכזי עבור כל עבודה רצינית עם נתונים בפייתון. כפי שראינו, Pandas מציעה סט גמיש ואינטואיטיבי של כלים לאתחול מבנים אלה ממגוון רחב של פורמטים. על ידי הבנת אופן היצירה של DataFrame ממילונים, רשימות ומערכי NumPy, בניתם בסיס איתן לפרויקטי ניתוח הנתונים שלכם.

המפתח הוא לבחור את השיטה המתאימה ביותר למבנה המקורי של הנתונים שלכם. זה לא רק הופך את הקוד שלכם לנקי וקריא יותר, אלא גם ליעיל יותר. מכאן, אתם מוכנים לעבור למשימות המרגשות של ניקוי, חקירה, טרנספורמציה והצגה חזותית של נתונים. קידוד שמח!