Learning Path: Python: Guide to Become a Python Professional
5.0 (2 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
84 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learning Path: Python: Guide to Become a Python Professional to your Wishlist.

Add to Wishlist

Learning Path: Python: Guide to Become a Python Professional

A journey from being a novice to a professional Python developer
5.0 (2 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
84 students enrolled
Created by Packt Publishing
Last updated 7/2017
English
Curiosity Sale
Current price: $10 Original price: $200 Discount: 95% off
30-Day Money-Back Guarantee
Includes:
  • 19.5 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • See the intricate details of the Python syntax and how to use it to your advantage
  • Learn to manipulate data effectively using built-in data structures
  • Get acquainted with advanced programming techniques in Python
  • Equip yourself with functional and statistical programming features
  • Take advantage of Python's metaprogramming and programmable syntax features
  • Understand how to handle high I/O loads with asynchronous I/O to get a smoother performance
  • Get familiar with Python’s metaprogramming and programmable syntax features
  • Learn the concepts of reactive programming and RxPy
View Curriculum
Requirements
  • Basic programming knowledge is needed.
Description

If you are looking for a complete course on Python programming, then go for this Learning Path. Python is the preferred choice of developers, engineers, data scientists, and hobbyists everywhere. It is a great scripting language that can power your applications and provide speed, safety, and scalability.

We will begin this learning journey by understanding the basic concepts of Python such as statements and syntax along with using numbers, strings, and tuples. We will then explore various function definition techniques along with learning the basics of classes and objects.

Going ahead, we will understand the intermediate concepts such as functional and reactive programming in Python. We will also explore statistical programming and regression.

Next, you will uncover the advanced topics in Python, will learn to implement real-world test cases to your programs along with integrating different applications.

By the end of this Video Learning Path, you will become proficient in Python.   

About the Authors

Steven F. Lott has been programming since the 70s, when computers were large, expensive, and rare. As a contract software developer and architect, he has worked on hundreds of projects, from very small to very large. He's been using Python to solve business problems for over 10 years. He’s currently leveraging Python to implement microservices and ETL pipelines. His other titles with Packt Publishing include Python Essentials, Mastering Object-Oriented Python, Functional Python Programming, and Python for Secret Agents. Steven is currently a technomad who lives in various places on the east coast of the U.S.

Daniel Arbuckle gained his PhD in Computer Science from the University of Southern California. He has published numerous papers along with several books and video courses, and he is both a teacher of computer science and a professional programmer.

Who is the target audience?
  • This Learning Path is for web developers, programmers, enterprise programmers, engineers, big data scientist, and so on. If you are a beginner, Modern Python Recipes will get you started. If you are experienced, it will expand your knowledge base. A basic knowledge of programming would help.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
172 Lectures
19:43:52
+
Modern Python Solutions Part 1
52 Lectures 05:03:45
This video provides an overview of the entire course.
Preview 03:22

Choosing the correct name is essential to make our programs more readable and ease the process of designing software and applications. Complex names could lead to confusion. This video will guide you to select the appropriate names while designing an application.

Creating Meaningful Names and Using Variables
11:37

Many programming languages make a distinction between integers, bytes, and long integers. Some languages include distinctions for signed versus unsigned integers. How do we map these concepts to Python? This video will walk you through these concepts in detail.

Working with Large and Small Integers
08:02

Python offers us several ways to work with rational numbers and approximations of irrational numbers. We have three basic choices, which are Float, Decimal, and Fraction. With so many choices, when do we use each of these? This video will let you answer this question.

Choosing between Float, Decimal, and Fraction
12:55

This video will let you understand which division operator to use while converting numbers from one base to another

Choosing between True Division and Floor Division
05:23

How can we rewrite an immutable string? This video will answer this question and show you how to work with strings in Python.

Rewriting an Immutable String
08:56

The easiest way to decompose a complex string is by generalizing the string into a pattern and then writing a regular expression that describes that pattern.This video will let you know how to do it in a smart way!

String Parsing with Regular Expressions
06:14

Creating complex strings is, in many ways, the polar opposite of parsing a complex string. Let’s dive into building a complex string.

Building Complex Strings with “template”.format()
06:12

There’s another way of building complex strings, which is, from a list of characters. This video will walk you through the steps that let you build a complex string from a list of characters.

Building Complex Strings from Lists of Characters
04:44

Our Computers work a lot with Unicode, and sometimes, we are not aware how to use them. This video will let you know how to use Unicode and the internal operations on them.

Using the Unicode Characters that aren't on Our Keyboards
03:27

How do we map Unicode characters to bytes for writing to a file or transmitting? This video will show you, how to achieve this goal.
Encoding Strings-Creating ASCII and UTF8 Bytes
04:28

How can we work with files that aren't properly encoded? What do we do with files written in the ASCII encoding? How do we decode the characters from that stream of bytes? This video will answer all these queries.

Decoding Bytes, How to Get Proper Characters from Some Bytes
02:33

How can we keep things, which are pairs, such as latitude and longitude, together? Let’s see how to do this!
Using Tuples of Items
04:15

You need to write Python script files in order to do anything truly useful. How can we avoid syntax errors and be sure that our code matches what's in common use? This video will provide a resolution for these tasks.

Preview 07:48

There are many times when we need to write lines of code that are so long that they're very hard to read. How can we break long Python statements into more manageable pieces? Let’s explore this.

Writing Long Lines of Code
08:10

When we have a useful script, we often need to leave notes for ourselves and others, on what it does, how it solves some particular problem, and when it should be used. This video contains a suggested outline so that the documentation will be reasonably complete.

Including Descriptions and Documentation
05:02

When we have a useful script, we often need to leave notes on what it does, how it works, and when it should be used. Many tools for producing documentation, including Docutils, work with RST markup. What RST features can we use to make our documentation more readable? Let’s dive into it!

Writing Better RST Markup in docstring
04:03

When designing a complex chain of if and else statements, we might miss some condition that got lost in the tangle of logic. Missing this will mean that our program will fail to work properly. How can we be sure we haven't missed something? This video is an answer to this question.

Designing Complex if…elif Chains
04:43

There are a few situations, where we don't have the data until we get an input from the person. Let’s have a look at how we could implement a while statement in these conditions.

Designing a While Statement that Terminates Properly
06:12

What could you do when you have multiple break statements, each with its own condition. How can you minimize the problems created by having complex break conditions? Let’s get the answer for these questions.

Avoiding a Potential Problem with Break Statements
05:05

How could we avoid confusion due to hierarchy if we're trying to handle detailed exceptions as well as generic exceptions? This video will give a few of the best exception matching rules.
Leveraging the Exception Matching Rules
04:41

There are some common mistakes in exception handling. These can cause programs to become unresponsive. This video will show some common exception handling errors that we can avoid.

Avoiding a Potential Problem With an Except:Clause
02:05

In some cases, we may want to merge some seemingly unrelated exceptions into a single generic exception. What if we need to provide supporting details that amplify or extend the generic exception. We can do this by chaining from the generic exception to the root cause exception. Let’s see how to do this.
Chaining Exceptions with the Raise from Statement
03:00

There are many instances where our scripts will be entangled with external resources. We'd like to isolate each entanglement so that we can be sure that the resource is acquired and released properly. Let’s see how we could achieve this goal.

Managing a Context Using the With Statement
05:24

When we define a function, we often have a need for optional parameters. This allows us to write functions that are more flexible, and can be used in more situations. Let’s see how to design these functions.
Preview 11:02

In some cases, we want to provide a simple, high-performance software implementation that can perform different calculations based on what's known and what's unknown. We don't want to use a general algebraic framework; we want to bundle the different solutions into a simple, efficient function. This video will demonstrate how you could do this.
Using Super Flexible Keyword Parameter
05:16

What if you have a large number of positional parameters to a function? What would you do when it gets difficult to remember the required order for the parameters and there are too many parameters? Let’s answer these questions.

Forcing Keyword-only Argument with the * Separator
04:19

Sometimes we want hints about the type of data involved, which can be used for testing and confirmation but don't interfere with performance. How can we provide meaningful type hints? Let’s see how we could achieve this goal.

Writing Explicit Types on Function Parameters
04:47

What could be done if we’d like to provide a way to make the common parameters slightly easier to work with than the uncommon parameters and to avoid having to repeat the parameters that are part of a larger context? Let’s have a resolution to this situation.
Picking an Order for Parameters Based on Partial Functions
06:15

How can we clearly document what a function does? Can we provide examples? Let’s explore the answers to these questions.

Writing Clear Documentation Strings
04:13

Let’s see how we could use a simple and smart way to design recursive functions to enhance the structure of our program.

Designing Recursive Functions Around Python’s Stack Limit
04:22

How can we import the functions or classes from a file without having the script start doing something? Let’s see how to do this.

Writing Reusable Script with the Script Library Switch
04:30

How do we choose which structure to use? What are the features of lists, sets, and dictionaries? Why do we have tuples and frozen sets? Let’s answer these questions with this video.

Preview 09:38

Can we control the formatting in our programs? Can we change the extra characters that are supplied? Let’s see how to do this.

Building Lists – Literals, Appending, and Comprehensions
09:58

There are many times when we want to pick items from a list. One of the most common kinds of processing is to treat the first item of a list as a special case. This leads to a kind of head-tail processing where we treat the head of a list differently from the items in the tail of a list. Let’s see how we can slice or dice a list.
Slicing And Dicing a List
05:20

There are many times when we want to remove items from a list collection. We might delete items from a list, and then process the items that are left over. Let’s see how to do this.

Deleting From a List
09:13

We generally want to display the values with the most significant digit first. This leads to a need of reversing the sequence of digits in a list. This video will let you do this in Python.

Reversing a Copy of a List
04:54


Can we control the formatting in our programs? Can we change the extra characters that are supplied? Let’s see how to do this.

Using Set Methods and Operators
08:37

Python gives us several ways to remove items from a set collection. Let’s dive into few of these.
Removing Items from a Set
04:19

Through this video, you will be able to use a dictionary when you have some key that we need to map to a given value along with some key operations like inserting and updating dictionaries.

Creating Dictionaries
05:34

This video will show you how to define a service that works in a simulated environment with a single processing thread and avoid concurrency and multi-processing considerations.
Removing from Dictionaries
04:16

What if we want to keep the keys in a given order so that the dictionary follows the structure of the source file? Let’s see how we could do this.
Controlling the Order of the Dict Keys
03:48

How can we be sure our doctest examples really work? Let’s get the answer to this.

Handling Dictionaries and Sets in doctest Examples
02:24

How do variables really work? What happens when we assign a mutable object to two variables? Let’s have the answer to these questions.

Understanding Variables, References, and Assignment
03:23

This video will walk you through different ways to break the connection that exists when two variables are references to the same underlying object
Making Shallow and Deep Copies of Objects
05:46

This video will let you have a close look at the consequences of a mutable default value for a function parameter and how to avoid it.

Avoiding Mutable Default Values for Function Parameters
06:10

Can we control the formatting in our programs? Can we change the extra characters that are supplied? Let’s see how to do this.
Preview 07:25

The environment variables are available through the os module. How can we have an application's configuration based on these OS-level settings? Let’s have a close look at this.
Using input() and getpass() for User Input
08:39

There are some kinds of formatting options available in Python. What if we want more flexible output? Let’s see some amazing options for this, which are there for you in Python.
Debugging with “Format”.Format_Map(Vars())
03:17

In some cases, we may want to get the user input from the OS command line without a lot of interaction. We'd prefer to parse the command-line argument values and either perform the processing or report an error. How do we parse argument values from the command line? Let’s start doing this with this video.

Using Argparse to Get Command-line Input
06:57

There are several ways of creating interactive applications. Let’s see how we can prompt the user for input and then invoke a specific method of the class we provide.
Using CMD for Creating Command-line Applications
06:06

The environment variables are available through the os module. How can we have an application's configuration based on these OS-level settings? Let’s have a close look at this.

Using the OS Environment Settings
04:56
+
Modern Python Solutions - Part 2
46 Lectures 05:55:17
This video gives an overview of this course.
Preview 03:39

The unifying concept behind a class definition is often captured as a summary of theresponsibilities allocated to the class. How can we do this effectively? What's a good way todesign a class? Let’s get the answers to these questions through this video.
Using a Class to Encapsulate Data and Processing
15:43

How can we design a class that makes use of Python's array of sophisticated built-in collections? Let’s see it.

Designing Classes with Lotsof Processing
09:55

How can we create a class that allows us to use the object.attribute syntax instead ofobject['attribute']? This video will answer this question.

Designing Classes with Little Unique Processing
08:10

How can we create optimized classes with a fixed set of attributes? This video will show you how to do this.
Optimizing Small Objects with _slots_
05:13

Python has a wide variety of built-in collections.When we fold in the standard library, we have more choices, and more decisions to make.How can we choose the right data structure for our problem? Let’s explore this.

Using More Sophisticated Collections
07:31

Now, since you know to distinguishbetween a complex algorithm and a collection and how to encapsulate thealgorithm and the data into separate classes, the alternative design strategy is to extend the collection to incorporate a useful algorithm.How can we extend Python's built-in collections? Let’s do it right now!

Extending a Collection
05:38

What if we have values that are used rarely, and are very expensive to compute? What canwe do to minimize the up-front computation, and only compute values when they are trulyneeded? Let's look into it.
Using Properties for Lazy Attributes
05:54

What can we do if we want to use attribute-like syntax for setting a value, but we also wantto perform eager calculations? And how can we eagerly compute values from attribute changes? Let’s get the answer to these questions through this video.

Using Settable Properties to Update Eager Attributes
08:06

This video will let you distinguish between the semantic issues and apply the best possible technique while establishing connection between two classes.
Preview 12:51

This video will show you how to handle all the variations in card game rules.
Separating Concerns via Multiple Inheritance
07:10

Python doesn't have a formal mechanism for abstract superclasses. It relies on duck typing to locate methods within a class. Let’s see how we canleverage this duck typing in Python.

Leveraging Python's Duck Typing
05:10

This video will let you work with implicit global objects and manage the operation through them.

Managing Global and Singleton Objects
09:03

This video will teach you how to transform a flat list of details into a structure that for one column contains valuestaken from other columns

Using more Complex Structures
04:06

When simulating card games, it's often essential to be able to sort the Card objects into adefined order. Most of our class definitions requires sorting objectsinto order.How do we create comparable objects?Let’s obtain the answer to this question.

Creating a Class that Has Orderable Object
07:55

How can we build a sorted collection of objects? How can we build a multiset or bag usinga sorted collection?Let’s answer these questions.

Defining an Ordered Collection
06:48

Removing items from a list has an interesting consequence.How can we delete multiple items from a list?Let’s see this.
Deleting from a List of Mappings
08:53

Is there some way to disentangle the collection structure from the processing function? Canwe yield results from processing as soon as each individual item is available? This video will provide you with an answer to these questions.
Preview 11:23

How can we stack or combine multiple generator functions to create a composite function? Let’s look into this.

Using Stacked Generator Expression
11:50

This video will show you, how you could simplify the generator functions and generator expressions which have the similar boilerplate code.

Applying Transformations to a Collection
04:54

This video will teach you the different ways to filter and pick items from a subset.
Picking a Subset
06:22

Can we generalize summation in a way that allows us to write a number of different kindsof reductions? How can we define the concept of reduction in a more general way? Let’s get the answers to these questions through this video.

Summarizing a Collection
05:02

This video will teach you the design considerations when workingwith multiple kinds of generator functions in conjunction with map, filter, and reduce. You will learn to cache intermediate results so that we can perform multiple reductions on the data.
Combining Map and Reduce Transformations
08:50

How can we write a process using generator functions that stops when the first valuematches some predicate? How do we avoid for all and quantify our logic with there exists? Let’s do it, with this video.

Implementing “There Exists” Processing
06:44

Let’s see how we can define a function that has some parameters provided in advance.
Creating a Partial Function
06:34

A great deal of the emphasis ofobject-oriented design is creating methods that mutate an object's state. Let’s see how we can use immutable data structures.

Simplifying Complex Algorithms with Immutable Data Structures
09:45

In many cases, there are advantages to using generators for processing these kinds ofstructures. How can we write generators that work with recursion? How does the yieldfrom statement save us from writing an extra loop? Let’s explore these questions.

Writing Recursive Generator Functions with the Yield from Statement
06:06

How can we work with pathnames in a way that's independent of aspecific operatingsystem? How can we simplify common operations to make them as uniform as possible? This video is an answer to these questions.
Preview 13:02

Let’s see how we can be sure that resources are acquired and released properly and how we can avoid avoidresource leaks.

Reading and Writing Files with Context Managers
07:45

Clearly, we can make backup copies of files. This introduces an extra processing step. Wecan do better. What's a good approach to createfiles that are fail-safe? Let’s see this!
Replacing a File While Preserving the Previous Version
06:08

How can we process data in one of the wide varieties of CSV formatting? Let’s learn to do it, right now!

Reading Delimited Files with the CSV Module
05:56

This video will show you how you can process this kind of data with the elegant simplicity of a CSV file and transform these irregular rows to a more regular data structure.

Reading Complex Formats Using Regular Expressions
03:04

How do we use the json module to parse JSON data in Python? Let’s look into this.
Reading JSON Documents
13:55

How do we use the xml.etree module to parse XML data in Python? Let’s explore this questions.

Reading XML Documents
06:45

A great deal of content on the Web is presented using HTML markup. A browser rendersthe data very nicely. How can we parse this data to extract the meaningful content from thedisplayed web page? Let’s learn this through this video.
Reading HTML Documents
06:49

This video will show you what you can do to replace complex syntax with something simpler.

Upgrading CSV from DictReader to the namedtuple Reader
05:54

This video will show you how you could upgrade the CSV and replace complex syntax with something simpler.

Upgrading CSV from a DictReader to a Namespace Reader
05:00

It's common to need to convert data from one format to another. For example, we mighthave a complex web log that we'd like to convert to a simpler format. This video will show you, how you could convert from one format to another.

Using Multiple Contexts for Reading and Writing Files
05:41

A great deal of exploratory data analysis or EDA involves getting a summary of the data. How can we get basic descriptive statistics in Python? Let’s do it right now!
Preview 09:57

This video will let you perform statistical processing on (value, frequency) pairs.
Average of Values in a Counter
07:20

Another common statistical summary involves the degree of correlation between two sets of data. This is not directly supported by Python's standard library. How can we determine if two sets of data correlate? Let’s see this.
Computing the Coefficient of a Correlation
04:22

How can we compute the linear regression parameters between two variables? Let’s answer this question.
Computing Regression Parameters
06:17

If we suspect we have cyclic data, can we leverage the previous correlation function to compute an autocorrelation? Let’s explore this question.
Computing an Autocorrelation
08:29

Let’s see how we can evaluate data to see if it's truly random if there's some meaningful variation.

Confirming that the Data is Random – the Null Hypothesis
10:31

When we have statistical data, we often find data points which can be described as outliers. Let’s see how we locate and label potential outliers.

Locating Outliers
10:01

This video will show, how you can make one pass through a set of data and collect a number of descriptive Statistics.
Analyzing Many Variables in One Pass
09:06
+
Modern Python Solutions - Part 3
23 Lectures 03:24:07

This video provides an overview of the entire course.

Preview 03:25

Good Python includes docstrings inside every module, class, function, and method. Many tools can create useful, informative documentation from the docstrings. How can we turn examples into proper test cases? Let's explore this question.
Using docstring for Testing
10:17

This video will show you how to turn exception processing and the resulting traceback messages into proper test cases.

Testing Functions that Raise Exceptions
04:09

Doctest examples require an exact match with the text. How can we write doctest examples that handle hash randomization or floating-point implementation details appropriately? This video will enable you to answer this question.
Handling Common doctest Issues
06:11

This video will show you how you could create more sophisticated tests.
Creating Separate Test Modules and Packages
04:34

This video shows how we can combine all of the various tests into one tidy package.

Combining the unittest and doctest Tests
04:39

Many applications rely on datetime.datetime.now() to create a timestamp. When we use this with a unit test, the results are essentially impossible to predict. How can we work with datetime stamps? Let's look into this.

Testing Things that Involve Dates and Time
05:41

Many times we create random values or put values into random order. In many statistical tests, repeated random shuffling or random subset calculations are done. Let's see how we can unit test algorithms that involve randomness.

Testing Things That Involve Randomness
06:07

How can we create more sophisticated mock objects that have internal state and make their own internal state changes? Let's dive into these questions.

Mocking External Resources
14:13

Let's create applications that support layered composition following the WSGI standard.
Preview 18:35

How can we simplify all of the common web application programming and eliminate the boilerplate code? Let's explore these questions.

Using the Flask Framework for RESTful APIs
09:36

This video will show you a better way to handle a query string and have a more sophisticated structure that behaves like a dictionary with single values for the common case, and a more complex object for the rare cases where a field key is duplicated and has multiple values.

Parsing the Query String in a Request
04:59

There are several user stories that involve RESTful API clients written in Python. How can we create a Python program that is a client of RESTful web services? Let's see this.
Making REST Requests Using urllib
11:57

The path to a resource can be quite complex. It's common in RESTful web services to use the path information to identify groups of resources, individual resources, and even relationships among resources. How can we handle complex path parsing? Let's answer this question.

Parsing the URL Path
15:54

This video will teach you, how you can parse JSON inputs from web clients and what is an easy way to validate the input.

Parsing a JSON Request
10:47

This video will show a self-service application in which there is no defined set of users. This means that there must be a web service to create new users that doesn't require any authentication. All other services will require a properly authenticated user.
Implementing Authentications for Web Services
14:45

Let's see how we can support a rich hierarchy of locations for configuration files.

Preview 10:37

Python offers a variety of ways to package application inputs and configuration files. Let's look at writing files in YAML notation because it's elegant and simple. This video will show you how you can represent configuration details in YAML notation.
Using YAML for Configuration Files
08:47

How can we represent configuration details in Python module notation? Let's find the solution to this problem.
Using Python for Configuration Files
07:16

Python offers the logging package, which can be used to direct the ancillary output to a separate file. It can also be used to format and filter that additional output. How can we use logging properly? Let's see this.

Using Logging for Control and Audit Output
07:10

This video will walk you through a design pattern that would allow several Python language components to be combined into a larger application. You will learn to combine applications to create a composite.

Combining Two Applications into One
08:07

This video will enable you to create families of closely related commands.

Combining Many Applications Using the Command Design Pattern
07:34

How can we combine these techniques effectively? Can we create longer, more complex sequences of operations using Python? This video will answer all these questions.
Controlling Complex Sequences of Steps
08:47
+
Mastering Python - Second Edition
51 Lectures 05:20:43
This video provides an overview of the entire course
Preview 03:24

The goal of this video is to provide a basic understanding of the Python language constructs.

Python Basic Syntax and Block Structure
11:54

The goal of this video is to ensure we have the basic ability to operate with Python's most common data structures.

Built-in Data Structures and Comprehensions
08:54

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

First-Class Functions and Classes
05:49

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.

Extensive Standard Library
05:55

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

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

Preview 05:16

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
Using the Command-Line and the Interactive Shell
04:01

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

Installing Packages with pip
03:16

There's a lot of good code available. How do we find it? Let's take a look in this video.

Finding Packages in the Python Package Index
04:29

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

Preview 05:50

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.

Adding Modules to the Package
05:30

The goal in this video is to understand how we can make code in separate modules of the package interact.

Importing One of the Package's Modules from Another
05:26

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!

Adding Static Data Files to the Package
02:53

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.

Preview 07:50

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.
Using Version Control
04:47

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.
Using venv to Create a Stable and Isolated Work Area
04:40

Properly formatted docstrings can be automatically used by IDEs and transformed into HTML. Let's take a peek into it in this video.

Getting the Most Out of docstrings 1: PEP 257 and docutils
08:00

The goal of this video is to understand why it's important that examples in the documentation stay consistent with the code.

Getting the Most Out of docstrings 2: doctest
04:04

A menu is a very important component for any game and it's really useful too. However, the steps to use a menu are a little complex. Let's see what we do here.
Preview 05:51

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.
Handling Command-Line Arguments with argparse
06:21

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

Interacting with the User
04:38

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

Executing Other Programs with Subprocess
09:09

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.

Using Shell Scripts or Batch Files to Run Our Programs
03:00

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.
Preview 13:52

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.
Using Multiprocessing
11:22

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.

Preview 08:01

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

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

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

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

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

Preview 06:45

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.

Function Annotations
07:08

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.

Class Decorators
05:52

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.
Metaclasses
05:35

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
05:52

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

Descriptors
05:37

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

Preview 05:07

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

Using the unittest Package
07:27

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.

Using unittest.mock
06:12

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

Using unittest's Test Discovery
04:30

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

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

Preview 02:49

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.
Building a Simple Reactive Programming Framework
07:21

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.

Using the Reactive Extensions for Python (RxPY)
10:21

We need our web server to scale up and maintain high availability. Let's see how we can do that.
Preview 04:12

We need a microservice that works well with the web infrastructure or perhaps is even directly accessible to JavaScript running in web browsers.

Building a High-Level Microservice with Flask
09:59

Sometimes, we'd rather have all of the protocol-level stuff handled automatically for our microservice.

Building a Low-Level Microservice with nameko
06:24

Sometimes we need to access or create compiled code and sometimes we don't need it as much as we think. How do we know which is which?
Preview 04:41

There's a lot of useful code out that wasn't written for Python, but most of it is accessible to C code.

Accessing a Dynamic Library Using ctypes
07:59

Sometimes we just need to write a code that runs close to the metal. Cython gives us that option.

Interfacing with C Code Using Cython
12:34
About the Instructor
Packt Publishing
3.9 Average rating
7,336 Reviews
52,506 Students
616 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.