Python Tutorials

Before learning Python programming, you need an environment where you can write and execute Python programs. The easiest option for beginners is IDLE, which is included with the standard Python installation.

IDLE stands for Integrated Development and Learning Environment. It provides a simple interface for writing, editing, and executing Python programs without requiring a separate code editor.

What You Will Learn

Step 1 Check Whether Python Is Already Installed

Before installing Python, first check whether Python is already available on your computer.

On Windows, open Command Prompt.

1. Press Windows + R.
2. Type cmd.
3. Press Enter.

Now execute:

python --version

If Python is installed, you may see output similar to:

Python 3.x.x

If Python is not installed, Windows may display a message indicating that the command cannot be found.

Step 2 Download Python

If Python is not installed, download it from the official Python website.

Choose the latest supported Python 3 release available for your operating system.

Step 3 Start the Python Installation

After downloading the Python installer:

1. Open your Downloads folder.
2. Find the downloaded Python installer.
3. Double-click the installer.
4. Wait for the Python Setup window to open.

Step 4 Enable "Add Python to PATH"

On the Python installation screen, you will find an option similar to:

Enable this option before continuing with the installation.

PATH allows Windows to find Python when you type commands such as python in Command Prompt.

Step 5 Install Python

After enabling the PATH option:

1. Click Install Now.
2. Allow the installer to copy the required Python files.
3. Wait until the installation is completed.
4. Click Close.

Step 6 Verify the Installation

Open a new Command Prompt window and execute:

python --version

You should see a Python version:

Python 3.x.x

You can also start Python directly from the Command Prompt:

python

If Python is working correctly, you will see the Python interactive shell with the >>> prompt.

>>> print("Hello Python")
Hello Python

Exit the Python shell using:

exit()

Step 7 Open Python IDLE

IDLE is installed along with Python, so you normally do not need to install it separately.

To open IDLE in Windows:

1. Open the Start Menu.
2. Search for IDLE.
3. You should see an entry similar to IDLE (Python 3.x).
4. Click it to open IDLE.

Step 8 Understand the IDLE Shell

When IDLE opens, you will normally see a window containing the Python Shell.

The Shell allows you to execute Python statements immediately without creating a Python file.

For example, type:

>>> 10 + 20
30

You can also execute:

>>> print("Welcome to Python")
Welcome to Python

Step 9 Create a Python Program in IDLE

The Shell is useful for testing small pieces of code, but complete programs should normally be saved in a Python file.

To create a Python file:

1. Open IDLE.
2. Click File.
3. Select New File.

A new editor window will appear.

Step 10 Write Your First Python Program

In the new IDLE editor window, type the following program:

name = "Python"

print("Welcome to", name)

This program creates a variable named name and stores the value "Python" in it.

The print() function then displays the value on the screen.

Step 11 Save the Python Program

Python programs should be saved with the .py file extension.

1. Click File.
2. Select Save As.
3. Choose a folder where you want to store your programs.
4. Enter the file name hello.py.
5. Click Save.

Step 12 Run the Program in IDLE

After saving the program, you can execute it directly from IDLE.

1. Make sure hello.py is open in the IDLE editor.
2. Click Run from the menu.
3. Select Run Module.

You can also use the keyboard shortcut:

F5

IDLE will execute the program and display the output in the Python Shell.

Welcome to Python

Step 13 Modify and Run the Program Again

One advantage of using IDLE is that you can quickly modify your program and run it again.

Change the program to:

name = "Python Programming"

print("Welcome to", name)
print("Let's start learning!")

Save the file and press F5.

The Shell will display:

Welcome to Python Programming
Let's start learning!

Step 14 Understand the Difference Between Shell and Editor

Step 15 Run a Python File from Command Prompt

Although IDLE is convenient for beginners, it is also important to understand how Python programs are executed from a terminal.

Open Command Prompt and navigate to the folder containing hello.py.

Then run:

python hello.py

The output will be:

Welcome to Python Programming
Let's start learning!

Common Problems

IDLE

Run → Run Module

Python Setup Checklist

Every Python program works with data. A program may need to store a person's name, calculate a salary, compare two numbers, store multiple values, or perform mathematical calculations.

Python provides variables to store or refer to values, data types to describe the kind of data being used, and operators to perform operations on that data.

Variables

A variable is a name used to refer to a value stored during program execution.

For example:

name = "Arun"
age = 22
salary = 25000.50
                  

In this example:

• name refers to the string "Arun".
• age refers to the integer 22.
• salary refers to the floating-point value 25000.50.

The = symbol is called the assignment operator. It assigns a value to a variable.

Example: Using Variables

name = "Arun"
age = 22
salary = 25000.50

print(name)
print(age)
print(salary)
                  

Arun
22
25000.5
                  

Changing the Value of a Variable

A variable can be assigned a new value at any time.

age = 22                  
print(age)                    
age = 23                        
print(age)
                  

22
23
                    

The variable age first refers to 22 and later refers to 23.

Multiple Assignment

Python allows multiple variables to be assigned in a single statement.

name, age, city = "Arun", 22, "Chennai"                    
print(name)
print(age)
print(city)
                  

Variable Naming Rules

Python has rules that must be followed when creating variable names.

Good Variable Names

student_name = "Arun"
student_age = 22
total_salary = 35000
                  

Python's Dynamic Typing

Python is a dynamically typed language. This means you do not need to explicitly specify the data type when creating a variable.

For example:

value = 10
value = "Python"
value = 25.5
                  

The same variable can refer to values of different types at different points during program execution.

Python Data Types

A data type defines the kind of value that Python is working with. Different types support different operations.

Some of the most commonly used built-in Python data types are:

Numeric Data Types

Python provides several numeric types. The most commonly used are int, float, and complex.

Integer

The int type represents whole numbers without a decimal component.

age = 22
quantity = 100
temperature = -5
                  

Float

The float type represents numbers containing a decimal component.

price = 99.50
height = 5.8
percentage = 82.75
                  

Complex

Complex numbers contain a real part and an imaginary part. Python uses j to represent the imaginary component.

number = 3 + 4j
print(number)
                  

String Data Type

A str represents text. Strings can be created using single quotes, double quotes, or triple quotes.

name = "Arun"
city = 'Chennai'
message = """Welcome to
Python Programming"""
                  

Strings can contain letters, numbers, spaces, and special characters.

course = "Python Full Stack"
code = "PY101"
message = "Hello, Python!"
                  

Boolean Data Type

The bool data type has only two possible values: True and False.

is_logged_in = True
is_admin = False

print(is_logged_in)
print(is_admin)
                  

Boolean values are commonly used with conditions and comparison operations.

Collection Data Types

Python provides several built-in collection types for storing multiple values.

Checking the Data Type

Python provides the built-in type() function to determine the type of a value or variable.

age = 22
price = 99.50
name = "Arun"

print(type(age))
print(type(price))
print(type(name))
                  

                    <class 'int'>
                    <class 'float'>
                    <class 'str'>
                  

The type() function is especially useful when debugging programs or understanding what type of value a variable currently contains.

Type Conversion

Sometimes a program receives a value in one data type but needs to use it as another type. Python provides built-in functions for converting compatible values.

Example: String to Integer

age = "22"              
age = int(age)                    
print(age + 5)
                  

Without conversion, "22" is a string rather than a number. Converting it to int allows numerical operations.

Example: Integer to String

age = 22              
message = "My age is " + str(age)              
print(message)
                  

Mutable and Immutable Data

Python objects can broadly be classified as mutable or immutable.

A mutable object can be changed after it is created, while an immutable object cannot be changed after creation.

This concept becomes particularly important when working with lists, functions, and object references.

Operators

Operators are symbols or keywords used to perform operations on values and variables.

Python provides several categories of operators.

Arithmetic Operators

Arithmetic operators are used to perform mathematical calculations.

Arithmetic Example

a = 10
b = 3                    
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)
print(a % b)
print(a ** b)
                  

Comparison Operators

Comparison operators compare two values and return either True or False.

a = 10
b = 3                    
print(a > b)
print(a == b)
print(a != b)
                  

True
False
True
                  

Assignment Operators

Assignment operators are used to assign values to variables and update their existing values.

score = 100              
score += 20                    
print(score)
                  

Logical Operators

Logical operators are used to combine or modify Boolean expressions.

age = 22
has_id = True                    
print(age >= 18 and has_id)
print(age < 18 or has_id)
print(not has_id)
                  

Membership Operators

Membership operators check whether a value exists inside a collection such as a string, list, tuple, or set.

Python provides:

• in
• not in

languages = ["Python", "Java", "C++"]              
print("Python" in languages)
print("PHP" not in languages)
                  

True
True
                  

Operator Precedence

When an expression contains multiple operators, Python follows a specific order to determine which operation should be performed first.

For example:

result = 10 + 5 * 2              
print(result)
                  

Multiplication is performed before addition, so the expression is evaluated as:

10 + (5 * 2)
10 + 10
20
                  

Parentheses can be used when you want to explicitly control the order of evaluation.

result = (10 + 5) * 2                    
print(result)
                  

Common Beginner Mistakes

age = 22                            
print(age == 22)
                          

age = "22"                            
age = int(age)                            
print(age + 5)
                          

2name = "Arun"

name2 = "Arun"

A Python program normally executes statements from top to bottom. However, real-world programs often need to make decisions or repeat certain operations multiple times.

For example, a program may need to check whether a student has passed, determine whether a person is eligible to vote, display different messages based on a user's age, or process every item in a list.

Python provides conditional statements for decision-making and loops for repeated execution.

Conditional Statements

Conditional statements allow a program to make decisions based on whether a condition is True or False.

Python commonly uses:

• if
• if ... else
• if ... elif ... else
• Nested if statements

Conditions usually contain comparison or logical operators.

The if Statement

The if statement executes a block of code only when its condition evaluates to True.

Basic syntax:

if condition:
  statement

For example:

age = 20

if age >= 18:
    print("You are eligible to vote")

Since age >= 18 evaluates to True, Python executes the indented print() statement.

Indentation in Python

Python uses indentation to define a block of code. Unlike languages that use curly braces such as { }, Python uses whitespace to determine which statements belong to a conditional or loop.

age = 20

if age >= 18:
    print("Eligible")
    print("Age requirement satisfied")

Both print() statements belong to the if block because they are indented.

The if...else Statement

The else block is executed when the if condition is False.

age = 16

if age >= 18:
    print("You are eligible to vote")
else:
    print("You are not eligible to vote")

Only one of the two blocks is executed.

The if...elif...else Statement

When there are multiple possible conditions, Python provides elif, which means "else if".

marks = 75

if marks >= 90:
    grade = "A"
elif marks >= 60:
    grade = "B"
else:
    grade = "C"

print(grade)

Python checks the conditions from top to bottom. Once it finds a condition that is True, its corresponding block executes and the remaining conditions are skipped.

Using Multiple elif Conditions

You can use multiple elif blocks when a program needs to handle several possible outcomes.

marks = 82

if marks >= 90:
    grade = "A+"
elif marks >= 80:
    grade = "A"
elif marks >= 70:
    grade = "B"
elif marks >= 60:
    grade = "C"
else:
    grade = "F"

print(grade)

Using Comparison Operators in Conditions

Conditions commonly use comparison operators such as:

Using Logical Operators in Conditions

Logical operators allow multiple conditions to be combined.

age = 25
has_id = True

if age >= 18 and has_id:
    print("Entry allowed")
else:
    print("Entry denied")

Here, both conditions must be true because the and operator is being used.

Nested if Statements

An if statement can be placed inside another if statement. This is called a nested if.

age = 22
has_id = True

if age >= 18:
    if has_id:
        print("Entry allowed")
    else:
        print("ID is required")
else:
    print("You are underage")

The inner condition is checked only when the outer condition is true.

Practical Example: Login Validation

Conditional statements are frequently used when validating information.

username = "admin"
password = "python123"

if username == "admin" and password == "python123":
    print("Login successful")
else:
    print("Invalid username or password")

Loops

A loop allows a block of code to execute repeatedly.

Instead of writing the same statement many times, you can use a loop to perform the operation automatically.

Python provides two main types of loops:

• for loop
• while loop

The for Loop

A for loop is used to iterate over the items of an iterable such as a list, tuple, string, set, or range.

For example:

for number in range(1, 6):
  print(number)

1
2
3
4
5

During each iteration, the variable number receives the next value produced by range(1, 6).

Understanding range()

The range() function is commonly used with for loops to generate a sequence of numbers.

When using two arguments, range(start, stop) begins at start and stops before stop.

for number in range(1, 6):
  print(number)

The values are:

1
2
3
4
5

Using a Step with range()

A third argument can be used to specify how much the value should change during each iteration.

for number in range(2, 11, 2):
  print(number)

2
4
6
8
10

Using for with a String

A string is iterable, so a for loop can process one character at a time.

name = "Python"

for character in name:
    print(character)

P
y
t
h
o
n

Using for with a List

A for loop can also process each item in a list.

languages = ["Python", "Java", "C++"]

for language in languages:
    print(language)

Python
Java
C++

Nested for Loops

A loop can be placed inside another loop. This is called a nested loop.

for row in range(1, 4):
  for column in range(1, 4):
      print(row, column)

The inner loop completes all of its iterations for every iteration of the outer loop.

The while Loop

A while loop repeatedly executes a block of code as long as its condition remains True.

Example:

count = 1

while count <= 5:
  print(count)
  count += 1

1
2
3
4
5

The variable count changes during every iteration. Once the condition count <= 5 becomes false, the loop stops.

Avoiding Infinite Loops

A while loop must eventually reach a condition that becomes false. Otherwise, it can continue running indefinitely.

For example:

count = 1

while count <= 5:
    print(count)
    count += 1

Here, count += 1 changes the value used by the condition. Without an appropriate update, the condition might never become false.

for Loop vs while Loop

The break Statement

The break statement immediately terminates the current loop. Python continues execution with the statement after the loop.

for number in range(1, 10):

  if number == 5:
      break

  print(number)

1
2
3
4

When number becomes 5, break stops the loop.

The continue Statement

The continue statement skips the remaining statements in the current iteration and moves to the next iteration.

for number in range(1, 6):

  if number == 3:
      continue

  print(number)

1
2
4
5

When number becomes 3, Python skips the print() statement for that iteration and continues with the next value.

break vs continue

The pass Statement

The pass statement does nothing. It is used as a placeholder when Python requires a statement but you do not want to execute any code yet.

age = 20

if age >= 18:
    pass
else:
    print("Underage")

pass is useful while developing a program when a block is planned but its implementation has not been written yet.

else with Loops

Python also allows an else block to be associated with a loop. The else block executes when the loop finishes normally without encountering break.

for number in range(1, 4):
    print(number)
else:
    print("Loop completed")

1
2
3
Loop completed

Practical Example: Student Result

Conditional statements and loops are often combined to solve practical problems.

The following example checks the result of multiple students:

marks = [85, 72, 45, 91, 38]

for mark in marks:

    if mark >= 50:
        print(mark, "Pass")
    else:
        print(mark, "Fail")

85 Pass
72 Pass
45 Fail
91 Pass
38 Fail

Here, the for loop processes every mark, while the if...else statement determines whether each student has passed or failed.

Practical Example: Finding Even Numbers

The modulus operator can be combined with a loop and a condition to identify even numbers.

for number in range(1, 11):

  if number % 2 == 0:
      print(number)

2
4
6
8
10

Common Beginner Mistakes

if age >= 18:
  print("Eligible")

if age >= 18:
  print("Eligible")
  print("You can continue")

                            count = 1                            
                            while count <= 5:
                            print(count)
                            count += 1
                          

A function is a reusable block of code designed to perform a specific task. Instead of writing the same logic repeatedly, you can place it inside a function and call that function whenever you need it.

Functions are one of the most important concepts in Python because they help break a large program into smaller and more manageable parts.

For example, an application may contain separate functions for calculating salary, validating a user, calculating an order total, sending a message, or processing data.

Understanding a Function

A Python function is created using the def keyword. The function has a name, optional parameters, and a block of statements.

def function_name(parameters):
  statements
  return value

Creating a Function

The following function displays a welcome message:

def greet():
  print("Welcome to Python")

greet()

The function is defined using def greet():. The statement inside the function is executed only when greet() is called.

Defining and Calling a Function

There is an important difference between defining a function and calling a function.

def greet():
print("Hello")

greet()

Parameters and Arguments

Functions can accept values from the code that calls them. These values are commonly referred to as arguments.

A parameter is the variable defined inside the function definition, while an argument is the actual value passed when the function is called.

def greet(name):
  print("Hello", name)

greet("Arun")
greet("Priya")

Hello Arun
Hello Priya

Here, name is the parameter, while "Arun" and "Priya" are arguments.

Multiple Parameters

A function can accept multiple parameters. Each parameter can represent a different piece of information required by the function.

def student(name, age, course):
  print("Name:", name)
  print("Age:", age)
  print("Course:", course)

student("Arun", 22, "Python")

Name: Arun
Age: 22
Course: Python

Returning a Value

A function can perform a calculation and send the result back to the part of the program that called it. The return statement is used for this purpose.

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

result = add(10, 20)

print(result)

The value returned by add() is stored in the result variable.

print() vs return

Beginners often confuse print() and return. They serve different purposes.

For reusable logic, return is often more useful than simply printing the result.

Returning Multiple Values

Python allows a function to return multiple values. Internally, Python packages the returned values together, and they can be assigned to multiple variables.

def calculate(a, b):
  total = a + b
  difference = a - b
  return total, difference

result, difference = calculate(20, 5)

print(result)
print(difference)

25
15

Default Arguments

A parameter can have a default value. If the caller does not provide a value for that parameter, Python uses the default value.

def greet(name="Student"):
  print("Hello", name)

greet()
greet("Arun")

Hello Student
Hello Arun

In the first call, no value is supplied, so Python uses "Student".

Keyword Arguments

Keyword arguments allow you to pass values by explicitly specifying the parameter name.

def student(name, age):
  print("Name:", name)
  print("Age:", age)

student(age=22, name="Arun")

Name: Arun
Age: 22

Notice that the arguments are supplied in a different order from the function definition. Because the parameter names are specified, Python knows which value belongs to which parameter.

Positional Arguments

Positional arguments are assigned to parameters according to their position.

def student(name, age):
  print(name)
  print(age)

student("Arun", 22)

The first argument is assigned to name and the second argument is assigned to age.

Positional vs Keyword Arguments

Variable Scope in Functions

The scope of a variable determines where that variable can be accessed. Variables created inside a function are generally local to that function.

def calculate():
  result = 100
  print(result)

calculate()

The variable result belongs to the function's local scope. It is available inside the function where it was created.

Local and Global Variables

A variable created outside a function is generally considered a global variable, while a variable created inside a function is local to that function.

course = "Python"

def display():
  name = "Arun"

  print(course)
  print(name)

display()

The function can access the global course variable and its own local name variable.

Calling One Function from Another

Functions can call other functions. This makes it possible to divide a larger task into smaller reusable operations.

def calculate_total(price, quantity):
  return price * quantity


def display_bill():
  total = calculate_total(500, 3)
  print("Total:", total)


display_bill()

Here, display_bill() calls calculate_total() to perform the calculation.

Common Beginner Mistakes

def greet():
  print("Hello")

greet()

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

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

add(10, 20)

Function Best Practices

A data structure determines how multiple values are stored, organized, accessed and modified inside a program. Choosing the correct data structure can make a program easier to understand and more efficient.

Python provides several built-in data structures. The four most commonly used collection types are list, tuple, set and dictionary.

Python's Built-in Collection Types

* Sets are unordered collections and should not be used when positional order is required.
** Dictionaries preserve insertion order in modern Python versions.

Lists

A list is an ordered and mutable collection. It can contain multiple values and those values can be changed after the list is created.

Lists can contain values of the same type or different types.

students = ["Arun", "Priya", "Kumar"]

print(students)

List Indexing

Every element in a list has a position called an index. Python uses zero-based indexing, so the first element has index 0.

students = ["Arun", "Priya", "Kumar", "Meena"]

print(students[0])
print(students[2])
print(students[-1])

Arun
Kumar
Meena

Modifying List Elements

Lists are mutable, so individual elements can be changed using their index.

students = ["Arun", "Priya", "Kumar"]

students[1] = "Meena"

print(students)

Common List Methods

Tuples

A tuple is an ordered and immutable collection. Like lists, tuples support indexing and slicing, but their elements cannot normally be changed after creation.

coordinates = (10, 20, 30)

print(coordinates[0])
print(coordinates[-1])

10
30

Tuple Immutability

Because tuples are immutable, an existing element cannot simply be replaced.

coordinates = (10, 20, 30)

# coordinates[0] = 50

Tuple Methods

Since tuples cannot be modified, they have fewer methods than lists. Two commonly used methods are count() and index().

numbers = (10, 20, 20, 30)

print(numbers.count(20))
print(numbers.index(30))

2
3

Sets

A set is a mutable collection that stores unique values. Duplicate elements are automatically removed.

numbers = {10, 20, 20, 30, 30}

print(numbers)

Adding Elements to a Set

numbers = {10, 20, 30}

numbers.add(40)

print(numbers)

Removing Elements from a Set

Sets provide methods such as remove() and discard().

numbers = {10, 20, 30}

numbers.remove(20)

print(numbers)

Dictionaries

A dictionary stores data as key-value pairs. Each key identifies a corresponding value.

student = {
    "name": "Arun",
    "age": 22,
    "course": "Python"
}

print(student["name"])
print(student["course"])

Arun
              Python

Dictionary Keys and Values

A dictionary consists of keys and values. Keys must be unique, while values can be duplicated.

student = {
    "name": "Arun",
    "age": 22,
    "course": "Python"
}

print(student.keys())
print(student.values())
print(student.items())

Adding and Updating Dictionary Data

Dictionaries are mutable. A new key-value pair can be added, and an existing value can be updated using its key.

student = {
    "name": "Arun",
    "age": 22
}

student["course"] = "Python"
student["age"] = 23

print(student)

Common Dictionary Methods

Nested Data Structures

Python data structures can contain other data structures. This is useful when representing real-world data.

students = [
    {
        "name": "Arun",
        "age": 22,
        "course": "Python"
    },
    {
        "name": "Priya",
        "age": 21,
        "course": "Java"
    }
]

print(students[0]["name"])
print(students[1]["course"])

              Arun
              Java

This type of structure is commonly encountered when working with JSON data, APIs and database records.

List of Lists

A list can also contain other lists. This is useful for representing table-like or matrix-style data.

marks = [
    [80, 75, 90],
    [70, 85, 88],
    [90, 92, 95]
]

print(marks[0][1])

Mutable vs Immutable

One of the most important concepts when working with Python data structures is mutability.

A mutable object can be changed after it is created. An immutable object cannot normally be changed after creation.

Which Data Structure Should You Use?

Common Mistakes

Object-Oriented Programming, commonly called OOP, is a programming approach where data and the operations performed on that data are organized into objects.

Instead of writing an entire program as a collection of unrelated functions, OOP allows us to model real-world entities such as students, employees, customers, products and vehicles as objects.

Python supports several important OOP concepts including classes, objects, attributes, methods, constructors, inheritance and polymorphism.

Classes and Objects

A class defines the properties and behaviors that its objects will have. It acts like a blueprint for creating objects.

An object is an actual instance of a class. Multiple objects can be created from the same class, and each object can contain different data.

class Student:

  def greet(self):
      print("Hello Student")


student1 = Student()

student1.greet()

Here, Student is the class and student1 is an object created from that class. The greet() method defines a behavior that the object can perform.

Understanding self

The self parameter refers to the current object. It allows methods inside a class to access the attributes and other methods belonging to that particular object.

class Student:

  def greet(self):
      print("Hello", self)


student1 = Student()
student2 = Student()

student1.greet()
student2.greet()

When student1.greet() is called, self refers to student1. When student2.greet() is called, self refers to student2.

Attributes and Methods

An object generally contains two important types of information: attributes and methods.

Constructor: __init__()

The __init__() method is commonly used to initialize the attributes of an object when it is created.

It is automatically called when a new object is created from the class. This allows each object to start with its own initial data.

class Student:

  def __init__(self, name, age):
      self.name = name
      self.age = age


student = Student("Arun", 22)

print(student.name)
print(student.age)

Arun
              22

In this example, name and age are attributes of the object. The values "Arun" and 22 are passed when the object is created.

Creating Multiple Objects

A single class can be used to create multiple objects. Each object can contain different attribute values.

class Student:

  def __init__(self, name, age):
      self.name = name
      self.age = age


student1 = Student("Arun", 22)
student2 = Student("Priya", 21)

print(student1.name)
print(student2.name)

              Arun
              Priya

Both objects belong to the same Student class, but they contain different data.

Inheritance

Inheritance allows one class to acquire properties and methods from another class.

The existing class is called the parent class or base class. The class that inherits from it is called the child class or derived class.

Inheritance is useful when different classes share common functionality. Instead of writing the same code repeatedly, the common functionality can be placed in a parent class.

class Animal:

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


class Dog(Animal):

  def bark(self):
      print("Dog barks")


dog = Dog()

dog.speak()
dog.bark()

              Animal makes a sound
              Dog barks

Dog inherits from Animal. Therefore, the Dog object can use the speak() method inherited from Animal, in addition to its own bark() method.

Common Types of Inheritance

Python supports different inheritance relationships depending on how classes are connected.

Method Overriding

Method overriding occurs when a child class provides its own implementation of a method that already exists in the parent class.

This allows the child class to change or specialize the behavior inherited from the parent.

class Animal:

  def sound(self):
      print("Animal sound")


class Dog(Animal):

  def sound(self):
      print("Bark")


dog = Dog()

dog.sound()

Although Animal contains a sound() method, Dog provides its own version. Therefore, when dog.sound() is called, the implementation in Dog is executed.

Using super()

The super() function can be used to access methods or functionality from the parent class.

class Animal:

  def sound(self):
      print("Animal sound")


class Dog(Animal):

  def sound(self):
      super().sound()
      print("Bark")


dog = Dog()

dog.sound()

              Animal sound
              Bark

Here, super().sound() calls the parent class implementation before the child class adds its own behavior.

Polymorphism

Polymorphism means "many forms". In OOP, it allows the same method or operation to produce different behavior depending on the object that is using it.

This is useful when different classes provide the same method name but implement that method differently.

class Dog:

  def sound(self):
      print("Bark")


class Cat:

  def sound(self):
      print("Meow")


animals = [Dog(), Cat()]

for animal in animals:
  animal.sound()

Bark
Meow

The loop does not need to know whether the object is a Dog or a Cat. It simply calls sound(). Python automatically uses the implementation belonging to the current object.

Encapsulation

Encapsulation means keeping data and the methods that operate on that data together inside a class. It also helps control how an object's internal data is accessed or modified.

Python uses naming conventions such as a single underscore (_name) and double underscore (__name) to indicate protected or private-like attributes.

class BankAccount:

  def __init__(self, balance):
      self.__balance = balance

  def show_balance(self):
      print(self.__balance)


account = BankAccount(5000)

account.show_balance()

The double underscore makes __balance name-mangled by Python, which helps prevent direct accidental access from outside the class.

Abstraction

Abstraction means exposing only the necessary details while hiding unnecessary implementation details.

For example, when using a car, a driver uses the steering wheel, accelerator and brakes without needing to understand every internal operation of the engine.

Python provides the abc module for creating abstract classes and abstract methods.

from abc import ABC, abstractmethod              

class Animal(ABC):

    @abstractmethod
    def sound(self):
        pass


class Dog(Animal):

    def sound(self):
        print("Bark")


dog = Dog()

dog.sound()

Four Major Principles of OOP

An exception is an event that occurs while a program is running and interrupts the normal flow of execution. Exceptions commonly occur when a program receives invalid input, performs an invalid operation, or tries to access something that does not exist.

For example, dividing a number by zero, converting invalid text into an integer, or opening a file that does not exist can cause exceptions.

Python provides try, except, else, finally and raise to handle and control exceptions.

Errors and Exceptions

During Python programming, you may encounter different types of problems. Some problems occur before the program can execute, while others occur during execution.

Exception handling mainly deals with problems that occur while the program is running.

Basic try-except

The try block contains code that may produce an exception. If an exception occurs, Python stops executing the remaining statements inside the try block and looks for a matching except block.

try:
  number = int(input("Enter a number: "))

  print(10 / number)

except ZeroDivisionError:
  print("Cannot divide by zero")

  Enter a number: 0
Cannot divide by zero

If the user enters 0, Python raises a ZeroDivisionError. The except block catches that exception and displays a meaningful message instead of allowing the program to terminate with an unhandled exception.

How try-except Works

Common Python Exceptions

Python provides many built-in exception types. Each exception represents a particular type of runtime problem.

Handling Multiple Exceptions

A single block of code may produce different types of exceptions. Python allows multiple except blocks so that each exception can be handled appropriately.

try:
  number = int(input("Enter a number: "))

  result = 10 / number

  print(result)

except ValueError:
  print("Please enter a valid number")

except ZeroDivisionError:
  print("Number cannot be zero")

Using separate except blocks makes it possible to provide a different response for each type of problem.

Accessing the Exception Message

The as keyword can be used to store the exception object in a variable. This allows the program to inspect or display information about the error.

try:
  number = int("abc")

except ValueError as error:
  print("Error:", error)

This technique is useful when you need more information about the exception while debugging or logging an application.

else and finally

Python also provides else and finally blocks to give more control over exception handling.

• else executes only when no exception occurs.
• finally executes whether an exception occurs or not.

try:
  number = int(input("Enter number: "))

except ValueError:
  print("Invalid input")

else:
  print("You entered:", number)

finally:
  print("Program completed")

Enter number: 25
You entered: 25
Program completed

Understanding the Execution Flow

Why Use finally?

The finally block is useful when some operation must be performed regardless of the result. For example, a program may need to close a file, release a resource, or disconnect from a service.

try:
  print("Processing data")

except Exception:
  print("Something went wrong")

finally:
  print("Cleanup completed")

Raising an Exception

Normally, Python raises exceptions when it detects a problem during execution. However, sometimes the programmer needs to deliberately generate an exception when a specific condition is not acceptable.

The raise statement is used to explicitly raise an exception.

age = -5

if age < 0:
    raise ValueError("Age cannot be negative")

ValueError: Age cannot be negative

This is useful when a program has a business rule or validation rule. For example, an application may reject a negative age, an invalid salary, or an empty username.

Using raise with try-except

An exception raised using raise can also be handled using try-except.

try:
  age = -5

  if age < 0:
      raise ValueError("Age cannot be negative")

except ValueError as error:
  print(error)

Custom Exceptions

Python also allows developers to create their own exception classes. Custom exceptions are useful when an application contains specific business rules that are not clearly represented by Python's built-in exceptions.

class InvalidAgeError(Exception):
    pass


age = -2

if age < 0:
    raise InvalidAgeError("Age cannot be negative")

Here, InvalidAgeError is a custom exception created by inheriting from Python's built-in Exception class.

Catching a General Exception

A general except Exception can catch many common runtime exceptions. However, specific exceptions are usually preferred because they make the program easier to understand and debug.

try:
    result = 10 / 0

except Exception as error:
    print("An error occurred:", error)

Exception Handling Best Practices

File handling is used when a Python program needs to store or retrieve information from files. Unlike variables, which hold data temporarily while a program is running, files allow information to be stored permanently on a storage device.

For example, a program can use files to store student records, employee information, application logs, configuration data, reports and other information.

Python provides the built-in open() function for opening files. After opening a file, we can read from it, write to it, append data to it, and finally close it.

Basic File Handling Process

Working with a file generally involves a few important steps:

Opening a File

Python uses the open() function to open a file. The function returns a file object that can be used to perform operations on the file.

file = open("message.txt", "r")

Here, message.txt is the file name and "r" specifies that the file should be opened in read mode.

File Modes

The second argument of open() determines what operation Python should perform on the file.

Writing to a File

The write() method is used to store text inside a file. When a file is opened using w mode, Python creates the file if it does not already exist.

file = open("message.txt", "w")

file.write("Welcome to Python")

file.close()

After executing this program, a file named message.txt will contain:

Writing Multiple Lines

Multiple lines can be written by including newline characters (\n) between the lines.

file = open("students.txt", "w")

file.write("Arun\n")
file.write("Priya\n")
file.write("Kumar\n")

file.close()

The \n character moves the next text to a new line.

Arun
Priya
Kumar

Reading a File

The read() method reads the contents of a file. The file must normally be opened in r mode for reading.

file = open("message.txt", "r")

content = file.read()

print(content)

file.close()

Different Ways to Read a File

Python provides several methods for reading file contents. The method you choose depends on how much data you need to process at a time.

Appending Data to a File

The a mode is used when you want to add new content without removing the existing content.

file = open("students.txt", "a")

file.write("Meena\n")

file.close()

If the file already contains:

Arun
Priya
Kumar

After appending Meena, the file becomes:

Arun
Priya
Kumar
Meena
                  

File Paths

Python can work with files located in the same folder as the Python program or in another directory.

When only the file name is provided, Python looks for the file relative to the program's current working directory.

with open("data.txt", "r") as file:
                  content = file.read()

You can also specify a path to a file located inside another folder.

with open("data/students.txt", "r") as file:
                  content = file.read()

Text Files and Binary Files

Python can work with both text files and binary files.

Binary mode is useful when the file contains data that should not be interpreted as ordinary text.

File Handling Best Practices

Decorators are used to modify or extend the behavior of an existing function without changing its original implementation. They are commonly used when the same additional functionality needs to be applied to multiple functions.

Python treats functions as objects, which means a function can be passed as an argument to another function and can also be returned from a function. Decorators use this feature to wrap an existing function with additional behavior.

Basic Structure of a Decorator

A decorator normally contains another function inside it. The inner function is responsible for adding the extra behavior and then calling the original function.

def decorator_function(original_function):

  def wrapper():
      # Additional behavior
      original_function()

  return wrapper
                  

Here, original_function represents the function that we want to modify, while wrapper() contains the additional behavior.

Creating a Simple Decorator

Consider a situation where several functions need to display a welcome message before they execute. Instead of repeating the same statement in every function, we can place it inside a decorator.

def welcome(func):

  def wrapper():
      print("Welcome")
      func()

  return wrapper


def message():
  print("Python Tutorial")


message = welcome(message)

message()
                  

The welcome() function receives message as an argument. It creates a wrapper function that prints Welcome and then calls the original message() function.

Using the @ Decorator Syntax

Python provides a shorter syntax for applying a decorator. Instead of assigning the decorated function manually, we can place the decorator name above the function using the @ symbol.

def welcome(func):

  def wrapper():
      print("Welcome")
      func()

  return wrapper


@welcome
def message():
  print("Python Tutorial")


message()
                  

The statement @welcome tells Python to apply the welcome decorator to the message() function. Internally, Python performs the equivalent of:

message = welcome(message)

Decorator with Function Arguments

Decorators can also be used with functions that accept arguments. In this case, the wrapper should accept the required arguments and pass them to the original function.

def display(func):

  def wrapper(name):
      print("Student Information")
      func(name)

  return wrapper


@display
def student(name):
  print("Student:", name)


student("Arun")
                  

Practical Uses of Decorators

Decorators are widely used in Python applications and frameworks because they allow common functionality to be added without repeating code.

Decorator Best Practices

Iterators and generators are used in Python to process values one at a time. They are especially useful when working with collections, sequences and large amounts of data.

An iterator keeps track of its current position and provides the next value when requested. A generator is a simple way to create an iterator using the yield keyword.

What Is an Iterable?

An iterable is an object whose elements can be accessed one at a time. Python provides many built-in iterable objects such as lists, tuples, strings, sets and dictionaries.

A for loop can be used to automatically iterate through the values of an iterable.

numbers = [10, 20, 30]

for number in numbers:
    print(number)
                  

The list numbers is an iterable because Python can access each of its elements one by one.

Iterator

An iterator is an object that keeps track of its current position while going through a collection. The iter() function can be used to create an iterator from an iterable.

numbers = [10, 20, 30]

iterator = iter(numbers)

print(next(iterator))
print(next(iterator))
print(next(iterator))
                  

The next() function requests the next value from the iterator. Each time it is called, the iterator moves to the next element.

Using an Iterator with a for Loop

Although next() can be used manually, Python's for loop automatically handles the iteration process.

numbers = [10, 20, 30]

iterator = iter(numbers)

for number in iterator:
    print(number)
                  

Generator

A generator is a special type of iterator that produces values one at a time. Generators are created using a function containing the yield keyword.

Unlike return, which ends a function completely, yield pauses the function and remembers its current state. When the next value is requested, the function continues from where it stopped.

def numbers():
  yield 1
  yield 2
  yield 3


for number in numbers():
  print(number)
                  

Using next() with a Generator

Since a generator is an iterator, we can also use next() to request each value individually.

def numbers():
  yield 10
  yield 20
  yield 30


values = numbers()

print(next(values))
print(next(values))
print(next(values))
                  

yield vs return

Both yield and return can produce a value from a function, but they behave differently.

Generator Expression

Python also provides generator expressions, which have a syntax similar to list comprehensions. The main difference is that a generator expression produces values one at a time instead of creating the complete list immediately.

numbers = (number * number for number in range(1, 6))

for number in numbers:
print(number)
                  

Why Use Generators?

Generators are useful when a program needs to process a large amount of data. Instead of creating and storing every value at once, a generator produces each value only when it is needed.

Iterable vs Iterator vs Generator

Generator & Iterator Best Practices

A virtual environment is an isolated environment used to install Python packages for a specific project. It helps prevent package conflicts between different Python projects.

For example, one project may require a particular version of a library, while another project may require a different version. Virtual environments allow both projects to maintain their own packages.

Creating a Virtual Environment

Python provides the venv module to create a virtual environment.

python -m venv myenv

Here, myenv is the name of the virtual environment. You can choose a different name if required.

Activating on Windows

After creating the environment, activate it using the following command:

myenv\Scripts\activate

Once activated, packages installed using pip will be installed inside this virtual environment.

Activating on Linux / macOS

source myenv/bin/activate

Installing a Package

After activating the environment, you can install packages using pip.

pip install requests

The requests package will be installed in the active virtual environment rather than globally.

Saving Project Dependencies

The installed packages can be saved in a requirements.txt file. This makes it easier to recreate the same environment on another computer.

pip freeze > requirements.txt

Another developer can install all the packages listed in the file using:

pip install -r requirements.txt

Deactivating the Environment

When you finish working on the project, you can leave the virtual environment using the deactivate command.

deactivate

Basic Virtual Environment Workflow