Επεξεργασία δεδομένων

Εισαγωγή

Σε αυτό το κεφάλαιο, θα εξετάσουμε διάφορες συναρτήσεις και μεθόδους που χρησιμοποιούνται για τον χειρισμό δεδομένων. Πιο συγκεκριμένα, παρουσιάζουμε το package NumPy και εξετάζουμε πολύ πιο αναλυτικά το package Pandas.

Από την εισαγωγή στην επεξεργασία δεδομένων

Γενικά, αφού εισαγάγουμε τα δεδομένα, θέλουμε να τα μετασχηματίσουμε με τέτοιον τρόπο ώστε να γίνουν εύκολα στην ανάλυση, μια διαδικασία που συχνά ονομάζεται επεξεργασία δεδομένων (data manipulation). Στον πραγματικό κόσμο, τα σύνολα δεδομένων συνήθως δεν έχουν τη μορφή που θα θέλαμε. Ακόμη και όταν τα δεδομένα είναι αποθηκευμένα με τάξη σε βάσεις δεδομένων, συνήθως δεν είναι δομημένα με γνώμονα τη συγκεκριμένη ανάλυση που θέλουμε να κάνουμε. Για παράδειγμα, θέλουμε να αναλύσουμε τις πωλήσεις ανά χώρα για ένα συγκεκριμένο ημερολογιακό έτος ή τις πωλήσεις όλων των ημερολογιακών ετών για μια συγκεκριμένη χώρα; Σε αυτό το παράδειγμα, εναπόκειται σε εμάς να αποφασίσουμε ποια είναι η καλύτερη προσέγγιση, ανάλογα με τον στόχο μας. Αυτό δείχνει ότι πρέπει να μπορούμε να φέρουμε ένα σύνολο δεδομένων που εισαγάγαμε σε κατάλληλη μορφή, ώστε να διευκολύνουμε την ανάλυσή μας.

Επεξεργασία δεδομένων με το NumPy

Τα δύο ίσως σημαντικότερα packages για την επεξεργασία δεδομένων στο οικοσύστημα της επιστήμης δεδομένων της Python είναι το NumPy και το Pandas.

Το package NumPy (συντομογραφία του Numerical Python) παρέχει αποδοτικά εργαλεία για την εργασία με αριθμητικά δεδομένα. Συγκεκριμένα, εισάγει το NumPy array, το οποίο μοιάζει με μια list της Python, αλλά έχει σχεδιαστεί για γρήγορους μαθηματικούς υπολογισμούς. Τα NumPy arrays υποστηρίζουν διανυσματικές πράξεις (vectorized operations), που σημαίνει ότι οι υπολογισμοί μπορούν να εφαρμοστούν σε μια ολόκληρη συλλογή τιμών ταυτόχρονα, χωρίς να χρειάζονται βρόχοι. Αυτό καθιστά το NumPy εξαιρετικά σημαντικό για την επιστήμη δεδομένων, τη στατιστική, τη μηχανική μάθηση και τους επιστημονικούς υπολογισμούς. Πολλές άλλες βιβλιοθήκες της Python (συμπεριλαμβανομένου του Pandas) βασίζονται στο NumPy.

Αρχικά, ας δημιουργήσουμε μια συνηθισμένη list της Python:

import numpy as np

our_list = [1, 4, 5, 6, 6, 6, 6, 4100, 100, 100]

Μια συνηθισμένη list της Python είναι ευέλικτη, αλλά δεν είναι βελτιστοποιημένη για μαθηματικούς υπολογισμούς. Για παράδειγμα, αν πολλαπλασιάσουμε μια list με έναν αριθμό, η list επαναλαμβάνεται, αντί να πολλαπλασιαστεί κάθε τιμή:

# Πολλαπλασιασμός του our_list με το 2
our_list * 2
[1, 4, 5, 6, 6, 6, 6, 4100, 100, 100, 1, 4, 5, 6, 6, 6, 6, 4100, 100, 100]

Για να εκτελέσουμε μαθηματικές πράξεις στοιχείο προς στοιχείο, μετατρέπουμε πρώτα τη list σε NumPy array. Μόλις μετατραπεί σε array, οι υπολογισμοί εφαρμόζονται αυτόματα σε κάθε στοιχείο, κάτι που είναι γνωστό ως vectorization (διανυσματοποίηση). Στον παρακάτω κώδικα, κάθε τιμή του array πολλαπλασιάζεται πλέον ξεχωριστά με το 2:

# Διανυσματικός πολλαπλασιασμός
np.array(our_list) * 2
array([2, 8, 10, 12, 12, 12, 12, 8200, 200, 200])

Μπορούμε επίσης να κάνουμε υπολογισμούς μεταξύ arrays του ίδιου μήκους. Στο παρακάτω παράδειγμα, κάθε στοιχείο του πρώτου array προστίθεται στο αντίστοιχο στοιχείο του δεύτερου array:

# Πρόσθεση στοιχείο προς στοιχείο
np.array(our_list) + np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
array([2, 6, 8, 10, 11, 12, 13, 4108, 109, 110])

Όπως και οι lists της Python, τα NumPy arrays υποστηρίζουν επιλογή με βάση τη θέση (indexing) και slicing. Για παράδειγμα, μπορούμε να επιλέξουμε τα δύο πρώτα στοιχεία ενός NumPy array με τον εξής τρόπο:

# Επιλογή των δύο πρώτων στοιχείων
np.array(our_list)[0:2]
array([1, 4])

Όπως και οι συνηθισμένες lists της Python, τα NumPy arrays μπορούν επίσης να έχουν πολλές διαστάσεις. Για παράδειγμα, μια διπλή list μπορεί να μετατραπεί σε ένα δισδιάστατο array:

# Δημιουργία μιας διπλής list
double_list = [[1, 2, 3], [4, 5, 6]]

# Μετατροπή του double_list σε numpy array
np.array(double_list)
array([[1, 2, 3],
       [4, 5, 6]])

Έτσι δημιουργείται μια δομή που μοιάζει με μήτρα (matrix), με δύο γραμμές (όσες και οι lists) και τρεις στήλες (όσα και τα στοιχεία κάθε list).

Μπορούμε επίσης να χρησιμοποιήσουμε το NumPy για να εφαρμόσουμε συνθήκες στοιχείο προς στοιχείο. Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να κατατάξουμε τις τιμές μιας list ως "large" ή "small", ανάλογα με το αν κάθε τιμή είναι μεγαλύτερη από 5. Για να το κάνουμε αυτό, μπορούμε να χρησιμοποιήσουμε τη συνάρτηση np.where():

# Εφαρμογή συνθήκης
np.where(np.array(our_list) > 5, "large", "small")
array(['small', 'small', 'small', 'large', 'large', 'large',
       'large', 'large', 'large', 'large'], dtype='<U5')

Τέλος, το NumPy μπορεί επίσης να χρησιμοποιηθεί για τον υπολογισμό περιγραφικών στατιστικών μέτρων (summary statistics), όπως το mean ή το άθροισμα. Παρόλο που η Python παρέχει ήδη ενσωματωμένες συναρτήσεις, όπως η sum(), οι συναρτήσεις του NumPy είναι ειδικά βελτιστοποιημένες για αριθμητικά δεδομένα και λειτουργούν αποδοτικά με τα NumPy arrays. Στην πράξη, οι πράξεις του NumPy είναι γενικά πιο γρήγορες και πιο βολικές όταν δουλεύουμε με μεγάλα αριθμητικά σύνολα δεδομένων ή όταν κάνουμε μαθηματικούς υπολογισμούς σε arrays.

# Υπολογισμός αθροίσματος με την τυπική Python
sum(our_list)
4334
# Υπολογισμός αθροίσματος με το numpy
np.sum(np.array(our_list))
np.int64(4334)

Και στις δύο περιπτώσεις, η έξοδος είναι η ίδια (4334). Η κύρια διαφορά δεν είναι το ίδιο το αποτέλεσμα, αλλά ο τρόπος με τον οποίο εκτελείται εσωτερικά ο υπολογισμός. Η ενσωματωμένη συνάρτηση sum() λειτουργεί με γενικά objects της Python, όπως οι lists, ενώ η np.sum() είναι βελτιστοποιημένη για NumPy arrays και αριθμητικούς υπολογισμούς. Αυτό γίνεται ιδιαίτερα χρήσιμο όταν δουλεύουμε με μεγάλα σύνολα δεδομένων ή με πολυδιάστατα arrays, όπου οι πράξεις του NumPy είναι γενικά πιο γρήγορες και πιο αποδοτικές ως προς τη μνήμη. Σημειώνεται ότι η έξοδος της np.sum() έχει ελαφρώς διαφορετική μορφή, επειδή επιστρέφει έναν αριθμητικό τύπο του NumPy (όπως numpy.int64) αντί για ένα τυπικό ενσωματωμένο integer της Python.

Επεξεργασία δεδομένων με το Pandas

Παρόλο που το NumPy παρέχει πολλές επιπλέον δυνατότητες, θα επικεντρωθούμε κυρίως στη χρήση του Pandas (συντομογραφία του Panel Data ή του Python Data Analysis), του οποίου ο κύριος σκοπός είναι η επεξεργασία δεδομένων με data frames. Ένα data frame (πλαίσιο δεδομένων) είναι ένας ορθογώνιος πίνακας δεδομένων οργανωμένος σε γραμμές και στήλες, παρόμοιος με ένα υπολογιστικό φύλλο. Ενώ το NumPy είναι βελτιστοποιημένο για γρήγορους αριθμητικούς υπολογισμούς, το Pandas επικεντρώνεται σε πρακτικές εργασίες ανάλυσης δεδομένων. Στα περισσότερα πραγματικά έργα επιστήμης δεδομένων, το Pandas είναι το κύριο εργαλείο για την επεξεργασία συνόλων δεδομένων, ενώ το NumPy λειτουργεί στο παρασκήνιο, παρέχοντας αποδοτικές αριθμητικές πράξεις.

Για να μάθουμε πώς να χρησιμοποιούμε το Pandas, είναι λογικό να έχουμε ένα συγκεκριμένο σύνολο δεδομένων σε όλο αυτό το κεφάλαιο. Αυτό το σύνολο δεδομένων θα είναι το ίδιο με εκείνο που εισαγάγαμε (με τη συνάρτηση read_csv() του package Pandas) στο Κεφάλαιο Εισαγωγή δεδομένων: το σύνολο δεδομένων customer_churn.

Το σύνολο δεδομένων μας περιέχει πληροφορίες για 4,000 πελάτες, από τους οποίους οι 1,000 αποχωρούν (churn), δηλαδή είναι γνωστό ότι σταμάτησαν να αγοράζουν σε κάποια χρονική στιγμή. Οι στήλες Recency και Recency_Level δείχνουν πόσο πρόσφατα έκανε ένας πελάτης την τελευταία του αγορά. Επιπλέον, οι στήλες Frequency και Frequency_Level μάς δείχνουν πόσες αγορές (συνολικά) έχει κάνει ένας πελάτης στο παρελθόν. Ακόμη, οι στήλες Monetary_Value και Monetary_Value_Level δείχνουν πόσα χρήματα έλαβε η εταιρεία από έναν πελάτη. Σύμφωνα με την ακαδημαϊκή βιβλιογραφία του μάρκετινγκ (βλ., για παράδειγμα, Blattberg, Kim, & Neslin, 2008· Fader & Hardie, 2009), αυτές οι γενικές μεταβλητές, γνωστές με το ακρωνύμιο RFM, μπορούν να χρησιμοποιηθούν ως ισχυροί δείκτες για το αν ένας πελάτης θα αποχωρήσει στο μέλλον. Μπορούμε να φανταστούμε ότι όσο πιο πρόσφατες είναι οι αγορές και όσο μεγαλύτερη είναι η αξία τους, τόσο μεγαλύτερη είναι η πιθανότητα να μην αποχωρήσει ένας πελάτης. Τέλος, η στήλη Observation_Period δείχνει πόσο καιρό είναι γνωστό ότι ένας πελάτης είναι πελάτης της εταιρείας.

Φορτώνουμε το package Pandas και το αντίστοιχο σύνολο δεδομένων (εκχωρώντας το σε ένα object με όνομα customer_churn) με τον παρακάτω κώδικα:

import pandas as pd

# Εισαγωγή του customer_churn
customer_churn = pd.read_csv("https://raw.githubusercontent.com/Datakortex/Datasets/refs/heads/main/customer_churn.csv")

# Εμφάνιση των πρώτων γραμμών
customer_churn.head()
ID Recency Recency_Level ... Monetary_Value_Level Observation_Period Churn
0 1 46 Low ... Medium 742 0
1 2 40 Low ... High 2301 0
2 3 35 Low ... High 2411 0
3 4 50 Low ... Medium 813 0
4 5 77 Medium ... Low 1 0

5 rows × 9 columns

Όπως αναφέραμε, το σύνολο δεδομένων που εισαγάγαμε έχει 4,000 παρατηρήσεις (ως γραμμές) και 9 μεταβλητές (ως στήλες). Επειδή είναι πολύ χρήσιμο να έχουμε μια σύντομη περιγραφή κάθε μεταβλητής, περιγράφουμε παρακάτω το περιεχόμενο κάθε στήλης:

  • ID: κωδικός πελάτη (μοναδικός αριθμός)

  • Recency: αριθμός ημερών που έχουν περάσει από την τελευταία αγορά

  • Recency_Level: το επίπεδο του recency (χαμηλό, μεσαίο ή υψηλό)

  • Frequency: αριθμός αγορών

  • Frequency_Level: το επίπεδο του frequency (χαμηλό, μεσαίο ή υψηλό)

  • Monetary_Value: συνολική χρηματική αξία (π.χ. συνολικό ποσό σε ευρώ)

  • Monetary_Value_Level: το επίπεδο της χρηματικής αξίας (χαμηλό, μεσαίο ή υψηλό)

  • Observation_Period: αριθμός ημερών ανάμεσα στην πρώτη και στην τελευταία αγορά

  • Churn: αν ο πελάτης αποχωρεί ή όχι (η τιμή 1 σημαίνει ότι ο πελάτης αποχωρεί)

Είναι φανερό ότι τα δεδομένα που εισαγάγαμε έχουν τη δομή ενός DataFrame του Pandas. Κάθε γραμμή είναι μια παρατήρηση (observation), δηλαδή ένας πελάτης, ενώ κάθε στήλη είναι μια διαφορετική μεταβλητή (variable), δηλαδή ένα χαρακτηριστικό.

Εμφάνιση της εξόδου

Οι πρώτες γραμμές του DataFrame εμφανίζονται ως μορφοποιημένος πίνακας και όχι ως κείμενο μέσα στην έξοδο του κώδικα. Αυτό οφείλεται στον τρόπο με τον οποίο το περιβάλλον της Python αποδίδει τα objects σε μορφή πίνακα. Ανάλογα με το λογισμικό που χρησιμοποιείτε για να εκτελέσετε τον κώδικα, η εμφάνιση και η θέση της εξόδου μπορεί να διαφέρουν. Αυτές οι διαφορές είναι καθαρά αισθητικές και δεν επηρεάζουν τα αποτελέσματα.

Η χρήση της μεθόδου chaining

Ένα από τα βασικά χαρακτηριστικά του Pandas είναι ότι μπορούμε να επεξεργαστούμε ένα DataFrame σε βήματα. Για παράδειγμα, στο customer_churn μπορεί να θέλουμε πρώτα να κρατήσουμε μια συγκεκριμένη ομάδα πελατών και στη συνέχεια να υπολογίσουμε τη μέση τιμή του recency. Μια τέτοια διαδικασία θα απαιτούσε δύο διακριτά βήματα: πρώτα, το φιλτράρισμα των γραμμών που ικανοποιούν μια συνθήκη και, δεύτερον, την εφαρμογή ενός υπολογισμού στο υποσύνολο δεδομένων που προκύπτει. Με το Pandas, εφαρμόζουμε τη μέθοδο chaining (method chaining, αλυσιδωτή κλήση μεθόδων), η οποία βασίζεται στον τελεστή της τελείας (.). Αυτό μας επιτρέπει να πάρουμε την έξοδο μιας πράξης και να εφαρμόσουμε αμέσως σε αυτήν μια άλλη πράξη, δημιουργώντας μια ακολουθία (ή «αλυσίδα») μετασχηματισμών. Με άλλα λόγια, η τελεία μάς επιτρέπει να προχωράμε βήμα βήμα μέσα σε ένα object δεδομένων, καλώντας μεθόδους απευθείας πάνω του.

Για να δείξουμε αυτή την έννοια, ας χρησιμοποιήσουμε ένα πολύ απλό παράδειγμα. Μέχρι τώρα, έχουμε χρησιμοποιήσει τη μέθοδο head(), η οποία από προεπιλογή επιστρέφει τις 5 πρώτες γραμμές ενός DataFrame. Σε αυτή τη μέθοδο, μπορούμε επίσης να ορίσουμε τον αριθμό των γραμμών μέσα στις παρενθέσεις. Για παράδειγμα, ο παρακάτω κώδικας επιστρέφει τις δέκα πρώτες γραμμές:

# Εμφάνιση των δέκα πρώτων γραμμών
customer_churn.head(10)
ID Recency Recency_Level ... Monetary_Value_Level Observation_Period Churn
0 1 46 Low ... Medium 742 0
1 2 40 Low ... High 2301 0
2 3 35 Low ... High 2411 0
3 4 50 Low ... Medium 813 0
4 5 77 Medium ... Low 1 0
5 6 55 Medium ... Medium 2077 0
6 7 48 Low ... Medium 1317 0
7 8 193 High ... High 1612 1
8 9 96 Medium ... Medium 1037 0
9 10 167 High ... Medium 1373 1

10 rows × 9 columns

Τώρα, για να δείξουμε την ιδέα της μεθόδου chaining, μπορούμε να εφαρμόσουμε μια ακόμη μέθοδο head() αμέσως μετά την πρώτη:

# Εμφάνιση των πρώτων γραμμών
customer_churn.head(10).head()
ID Recency Recency_Level ... Monetary_Value_Level Observation_Period Churn
0 1 46 Low ... Medium 742 0
1 2 40 Low ... High 2301 0
2 3 35 Low ... High 2411 0
3 4 50 Low ... Medium 813 0
4 5 77 Medium ... Low 1 0

5 rows × 9 columns

Όπως αναμενόταν, εμφανίζονται οι πέντε πρώτες γραμμές. Αυτό συμβαίνει επειδή η πρώτη πράξη (head(10)) δημιουργεί ένα νέο DataFrame που περιέχει μόνο τις δέκα πρώτες γραμμές. Στη συνέχεια, η δεύτερη πράξη (head()) εφαρμόζεται σε αυτό το ενδιάμεσο αποτέλεσμα και εξάγει τις πέντε πρώτες γραμμές από αυτό το υποσύνολο.

Με αυτόν τον τρόπο, κάθε τελεία αντιπροσωπεύει ένα βήμα σε μια ακολουθία μετασχηματισμών: η έξοδος μιας πράξης γίνεται η είσοδος της επόμενης. Αυτό μας επιτρέπει να χτίζουμε ροές επεξεργασίας δεδομένων βήμα βήμα, κάνοντας τον κώδικα πιο δομημένο, πιο ευανάγνωστο και πιο εύκολο να επεκταθεί.

Εξερεύνηση πράξεων για την επεξεργασία δεδομένων

Στο υπόλοιπο αυτού του κεφαλαίου, βλέπουμε πώς μπορούμε να επεξεργαστούμε το DataFrame customer_churn με το Pandas. Οι μέθοδοι info() και describe() εμφανίζουν τη δομή του συνόλου δεδομένων και τα περιγραφικά στατιστικά μέτρα αντίστοιχα. Με αυτόν τον τρόπο, μπορούμε γρήγορα να σχηματίσουμε μια αρχική εικόνα για τα δεδομένα με τα οποία δουλεύουμε.

# Εμφάνιση της δομής
customer_churn.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4000 entries, 0 to 3999
Data columns (total 9 columns):
 #   Column                Non-Null Count  Dtype  
---  ------                --------------  -----  
 0   ID                    4000 non-null   int64  
 1   Recency               4000 non-null   int64  
 2   Recency_Level         4000 non-null   object 
 3   Frequency             4000 non-null   int64  
 4   Frequency_Level       4000 non-null   object 
 5   Monetary_Value        4000 non-null   float64
 6   Monetary_Value_Level  4000 non-null   object 
 7   Observation_Period    4000 non-null   int64  
 8   Churn                 4000 non-null   int64  
dtypes: float64(1), int64(5), object(3)
memory usage: 281.4+ KB
# Εμφάνιση των περιγραφικών στατιστικών μέτρων
customer_churn.describe()
ID Recency Frequency Monetary_Value Observation_Period Churn
count 4000.00 4000.00 4000.00 4000.00 4000.00 4000.00
mean 2000.50 102.06 37.82 8417.93 1529.73 0.25
std 1154.84 101.46 30.55 12498.18 825.79 0.43
min 1.00 30.00 12.00 109.00 1.00 0.00
25% 1000.75 38.00 22.00 1779.81 852.75 0.00
50% 2000.50 54.00 31.00 4209.97 1803.00 0.00
75% 3000.25 129.00 45.00 9163.19 2288.00 0.25
max 4000.00 519.00 860.00 99011.17 2435.00 1.00

Σε κάθε στήλη αντιστοιχεί ένας συγκεκριμένος τύπος δεδομένων. Για παράδειγμα, το int64 δηλώνει μια αριθμητική μεταβλητή (integer), ενώ το object (ή το str στις νεότερες εκδόσεις του Pandas) συνήθως αντιπροσωπεύει δεδομένα κειμένου. Επιπλέον, τα περιγραφικά στατιστικά μέτρα περιλαμβάνουν μέτρα όπως τον αριθμό των παρατηρήσεων (count), τη μέση τιμή (mean) και το standard deviation (std). Αυτές οι τιμές δίνουν μια γρήγορη εικόνα της κατανομής κάθε αριθμητικής μεταβλητής. Επειδή η μεταβλητή (στήλη) Churn παίρνει μόνο τις τιμές 0 και 1, μπορεί να ερμηνευτεί ως δυαδικός δείκτης (binary indicator). Σε αυτή την περίπτωση, το mean του Churn αντιπροσωπεύει το ποσοστό των πελατών που αποχώρησαν. Επομένως, ένα mean ίσο με 0.25 σημαίνει ότι το 25% των πελατών του συνόλου δεδομένων έχουν αποχωρήσει.

Επιλογή στηλών:
Για να επιλέξουμε συγκεκριμένες στήλες σε ένα DataFrame του Pandas, χρησιμοποιούμε αγκύλες ([]) με το όνομα ή τα ονόματα των στηλών. Αυτό μας επιτρέπει να εξαγάγουμε είτε μία στήλη είτε πολλές στήλες από το σύνολο δεδομένων.

customer_churn["Recency"]
0        46
1        40
2        35
3        50
4        77
       ... 
3995    189
3996    152
3997    359
3998     69
3999     31
Name: Recency, Length: 4000, dtype: int64

Παρατηρούμε ότι η έξοδος που προκύπτει είναι ένα Series του Pandas, παρόλο που μπορεί να μοιάζει με DataFrame μίας στήλης. Όταν επιλέγουμε μία στήλη με μονές αγκύλες, το αποτέλεσμα είναι ένα Series, δηλαδή ένα μονοδιάστατο object που αναπαριστά μία μεταβλητή, ενώ ένα DataFrame είναι δισδιάστατο και μπορεί να περιέχει πολλές μεταβλητές. Παρόλο που και τα δύο μπορεί να μοιάζουν όταν εμφανίζονται, είναι θεμελιωδώς διαφορετικές δομές δεδομένων και το Pandas τα χειρίζεται διαφορετικά.

Αυτή η διάκριση έχει σημασία, επειδή ορισμένες πράξεις συμπεριφέρονται διαφορετικά ανάλογα με το αν δουλεύουμε με ένα Series ή με ένα DataFrame. Για παράδειγμα, ένα Series χρησιμοποιείται συχνά όταν θέλουμε να δουλέψουμε απευθείας με μία μεταβλητή (όπως όταν υπολογίζουμε στατιστικά μέτρα, εφαρμόζουμε συναρτήσεις ή περνάμε δεδομένα σε μοντέλα), ενώ ένα DataFrame προτιμάται όταν θέλουμε να διατηρήσουμε τη δομή πίνακα ή να δουλέψουμε με πολλές στήλες ταυτόχρονα.

Για να διατηρήσουμε τη δομή του DataFrame, πρέπει να χρησιμοποιήσουμε διπλές αγκύλες ([[]]):

# Επιλογή του Recency
customer_churn[["Recency"]]
Recency
0 46
1 40
2 35
3 50
4 77
... ...
3995 189
3996 152
3997 359
3998 69
3999 31

4000 rows × 1 columns

Τώρα έχουμε ένα DataFrame μόνο με τη στήλη Recency. Με τον ίδιο τρόπο, μπορούμε να επιλέξουμε πολλές στήλες περνώντας μια list με ονόματα στηλών μέσα στις αγκύλες:

# Επιλογή των Recency, Frequency, Monetary_Value και Churn
customer_churn[["Recency", "Frequency", "Monetary_Value", "Churn"]]
Recency Frequency Monetary_Value Churn
0 46 26 3009.60 0
1 40 56 57347.28 0
2 35 293 14496.16 0
3 50 18 1416.20 0
4 77 14 523.72 0
... ... ... ... ...
3995 189 17 683.18 1
3996 152 23 3205.66 0
3997 359 17 251.00 1
3998 69 43 9438.84 1
3999 31 45 5822.22 0

4000 rows × 4 columns

Έτσι επιστρέφεται ένα νέο DataFrame που περιέχει μόνο τις επιλεγμένες στήλες, επιτρέποντάς μας να επικεντρωθούμε σε συγκεκριμένες μεταβλητές που μας ενδιαφέρουν, διατηρώντας ταυτόχρονα τα δεδομένα σε δομημένη μορφή.

Διαγραφή στηλών:
Αντί να επιλέξουμε τις στήλες που θέλουμε να κρατήσουμε, μερικές φορές είναι πιο εύκολο να αφαιρέσουμε τις στήλες που δεν χρειαζόμαστε. Στο Pandas, για αυτόν τον σκοπό χρησιμοποιείται η μέθοδος drop(). Για να διαγράψουμε στήλες, χρησιμοποιούμε το όρισμα columns και δίνουμε μια list με τα ονόματα των στηλών που θέλουμε να αφαιρέσουμε. Για παράδειγμα, ας υποθέσουμε ότι θέλουμε ένα DataFrame που περιέχει μόνο τις στήλες Recency, Frequency, Monetary_Value και Churn. Αντί να επιλέξουμε απευθείας αυτές τις στήλες, μπορούμε να διαγράψουμε όλες τις υπόλοιπες:

# Διαγραφή όλων των υπόλοιπων στηλών
customer_churn.drop(columns = ["ID",
                               "Recency_Level",
                               "Frequency_Level",
                               "Monetary_Value_Level",
                               "Observation_Period"])
Recency Frequency Monetary_Value Churn
0 46 26 3009.60 0
1 40 56 57347.28 0
2 35 293 14496.16 0
3 50 18 1416.20 0
4 77 14 523.72 0
... ... ... ... ...
3995 189 17 683.18 1
3996 152 23 3205.66 0
3997 359 17 251.00 1
3998 69 43 9438.84 1
3999 31 45 5822.22 0

4000 rows × 4 columns

Μετονομασία στηλών:
Μια ακόμη εύκολη αλλά χρήσιμη μέθοδος είναι η rename(), η οποία χρησιμοποιείται για να αλλάξουμε τα ονόματα των στηλών. Για να το κάνουμε αυτό, δίνουμε ένα dictionary (βλ. Κεφάλαιο Τα βασικά της Python) στο όρισμα columns, όπου τα κλειδιά αντιπροσωπεύουν τα αρχικά ονόματα των στηλών και οι τιμές τα νέα ονόματα που θέλουμε να δώσουμε. Για παράδειγμα, ο παρακάτω κώδικας αλλάζει το όνομα της στήλης Frequency σε Number_of_Purchases:

# Μετονομασία της στήλης Frequency σε Number_of_Purchases
customer_churn.rename(columns = {"Frequency": "Number_of_Purchases"})[["ID", "Number_of_Purchases", "Churn"]].head()
ID Number_of_Purchases Churn
0 1 26 0
1 2 56 0
2 3 293 0
3 4 18 0
4 5 14 0

Σημειώνεται ότι η δομή των δεδομένων παραμένει η ίδια· ενημερώνεται μόνο η ετικέτα της στήλης.

Ταξινόμηση τιμών:
Μια απλή αλλά πολύ χρήσιμη μέθοδος είναι η sort_values(). Όπως υποδηλώνει το όνομά της, αυτή η μέθοδος μας βοηθά να ταξινομήσουμε τις γραμμές ενός DataFrame με βάση τις τιμές μίας ή περισσότερων συγκεκριμένων στηλών. Για παράδειγμα, μπορεί να θέλουμε να δούμε το σύνολο δεδομένων μας σε φθίνουσα σειρά με βάση το Monetary_Value. Για να χρησιμοποιήσουμε αυτή τη μέθοδο, πρέπει να δώσουμε μέσα στις παρενθέσεις το όνομα της στήλης με βάση την οποία θέλουμε να ταξινομήσουμε τα δεδομένα μας. Πρέπει επίσης να ορίσουμε το όρισμα ascending, ανάλογα με το αν προτιμάμε αύξουσα ή φθίνουσα σειρά.

# Ταξινόμηση με βάση το Monetary_Value
customer_churn.sort_values("Monetary_Value", ascending = False)[["ID", "Monetary_Value", "Churn"]].head()
ID Monetary_Value Churn
1004 1005 99011.17 0
35 36 97748.52 0
3720 3721 96694.04 0
3947 3948 96201.57 0
3967 3968 90727.97 0

Για να συμπεριλάβουμε περισσότερες από μία μεταβλητές, αρκεί να τις δώσουμε σε μια list. Σε αυτή την περίπτωση όμως, πρέπει να ορίσουμε και το όρισμα ascending (True ή False) επίσης με μια list:

# Ταξινόμηση με βάση τα Frequency και Monetary_Value
customer_churn.sort_values(["Frequency", "Monetary_Value"], ascending = [True, False])[["ID", "Frequency", "Monetary_Value", "Churn"]].head()
ID Frequency Monetary_Value Churn
418 419 12 789.08 1
2876 2877 12 670.94 1
1501 1502 12 535.52 0
1108 1109 12 496.08 1
221 222 12 490.35 1

Φιλτράρισμα γραμμών:
Συχνά, θέλουμε να αφαιρέσουμε ορισμένες γραμμές από ένα σύνολο δεδομένων. Για να το κάνουμε αυτό, βασιζόμαστε σε συγκρίσεις (βλ. Κεφάλαιο Τα βασικά της Python), οι οποίες μας επιτρέπουν να δημιουργούμε λογικές προτάσεις που αποτιμώνται είτε σε True είτε σε False για κάθε γραμμή. Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να κρατήσουμε μόνο τους πελάτες με recency μικρότερο από 60 ημέρες. Ξεκινάμε με την εξής έκφραση:

# Έλεγχος του ποιες γραμμές ικανοποιούν τη συνθήκη
customer_churn["Recency"] < 60
0        True
1        True
2        True
3        True
4       False
        ...  
3995    False
3996    False
3997    False
3998    False
3999     True
Name: Recency, Length: 4000, dtype: bool

Αυτή η έκφραση δημιουργεί ένα Boolean Series του Pandas, στο οποίο κάθε στοιχείο είναι είτε True είτε False, ανάλογα με το αν ικανοποιείται η συνθήκη. Σε αυτή την περίπτωση, ελέγχεται κάθε γραμμή για να δούμε αν η τιμή της στήλης Recency είναι μικρότερη από 60. Στη συνέχεια, μπορούμε να χρησιμοποιήσουμε αυτό το Boolean Series για να φιλτράρουμε το αρχικό DataFrame. Όταν τοποθετούμε τη συνθήκη μέσα στις αγκύλες του DataFrame, το Pandas κρατά μόνο τις γραμμές για τις οποίες η συνθήκη είναι True:

# Φιλτράρισμα γραμμών με βάση τη συνθήκη
customer_churn[customer_churn["Recency"] < 60].head()
ID Recency Recency_Level ... Monetary_Value_Level Observation_Period Churn
0 1 46 Low ... Medium 742 0
1 2 40 Low ... High 2301 0
2 3 35 Low ... High 2411 0
3 4 50 Low ... Medium 813 0
5 6 55 Medium ... Medium 2077 0

5 rows × 9 columns

Αυτή η πράξη ουσιαστικά δημιουργεί ένα υποσύνολο του DataFrame, επιστρέφοντας μόνο τις παρατηρήσεις που ικανοποιούν τη συνθήκη. Με αυτόν τον τρόπο, οι συγκρίσεις μάς επιτρέπουν να αφαιρούμε ή να επιλέγουμε γραμμές με ευελιξία, με βάση οποιονδήποτε κανόνα ορίζεται πάνω στα δεδομένα.

Μπορούμε να επεκτείνουμε τις συγκρίσεις συνδυάζοντας πολλές συνθήκες. Για να το κάνουμε αυτό, τοποθετούμε κάθε συνθήκη μέσα σε παρενθέσεις και τις συνδέουμε με λογικούς τελεστές, όπως ο &:

# Φιλτράρισμα γραμμών με βάση πολλές συνθήκες
customer_churn[(customer_churn["Recency"] == 30) & (customer_churn["Frequency_Level"] == "High")][["ID", "Recency", "Frequency_Level", "Churn"]].head()
ID Recency Frequency_Level Churn
71 72 30 High 0
3005 3006 30 High 0

Σε αυτό το παράδειγμα, κρατάμε μόνο τους πελάτες που ικανοποιούν και τις δύο συνθήκες ταυτόχρονα: πελάτες με τιμή recency 30 ημέρες και επίπεδο frequency ίσο με "High".

Όταν δουλεύουμε με μεταβλητές που έχουν πολλές κατηγορίες, το να γράφουμε πολλές συνθήκες ισότητας δεν είναι αποδοτικό. Σε τέτοιες περιπτώσεις, η μέθοδος isin() προσφέρει μια πιο καθαρή εναλλακτική. Αυτή η μέθοδος ελέγχει αν κάθε τιμή ανήκει σε μια συγκεκριμένη list κατηγοριών. Ο παρακάτω κώδικας δείχνει αυτή την ιδέα:

# Φιλτράρισμα γραμμών με βάση πολλές συνθήκες
customer_churn[(customer_churn["Recency"] == 30) & (customer_churn["Monetary_Value_Level"].isin(["Medium", "High"]))][["ID", "Recency", "Monetary_Value_Level", "Churn"]].head()
ID Recency Monetary_Value_Level Churn
71 72 30 High 0
1883 1884 30 Medium 0
2309 2310 30 Medium 0
2349 2350 30 Medium 0
3005 3006 30 High 0

Εδώ, κρατάμε τους πελάτες με τιμή recency 30 ημέρες και με επίπεδο χρηματικής αξίας είτε "Medium" είτε "High".

Μπορούμε επίσης να επιλέξουμε γραμμές και στήλες με τα ειδικά indexers του Pandas, το loc[] και το iloc[]. Αυτά προσφέρουν έναν πιο σαφή και πιο ευέλικτο τρόπο για να δημιουργούμε υποσύνολα των DataFrames. Το indexer loc[] επιλέγει γραμμές και στήλες με βάση ετικέτες (labels), δηλαδή ονόματα στηλών και ετικέτες γραμμών. Η γενική του δομή είναι:

# Γενική δομή του .loc[]
dataframe.loc[row_selection, column_selection]

Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να κρατήσουμε μόνο τις γραμμές όπου το Recency είναι μικρότερο από 60 και να εμφανίσουμε μόνο τις μεταβλητές Recency, Frequency_Level και Monetary_Value. Μπορούμε να γράψουμε:

# Φιλτράρισμα γραμμών και επιλογή στηλών με το .loc[]
customer_churn.loc[
    customer_churn["Recency"] < 60,
    ["Recency", "Frequency_Level", "Monetary_Value"]
    ].head()
Recency Frequency_Level Monetary_Value
0 46 Low 3009.60
1 40 Medium 57347.28
2 35 High 14496.16
3 50 Low 1416.20
5 55 Low 8830.32

Εδώ, το πρώτο μέρος μέσα στο loc[] ορίζει τις γραμμές που θέλουμε να κρατήσουμε με μια Boolean συνθήκη, ενώ το δεύτερο μέρος ορίζει τις στήλες που θα εμφανιστούν. Αυτός είναι, φυσικά, απλώς ένας εναλλακτικός τρόπος επιλογής γραμμών και στηλών. Θα μπορούσαμε αντί γι’ αυτό να κάνουμε το φιλτράρισμα των γραμμών και την επιλογή των στηλών ξεχωριστά· η έξοδος θα ήταν ακριβώς η ίδια.

# Φιλτράρισμα γραμμών και επιλογή στηλών χωρίς το .loc[]
customer_churn[customer_churn["Recency"] < 60][["Recency", "Frequency_Level", "Monetary_Value"]].head()
Recency Frequency_Level Monetary_Value
0 46 Low 3009.60
1 40 Medium 57347.28
2 35 High 14496.16
3 50 Low 1416.20
5 55 Low 8830.32

Το indexer iloc[] λειτουργεί διαφορετικά, επειδή επιλέγει γραμμές και στήλες με βάση τις ακέραιες θέσεις τους και όχι με βάση ετικέτες. Η δομή του είναι παρόμοια:

# Γενική δομή του .iloc[]
dataframe.iloc[row_positions, column_positions]

Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να εμφανίσουμε τις πέντε πρώτες γραμμές και τις τρεις πρώτες στήλες του συνόλου δεδομένων:

# Επιλογή γραμμών και στηλών με βάση τη θέση με το .iloc[]
customer_churn.iloc[0:5, 0:3]
ID Recency Recency_Level
0 1 46 Low
1 2 40 Low
2 3 35 Low
3 4 50 Low
4 5 77 Medium

Σε αυτό το παράδειγμα, το 0:5 επιλέγει τις γραμμές από τη θέση 0 έως (αλλά χωρίς να περιλαμβάνεται) τη θέση 5, ενώ το 0:3 επιλέγει τις τρεις πρώτες στήλες.

Επομένως, η σημαντική διαφορά ανάμεσα στο loc[] και στο iloc[] είναι ότι το loc[] χρησιμοποιεί ετικέτες και περιλαμβάνει την τελική ετικέτα στο slicing, ενώ το iloc[] χρησιμοποιεί ακέραιες θέσεις και εξαιρεί την τελική θέση, ακριβώς όπως το τυπικό slicing της Python.

Δημιουργία νέων στηλών:
Είδαμε πώς μπορούμε να αφαιρέσουμε στήλες και γραμμές από ένα σύνολο δεδομένων. Τι γίνεται όμως αν θέλουμε να δημιουργήσουμε μια νέα στήλη ή να μετασχηματίσουμε τις τιμές μιας υπάρχουσας; Στο Pandas, αυτό μπορεί να γίνει εκχωρώντας τιμές απευθείας σε ένα όνομα στήλης. Η ιδιότητα του vectorization που είδαμε νωρίτερα με το NumPy ισχύει και για το Pandas. Αυτό σημαίνει ότι οι πράξεις εκτελούνται αυτόματα στοιχείο προς στοιχείο σε ολόκληρη τη στήλη, χωρίς να χρειάζονται βρόχοι. Υποθέτοντας ότι ένας μήνας έχει 30 ημέρες, μπορούμε να δημιουργήσουμε μια νέα μεταβλητή με όνομα Recency_Months με τον εξής τρόπο:

# Δημιουργία της στήλης Recency_Months
customer_churn["Recency_Months"] = customer_churn["Recency"] / 30

# Εμφάνιση των πρώτων γραμμών
customer_churn.head()
ID Recency Recency_Level ... Observation_Period Churn Recency_Months
0 1 46 Low ... 742 0 1.53
1 2 40 Low ... 2301 0 1.33
2 3 35 Low ... 2411 0 1.17
3 4 50 Low ... 813 0 1.67
4 5 77 Medium ... 1 0 2.57

5 rows × 10 columns

Μια νέα στήλη που περιέχει τις μετασχηματισμένες τιμές έχει πλέον προστεθεί στο DataFrame. Κάθε τιμή της στήλης Recency διαιρείται με το 30 και το αποτέλεσμα αποθηκεύεται στη νέα στήλη Recency_Months.

Θα μπορούσαμε επίσης να πετύχουμε το ίδιο αποτέλεσμα με τη μέθοδο assign():

# Δημιουργία της στήλης Recency_Months με την assign
customer_churn = customer_churn.assign(Recency_Months = customer_churn["Recency"] / 30)

# Εμφάνιση των πρώτων γραμμών
customer_churn.head()
ID Recency Recency_Level ... Observation_Period Churn Recency_Months
0 1 46 Low ... 742 0 1.53
1 2 40 Low ... 2301 0 1.33
2 3 35 Low ... 2411 0 1.17
3 4 50 Low ... 813 0 1.67
4 5 77 Medium ... 1 0 2.57

5 rows × 10 columns

Και οι δύο προσεγγίσεις δίνουν ακριβώς τα ίδια αποτελέσματα· είναι απλώς θέμα στυλ. Η πρώτη προσέγγιση τροποποιεί απευθείας το customer_churn, ενώ η assign() επιστρέφει ένα νέο DataFrame με την πρόσθετη στήλη, το οποίο στη συνέχεια εκχωρούμε ξανά στο customer_churn. Η μέθοδος assign() γίνεται ιδιαίτερα χρήσιμη αργότερα, όταν συνδέουμε αλυσιδωτά πολλές πράξεις, επειδή μας επιτρέπει να δημιουργήσουμε μια νέα στήλη ως ένα βήμα μέσα σε μια μεγαλύτερη αλυσίδα, χωρίς να διακόψουμε τη ροή με μια ξεχωριστή εντολή εκχώρησης.

Μπορούμε επίσης να δημιουργήσουμε νέες μεταβλητές συνδυάζοντας πολλές στήλες. Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να υπολογίσουμε τη μέση χρηματική αξία ανά αγορά. Μπορούμε να διαιρέσουμε τη στήλη Monetary_Value με τη στήλη Frequency:

# Δημιουργία της στήλης Average_Monetary_Value
customer_churn["Average_Monetary_Value"] = customer_churn["Monetary_Value"] / customer_churn["Frequency"]

# Εμφάνιση των πρώτων γραμμών
customer_churn[["ID", "Monetary_Value", "Frequency", "Average_Monetary_Value"]].head()
ID Monetary_Value Frequency Average_Monetary_Value
0 1 3009.60 26 115.75
1 2 57347.28 56 1024.06
2 3 14496.16 293 49.47
3 4 1416.20 18 78.68
4 5 523.72 14 37.41

Ουσιαστικά, κάθε τιμή του Monetary_Value διαιρείται με την αντίστοιχη τιμή του Frequency. Επειδή το Pandas εφαρμόζει τις πράξεις στοιχείο προς στοιχείο, ο υπολογισμός εκτελείται αυτόματα γραμμή προς γραμμή σε ολόκληρο το DataFrame.

Επιπλέον, μπορούμε να δημιουργήσουμε μια νέα στήλη με βάση πολλές συνθήκες. Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να κατατάξουμε τους πελάτες ως "Inactive", "Active" ή "Very Active", ανάλογα με το πόσο πρόσφατα έκαναν μια αγορά. Αντί να γράψουμε πολλές εμφωλευμένες συνθήκες με την np.where(), μπορούμε να χρησιμοποιήσουμε μια πιο δομημένη προσέγγιση, παρόμοια με την CASE WHEN της γλώσσας προγραμματισμού SQL, η οποία μπορεί να υλοποιηθεί στο Pandas με την case_when() (διαθέσιμη στο Pandas 2.2 και σε νεότερες εκδόσεις):

# Δημιουργία της στήλης Customer_Status με την case_when
customer_churn["Customer_Status"] = customer_churn["Recency"].case_when([
  (customer_churn["Recency"] > 180, "Inactive"),
  (customer_churn["Recency"].between(90, 180), "Active"),
  (customer_churn["Recency"] < 90, "Very Active")
  ])

# Εμφάνιση των πρώτων γραμμών
customer_churn[["ID", "Recency", "Customer_Status"]].head()
ID Recency Customer_Status
0 1 46 Very Active
1 2 40 Very Active
2 3 35 Very Active
3 4 50 Very Active
4 5 77 Very Active

Στον παραπάνω κώδικα, κάθε συνθήκη αξιολογείται γραμμή προς γραμμή, και η πρώτη συνθήκη που ικανοποιείται καθορίζει την τιμή που εκχωρείται στη νέα στήλη. Αυτό σημαίνει ότι για κάθε πελάτη το Pandas ελέγχει τις συνθήκες με τη σειρά (ξεκινώντας από το "Inactive", μετά το "Active" και τέλος το "Very Active") και, μόλις βρεθεί αντιστοιχία, εκχωρεί την αντίστοιχη ετικέτα. Έτσι, η λογική είναι ταυτόχρονα διαδοχική και διαφανής, και μοιάζει πολύ με τον τρόπο που λειτουργεί μια εντολή CASE WHEN στην SQL. Ως αποτέλεσμα, ο κώδικας είναι πιο ευανάγνωστος και ιδιαίτερα χρήσιμος όταν δουλεύουμε με πολλές κατηγορίες ή με πιο σύνθετους κανόνες κατάταξης.

Εκτός από τη δημιουργία μετασχηματισμένων μεταβλητών, μπορούμε επίσης να δημιουργήσουμε στήλες με βάση τις θέσεις των γραμμών του DataFrame. Η μέθοδος reset_index() δημιουργεί μια νέα στήλη που περιέχει τους αριθμούς των γραμμών (τις τιμές του index):

# Διαγραφή των στηλών που δημιουργήσαμε προηγουμένως
customer_churn = customer_churn.drop(
  columns = ["Recency_Months",
             "Average_Monetary_Value",
             "Customer_Status"]
             )

# Δημιουργία στήλης index
customer_churn.reset_index()
index ID Recency ... Monetary_Value_Level Observation_Period Churn
0 0 1 46 ... Medium 742 0
1 1 2 40 ... High 2301 0
2 2 3 35 ... High 2411 0
3 3 4 50 ... Medium 813 0
4 4 5 77 ... Low 1 0
... ... ... ... ... ... ... ...
3995 3995 3996 189 ... Low 264 1
3996 3996 3997 152 ... Medium 1675 0
3997 3997 3998 359 ... Low 1 1
3998 3998 3999 69 ... Medium 2234 1
3999 3999 4000 31 ... Medium 2392 0

4000 rows × 10 columns

Αυτή η μέθοδος προσθέτει το τρέχον index (ευρετήριο) ως κανονική στήλη στο DataFrame και ταυτόχρονα επαναφέρει το ίδιο το index. Αυτές οι τιμές ήταν ήδη ορατές στην αριστερή πλευρά του DataFrame ως index, αλλά δεν αποτελούσαν μέρος της πραγματικής δομής των δεδομένων. Ουσιαστικά, η reset_index() μετατρέπει αυτό το index σε κανονική στήλη, ώστε να γίνει μια ρητή μεταβλητή του DataFrame και να μπορεί να χρησιμοποιηθεί όπως οποιοδήποτε άλλο χαρακτηριστικό (feature) του συνόλου δεδομένων.

Συνάθροιση αποτελεσμάτων:
Τα συναθροισμένα δεδομένα (aggregated data) είναι συνόψεις των ακατέργαστων δεδομένων μας. Για παράδειγμα, πόσοι πελάτες υπάρχουν σε κάθε κατηγορία του επιπέδου recency; Ή ποια είναι η μέση τιμή του recency για τους πελάτες που αποχωρούν σε σύγκριση με τους πελάτες που δεν αποχωρούν; Ουσιαστικά, «συνοψίζουμε» τα αποτελέσματά μας, χάνοντας ορισμένες πληροφορίες για τις μεμονωμένες περιπτώσεις, ώστε να μπορούμε να εξαγάγουμε χρήσιμα συμπεράσματα για το σύνολο.

Ο απλούστερος τρόπος για να συνοψίσουμε μια μεταβλητή είναι να εφαρμόσουμε μια μέθοδο συνάθροισης (aggregation) αμέσως μετά την επιλογή μιας στήλης. Για παράδειγμα, μπορούμε να υπολογίσουμε τη μέση τιμή της μεταβλητής Frequency με τη μέθοδο mean():

# Υπολογισμός της μέσης τιμής του frequency
customer_churn["Frequency"].mean()
np.float64(37.8235)
# Υπολογισμός της μέσης τιμής του frequency διατηρώντας τη δομή του DataFrame
customer_churn[["Frequency"]].mean()
Frequency    37.82
dtype: float64

Και οι δύο προσεγγίσεις υπολογίζουν την ίδια μέση τιμή. Ωστόσο, η πρώτη έκφραση επιστρέφει ένα μεμονωμένο αριθμητικό αποτέλεσμα, επειδή η στήλη που επιλέγεται αντιμετωπίζεται ως Series του Pandas. Η δεύτερη έκφραση εφαρμόζεται σε ένα DataFrame και επομένως επιστρέφει ένα Series του Pandas, στο οποίο το όνομα της στήλης εμφανίζεται δίπλα στο αντίστοιχο mean. Στην πράξη, η πρώτη προσέγγιση είναι συχνά πιο απλή όταν δουλεύουμε με μία μεταβλητή, ενώ η δεύτερη γίνεται χρήσιμη όταν συνδυάζουμε πολλές συναθροίσεις ή όταν δουλεύουμε σταθερά με objects τύπου DataFrame.

Ένας πιο προχωρημένος τρόπος συνάθροισης δεδομένων είναι η σύνοψή τους ανά ομάδα. Στο Pandas, αυτό γίνεται με τη μέθοδο groupby(), μέσα στην οποία δίνουμε μία ή περισσότερες μεταβλητές που ορίζουν τις ομάδες που θέλουμε να δημιουργήσουμε.

Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να υπολογίσουμε τη μέση χρηματική αξία για κάθε συνδυασμό των Recency_Level και Frequency_Level. Σε αυτή την περίπτωση, το Pandas πρώτα χωρίζει τα δεδομένα σε ομάδες με βάση αυτές τις κατηγορίες και στη συνέχεια εφαρμόζει τον επιλεγμένο υπολογισμό σε κάθε ομάδα ξεχωριστά:

# Υπολογισμός της μέσης χρηματικής αξίας ανά ομάδα
customer_churn.groupby(["Recency_Level", "Frequency_Level"])["Monetary_Value"].mean()
Recency_Level  Frequency_Level
High           High               32589.66
               Low                 3191.59
               Medium             21914.37
Low            High               37084.83
               Low                 6261.37
               Medium             23735.66
Medium         High               51118.21
               Low                 4897.72
               Medium             20290.33
Name: Monetary_Value, dtype: float64

Εδώ, το DataFrame ομαδοποιείται σύμφωνα με όλους τους συνδυασμούς των Recency_Level και Frequency_Level, και η μέθοδος mean() εφαρμόζεται στη στήλη Monetary_Value μέσα σε κάθε ομάδα.

Η έξοδος που προκύπτει δεν είναι ένα κανονικό DataFrame, αλλά ένα Series του Pandas με ιεραρχικό index (που ονομάζεται επίσης MultiIndex). Οι μεταβλητές ομαδοποίησης (Recency_Level και Frequency_Level) γίνονται τα επίπεδα του index, ενώ τα means που υπολογίστηκαν αποθηκεύονται ως οι τιμές του Series. Αυτή η δομή είναι χρήσιμη για πολλές αναλυτικές εργασίες, αλλά μερικές φορές μπορεί να είναι λιγότερο βολική για περαιτέρω επεξεργασία δεδομένων, φιλτράρισμα ή εξαγωγή αποτελεσμάτων.

Για να μετατρέψουμε την έξοδο σε ένα τυπικό DataFrame με κανονικές στήλες, μπορούμε να χρησιμοποιήσουμε τη μέθοδο reset_index(). Αυτή μεταφέρει τις μεταβλητές ομαδοποίησης από το index πίσω σε κανονικές στήλες και επιστρέφει μια καθαρή δομή πίνακα:

# Υπολογισμός της μέσης χρηματικής αξίας ανά ομάδα
customer_churn.groupby(["Recency_Level", "Frequency_Level"])["Monetary_Value"].mean().reset_index()
Recency_Level Frequency_Level Monetary_Value
0 High High 32589.66
1 High Low 3191.59
2 High Medium 21914.37
3 Low High 37084.83
4 Low Low 6261.37
5 Low Medium 23735.66
6 Medium High 51118.21
7 Medium Low 4897.72
8 Medium Medium 20290.33

Επιπλέον, η μέθοδος agg() μπορεί να χρησιμοποιηθεί όταν θέλουμε να εφαρμόσουμε έναν ή περισσότερους υπολογισμούς συνάθροισης στα ομαδοποιημένα δεδομένα. Ας προσθέσουμε τον υπολογισμό του median μαζί με το mean:

# Υπολογισμός του mean και του median της χρηματικής αξίας ανά ομάδα
customer_churn.groupby(["Recency_Level", "Frequency_Level"])["Monetary_Value"].agg(["mean", "median"])
mean median
Recency_Level Frequency_Level
High High 32589.66 38336.25
Low 3191.59 1716.67
Medium 21914.37 19691.79
Low High 37084.83 37121.19
Low 6261.37 4666.78
Medium 23735.66 17398.98
Medium High 51118.21 61814.51
Low 4897.72 3476.98
Medium 20290.33 15396.38

Καταμέτρηση τιμών:
Παρόλο που μόλις είδαμε πώς να κάνουμε υπολογισμούς όπως μέσες τιμές και medians ανά ομάδα, μία από τις πιο συνηθισμένες και απλές εργασίες συνάθροισης είναι απλώς η καταμέτρηση των παρατηρήσεων σε κάθε κατηγορία. Στο Pandas, αυτό μπορεί να γίνει με τη μέθοδο value_counts():

# Καταμέτρηση παρατηρήσεων ανά κατηγορία
customer_churn["Recency_Level"].value_counts(sort = True)
Recency_Level
Low       1877
High      1160
Medium     963
Name: count, dtype: int64

Αυτή η μέθοδος μετρά πόσες φορές εμφανίζεται κάθε κατηγορία στη στήλη που επιλέξαμε. Από προεπιλογή, το όρισμα sort = True ταξινομεί τις κατηγορίες από τη συχνότερη στη σπανιότερη.

Σε πολλές περιπτώσεις, οι απόλυτες συχνότητες είναι χρήσιμες, αλλά οι αναλογίες μπορεί να είναι ακόμη πιο κατατοπιστικές. Γι’ αυτόν τον λόγο, η value_counts() περιλαμβάνει επίσης το όρισμα normalize, το οποίο, όταν οριστεί σε True, μετατρέπει τις απόλυτες συχνότητες σε σχετικές συχνότητες (αναλογίες).

# Καταμέτρηση παρατηρήσεων ανά κατηγορία
customer_churn["Recency_Level"].value_counts(sort = True, normalize = True)
Recency_Level
Low       0.47
High      0.29
Medium    0.24
Name: proportion, dtype: float64

Επειδή ορίσαμε το όρισμα normalize ίσο με True, οι απόλυτες συχνότητες διαιρούνται με το συνολικό πλήθος των παρατηρήσεων. Ως αποτέλεσμα, η έξοδος αναπαριστά αναλογίες αντί για απλές μετρήσεις. Για παράδειγμα, η τιμή 0.47 για την κατηγορία Low σημαίνει ότι το 47% των παρατηρήσεων ανήκει σε αυτή την κατηγορία. Αυτό είναι ιδιαίτερα χρήσιμο όταν συγκρίνουμε κατανομές κατηγοριών μεταξύ συνόλων δεδομένων διαφορετικού μεγέθους ή όταν ερμηνεύουμε αποτελέσματα σε ποσοστιαίους όρους.

Pivot tables:
Τα pivot tables (συγκεντρωτικοί πίνακες) προσφέρουν έναν εξαιρετικό τρόπο συνάθροισης δεδομένων σε δομημένη και ιδιαίτερα ευέλικτη μορφή. Παρόλο που έχουμε ήδη δει πώς να υπολογίζουμε συνόψεις με μεθόδους όπως η groupby() και η agg(), τα pivot tables προσφέρουν μια πιο διαισθητική εναλλακτική, παρόμοια με τα υπολογιστικά φύλλα, για τη δημιουργία συνόψεων ανά ομάδα. Είναι ιδιαίτερα χρήσιμα όταν θέλουμε να αναδιοργανώσουμε τα δεδομένα σε μια σαφή δομή πίνακα, με τις ομάδες να εμφανίζονται ως γραμμές (και προαιρετικά ως στήλες), ώστε τα αποτελέσματα να ερμηνεύονται και να συγκρίνονται πιο εύκολα.

Για να δημιουργήσουμε ένα pivot table στο Pandas, χρησιμοποιούμε τη μέθοδο pivot_table(). Τα τρία κύρια ορίσματα είναι τα index, values και aggfunc.

  • Το index ορίζει τη μεταβλητή που καθορίζει τις γραμμές του pivot table.

  • Το values ορίζει τη μεταβλητή που θα συνοψιστεί.

  • Το aggfunc ορίζει τη συνάρτηση συνάθροισης που εφαρμόζεται στις επιλεγμένες τιμές, όπως "mean", "sum" ή "count".

Για παράδειγμα, ο παρακάτω κώδικας υπολογίζει τη μέση τιμή του recency για κάθε κατηγορία του Recency_Level:

# Υπολογισμός της μέσης τιμής του Recency ανά Recency_Level
customer_churn.pivot_table(index = "Recency_Level",
                           values = "Recency",
                           aggfunc = "mean")
Recency
Recency_Level
High 232.08
Low 38.56
Medium 69.20

Εδώ, οι παρατηρήσεις ομαδοποιούνται σύμφωνα με το Recency_Level, και το mean της μεταβλητής Recency υπολογίζεται μέσα σε κάθε ομάδα.

Τα pivot tables γίνονται ακόμη πιο χρήσιμα όταν προσθέσουμε το όρισμα columns. Αυτό μας επιτρέπει να δημιουργήσουμε συνόψεις σε δύο διαστάσεις ομαδοποίησης ταυτόχρονα, παράγοντας έναν πίνακα που μοιάζει με μήτρα. Για παράδειγμα, ο παρακάτω κώδικας υπολογίζει τη μέση τιμή του recency για κάθε συνδυασμό των Recency_Level και Frequency_Level:

# Υπολογισμός της μέσης τιμής του Recency ανά Recency_Level και Frequency_Level
customer_churn.pivot_table(index = "Recency_Level",
                           columns = "Frequency_Level",
                           values = "Recency",
                           aggfunc = "mean")
Frequency_Level High Low Medium
Recency_Level
High 216.67 233.06 191.35
Low 34.63 39.20 37.66
Medium 60.50 69.76 63.29

Σε αυτή την περίπτωση, οι γραμμές ορίζονται από το Recency_Level, οι στήλες ορίζονται από το Frequency_Level και οι τιμές είναι οι μέσες τιμές του Recency.

Τέλος, έχουμε επίσης τη δυνατότητα να προσθέσουμε το όρισμα margins = True, το οποίο προσθέτει στο pivot table συνολικές τιμές:

# Προσθήκη συνολικών τιμών (margins)
customer_churn.pivot_table(index = "Recency_Level",
                           columns = "Frequency_Level",
                           values = "Recency",
                           aggfunc = "mean",
                           margins = True)
Frequency_Level High Low Medium All
Recency_Level
High 216.67 233.06 191.35 232.08
Low 34.63 39.20 37.66 38.56
Medium 60.50 69.76 63.29 69.20
All 40.70 113.69 47.86 102.06

Η πρόσθετη γραμμή και η πρόσθετη στήλη με την ετικέτα All περιέχουν συναθροισμένα αποτελέσματα για όλες τις ομάδες, δίνοντας μια συνολική εικόνα δίπλα στα στατιστικά ανά ομάδα.

Μετατροπή σε και από DataFrame:
Πριν ολοκληρώσουμε αυτό το κεφάλαιο, είναι σημαντικό να τονίσουμε ότι το Pandas προσφέρει μεγάλη ευελιξία στη μετατροπή μεταξύ διαφορετικών δομών δεδομένων. Για παράδειγμα, τα objects του Pandas μπορούν να μετατραπούν σε NumPy arrays και αντίστροφα. Επιπλέον, το Pandas μπορεί να δημιουργήσει DataFrames από δομές όπως lists, dictionaries, tuples και NumPy arrays.

Για να μετατρέψουμε ένα DataFrame του Pandas σε NumPy array, μπορούμε να χρησιμοποιήσουμε τη μέθοδο to_numpy(). Αν εφαρμόσουμε αυτή τη μέθοδο στο DataFrame customer_churn, δημιουργείται ένα μεγάλο NumPy array σε μορφή μήτρας, με 4,000 γραμμές και 9 στήλες.

Ένας σημαντικός περιορισμός, ωστόσο, είναι ότι τα ονόματα των στηλών δεν διατηρούνται στο array που προκύπτει, επειδή τα NumPy arrays αποθηκεύουν μόνο τις τιμές. Γι’ αυτόν τον λόγο, είναι συχνά χρήσιμο να αποθηκεύουμε ξεχωριστά τα ονόματα των στηλών με το attribute columns:

# Μετατροπή του DataFrame σε numpy array
customer_churn_in_numpy_array = customer_churn.to_numpy()

# Εμφάνιση του customer_churn_in_numpy_array
customer_churn_in_numpy_array
array([[1, 46, 'Low', ..., 'Medium', 742, 0],
       [2, 40, 'Low', ..., 'High', 2301, 0],
       [3, 35, 'Low', ..., 'High', 2411, 0],
       ...,
       [3998, 359, 'High', ..., 'Low', 1, 1],
       [3999, 69, 'Medium', ..., 'Medium', 2234, 1],
       [4000, 31, 'Low', ..., 'Medium', 2392, 0]],
      shape=(4000, 9), dtype=object)
# Εξαγωγή των ονομάτων των στηλών
customer_churn_column_names = customer_churn.columns

# Εμφάνιση του customer_churn_column_names
customer_churn_column_names
Index(['ID', 'Recency', 'Recency_Level', 'Frequency',
       'Frequency_Level', 'Monetary_Value',
       'Monetary_Value_Level', 'Observation_Period', 'Churn'],
      dtype='object')

Μέθοδοι και attributes

Ορισμένες πράξεις του Pandas (π.χ. η describe()) απαιτούν παρενθέσεις, ενώ άλλες (π.χ. το columns) όχι. Ο λόγος είναι ότι οι μέθοδοι εκτελούν μια ενέργεια ή έναν υπολογισμό και επομένως χρειάζονται παρενθέσεις για να εκτελεστούν. Αντίθετα, το columns είναι ένα attribute (ιδιότητα), δηλαδή απλώς αποθηκεύει πληροφορίες για το object και μπορούμε να έχουμε πρόσβαση σε αυτό απευθείας, χωρίς παρενθέσεις.

Για να μετατρέψουμε ένα NumPy array, μια list, ένα dictionary ή άλλες συμβατές δομές δεδομένων σε DataFrame του Pandas, χρησιμοποιούμε τη συνάρτηση DataFrame() του package Pandas. Αυτή η συνάρτηση δημιουργεί ένα object σε μορφή πίνακα, με γραμμές και στήλες, το οποίο μπορούμε στη συνέχεια να επεξεργαστούμε με τις πράξεις του Pandas.

Για να δείξουμε αυτή την ιδέα, μπορούμε να μετατρέψουμε το object customer_churn_in_numpy_array ξανά σε DataFrame:

# Μετατροπή του numpy array ξανά σε DataFrame
customer_churn_in_pandas = pd.DataFrame(customer_churn_in_numpy_array)

# Εμφάνιση των πρώτων γραμμών
customer_churn_in_pandas.head()
0 1 2 ... 6 7 8
0 1 46 Low ... Medium 742 0
1 2 40 Low ... High 2301 0
2 3 35 Low ... High 2411 0
3 4 50 Low ... Medium 813 0
4 5 77 Medium ... Low 1 0

5 rows × 9 columns

Παρατηρούμε ότι τα ονόματα των στηλών είναι πλέον διαφορετικά. Επειδή τα NumPy arrays αποθηκεύουν μόνο τις ακατέργαστες τιμές, τα αρχικά ονόματα των στηλών χάθηκαν κατά τη διαδικασία της μετατροπής. Ως αποτέλεσμα, το Pandas εκχωρεί αυτόματα ακέραιες ετικέτες στηλών, όπως 0, 1, 2 κ.ο.κ.

Για να επαναφέρουμε τα αρχικά ονόματα των μεταβλητών, μπορούμε να χρησιμοποιήσουμε το όρισμα columns και να περάσουμε το object που περιέχει τα αποθηκευμένα ονόματα των στηλών:

# Επαναφορά των αρχικών ονομάτων των στηλών
customer_churn_in_pandas = pd.DataFrame(
  customer_churn_in_numpy_array,
  columns = customer_churn_column_names
  )

# Εμφάνιση των πρώτων γραμμών
customer_churn_in_pandas.head()
ID Recency Recency_Level ... Monetary_Value_Level Observation_Period Churn
0 1 46 Low ... Medium 742 0
1 2 40 Low ... High 2301 0
2 3 35 Low ... High 2411 0
3 4 50 Low ... Medium 813 0
4 5 77 Medium ... Low 1 0

5 rows × 9 columns

Με αυτόν τον τρόπο, αναδημιουργούμε την αρχική δομή του DataFrame, διατηρώντας τα ονόματα των μεταβλητών από το αρχικό σύνολο δεδομένων.

Όπως αναφέραμε, είναι επίσης δυνατό να δημιουργήσουμε ένα DataFrame από ένα dictionary. Μάλιστα, η μετατροπή ενός dictionary σε DataFrame είναι πολύ συνηθισμένη στην πράξη, καθώς η δομή του αντιστοιχεί με φυσικό τρόπο σε αυτήν ενός DataFrame: τα κλειδιά αντιστοιχούν στα ονόματα των στηλών, ενώ οι τιμές αντιστοιχούν στις τιμές των στηλών. Υπό αυτή την έννοια, τα dictionaries προσφέρουν έναν πολύ διαισθητικό τρόπο δημιουργίας δεδομένων σε μορφή πίνακα στην Python. Επιπλέον, η list τιμών κάθε κλειδιού πρέπει να περιέχει τον ίδιο αριθμό στοιχείων, κάτι που συμφωνεί με τη θεμελιώδη απαίτηση ενός DataFrame, όπου όλες οι στήλες πρέπει να έχουν το ίδιο μήκος.

Για να δείξουμε αυτή την ιδέα, μπορούμε να χρησιμοποιήσουμε το εξής παράδειγμα:

# Δημιουργία dictionary
customer_dict = {
  "Recency": [46, 40, 35, 50, 55],
  "Frequency_Level": ["Low", "Medium", "High", "Low", "Low"],
  "Monetary_Value": [3009.6000, 57347.2800, 14496.1575, 1416.2000, 8830.3200]
  }

# Μετατροπή του dictionary σε pandas DataFrame
customer_df = pd.DataFrame(customer_dict)

# Εμφάνιση των πρώτων γραμμών
customer_df.head()
Recency Frequency_Level Monetary_Value
0 46 Low 3009.60
1 40 Medium 57347.28
2 35 High 14496.16
3 50 Low 1416.20
4 55 Low 8830.32

Σε αυτό το παράδειγμα, κάθε κλειδί του dictionary αντιστοιχεί σε μια στήλη του DataFrame που προκύπτει, και οι αντίστοιχες lists γίνονται οι τιμές των στηλών. Επειδή όλες οι lists περιέχουν τον ίδιο αριθμό στοιχείων, το Pandas μπορεί να τις ευθυγραμμίσει γραμμή προς γραμμή, ώστε να δημιουργήσει σωστά το DataFrame.