Passing args = (elements) is equivalent to args = elements, i.e. no tuple is created.

To pass a 1-element tuple, either do args = (elements,), or args = tuple([elements]).

To answer the question: yes, it is likely to be a little slower, all else being equal. Some things that used to be variables (including functions) are now going to be object attributes, and self.foo is always going to be slightly slower than foo regardless of whether foo was a global or local originally. (Local variables are accessed by index, and globals by name, but an attribute lookup on an object is either a local or a global lookup, plus an additional lookup by name for the attribute, possibly in multiple places.) Calling a method is also slightly slower than calling a function -- not only is it slower to get the attribute, it is also slower to make the call, because a method is a wrapper object that calls the function you wrote, adding an extra function call overhead.

Will this be noticeable? Usually not. In rare cases it might be, say if you are accessing an object attribute a lot (thousands or millions of times) in a particular method. But in that case you can just assign self.foo to a local variable foo at the top of the method, and reference it by the local name throughout, to regain 99.44% of the local variable's performance advantage.

Beyond that there will be some overhead for allocating memory for instances that you probably didn't have before, but unless you are constantly creating and destroying instances, this is likely a one-time cost.

In short: there will be a likely-minor performance hit, and where the performance hit is more than minor, it is easy to mitigate. On the other hand, assuming your problem lends itself to an object-oriented solution, you could save hours in writing and maintaining the code. And saving time is likely why you're using a language like Python to begin with.

Starting with an example for minimize documentation:

In [183]: x0 = [1.3, 0.7, 0.8, 1.9, 1.2]
In [185]: optimize.minimize(optimize.rosen, x0, method='Nelder-Mead', tol=1e-6)
Out[185]: 
 final_simplex: (array([[ 1.00000002,  1.00000002,  1.00000007,  1.00000015,  1.00000028],
...
             x: array([ 1.00000002,  1.00000002,  1.00000007,  1.00000015,  1.00000028])

Define a callable class that does the same thing:

In [191]: class Class1(object):
    def __init__(self):
        pass
    def __call__(self,args):
        return optimize.rosen(args)
In [190]: optimize.minimize(Class1(), x0, method='Nelder-Mead', tol=1e-6)

A Class1 object is callable, so I can use it exactly as though I had defined a rosen method

In [191]: Class1()(x0)
Out[191]: 848.22000000000003

I could have defined it this way:

In [192]: class Class2(object):
    def rosen(self,args):
        return optimize.rosen(args)   

In [193]: optimize.minimize(Class2().rosen, x0, method='Nelder-Mead', tol=1e-6)

In [194]: Class2().rosen(x0)
Out[194]: 848.22000000000003

Adding in class layer shouldn't make a difference, just so long as the first argument to minimize is a function that returns a value when called with x0.

In your case you just need to define:

class XYZ(object):
    def predict(self, args):
        return optimize.rosen(args)

class BuildSurrogate(object):
    def __init__(self):
        self.surrogateObj = XYZ()
    def minima(self,x0):
        return optimize.minimize(self.surrogateObj.predict, x0, method='Nelder-Mead', tol=1e-6)

And use:

BuildSurrogate().minima(x0)

Or something comparable.

I could have also defined self.SurrogateClass=XYZ and called self.SurrogateClass().predict. As long as predict is a method of the XYZ class I have to create an XYZ() object before using it.

Here's how I would do it. Separate the function to be optimized from the class method and have a private static method for the payoff calculation that both methods can utilize.

import numpy as np
from scipy.optimize import minimize

class Player:
    def __init__(self):
        self.action = np.random.choice(np.linspace(0, 1, 11))

    @staticmethod
    def _calc_payoff(a, b):
        if a < b:
            return (1 - a) * a
        elif a == b:
            return 0.5 * (1 - a) * a
        else:
            return 0

    def payoff(self, other):
        return self._calc_payoff(self.action, other.action)

    def best_reply(self, other):
        f = lambda x: 1 - self._calc_payoff(x, other.action)
        br = minimize(f, 0.5)
        return br.x.item()

A = Player()
B = Player()

print(A.best_reply(B))

Is 0.5 the correct result?

Sure, create an instance and pass its bound method:

class MyClass(object):
   ...
   def model_fun(self,x,par): ...

obj = MyClass(...)
curve_fit(obj.model_fun, ...)

You can find a good explanation about bound/unbound/etc. in this question.