Python Fullstack training in Mumbai

Overview

History of Python

Python versions

Installation and setup

Interactive Python (REPL)

Using the Python shell

Writing and running Python scripts

Basic Syntax

Indentation and code blocks

Statements and expressions

Commenting code

Data Types

Numbers (integers, floats, complex numbers)

Strings

Booleans

Variables and Constants

Naming conventions

Assignment statements

Conditionals

If, elif, and else statements

Loops

For loops

While loops

Loop control statements (break, continue, pass)

Defining Functions

Function syntax

Parameters and arguments

Return values

Scope and Lifetime

Local and global scope

global and nonlocal keywords

Lambda Functions

Syntax and usage

Modules

Creating and using modules

Importing modules (import, from ... import)

Packages

Creating and using packages

Understanding __init__.py

Lists

Creating and accessing list elements

List methods and operations

Tuples

Creating and accessing tuple elements

Tuple operations

Sets

Creating and accessing set elements

Set methods and operations

Dictionaries

Creating and accessing dictionary elements

Dictionary methods and operations

String Manipulation

Concatenation and repetition

Slicing and indexing

String Methods

Common string methods (e.g., split(), join(), replace(), find())

Formatting Strings

Using format() method

f-strings (formatted string literals)

Reading Files

Opening files

Reading from files (read(), readline(), readlines())

Writing Files

Writing to files (write(), writelines())

Working with File Paths

Using os and pathlib modules

Handling Exceptions

Try, except, else, and finally blocks

Common built-in exceptions

Raising Exceptions

Using raise statement

Custom Exceptions

Creating user-defined exceptions

Classes and Objects

Defining classes

Creating objects

Attributes and Methods

Instance attributes and methods

Class attributes and methods

Inheritance

Single and multiple inheritance

Using super()

Polymorphism and Encapsulation

Method overriding

Standard Library

Overview of important modules (e.g., math, datetime, os, sys)

Third-Party Libraries

Installing packages using pip

Overview of popular libraries (e.g., requests, numpy, pandas)

Overview

What is Django?

Features of Django

The Django philosophy

Setting Up Django

Installing Django

Creating a Django project

Understanding the project structure

Creating and Running a Django Project

Using django-admin and manage.py

Running the development server

Django Settings

Configuration settings

Managing different environments (development, production)

Defining Models

Creating model classes

Fields and field types

Database Migrations

Creating and applying migrations

Understanding the migration files

Querying the Database

CRUD operations (Create, Read, Update, Delete)

Using the Django ORM to filter, order, and retrieve data

Introduction to Django Admin

Enabling and accessing the admin site

Customizing the admin interface

Admin Models                  

Registering models with the admin

Using model admins to customize list and detail views

Understanding Views

Function-based views (FBVs)

Class-based views (CBVs)

URL Routing

URL configuration (urls.py)

Path converters and named URLs

View Decorators

Using decorators to add functionality to views

Template Basics

Creating and using templates

Template inheritance (base and child templates)

Template Tags and Filters

Built-in template tags and filters

Creating custom template tags and filters

Static Files

Managing static files (CSS, JavaScript, images)

Using the {% static %} template tag

Creating and Using Forms

Defining forms in Django

Form fields and widgets

Form Validation

Built-in validators

Custom validation logic

Model Forms

Using ModelForm for creating forms directly from models

User Authentication

Built-in authentication system

User registration and login/logout

Permissions and Authorization

Managing user permissions and groups

Using decorators and mixins for access control

Custom User Models

Extending or replacing the default user model

Understanding Middleware

Built-in middleware components

Creating custom middleware

Middleware Lifecycle

Request and response processing

Introduction to DRF

Setting up Django REST framework

Understanding serializers

Building APIs

Creating API views (function-based and class-based)

Viewsets and routers

Authentication and Permissions

Implementing authentication (Token, JWT)

Setting up permissions and throttling