Συχνή Χρήση της Python στην Επιστήμη Δεδομένων (Βασικά)

7 Νοεμβρίου 2018 #Python

Τις τελευταίες μέρες, διάβαζα το βιβλίο Data Science from Scrach (Διεύθυνση PDF), το οποίο είναι ένα εξαιρετικό, κατανοητό εισαγωγικό εγχειρίδιο στην επιστήμη δεδομένων. Ένα από τα κεφάλαιά του παρουσιάζει τη βασική σύνταξη της Python και τις προχωρημένες δομές που χρησιμοποιούνται συχνά στην επιστήμη δεδομένων. Βρήκα την παρουσίαση πολύ καλή, περιεκτική και σαφή, γι’ αυτό και τη μεταφράζω εδώ ως σημειώσεις για μελλοντική αναφορά.
Βασική σύνταξη Python στην επιστήμη δεδομένων
Προχωρημένη σύνταξη Python στην επιστήμη δεδομένων

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

Μορφοποίηση με κενά

Ενώ πολλές γλώσσες χρησιμοποιούν αγκύλες για τον έλεγχο των μπλοκ κώδικα, η Python βασίζεται στην εσοχή (indentation):

for i in [1, 2, 3, 4, 5]:  
    print i          # Η πρώτη γραμμή του βρόχου "for i"  
    for j in [1, 2, 3, 4, 5]:  
        print j      # Η πρώτη γραμμή του βρόχου "for j"  
        print i + j  # Η τελευταία γραμμή του βρόχου "for j"  
    print i          # Η τελευταία γραμμή του βρόχου "for i"  
print "done looping"

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

long_winded_computation = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20)

και κάνει τον κώδικα πιο ευανάγνωστο:

list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  
easier_to_read_list_of_lists = [ [1, 2, 3],  
                                 [4 ,5 ,6 ],  
                                 [7 ,8 ,9 ] ]

Πολύγραμμες εντολές

Μπορείτε να χρησιμοποιήσετε μια ανάστροφη κάθετο για να ενώσετε δύο γραμμές (πρόκειται για μια πρακτική που χρησιμοποιείται σπάνια):

two_plus_three = 2 + \
                 3

Μονάδες (Modules)

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

Απλή, άμεση εισαγωγή ολόκληρης της μονάδας:

import re  
my_regex = re.compile("[0-9]+", re.I)

Η μονάδα re που εισάγεται εδώ χρησιμοποιείται για κανονικές εκφράσεις (regular expressions). Μετά την εισαγωγή της, μπορείτε να καλέσετε τις συγκεκριμένες λειτουργίες της χρησιμοποιώντας το όνομα της μονάδας ως πρόθεμα (π.χ. re.).

Εάν το όνομα της μονάδας που θέλετε να εισάγετε χρησιμοποιείται ήδη στον κώδικά σας, μπορείτε να την εισάγετε με διαφορετικό όνομα (alias):

import re as regex  
my_regex = regex.compile("[0-9]+", regex.I)

Εάν είστε «κακός» προγραμματιστής, μπορείτε να εισάγετε ολόκληρη τη μονάδα στον τρέχοντα χώρο ονομάτων, κάτι που μπορεί να οδηγήσει σε ακούσια αντικατάσταση μεταβλητών που έχετε ήδη ορίσει:

match = 10  
from re import *  # Η μονάδα re περιέχει μια συνάρτηση match  
print match       # Εκτυπώνει τη συνάρτηση match

Επειδή όμως είστε καλοί άνθρωποι, είμαι σίγουρος ότι δεν θα το κάνετε.

Αριθμητικές πράξεις

Η Python 2.7 χρησιμοποιεί εξ ορισμού ακέραια διαίρεση, επομένως $ 5 / 2 = 2 $. Ωστόσο, συχνά δεν θέλουμε ακέραια διαίρεση, οπότε μπορούμε να εισάγουμε την ακόλουθη μονάδα:

from __future__ import division

Μετά την εισαγωγή, έχουμε $5 / 2 = 2.5$.
Η ακέραια διαίρεση παραμένει $5 // 2 = 2$.

Συναρτήσεις

Ορισμός συναρτήσεων

Μια συνάρτηση είναι ένας κανόνας που μπορεί να δεχτεί μηδέν ή περισσότερες εισόδους και να επιστρέψει μια συγκεκριμένη έξοδο. Στην Python, ορίζουμε μια συνάρτηση χρησιμοποιώντας def όνομα_συνάρτησης(παράμετροι):

def double(x):  
    """Εδώ μπορείτε να γράψετε μια επεξήγηση για τη λειτουργία της συνάρτησης,  
    π.χ. ότι πολλαπλασιάζει την είσοδο επί 2."""  
    # Εδώ γράφεται το σώμα της συνάρτησης, θυμηθείτε την εσοχή.  
    return x * 2

Χρήση συναρτήσεων

Στην Python, οι συναρτήσεις είναι ‘first-class citizens’, πράγμα που σημαίνει ότι μπορούμε να αναθέσουμε μια συνάρτηση σε μια μεταβλητή ή να την περάσουμε ως όρισμα σε άλλες συναρτήσεις:

def apply_to_one(f):  
    """Καλεί τη συνάρτηση f και περνάει το 1 ως όρισμα"""  
    return f(1)  
my_double = double          # το `double` αναφέρεται στη συνάρτηση που ορίστηκε στην προηγούμενη ενότητα  
x = apply_to_one(my_double) # το `x` είναι ίσο με 2

Ανώνυμες συναρτήσεις

Μπορούμε επίσης να δημιουργήσουμε ανώνυμες συναρτήσεις χρησιμοποιώντας το lambda:

y = apply_to_one(lambda x: x + 4)     # είναι ίσο με 5

Μπορείτε να αναθέσετε μια έκφραση lambda σε μια μεταβλητή, αλλά οι περισσότεροι θα σας συμβουλεύσουν να χρησιμοποιείτε το def όπου είναι δυνατόν:

another_double = lambda x: 2 * x      # Δεν συνιστάται  
def another_double(x): return 2 * x   # Συνιστώμενη πρακτική

Σημείωση:

Το lambda είναι απλώς μια έκφραση, και το σώμα της συνάρτησης είναι πολύ πιο απλό από αυτό μιας συνάρτησης def.
Το σώμα μιας lambda είναι μια έκφραση, όχι ένα μπλοκ κώδικα. Μπορεί να ενσωματώσει μόνο περιορισμένη λογική.

Πέρασμα παραμέτρων σε συναρτήσεις

Οι παράμετροι συναρτήσεων μπορούν να οριστούν με προεπιλεγμένες τιμές. Αν δεν παρασχεθούν παράμετροι κατά την κλήση της συνάρτησης, θα χρησιμοποιηθούν οι προεπιλεγμένες τιμές. Αν παρασχεθούν, θα χρησιμοποιηθούν οι καθορισμένες τιμές:

def my_print(message="my default message"):  
    print message  
my_print("hello")     # Εκτυπώνει "hello"  
my_print()            # Εκτυπώνει "my default message"

Μερικές φορές είναι επίσης χρήσιμο να καθορίζετε τις παραμέτρους απευθείας με το όνομά τους:

def subtract(a=0, b=0):  
    return a - b  
subtract(10, 5)   # Επιστρέφει 5  
subtract(0, 5)    # Επιστρέφει -5  
subtract(b=5)     # Το ίδιο με το προηγούμενο, επιστρέφει -5

Συμβολοσειρές (Strings)

Μπορείτε να χρησιμοποιήσετε μονά ή διπλά εισαγωγικά για να δημιουργήσετε συμβολοσειρές (τα εισαγωγικά πρέπει να είναι ζευγάρια):

single_quoted_string = 'data science'  
double_quoted_string = "data science"

Χρησιμοποιήστε την ανάστροφη κάθετο για χαρακτήρες διαφυγής, όπως:

tab_string = "\t"      # Αντιπροσωπεύει έναν χαρακτήρα tab  
len(tab_string)        # Είναι ίσο με 1

Όταν θέλετε να χρησιμοποιήσετε την ανάστροφη κάθετο ως έχει (π.χ. για διαδρομές Windows ή κανονικές εκφράσεις), μπορείτε να το ορίσετε χρησιμοποιώντας μια ακατέργαστη συμβολοσειρά r"":

not_tab_string = r"\t" # Αντιπροσωπεύει τους χαρακτήρες '\' και 't'  
len(not_tab_string)    # Είναι ίσο με 2

Χρησιμοποιήστε τρία διπλά εισαγωγικά για να δημιουργήσετε πολυγραμμικές συμβολοσειρές:

multi_line_string = """Αυτή είναι η πρώτη γραμμή  
Αυτή είναι η δεύτερη γραμμή  
Αυτή είναι η τρίτη γραμμή"""

Χειρισμός Εξαιρέσεων (Exceptions)

Όταν ένα πρόγραμμα αντιμετωπίζει σφάλμα, η Python δημιουργεί μια εξαίρεση (exception). Εάν δεν την χειριστούμε, το πρόγραμμα θα τερματιστεί. Μπορούμε να συλλάβουμε εξαιρέσεις χρησιμοποιώντας τις εντολές try και except:

try:  
    print 0 / 0  
except ZeroDivisionError:  
    print "Δεν γίνεται διαίρεση με το 0"

Ενώ σε άλλες γλώσσες οι εξαιρέσεις μπορεί να θεωρούνται ανεπιθύμητες, στην Python, ο συχνότερος χειρισμός εξαιρέσεων μπορεί να κάνει τον κώδικά σας πιο καθαρό και κομψό.

Λίστες (Lists)

Δημιουργία λιστών

Οι λίστες είναι απλές, ταξινομημένες συλλογές και αποτελούν την πιο βασική δομή δεδομένων στην Python (παρόμοιες με τους πίνακες σε άλλες γλώσσες, αλλά με ορισμένες επιπλέον ιδιότητες). Για να δημιουργήσετε μια λίστα:

integer_list = [1, 2, 3]  
heterogeneous_list = ["string", 0.1, True]  
list_of_lists = [ integer_list, heterogeneous_list, [] ]  
list_length = len(integer_list)   # Είναι ίσο με 3  
list_sum = sum(integer_list)      # Είναι ίσο με 6

Πρόσβαση σε τιμές λίστας

Μπορείτε να προσπελάσετε τις τιμές μιας λίστας χρησιμοποιώντας δείκτες σε αγκύλες:

x = range(10)       # Η λίστα `x` γίνεται `x = [0, 1, ..., 9]`  
zero = x[0]         # Είναι ίσο με 0, οι δείκτες λίστας ξεκινούν από το 0  
one = x[1]          # Είναι ίσο με 1  
nine = x[-1]        # Είναι ίσο με 9, το τελευταίο στοιχείο της λίστας  
eight = x[-2]       # Είναι ίσο με 8, το δεύτερο προς το τέλος στοιχείο της λίστας  
x[0] = -1           # Η τρέχουσα λίστα `x` είναι `[-1, 1, 2, 3, ..., 9]`

Τμηματική επιλογή λιστών (Slicing)

Μπορείτε να επιλέξετε τμήματα της λίστας χρησιμοποιώντας αγκύλες:

first_three = x[:3]                  # [-1, 1, 2]  
three_to_end = x[3:]                 # [3, 4, ..., 9]  
one_to_four = x[1:5]                 # [1, 2, 3, 4]  
last_three = x[-3:]                  # [7, 8, 9]  
without_first_and_last = x[1:-1]     # [1, 2, ..., 8]  
copy_of_x = x[:]                     # [-1, 1, 2, ..., 9]

Μπορείτε να χρησιμοποιήσετε το in για να ελέγξετε αν ένα στοιχείο υπάρχει σε μια λίστα:

1 in [1, 2, 3]        # True  
0 in [1, 2, 3]        # False

Αυτός ο τρόπος αναζήτησης στοιχείων είναι αναποτελεσματικός. Θα πρέπει να τον χρησιμοποιείτε μόνο όταν η λίστα είναι μικρή ή όταν δεν σας ενδιαφέρει ο χρόνος αναζήτησης.

Συγχώνευση λιστών

Στην Python, είναι πολύ εύκολο να συγχωνεύσετε δύο λίστες:

x = [1, 2, 3]  
x.extend([4, 5, 6])   # Το `x` είναι τώρα `[1,2,3,4,5,6]`

Αν δεν θέλετε να τροποποιήσετε την αρχική λίστα x, μπορείτε να χρησιμοποιήσετε τον τελεστή πρόσθεσης για να δημιουργήσετε μια νέα λίστα:

x = [1, 2, 3]  
y = x + [4, 5, 6]     # Το `y` είναι τώρα `[1, 2, 3, 4, 5, 6]`; το `x` παραμένει αμετάβλητο

Συχνά προσθέτουμε ένα στοιχείο σε μια λίστα με τον εξής τρόπο:

x = [1, 2, 3]  
x.append(0)           # Το `x` είναι τώρα `[1, 2, 3, 0]`  
y = x[-1]             # Είναι ίσο με 0  
z = len(x)            # Είναι ίσο με 4

Αποδόμηση λιστών (List Unpacking)

Εάν γνωρίζετε πόσα στοιχεία υπάρχουν σε μια λίστα, μπορείτε εύκολα να την αποδομήσετε (unpack):

x, y = [1, 2]         # Το `x` είναι τώρα 1, το `y` είναι 2

Εάν ο αριθμός των στοιχείων στις δύο πλευρές της ανάθεσης δεν ταιριάζει, θα λάβετε ένα ValueError. Γι’ αυτό, συχνά χρησιμοποιούμε την υπογράμμιση για να αποθηκεύσουμε τα υπόλοιπα στοιχεία της λίστας:

_, y = [1, 2]         # Το `y` είναι ίσο με 2, αγνοώντας το πρώτο στοιχείο

Δέσμες (Tuples)

Οι λίστες και οι δέσμες είναι πολύ παρόμοιες. Η μόνη διαφορά είναι ότι τα στοιχεία σε μια δέσμη δεν μπορούν να τροποποιηθούν.

Δημιουργία δεσμών

Μπορείτε να δημιουργήσετε δέσμες χρησιμοποιώντας παρενθέσεις ή χωρίς καθόλου παρενθέσεις:

my_tuple = (1, 2)  
other_tuple = 3, 4  
my_list[1] = 3        # Το `my_list` είναι τώρα `[1, 3]`  
try:  
    my_tuple[1] = 3  
except TypeError:  
    print "Δεν είναι δυνατή η τροποποίηση της δέσμης"

Οι δέσμες είναι πολύ χρήσιμες για την επιστροφή πολλαπλών τιμών από μια συνάρτηση:

def sum_and_product(x, y):  
    return (x + y),(x * y)  
sp = sum_and_product(2, 3)    # Είναι ίσο με (5, 6)  
s, p = sum_and_product(5, 10) # Το `s` είναι 15, το `p` είναι 50

Οι δέσμες (και οι λίστες) υποστηρίζουν την ταυτόχρονη ανάθεση πολλαπλών στοιχείων:

x, y = 1, 2       # Το `x` είναι τώρα 1, το `y` είναι 2  
x, y = y, x       # Ανταλλαγή τιμών δύο μεταβλητών στην Python. Το `x` είναι τώρα 2, το `y` είναι 1

Λεξικά (Dictionaries)

Δημιουργία λεξικών

Μια άλλη βασική δομή δεδομένων στην Python είναι το λεξικό, το οποίο σας επιτρέπει να ανακτάτε γρήγορα μια τιμή (value) χρησιμοποιώντας ένα κλειδί (key):

empty_dict = {}                       # Πολύ «Pythonic» ορισμός κενού λεξικού  
empty_dict2 = dict()                  # Λιγότερο «Pythonic» ορισμός κενού λεξικού  
grades = { "Joel" : 80, "Tim" : 95 }  # Αποθήκευση λεξικού

Αναζήτηση στοιχείων λεξικού

Μπορείτε να χρησιμοποιήσετε αγκύλες με ένα κλειδί για να αναζητήσετε την αντίστοιχη τιμή:

joels_grade = grades["Joel"]          # Είναι ίσο με 80

Εάν το κλειδί που αναζητάτε δεν υπάρχει στο λεξικό, θα επιστραφεί ένα KeyError:

try:  
    kates_grade = grades["Kate"]  
except KeyError:  
    print "κανένας βαθμός για την Kate!"

Μπορείτε να χρησιμοποιήσετε το in για να ελέγξετε αν ένα κλειδί υπάρχει στο λεξικό:

joel_has_grade = "Joel" in grades     # True  
kate_has_grade = "Kate" in grades     # False

Τα λεξικά διαθέτουν μια μέθοδο που μπορεί να επιστρέψει μια προεπιλεγμένη τιμή όταν το κλειδί που αναζητείται δεν υπάρχει στο λεξικό (αντί να δημιουργήσει μια εξαίρεση):

joels_grade = grades.get("Joel", 0)   # Είναι ίσο με 80  
kates_grade = grades.get("Kate", 0)   # Είναι ίσο με 0  
no_ones_grade = grades.get("No One")  # Επιστρέφει την προεπιλεγμένη τιμή `None`

Τροποποίηση λεξικών

Μπορείτε να χρησιμοποιήσετε αγκύλες για να δημιουργήσετε ή να τροποποιήσετε ζεύγη κλειδιών-τιμών σε ένα λεξικό:

grades["Tim"] = 99                    # Αντικαθιστά την παλιά τιμή  
grades["Kate"] = 100                  # Προσθέτει ένα ζεύγος κλειδί-τιμή  
num_students = len(grades)            # Είναι ίσο με 3

Συχνά χρησιμοποιούμε λεξικά με αυτόν τον τρόπο για να εκφράσουμε τη δομή των δεδομένων:

tweet = {  
    "user" : "joelgrus",  
    "text" : "Data Science is Awesome",  
    "retweet_count" : 100,  
    "hashtags" : ["#data", "#science", "#datascience", "#awesome", "#yolo"]  
}

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

tweet_keys = tweet.keys()             # Λαμβάνουμε μια λίστα κλειδιών  
tweet_values = tweet.values()         # Λαμβάνουμε μια λίστα τιμών  
tweet_items = tweet.items()           # Λαμβάνουμε δέσμες (κλειδί, τιμή)  
"user" in tweet_keys                  # Επιστρέφει True, χρησιμοποιώντας την αναποτελεσματική αναζήτηση `in` σε λίστα  
"user" in tweet                       # Πιο «Pythonic» χρήση, με χρήση της αποτελεσματικής αναζήτησης `in` σε λεξικό  
"joelgrus" in tweet_values            # True

Τα κλειδιά στα λεξικά είναι μοναδικά και οι λίστες δεν μπορούν να χρησιμοποιηθούν ως κλειδιά λεξικού. Εάν χρειάζεστε ένα κλειδί με πολλαπλά μέρη, μπορείτε να χρησιμοποιήσετε μια δέσμη (tuple) ή να μετατρέψετε το κλειδί σε συμβολοσειρά με κάποιο τρόπο.

Ενσωματωμένα λεξικά (Defaultdicts)

Εάν προσπαθείτε να μετρήσετε τη συχνότητα εμφάνισης κάθε λέξης σε ένα έγγραφο, μια προφανής προσέγγιση είναι να δημιουργήσετε ένα λεξικό όπου οι λέξεις είναι τα κλειδιά και οι συχνότητες οι αντίστοιχες τιμές. Στη συνέχεια, διασχίζετε το έγγραφο, αυξάνοντας την τιμή του κλειδιού κατά 1 για κάθε λέξη που έχει ήδη εμφανιστεί και προσθέτοντας ένα νέο ζεύγος κλειδιού-τιμής για τις λέξεις που δεν έχουν εμφανιστεί:

word_counts = {}  
for word in document:  
    if word in word_counts:  
        word_counts[word] += 1  
    else:  
        word_counts[word] = 1

Φυσικά, μπορείτε επίσης να χειριστείτε ένα κλειδί που λείπει προκαταβολικά με μια προσέγγιση ‘δοκίμασε και διόρθωσε’ (EAFP):

word_counts = {}  
for word in document:  
    try:  
        word_counts[word] += 1  
    except KeyError:  
        word_counts[word] = 1

Η τρίτη μέθοδος είναι η χρήση της συνάρτησης get, η οποία είναι εξαιρετική για τον χειρισμό των κλειδιών που λείπουν:

word_counts = {}  
for word in document:  
    previous_count = word_counts.get(word, 0)  
    word_counts[word] = previous_count + 1

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

from collections import defaultdict  
word_counts = defaultdict(int)        # Το `int()` δημιουργεί το 0  
for word in document:  
    word_counts[word] += 1

Τα defaultdict είναι επίσης πολύ χρήσιμα με λίστες, κανονικά λεξικά ή ακόμα και με προσαρμοσμένες συναρτήσεις:

dd_list = defaultdict(list)           # Το `list()` δημιουργεί μια κενή λίστα  
dd_list[2].append(1)                  # Το `dd_list` είναι τώρα `{2: [1]}`  
dd_dict = defaultdict(dict)           # Το `dict()` δημιουργεί ένα κενό λεξικό  
dd_dict["Joel"]["City"] = "Seattle"   # Το `dd_dict` περιέχει τώρα `{ "Joel" : { "City" : "Seattle"}}`  
dd_pair = defaultdict(lambda: [0, 0]) # Δημιουργεί ένα λεξικό όπου οι τιμές για τα κλειδιά είναι λίστες  
dd_pair[2][1] = 1                     # Το `dd_pair` περιέχει τώρα `{2: [0,1]}`

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

Μετρητές (Counters)

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

from collections import Counter  
c = Counter([0, 1, 2, 0]) # το `c` είναι (περίπου) `{ 0 : 2, 1 : 1, 2 : 1 }`

Έτσι έχουμε έναν πολύ βολικό τρόπο για να μετράμε τις συχνότητες λέξεων:

word_counts = Counter(document)

Οι μετρητές έχουν επίσης μια πολύ χρήσιμη μέθοδο, την most_common, η οποία μπορεί να επιστρέψει απευθείας τις πιο συχνές λέξεις και τις αντίστοιχες συχνότητές τους:

# Εκτυπώνει τις 10 πιο συχνές λέξεις και τους αντίστοιχους αριθμούς τους.  
for word, count in word_counts.most_common(10):  
    print word, count

Σύνολα (Sets)

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

s = set()  
s.add(1)          # το `s` είναι `{ 1 }`  
s.add(2)          # το `s` είναι `{ 1, 2 }`  
s.add(2)          # το `s` είναι `{ 1, 2 }`  
x = len(s)        # Είναι ίσο με 2  
y = 2 in s        # Είναι ίσο με True  
z = 3 in s        # Είναι ίσο με False

Δύο βασικοί λόγοι για τη χρήση συνόλων:

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

stopwords_list = ["a","an","at"] + hundreds_of_other_words + ["yet", "you"]  
"zip" in stopwords_list               # Αποτυγχάνει, πρέπει να ελεγχθεί κάθε στοιχείο  
stopwords_set = set(stopwords_list)  
"zip" in stopwords_set                # Η αναζήτηση είναι επιτυχής και πολύ γρήγορη

Δεύτερον, η χρήση συνόλων είναι πολύ βολική για την ανάκτηση των μοναδικών στοιχείων από ένα σύνολο δεδομένων:

item_list = [1, 2, 3, 1, 2, 3]  
num_items = len(item_list)            # 6  
item_set = set(item_list)             # {1, 2, 3}  
num_distinct_items = len(item_set)    # 3  
distinct_item_list = list(item_set)   # [1, 2, 3]

Στην πράξη, ωστόσο, τα σύνολα δεν χρησιμοποιούνται τόσο συχνά όσο τα λεξικά και οι λίστες.

Εντολές συνθήκης

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

if 1 > 2:  
    message = "αν μόνο το 1 ήταν μεγαλύτερο από το δύο…"  
elif 1 > 3:  
    message = "το 'elif' σημαίνει 'else if'"  
else:  
    message = "όταν όλα τα άλλα αποτύχουν, χρησιμοποιήστε το 'else' (αν θέλετε)"

Μπορείτε επίσης να γράψετε μια εντολή υπό όρους σε μία γραμμή, αλλά αυτό χρησιμοποιείται σπάνια:

parity = "even" if x % 2 == 0 else "odd"

Εντολές επανάληψης (Βρόχοι)

Βρόχοι while

Ο βρόχος while στην Python:

x = 0  
while x < 10:  
    print x, "είναι μικρότερο από 10"  
    x += 1

Βρόχοι for

Πιο συχνά χρησιμοποιείται ο βρόχος for-in:

for x in range(10):  
    print x, "είναι μικρότερο από 10"

Για πιο σύνθετες λογικές εκφράσεις, μπορούν να χρησιμοποιηθούν οι εντολές continue και break:

for x in range(10):  
    if x == 3:  
        continue          # Προχωρά απευθείας στην επόμενη επανάληψη του βρόχου  
    if x == 5:  
        break             # Εξέρχεται πλήρως από τον βρόχο  
    print x

Το αποτέλεσμα θα είναι η εκτύπωση των 0, 1, 2 και 4.

Αληθοτιμή (Truthiness)

Οι δυαδικές μεταβλητές (Booleans) στην Python χρησιμοποιούνται παρόμοια με άλλες γλώσσες, με τη μόνη διαφορά ότι το πρώτο γράμμα πρέπει να είναι κεφαλαίο:

one_is_less_than_two = 1 < 2      # Είναι True  
true_equals_false = True == False # Είναι False

Η Python χρησιμοποιεί το None για να δηλώσει ότι μια τιμή δεν υπάρχει, παρόμοια με το null σε άλλες γλώθες:

x = None  
print x == None        # Εκτυπώνει True, αλλά δεν είναι η πιο κομψή μέθοδος  
print x is None        # Εκτυπώνει True, πιο κομψό

Η Python σας επιτρέπει να χρησιμοποιείτε άλλες τιμές αντί για δυαδικές. Οι ακόλουθες τιμές είναι όλες ισοδύναμες με False:

False
None
[] (μια κενή λίστα)
{} (ένα κενό λεξικό)
“”
set()
0
0.0

Παρομοίως, υπάρχουν πολλές τιμές ισοδύναμες με True, κάτι που καθιστά πολύ βολικό τον έλεγχο για κενές λίστες, κενές συμβολοσειρές, κενά λεξικά κ.λπ.

Φυσικά, εάν δεν μπορείτε να προβλέψετε το αποτέλεσμα, μπορεί να προκύψουν σφάλματα κατά τη χρήση:

s = some_function_that_returns_a_string()  
if s:  
    first_char = s[0]  
else:  
    first_char = ""

Μια απλούστερη προσέγγιση, η οποία έχει το ίδιο αποτέλεσμα με την παραπάνω:

first_char = s and s[0]

Εάν η πρώτη τιμή είναι αληθής, επιστρέφεται η δεύτερη τιμή, διαφορετικά επιστρέφεται η πρώτη τιμή.

Παρομοίως, εάν το x μπορεί να είναι ένας αριθμός ή None, τότε αυτός ο τρόπος εξασφαλίζει ότι το x θα είναι σίγουρα ένας αριθμός:

safe_x = x or 0

Η Python διαθέτει επίσης τη συνάρτηση all, η οποία επιστρέφει True εάν όλα τα στοιχεία είναι True. Η συνάρτηση any επιστρέφει True εάν έστω και ένα στοιχείο είναι True. Για παράδειγμα, για μια λίστα όπου κάθε στοιχείο είναι ‘αληθές’, η συνάρτηση all θα επιστρέψει True, διαφορετικά θα επιστρέψει False:

all([True, 1, { 3 }])       # True  
all([True, 1, {}])          # False, το `{}` είναι ισοδύναμο με 'False'  
any([True, 1, {}])          # True  
all([])                     # True, δεν υπάρχει κανένα στοιχείο ισοδύναμο με 'False'  
any([])                     # False, δεν υπάρχει κανένα στοιχείο ισοδύναμο με 'True'

Περαιτέρω Ανάγνωση:
Προχωρημένη σύνταξη Python στην επιστήμη δεδομένων