Parametric constrained optimization loop over parameters?

Question

Say that I want to solve a parametric constrained optimization, method. Is there any method I can use to avoid looping over the parameters?

I would use a code (adapted to my problem) such as (credit):

import numpy as np
from scipy.optimize import minimize
import random
import pandas as pd
pd.options.display.float_format = '{:.5f}'.format

def uncovered(x):
    ## note x[0]--> x ; x[1]--> y
    first_prod = x[0]**2-2*x[0]-4*x[1]+1
    second_prod_first = x[0]**3*(8*a**2*(b-1)*b-4*a*(b-2)-3)
    second_prod_second = x[0]**2*(-8*a**2*(b-1)*b-8*a+5)
    second_prod_third = x[0]*(4*x[1]*(4*a*(b-1)+1)+4*a*b - 1) -4*x[1] - 1
    denom = 8*(x[0]-1)*(x[0]*(2*a*(b-1)+1)-1)**2
    if (x[0]-1==0):
        final_func=0
    else:
        final_func = first_prod*(second_prod_first+second_prod_second+second_prod_third)/denom
    return -final_func

def constraint_strict(x):
    return x[1]-0.5*a*x[0]*(x[0]-1)*(1-b)-0.0001

def constraint_nonstrict(x):
    return 0.25*(1-2*x[0]+x[0]**2) - x[1]

def constraint_1(x):
    return 1-x[0]

def constraint_2(x):
    return x[0]

def run_uncovered_market_maximization(alpha,xi):
    a=alpha
    b=xi
    # initial guesses
    n = 2
    x0 = np.zeros(n)
    x0[0] = 1
    x0[1] = 1.0
    
    success = False
    # show initial objective
    print("We are maximizing uncovered welfare:")
    print('Initial Objective: ' + str(uncovered(x0)))
    
    while success == False:
        # optimize
        bnds = ((0,1),(-np.inf,np.inf))

        con1 = {'type': 'ineq', 'fun': constraint_strict}
        con2 = {'type': 'ineq', 'fun': constraint_nonstrict}
        cons = ([con1,con2])
        solution = minimize(uncovered,x0,method='SLSQP',                            bounds=bnds,constraints=cons,options={'disp': False})
        x = solution.x
        success = solution.success

        if success == False:
            x0[0] = x0[0]-random.uniform(0, 1)
            x0[1] = 5.0-random.uniform(0, 1)
    
    indcons=(x[1]+a*(1-x[0])*x[0]*(1-b)/2)/((((1-x[0])**2)/4)+a*(1-x[0])*(1-b)*x[0]/2)
    
    # show final objective
    print("Success:"+str(solution.success))
    print('Final Objective: ' + str(uncovered(x)))
    print('First Constraint: ' + str(constraint_strict(x)))
    print('Second Constraint: ' + str(constraint_nonstrict(x)))

    # print solution
    print('Solution')
    print('d = ' + str(x[0]))
    print('p = ' + str(x[1]))
    print('market demand:'+ str(1-indcons))

    return (solution.success, str(x[0]),str(x[1]),str(uncovered(x)),indcons)

I am unsure on how to handle a and b given that the maximization should not be over these and they only represent parameters. I want to have a pair (x,y) for any acceptable value of (a,b). How to set the boundaries? and how to insert a and b if not by looping over them?

For now I do:

optlist =[]
for b in np.linspace(start=0, stop=1, num=2000):
    for a in np.linspace(start=0, stop=1, num=2000):
        print('-------------Optimization for a:{} and b:{}-------------------'.format(a,b))   
        
        print('-------------Uncovered market')

        (usuccess, du, pu,ufinal,uindcons) = run_uncovered_market_maximization(a,b)