目录

1.层次分析法原理介绍

2.层次分析法建模步骤

3.案例分析

3.1 题目简述

3.2 确定评价指标，建立层次关系

3.3 构造判断矩阵

3.3.1 标度定义

3.3.2 构造判断矩阵

 3.4 一致性检验

3.5 层次总排序

4.代码实现

1.层次分析法原理介绍

        关于层次分析法的具体原理即详细的步骤以及有很多人发布，可自行搜索查看，以下链接为个人认为较好的两篇：数学建模方法——层次分析法（AHP）_Learning-Deep-CSDN博客_层次分析法列向量归一化计算0. 层次分析法简介层次分析法（Analytic Hierarchy Process，简称AHP）主要是对于定性的决策问题进行定量化分析的方法。举个例子，在日常生活中，我们经常需要进行感性的判断，比如报高考志愿，感觉清华北大都很好，到底要报哪个；再比如去市场买菜，到底是买青椒做青椒炒鸡蛋，还是买黄瓜做黄瓜炒鸡蛋；再比如想去出游，到底是去公园A还是公园B。上面提到的这些问题，都是决策，也叫做评价类...https://blog.csdn.net/limiyudianzi/article/details/103389880?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164386596716780261988153%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164386596716780261988153&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-103389880.pc_search_insert_es_download&utm_term=AHP&spm=1018.2226.3001.4187

【AHP】层次分析法 | 过程解读 案例实践_Fxtack的博客-CSDN博客_ahp分析法完整案例AHP 层次分析法一. AHP 层次分析法介绍AHP 层次分析法简介AHP，即层次分析法（Analytic Hierarchy Process,AHP）是一种系统化的、层次化的多目标综合评价方法。在评价对象的待评价属性复杂多样，结构各异，难以量化的情况下AHP层次分析法也能发挥作用。AHP 基本思想 [1]AHP 把复杂的问题分解为各个组成因素，又将这些因素按支配关系分组形成地递阶层次结构。通过两两比较的方式确定方式确定层次中诸因素的相对重要性。然后综合有人员的判断，确定备选方案相对重要https://blog.csdn.net/weixin_43095238/article/details/108055579?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164386596716780261988153%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=164386596716780261988153&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_click~default-2-108055579.pc_search_insert_es_download&utm_term=AHP&spm=1018.2226.3001.4187

2.层次分析法建模步骤

3.案例分析

3.1 题目简述

        假定现需要购置一批冰箱，由于市场上冰箱种类参差不齐，其性能及性价比也存在很大差异，现有一批冰箱待选择，请考虑冰箱的容积、功耗、外观、噪声、寿命、价格、保修时间等因素，建立模型，确定性价比最高的购买方案。

量化后冰箱参数：

以冰箱A为基准，若该项性能优于A则其值加1，且每优一级都加1，反之亦然。

3.2 确定评价指标，建立层次关系

3.3 构造判断矩阵

3.3.1 标度定义

若要描述后者与前者比较，则用倒数为标度。例如 1/3 描述的是，后者比前者稍微重要。 

3.3.2 构造判断矩阵

 3.4 一致性检验

具体的计算方法见推荐阅读的两篇文章。

经过计算得到C.R=0,025<0.1，故一致性检验成功。

 得到七种属性的权值如下：

3.5 层次总排序

 由此可见评分：B>C>A。故冰箱B对顾客来说性价比最高。

4.代码实现

package AHP;

import java.util.Scanner;

public class AHP {
	public static void main(String[] args) {
		System.out.println("输入矩阵阶数：");
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		System.out.println("按行输入：");
		double d[][] = new double[n][n];
		double temp[][] = new double[n][n];
		for (int i = 0; i < n; i++) { 
			for (int j = 0; j < n; j++) {
				double sToD = SToD(scanner.next());
				d[i][j] = sToD;
				temp[i][j] = sToD;
			}
		}

		System.out.println("以下是判断矩阵");
		// 得到判断矩阵
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				System.out.printf("%.2f\t", d[i][j]);
			}
			System.out.println();
		}
 
		// 1.对判断矩阵进行求和
		System.out.println("列相加结果w1");
 
		double w1[] = new double[n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				w1[i] = w1[i] + d[j][i];
			}
			System.out.printf("%.2f\t", w1[i]);
		}
 
		// 2.相除
		System.out.println();
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				d[i][j] = d[i][j] / w1[j];
			}
		}
		System.out.println("和积法第一步求出的结果d（即对列向量归一化）：");
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				System.out.printf("%.2f\t", d[i][j]);
			}
			System.out.println();
		}
 
		System.out.println("对第一步求出的结果进行 行相加");
 
		System.out.println("行相加结果w2:");
 
		double w2[] = new double[n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				w2[i] = w2[i] + d[i][j];
			}
			System.out.printf("\t%.2f\n", w2[i]);
		}
 
		System.out.println("特征向量求解第一步 ： 将上面的行相加的所有结果相加sum：");
		double sum = 0.0;
		for (int i = 0; i < n; i++) {
			sum += w2[i];
		}
		System.out.printf("结果为sum = \t%.2f\n", sum);
 
		System.out.println("将行结果与 sum 相除 得出结果为w3：  ");
		double w3[] = new double[n];
		for (int i = 0; i < n; i++) {
			w3[i] = w2[i] / sum;
			System.out.printf("\t%.2f\n", w3[i]);
		}
 
		System.out.println();
		System.out.println("************************************************");
		System.out.println("用和积法计算其最大特征向量为（即权重）：W = ");
		// 以下是校验
		System.out.printf("(");
		for (int i = 0; i < n; i++) {
			System.out.printf("%.2f ,", w3[i]);
		}
		System.out.printf(")");
 
		System.out.print("\nBW(w4) = ");//BW即行相加结果
		double w4[] = new double[n];
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				w4[i] = w4[i] + temp[i][j] * w3[j];
			}
			System.out.printf("%.5f \t", w4[i]);
		}
		System.out.println("\n----------------------------------------");
		double sum2 = 0.0;
		for (int i = 0; i < n; i++) {
			sum2 = sum2 + w4[i];
		}
		System.out.printf("得到最大特征值sum2：\t %.2f\n", sum2);
		System.out.println("************************************************");
		System.out.println("最大的特征向量为 ：  ");
 
		double result = 0.0;
		for (int i = 0; i < n; i++) {
			result = result + w4[i] / (6 * w3[i]);
		}
		System.out.printf(" %.2f \n", result);
 
		System.out.println("\n判断矩阵一致性指标C.I.(Consistency Index)");
		double CI = (result - n) / (n - 1);
		System.out.printf(" %.2f \n", CI);
 
		System.out.println("随机一致性比率C.R.(Consistency Ratio)");
 
		/*
		 * 
		 n  1  2  3  	4  		5	  6	  7		  8		 9	  10	  11
		RI  0  0  0.58  0.90  1.12  1.24  1.36  1.41  1.45  1.49  1.51 
		一般，当一致性比率 <0.1 时
		的不一致程度在容许范围之内，可用其归一化特征向量
		作为权向量，否则要重新构造成对比较矩阵，对  加
		以调整
		 */
		double RI = 0.0;
		switch (n) {
		case 0:
			RI=0;
			break;
		case 1:
			RI=0;
			break;
		case 2:
			RI=0;
			break;
		case 3:
			RI=0.58;
			break;
		case 4:
			RI=0.90;
			break;
		case 5:
			RI=1.12;
			break;
		case 6:
			RI=1.24;
			break;
		case 7:
			RI=1.36;
			break;
 
		default:
			break;
		}
		double CR=CI / RI;
		if(CR<0.1) {
			System.out.printf("一致性检验成功！  C.R =  %.2f \n", CR);
		}
		else
			System.out.printf("一致性检验失败！  C.R =  %.2f \n", CR);
		
		
		scanner.close();
	}
 
	public static double SToD(String s) {
		String[] p = s.split("/");
		if (p.length > 1) {
			return Double.parseDouble(p[0]) / Double.parseDouble(p[1]);
		}
		return Double.parseDouble(s);
	}
}

（通过MATLAB实现）

1.线性加权法

        线性加权法的适用条件是各评价指标之间相互独立， 这样就可以利用多元线性回归方法来得到各指标对应的系数。

        举个例子：所评价的对象是股票， 已知一些股票的各个指标以及这些股票的历史表现，其中最后一列标记为 1 的表示为上涨股票，标为 0 的表现为一般的股票，-1 的则为下跌的股票。希望根据这些已知的数据， 建立股票的评价模型，这样就可以利用模型评价新的股票。

1.导入数据

clear all, close all

s = dataset('xlsfile', 'SampleA1.xlsx');

2.多元线性回归

        当导入数据后，就可以先建立一个多元线性回归模型，具体实现过程和结果如下：

myFit = LinearModel.fit(s);

disp(myFit)
sx=s(:,1:10);
sy=s(:,11);
n=1:size(s,1);
sy1= predict(myFit,sx);
figure
plot(n,sy, 'ob', n, sy1,'*r')
xlabel('样本编号', 'fontsize',12)
ylabel('综合得分', 'fontsize',12)
title('多元线性回归模型', 'fontsize',12)
set(gca, 'linewidth',2)

        该段程序执行后，得到的模型及模型中的参数如下。

        利用该模型对原始数据进行预测，得到的股票综合得分如图1所示。从图中可以看出，尽管这些数据存在一定的偏差，但三个簇的分层非常明显，说明模型在刻画历史数据方面具有较高的准确度。

                 图1  多元线性回归模型得到的综合得分与原始得分的比较图

3.逐步回归

        上述是对所有变量进行回归，也可以使用逐步回归进行因子筛选，并可以得到优选因子后的模型，具体实现过程如下：

myFit2 = LinearModel.stepwise(s);

disp(myFit2)
sy2= predict(myFit2,sx);
figure
plot(n,sy, 'ob', n, sy2,'*r')
xlabel('样本编号', 'fontsize',12)
ylabel('综合得分', 'fontsize',12)
title('逐步回归模型', 'fontsize',12)
set(gca, 'linewidth',2)

        该段程序执行后，得到的模型及模型中的参数如下。

        从该模型中可以看出，逐步回归模型得到的模型少了 5 个单一因子，多了 5 个组合因子，模型的决定系数反而提高了一些，这说明逐步回归得到的模型精度更高些，影响因子更少些，这对于分析模型本身是非常有帮助的，尤其是在剔除因子方面。

        利用该模型对原始数据进行预测，得到的股票综合得分如图 2 所示，总体趋势和图 1 相似。

                 图2  逐步回归模型得到的综合得分与原始得分的比较图

        以上是线性加权法构建评价型模型的方法， 所用的程序框架对绝大多数的这类问题都可以直接应用，核心是要构建评价的指标体系， 这是建模的基本功。总的来说，线性加权法的特点是：

（1）该方法能使得各评价指标间作用得到线性补偿，保证综合评价指标的公平性；

（2）该方法中权重系数的对评价结果的影响明显，即权重较大指标值对综合指标作用较大；

（3）该方法计算简便，可操作性强，便于推广使用。

2.层次分析法

        层次分析法 (Analytic Hierarchy Process, AHP) 是美国运筹学家萨蒂（T. L. Saaty）等人 20 世纪 70 年代初提出的一种决策方法，它是将半定性、半定量问题转化为定量问题的有效途径，它将各种因素层次化，并逐层比较多种关联因素，为分析和预测事物的发展提供可比较的定量依据，它特别适用于那些难于完全用定量进行分析的复杂问题。因此在资源分配、选优排序、政策分析、冲突求解以及决策预报等领域得到广泛的应用。

        AHP 的本质是根据人们对事物的认知特征，将感性认识进行定量化的过程。人们在分析多个因素时，大脑很难同时梳理那么多的信息，而层次分析法的优势就是通过对因素归纳、分层，并逐层分析和量化事物，以达到对复杂事物的更准确认识，从而帮助决策。

        在数学建模中，层次分析法的应用场景比较多，归纳起来，主要有以下几个场景：

(1) 评价、评判类的题目。这类题目都可以直接用层次分析法来评价，例如奥运会的评价、彩票方案的评价、导师和学生的相互选择、建模论文的评价、城市空气质量分析等。

(2) 资源分配和决策类的题目。这类题目可以转化为评价类的题目，然后按照 AHP 进行求解，例如将一笔资金进行投资，有几个备选项目，那么如何进行投资分配最合理呢？这类题目中还有一个典型的应用，就是方案的选择问题，比如旅游景点的选择、电脑的挑选、学校的选择、专业的选择等等，这类应用可以说是 AHP 法最经典的应用场景了。

(3) 一些优化问题，尤其是多目标优化问题。对于通常的优化问题，目前已有成熟的方法求解。然而，这些优化问题一旦具有如下特性之一，如：

①问题中存在一些难以度量的因素；

②问题的结构在很大程度上依赖于决策者的经验；

③问题的某些变量之间存在相关性；

④需要加入决策者的经验、偏好等因素，

这时就很难单纯依靠一个优化的数学模型来求解。这类问题，通常的做法是借助 AHP 法将复杂的问题转化为典型的、便于求解的优化问题，比如多目标规划，借助层次分析法，确定各个目标的权重，从而将多目标规划问题转化为可以求解的单目标规划问题。

        如何用 MATLAB 来实现层次分析法的过程，层次分析法中，需要 MATLAB 的地方主要就是将评判矩阵，转化为因素的权重矩阵。为此，这里只介绍如何用 MATLAB 来实现这一转化。

将评判矩阵转化为权重矩阵，通常的做法就是求解矩阵最大特征根和对应阵向量。

需要注意的是，在将评判矩阵转化为权重向量的过程中，一般需要先判断评判矩阵的一致性，因为通过一致性检验的矩阵，得到的权重才更可靠。

        下面就以一个实例来说明如何应用 MATLAB 来求解权重矩阵，具体程序如下：

%% AHP法权重计算MATLAB程序

%% 数据读入

clc

clear all

A=[1 2 6; 1/2 1 4; 1/6 1/4 1];% 评判矩阵

%% 一致性检验和权向量计算

[n,n]=size(A);

[v,d]=eig(A);

r=d(1,1);

CI=(r-n)/(n-1);

RI=[0 0 0.58 0.90 1.12 1.24 1.32 1.41 1.45 1.49 1.52 1.54 1.56 1.58 1.59];

CR=CI/RI(n);

if  CR<0.10

    CR_Result='通过';

   else

    CR_Result='不通过';  

end

 

%% 权向量计算

w=v(:,1)/sum(v(:,1));

w=w';

 

%% 结果输出

disp('该判断矩阵权向量计算报告：');

disp(['一致性指标:' num2str(CI)]);

disp(['一致性比例:' num2str(CR)]);

disp(['一致性检验结果:' CR_Result]);

disp(['特征值:' num2str(r)]);

disp(['权向量:' num2str(w)]);

        运行该程序，可得到以下结果：

该判断矩阵权向量计算报告：

一致性指标:0.0046014

一致性比例:0.0079334

一致性检验结果:通过

特征值:3.0092

权向量:0.58763     0.32339    0.088983

        应用这段程序时，只要将评判矩阵输入到程序中，其它地方都不需要修改，然后就可以直接、准确地计算出对应的结果，所以这段程序在实际使用中非常灵活。

初学者搞的层次分析法，先放代码再放图

import numpy as np
import pandas as pd
import pymysql
import math
import time
import datetime
from sqlalchemy import create_engine

class AHP:
    """
    相关信息的传入和准备
    """

    def __init__(self, array):
        ## 记录矩阵相关信息
        self.array = array
        ## 记录矩阵大小
        self.n = array.shape[0]
        # 初始化RI值，用于一致性检验
        self.RI_list = [0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49, 1.51]
        # 矩阵的特征值和特征向量
        self.eig_val, self.eig_vector = np.linalg.eig(self.array)
        # 矩阵的最大特征值
        self.max_eig_val = np.max(self.eig_val)
        # 矩阵最大特征值对应的特征向量
        self.max_eig_vector = self.eig_vector[:, np.argmax(self.eig_val)].real
        # 矩阵的一致性指标CI
        self.CI_val = (self.max_eig_val - self.n) / (self.n - 1)
        # 矩阵的一致性比例CR
        self.CR_val = self.CI_val / (self.RI_list[self.n - 1])

    """
    一致性判断
    """
    def test_consist(self):
        # 打印矩阵的一致性指标CI和一致性比例CR
        print("判断矩阵的CI值为：" + str(self.CI_val))
        print("判断矩阵的CR值为：" + str(self.CR_val))
        # 进行一致性检验判断
        if self.n == 2:  # 当只有两个子因素的情况
            print("仅包含两个子因素，不存在一致性问题")
        else:
            if self.CR_val < 0.1:  # CR值小于0.1，可以通过一致性检验
                print("判断矩阵的CR值为" + str(self.CR_val) + ",通过一致性检验")
                return True
            else:  # CR值大于0.1, 一致性检验不通过
                print("判断矩阵的CR值为" + str(self.CR_val) + "未通过一致性检验")
                return False
    """
    特征值法求权重
    """
    def cal_weight__by_eigenvalue_method(self):
        # 将矩阵最大特征值对应的特征向量进行归一化处理就得到了权重
        array_weight = self.max_eig_vector / np.sum(self.max_eig_vector)
        # 打印权重向量
        for index in range(len(array_weight)):
            array_weight[index] = round(array_weight[index],2)
        print(array_weight)
        # 返回权重向量的23
        # 值
        return array_weight



'''
  计算权重
'''
RI = [0, 0, 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49, 1.51]

#信息准确
mes = np.array([[1,3,5],
                [1/3,1,3],
                [1/5, 1/3, 1]])
m1 = len(mes)  # 获取指标个数
n1 = len(mes[0])
R1 = np.linalg.matrix_rank(mes)  # 求判断矩阵的秩
V1, D1 = np.linalg.eig(mes)  # 求判断矩阵的特征值和特征向量，V特征值，D特征向量；
list1 = list(V1)
B1 = np.max(list1)  # 最大特征值
index1 = list1.index(B1)
C1 = D1[:, index1]  # 对应特征向量
CI1 = (B1 - n1) / (n1 - 1)  # 计算一致性检验指标CI
CI1 = CI1.real
CR1 = CI1 / RI[n1]
CR1 = CR1.real
if CR1 < 0.10:
    print("信息准确权重：")
    # 特征值法求权重
    mes_weight = AHP(mes).cal_weight__by_eigenvalue_method()


#交费行为
pay = np.array([[1, 1.1, 1.3, 5.3, 5.7, 7],
                [1 / 1.1, 1, 1.2, 5.2, 5.5, 6.8],
                [1 / 1.3, 1 / 1.2, 1, 5, 5.4, 6.6],
                [1 / 5.3, 1 / 5.2, 1 / 5, 1, 1.5, 2.8],
                [1 / 5.7, 1 / 5.5, 1 / 5.4, 1 / 1.5, 1, 2.5],
                [1 / 7, 1 / 6.8, 1 / 6.6, 1 / 2.8, 1 / 2.5, 1]])
m2 = len(pay)  # 获取指标个数
n2 = len(pay[0])
R2 = np.linalg.matrix_rank(pay)  # 求判断矩阵的秩
V2, D2 = np.linalg.eig(pay)  # 求判断矩阵的特征值和特征向量，V特征值，D特征向量；
list2 = list(V2)
B2 = np.max(list2)  # 最大特征值
index2 = list2.index(B2)
C2 = D2[:, index2]  # 对应特征向量
CI2 = (B2 - n2) / (n2 - 1)  # 计算一致性检验指标CI
CI2 = CI2.real
CR2 = CI2 / RI[n2]
CR2 = CR2.real
if CR2 < 0.10:
    print("交费行为权重：")
    # 特征值法求权重
    pay_weight = AHP(pay).cal_weight__by_eigenvalue_method()

#用电行为
elec = np.array([[1,2,3.5,3.8,5.5,5.9],
                 [1/2,1,3.3,3.5,5.4,5.7],
                 [1/3.5,1/3.3,1,1.5,3.5,3.7],
                 [1/3.8,1/3.5,1/1.5,1,3.2,3.5],
                 [1/5.5,1/5.4,1/3.5,1/3.2,1,1.3],
                 [1/5.9,1/5.7,1/3.7,1/3.5,1/1.3,1]
                 ])
m3 = len(elec)  # 获取指标个数
n3 = len(elec[0])
R3 = np.linalg.matrix_rank(elec)  # 求判断矩阵的秩
V3, D3 = np.linalg.eig(elec)  # 求判断矩阵的特征值和特征向量，V特征值，D特征向量；
list3 = list(V3)
B3 = np.max(list3)  # 最大特征值
index3 = list3.index(B3)
C3 = D3[:, index3]  # 对应特征向量
CI3 = (B3 - n3) / (n3 - 1)  # 计算一致性检验指标CI
CI3 = CI3.real
CR3 = CI3 / RI[n3]
CR3 = CR3.real
if CR3 < 0.10:
    print("用电行为权重：")
    # 特征值法求权重
    elec_weight = AHP(elec).cal_weight__by_eigenvalue_method()

#准则层判断矩阵
credit = np.array([[1,3,5],
                [1/3,1,3],
                [1/5, 1/3, 1]])
m1 = len(credit)  # 获取指标个数
n1 = len(credit[0])
R1 = np.linalg.matrix_rank(credit)  # 求判断矩阵的秩
V1, D1 = np.linalg.eig(credit)  # 求判断矩阵的特征值和特征向量，V特征值，D特征向量；
list1 = list(V1)
B1 = np.max(list1)  # 最大特征值
index1 = list1.index(B1)
C1 = D1[:, index1]  # 对应特征向量
CI1 = (B1 - n1) / (n1 - 1)  # 计算一致性检验指标CI
CI1 = CI1.real
CR1 = CI1 / RI[n1]
CR1 = CR1.real
if CR1 < 0.10:
    print("客户信用权重：")
    # 特征值法求权重
    weight = AHP(credit).cal_weight__by_eigenvalue_method()

'''
连接ads宽表，取出数据,计算信息质量得分、交费行为得分、用电行为得分、总得分
'''

# python读数据库
# 连接mysql数据库
conn = pymysql.connect(
    host='25.212.157.216',
    port=13306,
    user='jingyanyuan',
    password='Jingyanyuan@%458',
    db='jingyanyuan',
    charset='utf8',
    cursorclass=pymysql.cursors.DictCursor)#json格式
# 创建游标
cursor = conn.cursor()  # 执行完毕返回的结果默认以元组的形式保存
# 使用 execute()  方法执行 SQL 查询
sql = 'select * from mrt_cons_credit_jyy_m'
cursor.execute(sql)
data = cursor.fetchall()
update_sql = 'update mrt_cons_credit_jyy_m set info_ql_sco =(%s),deal_ql_sco =(%s) , elec_mn_sco =(%s), credit_sco =(%s)  where cons_no = (%s)'
update_data = []
#循环遍历所有数据
for index in range(len(data)):
    total_score = 0
    row_data = data[index]
    #基础信息
    cons_no = data['cons_no']
    cons_nm = data['cons_nm']
    cert_typ = data['cert_typ']
    cert_no = data['cert_no']
    elec_typ = data['elec_typ']
    elec_addr = data['elec_addr']
    tel_no = data['tel_no']
    owner_dt = data['owner_dt']
    ls_wechat = data['ls_wechat']
    ls_app = data['is_app']
    mes_len = 18
    '''
        信息准确得分    
    '''
    mes_score = 0

    # 基础信息完整性
    count_null = 0
    if (cons_no.strip() == ''):
        count_null += 1
    if (cons_nm.strip() == ''):
        count_null += 1
    if (cert_typ.strip() == ''):
        count_null += 1
    if (cert_no.strip() == ''):
        count_null += 1
    if (elec_typ.strip() == ''):
        count_null += 1
    if (elec_addr.strip() == ''):
        count_null += 1
    if (tel_no.strip() == ''):
        count_null += 1
    if (owner_dt.strip() == ''):
        count_null += 1
    if (count_null == 0):
        mes_score += mes_weight[0] * 100
    elif (count_null == 1):
        mes_score += mes_weight[0] * 75
    elif (count_null == 2):
        mes_score += mes_weight[0] * 50
    elif (count_null >=3 and count_null<mes_len):
        mes_score += mes_weight[0] * 25
    else:
        mes_score += 0

    #基础信息准确性
    if(cert_typ==1 and len(cert_no)!=18):
        mes_score += mes_weight[1] * 0
    else:
        mes_score += mes_weight[1] * 100

    #附加信息完整性
    if(ls_app==0 and ls_wechat==0):
        mes_score += mes_weight[2] * 0
    elif (ls_app == 1 and  ls_wechat == 1):
        mes_score += mes_weight[2] * 100
    else:
        mes_score += mes_weight[2] * 50
    print("信息准确得分：\n")
    print(mes_score)

    '''
        交费行为得分    
    '''
    pay_score = 0
    rcvbl_penalty_sum = data['rcvbl_penalty_sum']
    deal_amt_sum = data['deal_amt_sum']
    deal_channel_Pref = data['deal_channel_Pref']
    deal_channel_kind = data['deal_channel_kind']

    # 交费金额
    if (deal_amt_sum >=0 and deal_amt_sum < 87.6):
        pay_score += 0
    elif (deal_amt_sum>= 87.6 and deal_amt_sum < 215):
        pay_score += pay_weight[0] * 25
    elif (deal_amt_sum>=215 and deal_amt_sum < 488):
        pay_score += pay_weight[0] * 50
    elif (deal_amt_sum>=488 and deal_amt_sum < 1360):
        pay_score += pay_weight[0] * 75
    else:
        pay_score += pay_weight[0] * 100

    # 累计违约金额占比
    pay_percent = round(rcvbl_penalty_sum/deal_amt_sum,4)
    if(pay_percent == 0):
        pay_score += pay_weight[1] * 100
    elif(pay_score<0.0003):
        pay_score += pay_weight[1] * 75
    elif (pay_score <0.0009):
        pay_score += pay_weight[1] * 50
    elif (pay_score < 0.0023):
        pay_score += pay_weight[1] * 25
    else:
        pay_score += 0

    # 累计违约金额
    if (rcvbl_penalty_sum == 0):
        pay_score += pay_weight[2] * 100
    elif (rcvbl_penalty_sum < 1.09):
        pay_score += pay_weight[2] * 75
    elif (rcvbl_penalty_sum < 3.95):
        pay_score += pay_weight[2] * 50
    elif (rcvbl_penalty_sum < 13.6):
        pay_score += pay_weight[2] * 25
    else:
        pay_score += 0

    # 交费渠道偏好
    if(deal_channel_Pref == '0203'):
        pay_score += pay_weight[3] * 75
    elif (deal_channel_Pref == '0307' or deal_channel_Pref == '030702'
          or deal_channel_Pref == '0306' or deal_channel_Pref == '011101'):
        pay_score += pay_weight[3] * 100
    else:
        pay_score += pay_weight[3] * 50

    # 交费渠道种类
    if(deal_channel_kind >= 3):
        pay_score += pay_weight[4] * 25
    elif (deal_channel_kind  == 2):
        pay_score += pay_weight[4] * 50
    else:
        pay_score += pay_weight[4] * 100

    #户龄
    now_date = datetime.datetime.fromtimestamp(time.time())
    owner_dt = datetime.datetime.fromtimestamp(owner_dt)
    dd = (now_date - owner_dt).days / 30
    dd = math.ceil(dd)
    if (dd <70 ):
        pay_score += pay_weight[5] * 25
    elif (dd<133):
        pay_score += pay_weight[4] * 50
    elif (dd <175):
        pay_score += pay_weight[4] * 75
    else:
        pay_score += pay_weight[4] * 100

    print("交费行为得分：\n")
    print(pay_score)

    elec_score = 0

    '''
       用电行为得分    
    '''
    violate_kind = data['violate_kind']
    violate_num = data['violate_num']
    violate_elecqt = data['violate_elecqt']
    steal_kind = data['steal_kind']
    steal_num = data['steal_num']
    steal_elecqt = data['steal_elecqt']

    # 违法次数
    if (steal_num == 0):
        elec_score += elec_weight[0] * 100
    elif (steal_num == 1):
        elec_score += elec_weight[0] * 10
    elif (steal_num == 2):
        elec_score += elec_weight[0] * 10
    else:
        elec_score += 0

    # 违规次数
    if (violate_num == 0):
        elec_score += elec_weight[1] * 100
    elif (violate_num == 1):
        elec_score += elec_weight[1] * 10
    elif (violate_num == 2):
        elec_score += elec_weight[1] * 10
    else:
        elec_score += 0

    # 违法追补电量
    if (steal_elecqt == 0):
        elec_score += elec_weight[2] * 100
    elif (steal_elecqt>0):
        elec_score += 0

    # 违规追补电量
    if (violate_elecqt == 0):
        elec_score += elec_weight[3] * 100
    elif (violate_elecqt > 0):
        elec_score += 0

    # 违法窃电种类
    if (steal_kind == 0):
        elec_score += elec_weight[4] * 100
    elif (steal_kind == 1):
        elec_score += elec_weight[4] * 10
    elif (steal_kind == 2):
        elec_score += elec_weight[4] * 10
    else:
        elec_score += 0

    #违规种类
    if (violate_kind == 0):
        elec_score += elec_weight[4] * 100
    elif (violate_kind == 1):
        elec_score += elec_weight[4] * 10
    elif (violate_kind == 2):
        elec_score += elec_weight[4] * 10
    else:
        elec_score += 0
    print("用户行为得分：\n")
    print(elec_score)

    #计算总分
    total_score = weight[0] * mes_score + weight[1] * pay_score + weight[2] * elec_score

    #赋值分数
    tmp_update_data = [mes_score,pay_score,elec_score,total_score,cons_no]
    update_data.append(tmp_update_data)


# 批量更新
try:
    res = cursor.executemany(update_sql, update_data)
    print(res)
    conn.commit()
except Exception as e:
    print(e)
    conn.rollback()
finally:
    # 关闭数据库
    cursor.close()
    conn.close()