Participate in Codex, Test Your Skills & Win BIG
Participate in Codex, Test Your Skills & Win BIG
Python is a high-level, interpreted, general-purpose programming language. Being a general-purpose language, it can be used to build almost any type of application with the right tools/libraries. Additionally, python supports objects, modules, threads, exception-handling and automatic memory management which help in modelling real-world problems and building applications to solve these problems.
Python is a general-purpose programming language that has simple, easy-to-learn syntax which emphasizes readability and therefore reduces the cost of program maintenance. Moreover, the language is capable of scripting, completely open-source and supports third-party packages encouraging modularity and code-reuse.
Its high-level data structures, combined with dynamic typing and dynamic binding, attract a huge community of developers for Rapid Application Development and deployment.
Before we understand what a dynamically typed language, we should learn about what typing is. Typing refers to type-checking in programming languages. In a strongly-typed language, such as Python, "1" + 2 will result in a type error, since these languages don't allow for "type-coercion" (implicit conversion of data types). On the other hand, a weakly-typed language, such as Javascript, will simply output "12" as result.
Type-checking can be done at two stages -
An Interpreted language executes its statements line by line. Languages such as Python, Javascript, R, PHP and Ruby are prime examples of Interpreted languages. Programs written in an interpreted language runs directly from the source code, with no intermediary compilation step.
PEP stands for Python Enhancement Proposal. A PEP is an official design document providing information to the Python Community, or describing a new feature for Python or its processes. PEP 8 is especially important since it documents the style guidelines for Python Code. Apparently contributing in the Python open-source community requires you to follow these style guidelines sincerely and strictly.
Memory management in Python is handled by the Python Memory Manager. The memory allocated by the manager is in form of a private heap space dedicated for Python. All Python objects are stored in this heap and being private, it is inaccessible to the programmer. Though, python does provide some core API functions to work upon the private heap space.
Additionally, Python has an in-built garbage collection to recycle the unused memory for the private heap space.
A namespace in Python ensures that object names in a program are unique and can be used without any conflict. Python implements these namespaces as dictionaries with 'name as key' mapped to a corresponding 'object as value'. This allows for multiple namespaces to use the same name and map it to a separate object. A few examples of namespaces are as follows:
Every object in Python functions within a scope. A scope is a block of code where an object in Python remains relevant. Namespaces uniquely identify all the objects inside a program. However, these namespaces also have a scope defined for them where you could use their objects without any prefix. A few examples of scope created during code execution in Python are as follows:
Sometimes objects within the same scope have the same name but function differently. In such cases, scope resolution comes into play in Python automatically. A few examples of such behaviour are:
log10(), acos(), exp() etc. To resolve this amiguity, it is necessary to prefix them with their respective module, like math.exp() and cmath.exp().
temp = 10 # global-scope variable def func(): temp = 20 # local-scope variable print(temp) print(temp) # output => 10 func() # output => 20 print(temp) # output => 10
This behaviour can be overriden using the global keyword inside the function, as shown in the following example:
temp = 10 # global-scope variable def func(): global temp temp = 20 # local-scope variable print(temp) print(temp) # output => 10 func() # output => 20 print(temp) # output => 20
Decorators in Python are essentially functions that add functionality to an existing function in Python without changing the structure of the function itself. They are represented by the @decorator_name in Python and are called in bottom-up fashion. For example:
# decorator function to convert to lowercase def lowercase_decorator(function): def wrapper(): func = function() string_lowercase = func.lower() return string_lowercase return wrapper # decorator function to split words def splitter_decorator(function): def wrapper(): func = function() string_split = func.split() return string_split return wrapper @splitter_decorator # this is executed next @lowercase_decorator # this is executed first def hello(): return 'Hello World' hello() # output => [ 'hello' , 'world' ]
The beauty of the decorators lies in the fact that besides adding functionality to the output of the method, they can even accept arguments for functions and can further modify those arguments before passing it to the function itself. The inner nested function, i.e. 'wrapper' function, plays a significant role here. It is implemented to enforce encapsulation and thus, keep itself hidden from the global scope.
# decorator function to capitalize names def names_decorator(function): def wrapper(arg1, arg2): arg1 = arg1.capitalize() arg2 = arg2.capitalize() string_hello = function(arg1, arg2) return string_hello return wrapper @names_decorator def say_hello(name1, name2): return 'Hello ' + name1 + '! Hello ' + name2 + '!' say_hello('sara', 'ansh') # output => 'Hello Sara! Hello Ansh!'
Lists and Tuples are both sequence data types that can store a collection of objects in Python. The objects stored in both sequences can have different data types. Lists are represented with square brackets ['sara', 6, 0.19], while tuples are represented with parantheses ('ansh', 5, 0.97).
But what is the real difference between the two? The key difference between the two is that while lists are mutable, tuples on the other hand are immutable objects. This means that lists can be modified, appended or sliced on-the-go but tuples remain constant and cannot be modified in any manner. You can run the following example on Python IDLE to confirm the difference:
my_tuple = ('sara', 6, 5, 0.97) my_list = ['sara', 6, 5, 0.97] print(my_tuple[0]) # output => 'sara' print(my_list[0]) # output => 'sara' my_tuple[0] = 'ansh' # modifying tuple => throws an error my_list[0] = 'ansh' # modifying list => list modified print(my_tuple[0]) # output => 'sara' print(my_list[0]) # output => 'ansh'
Python comprehensions, like decorators, are syntactic sugar constructs that help build altered and filtered lists, dictionaries or sets from a given list, dictionary or set. Using comprehensions, saves a lot of time and code that might be considerably more verbose (containing more lines of code). Let's check out some examples, where comprehensions can be truly beneficial:
my_list = [2, 3, 5, 7, 11] squared_list = [x**2 for x in my_list] # list comprehension # output => [4 , 9 , 25 , 49 , 121] squared_dict = {x:x**2 for x in my_list} # dict comprehension # output => {11: 121, 2: 4 , 3: 9 , 5: 25 , 7: 49}
my_list = [2, 3, 5, 7, 11] squared_list = [x**2 for x in my_list if x%2 != 0] # list comprehension # output => [9 , 25 , 49 , 121] squared_dict = {x:x**2 for x in my_list if x%2 != 0} # dict comprehension # output => {11: 121, 3: 9 , 5: 25 , 7: 49}
a = [1, 2, 3] b = [7, 8, 9] [(x + y) for (x,y) in zip(a,b)] # parallel iterators # output => [8, 10, 12] [(x,y) for x in a for y in b] # nested iterators # output => [(1, 7), (1, 8), (1, 9), (2, 7), (2, 8), (2, 9), (3, 7), (3, 8), (3, 9)]
my_list = [[10,20,30],[40,50,60],[70,80,90]] flattened = [x for temp in my_list for x in temp] # output => [10, 20, 30, 40, 50, 60, 70, 80, 90]
Note: List comprehensions have the same effect as the map method in other languages. They follow the mathematical set builder notation rather than map and filter functions in Python.
There are several built-in data types in Python. Although, Python doesn't require data types to be defined explicitly during variable declarations but type errors are likely to occur if the knowledge of data types and their compatibility with each other are neglected. Python provides type() and isinstance() functions to check the type of these variables. These data types can be grouped into the following catetgories-
None keyword represents the null values in Python. Boolean equality operation can be performed using these NoneType objects.
| Class Name | Description |
|---|---|
| NoneType | Represents the NULL values in Python |
| Class Name | Description |
|---|---|
| int | Stores integer literals including hex, octal and binary numbers as integers |
| float | Stores literals containing decimal values and/or exponent sign as floating-point numbers |
| complex | Stores complex number in the form (A + Bj) and has attributes: real and imag |
| bool | Stores boolean value (True or False) |
in and not in operators defined for their traversing their elements. These operators share the same priority as the comparison operations.
| Class Name | Description |
|---|---|
| list | Mutable sequence used to store collection of items. |
| tuple | Immutable sequence used to store collection of items. |
| range | Represents an immutable sequence of numbers generated during execution. |
| str | Immutable sequence of Unicode code points to store textual data. |
bytearray bytes memoryview
, and
str
.
| Class Name | Description |
|---|---|
| dict | Stores comma-separated list of key: value pairs |
add() and remove(). frozenset type is immutable and can't be modified after creation.
| Class Name | Description |
|---|---|
| set | Mutable unordered collection of distinct hashable objects |
| frozenset | Immutable collection of distinct hashable objects |
set is mutable and thus cannot be used as key for a dictionary. On the other hand, frozenset is immutable and thus, hashable, and can be used as a dictionary key or as an element of another set.
mymod.myobj, where mymod is a module and myobj references a name defined in m's symbol table. The module's symbol table resides in a very special attribute of the module __dict__, but direct assignment to this module is neither possible nor recommended.
Lambda is an anonymous function in Python, that can accept any number of arguments, but can only have a single expression. It is generally used in situations requiring an anonymous function for a short time period. Lambda functions can be used in either of the two ways:
mul = lambda a, b : a * b print(mul(2, 5)) # output => 10
def myWrapper(n): return lambda a : a * n mulFive = myWrapper(5) print(mulFive(2)) # output => 10
The pass keyword represents a null operation in Python. It is generally used for the purpose of filling up empty blocks of code which may execute during runtime but has yet to be written. Without the pass statement in the following code, we may run into some errors during code execution.
def myEmptyFunc(): # do nothing pass myEmptyFunc() # nothing happens ## Without the pass keyword # File "<stdin>", line 3 # IndentationError: expected an indented block
In Python, the assignment statement (= operator) does not copy objects. Instead, it creates a binding between the existing object and the target variable name. To create copies of an object in Python, we need to use the copy module. Moreover, there are two ways of creating copies for the given object using the copy module -
from copy import copy, deepcopy list_1 = [1, 2, [3, 5], 4] ## shallow copy list_2 = copy(list_1) list_2[3] = 7 list_2[2].append(6) list_2 # output => [1, 2, [3, 5, 6], 7] list_1 # output => [1, 2, [3, 5, 6], 4] ## deep copy list_3 = deepcopy(list_1) list_3[3] = 8 list_3[2].append(7) list_3 # output => [1, 2, [3, 5, 6, 7], 8] list_1 # output => [1, 2, [3, 5, 6], 4]
xrange() and range() are quite similar in terms of functionality. They both generate a sequence of integers, with the only difference that range() returns a Python list, whereas, xrange() returns an xrange object.
So how does that make a difference? It sure does, because unlike range(), xrange() doesn't generate a static list, it creates the value on the go. This technique is commonly used with an object type generators and has been termed as "yielding".
Yielding is crucial in applications where memory is a constraint. Creating a static list as in range() can lead to a Memory Error in such conditions, while, xrange() can handle it optimally by using just enough memory for the generator (significantly less in comparison).
for i in xrange(10): # numbers from o to 9 print i # output => 0 1 2 3 4 5 6 7 8 9 for i in xrange(1,10): # numbers from 1 to 9 print i # output => 1 2 3 4 5 6 7 8 9 for i in xrange(1, 10, 2): # skip by two for next print i # output => 1 3 5 7 9Note: xrange has been deprecated as of Python 3.x. Now
range does exactly the same what xrange used to do in Python 2.x, since it was way better to use xrange() than the original range() function in Python 2.x.
Python packages and Python modules are two mechanisms that allow for modular programming in Python. Modularizing ahs several advantages -
Modules, in general, are simply Python files with a .py extension and can have a set of functions, classes or variables defined and implemented. They can be imported and initialized once using the import statement. If partial functionality is needed, import the requisite classes or functions using from foo import bar.
Packages allow for hierarchial structuring of the module namespace using dot notation. As, modules help avoid clashes between global variable names, in a similary manner, packages help avoid clashes between module names.
Creating a package is easy since it makes use of the system's inherent file structure. So just stuff the modules into a folder and there you have it, the folder name as the package name. Importing a module or its contents from this package requires the package name as prefix to the module name joined by a dot.
global keyword.
Self is a keyword in Python used to define an instance or an object of a class. In Python, it is explicity used as the first paramter, unlike in Java where it is optional. It helps in disinguishing between the methods and attributes of a class from its local variables.
__init__ is a contructor method in Python and is automatically called to allocate memory when a new object/instance is created. All classes have a __init__ method associated with them. It helps in distinguishing methods and attributes of a class from local variables.
# class definition class Student: def __init__(self, fname, lname, age, section): self.firstname = fname self.lastname = lname self.age = age self.section = section # creating a new object stu1 = Student("Sara", "Ansh", 22, "A2")
| Break | The break statement terminates the loop immediately
and the control flows to the statement after the body of the loop. |
| Continue | The continue statement terminates the current iteration of the statement,
skips the rest of the code in the current iteration and the control flows to the next iteration of the loop. |
| Pass | As explained above, pass keyword in Python is generally used to fill-up empty blocks
and is similar to an empty statement represented by a semi-colon in languages such as Java, C++, Javascript etc. |
pat = [1, 3, 2, 1, 2, 3, 1, 0, 1, 3] for p in pat: pass if (p == 0): current = p break elif (p % 2 == 0): continue print(p) # output => 1 3 1 3 1 print(current) # output => 0
Python library offers a feature - serialization out of the box. Serializing a object refers to transforming it into a format that can be stored, so as to be able to deserialize it later on, to obtain the original object. Here, the pickle module comes into play.
Pickling
Pickling is the name of the serialization process in Python.
Any object in Python can be serialized into a byte stream and dumped as a file in the memory. The process of pickling is compact but pickle objects can be compressed further. Moreover, pickle keeps track of the objects it has serialized and the serialization is portable across versions.
The function used for the above process is pickle.dump().
Unpickling
Unpickling is the complete inverse of pickling. It deserializes the byte stream to recreate the objects stored in the file, and loads the object to memory.
The function used for the above process is pickle.load().
Generators are functions that return an iterable collection of items, one at a time, in a set manner. Generators, in general, are used to create iterators with a different approach. They employ the use of yield keyword rather than return to return a generator object.
Let's try and build a generator for fibonacci numbers -
## generate fibonacci numbers upto n def fib(n): p, q = 0, 1 while(p < n): yield p p, q = q, p + q x = fib(10) # create generator object ## iterating using __next__(), for Python2, use next() x.__next__() # output => 0 x.__next__() # output => 1 x.__next__() # output => 1 x.__next__() # output => 2 x.__next__() # output => 3 x.__next__() # output => 5 x.__next__() # output => 8 x.__next__() # error ## iterating using loop for i in fib(10): print(i) # output => 0 1 1 2 3 5 8
PYTHONPATH is an environment variable which you can set to add additional directories where Python will look for modules and packages. This is especially useful in maintaining Python libraries that you do not wish to install in the global default location.
help() function in Python is used to display the documentation of modules, classes, functions, keywords, etc. If no parameter is passed to the help() function, then an interactive help utility is launched on the console.
dir() function tries to return a valid list of attributes and methods of the object it is called upon. It behaves differently with different objects, as it aims to produce the most relevant data, rather than the complete information.
In Python, arguments are passed by reference, i.e., reference to the actual object is passed.
def appendNumber(arr): arr.append(4) arr = [1, 2, 3] print(arr) #Output: => [1, 2, 3] appendNumber(arr) print(arr) #Output: => [1, 2, 3, 4]
class ArrayList: def __init__(self, number_list): self.numbers = number_list def __iter__(self): self.pos = 0 return self def __next__(self): if(self.pos < len(self.numbers)): self.pos += 1 return self.numbers[self.pos - 1] else: raise StopIteration array_obj = ArrayList([1, 2, 3]) it = iter(array_obj) print(next(it)) #output: 2 print(next(it)) #output: 3 print(next(it)) #Throws Exception #Traceback (most recent call last): #... #StopIteration
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] print(numbers[1 : : 2]) #output : [2, 4, 6, 8, 10]
import os os.remove("ChangedFile.csv") print("File Removed!")
string = "This is a string." string_list = string.split(' ') #delimiter is ‘space’ character or ‘ ‘ print(string_list) #output: ['This', 'is', 'a', 'string.'] print(' '.join(string_list)) #output: This is a string.
import array a = array.array('i', [1, 2, 3]) for i in a: print(i, end=' ') #OUTPUT: 1 2 3 a = array.array('i', [1, 2, 'string']) #OUTPUT: TypeError: an integer is required (got type str) a = [1, 2, 'string'] for i in a: print(i, end=' ') #OUTPUT: 1 2 string
*args
def multiply(a, b, *argv): mul = a * b for num in argv: mul *= num return mul print(multiply(1, 2, 3, 4, 5)) #output: 120
**kwargs
def tellArguments(**kwargs): for key, value in kwargs.items(): print(key + ": " + value) tellArguments(arg1 = "argument 1", arg2 = "argument 2", arg3 = "argument 3") #output: # arg1: argument 1 # arg2: argument 2 # arg3: argument 3
arr = [1, 2, 3, 4, 5, 6] #get the last element print(arr[-1]) #output 6 #get the second last element print(arr[-2]) #output 5
"Hello World"[::-1]? func = lambda a, b : (a ** b), what is the output of func(float(10),20) ?list1 = ['s', 'r', 'a', 's'] and list2 = ['a', 'a', 'n', 'h'], what is the output of ["".join([i, j]) for i, j in zip(list1, list2)]? time.time() in Python returns? 
Log In using
