Learning Path: Python: Programming for Python Users

Course Curriculum

Chapter 1: Modern Python Solutions Part 1

Lecture 1: The Course Overview

Lecture 2: Creating Meaningful Names and Using Variables

Lecture 3: Working with Large and Small Integers

Lecture 4: Choosing between Float, Decimal, and Fraction

Lecture 5: Choosing between True Division and Floor Division

Lecture 6: Rewriting an Immutable String

Lecture 7: String Parsing with Regular Expressions

Lecture 8: Building Complex Strings with “template”.format()

Lecture 9: Building Complex Strings from Lists of Characters

Lecture 10: Using the Unicode Characters that aren't on Our Keyboards

Lecture 11: Encoding Strings-Creating ASCII and UTF8 Bytes

Lecture 12: Decoding Bytes, How to Get Proper Characters from Some Bytes

Lecture 13: Using Tuples of Items

Lecture 14: Writing Python Script and Module Files

Lecture 15: Writing Long Lines of Code

Lecture 16: Including Descriptions and Documentation

Lecture 17: Writing Better RST Markup in docstring

Lecture 18: Designing Complex if…elif Chains

Lecture 19: Designing a While Statement that Terminates Properly

Lecture 20: Avoiding a Potential Problem with Break Statements

Lecture 21: Leveraging the Exception Matching Rules

Lecture 22: Avoiding a Potential Problem With an Except:Clause

Lecture 23: Chaining Exceptions with the Raise from Statement

Lecture 24: Managing a Context Using the With Statement

Lecture 25: Designing Functions with Optional Parameters

Lecture 26: Using Super Flexible Keyword Parameter

Lecture 27: Forcing Keyword-only Argument with the * Separator

Lecture 28: Writing Explicit Types on Function Parameters

Lecture 29: Picking an Order for Parameters Based on Partial Functions

Lecture 30: Writing Clear Documentation Strings

Lecture 31: Designing Recursive Functions Around Python’s Stack Limit

Lecture 32: Writing Reusable Script with the Script Library Switch

Lecture 33: Choosing a Data Structure

Lecture 34: Building Lists – Literals, Appending, and Comprehensions

Lecture 35: Slicing and Dicing a Lsit

Lecture 36: Deleting From a List

Lecture 37: Reversing a Copy of a List

Lecture 38: Using Set Methods and Operators

Lecture 39: Removing Items from a Set

Lecture 40: Creating Dictionaries

Lecture 41: Removing from Dictionaries

Lecture 42: Controlling the Order of the Dict Keys

Lecture 43: Handling Dictionaries and Sets in doctest Examples

Lecture 44: Understanding Variables, References, and Assignment

Lecture 45: Making Shallow and Deep Copies of Objects

Lecture 46: Avoiding Mutable Default Values for Function Parameters

Lecture 47: Using Features of the print() Functions

Lecture 48: Using input() and getpass() for User Input

Lecture 49: Debugging with “Format”.Format_Map(Vars())

Lecture 50: Using Argparse to Get Command-line Input

Lecture 51: Using CMD for Creating Command-line Applications

Lecture 52: Using the OS Environment Settings

Chapter 2: Python Parallel Programming Solutions

Lecture 1: The Parallel Computing Memory Architecture

Lecture 2: Memory Organization

Lecture 3: Memory Organization (Continued)

Lecture 4: Parallel Programming Models

Lecture 5: Designing a Parallel Program

Lecture 6: Evaluating the Performance of a Parallel Program

Lecture 7: Introducing Python

Lecture 8: Working with Processes in Python

Lecture 9: Working with Threads in Python

Lecture 10: Defining a Thread

Lecture 11: Determining the Current Thread

Lecture 12: Using a Thread in a Subclass

Lecture 13: Thread Synchronization with Lock

Lecture 14: Thread Synchronization with RLock

Lecture 15: Thread Synchronization with Semaphores

Lecture 16: Thread Synchronization with a Condition

Lecture 17: Thread Synchronization with an Event

Lecture 18: Using the 'with' Statement

Lecture 19: Thread Communication Using a Queue

Lecture 20: Evaluating the Performance of Multithread Applications

Lecture 21: Spawning a Process

Lecture 22: Naming a Process

Lecture 23: Running a Process in the Background

Lecture 24: Killing a Process

Lecture 25: Using a Process in a Subclass

Lecture 26: Exchanging Objects between Processes

Lecture 27: Synchronizing Processes

Lecture 28: Managing a State between Processes

Lecture 29: Using a Process Pool

Lecture 30: Using the mpi4py Python Module

Lecture 31: Point-to-Point Communication

Lecture 32: Avoiding Deadlock Problems

Lecture 33: Using Broadcast for Collective Communication

Lecture 34: Using Scatter for Collective Communication

Lecture 35: Using Gather for Collective Communication

Lecture 36: Using Alltoall for Collective Communication

Lecture 37: The Reduction Operation

Lecture 38: Optimizing the Communication

Lecture 39: Using the concurrent.futures Python Modules

Lecture 40: Event Loop Management with Asyncio

Lecture 41: Handling Coroutines with Asyncio

Lecture 42: Manipulating a Task with Asyncio

Lecture 43: Dealing with Asyncio and Futures

Lecture 44: Using Celery to Distribute Tasks

Lecture 45: Creating a Task with Celery

Lecture 46: Scientific Computing with SCOOP