Monolithic Architecture

Monolithic architecture represents the traditional approach where an application is developed as a single, self-contained unit. In this model, all components, including the user interface, business logic, and database access, are tightly integrated and deployed together.

Advantages:

• Simplicity: Monolithic architectures are generally easier to develop, test, and deploy since all components reside within a single codebase.

• Performance: Inter-component communication in monolithic applications is efficient as it avoids the overhead associated with network calls.

• Ease of Debugging: Debugging and troubleshooting are simplified since all components run within the same process.

Challenges:

• Scalability: Scaling monolithic applications can be challenging as the entire application needs to be replicated, even if only specific components require additional resources.

• Limited Technology Choices: Monolithic architectures may restrict the use of different technologies or frameworks since the entire application must adhere to the same technology stack.

• Maintainability: As monolithic applications grow larger, maintaining and modifying them becomes more difficult due to their tightly coupled nature.

Microservices Architecture

Microservices architecture involves breaking down an application into small, loosely coupled services that can be independently developed, deployed, and scaled. Each service is responsible for a specific business capability and communicates with other services through lightweight protocols.

Advantages

• Simplifies application complexity by breaking it down into manageable services, leading to faster development and easier maintenance.

• Enables independent development of each service by dedicated teams, promoting agility and specialization.

• Facilitates the adoption of new technologies as developers have the freedom to choose the most suitable tools for their services.

• Supports independent deployment of services, enabling continuous deployment in complex applications.

• Allows for individual scaling of services, optimizing resource utilization.

Drawbacks

• Introduces complexity due to the distributed nature of microservices, requiring additional considerations for inter-service communication and handling partial failures.

• Imposes challenges for managing business transactions that involve multiple databases owned by different services, often necessitating eventual consistency approaches.

• Increases testing complexity as each service and its dependencies must be configured and launched for testing.

• Makes changes spanning multiple services more difficult to implement, requiring careful planning and coordination.

• Adds complexity to deployment with a larger number of services and instances, necessitating automation and service discovery mechanisms.

It's important to weigh these advantages and drawbacks when considering the adoption of a microservices architecture for your project.

Choosing the Right Approach:

Choosing between microservices and monolithic architecture depends on several factors, including project size, complexity, scalability requirements, and team capabilities.

• Monolithic Architecture is suitable when:

  • The application is relatively small and straightforward.

  • Simplicity and faster development are of paramount importance.

  • Scalability requirements are low to moderate.

  • The team has limited experience with distributed systems.

• Microservices Architecture is suitable when:

  • The application is large and complex, with multiple interdependent components.

  • Scalability requirements are high, necessitating independent scaling of services.

  • The team possesses experience in building and managing distributed systems.

  • There is a need for technological flexibility, allowing the use of different languages or frameworks.

Big Data Analytics

Big Data analytics is the process of extracting meaningful insights from vast and complex data sets. It revolves around the utilization of specialized tools and techniques to analyze, process, and interpret data to facilitate informed decision-making.

Key Components of Big Data Analytics

1. Data Collection and Ingestion: Gathering data from diverse sources, including social media, IoT devices, sensors, and more. This step involves data cleaning and transformation for standardized analysis.

2. Storage and Management: Employing distributed storage systems and cloud technologies to store and manage large volumes of data efficiently.

3. Processing and Analysis: Utilizing parallel processing frameworks like Hadoop and Spark for efficient handling of massive data sets.

4. Visualization and Reporting: Transforming complex data into visually comprehensible formats through charts, graphs, and dashboards.

5. Machine Learning Integration: Applying advanced algorithms to uncover patterns, predict trends, and automate decision-making processes.

Data Science

Data Science is a multidisciplinary field that combines elements of statistics, mathematics, programming, and domain expertise. It revolves around extracting knowledge and insights from data to drive informed business decisions.

Key Components of Data Science

1. Statistical Analysis and Modeling: Employing statistical techniques to uncover patterns, correlations, and trends within data sets.

2. Machine Learning and Predictive Modeling: Building and deploying algorithms to make predictions or classifications based on historical data.

3. Data Mining: Exploring large datasets to discover hidden patterns or relationships.

4. Data Cleaning and Preparation: Ensuring data quality and compatibility for analysis through processes like normalization and transformation.

5. Domain Knowledge Integration: Combining expertise in a specific field with data analysis to derive actionable insights.

Big Data Analytics Meets Data Science

While Big Data analytics focuses on handling and processing large volumes of data, Data Science brings the analytical and predictive capabilities that unlock the true potential of this information. Together, they form a powerhouse that drives innovation, efficiency, and competitiveness across industries.

Realizing the Potential

1. Personalized Marketing: By combining Big Data analytics for segmentation with Data Science for predictive modeling, businesses can deliver highly targeted and effective marketing campaigns.

2. Healthcare Advancements: The fusion of Big Data analytics and Data Science has revolutionized patient care through personalized treatment plans, predictive diagnostics, and drug discovery.

3. Predictive Maintenance: Industries leverage this duo to forecast when machinery and equipment might fail, enabling proactive maintenance and reducing downtime.

Ethical Considerations and Data Privacy

As these fields continue to evolve, it's crucial to address ethical concerns surrounding data usage. Striking a balance between innovation and privacy is paramount to ensuring the responsible application of Big Data analytics and Data Science.

Conclusion

Big Data analytics and Data Science stand at the forefront of the data-driven revolution, offering organizations unparalleled opportunities for growth and innovation. By harnessing their combined power, businesses can unlock a new era of informed decision-making, predictive insights, and strategic advantage in an increasingly competitive landscape. The synergy between these fields will continue to shape industries, redefine processes, and drive the next wave of technological advancements.

The Building Blocks: Series and DataFrame

Series: The One-Dimensional Powerhouse

A Series in pandas is akin to a column in a spreadsheet or a one-dimensional NumPy array. It’s a labeled array that can hold any data type, with each element having an associated label called an index. This indexing feature allows for efficient and intuitive data manipulation.

Here’s a quick look at how to create and use a Series:

import pandas as pd
# Creating a Series
s = pd.Series([1, 2, 3, 4, 5])
print(s)

Output:

0    1
1    2
2    3
3    4
4    5
dtype: int64

DataFrame : The Two-Dimensional Workhorse

A DataFrame is the heart of pandas, representing a two-dimensional labeled data structure with columns and rows, similar to a table or spreadsheet. Each column in a DataFrame is a Series.

Here’s how to create a DataFrame:

# Creating a DataFrame from a dictionary
data = {'col1': [1, 2], 'col2': [3, 4]}
df = pd.DataFrame(data)
print(df)

Output:

   col1  col2
0     1     3
1     2     4

# Creating a DataFrame from a NumPy array
import numpy as np
df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['a', 'b', 'c'])
print(df2)

Output:

   a  b  c
0  1  2  3
1  4  5  6
2  7  8  9

Unlocking the Potential of DataFrame Attributes and Methods

DataFrames come with a plethora of built-in attributes and methods that simplify common data analysis tasks. Here are some of the most commonly used ones:

Essential Attributes

• columns: Returns the column labels of the DataFrame.

• dtypes: Returns the data types of the columns.

• iloc: Accesses rows and columns using integer-based indexing.

• loc: Accesses rows and columns by labels or Boolean arrays.

• shape: Returns a tuple representing the dimensionality.

• values: Returns a NumPy representation of the DataFrame.

Examples:

print(df2.columns)
print(df2.dtypes)
print(df2.shape)
print(df2.values)

Output:

Index(['a', 'b', 'c'], dtype='object')

a    int64
b    int64
c    int64
dtype: object

(3, 3)

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

Vital Methods

• apply(): Applies a function along an axis.

• copy(): Creates a copy of the DataFrame.

• describe(): Provides descriptive statistics.

• drop(): Drops specified labels from rows or columns.

• groupby(): Groups DataFrame using a mapper or by a Series of columns.

• head(): Returns the first n rows.

• info(): Prints a concise summary of the DataFrame.

• isna(): Detects missing values.

• sort_values(): Sorts by the values along an axis.

• value_counts(): Returns a Series containing counts of unique values.

Example:

print(df2.describe())

Output:

              a         b         c
count  3.000000  3.000000  3.000000
mean   4.000000  5.000000  6.000000
std    3.000000  3.000000  3.000000
min    1.000000  2.000000  3.000000
25%    2.500000  3.500000  4.500000
50%    4.000000  5.000000  6.000000
75%    5.500000  6.500000  7.500000
max    7.000000  8.000000  9.000000

Selecting Data with Pandas

Selecting and manipulating data within a DataFrame is a crucial skill. Pandas offers several ways to achieve this.

Row Selection

Using loc[]:

Select rows by label:

df = pd.DataFrame({
   'A': ['alpha', 'apple', 'arsenic', 'angel', 'android'],
   'B': [1, 2, 3, 4, 5],
   'C': ['coconut', 'curse', 'cassava', 'cuckoo', 'clarinet'],
   'D': [6, 7, 8, 9, 10]
}, index=[0, 1, 2, 3, 4])

print(df.loc[1])
print(df.loc[[1, 3]])

Output:

A       apple
B           2
C       curse
D           7
Name: 1, dtype: object

          A  B       C  D
1     apple  2   curse  7
3     angel  4  cuckoo  9

Using iloc[]:

Select rows by position:

print(df.iloc[1])
print(df.iloc[[0, 2]])

Output:

A       apple
B           2
C       curse
D           7
Name: 1, dtype: object

         A  B        C  D
0     alpha  1  coconut  6
2   arsenic  3   cassava  8

Column Selection

Bracket Notation:

print(df['C'])
print(df[['A', 'C']])

Output:

0    coconut
1      curse
2    cassava
3     cuckoo
4   clarinet
Name: C, dtype: object

        A        C
0   alpha  coconut
1   apple    curse
2 arsenic  cassava
3   angel   cuckoo
4 android clarinet

Dot Notation:

print(df.A)

Output:

0     alpha
1     apple
2   arsenic
3     angel
4   android
Name: A, dtype: object

Selecting Rows and Columns Together

Using loc[]:

print(df.loc[0:2, ['A', 'C']])

Output:

        A        C
0   alpha  coconut
1   apple    curse
2 arsenic  cassava

Using iloc[]:

print(df.iloc[[2, 4], 0:3])

Output:

        A  B        C
2 arsenic  3   cassava
4 android  5  clarinet

Key Takeaways

Pandas DataFrames are an essential tool for working with tabular data. Each row and column in a DataFrame is represented by a pandas Series, making data manipulation intuitive and efficient. The robust suite of methods and attributes available in pandas allows for sophisticated data operations with minimal code. As you gain experience with pandas, you’ll find it an invaluable tool in your data science toolkit.

Additional Resources

For more detailed information, refer to the official pandas documentation:

• pandas DataFrame documentation

• pandas Series documentation

• pandas selection documentation

By mastering the fundamentals of pandas, you'll be on your way to becoming a proficient and effective data professional.

Creating Arrays

To begin using NumPy, import the library and create arrays:

import numpy as np

# 1D array (Similar to a list.)
array_1d = np.array([1, 2, 3])
print(array_1d)  # Output: [1 2 3]

# 2D array(Similar to a table.)
array_2d = np.array([(1, 2, 3), (4, 5, 6)])
print(array_2d)  # Output: [[1 2 3] [4 5 6]]

# 3D array(Similar to two tables)
array_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(array_3d)  # Output: [[[1 2] [3 4]] [[5 6] [7 8]]]

Special Arrays

Create arrays filled with zeros(), ones(), full().

# Array of zeros
print(np.zeros((3, 2)))  # Output: [[0 0] [0 0] [0 0]]

# Array of ones
print(np.ones((2, 2)))  # Output: [[1 1] [1 1]]

# Array filled with a specific value
print(np.full((5, 3), 8))  # Output: [[8 8 8] [8 8 8] [8 8 8] [8 8 8] [8 8 8]]

Array attributes

NumPy arrays have several attributes that enable you to access information about the array. Some of the most commonly used attributes include the following:

• ndarray.shape: returns a tuple of the array’s dimensions.

• ndarray.dtype: returns the data type of the array’s contents.

• ndarray.size: returns the total number of elements in the array.

• ndarray.T: returns the array transposed rows becomes columns, columns become rows).

•       array = np.array([(1, 2, 3), (4, 5, 6)])
        print(array )# Output:  [ [1 2 3] [4 5 6] ]
        print(array.shape)# Output: (2, 3)
        print(array.dtype)# Output: int64
        print(array.size)# Output: 6
        print(array.T)# Output:[ [1 4] [2 5] [3 6]]
  

Array Methods

Some important array methods are flatten() , reshape(), and tolist().

array = np.array([(1, 2, 3), (4, 5, 6)])

# Flatten an array( returns a copy of the array collapsed into one dimension.)
print(array .flatten())  # Output: [1 2 3 4 5 6]

# Reshape an array( Gives a new shape to an array without changing its data.)
print(array .reshape(3, 2))  # Output: [[1 2] [3 4] [5 6]]

# Reshape with inferred dimension
print(array .reshape(3, -1))  # Output: [[1 2] [3 4] [5 6]]

# Convert array to list(Converts an array to a list object.) 
print(array .tolist())  # Output: [[1, 2, 3], [4, 5, 6]]

Mathematical Functions

Some common mathematical operations : max(), mean(), min(), std().

array  = np.array([(1, 2, 3), (4, 5, 6)])

# Maximum value
print(array .max())  # Output: 6

# Mean value
print(array .mean())  # Output: 3.5

# Minimum value
print(array .min())  # Output: 1

# Standard deviation
print(array .std())  # Output: 1.707825127659933

Indexing and Slicing

• Access individual elements of a NumPy array using indexing and slicing.

• Indexing in NumPy is similar to indexing in Python lists, except multiple indices can be used to access elements in multidimensional arrays.

array = np.array([(1, 2, 3), (4, 5, 6)])

# Indexing
print(array [1])  # Output: [4 5 6]
print(array [0, 1])  # Output: 2
print(array [1, 2])  # Output: 6

# Slicing to access subarrays of a NumPy array
print(array [:, 1:])  # Output: [[2 3] [5 6]]

Array Operations

NumPy arrays support a variety of operations, including mathematical functions and arithmetic, such as element-wise addition and multiplication.

a = np.array([(1, 2, 3), (4, 5, 6)])
b = np.array([[1, 2, 3], [1, 2, 3]])
print(a)         # Output: [[1 2 3] [4 5 6]]
print(b)         # Output: [[1 2 3] [1 2 3]]
print(a + b)     # Output: [[2 4 6] [5 7 9]]
print(a * b)     # Output: [[ 1  4  9] [ 4 10 18]]

Furthermore, there are other crucial mathematical functions that can be applied to individual or multiple arrays.

Mutability

NumPy arrays are mutable, though they have certain limitations. For example, you can modify an existing element in an array:

# Modify an element
a[1][1] = 100
print(a)  # Output: [[  1   2   3] [  4 100   6]]

# Attempt to add an element (will cause an error)
a[3] = 100  # Uncommenting this will raise an IndexError

To conclude, NumPy arrays allocate a contiguous block of memory, ensuring fast access and manipulation but restricting the ability to resize after creation.

By mastering these core functionalities, you can leverage NumPy arrays for efficient numerical computing and data manipulation in your projects. Save this guide for quick reference and further practice as you delve deeper into data science and numerical analysis with NumPy.

One of the most useful tools in Python is list comprehension. It is a concise and efficient way to create a new list based on the values in an existing iterable object. List comprehensions take the following form:

my_list = [expression for element in iterable if condition]

In this syntax:

• expression: What you want to do with each element. This can be a transformation or any operation.

• element: The variable name that represents each item in the iterable.

• iterable: The sequence (like a list, tuple, string, etc.) you are iterating over.

• condition (optional): Any expression that evaluates to True of False.

Some examples of List Comprehensions :

1. Creating a List of Squares:

numbers = [1, 2, 3, 4, 5]
squared = [x ** 2 for x in numbers]
print(squared)  # Output: [1, 4, 9, 16, 25]

2. Filtering Even Numbers:

numbers = [1, 2, 3, 4, 5]
even = [x for x in numbers if x % 2 == 0]
print(even)  # Output: [2, 4]

3. Manipulating Elements with Conditions:

names = ["Alice", "Bob", "Charlie"]
formatted_names = [name.upper() if len(name) > 4 else name.lower() for name in names]
print(formatted_names)  # Output: ['alice', 'BOB', 'CHARLIE']

4. Flattening a Nested List:

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [x for sublist in nested_list for x in sublist]
print(flattened)  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

Zip( )

The zip() function is used to combine two or more iterables (like lists or tuples) into a single iterable of tuples. Each tuple contains elements from the input iterables that have the same position.

names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]

combined = zip(names, scores)
print(list(combined))  # Output: [('Alice', 85), ('Bob', 92), ('Charlie', 78)]

In this example, zip() pairs each element from names with the corresponding element from scores, creating a list of tuples. This can be particularly useful for iterating over multiple lists simultaneously.

Unzipping

You can also unzip an object with the * operator. Here’s the syntax:

cities = [('New York', 8419000), ('Los Angeles', 3980400), ('Chicago', 2716000)]
city_names, populations = zip(*cities)
print(city_names)     # Output: ('New York', 'Los Angeles', 'Chicago')
print(populations)    # Output: (8419000, 3980400, 2716000)

Enumerate( )

The enumerate() function adds a counter to an iterable and returns it as an enumerate object. This is extremely useful when you need both the index and the value of elements in a loop.

fruits = ['apple', 'banana', 'cherry']

for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

#Output :
'''
0: apple
1: banana
2: cherry
'''

With enumerate(), you no longer need to manage a separate counter variable, making your loop cleaner and more readable.

Key takeaways:

Using zip(), enumerate(), and list comprehensions can significantly enhance code efficiency by minimizing the reliance on traditional loops for data processing. These tools simplify working with iterables, saving time and making data manipulation more dynamic and streamlined. Understanding these common techniques will greatly improve your coding workflow.

Data Storage and Management

1.1 Hadoop Distributed File System (HDFS):

• HDFS is a distributed file system designed to store and manage massive volumes of data across clusters of commodity hardware.

• It offers fault tolerance and scalability.

  Real-Time Scenario:

  Storing and processing terabytes of sensor data from smart cities to improve urban planning and resource allocation.

1.2 Cassandra:

• Cassandra is a distributed NoSQL database known for its scalability and high availability.

• It employs a decentralized architecture that distributes data across multiple nodes, ensuring fault tolerance and uninterrupted operations even in the face of hardware failures.

  Real-Time Scenario:

  In case of IoT Data Management, consider a scenario where a smart city infrastructure generates vast volumes of data from sensors, traffic cameras, and weather stations. Cassandra's scalability and fault tolerance make it an ideal choice to handle the influx of real-time data, ensuring uninterrupted services and analytics for city planners.

1.3 MongoDb

• MongoDB is a popular NoSQL database recognized for its flexible schema and JSON-like document model.

• It allows organizations to store unstructured or semi-structured data while providing robust querying capabilities.

  Real-Time Scenario:

  In case of Content Management, MongoDB's flexible schema is invaluable. It accommodates diverse content types, such as articles, images, and videos, while enabling efficient querying and indexing for content retrieval and personalization.

Data Cleansing

2.1 OpenRefine (Google Refine):

• OpenRefine is a data wrangling tool used for data cleaning, transformation, and exploration.

• It helps standardize and clean messy data.

  Real-Time Scenario:

  Standardizing and cleaning customer data with variations in names, addresses, and contact information for a CRM system.

2.2 Trifacta:

• Trifacta is a data preparation platform that automates data cleansing and transformation tasks.

• It uses machine learning to suggest data cleaning operations.

  Real-Time Scenario:

  Preparing and cleaning unstructured text data, such as customer reviews, to extract sentiment and feedback for product improvements.

Data Analysis

3.1 Apache Spark:

• Apache Spark is a versatile data processing framework supporting batch and real-time data analysis, machine learning, and graph processing.

• One of the most significant advantages of Apache Spark is its exceptional speed.

  Real-Time Scenario:

  Analyzing real-time financial market data to detect anomalies and trigger automated trading decisions.

3.2 Python (with Pandas and Scikit-Learn):

• Python, along with libraries like Pandas and Scikit-Learn, is widely used for data analysis, statistical modeling, and machine learning.

  Real-Time Scenario:

  Developing predictive models to forecast customer demand for a retail chain based on historical sales and market trends.

Data Visualization

4.1 Tableau:

• Tableau is a leading data visualization tool that allows users to create interactive dashboards and reports, making data insights accessible.

  Real-Time Scenario:

  Creating dynamic supply chain dashboards to monitor inventory levels, track deliveries, and optimize logistics operations.

4.2 Power BI:

• Power BI is a Microsoft business intelligence tool for data visualization, analytics, and reporting, with seamless integration into the Microsoft ecosystem.

  Real-Time Scenario:

  Visualizing and sharing sales performance data across a retail organization to identify top-performing products and regions.

In conclusion, these tools and technologies are instrumental in managing, cleansing, analyzing, and visualizing data to extract actionable insights. Real-world scenarios demonstrate the practical application of these tools across various industries, showcasing their transformative power in enabling data-driven decision-making and innovation. Staying abreast of these tools and leveraging them effectively is essential for organizations to thrive in the data-centric landscape of today.

• Each model is a Python class that subclasses django.db.models.Model.

• Each attribute of the model represents a database field.

Example :

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()

    def __str__(self):
        return self.title

In this example, the "Post" model defines fields for title, description, and image. The CharField represents a character field with a maximum length of 200 characters, while the TextField represents a longer text field. The __str__ method returns the title of the post for better readability.

Corresponding schema

Databases in Django

In Django, the default database is set up to use SQLite as the database engine.

• In your project's "settings.py" file, the default database configuration is typically set up like this:

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',   # SQLite database engine
            'NAME': BASE_DIR / 'db.sqlite3',          # Database file path
        }
    }
  

Explanation of the configuration:

1. ENGINE: This specifies the database engine to be used, which is set to 'django.db.backends.sqlite3' for SQLite.

2. NAME: This indicates the file path where the SQLite database file will be created and stored.

3. By default, it is set to 'db.sqlite3', and it is placed in the project's base directory (BASE_DIR). You can change the name or location of the SQLite database file by modifying this setting.

• When connecting to other databases extra connection parameters will be required, let's take an example of PostgreSQL

    DATABASES = {
      'default': {
          'ENGINE': 'django.db.backends.postgresql',
          'NAME': 'database_name',
          'USER': 'database_user',
          'PASSWORD': 'database_password',
          'HOST': '127.0.0.1',
          'PORT': '5432',
      }
    }
  

Django Migrations

Whenever changes are made to the models in our Django project, we need to execute two commands: makemigrations and migrate.

• makemigrations generates SQL commands for both preinstalled apps and newly created app models that are added to the installed apps.

On the other hand, migrate applies these SQL commands to the database, making the necessary changes.

#create new database migration files
Python manage.py makemigrations

 #this create table in the database
Python manage.py migrate

Crud operation from Admin interface

For this , First I need to register my model in admin.py

from django.contrib import admin
from .models import Post

admin.site.register(Post)

After you register this , then you can do CRUD operation from Django admin interface.

While Django's admin interface provides a user-friendly way to interact with data, the Django shell offers a powerful command-line interface to manage your models and database.

Performing various crud operation from shell

To access the Django shell, open your terminal or command prompt, navigate to your Django project directory, and run the following command:

python manage.py shell

This command open shell terminal where you can perform data operations.

1. Creating Records

    >>>> new_post = Post(
             title = "BitsNotion",  
             description = "Post Description",
             )
    >>> new_post.save()#Save data to database
   

2. Reading Records

   To retrieve record from Post model .We can perform various operations.

   Retrieve all data

    all_posts = Post.objects.all()
   

   Retrieve a specific post by its primary key (id)

    post = Post.objects.get(id=1)
   

   Filter posts based on specific criteria (e.g., title)

    query_set = Post.objects.filter(title='BitsNotion')
   

3. Updating Records

    # Retrieve the post you want to update
    post = Post.objects.get(id=1)
    post.title = 'Updated Post Title'
    post.save()
   

4. Deleting Records

    # Retrieve the post you want to delete
    post = Post.objects.get(id=1)
    post.delete()#delete your post
   

Various model fields list

Features

Django boasts an array of distinctive features that set it apart:

1. Scalability: The modern world demands web applications that can handle an ever-increasing number of users and data. Django's scalability is a result of its ability to efficiently manage database queries, handle caching, and optimize code execution. This scalability makes Django suitable for applications ranging from small startups to large-scale enterprises.

2. Security: Security is of paramount importance in the modern digital landscape, and Django takes security seriously. It comes with built-in features to prevent common web vulnerabilities like SQL injection, cross-site scripting (XSS), and cross-site request forgery (CSRF). Additionally, Django's authentication system allows for secure user management.

3. Versatility: Django's versatility is evident in its ability to support various types of web applications. Whether it's a content-heavy website, an e-commerce platform, a social media network, or an API-centric application, Django can handle diverse requirements.

4. Community and Documentation: Django boasts an active and robust community of developers, contributing to its constant growth and improvement. The official documentation is extensive, well-maintained, and beginner-friendly, making it easier for developers to learn and utilize the framework effectively.

5. Django REST Framework: In the modern world of web development, APIs (Application Programming Interfaces) play a vital role in enabling seamless interactions between different services and platforms. Django's integration with the Django REST Framework simplifies the process of building powerful and scalable Web APIs.

Setting Up a Django Project

Creating a Virtual Environment

A virtual environment allows you to create an isolated Python environment for your project, ensuring that the dependencies you install don't interfere with other projects on your system.

# On Windows
python -m venv project_env

# On macOS and Linux
python3 -m venv project_env

This will create a new directory called project_env containing the virtual environment.

To activate virtual environment in your project run project_env\Scripts\activate on Windows or source project_env/bin/activate on Mac OS X or Linux will activate your virtual environment.

Now that the virtual environment is set up, it's time to install Django. Within your virtual environment, use pip to install Django:

# On Windows, macOS, and Linux
(project_env) ~/pip install django

Creating the Django Project

With Django installed, you can create a new Django project. Navigate to the folder where you want to create your project, and run the following command:

(project_env) ~/django-admin startproject myproject

This will create a new directory named myproject, which will be the root of your Django project.Inside the myproject directory, you'll find the initial folder structure of your Django project:

myproject/
|-- manage.py
|-- myproject/
    |-- __init__.py
    |-- asgi.py
    |-- settings.py
    |-- urls.py
    |-- wsgi.py

1. manage.py file is a command-line utility that allows you to interact with your project.

2. settings.py file contains the configuration of your website.

3. asgi.py configures the application to handle asynchronous web servers using the ASGI (Asynchronous Server Gateway Interface) specification.

4. wsgi.py configures the application to work with traditional synchronous web servers using the WSGI (Web Server Gateway Interface) standard.

Django provides a pre-built and pre-configured development server that you can easily run using the command python manage.py runserver. When you navigate to the locally deployed Django address, typically at http://127.0.0.1:8000.

You have successfully run your Django first application.But you may be curious to see some custom output by your own.Let's do that.

Creating Django apps

In Django, a web application is typically divided into smaller components called "apps." Each app handles a specific functionality or set of related features within the overall project.

To create a new app, navigate to the root directory of your Django project using the terminal (where the manage.py file is located) and run the following command:

python manage.py startapp <app_name>
#For example 
(project_env) ~/python manage.py startapp hello_app

This command will create a new directory named hello_app, which contains the initial structure of the app:

hello_app/
|-- migrations/
|   |-- __init__.py
|-- __init__.py
|-- admin.py
|-- apps.py
|-- models.py
|-- tests.py
|-- views.py

This will create another directory called hello_app with several files:

• __init__.py tells Python to treat the directory as a Python package.

• admin.py contains settings for the Django admin pages.

• apps.py contains settings for the application configuration.

• models.py contains a series of classes that Django’s ORM converts to database tables.

• tests.py contains test classes.

• views.py contains functions and classes that handle what data is displayed in the HTML templates.

Including the App in Settings

After creating the app, you need to include it in the project's settings. Open the settings.py file inside the myproject directory and locate the INSTALLED_APPS list. Add your app name (hello_app) to the list:

INSTALLED_APPS = [
    # ...
    'hello_app',
    # ...
]

By adding your app to the INSTALLED_APPS list, Django recognizes the app and includes it in the project.

Writing the "Hello, World!" View

In Django, views handle the logic for processing HTTP requests and returning responses. Let's create a simple "Hello, World!" view inside the views.py file of the hello_app:

# hello_app/views.py
from django.http import HttpResponse

def hello_world(request):
    html_content = "<h1>Hello, World!</h1>"
    return HttpResponse(html_content)

Creating a URL Mapping

Now that we have our view defined, we need to map it to a URL. Open the urls.py file inside the hello_app directory and add the following code:

# hello_app/urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('hello/', views.hello_world, name='hello_app'),
]

In this code, we import the hello_world view we created and map it to the URL path /hello/.

Include the App URLs in the Project

To make the app's URLs accessible within the project, open the urls.py file of the project (located in the myproject directory) and include the app's URLs using the include function:

# myproject/urls.py

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('hello_app/', include('hello_app.urls')),  # Include the app's URLs
]

Now, when you access 127.0.0.1:8000/hello_app/hello/ .You will see below output:

Congratulations! You've successfully set up a Django project from scratch. Now you can start building your web application using Django's powerful features and elegant design.

Installing and configuring git

1. Connect to Your VPS Server First, log in to your VPS server using SSH.

    ssh your_username@your_server_ip
   

2. Install Git: Most VPS servers come with Git pre-installed, but it's always good to verify. To install Git, use the package manager specific to your server's operating system.

    # on Ubuntu/Debian
    sudo apt-get update
    sudo apt-get install git
   
    #On CentOS/RHEL
    sudo yum install git
   

3. Configure Git:

   Before you start using Git, you need to configure your identity. Replace the placeholders with your own name and email address:

    git config --global user.name "Your Name"
    git config --global user.email "youremail@example.com"
   

4. Check your configuration

    git config --list
   

   The git config –list command should return the configuration you added

    user.name=YourUserName
    user.email=example@example.com
   

Using Git Basic Command

1. Create the Project Directory: First, create a directory for your project. You can do this using the mkdir command:

    mkdir project
   

1. Create Files for the Project: Navigate into the project1 directory and create some files and a sub-directory:

    $ cd project
    $ touch file
   

1. Initialize Git in the Project Directory: Next, you need to initialize a Git repository in the project1 directory using the git init command:

    git init
   

This command initializes an empty Git repository in the project directory, allowing Git to track changes in the files.

1. Add Files to the Repository:

     git add .
   

1. Make Your Initial Commit: After adding the files, it's time to make your initial commit. A commit is a snapshot of the changes you've made to the project. Each commit should have a meaningful commit message describing the changes.

    git commit -m "Initial Commit"
   

   The -m flag allows you to specify the commit message directly in the command. In this case, we use "Initial Commit" to indicate that this is the first commit for the project.

Adding SSH access to GitHub from your VPS

1. Check if you already have an SSH key pair by running:

    ls -al ~/.ssh
   

2. Generate SSH Key Pair on VPS: Log in to your VPS via SSH, open a terminal, and run the following command to generate an SSH key pair:

    ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
   

3. View and Copy Public Key: After generating the keys, run the following command to display your public key:

    cat ~/.ssh/id_rsa.pub
   

   Copy the entire output of the command, which is your public key.

4. Add Public Key to GitHub:

   1. Click on your profile picture in the upper right

   2. Select settings

   3. Click on SSH and GPG keys

   4. Click on the “Create SSH Key” button

   5. Give the key a “title” to help you identify it

   6. Paste the public key into the “key” field

   7. Save the key

5. Test SSH Connection: To test if your SSH connection is working, run the following command in the terminal of your VPS:

    ssh -T git@github.com
   

   You should see a message like "Hi username! You've successfully authenticated, but GitHub does not provide shell access."

6. Update Git Configuration: To ensure Git uses SSH for pushing and pulling from GitHub, configure it to use the SSH URL. Run the following commands in your VPS terminal:

    git config --global user.email "your_email@example.com"
    git config --global user.name "Your Name"
    git remote remote add origin git@github.com:your-username/your-repo.git
   

Now, your VPS should be set up to use SSH for interacting with your GitHub repository. Now , you can clone, push, and pull from GitHub using SSH without needing to enter your username and password each time.

History

• Apache: First released in 1995, Apache quickly gained popularity due to its flexibility and support for .htaccess configuration files.

• Nginx: Introduced in 2004, Nginx aimed to overcome Apache's performance limitations by focusing on being lightweight, fast, and efficient.

Architecture

When comparing Apache and Nginx, their fundamental difference lies in their design architecture, which dictates how they handle connections, traffic, and respond to various traffic conditions.

Apache

• Apache employs a process-driven approach, which means it creates a new thread for each incoming request.

• It offers a variety of processing modules with different algorithms for handling requests, providing flexibility in choosing the right approach for different server needs.

• However, this architecture can lead to resource-intensive operations, potentially causing performance issues such as slow speed.

  

Nginx

• On the other hand, Nginx adopts an event-driven approach, dealing with requests asynchronously within one processing thread.

• It utilizes a non-blocking event-driven connection handling algorithm, allowing it to efficiently manage thousands of connections simultaneously.

• This event-driven architecture makes Nginx fast and resource-efficient, suitable for low-power systems and handling heavy loads with ease.

  

Performance

• Nginx uses an asynchronous event-driven architecture, making it highly scalable and resource-efficient. It can handle a larger number of requests using fewer system resources.

• Nginx is particularly adept at serving static files, outperforming Apache in many benchmarks in this area.

• Apache's multi-processing architecture consumes more resources, though it has improved over time, Nginx still maintains a performance advantage.

Configuration

• Apache utilizes .htaccess files for directory-level configuration, providing flexibility for individual directories. However, this can impact performance due to the need for file checks on each request.

    <VirtualHost *:80>
        ServerName domain.com
        ScriptAlias /myscript /var/www/html/myscript.php
        # Other configurations for the site...
    </VirtualHost>
  

• Nginx uses a centralized configuration with server blocks and location blocks, resulting in better performance and a more streamlined configuration process.

    server {
      listen       80; 
      server_name  domain.com;
  
      location / {
        root   /var/www/domain.com/html;
        index  index.html index.htm;
      }
    }
  

Caching

• Nginx comes with built-in caching capabilities that are easy to configure and perform well.

• Apache relies on external caching solutions such as Varnish to achieve similar caching performance.

Modules

• Apache boasts a robust module system, allowing for easy installation and enabling/disabling of modules after installation, providing great flexibility.

• Nginx modules must be enabled during compilation, making the module system less flexible but potentially more secure.

In summary, Nginx is often a preferred choice for performance-critical applications due to its efficient and scalable architecture, especially excelling at serving static files. On the other hand, Apache remains popular for its flexibility and extensive module system, making it suitable for a wide range of use cases.

We will explore horizontal and vertical scaling, their pros and cons, empowering you to make informed decisions for effective database scaling.

Understanding Data Scalability:

Data scalability enables databases to handle increased workloads by expanding or reducing their capacity based on application usage. It ensures efficient processing of large data volumes, supports growing user bases, and maintains optimal performance under varying workloads.

Horizontal Scaling (Scale-Out):

Horizontal scaling, also known as scale-out, involves adding more database nodes or servers to distribute the workload and handle increased traffic. Instead of expanding the capacity of individual servers, horizontal scaling focuses on scaling the entire system by adding more nodes.

Advantages of Horizontal Scaling:

1. Easy to Upgrade: You can incrementally increase capacity as needed.

2. Cost-Effective: Horizontal scaling often involves using commodity hardware and open-source software, making it a cost-effective solution for scaling your database.

3. Flexible and Scalable: Horizontal scaling provides virtually unlimited scalability by allowing you to add more servers or nodes to the cluster as your application's workload grows.

Disadvantages of Horizontal Scaling:

1. Complexity in Debugging: As the number of nodes increases, debugging and understanding code issues can become more complex, requiring effective monitoring and debugging tools.

2. Licensing Costs: Adding more nodes to the cluster may require additional licenses, leading to increased licensing costs for proprietary software.

3. Increased Data Center Costs: Horizontal scaling necessitates more physical space, power, and cooling requirements in data centers, resulting in higher operational costs.

When to Use Horizontal Scaling:

Horizontal scaling is well-suited for applications that experience high traffic and require the ability to handle a large number of concurrent users. It provides excellent scalability, fault tolerance, and load balancing capabilities. If your application demands scalability beyond the capacity of a single server, horizontal scaling is a viable option.

Vertical Scaling (Scale-Up):

Vertical scaling, also known as scale-up, involves increasing the capacity of an individual server by adding more resources such as memory, storage, or processing power. In this approach, the focus is on enhancing the capabilities of a single machine rather than distributing the workload across multiple servers.

Advantages of Vertical Scaling:

1. Cost-Effective Data Center: Vertical scaling can lead to cost savings in terms of data center space, cooling, and power requirements, as it involves a smaller hardware footprint compared to horizontal scaling.

2. Ease of Management: Managing and maintaining a single server is generally easier than managing multiple servers in a distributed system.

3. Flexible Resource Allocation: Vertical scaling allows for flexible allocation of resources to meet the specific needs of your application, such as increasing memory or CPU power.

Disadvantages of Vertical Scaling:

1. Licensing Costs: Upgrading the resources of a single server often involves purchasing licenses for higher-end hardware components or proprietary software.

2. Hardware Limitations: There is a limit to how much a single server can be upgraded, and eventually, you may reach the hardware's maximum capacity.

3. Vendor Lock-In: Vertical scaling may tie you to a specific database vendor, making migration or switching to a different solution more challenging.

When to Use Vertical Scaling:

Vertical scaling is typically suitable for applications that require high data consistency or have unique data requirements. It is also an effective solution when you have a smaller user base and do not anticipate rapid or exponential growth in traffic.

Differences Between Vertical and Horizontal Scaling:

Choosing the Right Scaling Method for Your Application:

When deciding between vertical and horizontal scaling, consider the following factors:

1. Load Balancing: Horizontal scaling provides built-in load balancing by distributing the workload across multiple servers, while vertical scaling relies on a single server and does not require load balancing.

2. Point of Failure: Horizontal scaling offers resilience by eliminating a single point of failure, whereas vertical scaling is susceptible to downtime if the single server fails.

3. Speed: Vertical scaling is generally faster due to interprocess communication within a single server, while horizontal scaling may introduce latency due to network communication between multiple servers.

4. Data Consistency: Vertical scaling is preferred for maintaining data consistency, whereas horizontal scaling with distributed data can introduce complexities in achieving consistent data across multiple nodes.

5. Hardware Limitations: Consider the hardware limitations of vertical scaling, and if substantial growth beyond the capacity of a single server is expected, horizontal scaling may be a better option.

In conclusion, data scalability is essential for optimal performance and flexibility in your database. Understand vertical and horizontal scaling differences to make informed decisions based on your application's needs. Consider load balancing, fault tolerance, speed, data consistency, and growth. Combine vertical and horizontal scaling for desired scalability and performance.

Iterating over lists

Approach -1: Iterating over the list directly

list = [2, 4, 6, 8, 10]
for value in list:
    print(value, end=' ')
#Output = 2 4 6 8 10

• In this approach, the entire list [2, 4, 6, 8, 10] is stored in memory.

• The for loop iterates over each element of the list, processing them one by one.

• Memory usage is relatively higher since the complete list is stored in memory throughout the loop execution.

Approach -2: Using an iterator object

list = [2, 4, 6, 8, 10]
iter_obj = iter(list) # <list_iterator object at 0x7fcf3519f670>
print(next(iter_obj)) # Output = 2
print(next(iter_obj))# Output = 4
print(next(iter_obj))# Output = 6
print(next(iter_obj))# Output = 8
print(next(iter_obj))# Output = 10

• In this approach, an iterator object is explicitly created using iter(list).

• Each call to next(iter_obj) retrieves the next element from the iterator, without storing the entire list in memory.

• Only one element at a time is accessed and processed, reducing memory usage.

• As elements are fetched one by one, the memory footprint is lower compared to

Built-in Iterators in Python

Python provides several built-in iterators and iterable objects that simplify common iteration tasks. Let's explore a few of them:

1. range()

   The range() function generates a sequence of numbers within a specified range. It can be used directly as an iterator.

    for i in range(5):
        print(i,end = " ")
    #Output = 0 1 2 3 4 5
   

2. enumerate()

   The enumerate() function is useful when we need both the index and value of each element while iterating over a sequence.

    my_list = ['Nirmal', 'Niraj', 'Retrica']
    for index, value in enumerate(my_list):
        print(f"Index: {index}, Value: {value}")
   

   Output :

    Index: 0, Value: nirmal
    Index: 1, Value: niraj
    Index: 2, Value: retrica
   

3. zip():

   The zip() function combines multiple iterables into a single iterator. It pairs up corresponding elements from each iterable.

    names =  ['Nirmal', 'Niraj', 'Retrica']
    ages = [23, 20, 27]
   
    for name, age in zip(names, ages):
        print(f"Name: {name}, Age: {age}")
   

   Output :

    Name: Nirmal, Age: 23
    Name: Niraj, Age: 20
    Name: Retrica, Age: 27
   

Itertools Module

The itertools module is a powerful tool that provides various functions for efficient iteration and a combination of iterables. It extends the capabilities of built-in iterators.

Some modules are :

1. itertools.cycle()

This creates an iterator that cycles through elements of an iterable indefinitely.

import itertools

name = ["nirmal", "niraj", "retrica"]
myloopy = itertools.cycle(name)

print(next(myloopy))  # Output: nirmal
print(next(myloopy))  # Output: niraj
print(next(myloopy))  # Output: retrica

2. itertools.chain()

This combines multiple iterables into a single sequence.

import itertools

inter1 = itertools.chain("nirmal", "pandey")
print(list(inter1))  # Output: ['n', 'i', 'r', 'm', 'a', 'l', 'p', 'a', 'n', 'd', 'e', 'y']

1. itertools. accumulate()

This returns an iterator that produces accumulated sums of an iterable.

import itertools

num = [1, 2, 3, 4, 5, 6]
inter2 = itertools.accumulate(num)
print(list(inter2))  # Output: [1, 3, 6, 10, 15, 21]

4.itertools.repeat()

This generates an iterator that repeats a value a specified number of times.

import itertools

inter3 = itertools.repeat(10, 3)
print(list(inter3))  # Output: [10, 10, 10]

5: itertools.compress()

This filters an iterable based on the truth value of corresponding selectors.

import itertools

inter4 = itertools.compress("nirmal", [1, 0, 1, 0, 1, 1])
print(list(inter4))  # Output: ['n', 'r', 'a', 'l']

Custom Iterator

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value


my_list = [1, 2, 3, 4, 5]
my_iter = MyIterator(my_list)

for item in my_iter:
    print(item)

In this example, we create a custom iterator MyIterator takes a list as input. The __iter__() method returns the iterator object itself, and __next__() fetches the next element from the list. Once there are no more elements, a StopIteration exception is raised.

Private Members

• Private members in Python are denoted by a double underscore (__) prefix before the variable or method name.

• By convention, this prefix indicates that the member is intended for internal use within the class and should not be accessed directly from outside.

Example:

class MyClass:
    def __init__(self):
        self.__private_var = 100

    def __private_method(self):
        print("This is a private method.")

    def public_method(self):
        self.__private_method()
        print(f"The private variable value is: {self.__private_var}")


obj = MyClass()
obj.public_method()

This is a private method.
The private variable value is: 100

In the above example, __private_var and __private_method are private members of the MyClass class. They are accessed within the class using the double underscore prefix. If we want to access the private variable from outside like obj.__private_method() then it shows AttributeError

Protected Members

• Protected members in Python are denoted by a single underscore (_) prefix before the variable or method name.

• By convention, this prefix suggests that the member is intended to be used within the class and its subclasses.

• Though protected members can still be accessed from outside the class, developers should treat them as non-public, discouraging direct access.

Example:

class BaseClass:
    def __init__(self):
        self._protected_var = 10

    def _protected_method(self):
        print("This is a protected method.")

class SubClass(BaseClass):
    def access_protected(self):
        print(f"The protected variable value is: {self._protected_var}")
        self._protected_method()


obj = SubClass()
obj.access_protected()

In this example, _protected_var and _protected_method are protected members within the BaseClass. They are accessible within the class and its subclasses.

Abstract Classes

• An abstract class is a class that cannot be instantiated and acts as a blueprint for creating subclasses.

• It is a common interface or application programming interface(API) for concrete subclass.

from abc import ABC, abstractmethod

#Abstract class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

obj = Shape()
obj.area()

Output

TypeError: Can't instantiate abstract class pen with abstract method area

In this example, Shape is an abstract class that defines an abstract methodarea(). The abstractmethod decorator indicates that these methods must be implemented in the child subclasses derived from the Shape class. Attempting to create an instance of the Shape class directly will result in a TypeError.

from abc import ABC, abstractmethod

#Abstract class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    pass

obj = Circle()

Output

TypeError: Can't instantiate abstract class pen with abstract method area

If I implement the radius() method in the child class then it executes with error-free

from abc import ABC, abstractmethod

#Abstract class
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

'''
Circle class inherit abstract class Shape ,so it is mandatory to use 
method of parent/abstract class in this child class
'''
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius**2


obj = Circle(2)
area = obj.area()
print(f"Area is : {area}")

Output :

Area is : 12.56

In this example, the Circle class is a subclass of the Shape abstract class. It provides implementations for the area() and perimeter() methods, which are required by the Shape abstract class. The Circle class can be instantiated, and its methods can be called to perform specific calculations related to circles.

Method Overriding

• Method overriding occurs when a subclass defines a method with the same name as a method in its superclass.

• The method in the subclass overrides the implementation of the method in the superclass.

• This allows for different implementations of the same method across different classes.

Here's an example of method overriding in Python:

class Animal:
    def sound(self):
        print("Animal makes a sound")

class Dog(Animal):
    def sound(self):
        print("Dog barks")


# Creating instances of different classes
animal = Animal()
dog = Dog()

# Calling the overridden method
animal.sound()  # Output: Animal makes a sound
dog.sound()     # Output: Dog barks

In the example above, the Animal class has a method make_sound(). The Dog class inherit from the Animal class and override the make_sound() method with their specific implementations. When make_sound() is called on an instance of each class, the overridden method in the respective subclass is invoked.

Method Overloading

• Method overloading refers to defining multiple methods with the same name but different parameters within a class.

• Python doesn't support method overloading in the same way as some other languages (e.g., Java), where methods can have different signatures.

• However, you can achieve a form of method overloading using default argument values or variable-length arguments.

Here's an example demonstrating method overloading using default argument values:

class Calculator:
    def add(self, a, b):
        return a + b

    def add(self, a, b, c):
        return a + b + c

# Creating an instance of the Calculator class
calculator = Calculator()

# Calling the overloaded methods
result1 = calculator.add(2, 3)
result2 = calculator.add(2, 3, 4)

print(result1)  # Output: 5
print(result2)  # Output: 9

In this example, the Calculator class has two add() methods with different parameter counts. By providing different parameter lists, we can achieve a form of method overloading.

Single Inheritance:

• Single inheritance refers to a scenario where a class inherits from a single base class.

• The derived class acquires the attributes and methods of the base class, allowing for code reuse and extension of functionality.

class Creatures:
    def character(self):
        print("They Cannot talk")

class Bird(Creatures):
    def feature(self):
        print("Bird Can Fly")

# Creating an instance of Dog
bird = Bird()
bird.feature()  # Output: Bird Fly
bird.character() # Output: They Cannot talk

In this example, the Bird class inherits from the Creatures class using single inheritance. So, I can easily use the properties of the Creatures class inside the Bird class. For instance, bird. character() in the above example.

Multilevel Inheritance

Multilevel inheritance involves a chain of inheritance where a derived class inherits from a base class, and another class inherits from the derived class.

class Vehicle:
    def drive(self):
        print("Help in Driving")

class Car(Vehicle):
    def __init__(self, color, speed):
        self.color = color
        self.speed = speed

    def feature(self):
        print(f"Its color is {self.color} and speed is{self.speed}")

class SportsCar(Car):
    def __init__(self, color, speed, price):
        super().__init__(color, speed)# overriding init method of Car
        self.price = price


car = Car('black','100km/hr')
sport_car = SportsCar('red','200km/hr','15000$')

car.drive()
sport_car.feature() # accessing Car method
sport_car.drive() #accessing Vehicle method

Output :

Help in Driving
Its color is red and speed is200km/hr
Help in Driving

In this example, the SportsCar class inherits from theCar class, which itself inherits from the Vehicle class. The SportsCar class inherits the drive method from the Vehicle class through the intermediate Car class.

super() keyword

• super() is a built-in function that allows you to call a method from a parent class within a subclass.

• It provides a convenient way to invoke the parent class's methods and access its attributes.

• In the above example of multilevel inheritance, I am using super().__init__(color, speed) in the class SportsCar to override attributes from Car class.

    class SportsCar(Car):
        def __init__(self, color, speed, price):
            super().__init__(color, speed)#overriding init method of Car
            self.price = price
  
    '''THIS CODE IS EQUIVALENT TO BELOW CODE'''
  
    class SportsCar(Car):
        def __init__(self, color, speed, price):
            self.color = color
            self.speed = speed
            self.price = price
  

Multiple Inheritance

• Multiple inheritance allows a class to inherit from more than one base class.

• The derived class inherits attributes and methods from all the base classes, enabling it to combine the properties and behaviors of multiple classes. Let's explore an example:

class Vehicle:
    def drive(self):
        print("Driving")

class Car:
    def __init__(self, color, speed):
        self.color = color
        self.speed = speed

    def feature(self):
        print(f"It color is {self.color} and speed is{self.speed}")

class SportsCar(Vehicle, Car):
    def __init__(self, color, speed, price):
        super().__init__(color, speed)#overriding attribute of Car class
        self.price = price


car = Car('black','100km/hr')
sport_car = SportsCar('red','200km/hr','15000$')
sport_car.drive()  # Output: Driving

In this example, the Duck class inherits from both the Flyer and Swimmer classes using multiple inheritances. The Duck class can access the methods of both base classes.

MRO algorithm

• MRO (Method Resolution Order) is a process in Python that determines the order in which methods are resolved or searched for in a class hierarchy.

• It is used when multiple inheritance is involved, and it helps avoid ambiguities and conflicts in method resolution.

    class A:
        def greet(self):
            print("Hello from A")
  
    class B(A):
        def greet(self):
            print("Hello from B")
  
    class C(A):
        def greet(self):
            print("Hello from C")
  
    class D(B, C):
        pass
  
    # Creating an instance of D
    d = D()
    d.greet()
    print(d.greet())
    print(D.mro())
  

  Output :

    Hello from B
    [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>,
     <class '__main__.A'>, <class 'object'>]
  

• If we want to access the greet() method making an object for D then first it will check it in class D and then similarly in class B, C, and A respectively according to mro algorithm as in the above example.

• We are sure that we are creating the object of class D.So, it first checks in class D. But between class B and class C, class B is on the left of class C. Therefore, it accesses the method from class B based on mro() algorithm.

Instance Method

• Instance methods are the most common type of method in Python classes.

• They are associated with objects (instances) of a class and are defined within the class definition.

• Instance methods take the self parameter, which represents the instance itself.

• They can access and modify instance variables and invoke other instance methods of the same class. To define an instance method, we use the def keyword.

class Person:
    def instance_method(self, name, age):
        # Access instance variables
        self.name = name
        self.age = age

# Creating an instance of MyClass
obj = Person()

# Calling the instance method
obj.instance_method("Nirmal","23")

print(obj.name, obj.age)# Output = Nirmal 23

In the example above, instance_method() is an instance method that takes two arguments. It accesses the instance variables arg1 and arg2 using the self parameter performs some operations and modifies the instance variables accordingly.

Class Method

• They can be called on the class itself to perform operations rather than instances.

• Class methods take the cls parameter, which represents the class itself.

• We use the @classmethod decorator to define a class method.

• Class methods are often used for alternative constructors.

class MyClass:
    class_variable = "Hello, World!"

    @classmethod
    def class_method(cls):
        print("This is a class method.")
        print("Accessing class variable:", cls.class_variable)


# Calling class method
MyClass.class_method()

Static Method

• If we have nothing to do with instance and class then we use static method.

• They are defined within the class definition using the @staticmethod decorator.

• Static methods are not bound to the instance or the class, making them independent and self-contained.

class MyClass:

    @staticmethod
    def static_method():
        print("This is a static method.")

# Calling the static method
MyClass.static_method()

Output:

This is a static method.

Classes

• They are abstract and blueprint only. For example, Let's imagine a map of your house before you construct it is class.

• One class can have many objects like we can make multiple houses with the help of the same map.

    class Classname:
        #your variables and functions
  

Objects

• When the house is constructed from it then it is considered an object which exists and is real.

• Similarly, various features of house such as color, furniture, number of rooms, etc are also objects.

    object_name = Classname()
  

Some examples to create classes and objects :

#creating class
class Number:
    def sum(self):
        return self.a + self.b

obj = Number()
obj.a = 10
obj.b = 10
s = obj.sum()#calling sum() with 
print(s) # Object = 20

Creating a class with constructor(__init__())

class Map:
    #instance method because it is bound to instance of class
    category = 'house_category'
    def __init__(self, color, num_rooms, area):
        #declaring instance variable
        self.color = color
        self.num_rooms = num_rooms
        self.area = area

# Creating different objects for the House class
house1 = Map("Green", 10, 2500)#object1
house2 = Map("Orange", 2, 1000)#object3

print(house1.color) # Output = Green
print(house2.num_rooms) # Output = 2

__init__() constructor

• __init__ method is the constructor in Python which is automatically called at the time of object creation.

• __init__ is the instance method because it is bound to the instance of the class.

• Various variable inside this method is instance variable because it is associated with the object(self)

• category variable or attributes outside init consctuctor is class variable.

Self keyword

• self parameter is automatically passed as the first argument whenever the method is called.

• By convention, it is named self, although you can technically use any valid variable name in its place.

• self is the object in python.

• self parameter allows you to access and manipulate the instance's attributes and call other instance methods within the class. For instance, self.attribute_name or self.function_name()

Error types

Syntax error

Errors where the code is not valid in Python.

a, b = 1, 2
if a < b
    print("Messge")

Output :

File "main.py", line 2
    if a < b
           ^
SyntaxError: invalid syntax

Semantic error

Semantic errors can lead to incorrect program behavior or unexpected results, even if the code runs without any exceptions

# Calculate the area of a circle
radius = 5
area = 3.14 * radius * radius
print(area)# output = 78.5

In this code snippet, the intention is to calculate the area of a circle using the formula pi * radius * radius. However, there is a semantic error in the calculation. Instead of using the accurate value of π (pi), an approximation of 3.14 is used.

import math

radius = 5
area = math.pi * radius * radius
print(area)# output = 78.53981633974483

Runtime errors

• Runtime errors are errors that occur while executing code at runtime.

• They are caused by issues like dividing by zero, using undefined variables, performing operations on incompatible types, accessing invalid list indices, etc.

• You can handle runtime errors using try/except blocks.

• The try block contains the code that may raise an error, and the except block handles the error.

  To catch a ZeroDivisionError:

    try:  
        num / 0  
    except ZeroDivisionError:
        print("Cannot divide by zero")
  

  Catching TypeError:

    num = 5
    name = "nirmal"
    try:
         value = num + name  
    except TypeError:
         print("Incompatible types")
  

  To catch an IndexError:

    try:
        list[invalid_index]  
    except IndexError:
        print("Invalid list index")
  

try…except…else…finally

• In addition to try and except, you can use the else and finally keywords to further tune your code’s handling of exceptions.

• else: The optional else block is executed if no exceptions occur in the try block. It is used to specify code that should run only when no exceptions are raised.

• finally: The optional finally block is always executed, regardless of whether an exception occurred or not. It is used to specify code that should run regardless of the outcome, such as cleanup operations or resource release.

    try:
        print("write some logic")
    except:
        print("this happens only if it fails")
    else:
        print("this happens only if it succeeds")
    finally:
        print("this happens no matter what")
  

Own Exception Classes

• In python, raise keyword is used to explicitly raise an exception or an error during the execution of a program.

• It allows you to create custom exceptions or raise built-in exceptions to handle specific scenarios or error conditions.

• Syntax : raise ExceptionType("Error message")

    n = int(input("Enter any value::"))
    if n < 0:
      raise ValueError("Value cannot be negative")
    else:
      print(f"Enter value is :: {n}")