Learning Path: The Road to Tensorflow

Mastering Python 37 lectures 02:55:17 Mastering Python - The Course Overview Get a high-level view of what this course will do for you.

• A quick overview of each section
• A preview of the results

Downloading and Installing Python Get a functional Python development environment.

• Picking up a suitable version for working
• Setting up the environment variables
• Making sure everything works as expected

Using the Command Line and the Interactive Shell Learn how to perform quick experiments and access documentation.

• Getting to know the operating system prompt
• Accessing the Python prompt
• Accessing the documentation with the help function

Installing Packages with pip Learn how to easily download and install third-party packages.

• Running through the basic usage of packages
• Installing packages in the home directory
• Managing and removing installed packages

Finding Packages in the Python Package Index Discover available resources so that you don't have to reinvent the wheel.

• Using the web interface
• Using pip's search command
• About licenses and legalities

Creating an Empty Package Learn the filesystem structure that defines a Python package.

• Creating the package folder
• Creating the __init__.py file
• Importing the new package

Adding Modules to the Package Add code files to the package.

• Selecting filenames
• The namespace packages
• Package structure versus package API

Importing One of the Package's Modules from Another Combine code from multiple modules.

• Importing the syntax
• Dealing with import cycles
• Differences between Python 2 and Python 3

Adding Data Files to the Package Include data alongside the modules in your package.

• Where to store the files
• Using the pkgutil.get_data command
• Transforming the data into text

PEP 8 and Writing Readable Code Make your code more readable for yourself and others using Python's communal coding standard.

• Spaces versus tabs
• Understanding the code layout
• Using naming conventions to perfection

Using Version Control Manage changes, versions, and branches in your source code.

• Undoing changes you've made to the code
• Working with branches
• Understanding merging

Using venv to Create a Stable and Isolated Work Area Create a development area that remains stable for the duration of your development process.

• Advantages of development in a virtual environment
• Setting up a virtual environment
• Activating and using a virtual environment

Getting the Most Out of docstrings Part 1 – PEP 257 and Sphinx Format your docstrings to maximize their usefulness.

• Understanding the basic layout
• Using the reStructuredText command
• Exporting documentation to HTML

Getting the Most Out of docstrings Part 2 – doctest Run the examples in your docstrings as tests.

• Benefits of executing examples from docstrings
• How to write the examples
• How to run the examples

Making a Package Executable via python – m Create a package entry point to make the package executable.

• Using __main__.py
• Using if __name__ == '__main__'
• An interactive software pipeline – the first step

Handling Command-line Arguments with argparse Create full-featured command-line parsers.

• Understanding the basic usage of the command line arguments
• Adding command line switches and arguments
• An interactive software pipeline – the second step

Text-mode Interactivity Get the input and provide the output while the program is running.

• Using the print(), input(), getpass, and pprint commands
• Using the cmd module
• An interactive software pipeline – the third step

Executing Other Programs Execute and interact with other programs.

• Using the call(), check_call(), and check_output() functions
• Understanding the Popen class
• An interactive software pipeline – the fourth step

Using Shell Scripts or Batch Files to Launch Programs Reduce the effort needed to run executable packages.

• Launching via shell script
• Launching via a batch file
• An interactive software pipeline – the last step

Using concurrent.futures Use a high-level interface to distribute computational tasks to worker processes and collect the results.

• Understanding the strengths and weaknesses of multiprocess computation in Python
• Using the ProcessPoolExecutor and Future objects
• Using the wait and as_completed functions

Using Multiprocessing Use a mid-level interface to create cooperative parallel processes.

• Launching processes
• Sending data between processes
• Keeping processes synchronized

Understanding Why Asynchronous I/O Isn't Like Parallel Processing The API looks a lot like concurrent.futures, but it's doing something very different.

• What cooperative multitasking is
• What yield from means
• What all this means for I/O bound programs

Using the asyncio Event Loop and Coroutine Scheduler How to get the asyncio scheduler running and add asynchronous tasks.

• Creating coroutines
• Creating an event loop, adding tasks, running the loop, and shutting it down
• Checking out an example skeleton by running several tasks until you decides to end the program

Futures How asyncio futures behave and what to do with them.

• Learning the normal usage pattern
• Understanding iteration, coroutines, and Futures
• Coroutines versus functions that return Futures

Making Asynchronous Tasks Interoperate How to use synchronization, waiting, and communication channels.

• What Lock and Semaphore is
• Using the as_completed, gather, wait, and wait_for functions
• Learning the use of Queue, LifoQueue, PriorityQueue, and JoinableQueue

Communicating across the Network Easily use stream sockets to communicate.

• Creating a client-side connection
• Creating a server-side connection
• Running an example ping-pong client and server

Using Function Decorators Automatically post-process functions.

• Adding attributes to a function
• Wrapping a function
• Knowing more about decorators that accept parameters

Using Function Annotations Add new semantics to functions.

• Adding annotations to a function
• How to access the annotations
• Using annotations in decorators

Using Class Decorators Automatically post-process classes.

• Manipulating a class
• Wrapping a class
• Using a class as declarative data

Using Metaclasses Change what it means to be a class.

• Classes that are not instances of “type”
• Altering the class's namespace
• Inheritable special behavior

Using Context Managers Set up special rules for regions of code.

• Running code when execution enters and leaves a block
• Using the @contextlib.contextmanager decorator
• Writing context managers as classes

Using Descriptors Control what happens when attributes are accessed.

• Running code when an attribute is accessed
• Using @property
• Writing descriptors as classes

Understanding the Principles of Unit Testing Get more benefits out of testing with less work.

• Letting the computer do the work
• Keeping tests localized
• Letting the tests tell us what we need to work on

Using unittest Write tests, run them, and understand the results.

• Running some basic tests
• Using the assertion methods
• Checking out the test fixtures

Using unittest.mock Use mock objects to keep tests local.

• Simple mock objects
• Checking for proper behavior
• Using patch

Using unittest's Test Discovery Run tests even more easily with test discovery.

• Letting unittest find the tests
• Controlling how tests are found
• Modules are imported when they are searched for tests

Using Nose for Unified Test Discovery and Reporting Take advantage of more complete test discovery and integrated reporting.

• Letting Nose find even more tests
• Code coverage
• Running tests in multiple processes

Mastering Python. 37 lectures 02:55:17 Mastering Python - The Course Overview Get a high-level view of what this course will do for you.

• A quick overview of each section
• A preview of the results

Downloading and Installing Python Get a functional Python development environment.

• Picking up a suitable version for working
• Setting up the environment variables
• Making sure everything works as expected

Using the Command Line and the Interactive Shell Learn how to perform quick experiments and access documentation.

• Getting to know the operating system prompt
• Accessing the Python prompt
• Accessing the documentation with the help function

Installing Packages with pip Learn how to easily download and install third-party packages.

• Running through the basic usage of packages
• Installing packages in the home directory
• Managing and removing installed packages

Finding Packages in the Python Package Index Discover available resources so that you don't have to reinvent the wheel.

• Using the web interface
• Using pip's search command
• About licenses and legalities

Creating an Empty Package Learn the filesystem structure that defines a Python package.

• Creating the package folder
• Creating the __init__.py file
• Importing the new package

Adding Modules to the Package Add code files to the package.

• Selecting filenames
• The namespace packages
• Package structure versus package API

Importing One of the Package's Modules from Another Combine code from multiple modules.

• Importing the syntax
• Dealing with import cycles
• Differences between Python 2 and Python 3

Adding Data Files to the Package Include data alongside the modules in your package.

• Where to store the files
• Using the pkgutil.get_data command
• Transforming the data into text

PEP 8 and Writing Readable Code Make your code more readable for yourself and others using Python's communal coding standard.

• Spaces versus tabs
• Understanding the code layout
• Using naming conventions to perfection

Using Version Control Manage changes, versions, and branches in your source code.

• Undoing changes you've made to the code
• Working with branches
• Understanding merging

Using venv to Create a Stable and Isolated Work Area Create a development area that remains stable for the duration of your development process.

• Advantages of development in a virtual environment
• Setting up a virtual environment
• Activating and using a virtual environment

Getting the Most Out of docstrings Part 1 – PEP 257 and Sphinx Format your docstrings to maximize their usefulness.

• Understanding the basic layout
• Using the reStructuredText command
• Exporting documentation to HTML

Getting the Most Out of docstrings Part 2 – doctest Run the examples in your docstrings as tests.

• Benefits of executing examples from docstrings
• How to write the examples
• How to run the examples

Making a Package Executable via python – m Create a package entry point to make the package executable.

• Using __main__.py
• Using if __name__ == '__main__'
• An interactive software pipeline – the first step

Handling Command-line Arguments with argparse Create full-featured command-line parsers.

• Understanding the basic usage of the command line arguments
• Adding command line switches and arguments
• An interactive software pipeline – the second step

Text-mode Interactivity Get the input and provide the output while the program is running.

• Using the print(), input(), getpass, and pprint commands
• Using the cmd module
• An interactive software pipeline – the third step

Executing Other Programs Execute and interact with other programs.

• Using the call(), check_call(), and check_output() functions
• Understanding the Popen class
• An interactive software pipeline – the fourth step

Using Shell Scripts or Batch Files to Launch Programs Reduce the effort needed to run executable packages.

• Launching via shell script
• Launching via a batch file
• An interactive software pipeline – the last step

Using concurrent.futures Use a high-level interface to distribute computational tasks to worker processes and collect the results d and install third-party...