两个长度不同（数据个数不同）的一维数组该如何计算其相关性

python关于相关性的计算：两个长度不同（数据个数不同）的一维数组该如何计算其相关性

该回答通过自己思路及引用到各个渠道搜索综合及思考,得到内容具体如下：

对于两个长度不同的一维数组，可以使用相关系数来衡量它们之间的相关性。常见的相关系数包括皮尔逊相关系数、斯皮尔曼相关系数和肯德尔相关系数等。

其中，皮尔逊相关系数适用于连续变量之间的相关性，它的取值范围在-1到1之间，取值为1时表示完全正相关，取值为-1时表示完全负相关，取值为0时表示不相关。斯皮尔曼相关系数和肯德尔相关系数适用于有序变量之间的相关性，它们的取值范围也在-1到1之间。

下面是使用Python计算两个长度不同的一维数组的皮尔逊相关系数和斯皮尔曼相关系数的示例代码：

import numpy as np
from scipy.stats import pearsonr, spearmanr

# 生成两个长度不同的随机数组
x = np.random.rand(100)
y = np.random.rand(50)

# 计算皮尔逊相关系数
r, p = pearsonr(x[:50], y)
print("Pearson correlation coefficient: %.3f, p-value: %.3f" % (r, p))

# 计算斯皮尔曼相关系数
r, p = spearmanr(x[:50], y)
print("Spearman correlation coefficient: %.3f, p-value: %.3f" % (r, p))

在上述代码中，首先使用Numpy库生成两个长度分别为100和50的随机数组$x$和$y$，然后使用Scipy库中的pearsonr函数和spearmanr函数分别计算它们的皮尔逊相关系数和斯皮尔曼相关系数。输出结果包括相关系数和p值，p值表示该相关系数是否显著，一般取0.05作为显著性水平。需要注意的是，由于$x$和$y$的长度不同，因此在计算相关系数时需要对它们进行适当的处理，例如上述代码中使用了切片操作来截取两个长度相同的子数组。

如果以上回答对您有所帮助，点击一下采纳该答案～谢谢

• 这个问题的回答你可以参考下: https://ask.csdn.net/questions/262953
• 这篇博客你也可以参考下：Python 异常类的层次结构、或叫继承关系一览无余 [Python 异常]
• 除此之外, 这篇博客: 摄影测量手动提取立体像对同名点像素，相对定向解算，特征点提取，影像匹配同名点的python实现中的 采用连续法相对定向 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• 相对定向、共面方程原理可参照：
  摄测与CV 3: 共面方程，相对定向，绝对定向

  1. 粗差处理 数据探测法假设检验粗差，进行了粗差检验，并没有处理只是输出第几对像点存在粗差，粗差改正可后续添加
     注：数据探测法假设检验参照误差理论与测量平差基础

  def findCrossError():
      global X
      if (len(A) == 0) | (len(V) == 0):
          return
      q = 1 # 单位权中误差
      Q = np.eye(9,9) # 9*9的协因数阵
      Qvv = Q - (A * (A.T * A).I * A.T)
      t = 0.05 # 正态分布的阿尔法值
      ut = 1.96 # 正态分布表里的u0.025的限值
      i = 0
      for arr in V:
          u = arr / (q * np.sqrt(Qvv[i,i]))
          if np.abs(u) > ut:
              print("第{}个点存在粗差,粗差为：{}".format(i,arr))
              # 粗差处理
              # X = np.zeros(shape=(5,1))# 舍去改正值
              # print("已改正...")
          else:
              if i == len(V)-1: # 循环结束
                  print("未发现粗差...")
          i += 1
  

  2. 各相对定向参数结算
     解算参数和过程参照摄影测量学

  X = 0 # A矩阵 L由观测值计算得到的q值 V五个参数的改正值 X真值
  V = 0 # 存放改正值
  A = 0 # 系数矩阵
  def computerNewValue():
      global X, V, A
      L = 0
      i = 0
      while i < len(QArr):
          x2, y2, z2, n1 = spaceArr2[i][0], spaceArr2[i][1], spaceArr2[i][2], N1Arr[i]
          a1 = - (x2 * y2 / z2) * n1
          a2 = - (z2 + y2 * y2 / z2) * n1
          a3 = x2 * n1
          a4 = Bx
          a5 = - (y2 / z2) * Bx
  
          a = np.array([[a1[0], a2[0], a3[0], a4[0], a5[0]]])
          if i == 0:
              A = a
          else:
              A = np.row_stack((A, a))
          i += 1
  
      # print(len(A))
      A = np.mat(A)  # 转换成矩阵
      L = np.transpose(np.array([QArr]))
      L = np.mat(L)
  
      X = (A.T.dot(A)).I.dot(A.T).dot(L)  # A.T求转置 A.I求逆
      V = (A.dot(X) - L)
  
  

  3. 入口函数、迭代计算和精度评定
     由于得到的未知数改正值有时无法收敛到限值，未找到原因，故没有以改正值为迭代的收敛条件，而是以迭代次数为收敛条件

  if __name__ == '__main__':
      r, w, k = 0, 0, 0 # 起始值
      u, v = 0, 0
      # V = 0 #存放差值
      rDiffi, wDiffi, kDiffi, uDiffi, vDiffi = 0,0,0,0,0  #各差值
      pixelToImgPoint()  # 像素转像平面坐标
  
      def computer():
          global r,w,k,u,v,V
          global rDiffi,wDiffi,kDiffi,uDiffi,vDiffi
          computerPixelAssist(r, w, k) # 转像空间辅助坐标
          computerParameter(u, v) # 计算各参数
          computerNewValue() #计算新值
          # 计算差值
          # V = X - np.mat([[r,w,k,u,v]]).T
          # print(X)
          rDiffi = X[0, 0]   # 各个差值
          wDiffi = X[1, 0]
          kDiffi = X[2, 0]
          uDiffi = X[3, 0]
          vDiffi = X[4, 0]
      computer()
      findCrossError()
  
      # 迭代计算，判断是否满足要求
      limit = 0.08 # 限值
      flag = True # 是否继续迭代的指示
      num = 1 # 迭代次数
  
      # r, w, k, u, v = V[0, 0], V[1, 0], V[2, 0], V[3, 0], V[4, 0]
      # computer()
      while num < 100: #迭代多少次停止
          # if (np.abs(rDiffi) > limit) | (np.abs(wDiffi) > limit) | (np.abs(kDiffi) > limit) | (np.abs(uDiffi) > limit)| (np.abs(vDiffi) > limit): # 超出限值
          print("已迭代：%d次..."%num)
          r,w,k,u,v = rDiffi+r,wDiffi+w,kDiffi+k,uDiffi+u,vDiffi+ v # 参数改正
          precision = np.sqrt((V.T.dot(V))/4)[0,0]
          print("精度：{}毫米".format(precision))
          computer()
          num += 1
      print("已迭代：%d次..." % num)
          # else:
          #     flag = False
          #     break
  
      print("================================================")
      print("改正值：r:{}, w:{}, k:{}, u:{}, v:{}".format(rDiffi, wDiffi, kDiffi, uDiffi, vDiffi))
      print("最终精度：{}".format(precision))
      print("改正后的值：r:{}, w:{}, k:{}, u:{}, v:{}".format(r,w,k,u,v))
  

  运行输出结果如下：
  迭代次数、每次迭代后的精度、结果的改正值、结果的精度、相对定向的5参数
  到此相对定向解算完成
  

• 您还可以看一下 黄勇老师的Python从入门到实战 基础入门视频教程（讲解超细致）课程中的 子类不能继承父类的私有···小节, 巩固相关知识点