Python Fundamentals with Paul Deitel, 2nd Edition

Python Fundamentals: with Integrated GenAI, 2/e, Under Development

Updated July 2026

69+ hours of video instruction—Includes updated versions of Lessons 1-9 (more to come) and a NEW 11-hour lesson on programming with OpenAI's Python APIs, Agents SDK and Codex App.

Paul is recording new and updated lessons that will gradually replace this course's content. The video "Watch This First! Python Fundamentals, 2/e Sneak Peek" outlines the forthcoming Second Edition's updates, including new Python features through Python 3.14 and 3.15, new and enhanced data science and AI lessons, and integrated Generative AI (both prompting and API programming). New lessons will be marked as "[Updated]" until the Second Edition is complete.

For the second edition's status and a list of planned updates, visit https://deitel.com/python-fundamentals-with-genai-2-e-video-course

Overview

The professional programmer's Deitel® video guide to Python development with the powerful IPython interpreter and Jupyter Notebooks.

Related Learning:
Book: Python for Programmers by Paul Deitel and Harvey Deitel [Second Edition under development.]

Description

Python Fundamentals LiveLessons with Paul Deitel is a code-intensive presentation of Python—one of the world's most popular and fastest growing languages. In the context of hundreds of real-world code examples ranging from individual snippets to complete scripts, Paul demonstrates coding with the interactive IPython interpreter and Jupyter Notebooks. You'll quickly become familiar with the Python language, its popular programming idioms, key Python Standard Library modules and popular third-party, open-source libraries.

In the Intro to Data Science videos, Paul lays the groundwork for later lessons in which he introduces some of today's most compelling, leading-edge computing technologies, including:

• Natural language processing
• Data mining social media
• Supervised machine learning with classification and regression
• Unsupervised machine learning with clustering
• Computer vision through deep learning with a convolutional neural network
• Sentiment analysis through deep learning with a recurrent neural network
• Big data infrastructure including Spark™ streaming, NoSQL databases and the Internet of Things (IoT)

Download This Course's Code Examples:
https://github.com/pdeitel/PythonFundamentals2e

About the Instructor

Paul J. Deitel, CEO and Chief Technical Officer of Deitel & Associates, Inc., is an MIT graduate with 46 years in computing. Paul is one of the world's most experienced programming-languages trainers, having taught professional courses to software developers at all levels since 1992. He has delivered hundreds of programming courses to industry clients internationally, including SLB (formerly Schlumberger), Cisco, IBM, Siemens, Sun Microsystems (now Oracle), Dell, Fidelity, NASA at the Kennedy Space Center, the National Severe Storm Laboratory, White Sands Missile Range, Rogue Wave Software, Boeing, Puma, iRobot, UCLA Anderson's Master of Science in Business Analytics (MSBA) and Master of Financial Engineering (MFE) programs, and many more. He is among the world's best-selling programming-language textbook, professional book, video and interactive multimedia authors. Paul has taught Python, Python Data Science, Java and C++ live-training courses to tens of thousands of students worldwide on O'Reilly Online Learning and to millions more via his books and videos.

Skill Level: Beginner-to-Intermediate

Part I — What You Will Learn

• [Updated] Before You Begin—Configure your system for Python 3.13, obtain the code examples, Python package managers, creating a custom Python environment, Paul's contact info.
• [Updated] Lesson 1—Test-Drives: Using IPython and Jupyter Notebooks—Work with snippets and scripts in the context of IPython and Jupyter Notebooks.
• [Updated] Lesson 2—Intro to Python Programming—Variables, types, operators, strings, I/O, decisions, intro to objects and dynamic typing. Objects-natural case study on working with string objects.
• [Updated] Lesson 3—Control Statements—if, if…else, if…elif…else, match…case, for, while, break, continue, augmented assignments, boolean operators, intro to lists. Objects-natural case study on financial calculations with Decimal.
• [Updated] Lesson 4—Functions—Custom function definitions, importing libraries, simulation with random-number generation, match…case with multiple values per case, defining named constants with Enum, scope, default parameter values, keyword arguments, arbitrary argument lists, methods, intro to tuples, intro to functional-style programming. Objects-natural case study on working with dates and times.

Part II — What You Will Learn

• [Updated] Lesson 5—Sequences: Lists and Tuples—Create, initialize and access the elements of lists and tuples; sort and search lists, search tuples; pass lists and tuples to functions and methods; methods of the list collection; pattern-matching in match…case; functional-style programming (lambdas, filter, map, reduce, list comprehensions, generator expressions); 2D lists; object-natural case study on static visualization with the Matplotlib visualization library.
• [Updated] Lesson 6—Dictionaries and Sets—Dictionaries of key–value pairs; sets of unique values; iterating through keys, values and key–value pairs; adding, removing and updating key–value pairs; keyword-only parameters; arbitrary keyword arguments; dictionary and set comparison operators; set operators and methods; operators in and not in for membership testing; mutable set operations; dictionary and set comprehensions; object-natural case study on dynamic visualization with the Matplotlib visualization library.
• [Updated] Lesson 7—Array-Oriented Programming with NumPy—numpy module's high-performance ndarrays; how ndarrays differ from lists; comparing list vs. ndarray performance with the IPython %timeit magic; one-dimensional and multidimensional ndarrays; common ndarray manipulations; object-natural case study introducing the pandas data manipulation library; one-dimensional pandas Series and two-dimensional pandas DataFrames; custom Series and DataFrame indices; basic descriptive statistics for data in a Series and a DataFrame; customizing pandas output formatting.

Part III — What You Will Learn

• [Updated] Lesson 8—Strings: A Deeper Look—String methods; string formatting; concatenating and repeating strings; stripping whitespace; string comparisons; searching strings for substrings and replacing substrings; tokenizing strings; regular expressions for pattern matching, replacing substrings and validating data; object-natural case study on manipulating data in pandas.
• [Updated] Lesson 9—Files and Exceptions—Text-file processing, serializing objects into JSON with the json module, invoking a web service with the requests library and getting a JSON response, with statement for avoiding "resource leaks," exception handling, try…except statement, else clause, executing code when no exceptions occur in a try suite, finally clause, raise exceptions, more details on tracebacks, stack unwinding, object-natural case study on CSV-file processing via the csv module, and loading and manipulating CSV files in pandas.
• Lesson 10—Object-Oriented Programming—Custom classes, controlling access to attributes, properties for data access, simulating "private" attributes, Python special methods for customizing string representations, inheritance, duck typing, polymorphism, class object, Python special methods for overloading operators, named tuples, data classes, unit testing with doctest, namespaces, scope, intro to time series and simple linear regression.
• [NEW] What's New in Python—Includes:
  • f-string improvements for string delimiters in format placeholders
  • Multiple selection with match...case
  • Assignment expressions (:= "walrus" operator)
  • Statistics function mode update and multimode
  • Pattern matching with match...case
  • Positional-only parameters
  • Enums for creating named constants
  • Comprehension inlining for better performance
  • Starred unpacking expressions in for statements
  • Optional length-checking for zip
  • Self-documenting f-strings
  • Dictionary union operators
  • Keyword-only parameters and arbitrary keyword arguments (**kwargs)
  • Removing string prefixes and suffixes
  • Named Unicode characters in regular expressions
  • Adding notes to exceptions; exception groups and except*
  • Type annotations for **kwargs
  • @override decorator for overridden methods in subclasses
  • Type union operator for type hints
  • Built-in collection types in type hints
  Note: This lesson's examples will be merged into Lessons 3-10 in the Second Edition, then this lesson will be removed.

Part IV — What You Will Learn

• Lesson 11—Natural Language Processing (NLP)—Install and use the TextBlob, NLTK, Textatistic and spaCy NLP libraries; tokenize text into words and sentences; parts-of-speech tagging (noun, verb, etc.); sentiment analysis (positive, negative or neutral); detect the language of text; translate between languages; get word roots via stemming and lemmatization; spell checking and correction; word definitions, synonyms and antonyms; removing stop words from text; creating word-cloud visualizations; determining text readability.
• Lesson 12—Data Mining Twitter®—Note: X (formerly Twitter) eliminated the free-tier services that educational products like ours need for academic and professional audiences. We will replace this lesson in the new edition.
• Lesson 13—IBM Watson® and Cognitive Computing—This lesson will be replaced with a lesson on Python API-Based Generative AI Programming.

Part V — What You Will Learn

• Lesson 14—Machine Learning: Classification, Regression and Clustering—Use the scikit-learn library with popular datasets to perform machine-learning studies; use Seaborn and Matplotlib to visualize and explore data; perform supervised machine learning with k-nearest neighbors classification and linear regression; perform multi-classification with the Digits dataset; divide a dataset into training, testing and validation sets; tune hyperparameters with k-fold cross-validation; measure model performance; display a confusion matrix showing classification prediction hits and misses; perform multiple linear regression with the California Housing dataset; perform dimensionality reduction with PCA and t-SNE on the Iris and Digits datasets to prepare them for two-dimensional visualizations; perform unsupervised machine learning with k-means clustering and the Iris dataset.
• Lesson 15—Deep Learning—What neural networks are and how they enable deep learning; create Keras neural networks; Keras layers, activation functions, loss functions and optimizers; use a Keras convolutional neural network (CNN) trained on the MNIST dataset to build a computer vision application that recognizes handwritten digits; use a Keras recurrent neural network (RNN) trained on the IMDb dataset to create a sentiment analysis application that performs binary classification of positive and negative movie reviews.
• Lesson 16—Big Data: Hadoop, Spark, NoSQL (MongoDB) and IoT—Note: See Lesson 12's note about Twitter/X eliminating their free-tier APIs, which affects this lesson's NoSQL and Spark examples. We'll replace uses of the Twitter/X API with the Instagram Threads API. Topics include: manipulate a SQLite relational database using SQL; understand the four major types of NoSQL databases; store tweets in a MongoDB NoSQL JSON document database and visualize them on a Folium map; Apache Hadoop and how it's used in big-data batch-processing applications; build a Hadoop MapReduce application on Microsoft's Azure HDInsight cloud service; Apache Spark and how it's used in high-performance, real-time big-data applications; process mini-batches of data with Spark streaming; Internet of Things (IoT) and the publish/subscribe model; publish messages from a simulated Internet-connected device and visualize messages in a dashboard; subscribe to PubNub's sample live streams and visualize the data.
• [NEW LESSON] OpenAI's Python APIs, Agents SDK and Codex App—In the context of live-code examples in Jupyter Notebooks, you'll build generative AI and agentic applications using the OpenAI Python SDK, the OpenAI Agents SDK, and the Codex App. Topics include:
  • Create an OpenAI account and get an API key
  • Set up Python, JupyterLab and the course environment
  • Build Python apps using the OpenAI GenAI APIs and the official openai module
  • Generate and stream text responses
  • Summarize and extract key points from text
  • Analyze text sentiment
  • Get detailed, accessible descriptions of images using vision capabilities
  • Translate text among natural languages
  • Perform named-entity recognition (NER) and process structured JSON and Pydantic outputs
  • Transcribe speech to text and synthesize speech from text
  • Generate original images, edit images with prompts, and perform image-to-image style transfer
  • Create closed captions from video audio
  • Moderate text and image content
  • Generate, explain, refactor, test and optimize code with Codex models
  • Build agents with the OpenAI Agents SDK
  • Define agents with clear instructions, models and tool access
  • Run agents and display Markdown responses
  • Preserve conversation state across turns
  • Stream agent responses and inspect agent events
  • Add model-backed input guardrails and understand when to use output and tool guardrails
  • Create custom tools with @function_tool
  • Build agents that call tools, search the web, analyze files, generate images, execute code, query databases through Model Context Protocol (MCP), use hosted MCP services, and automate a web browser via agentic computer-use capabilities
  • Build a multi-agent system with a triage agent, specialist agents, and handoffs
  • Use tracing to inspect agent runs, tool calls, handoffs and guardrail behavior
  • Use the Codex App for vibe coding and agentic engineering as your coding partner for real Python development workflows