NOTE: This part is independent and doesn’t require PART-1 to be referred compulsorily, but its advisable 🙂
Slicing in Python is a mechanism to select a range of items from Sequence types like strings, list, tuple, etc.
>>> L = range(10) >>> L[::2] [0, 2, 4, 6, 8] mylist[::-1] # will reverse a list # Reverse a string >>> S = 'Abhilash' >>> S[::-1] 'haslihbA'
In object oriented programming, language feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes is called Method Overriding.
class Parent(object): def __init__(self): pass def Create(self): return 'Password' class Child(Parent): def __init__(self): self.Create() def Create(self): return 'The ' + super(Child, self).Create() print Child().Create() # prints "The Password"
So what exactly we are doing here; the class Child is capable of accessing the objects of class Parent, which is basically the base of the OOP concept.
Also you can see that class Child is also capable of overrides a method of the superclass, and you can also call the superclass method by calling super(Subclass, self).method instead of self.method.
Python Built-in Function – zip()
The Python’s built-in functions gives a lot more power to your program and there is an exhaustive list of that on Python Docs. We are not going to discuss them all, we will only see what zip power up’s.
zip() – A powerful function that can make your two lists paired together index wise and can give you option to do operations on both of them together.
# A simple example >>> a = [1,2,3] >>> b = [4,5,6] >>> z = zip(a,b) >>> z [(1, 4), (2, 5), (3, 6)] # Lets do the same to iterate over two lists in parallel >>> alist = ['a1', 'a2', 'a3'] >>> blist = ['b1', 'b2', 'b3'] >>> for a, b in zip(alist, blist): print a, b # Result a1 b1 a2 b2 a3 b3
@staticmethod is a Decorator. They are a special case of methods. Sometimes, you’ll write code that belongs to a class, but that doesn’t use the object itself at all. For example:
class Burger(object): @staticmethod def mix_ingredients(x, y): return x + y def cook(self): return self.mix_ingredients(self.cheese, self.vegetables)
In such a case, writing mix_ingredients as a non-static method would work too, but it would provide it a self argument that would not be used.
So lets understand it in this way; python doesn’t have to instantiate a bound-method for each Burger object we instantiate. Bound methods are objects too, and creating them has a cost. Having a static method avoids that:
>>> Burger().cook is Burger().cook False >>> Burger().mix_ingredients is Burger.mix_ingredients True >>> Burger().mix_ingredients is Burger().mix_ingredients True
The filter function constructs a list of elements from iterables for which the function returns true.
Let’s take a simple example where we want to remove all numbers which are less than 5.
n = [1,2,5,10,3,100,9,24] a= for e in n: if e >= 5: a.append(e) n = a # OR use filter return filter(lambda x: x >= 5, n)
In the above piece of code, both the blocks will output same. But it makes the code look more simplified and easy to write.
What actually happening is the second block filter the list n with a condition x >=5. So once the condition is matched, it puts that particular element in x.
With Built-in-Exceptions, I am not really willing to demonstrate each and every Exception type python provides. My Intention is to grab your focus on this important topic too. This is very important to understand and practice to become a successful programmer. Error handling is a beauty which everyone should follow.
They are the heart of application behavioral science 😉
Lets have an example to demostrate it’s functionality:
(x,y) = (5,0) try: z = x/y except ZeroDivisionError: print "divide by zero"
So, the above code will catch the exception and handle it only for divisions happening with zero and others will be thrown with Tracebacks (And that very non-friendly).
However, all errors are widely the same as in other language, so python is not re-inventing the wheel. What’s important is to understand the usage and requirement of each to fully utilize the power.
You could refer Python Docs for the same, because this topic is something which require a dedicated separate blog. So start rolling!
Testers love this. Companies are hiring specific people having this skill set. Testing word with big meaning for big standards. With unit testing each block of source code is set to be tested with pre-defined input and outputs. The task is to test that the program is doing what it is expected to do.
For an example: you may want to test a code blog with some specific filtration, like the data given by user should be converted into small case, the each character should be taken and converted into ASCII value and then returned. Just a random thought <:-|
Let’s see a more specific and direct example with codes. We need to check if a given text is palindrome or not, if word is palindrome then unit test will pass otherwise it will fail.
# Lets make our class and define method in it, that we will test later class Process(): """ Ideally this one should return a palindrome But I have intentionally added another letter "A" in end to make the method test to go false. """ def CheckPalindrome(self,text=None): # If we return this one, unit test will pass Correct = text[::-1] # If we return this one, unit test will fail Wrong = text[1::-1] return Wrong
Above code is a building block for converting word into palindrome. So if we return Correct the unit test will pass and if we return Wrong the unit test will fail. Lets have a look at unit test code also.
import unittest #Base class for Unit Testing class TestFunctions(unittest.TestCase): # Test case for checking Palindrome method def test_CheckPalindrome(self): # Expected input = "Abhilash" TestOutput = CheckPalindrome("Abhilash") # Expected output ExpetedOutput = "hsalihbA" self.assertEqual(ExpetedOutput, TestOutput) #To auto instantiate the unit tests if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(TestFunctions) unittest.TextTestRunner(verbosity=2).run(suite)
So if we consider the case we have defined above then CheckPalindrome will return “bA” and hence our condition will not match and a testError with Traceback will be shown.
Similarly, if we return Correct then it will give us test true and something like this will be a message on screen:
$ python unittest_simple.py -v test (__main__.TestFunctions) ... ok ------------------------------------------------ Ran 1 test in 0.000s OK
This abbreviated output includes the amount of time the tests took, along with a status indicator for each test. -v is for more detailed test results.
And of-course this is required in real world situation. Must for all programmers. Search for Test Driven Development (TDD), and start exploring.
So what the heck is profiling? Profiling is a technique to dynamically examine and analyze programs and measure the time complexity, usage of different instructions, duration of function calls, memory complexity and so on.
Python includes a profiler called cProfile. It not only gives the total running time, but also times each function separately, and tells you how many times each function was called, making it easy to determine where you should make optimizations.
Lets have a look:
""" You can call it from within your code, or from the interpreter, like this: """ import cProfile cProfile.run('foo()') """ Even more usefully, you can invoke the cProfile when running a script: """ python -m cProfile myscript.py """ To make it even easier, I made a little batch file called 'profile.bat': """ python -m cProfile %1 # So all I have to do is run: profile euler048.py
And the output will be something like this:
Python is a beautiful language and its very robust. Keep learning as it actually drives lots of fun building products. Cheers!
If you have any suggestions or something that you wanna say to me, just Tweet me or DM me here.