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.
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.
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.
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.
This video will let you understand which division operator to use while converting numbers from one base to another
How can we rewrite an immutable string? This video will answer this question and show you how to work with strings in Python.
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!
Creating complex strings is, in many ways, the polar opposite of parsing a complex string. Let’s dive into building a complex string.
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.
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.
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.
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.
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.
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.
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!
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.
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.
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.
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.
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.
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.
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.
How can we clearly document what a function does? Can we provide examples? Let’s explore the answers to these questions.
Let’s see how we could use a simple and smart way to design recursive functions to enhance the structure of our program.
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.
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.
Can we control the formatting in our programs? Can we change the extra characters that are supplied? Let’s see how to do this.
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.
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.
Can we control the formatting in our programs? Can we change the extra characters that are supplied? Let’s see how to do this.
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.
How can we be sure our doctest examples really work? Let’s get the answer to this.
How do variables really work? What happens when we assign a mutable object to two variables? Let’s have the answer to these questions.
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.
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.
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.
How can we design a class that makes use of Python's array of sophisticated built-in collections? Let’s see it.
How can we create a class that allows us to use the object.attribute syntax instead ofobject['attribute']? This video will answer this question.
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.
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!
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.
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.
This video will let you work with implicit global objects and manage the operation through them.
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
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.
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.
How can we stack or combine multiple generator functions to create a composite function? Let’s look into this.
This video will show you, how you could simplify the generator functions and generator expressions which have the similar boilerplate code.
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.
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.
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.
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.
Let’s see how we can be sure that resources are acquired and released properly and how we can avoid avoidresource leaks.
How can we process data in one of the wide varieties of CSV formatting? Let’s learn to do it, right now!
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.
How do we use the xml.etree module to parse XML data in Python? Let’s explore this questions.
This video will show you what you can do to replace complex syntax with something simpler.
This video will show you how you could upgrade the CSV and replace complex syntax with something simpler.
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.
Let’s see how we can evaluate data to see if it's truly random if there's some meaningful variation.
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.
This video will show you how to turn exception processing and the resulting traceback messages into proper test cases.
This video shows how we can combine all of the various tests into one tidy package.
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.
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.
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.
How can we simplify all of the common web application programming and eliminate the boilerplate code? Let's explore these questions.
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.
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.
This video will teach you, how you can parse JSON inputs from web clients and what is an easy way to validate the input.
Let's see how we can support a rich hierarchy of locations for configuration files.
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.
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.
This video will enable you to create families of closely related commands.
The goal of this video is to provide a basic understanding of the Python language constructs.
The goal of this video is to ensure we have the basic ability to operate with Python's most common data structures.
People used to lower-level languages are unfamiliar with First-class functions and classes; we'll take a look at them in this video.
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.
In this video, we are going to download and install the correct version of Python and make sure it's functional.
Python has good support for installing and managing third-party code packages; let's take a look at them in this video.
There's a lot of good code available. How do we find it? Let's take a look in this video.
The goal of this video is to know how to create the structure of a Python program.
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.
The goal in this video is to understand how we can make code in separate modules of the package interact.
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!
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.
Properly formatted docstrings can be automatically used by IDEs and transformed into HTML. Let's take a peek into it in this video.
The goal of this video is to understand why it's important that examples in the documentation stay consistent with the code.
What do we do when we need information to flow both ways with the user?
Running other programs from within a program is often useful, especially, for system automation. We'll look at how to do it.
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.
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.
Functions are very useful, but it would be nice to be able to tweak them to suit our specific needs. Enter function decorators.
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.
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.
We can plug code into Python's attribute access mechanism to control what it means to read, write, or delete a member variable.
Testing is critical, but it can feel like a burden. Automated unit testing and test-driven development can solve this problem.
The unittest package provides a framework for writing automatic tests; let's check it out.
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.
As a test suite grows, running the tests individually becomes impractical. We need the system to find and run them in large swaths.
For the newcomer, it can be difficult to figure out exactly what other people are talking about when they say "reactive programming".
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.
Sometimes, we'd rather have all of the protocol-level stuff handled automatically for our microservice.
There's a lot of useful code out that wasn't written for Python, but most of it is accessible to C code.
Sometimes we just need to write a code that runs close to the metal. Cython gives us that option.
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.