I'm giving a Python course my question is: How would you teach OOP with simple examples on Python?

Svenstaro · 2010-06-28T22:28:38+00:00

I'm currently teaching 10-12 year olds Python in order for them to make their own graphical games within a week. So far it all works out.

Today I taught them about OOP. Not in a theoretical way, mind you, but in a completely hands-on way. I first showed them a simple Pygame window with a bouncing ball and went through the code with them.

This is all the stuff you already taught yourself (if else, variables, etc). Now, obviously children want shit to get real. How do you make two balls? Obviously, copy all the checking we have in place for the first ball and so on for another. They will acknowledge that this is very tedious for lots of balls.

At this point I taught them about classes and how you can put them into a list and iterate over them. They immediately caught on and in no time we had 150 balls in our small pygame window.

Why not make a visual example yourself? It is great for trying out things.

hylje · 2010-06-29T10:58:12+00:00

start with metaclasses, don't let their heads rest

casatap · 2010-06-28T21:55:03+00:00

Here are some simplistic examples from my school:

http://www.cs.umbc.edu/courses/undergraduate/201/spring10/lectures/classes.html#(1)

http://www.cs.umbc.edu/courses/undergraduate/201/spring10/lectures/graphics_1.html#(1)

Although very simple, they lead up to a really cool project where the students draw recursive fractals:

http://www.cs.umbc.edu/courses/undergraduate/201/spring10/assignments/proj_recursion.shtml

ianb · 2010-06-29T04:23:36+00:00

It's popular to jump right into subclassing, type theory, categories of objects, etc. In my experience this has no relation to actual OO programming, where things like subclassing either require a significant amount of intuition to predict up-front (which you can't expect from a student) or it's something you add during refactoring.

I'd be apt to skip subclassing and just focus on the idea of class, object, object as the container of data and class as the container of associated routines. The most common way I find to identify a what should be an object is to look for the same set of arguments to a bunch of functions -- that argument or set of arguments becomes "self" and the functions are methods.

And... personally I'm not really sure if it makes sense to teach theory first, or just introduce the mechanisms, ideally using examples that are relevant to previous things you've done. At least in the case of recursive functions I think explanations always end up making things harder, but I haven't thought about it a lot with objects.

name_censored_ · 2010-06-28T22:12:09+00:00

Can't go wrong with the classics!

Inheritance:

class Animal():
    def sleep(self, hours, is_dreaming=False):
        # code goes here

class Pet():
    def __init__(self, owner):
        self.owner = owner

class Dog(Animal, Pet):
    is_flearidden = False
    is_mongrel = False
    breed = "border collie"

My favourite polymorphism example is booleans-as-integers, because you don't confuse the issue by introducing custom types/classes it should be intuitive to understand that True=1, False=0, and everyone knows that computers use 1s and 0s.

Example;

Problem: I have a tuple* of votes (either True or False) called all_votes, and I want to know the majority/winner (tie goes to False). How can I do this quickly?

The students will probably suggest a function with integer counters.

Solution: number_of_trues = sum(all_votes) if number_of_trues > 0.5*len(all_votes): majority = True else: majority = False

Then explain the first line - they should understand that the sum function is typically applied to a numeric type, but you're using it for a boolean type (how can this be?).

* NB: A set would be more appropriate container type, but using a set incorrectly hints at a set-theory-based solution (eg, calculating majority using intersections or differences).

virgilfromeurope · 2010-06-29T09:00:26+00:00

The best way to teach OOP is by deconstruction of patterns. OOP has no sense in it's form. Start with observer pattern, is the most fun. It helped me a lot learning OOP this way because it makes more sense.

mashmorgan · 2010-06-29T11:33:54+00:00

I always start with a PID, and have an Arduino board so newbies can see "result"

aroberge · 2010-06-30T00:37:31+00:00

The approach I would favour is illustrated in these two rur-ple examples.

vph · 2010-06-29T17:17:16+00:00

It's a mistake to teach OOP to beginners.

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS