Mohammad Tayseer

happiness

>>> def add(x, y):
...   return x + y

>>> add(3, 5)
8
>>> add("hello", " world")
'hello world'
>>> add(3, " world")
Traceback (most recent call last): 
File "<stdin>", line 1, in ? 
File "<stdin>", line 2, in add
TypeError: unsupported operand type(s) for +: 'int' and 'str'

if x in (1, 2, 3, 7, 4): 
  print 'Not found'
else: 
  print 'found'

>>> d = {'name': 'Bond. James Bond!!', 'car': 'Aston Martin'}

>>> d['name']
'Bond, James Bond!!'

graph = {'A': {'B': 14}, 'B': {'C': 3, 'D': 9}, 'C': None, 'D': None}

>>> graph['B']['C']
3

>>> x = 0
>>> x.keys()
Traceback (most recent call last):
File "<stdin>", line 1, in ?
AttributeError: 'int' object has no attribute 'keys'

>>> x = 0
>>> x = {'name': 'Bond, James Bond!!'}

class Base {}
class Derived : Base{
  public void MyMethod() {}
}

Base b = new Derived();
b.MethodCall();

((Derived)b).MethodCall();

string personIdString = context.Request.Params["personId"];
int personId = int.Parse(personIdString);

personId = context.Request.Params['personId']
personId = int(personId)

def return_many_values():  
  return (1, 2, 4, 8)

(a, b, c, d) = return_many_values()

def return_many_values():  
  return 1, 2, 4, 8
a, b, c, d = return_many_values()

Factorial(x=10)

public class AdvancedMath{  
  static SortedDictionary<int, int> _cache = new SortedDictionary<int, int>();
  static int Factorial(int x)  {
    if (_cache.ContainsKey(x))
      return _cache[x];
    if (x == 0)
      return 1;
    int result = x * Factorial(x - 1);    
    _cache.Add(x, result);    
    return result;  
  }
}

static SortedDictionary<int, int> _cache = new SortedDictionary<int, int>();
static int Factorial(int x)
{
  return Caching(x, _FactorialImpl);
}

delegate int MathDelegate(int x);
static int Caching(int x, MathDelegate mathDelegate)
{
  if (_cache.ContainsKey(x))
    return _cache[x];
  int result = mathDelegate(x);
  _cache.Add(x, result);
  return result;
}

static int _FactorialImpl(int x)
{
  if (x == 0)
    return 1;
  return x * _FactorialImpl(x - 1);
}

# This function takes any function as a parameter & returns an 
# equivalent function, but with caching
def cached(old_fn):  
  def new_fn(*args):# *args means that it can accept any
                    # number of arguments. They will                    
                    # be contained in the tuple `args`    
    if new_fn.cache.has_key(args):      
      return new_fn.cache[args]    
    result = old_fn(*args)  # We are passing all the                           
                            # arguments to the original                           
                            # function. If the number of                           
                            # arguments is not correct,                           
                            # it will throw an exception    
    new_fn.cache[args] = result    
    return result  
  new_fn.cache = {} # the cache is a member of the                     
                    # function itself  
  return new_fn

  def factorial(n):  
    if n == 0:    
      return 1  
    return n * factorial(n - 1)

  factorial = cached(factorial)

try{  
  XmlTextReader rdr = new XmlTextReader();  
  rdr.WhitespaceHandling = WhitespaceHandling.None;  
  while(rdr.Read())  
  {    
    switch (rdr.Name)    
    {      
      case "scoresheet":      
        if (rdr.IsStartElement())      
        {      
          // handle element start      
        }      
        else      
        {      
          // handle element end      
        }      
        break;      
      // handle other cases here      
      default:      
      // handle 'unexpected element' error    
      }  
    }
  }
  catch (XmlException ex)
  {  
    // handle error
  }

from xml.sax import parse as sax_parser
parser = MySaxParser()
sax_parse(file_name, parser)

# This is the base class that you will inherit
class BaseSaxHandler(xml.sax.handler.ContentHandler):
  def startElement(self, tag, attributes):
    tag = str(tag) # convert unicode -> str

    # get a method in this object named 'start_' + tag, or
    # return None if the method doesn't exist
    handler = getattr(self, 'start_' + tag.lower(), None)
    if handler:
      handler(attributes)
    else:
      self.error_unknow_start_tag(tag, attributes)

  def endElement(self, tag):
    tag = str(tag)
    handler = getattr(self, 'end_' + tag.lower(), None)
    if handler:
      handler()
    else:
      self.error_unknown_end_tag(tag)

  def error_unknown_start_tag(self, tag, attributes):
    print 'Unknown start tag:', tag

  def error_unknown_end_tag(self, tag):
    print 'Unknown end tag:', tag

class MySaxParser(BaseSaxHandler):
  def start_channel(self, attributes):
    # Look Ma, no switch  
    print '<channel>'

  def end_channel(self):
    print '</channel>'

Mohammad Tayseer

Why you should use Python

Comments