Monday, November 23, 2015

Understanding *args and **kwargs in Python

I need some time figuring out what is behind *args and **kwargs. Finally I understand it, so I want to share it with you here.

First of all, you need to know that what you need to understand here is the asterix (*), not the "args" and "kwargs". So if you write f(*params, **oparams) and f(*args, **kwargs), they both will behave similarly.

* is used to pass varied length of arguments. Here is an example on how to use *
def test_args(a, *b):

 def test_args(a, *b):  
   print "normal variable: ", a  
   print "first argument: ", b[0]  
   print "second argument: ", b[1]  
   print "third argument: ", b[2]  
 test_args('arwan', 1,2,3,4,5)  

From the example, "a" is single variable while "b" is varied length of argument. Thus, the first argument will be passed to "a" where the next variable will be passed to "b". Thus, all arguments (1,2,3,4,5) will be passed to "b" while only "arwan" will be passed to "a".

Double asterix (**) is used for varied argument with key. Here is an example.

 def test_args(a, **c):  
   print "normal variable: ", a  
   print "first argument: ", c['one']  
   print "second argument: ", c['two']  
   print "third argument: ", c['three']  
 test_args('arwan', one=1, two=2, three=3)  

In this example, the first argument is passed to "a", while next variable will be passed to "c".  Please notice that the way we pass the variable is different with single asterix(*). For two asterix (**), we need to define key for each value we pass. Note that the key is "one", "two" and "three" while the values are everything after "=".  The number of argument passed may be varied.

To make everything even more clear, here is another example to combine both.

 def test_args(a, *b, **c):  
   print "normal variable: ", a  
   print "arg 0: ", b[0]
   print "arg 1: ", b[1]
   print "arg 2: ", b[2]
   print "first argument: ", c['one']  
   print "second argument: ", c['two']  
   print "third argument: ", c['three']  
 test_args('arwan', 1, 2, 3, 4, one=1, two=2, three=3)  

Sunday, October 25, 2015

Stack Implementation in Python

Stack is one of important concepts in data structure. Stack can be defined as abstract data type (ADT) that collects items with LIFO (last in, first out) principle. Two operations are known for stack i.e. push and pop. Push will add an item into stack, while pop will remove the last element that was added into stack. 

You may think stack concept as if you arrange your plates. You will put a plate above other plates, but when you want to take one plate, you will take it from the top.

To implement it in python, you will have at least three methods i.e. __init__, push, and pop. However, here we will add some more methods i.e. isEmpty (to check if the stack is empty), peek (to get the item at the top) and size(to get the number of item(s) in the stack). Here are the implementation in python:

 class Stack:  
   def __init__(self):  
     self.items = []  
   def isEmpty(self):  
     return self.items == []  
   def push(self, item):  
   def pop(self):  
     if not self.isEmpty():  
       return self.items.pop()  
   def peek(self):  
     if not self.isEmpty():  
       return self.items[len(self.items)-1]  
   def size(self):  
     return len(self.items)  
So, now you may implement the stack like following:
 s = Stack()  
The output will be
By the way, I am using Python 3. However, for python 2 implementation, for this code, you will just need to change the print command. So it will be like this.
  s = Stack()   
  print s.isEmpty()   
  print s.size()  
Hope it helps.

Thursday, October 8, 2015

Dragon Ball Super Opening Lyrics (Chozetsu - Dynamic)

Itsuka Togireta 
yume no tsudzuki Hajimeyou 
Hoshi o tsunagete 
Sora ni tobira kakebaii 
arata na suteeji wa 
Kami ni idomu basho 
Kyouretsu - mouretsu -dynamic! Let's Go! GO ! daipanikku 
Makeru to tsuyoukunaru 
Minohodo shirazu ni wa 
koukai toka genkai toka nai mon 
 Souzetsu-chouzetsu-dynamic! Let's Go! Yes ! renda kikku 
abisete mushaburui 
sugee koto ga matterun da ze