Learning Python

A Python training course

Looking for professional, on-site Python training? Mark Lutz, author of multiple O'Reilly Python books, is now offering a general 2 or 3-day Python training course, taught at your company or organization. Starting in 2000, this class will also be held regularly in Boulder, Colorado.

Course overview

Python is a popular object-oriented scripting language, used for a wide variety of programming tasks. In this course, Mark provides an intensive, hands-on introduction to the Python language, as well as common Python tools and applications. Through lectures and laboratory work, students learn the basics of Python programming. In addition, each student receives a 250-page course handbook filled with material and examples used in the course, in both HTML and hardcopy form.

Course details

This document describes the course outline and schedule, the course fee structure, and the instructor's background. It's composed of the following sections:

1. Announcements
2. Instructor qualifications
3. Course outline and schedule
4. Financial details
5. Miscellaneous details

Contacts and references

For more information on Python training, please send email to the course instructor, at "lutz@rmi.net" (click here), or see the other contact points listed near the end of this page. References from prior clients of this course are available on request; for a partial list of prior class sessions, see the instructor's calendar page.

ANNOUNCEMENTS

• (11/99) Classes to be held in Boulder, Colorado
  Beginning in 2000, this Python class will also be taught in Boulder, Colorado, at Tom Christiansen's training facilities. Mark Lutz will be the instructor. Classes will be regularly scheduled, but are available on a first-come first-served basis. Class schedules are to be posted in November, 1999. All administrate, travel, and registration support is being provided by the Tom Christianson Perl Consultancy. For general information, please visit this page. For class schedules please visit this page after November, 1999.
  
  
• (11/99) Course material now available in HTML
  Beginning 11/99, class workbook material will be shipped in both hardcopy paper form (which clients generally copy for each student), as well as in a new HTML form that can be read with any standard web browser. Among other things, the HTML form makes it easy to jump between lectures, labs, solutions, source-code files, and related information. It's also more convenient for cut-and-paste of example code. Provided students have access to a web browser, the HTML workbook format subsumes both the hardcopy form and source-code disk, and is an alternative to making paper copies.
  
  
• (11/99) Course structure change
  The standard pricing structure for courses taught on-site was recently revised, to better accommodate customer needs. The new standard structure allows for either a 2 or 3-day session:
  
  
  • For 2 days: $5500 + travel expenses
  • For 3 days: $7000 + travel expenses
  
  In practice, I've found that most sessions fall into one of the two categories above. If you want a 2-day session, you can pick and choose topics from the full 3-day course description below. For instance, one client company in Atlanta elected to focus on the core language, and omit the Python/C(++) integration modules. Other companies have chosen to first hold a 2-day introductory level class, followed by a 2-day advanced topics session. Naturally, these prices only apply to on-site classes (see the links above for per-student fees for classes held locally in Boulder), and prior clients may elect to use the older fee structure instead.
  
  

INSTRUCTOR QUALIFICATIONS

Python background

Mark Lutz is one of the primary figures in the Python community. He has been involved with Python since 1992, and was one of its earliest adopters and evangelists. More recently, the instructor wrote the definitive book about Python: Programming Python, published by O'Reilly & Associates in October, 1996. This book is generally considered to be the most comprehensive source of Python information available. Since 1996, Mark has also written a 120-page chapter about Python for a book published by Macmillan, authored O'Reilly's Python Pocket Reference, and co-authored O'Reilly's new book Learning Python, which is based in part on this course. Mark earns his living as a Python trainer, writer, and contract developer.

General background

Besides Python experience, the instructor is also a software engineer with 13 years experience, and holds Bachelors and Masters degrees in computer science from the University of Wisconsin. His work background includes compilers, development environment GUIs, network programming, client/server systems, and business applications. His full resume is available on-line, at URL http://rmi.net/~lutz/resume.html.

Training experience

This course has been presented at a variety of organizations in and outside of the country, ranging from small companies, to large research centers. For a partial list of places where this course has already been held, please see the instructor's Python commitments calendar. Besides this course, the instructor's training background includes in-company Python training, as well as end-user training for a C-like scripting language. In addition, he has given talks at Python conferences, and UNIX and Linux user group meetings (see the abstract and materials from a past UNIX group talk).

COURSE OUTLINE AND SCHEDULE

This section describes the high-level outline and time schedule, for the full 3-day course session (2-day sessions generally cover a subset of the topics listed here). This is intended to be a flexible course plan. Other modules and topics may replace the standard material here, and/or selected topics may be given more or less time, depending on your training needs.

High-level outline

The current offering is a general Python course, composed of four main sections:

1. Introducing Python
   • General Python introduction
2. Python Basics
   • Using the interpreter
   • Types and operators
   • Basic statements
   • Functions
   • Modules
   • Classes
   • Exceptions
   • Built-in tools
3. Python Applications
   • System interfaces
   • GUI programming
   • Python object persistence
   • Text processing
   • Internet scripting
   • Extending Python in C/C++
   • Embedding Python in C/C++
4. Where to go from here?
   • Python packages and resources

Lab work

This course is designed to provide a hands-on, interactive learning experience. The course includes 30 minutes of lab work after each 1 hour of lecture time. Lab sessions are scheduled four times a day, with extra time at the end of the day for further work. I have given this course without lab sessions, but they tend to be a crucial component of the class, and are strongly recommended.

The labs ask students to write simple programs, as well as modify pre-coded examples. Later exercises demonstrate more advanced concepts and tools (simple Tkinter GUIs, C integration, etc.). The final lab (day 3) also points students to online Python resources, provided the lab machines have Internet access. Answers to all lab exercises (as well as source code for all examples) will be provided on disk with the course materials.

Course session schedule

To give you a better idea of what the course will be like, here is a typical schedule for the 3-day course with lab time. Note that this is just a general guideline: it will vary depending on course customizations and student needs. 2-day courses pick and choose from the topics and sessions listed here.

The standard course is 3 training days, running 9-5 each day (8 hours). The course provides 4 hours lecture per day, with 4 30-minute labs each day, an extra hour for more discussion or lab work, and breaks for lunch. That comes out to roughly 12 hours of lecture, 6 hours of labs time, and 3 hours for extra needs.

Day 1
    General Python introduction   30 min     9:00 - 9:30
    Using the interpreter         30 min     9:30 - 10:00
        lab 1                     30 min    10:00 - 10:30
    Types and operators           1 hour    10:30 - 11:30
        lab 2                     30 min    11:30 - 12:00
        lunch                     1 hour    12:00 -  1:00
    Basic statements              1 hour     1:00 -  2:00
        lab 3                     30 min     2:00 -  2:30
    Functions                     1 hour     2:30 -  3:30
        lab 4                     30 min     3:30 -  4:00+
        extra time                1 hour
 
Day 2
    Modules                       1 hour     9:00 - 10:00
        lab 5                     30 min    10:00 - 10:30
    Classes                       1 hour    10:30 - 11:30
        lab 6                     30 min    11:30 - 12:00
        lunch                     1 hour    12:00 -  1:00
    Exceptions                    30 min     1:00 -  1:30
    Built-in tools                30 min     1:30 -  2:00
        lab 7                     30 min     2:00 -  2:30
    System interfaces             30 min     2:30 -  3:00
    GUI programming               30 min     3:00 -  3:30
        lab 8                     30 min     3:30 -  4:00+
        extra time                1 hour
 
Day 3
    Python object persistence     1 hour     9:00 - 10:00
        lab 9                     30 min    10:00 - 10:30
    Text processing               30 min    10:30 - 11:00
    Internet scripting            30 min    11:00 - 11:30
        lab 10                    30 min    11:30 - 12:00
        lunch                     1 hour    12:00 -  1:00
    Extending Python in C/C++     1 hour     1:00 -  2:00
        lab 11                    30 min     2:00 -  2:30
    Embedding Python in C/C++     1 hour     2:30 -  3:30
        lab 12                    30 min     3:30 -  4:00+
    Packages and resources        30 min     4:00 -  4:30
        extra time                30 min

FINANCIAL DETAILS

The following paragraphs describe the components that you may be billed for, depending on your needs. All applicable fees should be described in the training agreement. Like the outline, this is just a standard fee structure; it can vary depending on your requirements. Also note that this section only applies to on-site classes; see the announcements section for links to per-student fee information, for classes held in Boulder.

1. Standard course fee: $7000 (3 days), $5500 (2 days)
   The standard fee for the course is either $7000 for a full 3-day session, or $5500 for a 2-day session. The general 3-day session is recommended, but a 2-day session is offered as an option for clients with more focused needs. This base fee allows for up to 15 students, and does not include the cost of travel to your site, or materials duplication.
   
   
2. Travel expenses fee: $950 (average)
   For out-of-town courses, clients are also expected to pay for the instructor's travel costs. This includes airline tickets, lodging, rental car, and meal expenses incurred while training at your site. These expenses vary by location and amount of advance notice, but they have generally run between $900 and $1000 in practice.
   
   
3. Over 15 students fee: optional
   The base course fee allows for 15 students. I generally recommend keeping class size to 15 or fewer students per session: based on my experience, the quality of the course tends to degrade when there are too many students. But if you need to have more than 15 students in a session, you will be charged an additional $500 per student beyond 15.
   
   
4. Course materials duplication fee: optional
   For on-site courses, there are two ways we can arrange to provide copies of the course workbook materials to students. (1) I can send you a paper copy of the course materials, for you to make copies at your site. The material will be sent by mail (overnight delivery is acceptable). (2) If you prefer, I can instead copy the materials here and ship them to your site ahead of time. In this case, you will be charged the cost I incur to duplicate and ship the material. I prefer option (1), and so have all my clients so far. In some cases, overhead transparency copies may also be required.

To calculate your cost, add the fees for all four fee categories above which apply to your situation. For instance, here are a few typical fee scenarios:

• For a 2-day on-site course, 15 students, you make copies: $6450
  A 2-day course for up to 15 students at your site will cost $5500 (base fee), plus the instructor's travel expenses (somewhere around $950). Depending on how you wish to arrange course material duplication, you might also be charged a shipping/copying fee, but most clients prefer to copy the material themselves.
  
  
• For a 3-day on-site course, 15 students, you make copies: $7950
  The full 3-day course for up to 15 students at your site will cost $7000 (base fee), plus the instructor's travel expenses (somewhere around $950), assuming you make the workbook copies.
  
  
• For a 2-day in-town course, 10 extra students, you copy: $10500
  A 2-day course for 25 students within driving distance of the instructor's home will cost $5500 (base fee), plus $5000 for the extra 10 students beyond the 15 student cutoff ($500 each), plus the cost of copying the course material if you ask me to do it for you.
  
  

The next few paragraphs go into further details on other aspects of the fees and contract.

Instructor expenses arrangements

In addition to the $5500 or $7000 base fee, the client picks up the cost for the instructor's travel to the training site, as described above. I'm flexible as to how to arrange for travel expenses. You can either (1) arrange transportation and lodging for the instructor ahead of time, or (2) have the expenses added to the bill after they are incurred. In either case, a "not to exceed" clause for travel expenses in the contract is acceptable. If I pay any travel expenses, I will submit a detailed invoice after the course, listing all billed expenses, along with receipts.

Course text books

Besides the training materials, each student should have a copy of Programming Python, from O'Reilly & Associates. The course will refer to examples, sections, and exercises in the book. This book will also serve as a source of supplemental information. If you don't already have copies on hand, this text can be purchased directly from O'Reilly (see URL http://www.ora.com); for orders of 10 or more, they generally give 25% discounts off the list price. Online stores such as www.amazon.com sell at discounts as well.

I strongly recommend (but don't require) students to have copies of the Python Pocket Reference book too; this small book is an easy-to-use Python reference, and will be valuable to students after the course. The new O'Reilly book, Learning Python may also be useful as a course supplement, but is optional reading; much of it is the same as class materials.

Per-day and per-student costs

To keep things simple, I prefer to charge the $5500/$7000 flat-rate fee (plus expenses) for the course. But as a basis of comparison, at the $5500 2-day rate, this comes out to $2750 per day, or $366 per student (for 15 students). At the $7000 3-day rate, that's $2333 per day, or $466 per student. Depending on your situation, also add in the copying costs and travel expenses to get more accurate day/student figures.

Follow-up training and consulting

At this time, I'm only offering the customizable 2 or 3-day general Python course, held on-site at your company or locally in Boulder. However, additional course time in advanced subjects can be scheduled on a specialized basis. Moreover, it's simple for me to split the class into a 2-day Introduction to Python class, to be followed by a 2-day Advanced Python class. Some clients have also asked about having me on site for more than three days; if you're interested in this option, let me know. I'm available for extra days of training, and I also do Python contract development and consulting on an hourly basis.

A few words about my rates

If you shop around, I think you'll find that my course fees are competitive by training standards. For instance, comparable Perl language training can typically cost $2500 to $3000 per day plus expenses, and training houses often charge much more (in fact, up to 3 times more, for classes offered by large companies).

Contract and payment arrangements

Now for the legalese. Payment is normally due on delivery of services. You can either pay the instructor on site, or be billed by me after the course. I prefer the former, but some travel expenses may not be known while I'm still at your location, and some companies have standard accounts payable policies in place (e.g., net 30). We can prepare a contract, purchase order, or verbal agreement, but the following sorts of details should be worked out ahead of time:

1. Course dates and location
2. Number of students expected
3. Estimated total cost, with detailed breakdown of charges
4. Travel expense arrangement
5. Materials duplication arrangement
6. Payment arrangements/terms
7. Any desired customizations to the standard outline and schedule
8. Hardware configuration you plan to provide for labs
9. Any other special requests you'd like to make

MISCELLANEOUS DETAILS

Course setup requirements

The following is a comprehensive checklist of everything you should do to prepare for a successful class at your site, along with a few optional things that have helped in prior sessions.

Required items:

• Lecture room: For lectures, I require only an overhead projector, and some sort of surface to write on (e.g., whiteboard, flippad, or blank transparencies).
  
  
• Workbooks: Assuming you do the copying locally, each student should have a paper copy of the course workbook material I ship in advance. (Note: now that the material is also shipped in HTML form, you can also elect to have students view it on a web browser instead.)
  
  
• Lab machines: For the lab work, students should have access to a computer with Python 1.4 (or later) installed. In the past, students have used everything from UNIX and Linux workstations, to notebooks and handheld PCs; Python runs just about everywhere, so this is very flexible. Generally, lab work is done on machines that are located in or carried to the lecture room. It's also okay to have students do work on machines in their offices, but the lab sessions are much more productive when the instructor somehow has contact with students during the lab times.
  
  
• Python install: The Python installation that students will use to do lab work should ideally include support for the Tkinter and dbm extensions for the GUI and persistence exercises. Ask me if you need assistance with this.
  
  
• Text editor: Students should also have access to whatever text editors are commonly used at your site--probably vi or emacs on UNIX/Linux; Notepad is sufficient on Windows. If you have installed Tk support in Python, the IDLE graphical interface can be used as a text editor as well.
  
  
• Text books: See the course text information in the financial details section. Each student should generally have a copy of the course text when the class begins.
  
  
• Source code disk: I ship or bring a MS-DOS format disk containing source-code for all the examples, as well as solutions to all lab exercises; you should make it or its contents available to students (e.g., copy it to an accessible server directory, or onto the lab machines).
  
  

Optional items:

• C compiler: If you want students to do the Python/C integration exercises, you'll also need to have a C compiler and a "make" utility on the lab machines. Students rarely get to these exercises, so this is only important if you wish to focus on C integration.
  
  
• Python manuals: Besides the course text (described above), it sometimes helps to also have copies of the standard Python manuals on-hand, especially if students can't view them online on the Internet. The manuals are available in postscript and HTML form, from URL www.python.org; ask me if you need assistance.
  
  
• Internet access: There is one optional FTP exercise in the labs too; lab machines will need Internet access if you want students to work though it. The CGI examples require Internet access to run, but they aren't exercises.
  
  
• Web browser: Students need access to a web browser to view the HTML form of the workbook (but it's also distributed in hardcopy paper form).
  
  
• Laptop projector: I usually bring a laptop to show Python program demos; if you can supply a projection interface for that, it helps, but is not required.
  
  

Instructor location

I live in Colorado, just outside Boulder. So, out-of-town for me means anything outside the area from Denver to Fort Collins.

Instructor availability

Please inquire at my email address or phone numbers below. The upcoming commitments list at this page is only updated rarely, so it's usually out of date. As a general rule, it's good to allow a few weeks between reaching an agreement and the course itself (especially if you ask for customized materials), but I have been known to fly out with just a few days notice.

Instructor contact information

Email is usually the best way to get in touch with me, but here are my other coordinates for your records:

    name:        Mark Lutz
                 Independent Python Trainer
    email:       lutz@rmi.net
    phone:       (303) 684-9565
    web:         http://rmi.net/~lutz
    address:     1907 24th Avenue
                 Longmont, CO. 80501

Note: as of 10/15/99, the old phone number that used to be listed here, 303-581-4732, is no longer active. Please use one of the other contact points above, instead.

Copyright 1997, 1998, 1999, by Mark Lutz

Back to my homepage