There is indeed another way, and it's inbuilt into scikit-learn (so should be quicker). You can use the wminkowski metric with weights. Below is an example with random weights for the features in your training set.

knn = KNeighborsClassifier(metric='wminkowski', p=2, 
                           metric_params={'w': np.random.random(X_train.shape[1])})

Yes, the line indicates that KNN is weighted and that the weight is the inverse of the distance. All of this can easily be found in scikit-learn's documentation

Also, pro-tip, you can find an object's documentation using the help function. In this case:

from sklearn.neighbors import KNeighborsClassifier

print(help(KNeighborsClassifier))

As to how weighted KNN works, I actually made a learning unit on my website about this.

In short, weighting the instances means that instead of each neighbor having an equal vote, their vote is weighted. This means that if for instance, in my 3 nearest-neighbors, 2 of them are of class A but have low weights, and 1 of them is of class B and has a high weight, KNN might still pick class B even though more neighbors are of class A.

https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html

class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, *, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=None)
...
weights{‘uniform’, ‘distance’} or callable, default=’uniform’ Weight function used in prediction. Possible values:
‘uniform’ : uniform weights. All points in each neighborhood are weighted equally.
‘distance’ : weight points by the inverse of their distance. in this case, closer neighbors of a query point will have a greater influence than neighbors which are further away.
[callable] : a user-defined function which accepts an array of distances, and returns an array of the same shape containing the weights.

This should work:

# compute inverses of distances
# suppress division by 0 warning, 
# replace np.inf with a very large number
with np.errstate(divide='ignore'):
    dinv = np.nan_to_num(1 / distances)
    
# an array with distinct class labels
distinct_labels = np.array(list(set(labels)))
# an array with labels of neighbors
neigh_labels = labels[indices]
# compute the weighted score for each potential label
weighted_scores = ((neigh_labels[:, :, np.newaxis] == distinct_labels) * dinv[:, :, np.newaxis]).sum(axis=1)
# choose the label with the highest score
predictions = distinct_labels[weighted_scores.argmax(axis=1)]

You actually specify the weights via the metric argument.

First off, your question details are slightly incorrect. The algorithm doesn't find a distance function - you supply it with a metric in which to compute distances, and a function to compute weights as a function of those distances. You are using the default distance metric which, according to the docs is just the good old Euclidean distance.

Weights are computed as the inverse of distance (also written in the docs), so you can manually find the k neighbors of a given point and compute their weights using the build in kneighbors method to find neighbors:

test = [[np.random.uniform(-1, 1) for _ in xrange(len(X[0]))]]

neighbors, distances = knn.kneighbors(test)
for d in distances:
    weight = 1.0/d
    print weight

The problem is that all features enter into the calculation of d with equal weight because you've specified a Euclidean metric, i.e. d is the square root of

1*(x1_neighbor - x1_test)^2 + 1*(x2_neighbor - x2_test)^2 + ...

This is because the Minkowsky metric is just a matrix with ones along the diagonal. If you want different weights, you can specify an alternate metric. However, if you just want a quick and dirty way of telling how important the various features are, a typical way of estimating the importance of feature i is to randomly permute all values of feature i and see how much it hurts the performance of the regressor. You can read more about that here.