Python is one of the most powerful, flexible, and popular programming languages in the world. It comes with all new features in version 3.5. With Python, you can write code that is efficient, maintainable, and reusable.
In this second edition of the course, we cover the basics of operating in a Python development environment as well as the advanced topics. We present you with real-world solutions to Python 3.5 and advanced-level concepts such as reactive programming and microservices, introduce ctypes and Cython tools.
You don't need to be familiar with the Python language as we start with Python primer and move on to explain what’s new in Python 3.5. You’ll get ready to install, create packages, and run them on the command line. Throughout the journey, we'll highlight the major aspects of managing your Python development environment, show you how to handle parallel computation, and help you to master asynchronous I/O with new Python 3.5 to improve the performance of your system.
Finally, you'll learn the secrets of metaprogramming and unit testing in Python—arming you with the perfect skillset to be a Python expert. This course will get you up to speed in everything from basic programming practices to high-end tools and techniques, things that will help you set apart as a successful Python programmer.
About The Author
Daniel Arbuckle got his Ph.D. In Computer Science from the University of Southern California. He has published numerous papers, along with several books and video courses, and is both a teacher of computer science and a professional programmer.
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.
The goal of this video is to look at the overview of recent language changes in Python.
In this video, we are going to download and install the correct version of Python and make sure it's functional.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The goal of this video is to set up and run the asyncio asyncio coroutine scheduler
In this video we will see how do we actually use asyncio's Future objects.
The goal of this video is to understand how to keep coroutines from jamming each other up and locking the program.
In this video, we will see how do asyncio's actual I/O facilities work
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.
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.
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.
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.
Sometimes we want a more flexible test runner than the one built in to unittest. Nose to the rescue.
For the newcomer, it can be difficult to figure out exactly what other people are talking about when they say "reactive programming".
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.
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.
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.