Learning Path: Deep Dive into Python Machine Learning

Mastering Python - Second Edition. 51 lectures 05:21:07 Mastering Python - Second Edition - The Course Overview This video provides an overview of the entire course. Python Basic Syntax and Block Structure The goal of this video is to provide a basic understanding of the Python language constructs.

• Understand basic grammar elements
• Understand functions and classes
• Explain the reasoning behind Python's differences from other languages

Built-in Data Structures and Comprehensions The goal of this video is to ensure we have the basic ability to operate with Python's most common data structures.

• Learn to create data structures
• Learn how the structures organize data
• Learn to use comprehensions to operate on all members of a data structure

First-Class Functions and Classes People used to lower-level languages are unfamiliar with First-class functions and classes; we'll take a look at them in this video.

• Define first-class objects
• Explain the implications of first-class functions
• Explain the implications of first-class classes

Extensive Standard Library Python comes with a lot of tools. We need to be familiar with them in order to make the best use of the language. That's the topic we will be covering in this video.

• Take a look at data structures and data storage
• Understand encoding and decoding formats
• Interact with low-level operating system services

New in Python 3.5 The goal of this video is to look at the overview of recent language changes in Python.

• Look at the syntax changes
• Understand the library additions
• Take a tour of the other changes

Downloading and Installing Python In this video, we are going to download and install the correct version of Python and make sure it's functional.

• Select the proper installer to download
• Install the Python runtime and libraries
• Test that everything is working correctly

Using the Command-Line and the Interactive Shell The fastest way to get rolling is to use a textual interface, so we need to make sure we know how to use it. That's the goal in this video

• Open a command window
• Run the Python iterative shell
• Practice evaluating Python expressions

Installing Packages with pip Python has good support for installing and managing third-party code packages; let's take a look at them in this video.

• Install packages
• Manage installed packages
• Search available packages

Finding Packages in the Python Package Index There's a lot of good code available. How do we find it? Let's take a look in this video.

• Understand keyword searches
• Know browsing categories
• Look at searching through Pip

Creating an Empty Package The goal of this video is to know how to create the structure of a Python program.

• Explore the relationship with filesystem directories
• Learn about __init__.py
• Try importing our new package

Adding Modules to the Package A package containing no code isn't of much use. How do we make it do something? Let's take a look at it in this video.

• Explore valid filenames for code modules
• Take a look at the contents of a code module
• Build up a programming interface from module parts

Importing One of the Package's Modules from Another The goal in this video is to understand how we can make code in separate modules of the package interact.

• Understand absolute imports
• Learn relative imports
• Check out how to avoid dependency cycles

Adding Static Data Files to the Package A complete program usually involves static data files along with the code. How do we integrate non-python files in a package? Let's find out!

• Understand where to put data files
• Use pkgutil.get_data
• Load text data

PEP 8 and Writing Readable Code The computer can read our code as long as the syntax is correct, but humans require more care. Let's see how we can write readable code in Python.

• Understand why tabs and spaces should not be mixed, and spaces are preferred
• Explain style conventions
• Explain naming conventions

Using Version Control If more than one programmer is working on a project, version control is a necessity. Even for a single programmer, version control is useful. We will take a look at it in this video.

• Initialize Git
• Use Git as an undo log
• Branch, merge, and pull

Using venv to Create a Stable and Isolated Work Area In this video, we will see how writing a program can take a while, and it's best that external changes to the development system do not impact the process.

• Set up a virtual environment
• Activate a virtual environment
• Install packages locally in a virtual environment

Getting the Most Out of docstrings 1: PEP 257 and docutils Properly formatted docstrings can be automatically used by IDEs and transformed into HTML. Let's take a peek into it in this video.

• Understand basic docstring structure
• Understand reStructuredText for rich formatting
• Take a look at the Sphinx documentation compiler

Getting the Most Out of docstrings 2: doctest The goal of this video is to understand why it's important that examples in the documentation stay consistent with the code.

• Understand how to write examples
• Learn how to check examples with doctest
• If the test fails, either the documentation is wrong or the code is; see how to rectify

Making a Package Executable via python -m Writing Python code packages is all well and good, but how to we make a program? We will take a look at it in this video.

• Understand what python-m means
• Take a look at the __main__ module
• Recognize when the program is being run and when it is being imported

Handling Command-Line Arguments with argparse It's useful to be able to read data from the program command line. The argparse package makes it easy. Let's see it in action in this video.

• Instantiate an argument parser object
• Configure a argument parser object
• Access the parsed data

Interacting with the User What do we do when we need information to flow both ways with the user?

• Get to know the basics of print() and input()
• Get introduced to the special cases: getpass and pprint
• Work on interactive interfaces with the cmd package

Executing Other Programs with Subprocess Running other programs from within a program is often useful, especially, for system automation. We'll look at how to do it.

• Know more about the subprocess.call function and its variants
• Get to know the subprocess.Popen class
• Communicate with a background process

Using Shell Scripts or Batch Files to Run Our Programs It's often useful to have a launcher file for a program, which can be double-clicked in a GUI or used a shorthand from the command line. A simple script or batch file does the trick, let's see how.

• Create a shell script for Mac or Unix/Linux
• Create a batch file for Windows
• Use shell scripts or batch files to launch Python programs

Using concurrent.futures Parallel processing has pitfalls, but Python's high-level parallel processing framework makes it easy to dodge them. Let's look at it in this video.

• Learn the map and submit operations
• Understand Futures
• Know what to avoid for efficient data transfer between processes

Using Multiprocessing When our program doesn't fit the conceptual model of concurrent.futures, we can use multiprocessing to define our own model. Let's see how.

• Get to know the Process class
• Learn inter-process communication
• Understand synchronization between processes

Understanding Why This Isn't Like Parallel Processing At first glance, Python's coroutine scheduling looks a lot like multiprocessing or multithreading. What's the difference? Let's get to know this better.

• See how coroutine scheduling operates in a single process
• Understand why coroutine scheduling has lower overhead per stream of execution
• Explore why coroutine scheduling is good for I/O bound programs, especially servers

Using the asyncio Event Loop and Coroutine Scheduler The goal of this video is to set up and run the asyncio asyncio coroutine scheduler

• Get the default scheduler
• Add coroutine tasks to the scheduler
• Run the scheduler to execute the tasks

Waiting for Data to Become Available In this video we will see how do we actually use asyncio's Future objects.

• Wait for Future to arrive and retrieve the value
• Check if Future has arrived, then retrieve the value
• Loop over a sequence of Future data

Synchronizing Multiple Tasks The goal of this video is to understand how to keep coroutines from jamming each other up and locking the program.

• Know the standard synchronization primitives
• Understand why synchronization is not always needed
• Use queues for inter-coroutine communication

Communicating Across the Network In this video, we will see how do asyncio's actual I/O facilities work

• Create a client
• Create a server
• Know when to stop serving a client

Using Function Decorators Functions are very useful, but it would be nice to be able to tweak them to suit our specific needs. Enter function decorators.

• Understand what is a decorator and what does it does
• Define a wrapper inside a decorator
• Understand parameterized decorators

Function Annotations If we're going to be using functions as data, it would be nice to have metadata for the functions too. Function annotations give us that.

• Add metadata about function parameters
• Add metadata about the function's return value
• Annotations as input to function decorators

Class Decorators Class objects are basically data structures, so it would be useful to be able to rewrite them as they're defined. Class decorators let us do that.

• Know that class decorators work just like function decorators
• Understand that classes are not functions, so the possibilities are different
• Rewrite classes as they're defined

Metaclasses Class decorators take effect after Python has created a class object. If we want our code involved before the class object is created, we need to use a metaclass.

• Understand that classes are objects, and these objects are instances of other classes
• Control class object creation
• Make custom handling inheritable

Context Managers Pieces of code often come in matched pairs, with one piece needing to run before something happens and the matching piece after. Context managers make sure the pieces match up.

• Context managers plug into the with statement
• Know the two ways to define a synchronous context manager
• Understand that asynchronous context managers are also an option

Descriptors We can plug code into Python's attribute access mechanism to control what it means to read, write, or delete a member variable.

• Use @property to create simple descriptors
• Write descriptors as classes
• Apply descriptors to simplify a complex I/O task

Understanding the Principles of Unit Testing Testing is critical, but it can feel like a burden. Automated unit testing and test-driven development can solve this problem.

• See how automated testing makes it quick and easy to run tests
• Understand why tests can motivate development rather than the other way around
• Check out that when we reduce the difficulty and increase the frequency, tests are more useful

Using the unittest Package The unittest package provides a framework for writing automatic tests; let's check it out.

• Learn how we structure a test file
• Know how to compare what happens to what should happen
• Learn we run our tests

Using unittest.mock We need to separate the code we're testing from everything else. When the code interacts with other objects, we can replace them with mock objects. Let's see how.

• Replace an object with a mock
• Make a mock object imitate the behavior of a real object.
• Check whether a mock object is a user

Using unittest's Test Discovery As a test suite grows, running the tests individually becomes impractical. We need the system to find and run them in large swaths.

• Too many tests in one file becomes a problem, so break it up
• See why running each test individually would be annoying
• Take a look at the test discovery tool that finds all the tests and runs them

Using Nose for Unified Test Discover and Reporting Sometimes we want a more flexible test runner than the one built in to unittest. Nose to the rescue.

• Run tests with Nose
• Get a code coverage report
• Run tests in parallel

What Does Reactive Programming Mean? For the newcomer, it can be difficult to figure out exactly what other people are talking about when they say "reactive programming".

• Publish/subscribe event handling
• Understand stateless functional composition
• Learn asynchronous execution

Building a Simple Reactive Programming Framework Many of the discussions of reactive programming are highly theoretical. Building a reactive programming system for ourselves will help show how simple the basic ideas are.

• Wiring Observable
• Write Observer
• Write a demo application

Using the Reactive Extensions for Python (RxPY) Creating a complete and correct reactive programming framework takes a lot of time and effort. Since somebody's already done it, let's take a look at the result.

• Install RxPY
• Translate our demo
• Learn more RxPY features

Microservices and the Advantages of Process Isolation We need our web server to scale up and maintain high availability. Let's see how we can do that...