Learn Python in 30 Days

Python is one of the most versatile and in-demand programming languages in the world. Created by Guido van Rossum and first released on February 20, 1991, Python has grown from a hobby project to the #1 programming language on the TIOBE Index as of 2024 . With over 18.2 million active developers worldwide and demand for Python skills growing 153% year-over-year in the U.S. tech sector , there has never been a better time to learn Python.

This 30-day curriculum is designed to take you from zero programming experience to building real-world Python applications. Each week is structured around a coherent theme, gradually building your skills from fundamentals to professional-grade development. The key to success is consistent daily practice — even 1–2 hours per day compounds into significant expertise over 30 days .

Python's readability makes it an ideal first language. Its syntax closely resembles natural English, and its dynamic typing system means you spend less time fighting the compiler and more time solving problems. Whether your goal is data science, web development, automation, or AI, Python provides the foundation.

Footnotes

1. 30 Days of Python — GitHub - A comprehensive step-by-step guide to learn Python in 30 days with exercises. ↩

2. 46 Python Statistics for 2026: Usage, Jobs & AI Trends — Pynions - Comprehensive data on Python developer jobs, salaries, and AI trends. ↩

3. Can I learn Python in 30 days? — Reddit r/learnpython - Community discussion on realistic expectations for 30-day Python learning. ↩

Week 1: Python Fundamentals (Days 1–7)

The first week builds your foundational vocabulary and muscle memory with Python. You will learn how to set up a development environment, write your first programs, and understand core syntax.

Day 1–2: Setup & Variables

Install Python 3.12+ from python.org and configure VS Code with the Python extension. Create your first .py file and write:

1# Your first Python program
2name = input("What is your name? ")
3age = int(input("How old are you? "))
4print(f"Hello, {name}! You were born in approximately {2025 - age}.")

Python's core data types include int (integers), float (decimal numbers), str (strings), and bool (booleans). Python is dynamically typed, so you don't declare types explicitly:

1x = 42          # int
2y = 3.14        # float
3z = "Python"    # str
4flag = True     # bool

Day 3: Operators & Expressions

Python supports arithmetic (+, -, *, /, //, %, **), comparison (==, !=, <, >, <=, >=), logical (and, or, not), and assignment (=, +=, -=) operators. Operator precedence follows standard math conventions: ** > * / // % > + - > comparisons > logical.

Day 4–5: Strings & Conditionals

Strings are immutable sequences with powerful methods:

1text = "Hello, Python!"
2print(text.upper())        # "HELLO, PYTHON!"
3print(text.split(", "))     # ["Hello", "Python!"]
4print(text.replace("Hello", "Hi"))  # "Hi, Python!"
5print(f"{text} Length = {len(text)}")  # f-string formatting

Conditionals control program flow:

1score = 85
2if score >= 90:
3    grade = "A"
4elif score >= 80:
5    grade = "B"
6elif score >= 70:
7    grade = "C"
8else:
9    grade = "F"

Day 6–7: Loops

Python provides for loops (iterating over sequences) and while loops (repeating while a condition is true):

1# For loop with range
2for i in range(1, 11):
3    print(f"{i} squared = {i**2}")
4
5# While loop
6n = 10
7while n > 0:
8    print(n, end=" ")
9    n -= 1
10# Output: 10 9 8 7 6 5 4 3 2 1

Use break to exit a loop early and continue to skip to the next iteration.

Week 2: Data Structures & Functions (Days 8–14)

This week covers Python's powerful built-in collections and how to write reusable functions — the building blocks of every real program.

Lists are ordered, mutable sequences. They are Python's most versatile collection :

1fruits = ["apple", "banana", "cherry"]
2fruits.append("date")
3fruits.insert(1, "blueberry")
4fruits.sort()
5print(fruits)  # ['apple', 'banana', 'blueberry', 'cherry', 'date']

Tuples are ordered, immutable sequences — ideal for fixed collections:

1coordinates = (40.7128, -74.0060)  # NYC lat/long
2print(coordinates[0])  # 40.7128
3# coordinates[0] = 41.0  # TypeError! Tuples can't be modified

Sets are unordered collections of unique elements:

1a = {1, 2, 3, 4}
2b = {3, 4, 5, 6}
3print(a | b)   # Union: {1, 2, 3, 4, 5, 6}
4print(a & b)   # Intersection: {3, 4}
5print(a - b)   # Difference: {1, 2}

Dictionaries store key-value pairs and are one of Python's most powerful data structures:

1student = {"name": "Alice", "age": 22, "gpa": 3.9}
2student["major"] = "Computer Science"
3for key, value in student.items():
4    print(f"{key}: {value}")

Functions encapsulate reusable logic. Python functions use def and support default arguments, *args, **kwargs, and return values:

1def greet(name, greeting="Hello"):
2    return f"{greeting}, {name}!"
3
4print(greet("Alice"))            # "Hello, Alice!"
5print(greet("Bob", "Welcome"))   # "Welcome, Bob!"

Understanding scope is critical. Variables defined inside a function are local by default:

1x = 10  # Global
2
3def modify():
4    x = 5  # Local variable (shadows global)
5    print(f"Inside: x = {x}")
6
7modify()         # Inside: x = 5
8print(f"Outside: x = {x}")  # Outside: x = 10

Footnotes

1. 30 Days of Python — GitHub - A comprehensive step-by-step guide to learn Python in 30 days with exercises. ↩

Week 3: OOP & Advanced Python (Days 15–21)

Object-Oriented Programming is the dominant programming paradigm in modern software development . Python's OOP system is elegant and powerful.

Classes & Objects:

1class BankAccount:
2    def __init__(self, owner, balance=0):
3        self.owner = owner
4        self.__balance = balance  # private by convention
5
6    def deposit(self, amount):
7        if amount > 0:
8            self.__balance += amount
9            return True
10        return False
11
12    def withdraw(self, amount):
13        if 0 < amount <= self.__balance:
14            self.__balance -= amount
15            return amount
16        return 0
17
18    @property
19    def balance(self):
20        return self.__balance
21
22account = BankAccount("Alice", 1000)
23account.deposit(500)
24print(account.balance)  # 1500

Inheritance lets you create specialized classes from general ones:

1class SavingsAccount(BankAccount):
2    def __init__(self, owner, balance=0, interest_rate=0.02):
3        super().__init__(owner, balance)
4        self.interest_rate = interest_rate
5
6    def add_interest(self):
7        interest = self.balance * self.interest_rate
8        self.deposit(interest)

List Comprehensions provide a concise way to create lists:

1# Traditional approach
2squares = []
3for x in range(10):
4    squares.append(x ** 2)
5
6# List comprehension — same result, one line
7squares = [x ** 2 for x in range(10)]
8
9# With condition
10even_squares = [x ** 2 for x in range(10) if x % 2 == 0]
11# [0, 4, 16, 36, 64]

Exception Handling makes your programs robust:

1def safe_divide(a, b):
2    try:
3        result = a / b
4    except ZeroDivisionError:
5        print("Cannot divide by zero!")
6        return None
7    except TypeError:
8        print("Both arguments must be numbers!")
9        return None
10    else:
11        print(f"Result: {result}")
12        return result
13    finally:
14        print("Division attempt complete.")

File I/O lets you persist data permanently:

1# Writing to a file
2with open("data.txt", "w") as f:
3    f.write("Hello, file I/O!\n")
4    f.write("Second line.\n")
5
6# Reading a file
7with open("data.txt", "r") as f:
8    content = f.read()
9    print(content)
10
11# Working with JSON
12import json
13data = {"name": "Alice", "scores": [95, 87, 92]}
14with open("data.json", "w") as f:
15    json.dump(data, f, indent=2)

Footnotes

1. Object-Oriented Programming in Python — Real Python - In-depth guide to OOP concepts, classes, inheritance, and polymorphism in Python. ↩

Week 4: Specialization & Real-World Python (Days 22–30)

The final week transitions you from learning syntax to building real applications and preparing for a career. Python's standard library is vast, and its third-party ecosystem is one of the largest in any programming language.

Packages & Pip: Python's package manager pip gives you access to over 500,000 packages on PyPI. Always use a virtual environment to manage dependencies:

1# Create and activate virtual environment
2python -m venv myproject_env
3source myproject_env/bin/activate  # Mac/Linux
4
5# Install packages
6pip install requests flask pandas numpy matplotlib
7
8# Freeze dependencies for reproducibility
9pip freeze > requirements.txt

Working with APIs is essential for modern Python development:

1import requests
2
3response = requests.get("https://api.github.com/users/python")
4data = response.json()
5print(f"Followers: {data['followers']}")
6print(f"Public repos: {data['public_repos']}")

Web Scraping with BeautifulSoup lets you extract data from websites:

1from bs4 import BeautifulSoup
2import requests
3
4page = requests.get("https://example.com")
5soup = BeautifulSoup(page.content, "html.parser")
6titles = soup.find_all("h2", class_="title")
7for title in titles:
8    print(title.text.strip())

The time complexity of key Python operations is essential knowledge for writing efficient code:

Choosing the right data structure can reduce algorithmic complexity from $O(n^2)$ to $O(n)$ — a dramatic difference on large datasets.