Define and call plus_2_times_4 with self, namely:

class ExampleClass():

    def __init__(self, number):
        self.number = number

    def plus_2_times_4(self,x):
        return(4*(x + 2))

    def arithmetic(self):
        return(self.plus_2_times_4(self.number))

This will work.

Updated after question edit:

Check out this link that shows how to make a "closure" https://stackoverflow.com/a/4831750/2459730

It's what you described as a function inside of a function.

def run(self):
    def calculate(self): # <------ Need to declare the function before calling
        return self.number**2

    print "I will now square your number"
    print "Your number squared is: "
    print self.calculate() # <---- Call after the function is declared

Before question edit: Your calculate function isn't indented properly.

def run(self):
    print "I will now square your number"
    print "Your number squared is: "
    print self.calculate()

#This squares the number
def calculate(self): # <----- Proper indentation
    return self.number**2 # <------ Proper indentation

The calculate function should have the same indentation level as the run function.

This really depends on what you want to do.

>>> class Foo(object):
...     def haha(self):
...         print 3
...     def __init__(self):
...         def haha():
...             print 4
...         self.haha = haha
... 
>>> a = Foo()
>>> a.haha
<function haha at 0x7f4539e25aa0>
>>> a.haha()
4

In the previous example, haha isn't actually a method -- It's just a function. But it will pick up a reference to self from the closure and a lot of the time, that's probably good enough. If you actually want to monkeypatch/duck punch a new method on an instance, you'll need to use types.MethodType. See here for an example.

That's an artifact of Python's name resolution rules: you only have access to the global and the local scopes, but not to the scopes in-between, e.g. not to your immediate outer scope.

EDIT: The above was poorly worded, you do have access to the variables defined in outer scopes, but by doing x = x or mymethod = mymethod from a non-global namespace, you're actually masking the outer variable with the one you're defining locally.

In example 2, your immediate outer scope is the global scope, so MyClass can see mymethod, but in example 4 your immediate outer scope is my_defining_func(), so it can't, because the outer definition of mymethod is already masked by its local definition.

See PEP 3104 for more details about nonlocal name resolution.

Also note that, for the reasons explained above, I can't get example 3 to run under either Python 2.6.5 or 3.1.2:

>>> def myfunc():
...     x = 3
...     class MyClass(object):
...         x = x
...     return MyClass
... 
>>> myfunc().x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in myfunc
  File "<stdin>", line 4, in MyClass
NameError: name 'x' is not defined

But the following would work:

>>> def myfunc():
...     x = 3
...     class MyClass(object):
...         y = x
...     return MyClass
... 
>>> myfunc().y
3

Since these are member functions, call it as a member function on the instance, self.

def isNear(self, p):
    self.distToPoint(p)
    ...

This is bad because it makes the following break:

1. Type-checking, with isinstance(result, FunkyClass)
   Furthermore, the results of invoking CreateSomeFunkyDataStructure multiple times will not even be of the same type! (ie, type(f1) is not type(f2))
2. Invoking members statically, with map(FunkyClass.getFunky, [funcy1, funcy2])
3. pickleing
   This requires classes to be visible at module scope - even nested classes cause it to choke

If you had read the error message from the first example then that might have given you a clue.

self.tooAhg=self.oaf(self.ahg)
AttributeError: foo instance has no attribute 'oaf'

The function name is oaf, not self.oaf.

class foo:
    def __init__(self,ahg):
        self.ahg=ahg
        def oaf(arg):
            return arg*2
        self.tooAhg=oaf(self.ahg)

bibi=foo(1)
print vars(bibi)

Gives:

{'tooAhg': 2, 'ahg': 1}

If you want to make the function oaf an attribute of the object, then:

self.oaf = oaf

Using self.mode_impute is indeed the correct way of calling the function inside the class. However the issue here is that your call is not part of a function, putting the for loop with the call inside a function (e.g. __init__) should solve the error as self is defined within the function (passed as the first argument).

You don't have to put them in a different file, they can either be at top level scope in the same file, or within do_thing.

E.g.

def first_process(self, var):
    ...

def second_process(self, var):
    ...

class A:
    def init(self, input_data):
        ...
        self.thing = do_thing(input_data)

    def do_thing(self, user_input):
        first_thing = first_process(self, user_input)
        second_thing = second_process(self, first_thing)
        return second_thing

or

class A:
    def init(self, input_data):
        ...
        self.thing = do_thing(input_data)

    def do_thing(self, user_input):
        def first_process(var):
            ...

        def second_process(var):
            ...

        first_thing = first_process(user_input)
        second_thing = second_process(first_thing)
        return second_thing

However if you are needing to use self in these functions, having them be part of the class is fine. Maybe you just want to indicate that they are private by naming them _first_process and _second_process