Python Programming Language

Video description

6+ Hours of Video Instruction

Python Programming Language LiveLessons provides developers with a guided tour of the Python programming language, including an introduction to many of the advanced techniques used in libraries and frameworks.


In this video training, David Beazley covers the essential features of Python programming through a series of practical programming examples. David assumes you are a programmer, familiar with central programming concepts such as control flow, functions, and data structures. The course provides programmers with an accelerated introduction to the essential parts of Python. Those with some previous Python experience will benefit from being exposed to modern Python style and programming idioms used by experienced programmers. Each lesson covers a “big idea” rather than taking an exhaustive, reference-style approach. In each lesson David addresses a specific, practical problem and demonstrates the solution through code. He explains the steps taken and why he is taking a particular approach.

About the Instructor

David Beazley is an independent software developer, teacher, and book author living in the city of Chicago. He primarily works on programming tools and teaches programming courses for software developers, scientists, and engineers. He is the author of the Python Essential Reference (Addison-Wesley) and Python Cookbook, 3rd Ed. (O'Reilly Media). He has also created several open-source packages including Swig, PLY, and Curio. He is a frequent speaker at PyCon. Although Python is his current language of choice, he also has significant experience with systems programming in C, C++, and assembly language.

Skill Level

  • Intermediate
  • Advanced
What You Will Learn
  • Python program structure and execution model
  • How to read and write data from files
  • How to effectively manipulate data using tuples, lists, sets, and dictionaries
  • How to define new functions
  • How to handle exceptions and errors
  • How to create new objects with classes
  • Essential object-oriented programming techniques
  • Customization of objects with special methods, properties, and descriptors
  • Metaprogramming features including decorators, class decorators, and metaclasses
  • Iterative data processing with generator functions
  • Placing code into modules and packages
  • How to use higher-order functions and closures
  • An introduction to coroutines and asynchronous I/O handling
Who Should Take This Course
  • Experienced programmers looking for a practical introduction to Python and current Python programmers interested in learning new techniques and ways of thinking about problems.
Course Requirements
  • Basic understanding of programming concepts, algorithms, and development tools
Lesson 1: Working Environment

Lesson 1 introduces the basics of working in the Python programming environment. This includes starting and stopping the interpreter, using the interactive console, editing and running programs, and turning simple programs into useful scripts. Getting help and some basic debugging tips are also described.

Lesson 2: Program Structure and Execution Model

Lesson 2 covers Python’s execution model and describes the statements related to variables, expressions, and simple control flow. It also covers using Python to perform simple mathematical calculations, making formatted output, and writing to a file.

Lesson 3: Text Processing and Files

To do almost anything useful, you need to be able to read data into your program. Lesson 3 addresses the problem of reading data from a file, basic techniques for manipulating text strings, converting input data, and performing calculations. It also introduces the csv module for reading data from CSV files.

Lesson 4: Functions and Error Handling

As you write larger programs, you will want to get organized. The primary way of doing this in Python is to write functions. And if you write functions, you will want them to play nicely with others. Lesson 4 addresses the problem of writing function definitions, handling exceptions, and coding practices that will help you when you start to write larger programs.

Lesson 5: Data Structures and Data Manipulation

One of the most critical Python skills to develop is being able to effectively use lists, tuples, sets, and dictionaries. Lesson 5 includes how to read a file into a useful data structure. It then explores different ways of performing calculations on the data, including data reductions, filtering, joining, and sorting. Particular attention is given to list, set, and dict comprehensions a feature that greatly simplifies a wide variety of data processing tasks.

Lesson 6: Library Functions and Import

As you write larger Python programs, you will want to write library functions and split your code across multiple files. To do this, you need to start working with modules and packages. Lesson 6 delves into creating and using modules. It starts with how to use the import statement and some of its gotchas. Next it covers how to create a general purpose CSV parsing function and apply it to some of our earlier code. The lesson concludes with a discussion of organizing larger code bases into packages.

Lesson 7: Classes and Objects

Object-oriented programming is a fundamental part of the Python language. You see this whenever you use its built-in types and execute methods on the resulting instances. If you want to make your own objects, you can do so using the class statement. A class is often a convenient way to define a data structure and to attach methods that carry out operations on the data. Lesson 7 covers the basics of defining a new object, creating instances, and manipulating objects. It then helps you see how the dynamic nature of Python enables you to write highly generic functions. The Lesson concludes with a special topic on how to write classes that need to have more than one initializer method.

Lesson 8: Inheritance

One of the most challenging problems in writing larger programs is that of code reuse and extensibility. A common tool used to address this problem is inheritance. Lesson 8 addresses using inheritance to make a program extensible as well as some of the tricky practical concerns that might arise as a result. Some advanced inheritance concepts, such as multiple inheritance with mixin classes and abstract base classes, are also introduced. The lesson concludes by discussing a few important design considerations to take into account if you’re going to use inheritance.

Lesson 9: Python Magic Methods (a.k.a., Speaking Python)

When defining new objects, it is usually beneficial to make your objects play nicely with other parts of Python. This is typically done by adding special or "magic" methods to your class. Lesson 9 demonstrates some of the common customizations that are made to objects to simplify debugging, create containers, and manage resources. Although this section doesn’t cover every possible customization that can be carried out, it gives you a taste of what’s possible and a foundation for more exploration.

Lesson 10: Encapsulation (Owning the Dot)

Major issues that arise in larger programs are how to encapsulate internal implementation details and how to have more control over the ways in which developers interact with objects. Lesson 10 dives into some of the low-level details that make the Python object system tick. It then turns to techniques for taking control over attribute access and custom-tailoring the environment to address issues such as data validation, type checking, and more. Topics include defining private attributes, properties, descriptors, and redefining magic methods for attribute access.

Lesson 11: Higher Order Functions and Closures

Functions are the basic organizational unit of all Python programs regardless of whether or not they serve as a stand-alone function or the method of a class. Lesson 11 introduces some important functional programming concepts, including the idea of functions as first class objects, passing functions as data, and creating functions as results. Particular emphasis is placed on closures as a tool for generating and simplifying code.

Lesson 12: Metaprogramming and Decorators

One of the most difficult problems in developing larger programs is dealing with highly repetitive code. For example, as a general rule you want to avoid situations where you’re cutting and pasting common code fragments between functions or across files. Restructuring the design of your program might help solve such problems. However, another common technique is to encapsulate common code-oriented tasks into a decorator. Lesson 12 covers how to write decorators for processing both function and class definitions.

Lesson 13: Metaclasses

One of the problems faced by the creators of large applications and frameworks is exercising control over the greater programming environment. Code is often organized using classes, but sometimes there is much more to it than simply making class definitions. For example, classes might need to register their existence with some other part of a framework. Or perhaps the definition of a class is too verbose and needs to be simplified in some way. Or perhaps some other aspect of classes needs to be managed. An advanced technique for addressing these problems is to use a metaclass. Lesson 13 introduces the metaclass concept and some practical applications are shown.

Lesson 14: Iterators and Generators

One of Python’s most useful features is the for-statement, which is used to iterate over data. As you may have noticed, the for-statement works with a wide variety of objects such as lists, dicts, sets, and files. It’s also used in a variety of related features, such as list comprehensions. One of the most powerful features of iteration is that it can be easily customized. Lesson 14 starts with the iteration protocol and how to customize it using generator functions. It also covers how to apply iteration to data processing pipelines a particularly powerful technique for working with data and problems involving workflows.

Lesson 15: Coroutines

Starting in Python 3.5, a special kind of function known as a "coroutine" could be defined using special async/await syntax. On the surface, coroutines look a lot like normal Python functions. However, under the covers they run under the supervision of a manager that coordinates their execution. Lesson 15 introduces coroutines and shows how they can be used to implement a simple network service that can handle thousands of concurrent client connections. It concludes by peeling back some of the covers to see how coroutines actually work and to explore their relationship to generators.

About LiveLessons Video Training

The LiveLessons Video Training series publishes hundreds of hands-on, expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. This professional and personal technology video series features world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, IBM Press, Pearson IT Certification, Prentice Hall, Sams, and Que. Topics include: IT Certification, Programming, Web Development, Mobile Development, Home and Office Technologies, Business and Management, and more. View all LiveLessons on InformIT at:

Table of contents

  1. Introduction
    1. Python Programming Language: Introduction 00:02:52
  2. Lesson 1: Working Environment
    1. Topics 00:00:25
    2. 1.1 Starting, Stopping, and Typing Commands into the Interactive Interpreter 00:04:25
    3. 1.2 Project: Catching the Bus 00:04:55
    4. 1.3 Project: Reading Command Line Arguments and Making a Script 00:03:59
    5. 1.4 Debugging 00:05:34
  3. Lesson 2: Program Structure and Execution Model
    1. Topics 00:00:22
    2. 2.1 Project: Mortgage Calculator 00:07:39
    3. 2.2 Project: Formatted Output and File I/O 00:05:43
  4. Lesson 3: Text Processing and Files
    1. Topics 00:00:26
    2. 3.1 File and String Basics 00:06:59
    3. 3.2 Project: Reading from a File and Performing a Calculation 00:04:39
    4. 3.3 Project: Using the CSV Module to Read Data 00:04:28
  5. Lesson 4: Functions and Error Handling
    1. Topics 00:00:27
    2. 4.1 Defining and Using Simple Functions 00:02:50
    3. 4.2 Project: Moving a Script into a Function 00:03:36
    4. 4.3 Project: Handling Bad Data and Exception Handling 00:07:03
    5. 4.4 Project: Function Design Considerations 00:10:43
  6. Lesson 5: Data Structures and Data Manipulation
    1. Topics 00:00:34
    2. 5.1 Basic Material: Tuples, Lists, Sets, and Dicts 00:06:33
    3. 5.2 Project: Building a Data Structure from a File 00:08:45
    4. 5.3 Data Manipulation 00:13:18
    5. 5.4 Example: Sorting and Grouping 00:06:53
  7. Lesson 6: Library Functions and Import
    1. Topics 00:00:37
    2. 6.1 Module Basics 00:11:22
    3. 6.2 Project: Writing a General Purpose CSV Parsing Module 00:08:02
    4. 6.3 Making a Package 00:08:54
  8. Lesson 7: Classes and Objects
    1. Topics 00:00:46
    2. 7.1 Introduction: From Simple Data Structures to Classes 00:06:25
    3. 7.2 Understanding Attribute Access 00:08:06
    4. 7.3 Advanced: Class Methods and Alternate Constructors 00:07:09
  9. Lesson 8: Inheritance
    1. Topics 00:00:41
    2. 8.1 Inheritance Concepts 00:06:58
    3. 8.2 Inheritance in Practice: Building an Extensible Library 00:08:21
    4. 8.3 Advanced Inheritance 00:09:24
    5. 8.4 Designing for Inheritance 00:05:22
    6. 8.5 Defensive Programming with Abstract Base Classes 00:04:33
    7. 8.6 Advanced: How Inheritance Actually Works 00:05:47
  10. Lesson 9: Python Magic Methods (a.k.a., Speaking Python)
    1. Topics 00:00:36
    2. 9.1 Background: Use of Magic Methods to Implement Operators 00:02:15
    3. 9.2 Making Objects Printable and Debuggable 00:03:55
    4. 9.3 Making a Custom Container Object 00:07:18
    5. 9.4 Making a Custom Context Manager 00:05:35
  11. Lesson 10:Encapsulation (Owning the Dot)
    1. Topics 00:00:42
    2. 10.1 Instance Representation, Attribute Access and Naming Conventions 00:05:31
    3. 10.2 Managed Attributes with Properties 00:10:10
    4. 10.3 Managed Attributes with Descriptors 00:12:17
    5. 10.4 Object Wrappers and Proxies 00:09:13
  12. Lesson 11: Higher Order Functions and Closures
    1. Topics 00:00:33
    2. 11.1 Functions as Objects 00:07:06
    3. 11.2 Generating Code with Closures 00:06:49
  13. Lesson 12: Metaprogramming and Decorators
    1. Topics 00:00:38
    2. 12.1 Background: Function Argument Passing and Calling Conventions 00:04:03
    3. 12.2 Don't Repeat Yourself—Introducing Decorators 00:09:45
    4. 12.3 Decorators with Arguments 00:07:03
    5. 12.4 Class Decorators 00:10:57
  14. Lesson 13: Metaclasses
    1. Topics 00:00:47
    2. 13.1 Background: Types and Metaclasses Introduced 00:09:20
    3. 13.2 Project: Tracking Subclasses in a Framework 00:09:51
    4. 13.3 Project: Filling in Missing Details and Code Generation 00:07:15
  15. Lesson 14: Iterators and Generators
    1. Topics 00:00:45
    2. 14.1 Iteration Protocol and Customization via Generators 00:08:40
    3. 14.2 Project: Watching a Real-Time Data Source with a Generator 00:06:42
    4. 14.3 Processing Pipelines and Workflows 00:06:51
  16. Lesson 15: Coroutines
    1. Topics 00:00:46
    2. 15.1 Defining and Calling Coroutines with async/await 00:03:40
    3. 15.2 Project: Asynchronous Echo Server with Coroutines and asyncio 00:08:46
    4. 15.3 Under the Covers: Enhanced Generators 00:12:15
  17. Summary
    1. Python Programming Language: Summary 00:01:39

Product information

  • Title: Python Programming Language
  • Author(s): David Beazley
  • Release date: August 2016
  • Publisher(s): Addison-Wesley Professional
  • ISBN: 0134217314