That doesn't work because distToPoint is inside your class, so you need to prefix it with the classname if you want to refer to it, like this: classname.distToPoint(self, p). You shouldn't do it like that, though. A better way to do it is to refer to the method directly through the class instance (which is the first argument of a class method), like so: self.distToPoint(p).

I think you're on the right way; but using some dependency injection might work better in your case. You could do something like this:

def arithmetic(prices):
    daily_ret = []
    for i rows in prices:
        returns.append(prices(i)-prices(i-1))
    return daily_ret

def logarithmic(prices):
    daily_ret = []
    for i rows in prices:
        returns.append(np.ln(prices(i) / prices(i-1))
    return daily_ret

class Returns:
    def __init__(self, stock_ticker, return_calc=arithmetic):
        self.stock_ticker = stock_ticker
        self.return_calc = return_calc

    def calculate_returns(self):
        get_price_data_from_ticker = whatever_data_source()
        return self.return_calc(get_price_data_from_ticker)

x = Returns('AAPL US Equity', return_calc=logarithmic)
print(x.calculate_returns())

by directly passing the function instead of passing a string constant to identify which function to use.

By the way, this is what you were doing in this line:

def __init__(self, stock_ticker, return_calc=arithmetic):

which means that the default value that you are passing right now isn't a string, but directly the function

First, there is a typo in your code. You misspelled return as "retrun". Also, you can't call a class method directly. Here is what you're probably looking for.

class fg():
    def __init__(self, text):
        self.text = text
    
    def red(self):
        return f'\033[00;49;031m{self.text}\033[0m'

    def heading(self):
        return self.red()

And now you can import the file.

from globals import fg

obj = fg("My text")
print(obj.red())
print(obj.heading())

I have made a lot of modifications to your code.

1. Use self to call the class methods
2. If the text parameter is the same for both, you need not pass it every time you call these methods. Instead, you can initialize that in the self method itself.
3. You first need to create an object of a class to access its methods (called constructors).

You can move the for loop calling the model_impute() method either to within your __init__() constructor or outside of the impute class. But I don’t see the dataset df6 defined anywhere.

So I would redesign things a bit. Create a fit_transform(X) method within your impute class. This takes in a X data frame from the user, saves it for the class instance & then populates missing values with the for loop invoking mode_impute().

You really need to understand Object-Oriented Programming and its implementation in Python. You cannot "call" a class like any function. You have to create an instance, which has a lifetime and methods linked to it:

o = printclass() # new object printclass
o.dotheprint()   # 

A better implementation of your class:

class printclass():
    string="yes"         #beware, this is instance-independant (except if modified later on)

    def dotheprint(self):
        print self.string

    def __init__(self):  # it's an initializer, a method called right after the constructor
         self.dotheprint()

Since foo() has a self parameter, that means it is an instance method, and therefore it is only callable from an instance of myClass.

If you want foo to be callable without an instance, use the @staticmethod decorator, and remove self from the parameter list.

You've got answers and comments, so let me explain the error message.

In your code, g and H are different names for the same thing, so the two errors are one.

Now, H is an (old-style) class and all the functions def'ed below it, unless "processed" with tricks like classmethod or staticmethod, are methods. When you access the methods as attributes of the class H, they're known as "unbound" methods because they're not yet bound to an instance of the class H.

To understand how Python's core model of classes, methods, and attributes, I recommend the excellent posts by Shalabh Chaturvedi:

• Python Types and Objects
• Python Attributes and Methods

The tl;dr version: normally you're expected to call a method by invoking an instance's bound method:

>>> class H(...):
>>>     def y(...):
>>> h_instance = H()
>>> h_instance.y(...)

Python will put that instance (h_instance here in the fake code snippet) as the first argument to the method. If you call it as h_instance.y(), the actual argument list is (h_instance); if you call it as h_instance.y(a), the arguments are (h_instance, a).

This is why you almost invariably find the first formal argument in a method definition to be self. There's nothing special about this name, except that Python expects that slot be reserved for the instance on which the method is invoked. It allows you to define the method with an empty argument list, but that one wouldn't be useful when you actually use the instance. In that case you'll always get TypeError -- because the call sends ONE argument (the "self" instance) while there's none in the method definition.

As a demonstration, consider the following session:

In [1]: class H(object):    # New-style class, doesn't matter here.
   ...:     def y(self):    # Notice the call signature: "self" included
   ...:         print "j"        

In [2]: h_instance = H()    # Create an instance from the class

# This is how normally you're expected to call. There's no argument
# passed to the *bound* to the instance h_instance, because when you do
# this Python will carry out the syntactic desugaring and call on the
# instance.
In [3]: h_instance.y()
j

# This does the same thing and demonstrates the concept of an
# unbound method.  It's not bound to any specific instance of H, so
# you'll have to specify which instance to call.
In [4]: H.y(h_instance)
j