Courses / Python Programming Fundamentals

Python Programming Fundamentals

A comprehensive introduction to programming using Python, covering core language concepts from variables and control flow through data structures, file handling, and practical applications. Students learn to write programs that process data, interact with networks and web services, and build object-oriented solutions with databases and visualizations.

  • Beginner
  • 35.5 hours
  • Self-paced
  • No certificate
  • 17 chapters
  • 162 modules
  • 365 articles
  • 15 quizzes
  • 0 learners enrolled

Course Overview

A comprehensive introduction to programming using Python, covering core language concepts from variables and control flow through data structures, file handling, and practical applications. Students learn to write programs that process data, interact with networks and web services, and build object-oriented solutions with databases and visualizations.

Course Syllabus

Chapter 1 — Getting Started

Module: Getting Started

Chapter 2 — Getting Started: Why Programming Matters and How Computers Work

Module: Why Learn to Program: Creativity, Motivation, and Real-World Impact

Module: Inside the Computer: Understanding Hardware Architecture

Module: Learning to Program: The Two Essential Skills

Module: Conversing with Python: Interactive Mode and Error Handling

Module: Python's Vocabulary: Reserved Words and Your First Sentence

Module: Interpreters vs. Compilers: How Python Translates Your Code

Module: Writing and Running Python Programs: From Interactive to Scripts

Module: What Is a Program? Understanding Programs and Problem-Solving

Module: Building Blocks of Programs: Six Essential Patterns

Module: When Things Go Wrong: Understanding Programming Errors

Module: Debugging: Finding and Fixing Errors in Your Code

Module: Your Learning Journey: Patience, Progress, and Programming Mastery

Chapter 3 — Building Programs with Variables, Expressions, and Statements

Module: Understanding Values and Data Types

Module: Naming Variables: Rules and Best Practices

Module: Creating and Using Variables

Module: Statements: The Actions Your Program Takes

Module: Operators and Operands: Performing Computations

Module: Expressions: Combining Values, Variables, and Operators

Module: Order of Operations: PEMDAS and Operator Precedence

Module: The Modulus Operator: Finding Remainders

Module: String Operations: Concatenation and Replication

Module: Getting Input from Users: The input() Function

Module: Writing Comments: Explaining Your Code

Module: Choosing Meaningful Variable Names: Mnemonics and Readability

Chapter 4 — Making Decisions in Your Code: Conditional Execution and Error Handling

Module: Understanding True and False: Boolean Expressions and Comparison

Module: Combining Conditions: Logical Operators and Boolean Flexibility

Module: Making Your First Decision: The if Statement

Module: Choosing Between Two Options: if-else Statements

Module: Handling Multiple Options: Chained Conditionals with elif

Module: Nesting Conditionals and Simplifying with Logical Operators

Module: Handling Errors Gracefully: try and except Blocks

Module: Preventing Errors Before They Happen: Short-Circuit Evaluation and the Guardian Pattern

Module: Reading and Understanding Error Messages: Debugging Conditional Code

Module: Chapter Review: Conditional Execution Concepts and Terminology

Chapter 5 — Mastering Functions: From Built-in Tools to Custom Code

Module: Converting Between Data Types

Module: Understanding Function Calls and Arguments

Module: Using Python's Built-in Functions

Module: Using the Math Module for Advanced Calculations

Module: Generating Random Numbers

Module: Writing Your Own Functions

Module: Tracing Program Execution Through Functions

Module: Using Parameters and Arguments in Functions

Module: Fruitful Functions vs. Void Functions

Module: Why Functions Matter: Benefits and Best Practices

Module: Chapter Review and Practice

Chapter 6 — Mastering Loops: Automating Repetitive Tasks with Python

Module: Building Blocks: Variable Updates and Initialization

Module: Conditional Repetition: Understanding while Loops

Module: Avoiding Pitfalls: Recognizing and Handling Infinite Loops

Module: Skipping to the Next Iteration: The continue Statement

Module: Looping Through Known Collections: The for Loop

Module: Essential Loop Patterns: Counting, Summing, and Finding Extremes

Module: Debugging Loops: Finding and Fixing Loop Errors

Module: Iteration Terminology: Key Concepts and Definitions

Chapter 7 — Working with Strings: Indexing, Traversal, and Manipulation

Module: Understanding Strings as Sequences

Module: Measuring String Length

Module: Traversing Strings with Loops

Module: Extracting Substrings with Slicing

Module: Understanding String Immutability

Module: Counting Characters with the Counter Pattern

Module: Testing Substrings with the in Operator

Module: Comparing Strings

Module: Exploring String Objects and Methods

Module: Calling String Methods with Dot Notation

Module: Extracting Data from Strings

Module: Creating Dynamic Strings with Formatted String Literals

Module: Debugging String Index Errors

Module: String Concepts Reference

Chapter 8 — Working with Files: Persistent Data Storage in Python

Module: Understanding File Storage and Memory

Module: Opening Files and Getting File Handles

Module: Understanding Text Files and Newline Characters

Module: Reading Files: From Line-by-Line to Full Content

Module: Searching Through Files: Patterns and Techniques

Module: Making Programs Flexible: User-Supplied File Names

Module: Handling File Errors Gracefully: Try, Except, and Exit

Module: Writing Files: Creating and Modifying Data

Module: Debugging File Operations: Handling Whitespace Issues

Module: Chapter Exercises: Applying File Operations

Chapter 9 — Mastering Lists: Sequences, Mutability, and Practical Data Handling

Module: Understanding Lists as Sequences

Module: Accessing and Modifying List Elements

Module: Iterating Through Lists

Module: Combining and Repeating Lists

Module: Extracting Portions of Lists with Slicing

Module: Essential List Methods

Module: Removing Elements from Lists

Module: Using Built-in Functions with Lists

Module: Converting Between Strings and Lists

Module: Parsing Lines to Extract Information

Module: Understanding Objects, Values, and Identity

Module: Aliasing: When Multiple Names Refer to the Same List

Module: Passing Lists to Functions

Module: Debugging List Programs and Avoiding Common Pitfalls

Module: Handling Errors When Parsing Files

Module: Capstone: Practical List Applications

Chapter 10 — Dictionaries: Mapping Keys to Values

Module: Dictionary Fundamentals: Creating and Accessing Data

Module: Counting with Dictionaries: Building Histograms

Module: Counting Words in Files: Dictionaries Meet Real Data

Module: Iterating Through Dictionaries: Keys, Sorting, and Filtering

Module: Advanced Text Parsing: Cleaning Data for Accurate Counting

Module: Debugging Dictionaries and Large Datasets

Module: Dictionary Terminology and Concepts

Module: Dictionary Practice Exercises

Chapter 11 — Mastering Tuples: Immutable Sequences and Practical Applications

Module: Understanding Tuples: Creation and Immutability

Module: Comparing and Sorting Tuples

Module: Tuple Assignment: Unpacking and Variable Swapping

Module: Working with Dictionaries and Tuples

Module: Iterating Through Dictionaries with Tuple Assignment

Module: Analyzing Word Frequency: A Real-World Application

Module: Using Tuples as Dictionary Keys

Module: Comparing Sequences: Strings, Lists, and Tuples

Module: Creating Lists Efficiently with List Comprehension

Module: Understanding Data Structures and Debugging Shape Errors

Chapter 12 — Mastering Regular Expressions for Powerful String Searching and Data Extraction

Module: Getting Started with Regular Expressions

Module: Matching Patterns with Special Characters

Module: Extracting Data from Strings

Module: Combining Search and Extract Operations

Module: Escaping Special Characters

Module: Regular Expression Reference and Summary

Module: Regular Expressions in Unix and Linux

Module: Debugging and Documentation Tools

Module: Practice Exercises and Challenges

    Chapter 13 — Building Network Applications: From HTTP to Web Scraping

    Module: Understanding Network Communication Fundamentals

    Module: Building Your First Web Browser with Sockets

    Module: Downloading Binary Files: Images Over HTTP

    Module: Simplifying Web Access with urllib

    Module: Downloading Binary Files Efficiently with urllib

    Module: Web Scraping Fundamentals

    Module: Parsing HTML with Regular Expressions

    Module: Robust HTML Parsing with BeautifulSoup

    Module: Command-Line Tools for Web Retrieval (Unix/Linux)

    Chapter 14 — Exchanging Data Across the Web: XML, JSON, and APIs

    Module: Understanding XML: Structure and Basics

    Module: Parsing XML with Python's ElementTree

    Module: Iterating Through Multiple XML Nodes

    Module: Introduction to JSON: A Simpler Data Format

    Module: Parsing JSON with Python

    Module: Understanding APIs: Contracts Between Applications

    Module: Securing API Access: Keys, Authentication, and OAuth

    Chapter 15 — Organizing Code with Objects: An Introduction to Object-Oriented Programming

    Module: Why Object-Oriented Programming Matters

    Module: Getting Started with Object-Oriented Concepts

    Module: Working with Objects You Already Know

    Module: Understanding Program Structure and Object Interaction

    Module: Hiding Complexity Through Objects

    Module: Creating Your First Python Class

    Module: Understanding Classes as Types

    Module: Object Lifecycle: Construction and Destruction

    Module: Creating Multiple Independent Instances

    Module: Extending Classes Through Inheritance

    Module: Chapter Summary and Review

    Chapter 16 — Storing and Retrieving Data with Databases and SQL

    Module: Database Fundamentals and Setup

    Module: Creating and Connecting to Databases

    Module: Core SQL Operations: CRUD Fundamentals

    Module: Visualizing Database Relationships: Data Model Diagrams

    Module: Designing Relational Databases: Multiple Tables and Normalization

    Module: Automatic Primary Keys and Efficient Lookups

    Module: Enforcing Data Integrity with Constraints

    Module: Building Multi-Table Applications: A Practical Example

    Module: Many-to-Many Relationships: Modeling Complex Connections

    Module: Adding Attributes to Relationships: Data in Junction Tables

    Module: When to Use Databases: Practical Considerations and Debugging

    Chapter 17 — Building Real-World Data Applications: From Collection to Visualization

    Module: Module 1: Mapping Geographic Data with OpenStreetMap

    Module: Module 2: Analyzing Web Connectivity with PageRank

    Module: Module 3: Processing Large Email Archives

    Course Access

    Self-paced — start immediately after registering.

    Ready to start?

    Python Programming Fundamentals