Chapter 1: Python Basics & Syntax - Complete Python Programming Fundamentals

Welcome to the most comprehensive Python programming tutorial available! This chapter serves as your gateway into the world of Python programming, covering every essential concept you need to master this powerful and versatile language. Whether you're an absolute beginner taking your first steps in programming or an experienced developer looking to solidify your Python foundation, this detailed guide will provide you with an in-depth understanding of Python's core concepts, syntax, and best practices.

Why Learn Python Programming?

Python is one of the most popular and versatile programming languages in the world, used by millions of developers for:

• Web Development: Building dynamic websites and web applications
• Data Science: Analyzing data, machine learning, and artificial intelligence
• Automation: Scripting and task automation
• Software Development: Desktop applications and enterprise software
• Scientific Computing: Research and scientific applications

This Python tutorial will teach you everything you need to know to start programming in Python effectively.

Learning Objectives

By the end of this comprehensive chapter, you will have mastered:

• Complete understanding of Python - its history, philosophy, and why it dominates modern programming
• Professional development environment setup - from installation to IDE configuration
• Python syntax mastery - every aspect of Python's elegant and readable syntax
• Variable and data type expertise - understanding Python's dynamic typing system
• Input/output operations - handling user interaction and data display
• Code documentation standards - writing maintainable and professional code
• Python interpreter knowledge - understanding how Python executes your code
• Best practices and conventions - writing Pythonic code that follows industry standards

What is Python? A Deep Dive into the Language

The Python Philosophy: Why Python Matters

Python is not just another programming language; it's a philosophy of programming that emphasizes simplicity, readability, and elegance. Created by Guido van Rossum and first released in 1991, Python has evolved into one of the most influential programming languages in the world. The language's design philosophy is encapsulated in "The Zen of Python," a collection of 19 aphorisms that guide Python's development.

Python's core philosophy centers around the belief that code should be readable and beautiful. Unlike languages that prioritize performance over readability, Python was designed with the principle that "readability counts." This philosophy has made Python the language of choice for beginners, data scientists, web developers, and even experienced programmers who value clean, maintainable code.

Why Python Has Become the World's Most Popular Programming Language

Python's meteoric rise to popularity isn't accidental. Several key factors have contributed to its dominance:

1. Simplicity and Readability Python's syntax is remarkably close to natural language. A Python program often reads like English, making it accessible to people from various backgrounds. This simplicity doesn't come at the cost of power - Python is a full-featured language capable of handling complex applications.

2. Versatility Across Domains Python's versatility is unmatched. It's used in:

• Web Development: Django, Flask, FastAPI
• Data Science: NumPy, Pandas, Matplotlib
• Machine Learning: TensorFlow, PyTorch, Scikit-learn
• Automation: Scripting, DevOps, system administration
• Game Development: Pygame, Panda3D
• Desktop Applications: Tkinter, PyQt, Kivy

3. Strong Community and Ecosystem Python boasts one of the largest and most active programming communities. This translates to:

• Extensive documentation and tutorials
• Thousands of third-party libraries
• Active forums and support communities
• Regular updates and improvements

4. Industry Adoption Major companies rely on Python:

• Google: Uses Python extensively for web services and internal tools
• Netflix: Powers recommendation algorithms and content delivery
• Instagram: Built entirely on Python/Django
• Spotify: Uses Python for data analysis and backend services
• NASA: Employs Python for scientific computing and data analysis

Understanding Python's Technical Architecture

Python's technical design is what makes it both powerful and accessible. Let's explore the key features that define Python:

1. Interpreted Language Architecture Unlike compiled languages like C++ or Java, Python is an interpreted language. This means:

• No compilation step: You can run Python code directly without compiling it first
• Interactive execution: You can execute code line by line in the Python interpreter
• Platform independence: The same Python code runs on any platform with a Python interpreter
• Dynamic execution: Code is analyzed and executed at runtime, allowing for more flexible programming

2. Dynamic Typing System Python's dynamic typing is revolutionary for beginners and experienced developers alike:

• No type declarations: Variables don't need to be declared with specific types
• Runtime type checking: Types are determined when the code runs, not when it's written
• Flexible variable assignment: The same variable can hold different types of data
• Automatic memory management: Python handles memory allocation and deallocation automatically

3. Object-Oriented Programming (OOP) Python is a true object-oriented language:

• Everything is an object: Even basic data types like integers and strings are objects
• Class-based inheritance: Supports single and multiple inheritance
• Encapsulation: Data hiding and method abstraction
• Polymorphism: Different objects can respond to the same method calls differently

4. Extensive Standard Library Python comes with a comprehensive standard library that includes:

• File and directory operations: os, shutil, pathlib modules
• Data processing: json, csv, xml modules
• Networking: urllib, socket, http modules
• Date and time: datetime, time modules
• Mathematical operations: math, statistics, random modules
• Regular expressions: re module for pattern matching

The Business Case for Python: Why Companies Choose Python

1. Rapid Development and Time-to-Market Python's syntax allows developers to write code 3-5 times faster than languages like Java or C++. This translates to:

• Faster prototyping: Ideas can be tested and validated quickly
• Reduced development cycles: Features can be implemented and deployed faster
• Lower initial investment: Less time and resources needed for initial development

2. Cost-Effective Development Python's efficiency leads to significant cost savings:

• Reduced development time: Less time spent writing and debugging code
• Lower maintenance costs: Clean, readable code is easier to maintain
• Abundant talent pool: Large number of Python developers available
• Open-source ecosystem: No licensing costs for the language or many libraries

3. Scalability and Performance Despite being interpreted, Python can handle enterprise-scale applications:

• Web applications: Instagram, Pinterest, and Reddit handle millions of users
• Data processing: Netflix processes petabytes of data with Python
• Scientific computing: NASA uses Python for space missions
• Performance optimization: Tools like Cython and PyPy provide near-C performance

4. Future-Proof Technology Python's design ensures long-term viability:

• Active development: Regular updates and improvements from Python Software Foundation
• Backward compatibility: Code written years ago still runs on modern Python versions
• Growing ecosystem: New libraries and frameworks are constantly being developed
• Industry adoption: Increasing use in emerging fields like AI, IoT, and blockchain

Python Installation and Professional Development Setup

Understanding Python Installation: A Comprehensive Guide

Before diving into Python programming, it's crucial to set up a professional development environment. This section will guide you through the complete installation process, ensuring you have everything needed for productive Python development.

Checking Your Current Python Installation

Before installing Python, let's check if you already have it installed and which version:

# Check Python version (Python 3)
python3 --version
# or
python3 -V

# Check Python version (Python 2 - legacy)
python --version
# or
python -V

# Check pip version (package installer)
pip3 --version
# or
pip --version

Understanding Python Versions:

• Python 2.x: Legacy version (end-of-life January 1, 2020)
• Python 3.x: Current and recommended version
• Latest stable: Python 3.11+ (as of 2024)

Professional Python Installation on Different Platforms

Windows Installation: Complete Setup Guide

Method 1: Official Python Installer (Recommended)

1. Download Python: Visit python.org/downloads
2. Choose the right version: Download Python 3.11+ (latest stable)
3. Run the installer:
   • ✅ CRITICAL: Check "Add Python to PATH" during installation
   • ✅ CRITICAL: Check "Install pip" for package management
   • Choose "Install for all users" if you have admin rights
4. Verify installation: Open Command Prompt and run python --version

Method 2: Microsoft Store (Alternative)

1. Open Microsoft Store
2. Search for "Python 3.11"
3. Click "Install"
4. This method automatically handles PATH configuration

Method 3: Anaconda Distribution (For Data Science)

1. Download Anaconda from anaconda.com
2. Run the installer
3. Anaconda includes Python + 150+ data science packages
4. Includes Jupyter Notebook, Spyder IDE, and conda package manager

macOS Installation: Multiple Options

Method 1: Official Python Installer

1. Download from python.org/downloads
2. Run the .pkg installer
3. Follow the installation wizard
4. Python will be installed in /usr/local/bin/

Method 2: Homebrew (Recommended for Developers)

# Install Homebrew first (if not installed)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Python
brew install python

# Verify installation
python3 --version
pip3 --version

Method 3: pyenv (For Multiple Python Versions)

# Install pyenv
brew install pyenv

# Install specific Python version
pyenv install 3.11.0

# Set global Python version
pyenv global 3.11.0

# Add to shell profile
echo 'export PATH="$HOME/.pyenv/bin:$PATH"' >> ~/.zshrc
echo 'eval "$(pyenv init -)"' >> ~/.zshrc

Linux Installation: Distribution-Specific Guide

Ubuntu/Debian:

# Update package list
sudo apt update

# Install Python 3 and pip
sudo apt install python3 python3-pip python3-venv

# Install development tools
sudo apt install python3-dev build-essential

# Verify installation
python3 --version
pip3 --version

CentOS/RHEL/Fedora:

# CentOS/RHEL
sudo yum install python3 python3-pip

# Fedora
sudo dnf install python3 python3-pip

# Verify installation
python3 --version
pip3 --version

Arch Linux:

# Install Python
sudo pacman -S python python-pip

# Verify installation
python --version
pip --version

Understanding the Python Interpreter: How Python Executes Code

The Python interpreter is the heart of Python programming. Understanding how it works is crucial for effective development.

Interactive Python Shell (REPL)

The Python REPL (Read-Eval-Print Loop) allows you to execute Python code interactively:

# Start interactive Python shell
python3

# You'll see something like:
# Python 3.11.0 (main, Oct 24 2022, 10:47:19) [GCC 9.4.0] on linux
# Type "help", "copyright", "credits" or "license" for more information.
# >>>

Interactive Shell Features:

• Immediate execution: Code runs as soon as you press Enter
• Variable persistence: Variables remain in memory during the session
• Help system: Type help() for interactive help
• History: Use arrow keys to navigate command history
• Tab completion: Press Tab for auto-completion

Executing Python Files

# Execute a Python script
python3 script.py

# Execute with specific Python version
python3.11 script.py

# Execute with module flag
python3 -m script

# Execute with optimization flags
python3 -O script.py  # Remove assert statements
python3 -OO script.py  # Remove assert and docstrings

Python Command Line Options

# Common Python command line options
python3 -c "print('Hello, World!')"  # Execute code from command line
python3 -m pip install package_name  # Run module as script
python3 -i script.py  # Execute script and enter interactive mode
python3 -u script.py  # Unbuffered stdout and stderr
python3 -v script.py  # Verbose mode (trace import statements)

Python Syntax Fundamentals: The Foundation of Clean Code

Understanding Python's Unique Syntax Philosophy

Python's syntax is what sets it apart from other programming languages. Unlike languages that use braces {} or keywords like begin/end, Python uses indentation to define code blocks. This design choice, while initially surprising to programmers from other languages, creates incredibly readable and clean code.

Your First Python Program: A Deep Dive

Let's start with the classic "Hello, World!" program and understand every component:

#!/usr/bin/env python3

print("Hello, World!")

Line-by-Line Analysis:

Line 1: #!/usr/bin/env python3

• This is called a shebang or hashbang
• It tells the system which interpreter to use to execute the script
• #! indicates this is a shebang line
• /usr/bin/env python3 finds the Python 3 interpreter in the system PATH
• Important: This line is only needed for executable scripts on Unix/Linux systems
• Windows: This line is ignored, but it's good practice to include it for cross-platform compatibility

Line 2: Empty line

• Python allows empty lines for readability
• They don't affect program execution
• Good practice for separating logical sections

Line 3: print("Hello, World!")

• print() is a built-in function in Python
• Functions are called using parentheses ()
• "Hello, World!" is a string literal (text enclosed in quotes)
• The function displays the string to the console
• Python automatically adds a newline after the output

Understanding Python's Indentation System

Python's indentation system is revolutionary in programming languages. Let's explore why it matters and how to use it correctly.

The Philosophy Behind Indentation

Why Indentation Instead of Braces?

• Readability: Code structure is immediately visible
• Consistency: Forces developers to write clean, organized code
• Reduced errors: No missing braces or mismatched brackets
• Pythonic: Follows the principle "Beautiful is better than ugly"

Correct Indentation Examples

# Example 1: Basic indentation
if True:
    print("This is indented")
    print("This is also indented")
print("This is not indented")

# Example 2: Nested indentation
if True:
    print("Level 1")
    if True:
        print("Level 2")
        if True:
            print("Level 3")
    print("Back to Level 1")

# Example 3: Function with indentation
def greet(name):
    """Function with proper indentation."""
    if name:
        print(f"Hello, {name}!")
        print("Welcome to Python!")
    else:
        print("Hello, Anonymous!")
    print("Function completed")

# Call the function
greet("Alice")

Common Indentation Errors and How to Avoid Them

# ERROR: Inconsistent indentation
if True:
    print("4 spaces")
  print("2 spaces")  # IndentationError!

# ERROR: Missing indentation
if True:
print("Not indented")  # IndentationError!

# ERROR: Mixing tabs and spaces
if True:
    print("4 spaces")
	print("1 tab")  # IndentationError!

# CORRECT: Consistent 4-space indentation
if True:
    print("4 spaces")
    print("4 spaces")

Indentation Best Practices

1. Use 4 Spaces (PEP 8 Standard)

# Good: 4 spaces per level
def calculate_area(length, width):
    if length > 0 and width > 0:
        area = length * width
        return area
    else:
        return 0

2. Never Mix Tabs and Spaces

# Bad: Mixing tabs and spaces
def bad_function():
    print("4 spaces")
	print("1 tab")  # This will cause errors

# Good: Consistent spaces
def good_function():
    print("4 spaces")
    print("4 spaces")

3. Use Your Editor's Tab Settings Most modern editors can be configured to:

• Convert tabs to spaces
• Show whitespace characters
• Auto-indent based on Python syntax
• Highlight indentation errors

4. Indentation in Different Contexts

# Function definition
def my_function():
    """Function body is indented."""
    return "Hello"

# Class definition
class MyClass:
    """Class body is indented."""
    
    def method(self):
        """Method body is indented."""
        return "Method"

# Control structures
if condition:
    # This block is indented
    do_something()
elif other_condition:
    # This block is indented
    do_something_else()
else:
    # This block is indented
    do_final_thing()

# Loops
for item in items:
    # Loop body is indented
    process(item)
    if item.is_special():
        # Nested block is indented more
        handle_special(item)

Python Comments: The Art of Code Documentation

Comments are essential for writing maintainable, professional Python code. They serve multiple purposes: explaining complex logic, documenting functions, and providing context for future developers (including yourself).

Understanding Different Types of Comments

1. Single-Line Comments

# This is a single-line comment
# Comments start with a hash symbol (#)
# Everything after # on the same line is ignored by Python

# You can have multiple single-line comments
# Each line needs its own # symbol

2. Inline Comments

# Inline comments explain code on the same line
x = 5  # Initialize x with value 5
y = x * 2  # Calculate y as double of x
print(f"Result: {y}")  # Display the result

3. Multi-Line Comments (Docstrings)

"""
This is a multi-line comment or docstring.
It can span multiple lines and is often used for:
- Module documentation
- Class documentation
- Function documentation
- General code explanations

Docstrings are different from regular comments because
they become part of the object's __doc__ attribute.
"""

def example_function():
    """
    This is a function docstring.
    It describes what the function does.
    
    Returns:
        str: A greeting message
    """
    return "Hello, World!"

Best Practices for Writing Comments

1. Write Comments for Why, Not What

# Bad: Comments that just repeat the code
x = x + 1  # Add 1 to x

# Good: Comments that explain the reasoning
x = x + 1  # Increment counter for next iteration

# Better: Comments that explain business logic
if user_age >= 18:
    # Legal drinking age requirement for alcohol purchase
    allow_purchase = True

2. Use Docstrings for Functions and Classes

def calculate_compound_interest(principal, rate, time, compound_frequency=12):
    """
    Calculate compound interest for an investment.
    
    This function implements the compound interest formula:
    A = P(1 + r/n)^(nt)
    
    Args:
        principal (float): Initial investment amount
        rate (float): Annual interest rate (as decimal, e.g., 0.05 for 5%)
        time (float): Time period in years
        compound_frequency (int): Number of times interest compounds per year
    
    Returns:
        float: Final amount after compound interest
    
    Raises:
        ValueError: If any parameter is negative
    
    Example:
        >>> calculate_compound_interest(1000, 0.05, 2)
        1104.7130674412967
    """
    if principal < 0 or rate < 0 or time < 0:
        raise ValueError("All parameters must be non-negative")
    
    amount = principal * (1 + rate / compound_frequency) ** (compound_frequency * time)
    return amount

3. Comment Complex Algorithms

def binary_search(sorted_list, target):
    """
    Perform binary search on a sorted list.
    
    Args:
        sorted_list (list): A sorted list of numbers
        target (int): The number to search for
    
    Returns:
        int: Index of target if found, -1 otherwise
    """
    left = 0
    right = len(sorted_list) - 1
    
    # Binary search algorithm: repeatedly divide search space in half
    while left <= right:
        # Calculate middle index to avoid integer overflow
        mid = left + (right - left) // 2
        
        # Check if target is at middle position
        if sorted_list[mid] == target:
            return mid
        
        # If target is greater, search right half
        elif sorted_list[mid] < target:
            left = mid + 1
        
        # If target is smaller, search left half
        else:
            right = mid - 1
    
    # Target not found
    return -1

4. Use TODO Comments for Future Work

def process_user_data(user_data):
    """Process user data and return formatted result."""
    
    # TODO: Add validation for email format
    # TODO: Implement caching for frequently accessed data
    # TODO: Add support for international phone numbers
    
    result = {}
    for key, value in user_data.items():
        # FIXME: This conversion might fail for non-string values
        result[key] = str(value).lower()
    
    return result

Comment Style Guidelines

1. PEP 8 Comment Guidelines

# Good: Space after hash symbol
# Bad: No space after hash symbol
#Good: No space after hash symbol

# Good: Capitalize first word of comment
# Calculate the area of a rectangle

# Good: Use complete sentences
# This function validates user input before processing

# Bad: Incomplete or unclear
# validate input

2. Comment Placement

# Good: Comments above the code they explain
# Initialize the counter for tracking iterations
counter = 0

# Good: Inline comments for short explanations
total = price * quantity  # Calculate total cost

# Bad: Comments that are too far from the code
# This comment is too far from the code it explains
# ... many lines of code ...
counter = 0

3. Avoid Obvious Comments

# Bad: Comments that state the obvious
name = "John"  # Set name to John
age = 25  # Set age to 25
print(name)  # Print the name

# Good: Comments that add value
name = "John"  # Default user name for testing
age = 25  # Minimum age requirement for registration
print(name)  # Display user name for confirmation

Special Comment Types

1. Section Headers

# =============================================================================
# USER AUTHENTICATION FUNCTIONS
# =============================================================================

def validate_username(username):
    """Validate username format."""
    pass

def authenticate_user(username, password):
    """Authenticate user credentials."""
    pass

# =============================================================================
# DATA PROCESSING FUNCTIONS
# =============================================================================

def process_data(data):
    """Process user data."""
    pass

2. Bug Tracking Comments

def calculate_tax(amount):
    """Calculate tax for given amount."""
    # BUG: This doesn't handle negative amounts correctly
    # Reported by: [email protected]
    # Date: 2024-01-15
    # TODO: Fix negative amount handling
    return amount * 0.1

3. Performance Notes

def process_large_dataset(data):
    """Process large dataset efficiently."""
    # PERFORMANCE: This function is O(n²) - consider optimization
    # for datasets larger than 10,000 items
    result = []
    for item in data:
        for other_item in data:
            if item != other_item:
                result.append(compare_items(item, other_item))
    return result

Python Variables and Data Types: Understanding Python's Dynamic Nature

The Philosophy of Variables in Python

Variables in Python are fundamentally different from variables in statically-typed languages like C++ or Java. Python variables are references to objects in memory, not containers that hold values directly. This design choice makes Python incredibly flexible and powerful, but it also requires understanding how Python manages memory and object references.

Understanding Python Variables: References, Not Containers

Key Concept: Variables are Labels, Not Boxes

In Python, when you write name = "John", you're not putting "John" into a box called name. Instead, you're creating a label called name that points to a string object "John" in memory. This distinction is crucial for understanding Python's behavior.

# Creating variables (actually creating references)
name = "John"        # 'name' points to string object "John"
age = 25            # 'age' points to integer object 25
height = 5.9        # 'height' points to float object 5.9
is_student = True   # 'is_student' points to boolean object True

# Multiple assignment - creating multiple references
x, y, z = 1, 2, 3   # x points to 1, y points to 2, z points to 3
a = b = c = 0       # a, b, and c all point to the same integer object 0

# Understanding reference behavior
original_list = [1, 2, 3]
reference_list = original_list  # Both variables point to the same list object
reference_list.append(4)
print(original_list)  # [1, 2, 3, 4] - both variables see the change!

Variable Naming: The Art of Clear Communication

Python's variable naming conventions are more than just style guidelines - they're essential for writing readable, maintainable code. The Python community has established clear conventions that make code self-documenting.

Python Naming Conventions (PEP 8)

1. Snake Case for Variables and Functions

# Good: Snake case (recommended)
user_name = "john_doe"
first_name = "John"
last_name = "Doe"
is_valid_user = True
calculate_total_price = lambda x, y: x + y

# Bad: Other styles for variables
userName = "john_doe"      # Camel case
UserName = "john_doe"      # Pascal case
user-name = "john_doe"     # Kebab case (not valid in Python)

2. Pascal Case for Classes

# Good: Pascal case for classes
class UserAccount:
    pass

class DatabaseConnection:
    pass

class PaymentProcessor:
    pass

# Bad: Other styles for classes
class userAccount:     # Should be UserAccount
class database_connection:  # Should be DatabaseConnection

3. Constants in UPPER_CASE

# Good: Constants in uppercase
MAX_CONNECTIONS = 100
DEFAULT_TIMEOUT = 30
API_BASE_URL = "https://api.example.com"

# Bad: Constants in lowercase
max_connections = 100  # Should be MAX_CONNECTIONS

Variable Naming Best Practices

1. Be Descriptive and Meaningful

# Bad: Unclear variable names
n = 10
d = 5.5
b = True
lst = [1, 2, 3]

# Good: Clear, descriptive names
number_of_students = 10
average_grade = 5.5
is_graduated = True
student_grades = [1, 2, 3]

# Better: Even more descriptive
total_students_in_class = 10
weighted_average_grade = 5.5
has_completed_graduation = True
final_exam_scores = [1, 2, 3]

2. Use Consistent Terminology

# Good: Consistent terminology
user_id = 123
user_name = "john_doe"
user_email = "[email protected]"
user_created_at = "2024-01-15"

# Bad: Inconsistent terminology
user_id = 123
customer_name = "john_doe"  # Should be user_name
email_address = "[email protected]"  # Should be user_email
created_date = "2024-01-15"  # Should be user_created_at

3. Avoid Abbreviations and Acronyms

# Bad: Unclear abbreviations
emp_id = 123
cust_svc = "support"
calc_tot = lambda x: sum(x)

# Good: Full words
employee_id = 123
customer_service = "support"
calculate_total = lambda x: sum(x)

# Acceptable: Well-known abbreviations
html_content = "<div>Hello</div>"
api_response = {"status": "success"}
url_endpoint = "/api/users"

4. Use Boolean Naming Conventions

# Good: Boolean variables start with is_, has_, can_, should_
is_valid = True
has_permission = False
can_edit = True
should_retry = False

# Good: Boolean functions return True/False
def is_user_authenticated():
    return True

def has_required_permissions():
    return False

# Bad: Unclear boolean names
valid = True  # Should be is_valid
permission = False  # Should be has_permission

Reserved Keywords and Built-in Names

Python Reserved Keywords (Cannot be used as variable names):

# These are reserved keywords - never use them as variable names
and, as, assert, break, class, continue, def, del, elif, else, except, 
finally, for, from, global, if, import, in, is, lambda, not, or, pass, 
raise, return, try, while, with, yield, True, False, None

# Bad: Using reserved keywords
class = "MyClass"  # SyntaxError!
def = "function"   # SyntaxError!
if = True          # SyntaxError!

# Good: Using descriptive alternatives
class_name = "MyClass"
function_name = "function"
condition = True

Built-in Names (Avoid shadowing):

# Bad: Shadowing built-in names
list = [1, 2, 3]      # Shadows built-in list()
dict = {"key": "value"}  # Shadows built-in dict()
str = "hello"         # Shadows built-in str()

# Good: Use descriptive names
number_list = [1, 2, 3]
user_data = {"key": "value"}
greeting = "hello"

# Good: Use built-in names for their intended purpose
my_list = list([1, 2, 3])  # Using built-in list() function
my_dict = dict(key="value")  # Using built-in dict() function
my_string = str(123)  # Using built-in str() function

Variable Scope and Lifetime

Understanding Variable Scope:

# Global scope
global_variable = "I'm global"

def my_function():
    # Local scope
    local_variable = "I'm local"
    
    # Accessing global variable
    print(global_variable)  # Works: "I'm global"
    
    # Modifying global variable
    global global_variable
    global_variable = "Modified global"
    
    return local_variable

# Function call
result = my_function()
print(result)  # "I'm local"
print(global_variable)  # "Modified global"

# Local variable is not accessible outside function
# print(local_variable)  # NameError: name 'local_variable' is not defined

Variable Lifetime:

def create_variables():
    """Demonstrate variable lifetime."""
    # Variables created in function
    temp_data = "temporary"
    counter = 0
    
    def nested_function():
        # Nonlocal variable
        nonlocal counter
        counter += 1
        return counter
    
    return nested_function

# Create function that remembers its state
counter_func = create_variables()
print(counter_func())  # 1
print(counter_func())  # 2
print(counter_func())  # 3

# temp_data is no longer accessible
# print(temp_data)  # NameError: name 'temp_data' is not defined

Basic Data Types

Python has several built-in data types:

# Numbers
integer_num = 42
float_num = 3.14
complex_num = 3 + 4j

# Strings
single_quote = 'Hello'
double_quote = "World"
triple_quote = """Multi-line
string"""

# Boolean
is_true = True
is_false = False

# None
empty_value = None

Type Checking and Conversion

# Check data type
print(type(42))        # <class 'int'>
print(type(3.14))      # <class 'float'>
print(type("Hello"))   # <class 'str'>

# Type conversion
num_str = "123"
num_int = int(num_str)
num_float = float(num_str)

str_num = str(123)
bool_val = bool(1)  # True
bool_val = bool(0)  # False

Python Input and Output

Input Function

The input() function allows user input:

# Basic input
name = input("Enter your name: ")
print(f"Hello, {name}!")

# Input with type conversion
age = int(input("Enter your age: "))
height = float(input("Enter your height: "))

# Multiple inputs
first_name, last_name = input("Enter first and last name: ").split()

Output Functions

# Print function variations
print("Hello, World!")
print("Hello", "World", "!")
print("Hello", "World", sep="-")  # Hello-World-!
print("Hello", end=" ")           # No newline
print("World")

# Formatted output
name = "John"
age = 25
print(f"My name is {name} and I am {age} years old")
print("My name is {} and I am {} years old".format(name, age))
print("My name is %s and I am %d years old" % (name, age))

Python Operators

Arithmetic Operators

# Basic arithmetic
a, b = 10, 3

print(a + b)   # Addition: 13
print(a - b)   # Subtraction: 7
print(a * b)   # Multiplication: 30
print(a / b)   # Division: 3.333...
print(a // b)  # Floor division: 3
print(a % b)   # Modulus: 1
print(a ** b)  # Exponentiation: 1000

Comparison Operators

a, b = 10, 5

print(a == b)  # Equal: False
print(a != b)  # Not equal: True
print(a > b)   # Greater than: True
print(a < b)   # Less than: False
print(a >= b)  # Greater or equal: True
print(a <= b)  # Less or equal: False

Logical Operators

x, y = True, False

print(x and y)  # Logical AND: False
print(x or y)   # Logical OR: True
print(not x)    # Logical NOT: False

Assignment Operators

x = 10

x += 5   # x = x + 5
x -= 3   # x = x - 3
x *= 2   # x = x * 2
x /= 4   # x = x / 4
x //= 2  # x = x // 2
x %= 3   # x = x % 3
x **= 2  # x = x ** 2

Python Keywords and Identifiers

Reserved Keywords

Python has reserved keywords that cannot be used as variable names:

# Common Python keywords
and, as, assert, break, class, continue, def, del, elif, else, except, 
finally, for, from, global, if, import, in, is, lambda, not, or, pass, 
print, raise, return, try, while, with, yield, True, False, None

Valid Identifiers

# Valid identifiers
variable_name = "valid"
_variable = "valid"
variable123 = "valid"
VariableName = "valid"

# Invalid identifiers
# 123variable = "invalid"  # Cannot start with number
# var-name = "invalid"     # Cannot contain hyphens
# class = "invalid"        # Cannot use reserved keywords

Python Code Structure

Python Files and Modules

# my_module.py
"""
This is a Python module.
It can contain functions, classes, and variables.
"""

# Module-level variables
MODULE_NAME = "my_module"
VERSION = "1.0.0"

# Functions
def greet(name):
    """Return a greeting message."""
    return f"Hello, {name}!"

# Classes
class Person:
    """A simple Person class."""
    def __init__(self, name):
        self.name = name
    
    def introduce(self):
        return f"I am {self.name}"

# Main execution
if __name__ == "__main__":
    print(greet("World"))
    person = Person("Alice")
    print(person.introduce())

Importing Modules

# Import entire module
import math
print(math.pi)

# Import specific functions
from math import pi, sqrt
print(pi)
print(sqrt(16))

# Import with alias
import numpy as np
import pandas as pd

# Import all (not recommended)
from math import *

Python Best Practices

Code Style Guidelines (PEP 8)

# Good Python style
def calculate_area(length, width):
    """Calculate the area of a rectangle.
    
    Args:
        length (float): Length of the rectangle
        width (float): Width of the rectangle
    
    Returns:
        float: Area of the rectangle
    """
    return length * width

# Constants in UPPER_CASE
MAX_CONNECTIONS = 100
DEFAULT_TIMEOUT = 30

# Class names in PascalCase
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def area(self):
        return self.length * self.width

Error Handling Basics

# Basic error handling
try:
    number = int(input("Enter a number: "))
    result = 10 / number
    print(f"Result: {result}")
except ValueError:
    print("Please enter a valid number")
except ZeroDivisionError:
    print("Cannot divide by zero")
except Exception as e:
    print(f"An error occurred: {e}")

Practical Examples

Example 1: Simple Calculator

def simple_calculator():
    """A simple calculator program."""
    print("Simple Calculator")
    print("Operations: +, -, *, /")
    
    try:
        num1 = float(input("Enter first number: "))
        operator = input("Enter operator: ")
        num2 = float(input("Enter second number: "))
        
        if operator == '+':
            result = num1 + num2
        elif operator == '-':
            result = num1 - num2
        elif operator == '*':
            result = num1 * num2
        elif operator == '/':
            result = num1 / num2
        else:
            print("Invalid operator")
            return
        
        print(f"Result: {result}")
    
    except ValueError:
        print("Please enter valid numbers")
    except ZeroDivisionError:
        print("Cannot divide by zero")

# Run the calculator
if __name__ == "__main__":
    simple_calculator()

Example 2: Temperature Converter

def temperature_converter():
    """Convert between Celsius and Fahrenheit."""
    print("Temperature Converter")
    print("1. Celsius to Fahrenheit")
    print("2. Fahrenheit to Celsius")
    
    choice = input("Enter choice (1 or 2): ")
    
    try:
        if choice == '1':
            celsius = float(input("Enter temperature in Celsius: "))
            fahrenheit = (celsius * 9/5) + 32
            print(f"{celsius}°C = {fahrenheit}°F")
        
        elif choice == '2':
            fahrenheit = float(input("Enter temperature in Fahrenheit: "))
            celsius = (fahrenheit - 32) * 5/9
            print(f"{fahrenheit}°F = {celsius}°C")
        
        else:
            print("Invalid choice")
    
    except ValueError:
        print("Please enter a valid number")

# Run the converter
if __name__ == "__main__":
    temperature_converter()

Common Python Pitfalls and Solutions

Common Mistakes

# 1. Indentation errors
# Wrong:
if True:
print("This will cause IndentationError")

# Correct:
if True:
    print("This is correct")

# 2. Variable scope issues
def function():
    global_var = "local"  # This creates a local variable
    print(global_var)

# 3. Mutable default arguments
# Wrong:
def append_to_list(item, my_list=[]):
    my_list.append(item)
    return my_list

# Correct:
def append_to_list(item, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(item)
    return my_list

# 4. String vs integer comparison
# Wrong:
age = input("Enter age: ")
if age > 18:  # This will cause TypeError
    print("Adult")

# Correct:
age = int(input("Enter age: "))
if age > 18:
    print("Adult")

Summary

In this chapter, we've covered:

• Python fundamentals and why it's popular
• Installation and setup for different platforms
• Basic syntax including indentation and comments
• Variables and data types in Python
• Input and output operations
• Operators for arithmetic, comparison, and logic
• Code structure and module organization
• Best practices and common pitfalls

Python's simplicity and readability make it an excellent choice for beginners and professionals alike. The clean syntax and extensive libraries provide a solid foundation for any programming project.

Next Steps

Now that you understand Python basics, you're ready to explore:

1. Data Types: Learn about strings, lists, tuples, dictionaries, and sets
2. Control Flow: Master if statements, loops, and exception handling
3. Functions: Create reusable code with functions and modules
4. Object-Oriented Programming: Build classes and objects
5. Advanced Topics: Explore decorators, generators, and more

---

Ready to dive deeper? Continue with Chapter 2: Data Types to master Python's data structures!