Python 2000: Beyond The Basics
4.5 (15 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
145 students enrolled

Python 2000: Beyond The Basics

Secrets of the Pythonic Masters
4.5 (15 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
145 students enrolled
Created by Randall Nagy
Last updated 5/2019
English
English [Auto]
Current price: $69.99 Original price: $99.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 4 hours on-demand video
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Learn how to share / re-use code
  • Learn how to gather user input
  • Learn how to detect and recover from errors
  • Understand how to create classes & class variables
  • Learn how to create your own classes
  • Understand class initialization
  • Learn how to locate protected member-functions in other modules
  • Use built-in functions to explore imported information
  • Discover how to list loaded modules
  • Discover 'invisible' package initialization
  • Learn how to avoid name collision in Python
  • Discover how to define & modify global and local variables
  • Learn how to access parent-member values & variables
  • Review the entire set of data-formatting operations
  • Learn how to anticipate dictionary ordering
  • Discover how to create & user a custom sort routine
  • Discover how using .format() is more flexible & forgiving than classic formatting operations
  • Learn how to use the sorted() built-in
  • Learn the difference between “isa” and “hasa”
  • Understand how Generators support distinct enumerations
  • Review the difference between Python's "Metaclasses," and the classes we create
  • Learn how to detect & manage critical class, as well as meta-class, relationships
Course content
Expand all 63 lectures 04:06:35
+ Python 2000: Intermediate Programmer Topics
26 lectures 01:36:40

Professional Python 3 software developers need to understand Python's complete set of keywords, as well as know how to create first-class, sharable, Python Objects. In Python 2000 therefore, we will cover not only how to create sharable modules and classes, but also delve deeper into how Python's keywords & classes interact with each other within Python's Class & Module Frameworks.

Preview 01:00

Let's take a moment to review our coverage of Python keywords, the classic built-ins, as well as use Pythons dir() and help() operations.


Preview 03:16

Gathering & processing input from humans and other programs can be an important part of any automation activity. Yet while gathering input from other sources is important however, relying upon data from humans or other sources can introduce allot of potential input errors into our applications.

Because outside input can be an amazing resource as well as a major source of error, in these more advanced lessons we should begin to build upon Pythons data-input support, as well as discover how to manage Exceptions. -Much as the moniker implies, in Python – as in other programming languages - Exceptions allow us to manage what we would like to do whenever results are not what we expect.

In this first official lesson in
Python 2000 therefore, we will:


  • Learn how to gather user input

  • Learn how to detect and recover from parsing errors

  • Learn how to raise & process an exception

  • Discover how to use try & except


Preview 05:35

When managing errors, we obviously do not know how many we might have. With the idea of gathering input therefore, we should be able to loop as many times as needed until get either quit, or get what we need.

In this lesson we will build upon what we have learned so as to be able to:

  • Understand how to use 'while' and 'break'

  • Discover how to use try, except, and finally

  • Learn how to raise an exception


Preview 02:09

Expanding Try / Except to use the "finally" and "else" keyword options.

202.02: Using 'Finally' & 'Else'
04:31

Inheritance is the bedrock of Object Orientation. One great way to appreciate Inheritance is to start re-using Exceptions, as well as to create our own classes.

Python's Exception-management hierarchy is also a very good example of what a good programming Framework is all about. By inheriting from the "Exception" Class, our first official class will be opting-in to an important Python, class-management, strategy.

In this lesson we will begin to create our own classes. While a challenging concept in Python, in order to truly master Python 3 we must be able to create our own classes so as to begin to explore Python's Object Framework, or those “Magic Methods,” later on!

Our goals for this lesson must therefore be to:

  • Understand how to create classes & class variables

  • Discover how to use try, except, else and finally

  • Understand how to use package importation

  • Discover how to limit package importation

  • Learn how to create custom exceptions

  • Understand class initialization

  • Review how to use 'pass' to create 'stub functions'

203.01: Introduction to Classes: Creating Custom Exceptions (Part II)
03:30

Discover the virtues of Python's "pass" keyword, as well as how to use comments to manage an Exception()al learning experience.

203.02: Importing the “Outside World”
01:49

You write code, I write code, they write code… designed for community support, sharing is truly caring in Python 3!

To enjoy what others have written, as well as to share what we have with others, professional Python Programmers need to understand how to create, as well as to re-use, code from other software developers. In this lesson therefore, we will:

  • Learn how to use Package importation 

  • Understand how to re-use 3rd party packages & names 

  • Discover how to limit package importation

0204: Inspecting the Python Path (Part I)
06:16

Just like testing assumptions in our code, Python's packing conventions allows us to document & test our modules, as well.

Yet Python Professionals also know how to manage a few of those lesser-known ways to include & exclude modules. By simply managing the locations Python uses to find what our code is looking for, we can even swap-in modules that look the same to our code, yet operate quite differently!

In this lesson, we will:

  • Learn how to enumerate the system path 

  • Discover how to list loaded modules 

  • Use built-in functions to explore imported information 

  • Discover how to test exception hierarchies

0205.01: System Paths (Part I)
02:19

Path management, part 2.


0205.02: System Paths (Part II)
05:21

Now that we know how to include and exclude packages by managing Python's search path, we should note that Python also allows us to accomplish much the same thing using code.

In this lesson, we will:

  • Learn how to avoid name collision in Python
  • Understand module documentation
  • Discover 'invisible' package initialization


0206: The Import Alias
04:26

While creating amazing things for ourselves is how most choose to use Python, in Python 3 we can allow our creations to integrate so as to seem to be “built into” the Python Programming Environment.

While there are many ways to integrate our code into both Python and Python-related Frameworks, one of the best ways to appreciate how Frameworks operate is to allow our own Modules to be used by the help() subsystem!

In this lesson therefore, the you will:

  • Create your own Package

  • Review dir()-accessible module listing

  • Create help() accessible documentation

  • Import and use your own module classes & functions

  • Learn how to test your own modules
0207: Your First Package!
06:32

Into the list of slightly odd, yet easy-to-understand software security paradigms is Python's unique way of protecting class & package members. In addition to code protection however, is our need to access variables and other objects created by ourselves, as well as by others. -Code & class members that Professional Python Experts will need to create and share between the testable applications & infrastructures that make up our programming worlds.

In this lesson therefore, we must:

  • Understand the Global, Local, and Build-in scope
  • Discover how to define & modify global and local variables
  • Learn how to protect module operations and class members
  • Discover how Python's protective “name-mangling” works
0208.01: Modules, Scripts & Scope
03:18
0208.02: Modules, Scripts & Scope (Continued)
01:03

Understand what a "forward reference" is, as well as the best-practice recommendation.

0208.03: Modules, Scripts & Scope (Continued)
02:40

Many old and new Python Professionals alike are surprised to learn that even our function definitions are themselves are typically being bound to a Python Object!

When function are bound to objects, we can of course share them, as well as to add & use functions in some rather surprising places.

In this lesson, we will also:

  • Discover how to share data

  • Revisit string-formatting operations

  • Discover how to avoid %-formatting exceptions
0209.01: Functions as Objects (Part I)
01:46
0209.02: Functions as Objects (Part II)
03:03

Discover how Python keeps track of global and local definitions, as well as some interesting ways to use a class to return a Dictionary.

0209.03: Managing Global & Local Scope (Part I)
02:47

The solution to the activity, as well as the continuation of Part I.

0209.04: Managing Global & Local Scope (Part II)
05:00

Updating our class so as to use "the contents of" operation to list the keywords in a returned Dictionary result.

0209.05: Managing Global & Local Scope (Part II)
03:34

Time for a little trivial pursuit…

Having defined “input” and “output” as two of the three (3) major justifications for writing software at-all, we should not be surprised that Python offers so many data-formatting choices. In this lesson we will:

  • Revisit string-formatting operations

  • Review the entire set of % formatting operations

  • Discover how to avoid %-formatting exceptions
0210.01: More Formatting Opportunities (Part I)
04:02

The solution to our previous activity, as well as the continuation of Part I.

0210.02: More Formatting Opportunities (Part II)
07:43

After having taken a closer look at Python's function-passing & data-formatting opportunities, we can both apply as well as expand what we are learning so as to make life a little easier… as well as a tad more “Pythonic!”

Our goals for this lesson will be to format a dictionary for string, floating point, integer, and field-justified reporting.

0211: Data Formatting Activity
02:17

Practice makes perfect … Python 'Pros!

In this session we can:

  • Practice using and / or / not

  • Learn how to read blocks of Boolean values

0212.01: Conditional Testing (Part I)
02:48

Using elif, as well as the official activity.

0212.02: Conditional Testing (Part II)
05:54
  • Learn how to anticipate dictionary ordering

  • Discover how to create & use a custom sort routine

  • Use the 'sorted' keyword to process several collection types

0212.03: Managing Dictionaries - Sorting
04:01
+ Python 2000: Beyond the Basics, Part II
24 lectures 01:43:22

Having covered Python's classic string-formatting operations, string's more recent ".format" member function offers far better formatting capabilities, as well as many backward-compatible type & format identifiers.

0301: Python's Official String Formatter
05:42

Discover the default object, as well as how class members can do allot of things for us, behind-the-scenes!

From object-creation to type conversion, creating classes in Python 3 requires us to delve deeper into what takes place whenever classes are defined. By understanding when reserved function definitions are helpful as well as how each operate, we are in reality learning more about the “magic methods” most often understood by Python experts. 

In this lesson, we will:

  • Learn how to create your own classes

  • Discover how to protect class member functions

  • Review class initialization logic

  • Learn how to create & recognize "static" member functions

  • Discover how to overload mathematical, as well as other operators in Python

0302.01: Getting Classy: Readng Data Behind-The Scenes
03:42

From object construction & named parameters, to the member & associative functions themselves, adding data to our classes can take place in several ways.

0302.02: Getting Classy: Keyword Initialization Parameters
03:43

Review a solution to the activity that uses three (3) different ways to provide data to our class.

0302.03: Getting Classy: Dual Initialization / Object Factory Solution
01:29

The number of meta methods in play in our object at any moment depends upon object re-use, as well as our own function definitions. While our goal is to understand a mere handful of the most commonly overridden function definitions, there are dozens of Framework opportunities to manage mathematical, type conversions, as well as other keyword-related operations.

In this lesson series, we will:

  • Learn more about the scope of Python's "magic methods”

  • Discover how __new_ and __del__ can change object initialization

  • Create an application that can toggle object creation strategies

  • Discover how keyword & operator usages can be intercepted Learn how to manage Python's per-class framework

  • Review self-initialization best practices

  • Discover how to explicitly manage class member visibility

  • Learn how to locate protected member-functions in other modules



0303.01: More "Meta Methods" (Part I)
06:12

Review a solution to the previous activity that demonstrates yet another re-use best-practice.

More Meta Methods, (Part II)
01:55

The way that we choose to create & manage our objects can dramatically influence how subsequent operations are applied. From being ignored to simply being used every time, in this lesson we will document some unexpected ways object creation can affect objection retirement.

Our mission in this lesson will be to:

  • Learn more about the scope of Python's “magic methods”

  • Discover how __new_ and __del__ can change object initialization

  • Create an application that can toggle object creation strategies

0304.01: Case Study: Object Creation & Deletion
10:41

Discover how the operation of our class can change merely by adding the __new__ meta method.


0304.02: Case Study (Part II)
02:26

When it comes time to swap-out content on-demand, very few programming languages can compete with Python's “Content Managers.”

Activated via keyword, in this lesson we will delve deep into the realm where very few new software developers find the need to go. Yet not matter if we use content managers frequently or not-at-all, students should be very interested in knowing what content managers do, as well as how to create them.

In this lesson we will:

  • Learn how to dynamically manage object content

  • Discover how to use "with" to manage meta-methods

  • Learn how content managers are used in the real world

  • Create & test your own Content Manager

0305: Pythonic Content Management
08:53

Don't be too intimidated by the term “Lambda.” -If you are like most new software developers, you've probably never heard the term before!

But understanding what is meant by “headless functions” is not only important, but can be key to impressing others with your comprehensive mastery of the Python language!

  • Learn more about passing functions as parameters

  • Learn how Lambda can be used to sort, select, and manage operations

  • Learn how to pass multiple parameters to a Lambda functions


0306.01: Lambdas - Lambs A & B
03:06

While Python allows us to name our Lambdas, the most anticipated usage is 'anonymous.'


0306.02: Anonymous Lambda
02:56

In Python, even function definitions can be changed. Replacing a built-in function with an instance of a string, let's discover how we can press on so as to use String's member functions to accomplish string-formatting operations ... without using formatting expressions.

0306.03: Re-Defining Built-in Functions & Faster String-Formatting Operations
03:17

Accessing & managing binary patterns is a necessary part of device control & robotics. Because deciphering and constructing might be very important for many Python Professionals, int this lesson we will:

  • Review low-level / bit representational concepts

  • Learn how to convert binary formats to classical string representations

  • Create a program to display hexadecimal, octal, binary and decimal formats

  • Use Python's int() function to convert between the most popular, integral, string-representations

0307.01: Characters, Numbers, Bits & Bytes (Part I)
07:22

From encoding "white space" to "special characters," modern Python can utilize far more than the classic set of character values.

  • Discover more about big-endian & little-endian formats

  • Learn how to "dump" data using bytearray()

0307.02: Characters, Numbers, Bits & Bytes (Part II)
04:48

The good news in Python 3 is that the default character type is now large enough to support different national languages. Because the need to support classical 8-but characters remains extremely important however, students should be comfortable with understanding not only what ASCII is, but also in creating classic, ASCII-encoded reports.

In this module we will continue our deep-dive into the bits any bytes of Python 3 by:

  • Learning how to use range() to enumerate arbitrary table sizes

  • Learn more about printable ASCII characters

  • Use keywords to create elegant column-formatted reports

  • Create your own ASCII Table generator


0308.01: Reporting, Columns, and ASCII Values (Part I)
03:38
0308.02: Reporting, Columns, and ASCII Values (Part II)
02:00
0308.03: Reporting, Columns, and ASCII Values (Part III)
01:30

Sometimes the definition of “number crunching” involves the use of a never-ending process. When in comes time to plow through possibly never-ending collections of data and / or operations therefore, we need to review a Python construct & keywords that will allow us to carry-on through a seemingly innumerable number of iterations.

In this module we will:

  • Discover how to use 'continue' and 'break'

  • Learn how to use an “infinite loop”

  • Learn how to manage independent variable loop-control

0309.01: Loop-Management: Keywords, Concepts for Data-Crunching (Part I)
03:23
0309.02: Loop-Management: Keywords, Concepts for Data-Crunching (Part II)
01:58

In-memory locations are traditionally specified in a common hexadecimal format. While the default address of objects in memory can never be assumed in Python 3, students should become familiar with how objects can be uniquely identified in Python.

In order to become more familiar with object-identification in Python 3, in this session we will:

  • Learn how the id() built-in operates

  • Discover how to locate the address of an object in CPython

  • Learn how to understand the distance between address in CPython

  • Understand how variables & collections manage object references

  • Learn how to reference dis-associated & orphaned data reverences

0310: Object Identificaiton & Address
05:21

Into the realm of professional terms arrives our need to understand the difference between “shallow” and “deep” operations. While the names might appear obvious to many, the need to understand how to track the absolute identity of any object we are sharing is an important technique to master.

By way of becoming familiar with shallow, deep, as well as positively identifiable object locations therefore, in this lesson we will:

  • Understand when to use a “shallow copy”

  • Compete the official activity for using id()

  • Understand when to use a “deep copy”

  • Discover how a collection's “shallow copy” can be updated

  • Learn how to protect mutable data collections from unexpected changes

0311: Understanding “Shallow” & “Deep” Operations
07:08

•    Discover how to write a function combined data into a unary / tuple parameter
•    Discover how to write a function that can combine references into a dictionary
•    Learn how to write code that can work with either a tuple or a dictionary

Tagging & Combining Parameters (Part I)
02:43
0401.02: Tagging & Combining Parameters (Part 2)
02:12

When writing in Python – as well as other languages – the need to define a “null,” or empty value can be extremely important.

In addition to having a way to define nothing, or “none” in Python, the language also provides a way to manage what we assume certain values are.

In this lesson, we will:

  • Learn where and when to use the “None” keyword

  • Discover how assert() can be used to maintain software integrity

  • Create, reference, & overload class variable names

0402: Verifying & Managing Assumptions
07:17
+ Instance & Object Detection / Management
9 lectures 28:45

Professional software developers share a common anthology of terms & concepts. No matter if we are writing Python, C#, C/C++ or Java, understand what Object-Orientated software developer mean by “isa” and “hasa” is a very important topic to become familiar with!

In this lesson we shall:

  • Learn how to compare built-in types

  • Discover how to custom object parentage

  • Learn the difference between “isa” and “hasa”

0403.01: The "IsA" and "HasA" Relationships
05:49
0403.02: Object Relationships (continued)
02:43
0403.03: Object Relationships (continued)
04:01
0403.04: Object Relationships (continued)
01:13
0403.05: Instance Detection (Part I)
04:23
0403.06: Instance Detection (Part II)
01:20
0403.07: Metaclass Detection
02:00
0403.08: Has-A, Part I
05:31
0403.09: Has-A, Part II
01:45
+ Closing Concepts
4 lectures 17:48

One of the most difficult concepts to understand is also key to understanding how Python operates in-action. Known as “Generators,” mastering the use of one final keyword is required to rocket our understanding of Python into the realm of professional topic mastery.

In this lesson we will:

  • Learn how to use the yield keyword to halt & resume operations

  • Create your own generator

0404.01: Totally Amazing Generators! (Part I)
04:53
0404.02: Totally Amazing Generators! (Part II)
01:26

In addition to understanding how to create robust scripts & applications written in Python 3, the hallmark of an accomplished Python Professional is to provide “Pythonic” solutions. But what does it mean to write software that is “Pythonic?”

In order to clearly understand what it means to be “Pythonic,” in this lesson we will review the common definition. We will also review several examples to as to understand the difference between code that “smells good” and code that we should be able to clearly identify as not being Pythonic.

So our goals for this lesson are to:

  • Understand what it means to be called “Pythonic”

  • Review community definition

  • Discover more resources!

0405: What is “Pythonic”?
06:00

Python 2000's closing lesson will:

  • Review topics presented
  • Complete a Keyword Review
  • Present Answers to Common Questions
0406: Python 2000 - Review
05:29
Requirements
  • Students must have installed Python 3.x or greater.
  • Students must know how to create, run, and debug Python using IDLE3, or an IDE equavalent.
Description

New Python 3 Programmers Welcome!

Designed for the students with a basic understanding of Python, this intermediate training opportunity will focus upon using Python for creating classes, managing packages & paths, creating frameworks, as well as exploring more advanced & modern topics in Python 3.

In the Python 2000 series students will complete keyword mastery by exploring a large collection of activity-related topics. Sold separately, in the 2000 series students will enjoy learning how to create Lambdas, Generators, Context Managers, Packages & Modules, Classes, Factories, Frameworks, how to manage Exceptions, as well as other professional programming topics.

Who this course is for:
  • Students must have completed Python 1000, or have an equivalent background in Python 3.