Python 2000: Beyond The Basics

Python 2000: Beyond The Basics, available at $199.99, has an average rating of 4.25, with 65 lectures, based on 17 reviews, and has 163 subscribers.

You will learn about 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 Understand Python "comprehensions" to quickly filter & collect lists, dictionaries, sets & even strings! 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 Discover advanced Pythoneering topics This course is ideal for individuals who are Students must have completed Python 1000, or have an equivalent background in Python 3. It is particularly useful for Students must have completed Python 1000, or have an equivalent background in Python 3.

Enroll now: Python 2000: Beyond The Basics

Summary

Title: Python 2000: Beyond The Basics

Price: $199.99

Average Rating: 4.25

Number of Lectures: 65

Number of Published Lectures: 65

Number of Curriculum Items: 65

Number of Published Curriculum Objects: 65

Original Price: $199.99

Quality Status: approved

Status: Live

What You Will 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
Understand Python "comprehensions" to quickly filter & collect lists, dictionaries, sets & even strings!
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
Discover advanced Pythoneering topics

Who Should Attend

Students must have completed Python 1000, or have an equivalent background in Python 3.

Target Audiences

Students must have completed Python 1000, or have an equivalent background in Python 3.

Layered Learning

Never a “one size fits all” approach, our training opportunities are divided into beginner(1000), intermediate(2000), and advanced(3000 – 9000) experience levels. Rather than learning things you might not needto know, you can choose the topics that youare most interested in. Written by a Principal Trainer & Principal Software Development Engineer, in order to insure mastery key topics are presented several times, as well as at ever-increasing depth. No practice, no glory?

Python Programmers Welcome!

Python 2000 is designed for students with a basic understanding of Python. In Python 2000: Beyond the Basics students will focus upon using Python for creating classes, managing packages & paths, creating frameworks, as well as exploring more advanced & modern topics in Modern Python.

Beyond Functional

Students will complete keyword mastery by exploring a large collection of activity-related topics. 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.

Training Approach

I have divided all my training into step-by-step modules. Numbered from 1000 to 9000, the numbering system allows us to skip things that we already know to focus upon the things that we do not.

After completing Python 2000 you are ready to next explore a large collection of activity-related topics. Numbered from 3000 – 9000 rather than learning things you might not needto know, you can choose the topics that youare most interested in.

If you are new to programming, then you’ll want to enjoy my free Python Primer.

Course Curriculum

Chapter 1: Python 2000: Intermediate Programmer Topics

Lecture 1: 2100: Welcome to Python 2000!

Lecture 2: 2110: Keywords -v- Built-In Functions

Lecture 3: 2120: Input & Error Management

Lecture 4: 2130: Input & Error Management (Part II)

Lecture 5: 2140: Using 'Finally' & 'Else'

Lecture 6: 2150: Introduction to Classes: Creating Custom Exceptions (Part II)

Lecture 7: 2160: Importing the “Outside World”

Lecture 8: 2170: Inspecting the Python Path (Part I)

Lecture 9: 2180: System Paths (Part I)

Lecture 10: 2190: System Paths (Part II)

Lecture 11: 2200 The Import Alias

Lecture 12: 2210: Your First Package!

Lecture 13: 2220: Modules, Scripts & Scope

Lecture 14: 2230: Modules, Scripts & Scope (Continued)

Lecture 15: 2240: Modules, Scripts & Scope (Continued)

Lecture 16: 2250: Functions as Objects (Part I)

Lecture 17: 2260: Functions as Objects (Part II)

Lecture 18: 2270: Managing Global & Local Scope (Part I)

Lecture 19: 2280: Managing Global & Local Scope (Part II)

Lecture 20: 2290: Managing Global & Local Scope (Part II)

Lecture 21: 2300: More Formatting Opportunities (Part I)

Lecture 22: 2310: More Formatting Opportunities (Part II)

Lecture 23: 2320: Data Formatting Activity

Lecture 24: 2330: Conditional Testing (Part I)

Lecture 25: 2340: Conditional Testing (Part II)

Lecture 26: 2350: Managing Dictionaries – Sorting

Chapter 2: Python 2000: Beyond the Basics, Part II

Lecture 1: 2360: Python's Official String Formatter

Lecture 2: 2370: Getting Classy: Readng Data Behind-The Scenes

Lecture 3: 2380: Getting Classy: Keyword Initialization Parameters

Lecture 4: 2390: Getting Classy: Dual Initialization / Object Factory Solution

Lecture 5: 2400: More "Meta Methods" (Part I)

Lecture 6: 2410: More Meta Methods, (Part II)

Lecture 7: 2420: Case Study: Object Creation & Deletion

Lecture 8: 2430: Case Study (Part II)

Lecture 9: 2440: Pythonic Content Management

Lecture 10: 2450: Lambdas – Lambs A & B

Lecture 11: 2460: Anonymous Lambda

Lecture 12: 2470: Re-Defining Built-in Functions & Faster String-Formatting Operations

Lecture 13: 2480: Characters, Numbers, Bits & Bytes (Part I)

Lecture 14: 2490: Characters, Numbers, Bits & Bytes (Part II)

Lecture 15: 2500: Reporting, Columns, and ASCII Values (Part I)

Lecture 16: 2510: Reporting, Columns, and ASCII Values (Part II)

Lecture 17: 2520: Reporting, Columns, and ASCII Values (Part III)

Lecture 18: 2530: Loop-Management: Keywords, Concepts for Data-Crunching (Part I)

Lecture 19: 2540: Loop-Management: Keywords, Concepts for Data-Crunching (Part II)

Lecture 20: 2550: Object Identificaiton & Address

Lecture 21: 2560: Understanding “Shallow” & “Deep” Operations

Lecture 22: 2570: Tagging & Combining Parameters (Part I)

Lecture 23: 2580: Tagging & Combining Parameters (Part 2)

Lecture 24: 2590: Verifying & Managing Assumptions

Chapter 3: Instance & Object Detection / Management

Lecture 1: 2600: The "IsA" and "HasA" Relationships

Lecture 2: 2610: Object Relationships (continued)

Lecture 3: 2620: Object Relationships (continued)

Lecture 4: 2630: Object Relationships (continued)

Lecture 5: 2640: Instance Detection (Part I)

Lecture 6: 2650: Instance Detection (Part II)

Lecture 7: 2660: Metaclass Detection

Lecture 8: 2670: Has-A, Part I

Lecture 9: 2680: Has-A, Part II

Chapter 4: Extremely Pythonic

Lecture 1: 2690: Totally Amazing Generators! (Part I)

Lecture 2: 2700: Totally Amazing Generators! (Part II)

Lecture 3: 2710: Uber Python: Filtering & Comprehensions

Lecture 4: 2711: Collection & Data Patterns

Chapter 5: Closing Concepts

Lecture 1: 2730: What is “Pythonic”?

Lecture 2: 2740: Python 2000 – Review

Instructors

Randall Nagy
Software Engineer & Educator

Rating Distribution

1 stars: 1 votes
2 stars: 1 votes
3 stars: 3 votes
4 stars: 4 votes
5 stars: 8 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu