Lists ב-R: יצירה, גישה ([[ מול $ מול [) ושינוי

רשימה מחזיקה כל דבר

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

person <- list(
  name = "Rosa",
  age = 30,
  scores = c(70, 85, 92),
  active = TRUE
)

print(length(person))
str(person)

length() מדווח 4: ארבעה איברים, אף שאחד מהם (scores) מכיל בעצמו שלושה מספרים. רשימה סופרת את התאים שלה, לא את מה שבתוכם. str() (structure) הוא הדרך המהירה ביותר לראות מה רשימה מחזיקה בפועל: שורה אחת לכל איבר עם השם, הטיפוס ותצוגה מקדימה. הפכו את str() לרפלקס: בכל פעם שפונקציה מחזירה לכם משהו ואתם לא בטוחים מה הוא, הפעילו עליו str().

שמות הם אופציונליים (list(1, "a", TRUE) חוקי) אבל כמעט תמיד כדאי שיהיו: רשימה עם שמות מתעדת את עצמה.

שלוש דרכי הכניסה: [, [[ ו-$

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

• [ מחזיר רשימה קטנה יותר: מכל מאותו סוג, שמחזיק את מה שבחרתם.
• [[ מחזיר את האיבר עצמו: הערך בפועל שבתוך התא.
• $ הוא קיצור של [[ עם שם מילולי: person$age הוא person[["age"]].

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

person <- list(name = "Rosa", age = 30, scores = c(70, 85, 92))

print(class(person["scores"]))
print(class(person[["scores"]]))

print(mean(person[["scores"]]))
print(person$age + 1)

ל-person["scores"] יש class "list": רשימה באורך 1 עם וקטור הציונים בתוכה. ל-person[["scores"]] יש class "numeric": הווקטור עצמו, מוכן ל-mean(). קראו ל-mean() על הגרסה עם הסוגריים הבודדים ותקבלו שגיאה שהארגומנט אינו מספרי; הודעת השגיאה הזו היא כמעט תמיד סימן שהשתמשתם ב-[ כשהתכוונתם ל-[[.

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

אז מתי [ הוא הכלי הנכון? כשרוצים כמה איברים ורוצים לשמור אותם ארוזים:

person <- list(name = "Rosa", age = 30, scores = c(70, 85, 92))

subset <- person[c("name", "age")]
str(subset)

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

עוד הבדל אחד: $ משתמש בהתאמה חלקית (person$sc מוצא את scores אם זה חד משמעי), מה שנוח בקונסולה ומסוכן בסקריפטים. בקוד שצריך להמשיך לעבוד, העדיפו [[ עם השם המלא: הוא גם מקבל שם ששמור במשתנה, מה ש-$ לא יכול לעשות.

הוספה, שינוי, הסרה

רשימות גדלות ומתכווצות בהשמה פשוטה, בלי צורך במתודת הוספה מיוחדת:

person <- list(name = "Rosa", age = 30)

person$email <- "rosa@example.com"
person[["age"]] <- 31
person[[length(person) + 1]] <- "extra"

str(person)

person$email <- NULL
print(names(person))

• השמה לשם שעדיין לא קיים מוסיפה את האיבר.
• השמה לשם קיים מחליפה אותו.
• השמה למיקום length(x) + 1 מוסיפה בסוף איבר ללא שם.
• הצבת NULL מסירה את האיבר לגמרי, והרשימה מתקצרת. (זה המקום היחיד שבו NULL מתנהג כפקודת מחיקה; אם אתם באמת צריכים לאחסן "כלום" בתא, השתמשו ב-x["k"] <- list(NULL).)

כדי להדביק שתי רשימות זו אחרי זו, c() עובד על רשימות בדיוק כמו על וקטורים: c(list_a, list_b) מחזיר רשימה אחת ארוכה יותר.

רשימות מקוננות

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

company <- list(
  name = "Acme",
  ceo = list(name = "Mia", start_year = 2019),
  offices = list(
    berlin = list(staff = 12),
    tokyo = list(staff = 31)
  )
)

print(company$ceo$name)
print(company[["offices"]][["tokyo"]][["staff"]])

הירידה פנימה היא פשוט שרשור של אופרטורי גישה: כל $ או [[ יורד רמה אחת לעומק. כשמבנה מקונן נעשה מבלבל, str(company) מראה את כל העץ בבת אחת, ו-str(company, max.level = 1) מראה רק את השכבה העליונה.

שיטוח עם unlist()

unlist() מכווץ רשימה, מקוננת לעומק ככל שתהיה, לווקטור יחיד:

grades <- list(math = c(80, 90), art = 75)

flat <- unlist(grades)
print(flat)
print(class(flat))

mixed <- unlist(list(a = 1, b = "two"))
print(mixed)
print(class(mixed))

שני דברים לשים לב אליהם. ראשית, unlist() בונה בשבילכם שמות (math1, math2, art) כך שעדיין אפשר לדעת מאיפה הגיע כל ערך. שנית, וזו המלכודת, וקטור מחזיק טיפוס אחד בלבד, ולכן שיטוח של רשימה מעורבת ממיר הכול לטיפוס הגמיש ביותר שקיים. המספר 1 חזר כמחרוזת "1". אם שיטחתם והמספרים שלכם הפכו לטקסט, הרשימה לא הייתה אחידה כמו שחשבתם.

למה רשימות חשובות

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

• פונקציות שמחזירות כמה דברים מחזירות רשימה. פונקציות ב-R מחזירות אובייקט אחד; רשימה מאפשרת לאובייקט האחד הזה לשאת ערך מותאם כאן וטבלת מקדמים שם. כשמריצים רגרסיה, אובייקט המודל שמקבלים בחזרה הוא רשימה (גדולה, עם class), ו-str() עליו מוכיח זאת.
• data frame הוא רשימה של עמודות: וקטורים באורך שווה עם התנהגות נוספת מעליהם. כל מה שלמדתם עכשיו ($, [[, הצבת NULL כדי להסיר איבר) חל מילה במילה על עמודות של data frame.
• משפחת apply, lapply() וחבריה, מקבלת רשימה, מפעילה פונקציה על כל איבר ומחזירה רשימה. רשימות נכנסות, רשימות יוצאות: זו הצורה הסטנדרטית של חישוב חוזר ב-R.

מה לקחת מכאן

• רשימות מחזיקות כל דבר: טיפוסים מעורבים, אורכים שונים, רשימות אחרות, data frames שלמים.
• [ מחזיר רשימה קטנה יותר; [[ מחזיר את האיבר עצמו; $ הוא [[ עם שם מילולי. רוצים לחשב? אתם צריכים [[ או $.
• מוסיפים בהשמה לשם חדש, מסירים בהצבת NULL, משלבים עם c().
• unlist() משטח לווקטור וממיר טיפוסים מעורבים בדרך: בדקו את ה-class של התוצאה.
• data frames הם רשימות של עמודות, כך שהידע הזה עובר ישירות.

בהמשך: מטריצות, המקבילה של הרשימה עם טיפוס אחד בלבד, שורות ועמודות.