Python 方法工作正常，直到在函数中调用它，然后取消绑定LocalError

我定义了一个称为dist的方法来计算两点之间的距离，直接使用该方法时，我正确地计算了两点之间的距离。 然而，当我得到一个函数来调用它来计算两点之间的距离时，我得到 UnboundLocalError:赋值前引用的局部变量“minkowski_distance”

编辑 对不起，我刚刚意识到，这个函数确实有效。然而，我有另一个方法调用它，但它没有。我把最后一种方法放在底部

方法如下：

class MinkowskiDistance(Distance):    
  def __init__(self, dist_funct_name_str = 'Minkowski distance', p=2):    
    self.p = p

  def dist(self, obj_a, obj_b):    
    distance_to_power_p=0    
    p=self.p    

    for i in range(len(obj_a)):    
      distance_to_power_p += abs((obj_a[i]-obj_b[i]))**(p)

    minkowski_distance = (distance_to_power_p)**(1/p)    
    return minkowski_distance

这就是功能： （它基本上将元组x和y拆分为它们的数字和字符串分量，计算x和y的数字部分之间的距离，然后计算字符串部分之间的距离，然后将它们相加

def total_dist(x, y, p=2, q=2):    
    jacard = QGramDistance(q=q)    
    minkowski = MinkowskiDistance(p=p)

    x_num = []    
    x_str = []    
    y_num = []    
    y_str = []

    #I am spliting each vector into its numerical parts and its string parts so that the distances
    #of each part can be found, then summed together.

    for i in range(len(x)):

        if type(x[i]) == float or type(x[i]) == int:    
            x_num.append(x[i])    
            y_num.append(y[i])    
        else:
            x_str.append(x[i])    
            y_str.append(y[i])

    num_dist = minkowski.dist(x_num,y_num)

    str_dist = I find using some more steps
    #I am simply adding the two types of distance to get the total distance:

    return num_dist + str_dist

class NearestNeighbourClustering(Clustering):

  def __init__(self, data_file,
               clust_algo_name_str='', strip_header = "no", remove = -1):

      self.data_file= data_file    
      self.header_strip = strip_header    
      self.remove_column = remove

  def run_clustering(self, max_dist, p=2, q=2):    
      K = {}    

      #dictionary of clusters    
      data_points = self.read_data_file()    
      K[0]=[data_points[0]]    
      k=0

      #I added the first point in the data to the 0th cluster    
      #k = number of clusters minus 1

      n = len(data_points)    
      for i in range(1,n):    
          data_point_in_a_cluster = "no"

          for c in range(k+1):    
              distances_from_i = [total_dist(data_points[i],K[c][j], p=p, q=q) for j in range(len(K[c]))]
          d = min(distances_from_i)
          if d <= max_dist:
              K[c].append(data_points[i])
              data_point_in_a_cluster = "yes"

      if data_point_in_a_cluster == "no":
          k += 1
          K[k]=[data_points[i]]
  return K

def总距离（x，y，p=2，q=2）：
jacard=QGramDistance（q=q）
闵可夫斯基=闵可夫斯基距离（p=p）
x_num=[]
x_str=[]
y_num=[]
y_str=[]
#我把每个向量分成数字部分和字符串部分，这样距离
#每一部分都可以找到，然后汇总在一起。
对于范围内的i（len（x））：
如果类型（x[i]）==float或类型（x[i]）==int：
x_num.append（x[i]）
y_num.append（y[i]）
其他：
x_str.append（x[i]）
y_str.append（y[i]）
num_dist=minkowski.dist（x_num，y_num）
str_dist=我发现使用更多步骤
#我只是简单地将两种类型的距离相加，得到总距离：
返回num\u dist+str\u dist
类最近邻聚类（聚类）：
定义初始化（自，数据文件，
clust_algo_name_str=''，strip_header=“否”，remove=-1）：
self.data\u file=数据文件
self.header\u strip=strip\u header
self.remove\u column=删除
def run_群集（自身，最大距离，p=2，q=2）：
K={}
#聚类词典
data\u points=self.read\u data\u文件（）
K[0]=[数据点[0]]
k=0
#我将数据中的第一个点添加到第0个集群
#k=簇数减去1
n=长度（数据点）
对于范围（1，n）内的i：
集群中的数据点=“否”
对于范围（k+1）内的c：
距离_到_i=[范围（len（K[c]）内j的总距离（数据点[i]，K[c][j]，p=p，q=q）]
d=最小值（距离i）
如果d只有当控制进入for循环时，才会执行线
minkowski_distance=（distance_to_power_p）**（1/p）

for i in range(len(obj_a)):
    distance_to_power_p += abs((obj_a[i]-obj_b[i]))**(p)

minkowski_distance = (distance_to_power_p)**(1/p) # this is only assignment, no need 
                                                  # for this to be inside the loop

return minkowski_distance

检查
len（obj_a）

如果返回的值为
0
，则语句
return minkowski_distance
将抛出错误
赋值前引用的局部变量“minkowski_distance”

您应该从for循环中取出线
minkowski\u distance=（distance\u to\u power\u p）**（1/p）

for i in range(len(obj_a)):
    distance_to_power_p += abs((obj_a[i]-obj_b[i]))**(p)

minkowski_distance = (distance_to_power_p)**(1/p) # this is only assignment, no need 
                                                  # for this to be inside the loop

return minkowski_distance

如果
obj_a
为空，则永远不会设置
minkowski_距离

for i in range(len(obj_a)):

  distance_to_power_p += abs((obj_a[i]-obj_b[i]))**(p)

  minkowski_distance = (distance_to_power_p)**(1/p)

return minkowski_distance

如果x中没有一个是整数或浮点数，则会发生这种情况。您似乎有缩进问题：

class MinkowskiDistance(Distance):
  def __init__(self, dist_funct_name_str = 'Minkowski distance', p=2):
    self.p = p

  def dist(self, obj_a, obj_b):
    distance_to_power_p=0
    p=self.p

    for i in range(len(obj_a)):
      distance_to_power_p += abs((obj_a[i]-obj_b[i]))**(p)
      minkowski_distance = (distance_to_power_p)**(1/p)

    return minkowski_distance
等级最小距离（距离）：
定义初始值（self，dist函数名，str='Minkowski distance'，p=2）：
self.p=p
def dist（自身、obj_a、obj_b）：
距离功率p=0
p=self.p
对于范围内的i（len（obj_a））：
距离功率p+=abs（（obj_a[i]-obj_b[i]）**（p）
minkowski距离=（距离功率）**（1/p）
返回minkowski_距离
minkowski_distance=（distance_to_power_p）**（1/p）
位于
for
循环内，因此如果
for
循环从未运行，
minkowski_distance
从未设置，您的错误将出现

把那行放低一个缩进级别（两个空格），一切都应该正常。
只有当
len（obj_a）时，你才会遇到问题==0
，因为你不会在
for
循环中设置
minkowski_距离
。你能粘贴实际的回溯吗……你得到的
str_dist=我发现使用更多的步骤
这一行会抛出一个错误，这是一个很好的点，我真的不应该在循环中设置它。但是，没有一个点的len=0。@user1776100：只需打印len（obj_a）的结果。我修复了缩进错误，但我仍然有相同的问题。