Explore topic-wise InterviewSolutions in .

Magic Commands are one of the new features added to the python shell. Basically, they are enhancements over the normal python code, provided by the IPython Kernel. The main syntax for these commands is that they are prefixed by as “%” character. They prove useful in solving many common problems we encounter while coding and also provide us some versatile shortcuts.
There are main kinds of commands:

• 
  %prefix: The command will operate only on the given single line of code.


• 
  %%prefix: The command will operate on the entire code block.

Some examples of these commands in Python are:

• %run: It is used for running an external file in Python.

• 
  %%time: This allows us to track the amount of time taken by our code for execution.

• 
   %%writefile: This command will copy content from our current code cell to another external file.

• 
   $pycat: This command is used to display the contents of an external file.

• 
  %who: This command lists all the variables in the Python notebook.

• 
   %%html: This command will let us write and execute html code in the current cell.

Output:

• 
  %env: This command allows us to list all the environment variables, set a value for such a variable, and get the value of such a variable.

• 
  %pinfo: This command provides detailed information regarding the object passed along with it. It works similar to that of the object? function.

Note: All the magic commands can be listed by using the %lsmagic command.

Some other useful tools for Python

• 
  pipenv: It is a packaging tool for python aimed to solve common problems which are associated with the typical program workflow.


• 
  poetry: It is a dependency management and packaging tool in Python.

We can conclude that Python is a robust, high-level, interpreted programming language. It is also an Object Oriented Programming Language that strongly follows all OOPs principles. It has various inbuilt powerful modules that follow simple syntax which makes it appealing to both beginners and experienced folks alike. A vast collection of libraries and functions makes the development of any sort much easier in Python. In this cheat sheet, we have covered the most common fundamentals of python language that would help you kickstart your career in python.

Useful Resources:

• Python Interview Questions


• Python Projects


• Python Developer: Career Guide


• Python Developer Skills


• Fast Track Python

Virtual Environments are used to encapsulate certain Python Libraries of Python for single project, which might not be used in other projects, rather than installing those dependencies globally.

Installation Steps:

Usage Steps:

Python Classes used for storing data objects are called Dataclasses. They have certain features like:

• Comparison with other objects of the same type is possible.


• Stores data, representing a particular data type.

Python 2.7:

The example shows the performing function of Dataclasses in older versions of python when Dataclasses were not yet introduced.

Python 3.7:

The example shows using dataclasses in newer versions of python.

Note: It is compulsory to specify the datatype of each variable declared. If at any point we don’t want to specify the type, set the type as typing.Any.

__main__ is the name of the scope in which the top-level code executes. It can check if it is running in its own scope by checking its own __name__.
Format of checking:

We can pass a variable number of arguments to a function using special symbols called *args and **kwargs.

The usage is as follows:

• 
     *args: For non-keyword arguments.

   Example:

• 
   **kwargs: For keyword arguments.

   Example:

The ternary operator is used as an alternative to the if-else conditional statements and provides a way to write a short crisp one-liner statement.

The syntax is as follows:

These are small anonymous functions in python, which can take any number of arguments but returns only 1 expression.

Let us understand it with an example,

Consider the function which multiplies 2 numbers:

The equivalent Lambda function for this function will be:

The syntax for this will be as shown below:

Similarly, other functions can be written as Lambda functions too, resulting in shorter codes for the same program logic.

Logging allows us to keep track of some events which occurs when some software runs. It becomes highly important in Software Development, Debugging and Running Softwares.

Levels of Logging:

Described in order of increasing importance

Raising Exceptions with raise statement:

The raise statement is used to raise exceptions and consists of 3 components:

• raise keyword


• Exception() function call


• Parameter of the Exception() function, which usually contains an error message.

Traceback as String

There is a function in python called traceback.format_exc() which returns the traceback displayed by Python when a raised Exception is not handled as a String type. The Traceback Module is required to be imported for this purpose.

Example:

Assert Statements in Python:

Assert Statements/Assertions are widely used for debugging programs and checking if the code is performing some operation that is obviously wrong according to the logic of the program. The special thing about assert is that when an assert fails, the program immediately crashes, allowing us to narrow down our search space for the bug.
Writing an assert statement has the following components as a part of it,

• assert keyword


• a condition that results in a boolean value


• a display message for when the assertion fails


• a comma separating the condition and the display message.

Assertions can be disabled by passing the -O option when running Python as shown in the commands below.

• Regex Matching

The re module in python allows us to perform regex matching operations.

The above example landline number from the string and stores it appropriately in the num variable using regex matching.

• Parenthesis Grouping

A group is a part of a regex pattern enclosed in parenthesis (). We can put matches into different groups using the parenthesis (). We can access the groups using group() function.

• Regex Symbols in Python

There are a lot of regex symbols that have different functionalities so they are mentioned in the table below:

Example:

Here we define a regex pattern,

From the above table, we can explain some of the symbols in this pattern:

• \s?: 0 or 1 whitespace.


• (\d*): 0 or more digit characters.


• (.+): Greater than or equal to 1 characters.


• \s: Single Whitespace


• ([A-Z]{2, 3}): 2 or 3 Uppercase alphabets


• (\d{4}): 4 digit characters

To handle date and time operations in Python, we use the datetime module.

• 
  time class: We can represent time values using the time class.

   Example:

• 
  date class: We can represent date values using the date class.

   Example:

• 
  Conversion from date to time: We can convert a date to its corresponding time using the strptime() function.

   Example:

• 
  time.strftime() in Python: It converts a tuple or struct_time representing the time into a string object.

   For example:

• Escape Sequences:

Escape Sequences are used to print certain characters to the output stream which carry special meaning to the language compiler.

Examples:

• Multiline Strings:

Multiline Strings are used in python through triple quotes '''

Example:

• Strings Indexing:

Strings in Python are indexed the same way as a list of characters, based on 0-based indexing. We can access elements of a string at some index by using the [] operators.

Consider an example of the string value Python.

• Strings Slicing:

Slicing is also done the same way as in lists.

• Case Conversion Functions:

The upper() and lower() functions are used to convert a string of letters into uppercase or lowercase respectively.

The isupper() and islower() functions are used to check if a string is in all uppercase or lowercase respectively.

Other similar functions:

• join() and split() Functions:

join() function merges elements of a list with some delimiter string, and returns the result as a string.

split() function splits the into tokens, based on some delimiters and returns the result as a list.

In general, a string can be split to list using split() method and a list can be joined to string using the join() method as shown in the image below:

• String Formatting:

String Formatting is done with the str.format() function.

• Template Strings:

It is recommended to be used when formatting strings generated by users. They make the code less complex so are easier to understand. They can be used by importing the Template class from the string module.

Example:

• 
  List Comprehensions:
  It is a shorter syntax to create a new list using values of an existing list.

• 
  Set Comprehension:
   It is a shorter syntax to create a new set using values of an existing set.

• 
  Dict Comprehension:
   It is a shorter syntax to create a new dictionary using values of an existing dictionary.

Initializing Sets:

Sets are initialized using curly braces {} or set() in python.

A python set is basically an unordered collection of unique values, i.e. it will automatically remove duplicate values from the set.

Inserting elements in set:

We can insert a single element into a set using the add function of sets.

To insert multiple elements into a set, we use the update function and pass a list of elements to be inserted as parameters.

Deleting elements from the set:

We can delete elements from a set using either the remove() or the discard() function.

Operators in sets:

The below table shows the operators used for sets:

The set operators are represented in the Venn Diagram below:

Examples:

Dictionaries in Python are equivalent to Maps in C++/JAVA. They are used to store data in key-value pairs.

Printing key and values in dictionaries:

To print the keys of the dictionary, use the .keys() method and to print the values, use .values() method.

Output:

Update key value in dictionary:

• 
  Update key value which is not present in dictionary:
  We can update a key value in a dictionary by accessing the key withing [] and setting it to a value.

• 
  Update key value which is present in the dictionary:
  We can update a key value in a dictionary, when the key is present in the exact same way as we update a key, when the key is not present in the dictionary.

• 
  Delete key-value pair from dictionary:
  We can delete a key-value pair from a dictionary using the del keyword followed by the key value to be deleted enclosed in [].

Merging 2 dictionaries

We can merge 2 dictionaries into 1 by using the update() method.

Tuples are entities in Python that work almost similar to that of lists, but differ in the main feature from lists, is in that they are inmutable.

They are initialized by writing the elements of the tuple with (), separated by commas.

Type Converting between Tuples, Lists, and Strings:

Lists are used to store multiple items in a single variable. Their usage and some functions are shown below with examples:

• 
  Accessing elements in a List:
  Accessing elements in a list basically means getting the value of an element at some arbitrary index in the list.
  Indexes are assigned on 0 based basis in python. We can also access elements in python with negative indexes. Negative indexes represent elements, counted from the back (end) of the list.

• 
  Slicing a List:
  Slicing is the process of accessing a part or subset of a given list. The slicing is explained in the image below:

• 
  Changing Values in a List:
  We can change values at some particular index in a list by accessing the element with [] and then setting it to some other value.

• List Concatenation and Replication:

When we merge the contents of 2 lists into one list, it is called list concatenation.

Copying the contents of a list, some finite number of times into the same or some list is called list replication.

• 
  Delete values from Lists:
  We can delete a particular element from a list by using the del keyword.

• 
  Looping through Lists:
  The below example shows how we can iterate over all the elements present in a list.

in and not in keywords:
With the in keyword, we can check if some particular element is present in the given python variable.
Similar to the not in keyword, we can check if some particular element is not present in the given python variable.

• Adding Values in Lists:

insert(): This function inserts an element into a particular index of a list.

append(): This function appends an element at the back of a list.

• 
  Sorting a List:
  Sorting a list means arranging the elements of the list in some particular order. We sort a list by using the sort() function.

Exception Handling is used to handle situations in our program flow, which can inevitably crash our program and hamper its normal working. It is done in Python using try-except-finally keywords.

• 
  try: The code in try section is the part of the code where the code is to be tested for exceptions.


• 
  except: Here, the cases in the original code, which can break the code, are written, and what to do in that scenario by the program.


• 
  finally: The code in the finally block will execute whether or not an exception has been encountered by the program.

The same has been illustrated in the image below:

Example:

Python has various external libraries of code with useful utilities and functions. To use these modules, we need to import them into our code, using the import keyword.

For example, if we want to use the functionalities of the math module, then we can import it in our python code by using import math as shown in the example below.

If we want to perform any string manipulations, we can use the string module as import string in python. More of this is covered in the String Manipulation section below.

To modify a global variable from inside a function, we use the global statement:

We set the value of “value” as Global. To change its value from inside the function, we use the global keyword along with “value” to change its value to local, and then print it.

Scope of a variable is the part of the code, where it can be accessed freely and used by the program.

The scopes in the above image are explained as follows:

• 
  Built-in: These are reserved names for Python built-in modules.


• 
  Global: These variables are defined at the highest level.


• 
  Enclosed: These variables are defined inside some enclosing functions.


• 
  Local: These variables are defined inside the functions or class and are local to them.

The rules used in Python to resolve scope for local and global variables are as follows:

• Code in the global scope cannot use any local variables.


• Code in a function’s local scope cannot use variables in any other local scope.


• However, a local scope can access global variables.


• We can use the same name for different variables if they are in different scopes.

Functions are used to well-organized our code and enhance code readability and reusability. In Python, a function is defined using the def keyword. A function can return some value, or not depending upon its use case. If it has to return a value, the return statement (which has been discussed) is used. The syntax of a python function is shown in the image below:

Example of a function:

• 
  break: break statements are used to break out of the current loop, and allow execution of the next statement after it as shown in the flowchart below:

• 
  continue: continue statement allows us to send the control back to the starting of the loop, skipping all the lines of code below it in the loop. This is explained in the flowchart below:

• 
  pass: The pass statement is basically a null statement, which is generally used as a placeholder. It is used to prevent any code from executing in its scope.

• 
  return: return statement allows us to send the control of the program outside the function we are currently in. A function can have multiple return statements, but can encounter only one of them during the course of its execution.

Loops in Python are statements that allow us to perform a certain operation multiple times unless some condition is met.

For Loops: For loop is used to iterate iterables like string, tuple, list, etc and perform some operation as shown in the flowchart below:

• 
  For with range:
  This loop format will iterate overall numbers from 0 to Limit - 1.
  The below example prints numbers from 0 to 4.

• For with range(start, stop, step):

   This will run the loop from start to stop - 1, with step size = step in each iteration.
   In the below example, the start is 2, end point is 10 and the step size is 2. Hence it prints 2,4,6,8

• 
  For with in:
     This is used to iterate over all the elements in a python container like list, tuple, dictionary, etc.

• 
  While Loops:
  This is used for executing set of statements within its block as long as the associated loop condition is evaluated to True as shown in the image below:

• 
  If Statements: If statement is a condition statement that will perform some operation, if the expression given in it evaluates to true as shown below:

• 
   Elif Statements:  This statement is used in conjunction with the if statement to add some other condition which is evaluated if the condition in if statement fails.

• 
  Else Statements:  This statement is used to perform some operation, if all the if and elif statements evaluates to be false.

The final if-elif-else ladder looks like shown below:

The Table gives a list of boolean operators available in Python along with their functions:

Examples:

Relational Operators in Python

The Table gives a list of relational operators available in Python along with their functions:

Some examples are given below:

Note: Never use relational operators to compare boolean operations. Use is or is not operators for it.

Type casting is basically a conversion of variables of a particular datatype into some other datatype, such that the conversion is valid.

Type casting can be of two types:

• 
  Implicit Type Casting: In implicit type casting, the python compiler internally typecasts one variable into another type without the external action of the user.
  Example:

• 
  Explicit Type Casting: In explicit type casting, the user explicitly forces the compiler to convert a variable from one type to another. The different ways of explicit typecasting are given below:

1. Integer to String or Float:

To typecast an integer into a string type, we use the str() method. Similarly, to typecast it into a float type, we use the float() method.

For example:

2. Float to Integer:

To typecast a float datatype into an integer datatype, we use the int() method.

For example:

• print() function in Python

The print() function prints some specified message to the screen or some standard output device. We can print strings, numbers, or any other object using this function. We can print multiple tokens, and also specify to print the data separated by different delimiters using the print() function.

• input() function in Python

The input() function in Python is used to take any form of inputs from the user/standard input device, which can later be processed accordingly in the program. It is complementary to the print() function.

• len() function in Python

The len() function is used find the length(number of elements) of any python container like string, list, dictionary, tuple, etc.

• ord() function in Python

The ord() function in Python will return an integer that represents the Unicode Character passed into it. It takes a single character as a parameter.

Example:

Comments are lines of text/code in the program, which are ignored by the compiler during program execution.

There are multiple types of comments in python:

• Inline Comment -

We can write an Inline Comment by typing # followed by the comment.

• Multiline Comment -

We can write a Multiline Comment by typing # followed by the comment in each of the lines.

• Docstring Comment -

Docstring comments are achieved by Typing the comment within triple quotes. (''' comment ''')

Variables are names given to data items that may take on one or more values during a program’s runtime.
Following are the variable naming conventions in python:

• It cannot begin with a number.


• It must be a single word.


• It must consist of letters and _ symbols only.


• Variables in Python which start with _ (underscore) are considered as “Unuseful”.

Some examples are shown below:

The table below lists the different data types in Python along with some examples of them:

The Arithmetic Operators in the below table are in Lowest to Highest precedence.

Some examples are shown below: