# 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: List Comprehension Syntax
# Creating a List of numbers from 1 to 10 can be done with: | |
list_1_to_10 = range(1,11) | |
# Returns | |
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] | |
# But what if you wanted only the even numbers? Use the List comprehension syntax! | |
even_num_list = [x for x in range(1,11) if x % 2 == 0] | |
# Returns | |
[2, 4, 6, 8, 10] |
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(x–1) # 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
# 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 |
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| a–b} | |
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| a–b} #Subtract | |
# Returns | |
"15" | |
"5" |
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) |