This Session

Session details:

• Time: 90 min
• Target Level: Novice/Intermediate†
• Prerequisites: strong familiarity with basic Python syntax

† Note: this session is designed for ambitious (!) novices—it will be fast-paced, dense session, and packed with critical subtleties & nuances but will cover ground you have likely trod before.

Abstract

In this session, our goal is to talk about the mechanics behind the CPython interpreter, to gain a better understanding of how we can design our code to make use of these mechanics, and to find ways to use this knowledge to better debug, investigate, and hot-patch our code.

We will look to answer the following questions:

• What are exec and eval? How do they work? Should I ever use exec or eval in my code, or should these be strictly avoided?
• What happens when I define a class? What purpose does type and do metaclasses serve? What is __new__ vs __init__? What is __prepare__? What is __set_name__?
• What is super() and how does it work? How does single-argument super() reference the build-time class? What is name-mangling and where does it come up in practice?
• What happens when I import a module? What is the difference between the different styles of module import (import … vs from … import …)?
• What happens when I define a function? What is a closure? What are mutable default args?
• What happens when I refer to variables in a defined function? How does scoping work in Python? Is Python pass-by-value, pass-by-reference, or something else entirely? What do the nonlocal and global keywords actually do?

Series Overview

In this seminar series, we will pick up where we left off in our “Python Basics for Experts” seminar series held in December 2021. In that series, we answered questions about the built-in data types, about the core language syntax, and about major features. We started each question by presenting the most basic perspective —the thing that catches your curiosity, that makes you go “hmm,” that gets you digging—then discussed mechanics, motivations, metaphors, and meaning from the perspective of an expert. Finally, we wrapped back around to how each of these questions and each of these topics will have immediate, material impact on your code… irrespective of whether you are a beginner or an expert!

In the first series, we discussed:

• The built-in data types
• Why does dict raise KeyError rather than return a sentinel value?
• Why does tuple even exist in the first place?
• What makes something hashable?
• What is the difference between identity & equality?
• What is the difference between str and bytes?
• Is str a container? Of what? (What else is a container?)

• The core syntax
• What's with all the stars?
• What's with all the stars (again)?
• Why even lambda?
• Why even comprehension syntax?
• Do I really need another way to format strings?
• Why do I need another way to assign a variable?

• The features
• Why do I need context managers?
• Why do I need generators?
• Why do I need coroutines (generators with .send)?
• Why do I need decorators?
• Why do I need Coroutines ("asynchronous functions")?
• Why do I need object orientation?

Lesson plan

• Session I: How are things designed? (August 5, 11:30am EDT)
• In our first seminar in this series, we will answer questions of motivation: why do certain things exist and how do we incorporate them into the design of our code?

• Session II: How are things created? (August 12, 11:30am EDT)
• In our second seminar in this series, we will answer questions about the parts of the Python runtime you may not typically consider—e.g., the construction of modules on import, the construction of types via the class statement, the construction of functions via the def statement. How do these things come into being, and how can they affect our code?
• Bonus Session: How did you (even) know this? (August 18, 11:30am EDT)
• In our bonus seminar in this series, we will show you how we are able to answer all of these questions. We will discuss how to decompile Python code into bytecode, how to build CPython from source, how to debug CPython using gdb, and how to gain greater insight into what the interpreter and your code are actually doing.

• Session III: How are things executed? (August 19, 11:30am EDT)
• In our third seminar in this series, we will answer questions about the execution of Python code—e.g., how does attribute lookup actually work, what is the descriptor protocol, how do memory management and garbage collection work, what are generators and asynchronous functions under the covers? … and, of course, why does this all matter?
• Invite-Only VIP Session (August 19, 2pm EDT)
• Finally, in our VIP session, we’ll revisit all of the above questions with attendees. We will provide our VIP attendees with a series of challenges that require an understanding of each of these questions, and guide them in discussion through solving these challenges, giving them the ability to more effectively debug, instrument, and hot-patch their code!

Your Presenter (James Powell)

James Powell is the founder and lead instructor at Don’t Use This Code. He currently serves as Chairman of the NumFOCUS Board of Directors, helping to oversee the governance and sustainability of all of the major tools in the Python data analysis ecosystem (i.e., pandas, NumPy, Jupyter, Matplotlib). At NumFOCUS, he helps build global open source communities for data scientists, data engineers, and business analysts. He helps NumFOCUS run the PyData conference series and has sat on speaker selection and organizing committees for 18 conferences. James is also a prolific speaker: since 2013, he has given over seventy conference talks at over fifty Python events worldwide. In fact, he is the second most prolific speaker in the PyData and Python ecosystem (source: pyvideo.org).

FAQ

What does each ticket type include?

• A Live Attendance ticket allows you to attend a single session live. You will have access to a website where all of the session notes are posted.

• A Live Attendance+ ticket is a single-event pass which offers:
• Live attendance at the event
• A professionally-edited, HD video recording of the seminar
• Complete notes including every checkpoint of the evolution of the code in a GitHub repository

• The Bonus Package provides:
• Attendance at and materials (video, notes) from all sessions including any Bonus Session(s) in the series
• Detailed Study Guides to help you get the most out of the sessions

• The VIP Package provides everything in the Bonus Package, PLUS an invite to an exclusive, "behind the scenes" live interactive coding challenge with our Presenters!

I purchased one Live Attendance+ ticket, but now I’d like to purchase one of the packages. Do I need to pay full price?

No! If you’d like to purchase a ticket package after purchasing a single Live Attendance+ ticket, contact us at info@dutc.io to let us know. We’ll credit the cost of your single ticket towards the purchase of the package ticket.

I can’t attend the seminar live. Should I still register?

Yes! The week after a seminar, everyone who registered with one of our paid tickets will receive:

• An HD, professionally-produced video of the presentation - You can watch the video any time you like and refer back to it later.
• Complete PDF notes including all of the code from the sessions
• (Bonus & VIP Packages only) Study guides for each session

I missed the first seminar in a series. How do I benefit from attending the subsequent sessions?

The best way to catch up is to purchase one of our ticket packages. If you purchase a package after one or more sessions have already concluded, we will send you the video and materials from the session(s) you missed.

To get the most out of the material, purchase the VIP Pass to attend our invite-only, interactive coding session!

Will the seminar be recorded? Are recordings available?

Yes, the seminar will be recorded and professionally produced. In the week following the seminar, anyone who purchased a Live Attendance+ or a ticket package will receive a link to the video at the email address associated with their EventBrite account.

Can I get a detailed receipt to submit for a corporate training reimbursement?

Yes - email us at info@dutc.io and we will provide you with an invoice.

What is your refund policy?

Receive a full refund if you cancel your ticket 24 hours in advance.

However! If you have to cancel because you can’t attend live, know that we send the videos out to everyone who has registered for one of the paid ticket types.

Our Offerings:

Subscribe to our newsletter (https://bit.ly/expert-python) to stay up to date on our offerings and receive exclusive discounts.

Team Courses & Private Bookings

We offer a wide variety of private training courses for your team on topics such as:

• “Scientific Computing with NumPy, pandas, and Xarray”
• “Fundamentals of Programming for Analysts”
• “Introduction to Python for Data Analysis”
• “Mastering pandas for Data Analysis”
• “Dashboarding & Data Pipelines in Python”
• “Web Scraping & Text Parsing for ETL”

Our courses and seminars are designed with the “why” at the forefront of everything we do. As a result, the courses balance information, exercises, and case studies that help encourage attendee success.

Courses are developed to fit the needs of multiple levels of mastery. We strive to ensure that every attendee is taught personally and that all the time they commit to learning is magnified.

Open to the Public

Once per quarter, we hold our Developing Expertise in Python course, open to the public!

This course is three full days of intensively personalized hands-on instruction within a small cohort (≤10). Sessions begin with individual interviews with each attendee to assess current levels of understanding and set specific, measurable goals for their individual growth and professional development

No lecture, no slides—the sessions are driven entirely by discussion around concrete live-coded examples with detailed prep & supplementary review materials (≥50 pages of background course notes and ≥10 hours of background videos) provided.

See our Organizer Page for info on upcoming dates!

Don’t see a course you need? Contact us at learning@dutc.io to get the curricula you’re looking for!