Nerd Level Tech logo
|

The Complete Python Guide: From Basics to Best Practices

September 18, 2025

#Python#Programming#Beginner Guide#Web Development#Data Science
The Complete Python Guide: From Basics to Best Practices

TL;DR

  • Python is a versatile, beginner-friendly language used in web dev, data science, AI, and automation
  • Master the basics: variables, data types, control flow, and functions
  • Learn Pythonic patterns: comprehensions, lambdas, and type hints
  • Understand OOP, exception handling, and file I/O for real-world applications
  • Follow PEP 8 for clean, maintainable code

Welcome to Python! Whether you're a complete novice or brushing up on skills, this guide covers everything from installation to advanced patterns. Python's simplicity and versatility make it one of the most popular programming languages, used in web development, data analysis, artificial intelligence, and automation.

What is Python?

Python is a high-level, interpreted programming language known for clear syntax and readability. Developed by Guido van Rossum in the late 1980s, Python emphasizes code readability, allowing developers to express concepts in fewer lines than languages like C++ or Java.

Why Learn Python?

  • Versatility: Web development, data science, machine learning, automation
  • Simple Syntax: English-like, readable code
  • Strong Community: Vast ecosystem of libraries and frameworks
  • Rich Libraries: NumPy, Pandas, Django, Flask, TensorFlow
  • Future-proof: Python 3 continues active development

Setting Up Python

Installing Python

  1. Download: Visit python.org/downloads and get the latest Python 3.x
  2. Install: Run the installer and check "Add Python to PATH"
  3. Verify: Open terminal and run:
python --version

Choosing an IDE

  • VS Code: Lightweight, extensible, free
  • PyCharm: Feature-rich Python IDE
  • Jupyter Notebook: Great for data science and exploration

Your First Program

Create hello.py:

print("Hello, World!")

Run it:

python hello.py

Congratulations! You've written your first Python program.

Variables and Data Types

Python is dynamically typed — you don't declare variable types explicitly.

Variable Naming

  • Use descriptive names: age, total_price
  • Use snake_case: user_name, not userName
  • Avoid starting with numbers or special characters

Common Data Types

# Integers - whole numbers
age = 25

# Floats - decimal numbers
height = 5.9

# Strings - text
name = "Alice"

# Booleans - True/False
is_active = True

# None - absence of value
result = None

Type Conversion

age_str = str(25)        # "25"
height_int = int(5.9)    # 5
number = float("3.14")   # 3.14

Type Checking with Type Hints

Python 3.5+ supports type hints for better code clarity:

def greet(name: str) -> str:
    return f"Hello, {name}!"

def add(a: int, b: int) -> int:
    return a + b

Control Structures

Conditional Statements

age = 18

if age < 13:
    print("Child")
elif age < 18:
    print("Teenager")
else:
    print("Adult")

For Loops

# Iterate over a range
for i in range(1, 6):
    print(i)

# Iterate over a list
names = ["Alice", "Bob", "Carol"]
for name in names:
    print(f"Hello, {name}!")

While Loops

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

Break and Continue

# Break - exit loop early
for number in range(1, 11):
    if number == 6:
        break
    print(number)  # Prints 1-5

# Continue - skip iteration
for number in range(1, 11):
    if number % 2 == 0:
        continue
    print(number)  # Prints odd numbers only

Functions

Functions are reusable blocks of code that perform specific tasks.

Basic Functions

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # Hello, Alice!

Return Values

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

result = add(3, 5)  # 8

Default Parameters

def greet(name="Guest"):
    print(f"Hello, {name}!")

greet()        # Hello, Guest!
greet("Bob")   # Hello, Bob!

Variable Arguments

# *args - variable positional arguments
def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3, 4, 5))  # 15

# **kwargs - variable keyword arguments
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=30, city="NYC")

Lambda Functions

Small anonymous functions for quick operations:

# Basic lambda
square = lambda x: x ** 2
print(square(4))  # 16

# With filter
numbers = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4, 6]

# With sorted
pairs = [(1, 'one'), (3, 'three'), (2, 'two')]
sorted_pairs = sorted(pairs, key=lambda x: x[1])

Collections

Lists

Ordered, mutable collections:

fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
print(fruits[0])     # apple
print(fruits[-1])    # orange (last item)
fruits[1] = "grape"  # Modify element

Dictionaries

Key-value pairs:

student = {
    "name": "Alice",
    "age": 20,
    "grades": [85, 90, 92]
}

print(student["name"])      # Alice
student["city"] = "NYC"     # Add new key

Tuples

Ordered, immutable collections:

coordinates = (10, 20)
x, y = coordinates  # Unpacking
print(x)  # 10

Sets

Unordered, unique elements:

unique_numbers = {1, 2, 3, 3, 3}
print(unique_numbers)  # {1, 2, 3}
unique_numbers.add(4)

Comprehensions

Pythonic way to create collections concisely.

List Comprehension

# Traditional
squares = []
for x in range(1, 6):
    squares.append(x ** 2)

# Comprehension
squares = [x ** 2 for x in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# With condition
evens = [x for x in range(10) if x % 2 == 0]

Dictionary Comprehension

squares_dict = {x: x ** 2 for x in range(1, 6)}
print(squares_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

Set Comprehension

unique_lengths = {len(word) for word in ["apple", "banana", "cherry"]}

Object-Oriented Programming

Python supports OOP for modeling real-world concepts.

Classes and Objects

class Dog:
    species = "Canis lupus familiaris"  # Class variable

    def __init__(self, name, breed):
        self.name = name    # Instance variable
        self.breed = breed

    def bark(self):
        print(f"{self.name} says woof!")

my_dog = Dog("Buddy", "Golden Retriever")
my_dog.bark()  # Buddy says woof!

Inheritance

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

# Polymorphism
def make_sound(animal):
    animal.speak()

make_sound(Dog())  # Woof!
make_sound(Cat())  # Meow!

Exception Handling

Handle errors gracefully without crashing.

Basic Try/Except

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")

Multiple Exceptions

try:
    value = int("abc")
except ValueError:
    print("Invalid number format")
except TypeError:
    print("Type error occurred")

Try/Except/Else/Finally

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Cannot divide by zero")
else:
    print(f"Result: {result}")  # Runs if no exception
finally:
    print("Cleanup code here")   # Always runs

Custom Exceptions

class ValidationError(Exception):
    pass

def validate_age(age):
    if age < 0:
        raise ValidationError("Age cannot be negative")
    return age

File Handling

Reading and Writing Files

# Writing
with open("output.txt", "w") as f:
    f.write("Hello, World!")

# Reading
with open("output.txt", "r") as f:
    content = f.read()
    print(content)

Using pathlib (Modern Approach)

from pathlib import Path

# Write
Path("output.txt").write_text("Hello, World!")

# Read
content = Path("output.txt").read_text()

# Check existence
if Path("output.txt").exists():
    print("File exists")

# Create directory
Path("new_folder").mkdir(exist_ok=True)

Best Practices (PEP 8)

Code Style

  • Indentation: 4 spaces (not tabs)
  • Line length: Max 79 characters
  • Naming:
    • Variables/functions: snake_case
    • Classes: PascalCase
    • Constants: ALL_CAPS

Example of Clean Code

# Constants
MAX_CONNECTIONS = 100
DEFAULT_TIMEOUT = 30

# Function with type hints and docstring
def calculate_area(radius: float) -> float:
    """Calculate the area of a circle.

    Args:
        radius: The radius of the circle.

    Returns:
        The area of the circle.
    """
    return 3.14159 * radius ** 2


# Class with clear structure
class User:
    def __init__(self, name: str, email: str):
        self.name = name
        self.email = email

    def __repr__(self) -> str:
        return f"User(name={self.name!r}, email={self.email!r})"

Practical Projects

Build these projects to solidify your learning:

  1. Calculator: Basic arithmetic operations
  2. To-Do List: Console app to manage tasks
  3. Password Generator: Random secure passwords
  4. Weather App: Fetch data from an API
  5. Web Scraper: Extract data from websites

Next Steps

  • Data Science: Learn pandas, NumPy, matplotlib
  • Web Development: Explore Flask or Django
  • Automation: Use Python for scripting and task automation
  • Machine Learning: Start with scikit-learn, then TensorFlow/PyTorch
  • Official Python Tutorial
  • Python Crash Course by Eric Matthes
  • Automate the Boring Stuff with Python by Al Sweigart
  • Real Python tutorials (realpython.com)

Conclusion

You now have a solid foundation in Python — from basic syntax to advanced patterns like comprehensions and OOP. The key to mastering Python is practice: build projects, solve problems, and experiment with the language.

Python's strength lies in its versatility. Whether you're building web applications, analyzing data, or automating tasks, Python has you covered. Keep coding, stay curious, and enjoy the journey!