Content Plan (Day-wise)

Day 1: Introduction to Python

• What is Data and Its Importance in Modern Business

• Evolution of Data Over 35 years
• Key Companies Revolutionizing Data Management and Analytics
• Python's Role in Managing Data
• Importance of Python In DataScience and AI
• High level and Low level Programming Languages
• Bits and Bytes, Interpretor, Compiler
• Python’s Pattern of Interpretation and Internal Execution

Day 2: History and Internals of Python :

• History Of Python, Features of Python

• Memory Management in Python
• Setting up Python environment & Installation of Python & its Code Editors,

• First Python program: "Hello, World!"

• Print output using print() function,

Day 3: Variables and Data Types :

• Variables, keywords, Indentation, Comments

• String, Numbers, Boolean, List, Tuples

o Sets, Dictionary, Arrays, Type Casting .

Day 4: Data Structures - Lists

• Introduction to lists

• Common list methods (append(), remove(), pop(), slicing)

Day 5: Data Structures - Tuples and Sets

• Tuples: immutable sequences

• Sets: unique unordered elements, operations

Day 6: Data Structures - Dictionaries

• Key-value pairs

• Dictionary methods (keys(), values(), items())

Day 7: String Handling

• Output Formatting,

• Taking User Input and type casting ,

• Multiple Inputs from users

• String operations and methods

• String formatting (f-strings, .format())

Day 8: Python Operators

• Arithmetic Operators,
• Comparison Operators,
• Logical Operators,
• Bitwise Operators,
• Assignment Operators,
• Membership and Identity Operators—“in” and “is” operator)

Day 9: Control Flow & Loops

• Conditional statements: if- else, Nested if statement,

• If-elif-else , if-else on one line

• Ternary Condition, Case statement

• for loops

• while loops

• break, continue, and else in loops

Day 10 : Functions

• Defining functions

• Function arguments and return values

• Default and keyword arguments

Day 11: Modules and Packages

• Importing modules

• Creating custom modules

 • Using Python libraries (e.g., math, random)

Day 12: File Handling

• Reading from and writing to files

• Context manager (with statement)

Day 13: Exception Handling

• try, except, finally

• Handling multiple exceptions

• Raising exceptions

Day 14: Object-Oriented Programming - Basics

• Classes and objects

• Instance variables and methods

Day 15: Object-Oriented Programming - Advanced

• Inheritance

• Polymorphism

• Encapsulation

Day 16: Working with JSON

• Reading and writing JSON files

• JSON serialization and deserialization

Day 17: Recursion

• Recursive functions

• Common examples (factorial, Fibonacci)

Day 18: Lambda Functions and List Comprehensions

• Anonymous functions using lambda

• List comprehensions for concise operations

Day 19: Advanced Python – Decorators, Iterators

• Introduction to decorators, Writing custom decorators

• Introduction to Iterators, Iterators vs Iterables, Create an Iterator

• Looping through an Iterator, Stop Iteration

• Socket Programming

• Types of Sockets, Getting started with sockets in python ,

• Building TCP Server-Client Program, Understanding UDP communication

Day 20: Regular Expressions

• Introduction to regex

• Common methods (match, search, findall)

Day 21: Modules and Packages and PIP

• What is a Module..?

• Create a Module, Using a Module, Variables in Module

• Re-Naming a Module, Built-in Modules

• Using the dir() function, Using import statement

• What is a Package ..?, Using a Package, Find Packages, Remove Package, List packages

• Check if PIP is installed, install PIP, Download a package

HTML Content Plan (Day-wise)

Day1: Html
1: HTML Fundamentals
• 1. Introduction to HTML

o What is HTML?

o Basic Structure of an HTML document (DOCTYPE, html, head, body tags)

o Common HTML elements (e.g., <h1> to <h6>, <p>, <br>, <hr>)

o Attributes (e.g., id, class, style)

• 2. Text Formatting

o Bold (<b>, <strong>)

o Italic (<i>, <em>)

o Underline (<u>)

o Superscript (<sup>)

o Subscript (<sub>)

• 3. Lists

o Unordered lists (<ul>, <li>)

o Ordered lists (<ol>, <li>)

o Definition lists (<dl>, <dt>, <dd>)

• 4. Images

o Inserting images (<img>)

o Image attributes (e.g., src, alt, width, height)

 • 5. Links

o Creating hyperlinks (<a>)

o Linking to internal and external pages

o Linking to email addresses

• 6. Tables

o Basic table structure (<table>, <tr>, <th>, <td>)

o Table attributes (e.g., border, cellspacing, cellpadding)

Day 2: HTML Forms and Advanced Topics

• 1. HTML Forms

o Creating HTML forms (<form>)

o Form elements:

▪ Text fields (<input type="text">)

▪ Password fields (<input type="password">)

▪ Checkboxes (<input type="checkbox">)

▪ Radio buttons (<input type="radio">)

▪ Select lists (<select>, <option>)

▪ Text areas (<textarea>)

▪ Submit buttons (<input type="submit">)

▪ Reset buttons (<input type="reset">)

• 2. Frames

o Creating framesets (<frameset>, <frame>)

o (Note: While frames were once common, they are generally discouraged due to usability
and accessibility concerns.)

• 3. Iframes

o Embedding other HTML documents within a page (<iframe>)

• 4. Working with Colors

o Using color names (e.g., "red", "blue")

o Using hexadecimal color codes (e.g., "#FF0000")

• 5. Working with Fonts

 o Specifying font families

o Setting font sizes

• 6. Basic Styling with Inline CSS

o Introduction to Cascading Style Sheets (CSS)

Applying basic styles directly within HTML elements (e.g., style="color: red;")

CSS Content Plan (Day-wise):

Day 1: CSS Fundamentals

• 1. Introduction to CSS

o What is CSS?

o How CSS works with HTML

o Different ways to write CSS (inline, internal, external stylesheets)

• 2. Basic Selectors

o Element selectors: (e.g., p, h1, div)

o Class selectors: (e.g., .myClass)

o ID selectors: (e.g., #myID)

• 3. Basic CSS Properties

o Text styling:

▪ color, font-family, font-size, font-weight, text-align, text-decoration

o Backgrounds:

▪ background-color, background-image, background-position

o Dimensions:

▪ width, height, margin, padding, border

• 4. Display and Positioning

o display property (e.g., block, inline, inline-block)

o Basic positioning (e.g., position: static, position: relative)

• 5. Working with Colors

o Color names, hexadecimal codes, RGB/RGBA values

Day 2: CSS Layout and Advanced Concepts

• 1. CSS Layout
 o Flexbox:

▪ Basic concepts of flexbox (flex container, flex items)

▪ Key flexbox properties (flex-direction, justify-content, align-items)

o Grid Layout:

▪ Basic concepts of grid layout (grid container, grid items)

▪ Key grid properties (grid-template-columns, grid-template-rows, grid-template-

areas)

• 2. Positioning

o Absolute positioning:

▪ Positioning elements relative to the nearest positioned ancestor

o Fixed positioning:

▪ Positioning elements relative to the viewport

• 3. CSS Transitions and Animations

o Introduction to CSS transitions

o Basic CSS animations (using @keyframes)

• 4. Responsive Design

o Introduction to media queries

o Creating responsive layouts using media queries

• 5. Working with Pseudo-classes and Pseudo-elements

o Pseudo-classes: (e.g., :hover, :active, :visited)

o Pseudo-elements: (e.g., ::before, ::after)

JavaScript Content Plan (Day-wise)

Day-Wise Topics and subtopics for JavaScript:

Day 1: Introduction to JavaScript

• What is JavaScript?

o Definition: A high-level, interpreted programming language

o Where it's used: Front-end web development (interactivity, dynamic content), back-
end development (Node.js), mobile app development

o Relationship with HTML and CSS

• Basic Syntax
 o Variables: let, const, var

o Data Types: Numbers, Strings, Booleans, Arrays, Objects

o Operators: Arithmetic, Assignment, Comparison, Logical

o Control Flow:

▪ if, else if, else statements

▪ switch statement

▪ Loops: for, while, do...while

• Console Output:

o Using console.log() for debugging and output

Day 2: Functions
• Function Definition:

o function keyword, parameters, arguments

o Function Scope and Hoisting

• Function Expressions:

o Defining functions as variables

• Arrow Functions:

o Concise syntax for writing functions

• Return Values:

o Returning data from a function

Day 3: Arrays and Objects

• Arrays

o Creating and accessing array elements

o Array methods: push, pop, shift, unshift, splice, slice, map, filter, reduce

o Iterating over arrays: for...of loop

• Objects

o Creating objects using object literals and constructors

o Accessing object properties: dot notation and bracket notation

o Adding, modifying, and deleting properties

o Working with object methods

Day 4: DOM Manipulation
• Document Object Model (DOM)

o Understanding the DOM tree

o Selecting elements:

▪ getElementById, getElementsByClassName, querySelector, querySelectorAll

o Manipulating elements:

▪ Changing content (innerHTML, textContent)

▪ Modifying attributes (style, class)

▪ Creating and removing elements

• Event Handling

o Event listeners: addEventListener

o Common events: click, mouseover, mouseout, keydown, keyup

o Handling user interactions

Day 5: JavaScript and the Browser

• Browser Object Model (BOM)

o Working with the browser window (e.g., window.alert, window.confirm)

o Handling browser events (e.g., onload, onresize)

• Timers

o setTimeout and setInterval functions

• Working with the browser console

o Debugging JavaScript code

Day 6: Introduction to Asynchronous JavaScript

• Callbacks

o Handling asynchronous operations (e.g., network requests)

• Promises

o A more elegant way to handle asynchronous operations

o then, catch, finally methods

• Async/Await

o A cleaner syntax for working with Promises

 SQL Topics Day 1: SQL Foundations

1. Introduction to SQL

What is SQL?

Importance of SQL in the data world.

Real-life applications of SQL (e.g., e-commerce, banking, analytics).

2. Relational Database Basics

Tables, rows, and columns: Understanding database structure.

Data types: Common data types like INT, VARCHAR, DATE, etc.

Constraints:

Primary key and foreign key.

Unique, Not Null, Default.

Relationships:

One-to-One, One-to-Many, Many-to-Many.

3. Setting Up SQL Environment

Installing MySQL/PostgreSQL.

Connecting to a database using command-line tools, GUI tools (e.g., MySQL Workbench, pgAdmin).

Creating your first database and table.

Day 2: Basic and Intermediate SQL Queries

4. Basic SQL Commands

SELECT: Retrieve data from a table.

INSERT: Add records into a table.

UPDATE: Modify existing records.

DELETE: Remove records from a table.

5. Filtering and Sorting Data

WHERE clause: Filter rows based on conditions.

 Operators:

=, !=, <, >, BETWEEN, LIKE, IN.

ORDER BY: Sort data in ascending or descending order.

Day 3: Advanced Queries with Aggregation and Joins

6. Aggregating Data

Aggregate functions:

SUM(), AVG(), COUNT(), MIN(), MAX().

GROUP BY: Group data by one or more columns.

HAVING: Filter grouped data.

7. Joins

Importance of Joins in combining data from multiple tables.

Types of Joins:

Inner Join: Combine rows with matching values.

Left Join: Include all rows from the left table and matching rows from the right.

Right Join: Include all rows from the right table and matching rows from the left.

Full Join: Include rows with matches in either table

MongoDB Topics
Day 1: MongoDB Basics

1. Introduction to MongoDB

What is MongoDB?

Key features and use cases:

Schema flexibility, scalability, and high performance.

Use cases like real-time analytics, IoT, and e-commerce.

Differences between MongoDB and SQL:

Schema-less vs. schema-based, collections vs. tables, etc.

2. Setting Up MongoDB
 Installing MongoDB and Compass:

Steps to install MongoDB locally or use MongoDB Atlas (cloud).

Installing and using Compass for GUI-based operations.

Basic Mongo Shell commands:

show dbs, use <database>, show collections.

3. MongoDB Structure

Databases, Collections, and Documents:

Overview of the hierarchical structure in MongoDB.

Comparison to relational databases.

BSON format overview:

How MongoDB uses BSON (binary JSON) for data storage.

4. CRUD Operations (Part 1)

Insert operations:

insertOne() and insertMany() with examples.

.Read operations (Basics):

find() and findOne() to retrieve documents.

Day 2: Querying and Advanced CRUD Operations

4. CRUD Operations (Part 2)

Update operations:

updateOne() and updateMany() with $set, $inc.

Delete operations:
 deleteOne() and deleteMany().

5. Querying in MongoDB

Comparison operators:

$eq, $ne, $gt, $lt, $in, $nin.

Logical operators:

$and, $or, $not.

Finally InClass Project: (Using Django Framework)

FrontEnd: Html, Css, Js,

Middleware: Python

BackEnd : Postgresql

Framework: Django