Mastering Python - Second Edition
3.7 (5 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.
177 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Mastering Python - Second Edition to your Wishlist.

Add to Wishlist

Mastering Python - Second Edition

Unlock the power of Python by learning effective application development strategies
3.7 (5 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.
177 students enrolled
Created by Packt Publishing
Last updated 1/2017
English
Current price: $10 Original price: $125 Discount: 92% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 5 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Get to grips with the basics of operating in a Python development environment
  • Build Python packages to efficiently create reusable code
  • Become proficient at creating tools and utility programs in Python
  • Use the Git version control system to protect your development environment from unwanted changes
  • Harness the power of Python to automate other software
  • Distribute computation tasks across multiple processors
  • Handle high I/O loads with asynchronous I/O to get a smoother performance
  • Take advantage of Python's metaprogramming and programmable syntax features
  • Get acquainted to the concepts behind reactive programming and RxPy
View Curriculum
Requirements
  • This video covers the basics to advanced-level concepts in computer science. If you are a beginner, then the video will get you started. If you are experienced, it will expand your knowledge base.
Description

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.

Who is the target audience?
  • If you are a programmer who is familiar with the basics of Python and you want to broaden your knowledge base to develop projects better and faster, this course is for you. Even if you are not familiar with Python, our course starts with the basics and takes you on a journey to become an expert in the technology.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
51 Lectures
05:11:34
+
Python Primer
6 Lectures 41:57

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
+
Setting Up
4 Lectures 17:02

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
+
Making a Package
4 Lectures 19:39

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
+
Basic Best Practices
5 Lectures 29:21

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
+
Making a Command-Line Utility
5 Lectures 19:50

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.

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
Processing..

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
2 Lectures 25:14

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
+
Coroutines and Asynchronous I/O
5 Lectures 28:24

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
+
Metaprogramming
6 Lectures 36:49

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
+
Unit Testing
5 Lectures 26:58

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
+
Reactive Programming
3 Lectures 20:31

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
2 More Sections
About the Instructor
Packt Publishing
3.9 Average rating
8,109 Reviews
58,282 Students
686 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.