Python Tutorial: Learn Python from Basics to Advanced

Python Installation & IDLE Setup

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.

Datatypes, Variables & Operators

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.

Variable Naming Rules

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

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:

Operators

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

Python provides several categories of operators.

Conditional Statements & Loops

Python uses conditional statements to make decisions and loops to repeat tasks. Conditional statements run different blocks of code depending on whether an expression is true or false, while loops repeat a block of code until a condition is no longer satisfied.

if Statement

The if statement executes a block when its condition evaluates to True. Python uses indentation to define the statements that belong to the block.

age = 20

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

if-else Statement

Use else when you need one block to run when the if condition is false. This is useful when a program has two possible outcomes.

number = 7

if number % 2 == 0:
    print("Even")
else:
    print("Odd")

elif Statement

The elif keyword checks another condition when the previous condition is false. You can use multiple elif branches when several outcomes are possible.

marks = 82

if marks >= 90:
    print("A")
elif marks >= 75:
    print("B")
elif marks >= 50:
    print("C")
else:
    print("Fail")

Nested Conditions

A conditional statement can contain another conditional statement. Nested conditions are useful when the second decision depends on the result of the first decision, but they should be kept simple so the program remains readable.

age = 25
has_id = True

if age >= 18:
    if has_id:
        print("Entry allowed")
    else:
        print("ID required")
else:
    print("Entry not allowed")

for Loop

A for loop is commonly used to iterate over items in a sequence such as a list, tuple or string. The loop executes once for each item.

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

for name in names:
    print(name)

while Loop

A while loop repeats its block while a condition remains true. Make sure the condition can eventually become false to avoid an unintended infinite loop.

count = 1

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

break and continue

The break statement stops a loop immediately. 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 == 4:
        break
    print(number)

Using Operators in Conditions

Conditions commonly use comparison operators such as ==, !=, >, <, >= and <=. Logical operators such as and, or and not can combine or reverse conditions.

age = 25
city = "Chennai"

if age >= 18 and city == "Chennai":
    print("Eligible")

When writing conditional logic, keep each condition clear and use indentation consistently. Simple conditions are easier to read, test and maintain than deeply nested decision blocks.

Python Functions

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 greet(name):
  return f"Hello, {name}"

message = greet("Arun")
print(message)

Python Data Structures

Python data structures are used to store and organize multiple values. The main built-in structures are lists, tuples, sets and dictionaries. The right choice depends on whether you need ordered data, modification, unique values or key-value access.

Lists

A list is an ordered and mutable collection. You can store different values, access items by index and change the contents after creating the list.

fruits = ["Apple", "Banana", "Mango"]

print(fruits[0])
fruits.append("Orange")
print(fruits)

Common List Operations

Frequently used list methods include append() for adding an item, remove() for removing a value, pop() for removing an item by position, and sort() for ordering values.

numbers = [3, 1, 4, 2]

numbers.append(5)
numbers.remove(1)
numbers.sort()

print(numbers)

Tuples

A tuple is an ordered collection that is immutable after creation. Tuples are useful when a group of values should remain unchanged.

student = ("Arun", 22, "Chennai")

print(student[0])
print(student[1])

Sets

A set stores unique values and is useful when duplicate items should be removed. Sets also provide operations such as union and intersection.

numbers = {1, 2, 2, 3, 4}

print(numbers)
numbers.add(5)
print(numbers)

Dictionaries

A dictionary stores data as key-value pairs. It is useful when each value needs a meaningful key for access, such as a user's name, age or city.

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

print(student["name"])
student["age"] = 23
print(student)

Nested Data Structures

Python structures can contain other structures. For example, a list can contain dictionaries, which is a common pattern when working with collections of records.

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

for student in students:
    print(student["name"])

OOP Concepts: Classes, Objects, Inheritance & Polymorphism

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.

Exception Handling in Python

Errors and Exceptions

Exception handling lets a Python program respond to runtime problems without stopping unexpectedly. Use try and except to handle errors, with else for successful execution and finally for cleanup.

File Handling in Python

Basic File Handling Process

Python can read and write files using open(). Common modes include r for reading, w for writing and a for appending. Use with to manage files safely and close them automatically.

Decorators in Python

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.

Generators & Iterators

Iterators provide values one at a time, while generators create those values lazily with yield. They are useful when processing large amounts of data without storing everything in memory.

def numbers():
  for i in range(3):
    yield i

for value in numbers():
  print(value)
                  

Virtual Environments

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.

Common Python Mistakes

• Using incorrect indentation: Keep consistent indentation because Python uses indentation to define code blocks.
• Using mutable default arguments: Avoid using mutable objects such as lists or dictionaries as default function arguments.
• Confusing = and ==: Use = for assignment and == for comparing values.
• Ignoring exceptions: Handle expected runtime errors with appropriate try and except blocks.
• Using global variables unnecessarily: Keep data local to functions or appropriate classes instead of making application state global.
• Ignoring input validation: Validate user input and external data before processing it in an application.
• Writing overly complex code: Keep functions focused, use meaningful names, and prefer simple and readable Python code.

A useful development rule is to write readable Python code, keep functions focused, handle errors appropriately, validate external data, and use additional architecture only when the application actually requires it.

Python Learning Roadmap

Learn Python in dependency order rather than treating every topic as an isolated feature.

1. Python fundamentals: syntax, variables, data types, operators, input/output and basic programming concepts.
2. Control flow: if-else statements, for loops, while loops, break, continue and pass.
3. Data structures: strings, lists, tuples, sets, dictionaries and common data operations.
4. Functions: function definitions, parameters, return values, scope, lambda functions and recursion.
5. Object-oriented programming: classes, objects, constructors, inheritance, polymorphism, encapsulation and abstraction.
6. Exception handling: try, except, else, finally and raising custom exceptions.
7. Modules and packages: imports, built-in modules, custom modules, packages and virtual environments.
8. File and data handling: reading and writing files, JSON, CSV and working with external data.
9. Projects: combine Python concepts to build practical applications and database-driven programs.
10. Backend development: learn APIs, databases, web frameworks, authentication, testing and deployment.

What to Learn After Python?

After learning Python fundamentals, useful next skills include advanced Python, databases, API development, testing, authentication, deployment and backend development. Python can be combined with different frameworks and database technologies depending on the application's requirements and the developer's career direction.

After learning Python, you can strengthen your backend development skills by exploring the Python Backend Developer Course in Chennai .

Learners who want to build complete web applications using frontend, backend and database technologies can explore the Full Stack Developer Course in Chennai .

Those interested in combining Python with database development can continue learning through the MySQL Tutorials .