What is a REST(Representational State Transfer) API?

API is the way by which systems communicate with each other. APIs can be used for various purposes, such as accessing web services, retrieving data from databases, or connecting different components of a software application. Rest API (also known as RESTful API) use standard HTTP methods (GET,PUT,PATCH,DELETE,POST) to perform operations. They are widely used in web development. It uses JSON(JavaScript Object Notation) as its message format which is platform independent language.

Their are different types of web APIS eg. (SOAP which uses XML as their message format, Open APIs or public APIs that are accessible to external developers and general public.)

Well their are so many public APIs to use for many purposes. But you can create your own APIs as well and now we'll understand how to make it using Django .

Making REST API using Django

• Installation :

1. Make a virtual environment to make things separate from system.

2. Activate it and install Django and Django-rest-framework.

3. Make a new Django project .

    python3 -m venv venv 
    ./venv/bin/activate #to activate it 
    pip install djangorestframework #this will also install django and djangorestframework
    django-admin startproject <project name>
    python manage.py startapp api #making your app
    python manage.py runserver #server started at localhost:8000
   

    python manage.py makemigrations
    python manage.py migrate
    python manage.py createsuperuser #to access the admin panel
    python manage.py runserver #go to localhost:8000/admin/
   

• Making model and changing settings :

1. We'll create a basic model for students with name and age only.

2. Go to the Settings.py file in the project folder and add your App name and package to it.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'api', #added app name
    'rest_framework' #installed package
]

1. Create models in models.py in api app.

from django.db import models
​
class Student(models.Model):
    name = models.CharField(max_length = 250)
    age = models.IntegerField()

    def __str__(self):  #for convenience in the admin panel
        return self.name

1. Now run these commands in terminal to migrate the the created model to Database.

python manage.py makemigrations
python manage.py migrate

1. Add some random data in the admin panel at localhost:8000/admin.

2. Create a new file serializers.py in the api app. Serializers.py basically serializes the data which you want to get or post in the JSON format.

from .models import Student
from rest_framework import serializers
​
​
class StudentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Student #the model which you want to serialise
        fields = '__all__' #fields you want. if want to add specific field do this ['field1','field2']

1. Now in the views.py and add your logics.

from django.shortcuts import render
from rest_framework import generics
from .models import Student
from .serializers import StudentSerializer
​
class StudentView(generics.ListCreateAPIView):
    queryset = Student.objects.all() #same like sql queries
    serializer_class = StudentSerializer #serialising the data

1. Now in the urls.py add your routes.

from django.urls import path,include
from .views import StudentView
​
urlpatterns = [
    path('student/',StudentView.as_view(),name='student'),
]

1. Now you can test your created url in Browser. Just simply open the browser and type 127.0.0.1:8000/student/ and all set !

2. Here, You can get as well post a new data of student.

Conclusion :

In this way you can create APIs using Django. You can add logic as well to protect your data, add specific logic for your data. You can read official documentation for more knowledge.

OVERVIEW:

OSI(Open System Interconnection) model is a conceptual model created to communicate over the network. Although the modern Internet is not based truly on the OSI model but on a simpler TCP/IP model.

HISTORY:

OSI model was introduced in 1983 by major computer and telecom companies. Later adopted by ISO(International Organisation for Standardization) as an international standard in 1984.

LAYERS OF OSI MODEL:

OSI model consists of 7 layers :

1. Application Layer

2. Presentation Layer

3. Session Layer

4. Transport Layer

5. Network Layer

6. Data Link Layer

7. Physical Layer

   ---

1. APPLICATION LAYER:

It is present at the top of the OSI model used by network applications like Chrome, Firefox, G-mail etc. An application layer is not an application, but it performs the application layer functions.

FUNCTION:

• FILE TRANSFER, ACCESS AND MANAGEMENT: An application layer allows users to access the files in a remote computer, to retrieve files from a computer.

PROTOCOLS USED:

A few application layer protocols are HTTP (Hypertext Transfer Protocol) for web surfing, FTP (File Transfer Protocol) for file transferring, SMTP (Simple Mail Transfer Protocol) for mail sending and receiving, DNS (Domain Name System) for converting domain names like www.google.com to its IP 197.193.232.3. etc.

2. PRESENTATION LAYER:

It receives data from the application layer. This layer serves as a data translator for the network. Data received is manipulated here.

FUNCTIONS:

• TRANSLATION: In this process, the data gets converted into a simple binary form.

• DATA COMPRESSION: It can be lossy or lossless. In lossy, the significant piece of data is removed to reduce size. While in lossless the data is transformed through encoding and then its size gets reduced.

• ENCRYPTION/DECRYPTION: Here the data is encrypted by the sender's side and decrypted by the receiver's side. As the data may often be sensitive, scrambling the data and then putting back together is Encryption and decryption.

PROTOCOLS USED:

A few presentation layer protocols are AFP (Apple Filing Protocol) is a network control protocol that offers services to macOS, NCP (NetWare Core Protocol) is used to access files, print, clock synchronization, messaging etc., SSL (Secure Socket Layer) is used to provide security to data that is being transferred between the web browser and the server.

3. SESSION LAYER:

These layers help in establishing sessions between different machines. It helps in maintaining, and terminating sessions between end-user applications.

FUNCTIONS:

• AUTHENTICATION: To establish a connection within the server. To know whether the other end-user is a legitimate one.

• AUTHORISATION: In this, although authentication of the user is done but you cannot access the files or data to which you are not authenticated.

• SESSION MANAGEMENT: The session layer helps in managing a session which includes opening, closing and managing sessions.

PROTOCOLS USED:

A few Session layer protocols are ADSP (Apple-Talk Data Stream Protocol) which allows to LAN to be connected with no setup, RTCP (Real-Time Transport Control Protocol) which provides feedback on the Quality of service, PAP (Password Authentication Protocol) which is used by PPTP (Point to Point Tunnelling Protocol) to validate users, etc.

NOTE:

ALL THE ABOVE 3 LAYER'S FUNCTIONS ARE PERFORMED BY THE BROWSER ITSELF.

4. TRANSPORT LAYER:

This layer takes data from the session layer and breaks it into segments on the sender's end. On the receiver's end, it reassembles the segments. It also checks how much data is being transported. This layer also checks if the data sent is correct or not.

FUNCTIONS:

• SEGMENTATION: It is the process of dividing a data packet into smaller units over the network. It then reassembles at the destination.

• FLOW CONTROL: It means sending the data to a rate that the receiver is capable of.

• ERROR CONTROL: This keeps an eye on missing segments or duplicate segments.

PROTOCOLS USED:

TCP (Transport Control Protocol) provides data transfer without any loss that can be used for emails etc., UDP (User Datagram Protocol) provides data transfer with some loss possible that can be used for video calls etc.

5. NETWORK LAYER:

The transport layer passes data segments to the network layer. It is the layer where the router resides. This layer is responsible for the transfer of network packets from source to destination. It sets the best path for the data to travel.

FUNCTIONS:

• LOGIC ADDRESSING: IP addressing done in the network layer is called logical addressing.

• PATH DETERMINATION: Choosing the best possible path to transfer the data from one computer to another.

• ROUTING: Routing is a method of moving data packets from source to destination. Based on the IP address format the data packet will first move to the network of the receiver and then into their system.

PROTOCOLS USED:

IP (Internet Protocol) address is a unique address that identifies a device a device on the Internet. It is a set of rules assigned to how data will be sent over the internet.

6. DATA LINK LAYER:

Data Link Layer takes the data packet from the network layer and breaks them into smaller pieces called frames. This layer is also responsible for flow and error control.

FUNCTIONS:

• FRAMING: Packets received from the network layer are called framing. A received data packet will be sent to the physical layer bit by bit. It also takes frames from the physical layer and sends them to the network layer.

• ADDRESSING: The data link layer encapsulates the source and destination’s MAC physical address in the header of each frame to ensure node-to-node delivery

• ERROR AND FLOW CONTROL: Corrupted data,s correction is the responsibility of the data link layer. The data link layer also synchronizes the sender's and receiver's speeds.

PROTOCOLS USED:

NCP (Network Control Protocol ) is a set of protocols forming a part of Point-to-Point Protocol (PPP), LCP (Link Control Protocol) is a part of PPP that operates in the data link layer.

7. PHYSICAL LAYER:

This layer includes physical components that are necessary from data transfer, like cables and switches. This is the layer where data gets converted into bit streams (basically it is a string of 1s and 0s).

FUNCTIONS:

• physical layer is the only layer in the OSI model that deals with physical connectivity and is responsible for establishing, maintaining and deactivating the physical connections of two different computing devices in a network.

• The physical layer controls the flow of data rate.

• It also deals with bit synchronization discussed above.

Since we have discussed all 7 layers of the OSI model in detail, now it is time to jump on to some real-life examples.

REAL-WORLD EXAMPLE OF OSI MODEL:

EMAIL WORKING

Suppose you want an email to your friend. You open your browser and then the mail website from where you type your mail and tap on the send button. This mail then passes on to the application layer which will pick SMTP (used for emails) and pass the data to the presentation layer. The presentation layer will compress the data and then pass it to the session layer. In the session layer, the whole communication will start as it will start a session.

The data is then broken down into segments in the transport layer. Then those segments will be broken up into packets in the network layer, which will further be broken down into frames in the data link layer. The Data link layer then delivers those frames to the physical layer where they get converted into bit streams of 1s and 0s and sent through a physical medium such as cable.

Now, once your friend's system receives the bit stream through the physical layer (Wi-Fi etc.), the bit stream will flow through the same series but in the opposite direction.

The physical layer will convert the bit stream into frames and pass it to the data link layer. The data link layer then reassembles the frames converts them to packets and sends them to the network layer. Then the network layer will convert the packets to segments and the transport layer will reassemble the segments into data.

The data will then flow into the receiver's session layer, which will pass the data along to the presentation layer and then end the communication session. The presentation layer will then remove the compression and pass the raw data up to the application layer. The application layer will then feed the human-readable data along to your friend's email software, which will allow him to read your email on her laptop screen.

Thanks for reading !!

What is Recursion?

To learn about Recursion let's first recall what is a function.

Python function is created using the def keyword. For example:

def func():
    print("hello world.")
func()      #function call

def func():
    print("Hello world.")
func()      #printing hello world 3 times
func()
func()

Now instead of calling the function every time we can make our job a little bit easier by using Recursion. So,

Recursion is a function that calls itself. Thats it!!

For ex. printing the first 5 natural numbers

def number(n):
    if n==6:
        return
    print(n)
    number(n+1)
number(1)

When to Use Recursion

Iterative code becomes a little bit tricky when solving complex problems. To make yourself good at programming try both iterative as well as recursive solutions. Recursion thus helps to tackle some complex problems with ease and hence convert the problem into iteration afterwards.

However, recursion is not the best way to solve a particular problem because:

1. They are a little slower than iterations because of function calls.

2. If the stack limit is too restrictive, iteration will be preferred over recursion.

3. They are hard to debug

How to Implement Recursion Effectively?

TRY TO BREAK THE PROBLEM INTO A SIMPLER SET OF EQUATIONS:

Try to make the problem simpler by making simple calculations and making equations out of it. for example, to print the Fibonacci numbers we add the two previous numbers so by this

$$0+1=1, 1+1=2, 2+1=3, 3+2=5, 5+3=8,$$

So the seventh Fibonacci number is 8 That is the sum of 5 and 3.

To make a simple equation in

Fib(n)=Fib(n-1)+Fib(n-2)

So recursive code for the Fibonacci number is

def fib(n):
    if n<=2:
        return n #if its less than 2 return the number
    return fib(n-1)+fib(n-2)
print(fib(5)) #output is 8

BASE CASE:

The base case is a condition to stop the recursion otherwise the recursion will keep going on.

For example, to print the first 5 natural numbers in the example above, we made a condition" if n==6:" this made the recursion stop and we got our desired output.

In another new example: Suppose we want to produce the product of the first 10 natural numbers

def recursion(n):
    if n<0 or n==1: #this is our base case 
        return 1
    else:
        return n*recursion(n-1)
print(recursion(10))

RECURSION TREE:

A recursion tree is a visualisation of what happens when recurrence is iterated.

For example the picture below of how Fibonacci problem tree looks like.

Some basic questions on recursion. [</>]

1. Factorial of a number.

    def recursive_factorial(n):
       if n == 1:   #base case 
           return n #to stop n from getting 0 
       else:
           return n*recursive_factorial(n-1)
   

2. The sum of first n natural numbers

    def sum_n(n):
        if n== 0:
            return 0
        else:
            return n + sum_n(n-1)
    print(sum_n(3))
   

3. Multiple of 3 (Table of 3).

    def mult3(n):
        if n == 1:
            return 3
        else:
            return mult3(n-1) + 3
    ​
    for i in range(1,11):
            print(mult3(i))
   

Conclusion

So this article is just an introduction to recursion and not much about it. The main idea is to give a basic idea of recursion and how it works.

What are errors in python?

Syntax errors : These errors are generated by wrong syntax in python . for example

1K = 199
print(1K)

output:
    1K = 199
     ^
SyntaxError: invalid syntax

There is another error names logical error in which error arrises due to wrong logic in code. These are most diificult error as python didnot return any error and coder may find difficulty in finding the error.

What are exceptions?

Exceptions arrises when your code is syntactcally correct but the code result an error. This willresult in breaking the flow of program.

x=100
y=x/0   #this will return error as it is being divided by 0 .
print(y)

output:
y=x/0   #this will return error as it is being divided by 0 .
ZeroDivisionError: division by zero

To overcome the problems we use exceptional handling .

Try and Except statement in python.

These are used to catch any exception in the code. Expressions the can raise exceptions in the try clause are kept and user generated output will be given in place of error. for ex.

try:
    100/0
except:
    print("No error LOL")

output:
No error LOL

Try and Except with Else statement.

Try and except with else statement is used to handle those type of problems in which we need the code to execute to fullest .For ex:

def div(a,b):
    try:
        c=a/b
    except:
        print("zero division error")
    else:
        print(c)
div(2,5)
div(5,0)
div(5,5)

output:0.4
       zero division error
       1.0

Finally Keyword.

The statement or expression inside the finally keyword will always be executed. For ex.

def div(a,b):
    try:
        c=a/b
        print(c)
    except:
        print("zero division error")
    finally:
        print("I will execute everytime :-)")
div(4,2)
div(4,0)

output:
2.0
I will execute everytime :-)
zero division error
I will execute everytime :-)

#THANKYOU

What is a function in python.

To complete a repeated task and writing the same code again and again ,we use function to call the same code just by calling it .

Function starts with def keyword followed by function name and parameter in parenthesis.

def ()

Creating a function.

We can create a function by using def keyword.

def new_func():
    print("This is new fucntion")

Calling of function

After creating a function we can use it by calling.

def new_func():
    print("calling of function.")
new_func()

output:-calling of function.

Calling a function with parameters.

def multiply(x,y):
    z=x*y
    return z
print(multiply(2,4))
print(multiply(4,5))

output:-8
        20

Arguments in functions.

Arguments are the values passed inside a parameter.

def odd_even(x):
    if x%2==0:
        print("even")
    else:
        print("odd")
odd_even(9)
odd_even(10)

output:- odd
         even

Return function .

Return function is used to exit from function and return value assigned to it. A return can consists of expression ,string ,constant etc.

def ret():
    return "return works like this ;)"
print(ret())

output:- return works like this;)*

Nested function

We can use a function inside a function and can make code more advanced.

def sum():
    x=4+5
    def multiply():#nested function defined as multiply
        z=x*5#multiplying x with 5 
        print(z)
    multiply()#calling nested func inside main func.
sum()#calling main function.

output:- 45

Some examples :

1. Ask 5 numbers from user and return odd or even

def odd(x):
    if x%2==0:
        return "even"
    else:
        return "false"
i=1
while i<=5:#for five number of attempts
    y=int(input("enter x "))
    print(odd(y))
    i+=1

 output:-enter x 12
        even
        enter x 23
        false
        enter x 34
        even
        enter x 45
        false
        enter x 56
        even

2. To find maximum of two numbers.

def max(x,y):
    if x>y:
        print(x,"is greater than ",y)
    else:
        print(y,"is greater than ",x)
x=int(input("Enter first number :-"))
y=int(input("Enter second number:-"))
max(x,y)


output:Enter first number :-12
       Enter second number:-322
       322 is greater than  12

3. Sum of all numbers in a list.

list=[]
i=1
while i<=5:
    x=int(input("Enter elements of list:-"))
    list.append(x)
    i+=1
print("List you have entered :",list)
def sum():
    add=0
    for j in range(5):
        add+=list[j]
    print("Sum of all the elements of list is ",add)
sum()

output:Enter elements of list:-12
       Enter elements of list:-12
       Enter elements of list:-12
       Enter elements of list:-12
       Enter elements of list:-12
       List you have entered : [12, 12, 12, 12, 12]
       Sum of all the elements of list is  60

Similarily you can create as many programs with the help of functions.

ThanK You ;-)

What is list comprehension?

List comprehension is an elegant way to create lists. A python list comprehension consists of expressions enclosed by square brackets.

For example:

#Normal way to create list.
x=[]
for i in range (11):#creating a list from 0 to 10 
    x.append(i)
print(x)

output:-  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#List comprehension.
x=[i for i in range(11)] #creating a list from 0 to 10
print(x)

output:-  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Advantages of list comprehension over normal way.

1. More time efficient and space efficient than loops.

2. Requires fewer lines of code.

Working of list comprehension.

x=[(expression to get displayed ) (for loop , for range of elements) (conditions)]

For example:-

x=[i for i in range(1,11) if i%2==0]
#expression followed by range and condition
print(x)

output:-[2, 4, 6, 8, 10]

Some examples of comprehension.

1. Creating a list of even numbers from 0 to 100.

x=[i for i in range(100) if i%2==0 ] 
#range of 100 numbers with condition.
print(x)

output:-[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]

2. Nested list comprehension.

#This is called matrix and a nested comprehension.
x=[[i for i in range(3)] for j in range(5)]
#range from 1 to 3 and number of repetitions 5
print(x)

output:-[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

3. Squares of 10 numbers.

x=[i**2 for i in range(1,11)]
print(x)

output:-[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

What is list?

List is a collection of data enclosed by []. Lists are mutable , which means the values inside the list can be changed anytime . List may contain string , integers ,a list inside a list or all of these in a single list itself.

A list can be created by simply putting values enclosed by [].

List operations.

1. Length of a list .

To know the length of list we use len() function. for ex.

list1=[1,2,3]
len(list) #this will return 3

2. Indexing in list.

Elements of a list are arranged in a definite sequence ,called indexes . The first element is treated as (0)th index and last element is treated as (n-1)th index . for ex.

list1=[10,20,30]
#index of 10 is 0
#index of 20 is 1 
#index of 30 is 2

3. Slicing in ist.

Slicing is sublist of a list. for ex.

list1=[1,2,3,4,5]
list2=list1[1:3] #this will extract a new list from index 1 to 3 .
print(list2) #output will be [2,3] as 3 gets excluded.

4. Adding and removing elements in a list.

a. We can add an element in a list by using append() fucntion .

Append fuction will add an element to a list at the end .Append will only insert 1 element ,to add multiple elements we use insert() fuction.

list1=[1,2,3]
list1.append(4)
#this will add 4 at the end of list1  
#new list is [1,2,3,4]

b. insert fuction

list1=[1,2,3]
list1.insert(4,5,6)
#this will add 4,5,6 at the end of list1
#new list is [1,2,3,4,5,6]

c. To merge two lists extend fucion is used. for ex,

list1=[1,2,3]
list2=[4,5,6]
list1.extend(list2)
#this will merge the two lists and return [1,2,3,4,5,6]

d.To remove an element in a list we use pop() fuction.

pop function will remove the indexed element and return it to the user. for ex.

list1=[1,2,3,4]
list1.pop(3) #this will remove the 4th elements i.e 4 from the list as at 3rd index 4 is there.

e. To remove elements we use remove function. remove fuction will remove the element given by the user . for ex.

list1=[2,3,4,5,6]
list1.remove(5)
#this will remove 5 from the list

f. Sorting :- sort() fucntion will arrange the elements of the list in ascending order .

list1=[4,3,2,6,1]
list1.sort()
#this will sort the list and return [1,2,3,4,6]

HERE IS CODE HAVING MULTIPLE OPERATIONS OF A LIST.

x='hello'
list1=[20,12,32,11,65,32]
print(list(x)) #create a list of alphabets 'hello'
print(list1.append(13)) #this will add 13 to the list.
list2=list1[2:5] #slicing
print(list2) #this will create a new list having 3 elements only.
print(list1.sort()) # this will sort the list in ascending order.
print(list1.reverse()) # this will reverse the list.
print(list1.extend(list2)) #this will add all the elements of list2 in list1.
x=list1.pop() # pop fucntion
print(x) #poped item
print(list1.remove(12)) # this will remove 12 from the list.
#end

TUPLES

What is a tuple?

Tuple is collection a data like list . The values stored in a tuple can be of any data type seperated by commas . Tuples are immutable means the values can not be changed like in list.

A tuple can be created by simply adding values enclosed by () seperated by commas .

Tuple operations.

1. creating a tuple.

x='hello'
tuple1=tuple(x)
print(tuple1)
#this will create a tuple for the word hello where each alphabet gets seperated by a comma.

2. Length of tuple .

Len function is used to find the length of a tuple. for ex.

tuple1=(1,2,34,4)
len(tuple1) #this willl return 4 (the length of tuple1.)

3. Indexing in tuple.

Indexing in tuple is same as of list .

tuple1=(1,2,3,4)
print(tuple1[2])
#this will return 3 ,as 3 is in second index.

4. Concatenation in tuples.

Two tuples can be concatenated by simply using + between them. for ex.

tuple1=(1,2,3)
tuple2=(4,5,6)
tuple3=tuple1+tuple2
print(tuple3)#merged tuple.

5. Deleting a tuple.

A tuple can be deleted by using del() function

tuple1=(1,2,3)
del tuple1 # tuple deleted
print(tuple1) #this will give error as tuple1 is already deleted.

6. Maximum and minumum value in a tuple.

By using min and max fuction we can find the minimum and maximum value in a tuple.

for ex.

tuple1=(2,4,5,6,3)
tuple1.max() # this will return 6
tuple2.max() # this will return 2

HERE IS CODE HAVING MULTIPLE OPERATIONS OF A TUPLE.

x='hello'
tuple1=(20,12,32,11,65,32)
print(tuple1(x)) #create a tuple of alphabets 'hello'
tuple2=tuple1[2:5] #slicing
print(tuple2) #this will create a new tuple having 3 elements only.
print(tuple1[0])# this will return value at index 0.
print(tuple1.max())
del tuple1 #this will delete tuple.
#end

DIFFERENCE BETWEEN A LIST AND A TUPLE.