Python Hax: Lambdas

# Python like Javascript is a functional langauge. It allows you to pass methods.
# To filter my_list for even numbers you can:
my_list = range(1,11) # Creates a list with the number 1 – 10
# Filter Syntax is filter(params to filter by, list to filter)
print filter( lambda x: x%2==0, my_list)
# Returns
[2, 4, 6, 8, 10]

Python Hax: Iterating Over a Dictionary

# Iterating over Dictionaries in Pythin is really straight forward
dictionary = {
"a" : "A",
"b" : "B",
"c" : "C",
"d" : "D"
}
# Get all items in the Dictionary
dictionary.items()
# Returns
[('a', 'A'), ('c', 'C'), ('b', 'B'), ('d', 'D')]
# Get all keys in the Dictionary
dictionary.keys()
# Returns
['a', 'c', 'b', 'd']
# Get all values in the Dictionary
dictionary.values()
# Returns
['A', 'C', 'B', 'D']

Python Hax: List Slicing / Reverse

# Python list can be manipulated as follows:
my_list = [1,2,3,4,5,6,7,8,9,10]
# my_list[start_index : end_index : stride]
# Default for start index is 0
# Default for end index is the end of the list
even_num_list = my_list[1::2]
# Returns
[2, 4, 6, 8, 10]
odd_num_list = my_list[::2]
# Returns
[1, 3, 5, 7, 9]
reverse_list = my_list[::1]
# Returns
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Python Hax: Recursive Example for Factorials

'''
Recursion can be difficult for beginners. It still is difficult for me.
The best way to improve is to try "easy" recursion problems such as
factorials in this case.
Instructions:
Create a function that takes an positive interger and returns the factorial of it
Example factorial(3) should return 3*2*1 or 6
Factorial(1) should return 1
Factorial(0) should return 1
'''
#Non Recursion Example
def factorial(x):
total = 1
if x == 0 or x == 1: # Handles Edge Case of 1 or 0
return total
while x > 1:
total = total * x # Multiples variable total defined outside of loop with x
x-=1 # Subtracts one from x so that the while loop will break when x = 1
return total
# Recursion Example
def factorial(x):
if x == 0 or x ==1: # When x is equal to 0 or 1, it returns 1
return 1
return x * factorial(x1) # multiples x with the recursion or calling itself with x – 1
'''
If we do factorial (3)
It first checks if x is == 0 or x == 1 => False
Then it go to x * factorial(x-1) which would be 3 * factorial(2)
Evaluate factorial(2)
Check if x == 0 or x == 1 => False
x * factorial(x-1) or 2 * factorial(1)
Evaluates factorial(1)
Check if x == 0 or x == 1 => True
returns 1
factorial(1) evaluates to 1
returns 1
So 2 * factorial(1) = 2 * 1 => 2
factorial(2) evaluates to 2
returns 2
So factorial(2) = 2
So 3 * factorial(2) = 3 * 2 => 6
This function then returns 6
'''

Install LDA, Beautiful Soup and NLPK for Sublime REPL

Screen Shot 2015-04-04 at 12.40.51 PM

# This guide is for people who have install Sublime REPL and linked their system Python to it.
# If you haven't but want to, refer to my previous post where I show you how.
# If you are using Python 3 and still have Python 2 installed on your system as default
# For NLTK
python3 m pip install U nltk
# For LDA
python3 m pip install lda
#For Beautiful Soup
python3 m pip install beautifulsoup4
#________________________________________________________________________________________
# python2 -m pip install PACKAGE NAME will allow you to install packages for Python 2
# If you are only running one version of Python, you can just type pip install PACKAGE NAME

view raw
install_nlpk_lda.py
hosted with ❤ by GitHub

Ruby Hax: Yield

# Yield in Ruby allow you to pass a block implicitly which not only makes it faster
# to type out this pattern but it also faster to execute!
# Regular Block Syntax
def calculate(a, b, action)
action.call(a,b)
end
# Defining the lambda add and subtract
add = lambda {|a,b| a+b}
subtract = lambda {|a,b| ab}
puts calculate(10,5, add)
puts calculate(10,5, subtract)
# Returns
"15"
"5"
#Yield Syntax
def calculate(a, b)
yield(a,b)
end
puts calculate(10,5){|a,b| a+b} #Add
puts calculate(10,5){|a,b| ab} #Subtract
# Returns
"15"
"5"

view raw
ruby_yield.rb
hosted with ❤ by GitHub

Ruby Hacks: Include vs Extend for Ruby Modules

# Include give you access to a module on a instance level while
# extend give class level access.
module CanYouHearMe
def test
puts "I hear you loud and clear!"
end
end
class Radio
include CanYouHearMe
end
class Satellite
extend CanYouHearMe
end
# Calling the method test on the class Radio
Radio.test
# Returns
"private method 'test' called for Context::Radio:Class"
# Calling the method test on the class Satellite
Satellite.test
# Returns
"I hear you loud and clear!"
# Calling the method test on an instance of the class Radio
ham_radio = Radio.new
ham_radio.test
# Returns
"I hear you loud and clear!"
# Calling the method test on an instance of the class Satellite
sat_comm = Satellite.new
sat_comm.test
# Returns
"private method 'test' called for #<Context::Satellite:0x000000024ef2f8>"

Ruby Hacks: Class inheritance in Ruby

# Inheritance is an important idea for Object Orientated Programming OOP
# This example will demo a simple example of inheritance
class Dog
def talk
puts "Woof"
end
end
class JackRussell < Dog
end
class BichonFrise
end
roo = JackRussell.new
roo.talk
#Returns
"Woof"
candy = BichonFrise.new
candy.talk
#Returns
" undefined method `talk' "
# Notice that the class JackRussell inherits from the class Dog on line 10.
# While JackRussell has no talk method defined, it inherits the talk method
# from the parent or Super class of Dog. This is why roo.talk returns "Woof"
# Meanwhile candy.talk returns undefined method as it is talk is not defined
# in the class BichonFrise nor did it inherit from the class Dog (line 21)

view raw
ruby_inheritance.rb
hosted with ❤ by GitHub