What Topics Are Covered in the First 10 Days of 30 Days of Python?

The first 10 days of the 30 Days of Python curriculum cover Python installation, variables, operators, strings, lists, tuples, sets, dictionaries, conditionals, and loops.

The Asabeneh/30-Days-Of-Python repository structures its learning path as a series of day-specific folders that progressively build a solid foundation. The first 10 days introduce the essential building blocks of Python programming, from writing your first script to mastering control flow and core data structures.

Day 1: Introduction to Python

Day 1 focuses on environment setup and basic syntax. Located in 01_Day_Introduction/, this day covers installing Python, writing your first script, using the print() function, and adding comments.

The helloworld.py file demonstrates the simplest Python program:

# Day 1 – Hello World

print("Hello, World!")

Day 2: Variables and Built-in Functions

Day 2 introduces data storage and Python's built-in utilities. The 02_Day_Variables_builtin_functions/ folder contains variables.py, which demonstrates declaring variables, data types (int, float, str, bool), and type conversion.

Key functions covered include type(), len(), str(), int(), and float():

# Day 2 – Variable types and conversion

age = 30                     # int

height = 5.9                 # float

name = "Alice"               # str

print(type(age), type(height), type(name))
age_str = str(age)           # conversion to string

Day 3: Operators in Python

Day 3 covers all operator categories in 03_Day_Operators/day-3.py. This includes arithmetic (+, -, *, /, **, %), assignment (=, +=), comparison (==, !=, <, >, <=, >=), logical (and, or, not), bitwise, membership (in, not in), and identity operators (is, is not).

# Day 3 – Operator usage

a, b = 10, 3
print(a + b, a ** b, a // b, a % b)   # arithmetic

print(a > b and b < 5)               # logical

Day 4: String Manipulation

Day 4 focuses on text processing in 04_Day_Strings/day_4.py. Topics include string literals, escaping, concatenation, formatting using f-strings and format(), slicing, and methods like upper(), lower(), replace(), split(), and join().

# Day 4 – String formatting

first = "John"
last = "Doe"
full = f"{first} {last}"
print(full.upper())

Day 5: Working with Lists

Day 5 introduces Python's primary sequence type in 05_Day_Lists/day_5.py. The curriculum covers list creation, indexing, slicing, mutability, and methods including append(), extend(), insert(), remove(), pop(), clear(), sort(), and reverse(), plus basic list comprehension concepts.

# Day 5 – List manipulation

fruits = ["apple", "banana"]
fruits.append("cherry")
print(fruits[1:])      # slicing

Day 6: Understanding Tuples

Day 6 covers immutable sequences in 06_Day_Tuples/06_tuples.md. Key concepts include tuple syntax, immutability guarantees, tuple packing and unpacking, using tuples as records, and conversion between lists and tuples.

# Day 6 – Tuple unpacking

person = ("Bob", 25, "Engineer")
name, age, job = person
print(name, age, job)

Day 7: Set Operations

Day 7 explores unordered collections in 07_Day_Sets/07_sets.md. Topics include set creation, the uniqueness property, and mathematical operations: union(), intersection(), difference(), and symmetric_difference(), plus set comprehension syntax.

# Day 7 – Set operations

evens = {2, 4, 6}
odds = {1, 3, 5}
primes = {2, 3, 5, 7}
print(evens.union(odds))               # {1,2,3,4,5,6}

print(primes.intersection(evens))      # {2}

Day 8: Dictionary Fundamentals

Day 8 introduces key-value mapping in 08_Day_Dictionaries/08_dictionaries.md. The curriculum covers dictionary literals, key/value access, methods including get(), keys(), values(), items(), pop(), and update(), plus nesting and iteration patterns.

# Day 8 – Dictionary access

student = {"name": "Emma", "grade": 88}
print(student["name"])
student["grade"] = 92               # update

Day 9: Conditional Statements

Day 9 covers decision-making logic in 09_Day_Conditionals/09_conditionals.md. Topics include if, elif, and else statements, truthy/falsy value evaluation, ternary conditional expressions, and nested conditional structures.

# Day 9 – Conditional logic

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

Day 10: Loops and Iteration

Day 10 completes the foundation with iteration constructs in 10_Day_Loops/10_loops.md. The material covers for loops (iterating over sequences, using range() and enumerate()), while loops, control statements (break, continue), the loop-else clause, and basic pattern-matching with loops.

# Day 10 – Looping with enumerate

colors = ["red", "green", "blue"]
for idx, col in enumerate(colors, start=1):
    print(idx, col)

Summary

The first 10 days of 30 Days of Python establish a comprehensive foundation for Python programming:

• Environment and Syntax: Day 1 covers installation and basic print() usage, while Day 2 introduces variables and type systems.
• Operations and Data Types: Days 3-8 progress through operators, strings, lists, tuples, sets, and dictionaries, covering Python's core data structures.
• Control Flow: Days 9-10 complete the foundation with conditionals and loops, enabling dynamic program execution.

Mastery of these topics prepares learners for advanced subjects like functions, modules, file I/O, and object-oriented programming covered in subsequent days of the curriculum.

Frequently Asked Questions

What prerequisites are needed before starting the first 10 days of 30 Days of Python?

No prior programming experience is required. Day 1 begins with Python installation and writing your first script in 01_Day_Introduction/helloworld.py. Basic computer literacy and a text editor are sufficient to begin the curriculum.

How long does it take to complete the first 10 days of the 30 Days of Python curriculum?

While the curriculum suggests one day per topic, the first 10 days typically require 1-2 weeks for beginners to fully absorb concepts like operators, data structures, and control flow. Each day includes hands-on exercises in files like day_5.py and 10_loops.md that reinforce the material.

Which data structures are covered in the first 10 days of 30 Days of Python?

Days 5 through 8 cover Python's fundamental data structures: lists (Day 5, day_5.py), tuples (Day 6, 06_tuples.md), sets (Day 7, 07_sets.md), and dictionaries (Day 8, 08_dictionaries.md). Day 4 also covers strings, which are immutable sequences of characters.

Are the first 10 days of 30 Days of Python sufficient for writing real programs?

Yes, the first 10 days provide the essential building blocks for practical programming. By Day 10, you will understand variables, data types, operators, conditionals, and loops—enough to write scripts that process data, automate tasks, and implement basic algorithms. However, advanced topics like functions, modules, and error handling appear in later days.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}