Python 2000: Beyond The Basics

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.

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!

Python 2000's closing lesson will:

• Review topics presented
• Complete a Keyword Review
• Present Answers to Common Questions