DEV Community: Mrigendra Prasad

Recursion: One more way.

Mrigendra Prasad — Fri, 23 Sep 2022 19:04:13 +0000

So, now that you are familiar with iterators right? if not then

Iterators

Iterators are one of the fundamental concepts of programming. It is used to loop through all the elements of an array and perform the same operation on all of them or you can perform an operation number of times like printing a text 100 times with just a few lines of code with the help of iterators. In Python iterators are "for loop" and "while loop". Let's take an example of factorial using for loop.

def fact(n):
    f = 1
    if n == 0:
        return 1
    elif n == 1:
        return 1
    else:
        for i in range(1, n+1):
            f *= i
        return f

print(fact(5))
>>> 120

But there is one more way to do that and that is recursion.

Recursion

Recursion is a technique by which a function calls itself but in its simpler form. It is an important concept and most of the time it is used in data structures. Let's take the example of factorial using recursion:

def fact_re(n):
    if n == 1:
        return 1
    elif n == 0:
        return 1
    else:
        return n * fact_re(n -1)

print(fact_re(5))
>>> 120

So, here you can see that fact_re() is calling itself but the argument passed is less than that of the initial function. Hence, every time the function calls itself the argument becomes smaller and smaller, and at some point, it will become 1 since we have already provided a condition that if the argument is equal to 1 it will return 1 and the function will stop calling itself after reaching that condition.

Here, if you compare both functions, the iterator one and the recursion one, you will find that the recursion one contains fewer lines of code and that's what programmers want.

Programmers are so lazy.

Recursion helps to develop logical thinking and improves problem-solving skills.
It is easier to write and debug code for data structures using recursion.
It reduces time complexity for larger codes.

Types of recursion

Yes, recursion also has different types. It is of three types basically:

Linear recursion: If a recursive function is invoking itself at most one time during its execution then it is known as linear recursion. It can be a useful tool for processing a data sequence like lists or tuples in Python. For example:- The factorial function that we have seen above. Let's take another example to illustrate it better

def power(x, n):
    if n == 0:
        return 1
    else:
        return x * power(x, n - 1)


print(power(3, 4))
>>> 81

In the above example "x" is a number and "n" is the power. Here is the illustration:-

Binary Recursion: In binary recursion, a recursive function calls itself twice in each execution. Let's understand it by an example.

The most famous example is the Fibonacci series. It is a series of positive numbers in which each number is the sum of the preceding two numbers and it starts from 0 and 1.

         0 1 2 3 5 8 13 ....

This is what it looks like.
Now, let's print it using a recursive function.

def fib(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib(n-1) + fib(n-2)

print(fib(6))
>>> 8

This function returns the number at the given index, where n is the index that a user will provide. So here you can see line number 7, we have called the same function twice but in a much simpler form. Let's see another example where we will print an English ruler like

this. Give it a try before we will dive into solving this using the recursive function.

Now if you have tried it by yourself let's solve it. Here, you can see a pattern i.e. dashes are decreasing from 4 to 1 and then increasing from 1 to 4, and at every line having maximum dashes, there is a number. So let's write a function that prints dashes.

def draw_line(tick_length, tick_label=""):
    line = tick_length * "-"
    if tick_label:
        line += ' ' + tick_label
    return line

print(draw_line(4, 0))
>>> ----

draw_line() function accepts two arguments the length of the line and if any line has a label prints it. Note: tick_label should be a string.
Now let's provide an interval so that the draw_line() function prints the line according to the length and interval.

def draw_interval(center_length):
    if center_length > 0:
        draw_interval(center_length - 1)
        draw_line(center_length)
        draw_interval(center_length - 1)

This function provides an interval to print the line.

In this function, you can see that the draw_interval() function calls itself twice but in its simpler form.

Now let's finally draw the ruler

def draw_ruler(line_length, ruler_length):
    draw_line(line_length, "0")
    for j in range(1, ruler_length + 1):
        draw_interval(line_length - 1)
        draw_line(line_length, str(j))

print(draw_ruler(5, 6))
>>>
----- 0
-
--
-
---
-
--
-
----
-
--
-
---
-
--
-
----- 1
-
--
-
---
-
--
-
----
-
--
-
---
-
--
-
----- 2
-
--
-
---
-
--
-
----
-
--
-
---
-
--
-
----- 3
-
--
-
---
-
--
-
----
-
--
-
---
-
--
-
----- 4
-
--
-
---
-
--
-
----
-
--
-
---
-
--
-
----- 5
-
--
-
---
-
--
-
----
-
--
-
---
-
--
-
----- 6

Congratulation, you have drawn your ruler using Python.

In the function draw_ruler() we have used for loop because this function cannot be broken into a smaller form to generate a continuous number.

Multiple Recursion:As the name suggests it is a process in which a function can call itself more than two times in each execution. This type of recursion is used to analyze the disk space usage of a file system because the number of recursive calls depends upon the entries within a given folder of a file system.

Summary

In this article, we saw another way of iteration using a function that calls itself in every execution but a simpler form and we are calling that function a recursive function.

Thanks For Reading

Classification of data structures in Python.

Mrigendra Prasad — Mon, 19 Sep 2022 16:13:43 +0000

Python is one of the most popular programming languages in the world. It is used for so many things such as making backends for websites, artificial intelligence, data science, and much more. We need lots and lots of data sets to work in these fields, for example, on websites there are lots of data of may be products or users which we need to store in such a way that they can be accessed efficiently. Then in artificial intelligence, we need data in millions. So to manage this amount of data, we structure them so they can be accessed efficiently. This structure of data is called Data Structures.

The format for efficiently storing, organizing, and managing data is called Data Structures.

What are the different types of data structures?

Python provides different kinds of data structures to facilitate problem-solving. These can be classified as linear or non-linear, primitive or non-primitive, and contiguous or non-contiguous. Let's talk about all of them in detail.

Primitive: These are the basic set of different data types from which all the other data types are constructed. It is also called simple data type. It cannot be null (empty). This includes integers, strings, floats, and boolean in Python.
Non-Primitive: These are the type of data structures that can store more than one type of data. It is also called complex data type. It can be null. This includes arrays, lists, tuples, sets, dictionaries, linked lists, stacks, etc.
Contiguous: As its name suggests that these contain those values that are stored in contiguous memory locations. For example, in an array, the elements are stored in an adjacent memory location one after another. In this type of data structure, the data element can be of primitive data type or complex data type. This includes arrays, tuples, sets, objects, strings, lists, maps, and dictionaries.
Non-Contiguous: In this type of data structure, the data elements are scattered across different memory locations. Here each data item is stored in the form of nodes which keeps a link to one or more other nodes in the collection. This includes linked lists, maps, and graphs.
Linear: In linear data structures, the elements are accessed in a sequential order irrespective of whether the data items are contiguous or non-contiguous. This includes arrays, linked lists, stacks, queues, and lists.
Non-Linear: In a nonlinear data structure, the elements are present in the form of nodes and they are accessed in nonlinear order and they are stored in noncontiguous order. Examples include trees and graphs.

Built-in Data Structures in Python.

Python provides four built-in data structures that cover almost 80% of the real-world data structures. Let's discuss them in detail.

1.List: Lists are the simplest container that comes inbuilt in Python. In other words, lists are the collection of elements within the [ ] brackets and separated by commas. A single list can contain elements of different data types and it can contain multiple elements of the same data type. A list is a mutable type which means the elements can be altered after the creation of the list.

      l1 = [1, 2, 3, "Hello", 3.4, 2 + 3j, 2, 3]
      print(l1)
      >>> [1, 2, 3, "Hello", 3.4, 2 + 3j, 2, 3]
      print(l1[0])
      >>> 1
      print(l1[2:3])
      >>> [3, "Hello"]

Note: A list can contain another list, tuples, dictionaries, and sets inside it.

2.Tuple: A tuple is also a collection of elements inside ( ) and they are separated by commas. It shares lots of functionality with the list like it can contain elements of multiple data types, accessing elements by indexing. A tuple is immutable which means we cannot change elements inside it once it has been created.

     t1 = (4, 5, 6, 4, 5, "World")
     print(t1)
     >>> (4, 5, 6, 4, 5, "World")

3.Dictionary: A dictionary is a collection of key-value pairs within { } brackets in python. In a dictionary, every element has its own key which is used to access the element unlike in lists and tuples where we use the index number to access elements. Here key and value are separated by a colon (":") and the key-value pair is separated by commas. Values inside a dictionary can be of any data type or they can be lists or tuples or even dictionaries as well but keys should be immutable and non-repeating. Keys are case sensitive which means the same name but different cases will be treated differently.

     d1 = {"key1":1, "key2":[1,2,3], "key3":(4,5,6), "key4":"Hello"}
     print(d1)
     >>> {"key1":1, "key2":[1,2,3], "key3":(4,5,6), "key4":"Hello"}
     print(d1["key1"])
     >>> 1

4.Set: A set is an unordered collection data type that is mutable, and iterable but it does not contain multiple elements of the same data type. The main advantage of using a set collection is that it has a highly optimized method to check whether the specific element is present in the set or not. Since a set is unordered hence we cannot access elements by index numbers like in lists. For creating a set we use { } braces

     s1 = {1, 2, 3, 4, 5}
     print(s1)
     >>> {1, 2, 3, 4, 5}

Summary

In this article, we talked about different types of data structures present in Python. And then we saw the built-in data structures in Python and their examples. Hope you have enjoyed it.

Thanks for reading.

Operators in Python

Mrigendra Prasad — Mon, 19 Sep 2022 14:38:05 +0000

"Operators are one of the main concepts in programming"

Now, we have variables and different types of data types and we need to perform some operations with our data or values like calculations or comparisons, etc. So, here comes the operators which help us to perform these operations. In Python, we have different types of operators and these are:

(i) Logical Operators: Logical operators are the operators which compare two expressions and return the value in True or False. Following are the logical operators:

1) and: It compares two expressions and returns True if both the operators return True. For example -: let's take two expressions A and B then

2) or: It compares two expressions and returns True if one of the expressions returns True. For example -: let's take two expressions
A and B then

3) not: It returns True if the expression returns False and returns False if the expression returns True.

(ii) Equality Operators: These operators strictly check the equality of two values. The following operators belong to this equality operator:

1) ==: Equivalent Operator, returns True if both the value are equal. For example

            2 == 2
            returns True

2) !=: Not Equivalent, returns True if both values are not equal.

            2 != 3
            returns True

3) is: Same Identity, it is for reference equality. It checks if two variables point toward the same object.

            a = 1
            b = 1
            a is b
            returns True

4) is not:Different Identity, it checks if both variables don't point toward the same object.

            a = 1
            b = "1"
            a is not b
            returns True

(iii) Comparison Operators: Comparison operators are the operators which are used to compare two values. Following are the comparison operators available in Python:

1) <: Less than, it checks if the left-hand side value is less than that of the right-hand side value if so it returns True.

             2 < 3
             returns True
             4 < 2
             returns False

2) >: Greater than, it checks if the left-hand side value is greater than that of the right-hand side value, if so it returns True.

             2 > 3
             returns False
             4 > 2
             returns True

3) <=: Less than equal to, it checks if the left-hand side value is less than or equal to that of the right-hand side value, if so it returns True.

             3 <= 3
             return True
             2 <= 4
             return True
             3 <= 2
             return False

4) >=: Greater than equal to, it checks if the left-hand side value is greater than or equal to that of the right-hand side value

             3 >= 3
             return True
             2 >= 4
             return False
             3 >= 2
             return True

(iv) Arithmetic Operators: Arithmetic operators are used to performing mathematical operations like calculations. Following are the arithmetic operators present in Python:

1) +: Use for addition

2) -: Use for subtraction

3) *: Use for multiplication

4) /: Use for division

5) //: Integer division, returns the integer part of the quotient For example:

6) %: Modulo operator: it returns the remainder of the division For example:

There are many other operators in Python like the Bitwise operator and Sequence operator.

Summary

So in this article, we have talked about operators and the different types of operators present in Python programming language. Hope you have enjoyed it.

Thanks for reading!

Data Types in Python

Mrigendra Prasad — Thu, 08 Sep 2022 10:30:38 +0000

Data Structure And Algorithms using Python

Python is one of the most popular programming languages. It is a high-level, easy-to-learn interpreted programming language. It was developed by Guido Van Rossum in 1991. Today, Python is used for many purposes like software development, data analysis, machine learning, robotics, backend web development, desktop application, GUIs, 2d game development, etc. So here in this repository, I am adding Data Structure and Algorithm concepts and problems and their solution.

Data Types in Python

In programming, we need to classify the data or value so that we can perform different operations on different data types
for example, The "+" operator will add two values if they are integer or #float while the same operator will concatenate two strings
So we can see that the same operator operates different types of values differently based on its data type, hence classifying the values with different data types is very important

Data types available in Python

(i) Integer
-> In Python, we represent whole numbers using int (integer). In integers, numbers can lie anywhere from negative infinity to positive infinity which makes it convenient for us to deal with integers without caring much about the memory size it will take because Python will handle it automatically.

 x = 4

 print(type(x))

 output >>  <class "int">

(ii) Float
-> In Python to represent a real number having decimal point we use float. It represents both rational and irrational numbers. There can be any number of digits before or after the decimal point.

 x = 4.0

 print(type(x))

 output >>  <class "float">

(iii) Complex Numbers
-> In Python, we can also work with the complex number where we represent an imaginary number. For example, a + bj is a complex number where a and b are real numbers and j is an imaginary number.

  x = 2 + 3j

  print(type(x))

  output >> <class "complex">

(iv) String
-> String values are the combination of letters, characters, numbers, and special characters inside the single, double, or even triple quotation mark. Most of the
time we use single and double quotation marks for single-line strings and while we want to write multi-line strings we use triple quotation marks.

  x = "Hello World"

  print(type(x))

  output >> <class 'str'>

(v) Boolean
-> Boolean has only two values True (T is always capital) and False (F is always capital). We use boolean data type when we have to make a decision or write conditional statements. We can also represent boolean values by using numbers such as 1 for True and 0 for False.

  x = True

  print(type(x))

  output >> <class 'bool'>

(vi) None
-> Suppose a situation where you have to declare a variable without initializing the variable then there comes a "none" type to save you. It is used to declare a
variable with any initial value.

  x = None

print(type(x))

output >> <class 'NoneType'>

Summary

These are the data types available in python and we will discuss them in details in my next post

Thanks For Reading