When you go to the tutorial, though, you have to wade
through quite a bit of English before seeing any
Python examples.

Below is my attempt at generating ten fairly simple,
representative Python programs that expose new users
to most basic concepts, as well as the overall syntax.

It was an interesting exercise.  I constrained myself
to ten lines or less, and it was pretty easy to
incorporate loops, conditionals, print, open(), lists,
tuples, dictionaries, and imported modules.  

It was harder to show classes, and my ShoppingCart
class is nothing more than an encapsulation of a list,
which has dubious value (although it's the start of
something more useful).

Anyway, here goes:

    ------
    print 'hello world'

    ------
    for name in ('peter', 'paul', 'mary'):
        print name

    ------
    # This is a Python comment. \n is a newline
    name = raw_input('What is your name?\n')
    print 'Hi', name

    ------
    parentRabbits, babyRabbits = (1, 1)
    while babyRabbits < 100:
        print 'This generation has %d rabbits' %
babyRabbits
        parentRabbits, babyRabbits = (babyRabbits,
parentRabbits + babyRabbits)

    ------
    # def defines a method in Python
    def tax(itemCharge, taxRate = 0.05):
        return itemCharge * taxRate
    print '%.2f' % tax(11.35)
    print '%.2f' % tax(40.00, 0.08)

    ------
    import re
    for test_string in [ '555-1212', 'ILL-EGAL']:
        if re.match('\d\d\d-\d\d\d\d$', test_string):
            print test_string, 'is a valid US local
phone number'
        else:
            print test_string, 'rejected'

    ------
    prices = {'apple': 0.40, 'banana': 0.50}
    myPurchase = {
        'apple': 1,
        'banana': 6}
    groceryBill = sum([prices[fruit] *
myPurchase[fruit]
        for fruit in myPurchase])
    print 'I owe the grocer $%.2f' % groceryBill

    ------
    class ShoppingCart:
        def __init__(self): self.items = []
        def buy(self, item): self.items.append(item)
        def boughtItems(self): return self.items
    myCart = ShoppingCart()
    myCart.buy('apple')
    myCart.buy('banana')
    print myCart.boughtItems()

    ------
    # indent your Python code to put into an email
    import glob
    pythonFiles = glob.glob('*.py')
    pythonFiles.sort()
    for fn in pythonFiles:
        print '    ------'
        for line in open(fn):
            print '    ' + line.rstrip()
        print

    ------
    import time
    now = time.localtime()
    hour = now.tm_hour
    if hour < 8: print 'sleeping'
    elif hour < 9: print 'commuting'
    elif hour < 17: print 'working'
    elif hour < 18: print 'commuting'
    elif hour < 20: print 'eating'
    elif hour < 22: print 'resting'
    else: print 'sleeping'

     http://wiki.python.org/moin/SimplePrograms

<nitpick>
Though the code should probably follow PEP 8 guidelines, e.g.
under_scores instead of camelCase for object and method names:

     http://www.python.org/dev/peps/pep-0008/
</nitpick>

     def select_items(self, prefix):
         return [item for item in self.items if item.startswith(prefix)]

--- Steven Bethard <steven.beth...@gmail.com> wrote:

Although I didn't call it out in the email, I tried to
make each program progressively one line longer, so if
somebody wants to write, say, an 11-line class
example, then I will try fill in the gap with another
8-liner.

Did I miss any basic concepts in the first 10
programs?  Maybe an 8-liner could demonstrate command
line arguments?

On May 26, 2:38 pm, Steven Bethard <steven.beth...@gmail.com> wrote:

If we want to just say "well, PEP-8 says such and such," I think this
is an area where the thinking has possibly evolved since 2001.  Also,
I think the PEP would benefit from explicitly discouraging some
practices, such as Hungarian notation.

How's this for a better non-trivial method example:

    MAX_ITEMS_FOR_EXPRESS_LANE = 10
    def canUseExpressLane(self):
        return (len(self.items) <= MAX_ITEMS_FOR_EXPRESS_LANE)

or call it "can_use_express_lane" if you must.

I guess pyparsing with its mixedCase functions and attributes is
doomed for the Dunce Corner.  Too bad for BeautifulSoup, cElementTree,
and wxPython that are also at variance with this canon of Python
coding style. ("Modules should have short, all-lowercase names. ...
Python packages should also have short, all-lowercase names, although
the use of underscores is discouraged.")

--- Paul McGuire <pt...@austin.rr.com> wrote:

I'm thinking you could actually have a progression
from a 1 line program up to a 50-line program.  The
number 50 is kind of arbitrary, but my gut says that
by a 50-line program, you will have demonstrated
almost every useful concept.

Here's my challenge to whoever wants to take it--write
(or find) a program with 20 or fewer lines that
sufficiently motivates the need for classes, has
decent Python style, and is newbie friendly.

The tutorial has this example, which is useful for
demonstrating the syntax of classes, but it doesn't
actually do anything interesting:

class MyClass:
    "A simple example class"
    i = 12345
    def f(self):
        return 'hello world'

It also has a ComplexNumber class, but I don't want to
scare away mathphobes.

It does have this idiom, which I think is worth
putting somewhere into the progression.

class Employee:
    pass

john = Employee() # Create an empty employee record

# Fill the fields of the record
john.name = 'John Doe'
john.dept = 'computer lab'
john.salary = 1000

Maybe try this approach:  pick your top 10/20/50 language features and
develop concise examples. Then order the examples by length as a first
cut (longer examples probably *are* more complex), and then reorder a
bit to handle pre-requisites (introduce a minimum of new features,
preferably 1, per example).  Overall, I'd have a tough time picking
just 10 language features to illustrate, but there are probably 10-20
basic features that will get new people onto fairly productive
ground.  Pick 20 as your example count (50 sounds a bit long), and
stick to it, and then later add "20 More Little Programs" for the next
wave of examples in increasing complexity.

One other nit to pick: have your example classes inherit from object,
to get new people using new-style classes from the get-go.

     (2) To be consistent with surrounding code that also breaks it

Of course, for new code, such as that in this thread, there's no reason
to break from the PEP 8 guidelines.

--- Paul McGuire <pt...@austin.rr.com> wrote:

I recently helped teach a Java programmer to program
in Python, and he learned a lot just by seeing simple
examples.  So I guess my target audience isn't so much
people learning how to program; it's more for
programmers getting their first exposure to Python.

On the other side of the fence, I recently tried to
relearn a bit of Ruby, and I remember being frustrated
by their tutorials, as really, I just wanted to see a
bunch of simple programs, and I can figure out mostly
what they're doing.  Instead, I had to wade through
verbose descriptions of what a variable is, rules for
how you construct identifiers, etc.

But on a more general note, I welcome folks to just
clean up my examples on the Wiki if I accidentally
introduce some bad practices...but preserving line
counts. :)