Read "Streaming Systems" 1&2, Streaming 101 Read "F1, a distributed SQL database that scales" Read "Zanzibar, Google’s Consistent, Global Authorization System" Read "Spanner, Google's Globally-Distributed Database" Read "Designing Data-intensive applications" 12, The Future of Data Systems IOS development with Swift Read "Designing Data-intensive applications" 10&11, Batch and Stream Processing Read "Designing Data-intensive applications" 9, Consistency and Consensus Read "Designing Data-intensive applications" 8, Distributed System Troubles Read "Designing Data-intensive applications" 7, Transactions Read "Designing Data-intensive applications" 6, Partitioning Read "Designing Data-intensive applications" 5, Replication Read "Designing Data-intensive applications" 3&4, Storage, Retrieval, Encoding Read "Designing Data-intensive applications" 1&2, Foundation of Data Systems Three cases of binary search TAMU Operating System 2 Memory Management TAMU Operating System 1 Introduction Overview in cloud computing 2 TAMU Operating System 7 Virtualization TAMU Operating System 6 File System TAMU Operating System 5 I/O and Disk Management TAMU Operating System 4 Synchronization TAMU Operating System 3 Concurrency and Threading TAMU Computer Networks 5 Data Link Layer TAMU Computer Networks 4 Network Layer TAMU Computer Networks 3 Transport Layer TAMU Computer Networks 2 Application Layer TAMU Computer Networks 1 Introduction Overview in distributed systems and cloud computing 1 A well-optimized Union-Find implementation, in Java A heap implementation supporting deletion TAMU Advanced Algorithms 3, Maximum Bandwidth Path (Dijkstra, MST, Linear) TAMU Advanced Algorithms 2, B+ tree and Segment Intersection TAMU Advanced Algorithms 1, BST, 2-3 Tree and Heap TAMU AI, Searching problems Factorization Machine and Field-aware Factorization Machine for CTR prediction TAMU Neural Network 10 Information-Theoretic Models TAMU Neural Network 9 Principal Component Analysis TAMU Neural Network 8 Neurodynamics TAMU Neural Network 7 Self-Organizing Maps TAMU Neural Network 6 Deep Learning Overview TAMU Neural Network 5 Radial-Basis Function Networks TAMU Neural Network 4 Multi-Layer Perceptrons TAMU Neural Network 3 Single-Layer Perceptrons Princeton Algorithms P1W6 Hash Tables & Symbol Table Applications Stanford ML 11 Application Example Photo OCR Stanford ML 10 Large Scale Machine Learning Stanford ML 9 Anomaly Detection and Recommender Systems Stanford ML 8 Clustering & Principal Component Analysis Princeton Algorithms P1W5 Balanced Search Trees TAMU Neural Network 2 Learning Processes TAMU Neural Network 1 Introduction Stanford ML 7 Support Vector Machine Stanford ML 6 Evaluate Algorithms Princeton Algorithms P1W4 Priority Queues and Symbol Tables Stanford ML 5 Neural Networks Learning Princeton Algorithms P1W3 Mergesort and Quicksort Stanford ML 4 Neural Networks Basics Princeton Algorithms P1W2 Stack and Queue, Basic Sorts Stanford ML 3 Classification Problems Stanford ML 2 Multivariate Regression and Normal Equation Princeton Algorithms P1W1 Union and Find Stanford ML 1 Introduction and Parameter Learning

Functional Programming

2016-07-04

Functional Programming

Map

map() receive two params, a function and a sequence. Each element in the sequence will be passed to the function and return the results as a new sequence. It’s more readable than iteration. You can also use list comprehension if you like, and it’s the prefered way in python.

# default function
name_len = map(len, ["Sam", "John", "Ned Stark"])
print name_len
[3, 4, 9]
# lambda function
squares = map(lambda x: x * x, range(9))
print squares
[0, 1, 4, 9, 16, 25, 36, 49, 64]
# self defined function
def toUpper(item):
      return item.upper()
 
upper_name = map(toUpper, ["sam", "john", "ned stark"])
print upper_name
['SAM', 'JOHN', 'NED STARK']

Reduce

reduce applay a function to a sequence [x1, x2, x3…], the function must take two params, reduce use the result returned by the function with the next element in the sequence. It looks like this:

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

# add
print reduce(lambda x, y: x+y, [1,2,3,4])
10
# multiply
print reduce(lambda x, y: x*y, [1, 2, 3,4])
24
# convert sequence [1,2,3,4] to integer 1234
print reduce(lambda x,y: 10*x + y, [1,2,3,4])
1234

Filter

filter acts just like a real filter. The first param passed to filter is a bool_func which return True or False for different element in the sequence, and only return those elements with True returned from bool_func.

Just like map(), filter() also receive a function and sequence. But different in that filter() only keeps those with True value returned.

# remove even number
def is_odd(n):
    return n % 2 == 1

filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
[1, 5, 9, 15]

All

When all elements in iterable object(like list) are True, return True. Just like and operation on all elements. Note that when iterable is empty, it also return True.

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
all(['a', 'b', 'c'])  # list
True
all([0, 1, 2, 3])  # list,with one 0 element
False
all(('a', 'b', '', 'd'))  #tuple,with one empty element
False
all([]) # empty list
True

Any

Where any of the iterable is True, return True; otherwise return False. When iterable is empty, return False.

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False
any([0,1,2])
True
any([0, '', False])  # list,element with 0,'',false
False

Sorted

Python’s built in function sorted() can sort a list:

sorted(iterable, cmp=None, key=None, reverse=False)

lst = [36, 5, -12, 9, -21]
sorted(lst)
[-21, -12, 5, 9, 36]

sorted() function also receive a key for sorting, like base on the absolute value of a number. You can think of that you pass the key to map() for transformation and use the results for sorting.

sorted keys => [5, 9, 12, 21, 36]
=============|==|==|===|===|
actual order====> [5, 9, -12, -21, 36]

sorted(lst,key=abs)
[5, 9, -12, -21, 36]
# ignore case
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
['about', 'bob', 'Credit', 'Zoo']
# reverse order
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']
['Zoo', 'Credit', 'bob', 'about']

Creative Commons License
Melon blog is created by melonskin. This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.
© 2016-2019. All rights reserved by melonskin. Powered by Jekyll.