Python 2000: Beyond The Basics

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.

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.

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

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

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

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'

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

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

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

Path management, part 2.

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

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

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

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

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

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

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

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

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

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

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.

Practice makes perfect … Python 'Pros!

In this session we can:

• Practice using and / or / not

• Learn how to read blocks of Boolean values

Using elif, as well as the official activity.

• Learn how to anticipate dictionary ordering

• Discover how to create & use a custom sort routine

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

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.

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

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

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

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

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

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

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

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

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

  
  

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

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.

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

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()

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

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

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

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

•    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

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

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”

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

We'll see many strange looking lists created by a process known as "Comprehension." While mastering "List Comprehensions" is important, another secret is that we can use the same comprehension process to triage & filter data into sets, dictionaries, and other collection types!

From the “scripting” commons to named class creations, the pinnacle of 'pythonisms is how even unrelated types often operate much the same.

Yet while many "sequence types" interoperate well, dictionary, tuples, and sets have each their own unique idioms to be aware of.