Python Beginner Guide

Python is a readable, beginner-friendly programming language used for web development, data analysis, automation, AI, and many other areas. In this lesson, you will create your first .py file, run it, and learn why indentation matters in Python.

# My first program
print("Hello Python")
print("I am learning on DocoDive")

print("Sufyan")
print("Karachi")
print(19)

A variable is a named container that stores a value. In Python you assign with '='. Common data types are int (whole numbers), float (decimals), str (text), bool (True/False), and None (empty).

name = "Sufyan"
age = 19
height = 5.9
is_student = True
nothing = None
print(name, type(name))
print(age, type(age))

city = "Karachi"
age = 19
height = 5.9
print(city, age, height)

Operators work on values: arithmetic (+, -, *, /, //, %), comparison (==, !=, >, <, >=, <=), and logical (and, or, not). These are the foundation for calculations and conditions.

price = 500
quantity = 3
total = price * quantity
print(total)
print(total > 1000)
print(quantity >= 3 and price > 100)

print(10 % 3)
print(10 // 3)

Strings are sequences of characters. Indexing starts at 0, and slicing returns a range. Methods like lower(), upper(), strip(), replace(), split(), and join() transform text. f-strings are the modern way to format strings.

text = "  Hello DocoDive  "
clean = text.strip().upper()
print(clean)
name = "Sufyan"
print(f"Welcome, {name}!")

name = "Sufyan"
print(name.upper())
print(len(name))

input() always returns a string, even when the user types a number. To do math you must convert with int() or float(). A wrong conversion raises ValueError, so basic validation matters.

age_text = input("Age: ")
age = int(age_text)
print("Next year:", age + 1)

a = int(input("First: "))
b = int(input("Second: "))
print(a + b)

Conditions let a program make decisions. if checks the first condition, elif checks more, and else is the fallback. Indentation tells Python which block each line belongs to.

score = 85
if score >= 90:
    print("A")
elif score >= 75:
    print("B")
else:
    print("C")

age = 19
print("Adult" if age >= 18 else "Minor")

Loops repeat code. A for loop iterates over a sequence, and a while loop runs until its condition is false. range() generates numbers. break exits a loop, continue skips to the next iteration.

for i in range(3):
    print(i)

n = 0
while n < 3:
    n += 1
    if n == 2:
        continue
    print(n)

for n in range(1, 11, 2):
    print(n)

A list is an ordered, mutable collection. Indexing starts at 0, and negative indices count from the end. append() adds an item, pop() removes one, and sort() arranges the list.

fruits = ["mango", "apple", "banana"]
fruits.append("grape")
fruits.sort()
print(fruits)
print(fruits[0], fruits[-1])

evens = []
for n in range(3, 16):
    if n % 2 == 0:
        evens.append(n)
print(evens)

A tuple is an immutable ordered collection, a set stores unique unordered values, and a dictionary maps keys to values. Fixed data -> tuple, unique items -> set, mapping -> dict.

point = (10, 20)
skills = {"Python", "HTML", "CSS"}
student = {"name": "Sufyan", "age": 19}
print(point[0])
print(skills)
print(student["name"])

s = {"name": "Sufyan", "score": 95}
print(s["score"])

A function is a reusable block defined with def. Parameters are inputs and return sends a value back. Default arguments preset values, and keyword arguments make calls clearer.

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Sufyan"))
print(greet("Sufyan", greeting="Hi"))

def add(a, b):
    return a + b
print(add(3, 7))

*args accepts arbitrary positional arguments, and **kwargs accepts arbitrary keyword arguments. A lambda is a one-line anonymous function. map and filter transform collections, zip iterates in parallel, and enumerate adds an index.

nums = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, nums))
evens = list(filter(lambda x: x % 2 == 0, nums))
print(squared)
print(evens)

names = ["A", "B"]
ages = [19, 20]
print(list(zip(names, ages)))

Comprehensions build collections in one clean line. A list comprehension is [expr for item in iterable if condition], and a dict comprehension is {key: value for ...}.

nums = [1, 2, 3, 4]
squares = [n**2 for n in nums]
even_squares = {n: n**2 for n in nums if n % 2 == 0}
print(squares)
print(even_squares)

names = ["Ali", "Sufyan"]
print({n: len(n) for n in names})

Files are central to real programs. with open() automatically closes the file. Modes: r read, w write, a append. JSON stores structured data, and pathlib makes paths clean and safe.

from pathlib import Path
import json

data = {"name": "Sufyan", "age": 19}
Path("data.json").write_text(json.dumps(data))
print(Path("data.json").read_text())

with open('notes.txt', 'w') as f:
    f.write('Sufyan')
with open('notes.txt') as f:
    print(f.read())

Syntax errors happen while writing code; runtime errors happen while it runs. try runs risky code, except catches errors, else runs on success, and finally always runs. raise lets you fail deliberately.

try:
    num = int(input("Number: "))
    print(10 / num)
except ValueError:
    print("Invalid number")
except ZeroDivisionError:
    print("Cannot divide by zero")
else:
    print("Success")

def safe_div(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return None
print(safe_div(10, 0))

A module is a .py file you can import. A package is a folder of modules. import math brings in the whole module; from math import sqrt brings one name. The __name__ == '__main__' guard runs code only on direct execution.

import math
print(math.sqrt(16))

if __name__ == "__main__":
    print("Direct run")

import math
print(math.sqrt(25))
print(math.pi)

Python's standard library is huge. Beginners should know representative modules: math for calculations, random for randomness, datetime for dates, pathlib for files, json for data, and collections for useful containers.

import random
import datetime
from collections import Counter

print(random.randint(1, 10))
print(datetime.date.today())
print(Counter(["a", "b", "a", "c"]))

import random
import string
chars = string.ascii_letters + string.digits
print(''.join(random.choices(chars, k=10)))

OOP organizes code into objects. A class is a blueprint and an object is an instance of it. __init__ is the constructor that initializes the object. self refers to the instance, and methods are functions inside the class.

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

    def greet(self):
        return f"Hi, I am {self.name}"

s = Student("Sufyan", 19)
print(s.greet())

class Car:
    def __init__(self, brand, speed):
        self.brand = brand
        self.speed = speed
    def show(self):
        print(self.brand, self.speed)
Car("Toyota", 120).show()

Errors are inevitable — learn to read a traceback. print debugging is simple and effective; pdb is the interactive debugger. For clean code, use meaningful names, small functions, and comments only when needed.

def divide(a, b):
    breakpoint()  # pauses execution here
    return a / b

print(divide(10, 2))

def safe_int(value):
    try:
        return int(value)
    except ValueError:
        print(f"'{value}' is not a number")
        return None
safe_int("abc")

Real projects use isolated environments. python -m venv creates one, python -m pip installs packages, and requirements.txt freezes dependencies. Project folders and .gitignore keep things organized.

# Create a virtual environment
python -m venv .venv

# Activate (Windows PowerShell)
.venv\Scripts\Activate.ps1

# Activate (macOS / Linux)
source .venv/bin/activate

# Install a package
python -m pip install requests

# Save dependencies
python -m pip freeze > requirements.txt

python -m venv .venv

This final project combines variables, loops, conditions, functions, lists, dictionaries, files, JSON, exceptions, and OOP. You will build a CLI system that can add, view, search, update, delete, and save students to JSON.

import json
from pathlib import Path

class StudentManager:
    def __init__(self, path="students.json"):
        self.path = Path(path)
        self.students = json.loads(self.path.read_text()) if self.path.exists() else []

    def add(self, name, age):
        self.students.append({"name": name, "age": age})
        self.save()

    def save(self):
        self.path.write_text(json.dumps(self.students, indent=2))

sm = StudentManager()
sm.add("Sufyan", 19)
print(sm.students)

def view(self):
    for s in self.students:
        print(s)
def delete(self, name):
    self.students = [s for s in self.students if s["name"] != name]
    self.save()