Syntax Comparisons Across Languages

def myClosure = { x, y -> x + y }		// scala uses =>
[1, 2, 3, 4].each{ println it*2 } 		// it is assumed
[<list>].<iterator>{<param> -> <statment>}
for(<condition>){<logic>} 				// loops can be faster than `.each`

%%python
string = "Hello 12345 World"
numbers = [x for x in string if x.isdigit()]
numbers

%%python
def double(x):
  return x*2
[double(x) for x in range(10)]
[double(x) for x in range(10) if x%2==0]

%%python
[x+y for x in [10,30,50] for y in [20,40,60]]

%%python
#dict comprehensions are just as good as list comprehensions
my_phrase = ["No", "one", "expects", "the", "Spanish", "Inquisition"]
my_dict = {key: value for value, key in enumerate(my_phrase)}
reversed_dict = {value: key for key, value in my_dict.items()}
reversed_dict

//ArrayList
list = [5, 6, 7, 8]
list.add(9)
list << 10
assert list  == [5, 6, 7, 8, 9, 10]
assert list.get(2) == 7

list.remove(5)    
assert list.max() == 9
assert ['a','b','c','b','b'] - 'c' == ['a','b','b','b']  //remove elements from list by value

assert [1, 2, 3, 4, 5][-1] == 5             //use negative indices to count from the end

assert list.size() == 5
assert list.getClass() == ArrayList     //the specific kind of list being used

assert [1, 2, 3] * 3 == [1, 2, 3, 1, 2, 3, 1, 2, 3]
assert [1, 2, 3].multiply(2) == [1, 2, 3, 1, 2, 3]

assert Collections.nCopies(3, 'b') == ['b', 'b', 'b']
assert Collections.nCopies(2, [1, 2]) == [[1, 2], [1, 2]] //not [1,2,1,2]; nCopies from the JDK has different semantics than multiply for lists

def list2 = new ArrayList<String>(list)
assert list2 == list   //== checks that each corresponding element is the same

def list3 = list.clone()
assert list3 == list   //clone() can also be called

['a', 'b', 'c'].eachWithIndex { it, i -> println "$i: $it"} //`it` is the current element, while `i` is the index
    
assert [1, 2, 3].collect { it * 2 } == [2, 4, 6]
assert [1, 2, 3]*.multiply(2) == [1, 2, 3].collect { it.multiply(2) }  //shortcut syntax instead of collect

assert [1, 2, 3].find { it > 1 } == 2           //find 1st element matching criteria
assert [1, 2, 3].findAll { it > 1 } == [2, 3]   //find all elements matching critieria

assert ['a', 'b', 'c', 'd', 'e'].findIndexOf { it in ['c', 'e', 'g'] } == 2     //find index of 1st element matching criteria
assert ['a', 'b', 'c', 'd', 'c'].indexOf('c') == 2                              //first index returned
assert ['a', 'b', 'c', 'd', 'c'].findIndexValues{it=='c'} == [2,4]              //all indices returned

assert [1, 2, 3].every { it < 5 }               // returns true if all elements match the predicate
assert ![1, 2, 3].every { it < 3 }              // negation
assert [1, 2, 3].any { it > 2 }                 // returns true if any element matches the predicate

assert [1, 2, 3].join('-') == '1-2-3'           // String joining
assert [1, 2, 3].inject('counting: ') { str, item -> str + item } == 'counting: 123'     // reduce operation

Comparator mc = { a, b -> a == b ? 0 : (a < b ? -1 : 1) }
def list = [7, 4, 9, -6, -1, 11, 2, 3, -9, 5, -13]
assert list.max(mc) == 11

assert [6, 3, 9, 2, 7, 1, 5].sort() == [1, 2, 3, 5, 6, 7, 9]

def list = ['abc', 'z', 'xyzuvw', 'Hello', '321']
assert list.sort { it.size() } == ['z', 'abc', '321', 'Hello', 'xyzuvw']

def list2 = [7, 4, -6, -1, 11, 2, 3, -9, 5, -13]
assert list2.sort { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 } == [-1, 2, 3, 4, 5, -6, 7, -9, 11, -13]

//Groovy Iterables???

%%python
def Sort(sub_li): 
    # reverse = None (Sorts in Ascending order) 
    # key is set to sort using second element of  
    # sublist lambda has been used 
    sub_li.sort(key = lambda x: x[1]) 
    return sub_li
 
sub_li =[['rishav', 10], ['akash', 5], ['ram', 20], ['gaurav', 15]] 
print(Sort(sub_li)) 

%%python
#you can iterate over a list and get its index
mylist = ["It's", 'only', 'a', 'model']
for index, item in enumerate(mylist):
    print(index, item)

%%javascript
arr = []

map = [name: 'Gromit', likes: 'cheese', id: 1234, "city":"New York"]
map.put('foo', 'bar')
assert map.get('name') == 'Gromit'
assert map.containsKey('city') == true

assert map.size() == 5
assert map instanceof java.util.Map
assert map.getClass() == LinkedHashMap     // this is probably what you want

def a = 'Bob'
def ages = [a: 43]
assert ages['Bob'] == null //`Bob` is not found
assert ages['a'] == 43     //because `a` is a literal!

ages = [(a): 43]            //now we escape `a` by using parenthesis
assert ages['Bob'] == 43   //and the value is found!

assert map.name == 'Gromit'     //can be used instead of map.get('name')
assert map.id == 1234
map.bar = 'foo'

map.eachWithIndex{entry, i -> println "$i $entry.key: $entry.value"}

map.sort()																// sort on key

map.find{it.value == "New York"}.key == "city"							// returns the first Entry that matches
map.findAll{it.value == "New York"} == [city : "New York"]				// returns all matches to a map

map.grep{it.value == "New York"}.each{it -> assertTrue(it.key == "city" && it.value == "New York")}			// returns a list instead of a map

map.every{it -> it.value instanceof String} == false					// returns a boolean
map.collect{entry -> entry.value.name}									// collect entries into a list
map.findAll{it.value.age < 30}.collect{key, value -> value.name}		// query and collect into new map
map.groupBy{it.value % 2}												// subgroup

%%python
#dict
#open an append file when given a file with the following
#a 5
#b 6
#d 7
#a 2
#c 1

d = {}
for line in file('data/keyvalue.txt'):
    key, value = line.split()
    l = d.get(key, [])
    l.append(int(value))
    d[key] = l
    
def sort_by_sum_value(a, b):
...    sum_a = sum(a[1])
...    sum_b = sum(b[1])
...    return cmp(sum_a, sum_b)

items = d.items()
items    #[('a', [5, 2]), ('c', [1]), ('b', [6]), ('d', [7])]
items.sort(sort_by_sum_value)


#iterate over items
my_dict = {'name': 'Lancelot', 'quest': 'Holy Grail', 'favourite_color': 'blue'}
print(my_dict.get('airspeed velocity of an unladen swallow', 'African or European?\n'))
for key, value in my_dict.iteritems():
    print(key, value, sep=": ")

assert 'a' in ['a','b','c']             // returns true if an element belongs to the list
assert ['a','b','c'].contains('a')      // equivalent to the `contains` method in Java
assert [1,3,4].containsAll([1,4])       // `containsAll` will check that all elements are found

assert [1,2,3,3,3,3,4,5].count(3) == 4  // count the number of elements which have some value

assert [1,2,4,6,8,10,12].intersect([1,3,6,9,12]) == [1,6,12]

assert [1,2,3].disjoint( [4,6,9] )
assert ![1,2,3].disjoint( [2,4,6] )

%%python
s = set((1, 2, 3, 4, 5))
t = set((4, 5, 6))
print( s.union(t) )

set([1, 2, 3, 4, 5, 6])
print( s.intersection(t) )

u = set((4, 5, 6, 7))
print( t.issubset(u) )
print( u.issubset(t) )

sl = list(s)
ss = set(sl)

%%javascript
//just JSON???

%%python
numbers = [10, 12, 15, 18, 20]   #create iterable
print(iter(numbers))

iterator = iter(numbers)         #create iterator
print(next(iterator))

%%python
numbers = [10, 12, 15, 18, 20]
iterator = enumerate(numbers)
print(next(iterator))             #index, value

squared = map(lambda x: x**2, numbers)
print(next(squared))              #applied function

%%python
from itertools import repeat
lots_of_fours = repeat(4, times=100_000_000)

import sys
size_in_bytes = sys.getsizeof(lots_of_fours)
print(size_in_bytes)

lots_of_fours = [4] * 100_000_000
size_in_bytes = sys.getsizeof(lots_of_fours)
print(size_in_bytes)

%%python
class SillyIter:
    i = 0
    n = 5
    def __iter__(self):
        return self
    def __next__(self):
        self.i += 1
        if self.i > self.n:
            raise StopIteration
        return self.i

si = SillyIter()
for i in si:
    print(i)

%%python
def SillyIter():
    i = 0
    n = 5
    while i < n:
        i+=1
        yield i

si = SillyIter()
for i in si:
    print(i)

%%python
squares = (number**2 for number in numbers if number % 2 == 0)
print(next(squares))

%%python
class my_enumerate:
    def __init__(self, some_iter):
        self.some_iter = iter(some_iter)
        self.count = -1
    def __iter__(self):
        return self
    def __next__(self):
        val = self.some_iter.__next__()
        self.count += 1
        return self.count, val
    
for n, val in my_enumerate(['a', 'b', 'c']):
    print(n, val)

%%python
def g():
    for i in range(0, 5):
        yield i**2
for i in g():
    print(i)

%%python
#tuple unpacking
a = 'Spam'
b = 'Eggs'
print(a, b)
a, b = b, a
print(a, b)

%%python
from collections import Counter
from random import randrange
import pprint
mycounter = Counter()
for i in range(100):
    random_number = randrange(10)
    mycounter[random_number] += 1
for i in range(10):
    print(i, mycounter[i])

%%python
class Binner:
    def __init__(self, binwidth, binmax):
        self.binwidth, self.binmax = binwidth, binmax
        nbins = int(binmax / float(binwidth) + 1)
        self.bins = [0] * nbins
    def add(self, value):
        bin = value / self.binwidth
        self.bins[bin] += 1
    def __getitem__(self, index):
        return self.bins[index]
    def __len__(self):
        return len(self.bins)

binner = Binner(5, 20)
for i in range(0, 20):
    binner.add(i)
for i in range(0, len(binner)):
    print( i, binner[i] )

%%python
#enums in python
class           Color : pass
class Red      (Color): pass
class Yellow   (Color): pass
class Blue     (Color): pass

class Toy: pass
myToy = Toy()
myToy.color = "blue"  # note we assign a string, not an enum
if myToy.color is Color:
    pass
else:
    print("My toy has no color!!!")    # produces:  My toy has no color!!!
 
myToy.color = Blue   # note we use an enum
print("myToy.color is", myToy.color.__name__)  # produces: myToy.color is Blue
print("myToy.color is", myToy.color)           # produces: myToy.color is <class '__main__.Blue'>
if myToy.color is Blue:
    myToy.color = Red
if myToy.color is Red:
    print("my toy is red")   # produces: my toy is red
else:
    print("I don't know what color my toy is.")

//`with` closes the file automatically
new File(baseDir,'haiku.txt').withWriter('utf-8') { writer ->
    writer.writeLine 'Hello World'
}

//But for such a simple example, using the << operator would have been enough:
new File(baseDir,'haiku.txt') << '''Hello World'''

new File(baseDir, 'haiku.txt').eachLine { line ->
    println line
}

//collect the lines of a text file into a list, you can do:
def list = new File(baseDir, 'haiku.txt').collect {it}

//output stream
new File(baseDir,'data.bin').withOutputStream { stream ->
    // do something ...
}

//withInputStream idiom that will take care of closing file connection:
new File(baseDir,'haiku.txt').withInputStream { stream ->
    // do something ...
}

boolean b = true
String message = 'Hello from Groovy'
// Serialize data into a file
file.withDataOutputStream { out ->
    out.writeBoolean(b)
    out.writeUTF(message)
}
// ...
// Then read it back
file.withDataInputStream { input ->
    assert input.readBoolean() == b
    assert input.readUTF() == message
}

//find files that match the regex, or just use `.eachFile` for each file, or `eachFileRecurse` to search deeper into subdirectories
dir.eachFileMatch(~/.*\.txt/) { file ->     
    println file.name
}

//execute external process
def process = "ls -l".execute()             
println "Found text ${process.text}"   

%%python
import os
os.listdir(path)

%%python
file = open("testfile.txt","w") 
file.write("Hello World") 
file.close() 

with open("testfile.txt", "r") as f:
    data = f.readlines()
    
for line in data:
    words = line.split()
    print( words )

%%python
import subprocess
output = subprocess.check_output('head', shell=True)
print(output)

%%python
assert False, "you can't do that here!"

%%python
#Worried that you’re getting an empty list? 
x = []
assert len(x)

%%python
#any and all
x = [ True, False ]
print( any(x))
print( all(x))

%%python
#Here, *args assigns all of the positional arguments to a tuple ‘args’, and ‘**kwargs’ assigns all of the keyword arguments to a dictionary ‘kwargs’:
def print_me(*args, **kwargs):
    print_me(5, 6, 7, test='me', arg2=None)
#When a function is called with this notation, the args and kwargs are unpacked appropriately and passed into the function. For example, the function test_call
#can be called with a tuple of three args (matching ‘a’, ‘b’, ‘c’):
def test_call(a, b, c, x=1, y=2, z=3): print( a, b, c, x, y, z)
tuple_in = (5, 6, 7)
test_call(*tuple_in)

%%python
#catch exceptions
x=[0,2,4,6]
try:
    y = x[10]
except IndexError:
    y = None
y

%%python
#The purpose of try/finally is to ensure that something is done, whether or not an exception is raised:
x = [0, 1, 2]
try:
    y = x[5]
finally:
    x.append('something')
    print( x)

%%python
#semantically equivalent to this
#but it’s a bit cleaner, because the exception doesn’t have to be re-raised and you don’t have to catch a specific exception type
try:
    y = x[5]
except IndexError:
    x.append('something')
    raise

%%python
x

%%python
#Exceptions are just classes that derive from Exception, and you can catch exceptions based on their base classes. So, for example, you can catch most standard errors by catching the StandardError exception, from which e.g. IndexError inherits:
print issubclass(IndexError, StandardError)
try:
    y = x[10]
except StandardError:
    print( 'CAUGHT EXCEPTION!', str(e))
    y = None

%%python
#define your own exceptions and exception hierarchies:
class MyFavoriteException(Exception):
    pass
raise MyFavoriteException

%%python
#function decorators are functions that take functions as arguments, and return other functions. 
def my_decorator(fn):
    def new_fn(*args, **kwargs):
        if 'something' in kwargs:
            print( 'REMOVING', kwargs['something'])
            del kwargs['something']
        return fn(*args, **kwargs)
    return new_fn
#To apply this decorator, use this funny @ syntax:
@my_decorator
def some_function(a=5, b=6, something=None, c=7):
    print( a, b, something, c)
#OK, now some_function has been invisibly replaced with the result of my_decorator, which is going to be new_fn. Let’s see the result:
some_function(something='MADE IT')

%%python
#add attributes to functions. (This is why I use them in my testing code sometimes.)
def attrs(**kwds):
    def decorate(f):
        for k in kwds:
            setattr(f, k, kwds[k])
        return f
    return decorate

@attrs(versionadded="2.2", author="Guido van Rossum")
def mymethod(f):
    pass
print( mymethod.versionadded)
print( mymethod.author)

%%python
#memoize/caching of results
def simple_cache(fn):
    cache = {}
    def new_fn(n):
        if n in cache:
            print( 'FOUND IN CACHE; RETURNING')
            return cache[n]
        #otherwise, call function & record value
        val = fn(n)
        cache[n] = val
        return val
    return new_fn

#Then use this as a decorator to wrap the expensive function:
@simple_cache
def expensive(n):
    print( 'IN THE EXPENSIVE FN:', n)
    return n**2
#Now, when you call this function twice with the same argument, if will only do the calculation once; the second time, the function call will be intercepted and the cached value will be returned.
expensive(55)
expensive(55)