Python Fundamentals

0%Certificate0/392

Join the Community

What is Python?

History of Python

Features of Python

Python vs Other Languages

Setting Up Environment

First Python Program

Python Interpreter

Exercise: Variables

Exercise: Data Types

Numbers (int, float, complex)

Exercise: Numbers (int, float, complex)

Type Conversion

Exercise: Type Conversion

Exercise: Operators

Exercise: Input & Output

Exercise: Comments

Exercise: Indentation

Keywords & Identifiers

Exercise: Keywords & Identifiers

Exercise: String Basics

Indexing & Slicing

Exercise: Indexing & Slicing

Exercise: String Methods

String Formatting

Exercise: String Formatting

Exercise: f-Strings

Exercise: Raw Strings

String Operations

Exercise: String Operations

Regular Expressions

Exercise: Regular Expressions

if-else-elif Statements

Exercise: if-else-elif Statements

Ternary Operator

Exercise: Ternary Operator

Exercise: for Loop

Exercise: while Loop

break, continue, pass

Exercise: break, continue, pass

Loop else Clause

Exercise: Loop else Clause

Exercise: Nested Loops

match-case (Python 3.10+)

Exercise: match-case (Python 3.10+)

Exercise: Lists Basics

Indexing & Slicing

Exercise: Indexing & Slicing

Exercise: List Methods

List Comprehensions

Exercise: List Comprehensions

Exercise: Nested Lists

Exercise: Tuples Basics

Tuple Operations

Exercise: Tuple Operations

Tuple Unpacking

Exercise: Tuple Unpacking

Exercise: Named Tuples

Exercise: Sets Basics

Exercise: Set Methods

Exercise: Set Operations

Exercise: Frozen Sets

Dictionaries Basics

Exercise: Dictionaries Basics

Dictionary Methods

Exercise: Dictionary Methods

Dictionary Comprehensions

Exercise: Dictionary Comprehensions

Nested Dictionaries

Exercise: Nested Dictionaries

Exercise: defaultdict

Exercise: OrderedDict

Exercise: Counter

Functions Basics

Exercise: Functions Basics

Function Parameters

Exercise: Function Parameters

return Statement

Exercise: return Statement

Default Arguments

Exercise: Default Arguments

*args and **kwargs

Exercise: *args and **kwargs

Keyword Arguments

Exercise: Keyword Arguments

Lambda Functions

Exercise: Lambda Functions

Exercise: Recursion

Scope & Namespace

Exercise: Scope & Namespace

global & nonlocal

Exercise: global & nonlocal

Exercise: Closures

Exercise: Decorators

functools Module

Exercise: functools Module

map, filter, reduce

Exercise: map, filter, reduce

zip & enumerate

Exercise: zip & enumerate

sorted & reversed

Exercise: sorted & reversed

Exercise: any & all

Exercise: min, max, sum

Exercise: len & range

type & isinstance

Exercise: type & isinstance

Exercise: eval & exec

Exercise: Modules Basics

import Statement

Exercise: import Statement

Exercise: from...import

Creating Modules

Exercise: Creating Modules

Exercise: Packages

__init__.py File

Exercise: __init__.py File

Standard Library

Exercise: Standard Library

pip Package Manager

Exercise: pip Package Manager

Virtual Environments

Exercise: Virtual Environments

Exercise: OOP Basics

Classes & Objects

Exercise: Classes & Objects

__init__ Method

Exercise: __init__ Method

Instance Attributes

Exercise: Instance Attributes

Class Attributes

Exercise: Class Attributes

Instance Methods

Exercise: Instance Methods

Class Methods (@classmethod)

Exercise: Class Methods (@classmethod)

Static Methods (@staticmethod)

Exercise: Static Methods (@staticmethod)

Exercise: self Keyword

@property Decorator

Exercise: @property Decorator

Getters & Setters

Exercise: Getters & Setters

Exercise: Dunder Methods

__str__ & __repr__

Exercise: __str__ & __repr__

Operator Overloading

Exercise: Operator Overloading

Inheritance Basics

Exercise: Inheritance Basics

Single Inheritance

Exercise: Single Inheritance

Multiple Inheritance

Exercise: Multiple Inheritance

Multilevel Inheritance

Exercise: Multilevel Inheritance

Method Resolution Order (MRO)

Exercise: Method Resolution Order (MRO)

super() Function

Exercise: super() Function

Method Overriding

Exercise: Method Overriding

Exercise: Polymorphism

Exercise: Duck Typing

Abstract Classes

Exercise: Abstract Classes

Exercise: abc Module

Interfaces & Protocols

Exercise: Interfaces & Protocols

Encapsulation Basics

Exercise: Encapsulation Basics

Public, Private, Protected

Exercise: Public, Private, Protected

Exercise: Name Mangling

Exercise: Data Classes

Exercise: __slots__

Exercise: Metaclasses

Exercise: Descriptors

Class Decorators

Exercise: Class Decorators

Exercise: Mixins

Exception Basics

Exercise: Exception Basics

Exercise: try-except

Multiple Exceptions

Exercise: Multiple Exceptions

Exercise: else & finally

raise Statement

Exercise: raise Statement

Custom Exceptions

Exercise: Custom Exceptions

Exception Chaining

Exercise: Exception Chaining

Context Managers

Exercise: Context Managers

Exercise: with Statement

Exercise: File Basics

Exercise: Reading Files

Exercise: Writing Files

Exercise: File Modes

Exercise: File Methods

Working with Paths

Exercise: Working with Paths

Exercise: pathlib Module

Exercise: os Module

Working with JSON

Working with CSV

Exercise: Iterators

__iter__ & __next__

Exercise: __iter__ & __next__

Custom Iterators

Exercise: Custom Iterators

Exercise: Generators

yield Statement

Exercise: yield Statement

Generator Expressions

Exercise: Generator Expressions

itertools Module

Exercise: itertools Module

Functional Programming Basics

Exercise: Functional Programming Basics

Exercise: Pure Functions

Higher-Order Functions

Exercise: Higher-Order Functions

Partial Functions

Exercise: Partial Functions

Exercise: Currying

Exercise: Immutability

Type Hints Basics

Exercise: Type Hints Basics

Basic Type Annotations

Exercise: Basic Type Annotations

Exercise: typing Module

Exercise: Generic Types

Exercise: Type Aliases

Optional & Union

Exercise: Optional & Union

Exercise: Callable Types

mypy Type Checker

Exercise: mypy Type Checker

Concurrency Basics

Exercise: Concurrency Basics

threading Module

Exercise: threading Module

Creating Threads

Exercise: Creating Threads

Thread Synchronization

Exercise: Thread Synchronization

Exercise: Locks

Exercise: Deadlocks

multiprocessing Module

Exercise: multiprocessing Module

Exercise: Process Pools

Global Interpreter Lock (GIL)

Exercise: Global Interpreter Lock (GIL)

concurrent.futures

Exercise: concurrent.futures

Exercise: asyncio Basics

Exercise: async/await

Exercise: Coroutines

Exercise: Event Loops

Exercise: asyncio Tasks

unittest Module

pytest Framework

Test-Driven Development

Debugging Basics

Memory Profiling

Database Basics

Connecting to Databases

Executing Queries

Parameterized Queries

requests Library

Django Overview

NumPy Operations

Pandas DataFrames

Pandas Operations

Matplotlib Basics

Data Visualization

Memory Management

Garbage Collection

Reference Counting

Weak References

PEP 8 Style Guide

Code Formatting

Design Patterns

Performance Tips

Security Best Practices

Python Fundamentals

Welcome

Course Roadmap
Course Setup
Join the Community

Introduction to Python

What is Python?
History of Python
Features of Python
Python vs Other Languages
Setting Up Environment
First Python Program
Python Interpreter

Basic Syntax

Variables
Exercise: Variables
Data Types
Exercise: Data Types
Numbers (int, float, complex)
Exercise: Numbers (int, float, complex)
Type Conversion
Exercise: Type Conversion
Operators
Exercise: Operators
Input & Output
Exercise: Input & Output
Comments
Exercise: Comments
Indentation
Exercise: Indentation
Keywords & Identifiers
Exercise: Keywords & Identifiers

Strings

String Basics
Exercise: String Basics
Indexing & Slicing
Exercise: Indexing & Slicing
String Methods
Exercise: String Methods
String Formatting
Exercise: String Formatting
f-Strings
Exercise: f-Strings
Raw Strings
Exercise: Raw Strings
String Operations
Exercise: String Operations
Regular Expressions
Exercise: Regular Expressions

Control Flow

if-else-elif Statements
Exercise: if-else-elif Statements
Ternary Operator
Exercise: Ternary Operator
for Loop
Exercise: for Loop
while Loop
Exercise: while Loop
break, continue, pass
Exercise: break, continue, pass
Loop else Clause
Exercise: Loop else Clause
Nested Loops
Exercise: Nested Loops
match-case (Python 3.10+)
Exercise: match-case (Python 3.10+)

Lists

Lists Basics
Exercise: Lists Basics
Indexing & Slicing
Exercise: Indexing & Slicing
List Methods
Exercise: List Methods
List Comprehensions
Exercise: List Comprehensions
Nested Lists
Exercise: Nested Lists

Tuples

Tuples Basics
Exercise: Tuples Basics
Tuple Operations
Exercise: Tuple Operations
Tuple Unpacking
Exercise: Tuple Unpacking
Named Tuples
Exercise: Named Tuples

Sets

Sets Basics
Exercise: Sets Basics
Set Methods
Exercise: Set Methods
Set Operations
Exercise: Set Operations
Frozen Sets
Exercise: Frozen Sets

Dictionaries

Dictionaries Basics
Exercise: Dictionaries Basics
Dictionary Methods
Exercise: Dictionary Methods
Dictionary Comprehensions
Exercise: Dictionary Comprehensions
Nested Dictionaries
Exercise: Nested Dictionaries
defaultdict
Exercise: defaultdict
OrderedDict
Exercise: OrderedDict
Counter
Exercise: Counter

Functions

Functions Basics
Exercise: Functions Basics
Function Parameters
Exercise: Function Parameters
return Statement
Exercise: return Statement
Default Arguments
Exercise: Default Arguments
*args and **kwargs
Exercise: *args and **kwargs
Keyword Arguments
Exercise: Keyword Arguments
Lambda Functions
Exercise: Lambda Functions
Recursion
Exercise: Recursion
Scope & Namespace
Exercise: Scope & Namespace
global & nonlocal
Exercise: global & nonlocal
Closures
Exercise: Closures
Decorators
Exercise: Decorators
functools Module
Exercise: functools Module

Built-in Functions

map, filter, reduce
Exercise: map, filter, reduce
zip & enumerate
Exercise: zip & enumerate
sorted & reversed
Exercise: sorted & reversed
any & all
Exercise: any & all
min, max, sum
Exercise: min, max, sum
len & range
Exercise: len & range
type & isinstance
Exercise: type & isinstance
eval & exec
Exercise: eval & exec

Modules & Packages

Modules Basics
Exercise: Modules Basics
import Statement
Exercise: import Statement
from...import
Exercise: from...import
Creating Modules
Exercise: Creating Modules
Packages
Exercise: Packages
__init__.py File
Exercise: __init__.py File
Standard Library
Exercise: Standard Library
pip Package Manager
Exercise: pip Package Manager
Virtual Environments
Exercise: Virtual Environments

Object-Oriented Programming

OOP Basics
Exercise: OOP Basics
Classes & Objects
Exercise: Classes & Objects
__init__ Method
Exercise: __init__ Method
Instance Attributes
Exercise: Instance Attributes
Class Attributes
Exercise: Class Attributes
Instance Methods
Exercise: Instance Methods
Class Methods (@classmethod)
Exercise: Class Methods (@classmethod)
Static Methods (@staticmethod)
Exercise: Static Methods (@staticmethod)
self Keyword
Exercise: self Keyword
@property Decorator
Exercise: @property Decorator
Getters & Setters
Exercise: Getters & Setters
Dunder Methods
Exercise: Dunder Methods
__str__ & __repr__
Exercise: __str__ & __repr__
Operator Overloading
Exercise: Operator Overloading

Inheritance

Inheritance Basics
Exercise: Inheritance Basics
Single Inheritance
Exercise: Single Inheritance
Multiple Inheritance
Exercise: Multiple Inheritance
Multilevel Inheritance
Exercise: Multilevel Inheritance
Method Resolution Order (MRO)
Exercise: Method Resolution Order (MRO)
super() Function
Exercise: super() Function
Method Overriding
Exercise: Method Overriding

Polymorphism & Abstraction

Polymorphism
Exercise: Polymorphism
Duck Typing
Exercise: Duck Typing
Abstract Classes
Exercise: Abstract Classes
abc Module
Exercise: abc Module
Interfaces & Protocols
Exercise: Interfaces & Protocols

Encapsulation

Encapsulation Basics
Exercise: Encapsulation Basics
Public, Private, Protected
Exercise: Public, Private, Protected
Name Mangling
Exercise: Name Mangling

Advanced OOP

Data Classes
Exercise: Data Classes
__slots__
Exercise: __slots__
Metaclasses
Exercise: Metaclasses
Descriptors
Exercise: Descriptors
Class Decorators
Exercise: Class Decorators
Mixins
Exercise: Mixins

Exception Handling

Exception Basics
Exercise: Exception Basics
try-except
Exercise: try-except
Multiple Exceptions
Exercise: Multiple Exceptions
else & finally
Exercise: else & finally
raise Statement
Exercise: raise Statement
Custom Exceptions
Exercise: Custom Exceptions
Exception Chaining
Exercise: Exception Chaining
Context Managers
Exercise: Context Managers
with Statement
Exercise: with Statement

File Handling

File Basics
Exercise: File Basics
Reading Files
Exercise: Reading Files
Writing Files
Exercise: Writing Files
File Modes
Exercise: File Modes
File Methods
Exercise: File Methods
Working with Paths
Exercise: Working with Paths
pathlib Module
Exercise: pathlib Module
os Module
Exercise: os Module
shutil Module
Working with JSON
Working with CSV
pickle Module

Iterators & Generators

Iterators
Exercise: Iterators
__iter__ & __next__
Exercise: __iter__ & __next__
Custom Iterators
Exercise: Custom Iterators
Generators
Exercise: Generators
yield Statement
Exercise: yield Statement
Generator Expressions
Exercise: Generator Expressions
itertools Module
Exercise: itertools Module

Functional Programming

Functional Programming Basics
Exercise: Functional Programming Basics
Pure Functions
Exercise: Pure Functions
Higher-Order Functions
Exercise: Higher-Order Functions
Partial Functions
Exercise: Partial Functions
Currying
Exercise: Currying
Immutability
Exercise: Immutability

Type Hints & Annotations

Type Hints Basics
Exercise: Type Hints Basics
Basic Type Annotations
Exercise: Basic Type Annotations
typing Module
Exercise: typing Module
Generic Types
Exercise: Generic Types
Type Aliases
Exercise: Type Aliases
Optional & Union
Exercise: Optional & Union
Callable Types
Exercise: Callable Types
mypy Type Checker
Exercise: mypy Type Checker

Concurrency

Concurrency Basics
Exercise: Concurrency Basics
threading Module
Exercise: threading Module
Creating Threads
Exercise: Creating Threads
Thread Synchronization
Exercise: Thread Synchronization
Locks
Exercise: Locks
Deadlocks
Exercise: Deadlocks
multiprocessing Module
Exercise: multiprocessing Module
Process Pools
Exercise: Process Pools
Global Interpreter Lock (GIL)
Exercise: Global Interpreter Lock (GIL)
concurrent.futures
Exercise: concurrent.futures
asyncio Basics
Exercise: asyncio Basics
async/await
Exercise: async/await
Coroutines
Exercise: Coroutines
Event Loops
Exercise: Event Loops
asyncio Tasks
Exercise: asyncio Tasks

Testing

Testing Basics
unittest Module
pytest Framework
Test Fixtures
Mocking
Test Coverage
doctest
Test-Driven Development

Debugging & Profiling

Debugging Basics
pdb Debugger
logging Module
Profiling
timeit Module
Memory Profiling

Database Access

Database Basics
sqlite3 Module
Connecting to Databases
Executing Queries
Parameterized Queries
ORM Basics
SQLAlchemy

Web Development Basics

Web Basics
HTTP Requests
requests Library
Flask Basics
Django Overview
FastAPI Basics
REST APIs

Data Science Essentials

NumPy Basics
NumPy Arrays
NumPy Operations
Pandas Basics
Pandas DataFrames
Pandas Operations
Matplotlib Basics
Data Visualization

Advanced Topics

Memory Management
Garbage Collection
Reference Counting
Weak References
C Extensions
ctypes
Cython Basics

Best Practices

PEP 8 Style Guide
Code Formatting
Documentation
Docstrings
Pythonic Code
Design Patterns
Anti-Patterns
Performance Tips
Security Best Practices

Exercise: Global Interpreter Lock (GIL)

High Priority

Premium Content

Subscribe to unlock full access to this content and more premium articles.

Global Interpreter L...concurrent.futures