Learning Path: Python: Programming for Python Users
3.3 (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.
121 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learning Path: Python: Programming for Python Users to your Wishlist.

Add to Wishlist

Learning Path: Python: Programming for Python Users

Program using the high-level, dynamic Python language and create manifold fun projects that are robust
3.3 (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.
121 students enrolled
Created by Packt Publishing
Last updated 3/2017
English
Current price: $10 Original price: $200 Discount: 95% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 11.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
  • Get acquainted with advanced programming techniques in Python
  • Integrate application software using Python
  • Synchronize multiple threads and processes to manage parallel tasks
  • Implement message passing communication between processes to build parallel applications
  • Apply parallel programming techniques that can lead to performance improvements
  • Send HTML formatted emails
  • Automate your tasks by using scheduling mechanisms
View Curriculum
Requirements
  • Basic understanding of Python is essential
Description

As a Python user, have you felt the need to use the programming features of this powerful language? You definitely would want to do more than just using Python commands and use its code to make your work easy. If this is the case, this Learning Path is for you.

It’s no NEWS that Python is the market-standard tool for data science. However, it’s worth mentioning that Python has made a huge impact in the programming world. Python is a widely used high-level, general-purpose, interpreted, dynamic programming language.

Python: Programming for Python Users is Packt’s Video Learning Path that is a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.

This Learning Path first introduces the Unity engine. It shows how to use the interface and how to build levels, and culminates in the creation of a simple game. The core features and fundamentals are explored in a fun and practical way, encouraging the development of real-world projects while establishing a solid understanding of game development principles.

This Learning Path starts with the essentials of Python programming. This will touch upon all the necessary Python concepts related to data structures, OOP, functional programming, as well as statistical programming. You will get acquainted with the nuances of Python syntax and how to effectively use the advantages that it offers.

Then, you’ll be introduced to the world of parallel computing. Explore thread-based parallelism model using the Python threading module by synchronizing threads and using locks, mutex, semaphores queues, GIL, and the thread pool. Moving on, you’ll get to grips with the asynchronous parallel programming model using the Python asyncio module, and will see how to handle exceptions. You will discover distributed computing with Python, and learn how to install a broker, use Celery Python Module, and create a worker.

The course focuses on building 4 fun projects from scratch with easy-to-understand explanations and practical applications. You’ll learn how to create a well-designed architecture and increase performance of the current applications. You will learn how to build enterprise ready applications with the Python language.

The goal of this course is to make you proficient at Python programming, able to make projects from scratch.

About the Authors:

This Learning Path is authored by some of the best in the field.

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.

Giancarlo Zaccone has more than 10 years of experience in managing research projects, both in the scientific and industrial domains. He worked as a researcher at the National Research Council of Italy (CNR), where he was involved in a few parallel numerical computing and scientific visualization projects.

Burkhard A. Meier has more than 15 years of professional experience working in the software industry as a software tester and developer, specializing in software test automation development, execution, and analysis.

Who is the target audience?
  • This Learning Path is for Python users wanting to learn Python’s programming principles to develop projects.
Compare to Other Python Courses
Curriculum For This Course
133 Lectures
11:21:59
+
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 Lsit
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
+
Python Parallel Programming Solutions
64 Lectures 03:59:05

In this video, we will take a look at Flynn's taxonomy.

Preview 06:12

Another aspect that we need to consider to evaluate a parallel architecture is memory organization. In this video you will understand this concept.

Memory Organization
06:58

This video is the continuation of the previous video where we will take a closer look at distributed memory systems.

Memory Organization (Continued)
05:30

In this video, you will get an overview of parallel programming models.

Parallel Programming Models
04:13

The design of algorithms that exploit parallelism is based on a series of operations. This video shows us how to design such parallel programs.

Designing a Parallel Program
06:18

The development of parallel programming created the need of performance metrics. This video will help us evaluate the performance of a parallel program.

Evaluating the Performance of a Parallel Program
05:19

Python is a powerful, dynamic, and interpreted programming language that is used in a wide variety of applications. In this video, we will get introduced to Python and its features.

Introducing Python
06:19

In this video, we simply demonstrate how to start a single new program from inside a Python program.

Working with Processes in Python
02:25

This video simply shows you how to create a single thread inside a Python program.

Working with Threads in Python
03:35

The simplest way to use a thread is to instantiate it with a target function. This video shows us how to do that.

Preview 03:19

This video helps us in determining the thread which we created earlier.

Determining the Current Thread
01:04

This video will help us to implement a new thread using the threading module.

Using a Thread in a Subclass
01:57

In this video, we describe the Python threading synchronization mechanism called lock().

Thread Synchronization with Lock
05:22

If we want only the thread that acquires a lock to release it, we must use an RLock() object. This video will get you introduced to RLock.

Thread Synchronization with RLock
01:45

A semaphore is an abstract data type managed by the operating system. In this video we will carry out the thread synchronization with semaphores.

Thread Synchronization with Semaphores
04:50

A condition identifies a change of state in the application. In this video, we will carry out the thread synchronization with a condition.

Thread Synchronization with a Condition
02:24

Events are objects that are used for communication between threads. In this video, we will carry out thread synchronization with an event.

Thread Synchronization with an Event
01:49

The "with" statement is useful when you have two related operations that must be executed as a pair with a block of code in-between. This video will show us how to use the "with" statement.

Using the 'with' Statement
02:01

Queues are much easier to deal with and make threaded programming considerably safe. In this video, we will take a look at thread communication using queue.

Thread Communication Using a Queue
03:06

In this video, we will verify the impact of the GIL, evaluating the performance of a multithread application.

Evaluating the Performance of Multithread Applications
04:36

Spawn means the creation of a process by a parent process. This video will show us how to spawn a process

Preview 02:47

The procedure to name a process is similar to that described for the threading library. Let's check this out in this video

Naming a Process
01:13

Running a process in the background is a typical mode of execution of laborious processes. This video will show you how to do that.

Running a Process in the Background
01:16

It's possible to kill a process immediately using the terminate() method. Let's see how to do that in this video.

Killing a Process
01:27

In this video, we will see how to implement a custom subclass and process.

Using a Process in a Subclass
01:21

The development of parallel applications has the need for the exchange of data between processes. We will see how to do that in this video.

Exchanging Objects between Processes
02:57

Synchronization primitives are quite similar to those encountered for the library and threading. In this video, we will see how to synchronize the process.

Synchronizing Processes
02:42

Python multiprocessing provides a manager to coordinate shared information between all its users. In this video, we will see how to manage a state between processes.

Managing a State between Processes
01:26

The multiprocessing library provides the Pool class for simple parallel processing tasks. In this video, we will see how to use it.

Using a Process Pool
02:21

The Python programming language provides a number of MPI modules to write parallel programs. In this video, we will see how to use the mpi4py library

Using the mpi4py Python Module
04:11

One of the most important features among those provided by MPI is the point-to-point communication. We will check that out in this video.

Point-to-Point Communication
02:59

A common problem we face is that of the deadlock in processes. This video will help us to avoid such problems.

Avoiding Deadlock Problems
03:06

In a collective communication broadcast process, a single process sends the same data to any other process.

Using Broadcast for Collective Communication
03:10

The scatter functionality sends the chunks of data in an array to different processes. This video will show us how to use scatter for collective communication.

Using Scatter for Collective Communication
02:08

With the gather function, all processes send data to a root process that collects the data received. Let's look at using gather for collective communication.

Using Gather for Collective Communication
01:39

The Alltoall collective communication combines the scatter and gathers functionalities. In this video, we will see how to use Alltoall for collective communication.

Using Alltoall for Collective Communication
03:05

Reduction takes an array of input elements in each process and returns an array of output elements to the root process. We will take a look at this operation in this video.

The Reduction Operation
02:53

MPI allows us to assign a virtual topology to a communicator. In this video, we will see how to optimize the communication using such mechanism

Optimizing the Communication
03:28

With the release of Python 3.2, the concurrent.future module was introduced. In this video, we will see how to use this module.

Preview 05:21

In this video, the focus is on handling events with the help of Asyncio.

Event Loop Management with Asyncio
04:20

In this video, we will see how to use the co-routine mechanism of Asyncio to simulate a finite state machine of five states.

Handling Coroutines with Asyncio
04:06

The Asyncio module provides us with the asyncio. Task(coroutine) method to handle computations with tasks. In this video, we will see how to manipulate a task with Asyncio.

Manipulating a Task with Asyncio
02:22

Another key component of the Asyncio module is the Future class. This video will teach you how to deal with Asyncio and futures.

Dealing with Asyncio and Futures
03:04

Celery is a Python framework used to manage a distributed tasks, following the object-oriented middleware approach. In this video, we will see how to use Celery to distribute tasks.

Preview 03:27

In this video, we'll learn to create and call a task using the Celery module.

Creating a Task with Celery
03:08

SCOOP is a Python module to distribute concurrent tasks (called Futures) on heterogeneous computational nodes. In this video we will take a look at scientific computing with Scoop.

Scientific Computing with SCOOP
04:54

The SCOOP Python modules define more than one map function; and they allow asynchronous computation that could be propagated to its workers. In this video, we will see how to handle Map functions with SCOOP.

Handling Map Functions with SCOOP
04:03

Python Remote Objects (Pyro4) is a library that resembles Java's Remote Method Invocation (RMI), which allows you to invoke a method of a remote object. In this video we will see how to do that.

Remote Method Invocation with Pyro4
05:27

Implement a chain of objects with Pyro4 using Python scripts.

Chaining Objects with Pyro4
04:01

In this video, we will see how to build a simple client-server application with Pyro4.

Developing a Client-Server Application with Pyro4
04:18

PyCSP is a Python module based on communicating sequential processes, which is a programming paradigm developed to build concurrent programs via message passing. We will take a look at that in this video.

Communicating Sequential Processes with PyCSP
07:02

Remote Python Call (RPyC) is a Python module that is used for remote procedure calls as well as for distributed computing. In this video, we will see how to carry out a remote procedure call with RPyC.

A Remote Procedure Call with RPyC
03:39

PyCUDA is a Python wrap for Compute Unified Device Architecture (CUDA), the softwarelibrary developed by NVIDIA for GPU programming. In this video, we will see how to use PyCUDA.

Preview 07:32

The PyCUDA programming model is designed for the common execution of a program on a CPU and GPU. This video will show us how to build a PyCUDA application.

Building a PyCUDA Application
07:32

In the CUDA-capable GPU card, there are four types of memories. In this video, we will take a look at those with the help of matrix manipulation.

Understanding the PyCUDA Memory Model with Matrix Manipulation
05:36

In this video, we will see the common use case of GPU computations in order to invoke a kernel function.

Kernel Invocations with GPU Array
02:23

The PyCuda.elementwise.ElementwiseKernel function allows us to execute the kernel on complex expressions. We will see how to do that in this video.

Evaluating Element-Wise Expressions with PyCUDA
03:20

PyCUDA provides a functionality to perform reduction operations on the GPU. We will take a look at that in this video.

The MapReduce Operation with PyCUDA
03:42

NumbaPro is a Python compiler that provides a CUDA-based API to write CUDA programs. In this video we will demonstrate GPU programming with NumbaPro.

GPU Programming with NumbaPro
04:47

NumbaPro provides a Python wrap for CUDA libraries for numerical computing. We will understand it with the help of this video.

Using GPU-Accelerated Libraries with NumbaPro
05:26

In this video, we'll examine the Python implementation of OpenCL called PyOpenCL.

Using the PyOpenCL Module
04:03

As for programming with PyCUDA, the first step to build a program for PyOpenCL is the encoding of the host application. This video will show us how to build the application.

Building a PyOpenCL Application
04:58

PyOpenCL provides the functionality in the pyopencl.elementwise class that allows us to evaluate the complicated expressions in a single computational pass. We will see how to do that in this video.

Evaluating Element-Wise Expressions with PyOpenCl
03:10

In this video, we will test the GPU application by implementing the regular definition schema of an application for PyOpenCL.

Testing Your GPU Application with PyOpenCL
04:13
+
Python Projects
17 Lectures 02:19:09

This video will give you brief information about the course.

Preview 05:29

In this video we will set up our development environment.

Setting Up the Python Development Environment
09:31

In this video, we will get started writing programs in Python using the Eclipse IDE with the PyDev plugin. This will give us a foundation for all Python projects we are developing in this video series.

Preview 04:55

In this video, we will be setting breakpoints in order to step through and debug our code. Setting breakpoints is a great way to understand the flow of our code, especially when using object-oriented programming with Inheritance.

Setting Breakpoints
04:38

In this video, we will be enhancing our Python debugging skills by setting breakpoints and then using different available debugging tools within Eclipse. We will explore the callstack window; look at the Variables, Breakpoint, and Expression windows; set watches; and use the Outline window as well as bookmarks to navigate the code.

Using the Pydev Debugger
07:02

In this video, we will introduce the software classic "Design Patterns". We will then create the Maze labyrinth game from the Design Patterns book in Python using OOP. We will begin by not using any patterns so that we can see and understand the value of using patterns.

Preview 09:17

In this video, we will create the "Maze" game using the abstract factory design pattern. We will first build a regular Maze and then extend this Maze to an Enchanted Maze, and also to another Maze that can have bombs in it.

Creating the Maze in Python Using the Abstract Factory Design Pattern
05:47

In this video, we will create the "Maze" game using the Builder Design Pattern. We will explain this pattern by then creating a "Counting Maze".

Creating the Maze in Python Using the Builder Design Pattern
08:42

In this video, we will create the "Maze" game using the Prototype Design Pattern. We will explain this pattern by creating one Maze, saving it, and then cloning it a few times. We'll then modify the clones.

Creating the Maze in Python Using the Factory Prototype Design Pattern
12:51

In this video, we will introduce Python's built-in GUI framework, Tkinter. We will start with the fewest lines of code required to build a working GUI, and then we will change the GUI's default size and also fix its size.

Preview 05:32

In this video, we will enhance the GUI by adding several widgets. We will add a menu, add tabs and populate those tabs with LabelFrames, Labels, Comboboxes, and text entries using the Grid layout manager. We will also add spacing around the widgets to make the GUI look great.

Simple_GUI
10:22

In this video, we will extend our GUI by turning it into a Weather app. We will be using data from NOAA. First we will use previously saved data to populate our GUI, and in the end we will directly retrieve the weather data in real time from the website.

NOAA_Weather_Data
15:12

In this video, we will further enhance our Weather app GUI by using the OpenWeatherMap API. This will allow us to retrieve weather data from cities located all over the world. We will retrieve this data directly from the Web.

OpenWeatherMap
15:19

In this video, we will reuse some code from the previous section, in which we collected live weather data from the NOAA website. We will then save this data in HTML format.

Preview 05:30

In this video, we will use Gmail as our personal e-mailing server. First, we will setup a new Gmail account and configure required settings. Then we will e-mail our HTML weather data report using Gmail.

EmailingViaGmail
05:40

In this video, we will introduce Python's "schedule" module. We will explore the different scheduling options it provides, and then we will use this module to schedule our data collection, save as HTML, and e-mailing process.

Scheduling the Task
03:58

In this video, we will create a Windows Service written in Python. We will see one way to correctly install the required pywin32 module that works for Python 3.5, and how to successfully run the postinstall script. We will then run our scheduled task as a Windows Service.

TaskSchedulerSvc
09:24
About the Instructor
Packt Publishing
3.9 Average rating
8,249 Reviews
59,045 Students
687 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.