Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Learning Path: Python: Programming for Python Users
Rating: 3.3 out of 5(21 ratings)
251 students

Learning Path: Python: Programming for Python Users

Program using the high-level, dynamic Python language and create manifold fun projects that are robust
Created byPackt Publishing
Last updated 3/2017
English

What you'll 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

Course content

3 sections • 133 lectures • 11h 21m total length

  • The Course Overview3:22

    This video provides an overview of the entire course.

  • Creating Meaningful Names and Using Variables11:37

    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.

  • Working with Large and Small Integers8:02

    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.

  • Choosing between Float, Decimal, and Fraction12:55

    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 True Division and Floor Division5:23

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

  • Rewriting an Immutable String8:56

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

  • String Parsing with Regular Expressions6:14

    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!

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

    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 from Lists of Characters4:44

    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.

  • Using the Unicode Characters that aren't on Our Keyboards3:27

    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.

  • Encoding Strings-Creating ASCII and UTF8 Bytes4:28

    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.

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

    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.

  • Using Tuples of Items4:15

    How can we keep things, which are pairs, such as latitude and longitude, together? Let’s see how to do this!

  • Writing Python Script and Module Files7:48

    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.

  • Writing Long Lines of Code8:10

    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.

  • Including Descriptions and Documentation5:02

    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.

  • Writing Better RST Markup in docstring4:03

    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!

  • Designing Complex if…elif Chains4:43

    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 a While Statement that Terminates Properly6:12

    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.

  • Avoiding a Potential Problem with Break Statements5:05

    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.

  • Leveraging the Exception Matching Rules4:41

    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.

  • Avoiding a Potential Problem With an Except:Clause2:05

    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.

  • Chaining Exceptions with the Raise from Statement3:00

    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.

  • Managing a Context Using the With Statement5:24

    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.

  • Designing Functions with Optional Parameters11:02

    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.

  • Using Super Flexible Keyword Parameter5:16

    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.

  • Forcing Keyword-only Argument with the * Separator4:19

    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.

  • Writing Explicit Types on Function Parameters4:47

    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.

  • Picking an Order for Parameters Based on Partial Functions6:15

    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.

  • Writing Clear Documentation Strings4:13

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

  • Designing Recursive Functions Around Python’s Stack Limit4:22

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

  • Writing Reusable Script with the Script Library Switch4:30

    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.

  • Choosing a Data Structure9:38

    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.

  • Building Lists – Literals, Appending, and Comprehensions9:58

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

  • Slicing and Dicing a Lsit5:20

    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.

  • Deleting From a List9:13

    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.

  • Reversing a Copy of a List4:54

    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.

  • Using Set Methods and Operators8:37

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

  • Removing Items from a Set4:19

    Python gives us several ways to remove items from a set collection. Let’s dive into few of these.

  • Creating Dictionaries5:34

    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.

  • Removing from Dictionaries4:16

    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.

  • Controlling the Order of the Dict Keys3:48

    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.

  • Handling Dictionaries and Sets in doctest Examples2:24

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

  • Understanding Variables, References, and Assignment3:23

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

  • Making Shallow and Deep Copies of Objects5:46

    This video will walk you through different ways to break the connection that exists when two variables are references to the same underlying object

  • Avoiding Mutable Default Values for Function Parameters6:10

    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.

  • Using Features of the print() Functions7:25

    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 input() and getpass() for User Input8:39

    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.

  • Debugging with “Format”.Format_Map(Vars())3:17

    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.

  • Using Argparse to Get Command-line Input6:57

    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 CMD for Creating Command-line Applications6:06

    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 the OS Environment Settings4:56

    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.

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 this course is for:

  • This Learning Path is for Python users wanting to learn Python’s programming principles to develop projects.

Report abuse