Python 2000: Beyond The Basics
4.0 (7 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.
80 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Python 2000: Beyond The Basics to your Wishlist.

Add to Wishlist

Python 2000: Beyond The Basics

Secrets of the Pythonic Masters
4.0 (7 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.
80 students enrolled
Created by Randall Nagy
Last updated 8/2016
English
Current price: $10 Original price: $40 Discount: 75% off
30-Day Money-Back Guarantee
Includes:
  • 3 hours on-demand video
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Discover how to share data
  • 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
View Curriculum
Requirements
  • Students must have installed Python 3.x. or greater.
  • Students must know how to create, run, and debug Python using IDLE3, or and 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 lessons, students will also complete their goal of keyword mastery by exploring a large collection of activity-related topics. Students will enjoy learning how to create Python Generators, Context Managers, Re-usable Modules, Exceptions, as well as dozens of other advanced topics.

Who is the target audience?
  • Students must have completed Python 1000, or have an equivalent background in Python 3 or greater.
Curriculum For This Course
30 Lectures
03:05:05
+
Python 2000: Intermediate Programmer Topics
30 Lectures 03:05:05

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

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:24

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 05:53

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.

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'


Preview 05:45

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


Importing the “Outside World”
05:56

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
Testing Packages & Paths
06:17

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


Managing Packages in Code
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
DIY First-Class Package!
06:36

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
Protecting, Sharing & Accessing Code
06:56

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
Functions as Objects
04:33

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
More Formatting Opportunities
04:24

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 using and / or / not

  • Practice using if / elif flow control

  • Discover how to create & use a custom sort routine
Sorting, Formatting, & Selecting Data
05:06

Practice makes perfect … Python 'Pros!

In this session we can:

  • Practice using and / or / not

  • Learn how to read blocks of Boolean values

  • Practice using if / elif flow control

  • Learn how to anticipate dictionary ordering

  • Discover how to create & user a custom sort routine

Conditional Testing
05:53

Time to combine what we have learned so as to create far more insightful objects.

In this lesson we will:

  • Discover how using .format() is more flexible & forgiving than classic formatting operations

  • Learn how to duplicate classic % formatting in format()

  • Learn how to create your own classes

  • Review class initialization logic

  • Discover how keyword & operator usages can be intercepted

  • Review self-initialization best practices

  • Learn how to locate protected member-functions in other modules
Classes, Sorting, & More Operators
06:38

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 Guru's.

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




Python's 'Magic' Classes & Methods
08:59

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, 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



More "Meta Methods"
08:09

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

Case Study: Object Creation & Deletion
06:58

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

Expanding & Contracting Content with “Content Managers”
08:57

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

  • Discover more .format() field-justification options

PY2016_0306 Lambda And Bannerl
06:20

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

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

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

Characters, Numbers, Bits & Bytes
09:37

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


Reporting, Columns, and ASCII Values
06:58

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

Loop-Management: Keywords, Concepts for Data-Crunching
05:19

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

Numeric Object Identification
05:21

Into the realm of professional terms come 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

Understanding “Shallow” & “Deep” Operations
07:12

•    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
04:56

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

Verifying & Managing Assumptions
07:17

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”

Understanding The IsA / HasA Relationship
06:16

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

Totally Amazing Generators!
06:15

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!

What is “Pythonic”?
06:07

Python 2000's closing lesson will:

  • Review topics presented
  • Complete a Keyword Review
  • Present Answers to Common Questions
Python 2000: Topical Review
05:37
About the Instructor
Randall Nagy
3.8 Average rating
168 Reviews
9,655 Students
14 Courses
Consulting Engineer & Educator

I've over 30 years of experience.

"Mr. Nagy presently earns his keep in the world by providing technology mentoring, training, hands-on consulting / software development, & customized content creation services.

Mr. Nagy has served as both a Principal Trainer & Principal Software Development Engineer. His "Linked In" recommendations testify to a 30+ year track record of excellent personal communication skills, design & analysis abilities, as well as superior consulting & training results.

Though tenured, Mr. Nagy is most often described as being extremely technical, yet very personable & easy to get along with.

The author of over 26 Open-Source Projects, Mr. Nagy's hands-on experience includes topics such as C/C++, Python, SO / SOA, Security, Testing, UML, Java/JEE, .NET (C# and VB.NET), LAMP, Hadoop, jQuery, HTML 5, Android, and more. Maintaining techniques in embedded engineering, Mr. Nagy has experience creating custom training for such expert-level, high-performance technologies as IBM Rhapsody.

Technically speaking, "... from the best Service-Oriented practices to embedded engineering, I maintain an extensive hands-on skill set. From Java and C/ C++, C#, PHP, Python, Ruby, HTML 5 and Web 2.0, I have both designed and implemented architectures from the UI / RIA to the server, well into the RFC Layer. …

I also have over 150 successful training / mentoring, publication, and speaking engagements to my credit. Recent experience includes such state-of-the art technologies as Hadoop, Android, WSO2, and TFS."