simultaneous_baike_process_4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   {\n",
      "    \"基本信息\": {\n",
      "        \"中文名\": {\n",
      "            \"中文名\": \"邬贺铨\",\n",
      "            \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "        },\n",
      "        \"外文名\": \"\",\n",
      "        \"性别\": {\n",
      "            \"性别\": \"男\",\n",
      "            \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "        },\n",
      "        \"出生日期\": {\n",
      "            \"出生日期\": \"1943-1-16\",\n",
      "            \"来源\": \"wu_360,wu_baidu,wu_hudong,wu_sougou\"\n",
      "        },\n",
      "        \"出生地\": {\n",
      "            \"出生地\": \"广东省广州市\",\n",
      "            \"来源\": \"wu_360,wu_baidu,wu_hudong,wu_sougou\"\n",
      "        },\n",
      "        \"国籍\": {\n",
      "            \"国籍\": \"中国\",\n",
      "            \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "        },\n",
      "        \"民族\": {\n",
      "            \"民族\": \"汉族\",\n",
      "            \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "        },\n",
      "        \"职业\": \"\",\n",
      "        \"毕业院校\": {\n",
      "            \"毕业院校\": \"武汉邮电学院\",\n",
      "            \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "        },\n",
      "        \"政治面貌\": {\n",
      "            \"政治面貌\": \"中国共产党党员\",\n",
      "            \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "        },\n",
      "        \"代表作品\": {\n",
      "            \"代表作品\": \"STH-1/STM-4复用设备\",\n",
      "            \"来源\": \"wu_hudong\"\n",
      "        },\n",
      "        \"主要成就\": {\n",
      "            \"主要成就\": \"155/622Mb/sSDH光纤通信\",\n",
      "            \"来源\": \"wu_hudong\"\n",
      "        },\n",
      "        \"曾任职\": \"\",\n",
      "        \"信仰\": \"\",\n",
      "        \"原籍\": \"\"\n",
      "    },\n",
      "    \"人物履历\": {\n",
      "        \"教育经历\": {\n",
      "            \"本科\": {\n",
      "                \"起始时间\": {\n",
      "                    \"起始时间\": \"1960-9\",\n",
      "                    \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "                },\n",
      "                \"结束时间\": {\n",
      "                    \"结束时间\": \"1964-6\",\n",
      "                    \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "                },\n",
      "                \"学校名称\": {\n",
      "                    \"学校名称\": \"武汉邮电学院\",\n",
      "                    \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "                },\n",
      "                \"所属院系名\": \"\",\n",
      "                \"学历\": \"\",\n",
      "                \"学位\": {\n",
      "                    \"学位\": \"学士学位\",\n",
      "                    \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "                }\n",
      "            },\n",
      "            \"硕士研究生\": {\n",
      "                \"起始时间\": \"\",\n",
      "                \"结束时间\": \"\",\n",
      "                \"学校名称\": \"\",\n",
      "                \"所属院系名\": \"\",\n",
      "                \"导师\": \"\",\n",
      "                \"学历\": {\n",
      "                    \"学历\": \"研究生\",\n",
      "                    \"来源\": \"wu_360,wu_baidu,wu_wiki,wu_hudong,wu_sougou\"\n",
      "                },\n",
      "                \"学位\": \"\"\n",
      "            },\n",
      "            \"博士研究生\": {\n",
      "                \"起始时间\": \"\",\n",
      "                \"结束时间\": \"\",\n",
      "                \"学校名称\": \"\",\n",
      "                \"所属院系名\": \"\",\n",
      "                \"导师\": \"\",\n",
      "                \"学历\": \"\",\n",
      "                \"学位\": \"\"\n",
      "            },\n",
      "            \"博士后\": {\n",
      "                \"起始时间\": \"\",\n",
      "                \"结束时间\": \"\",\n",
      "                \"学校名称\": \"\",\n",
      "                \"所属院系名\": \"\",\n",
      "                \"导师\": \"\",\n",
      "                \"学历\": \"\",\n",
      "                \"学位\": \"\"\n",
      "            }\n",
      "        },\n",
      "        \"工作经历\": {\n",
      "            \"任职\": [\n",
      "                {\n",
      "                    \"起始时间\": \"1979年\",\n",
      "                    \"结束时间\": \"1993年\",\n",
      "                    \"职称\": \"主任\",\n",
      "                    \"地点\": \"\",\n",
      "                    \"所在单位\": \"成都邮电部第五研究所数字通信研究室\"\n",
      "                },\n",
      "                {\n",
      "                    \"起始时间\": \"1964年\",\n",
      "                    \"结束时间\": \"1969年\",\n",
      "                    \"职称\": \"\",\n",
      "                    \"地点\": \"\",\n",
      "                    \"所在单位\": \"邮电部邮电科学研究院\"\n",
      "                },\n",
      "                {\n",
      "                    \"起始时间\": \"1969年\",\n",
      "                    \"结束时间\": \"1975年\",\n",
      "                    \"职称\": \"\",\n",
      "                    \"地点\": \"\",\n",
      "                    \"所在单位\": \"四川眉山电信总局505厂\"\n",
      "                },\n",
      "                {\n",
      "                    \"起始时间\": \"1975年\",\n",
      "                    \"结束时间\": \"1979年\",\n",
      "                    \"职称\": \"\",\n",
      "                    \"地点\": \"\",\n",
      "                    \"所在单位\": \"重庆邮电部第九研究所\"\n",
      "                },\n",
      "                {\n",
      "                    \"起始时间\": \"1993年\",\n",
      "                    \"结束时间\": \"1999年\",\n",
      "                    \"职称\": \"副总裁\",\n",
      "                    \"地点\": \"\",\n",
      "                    \"所在单位\": \"大唐电信集团\"\n",
      "                },\n",
      "                {\n",
      "                    \"起始时间\": \"1993年\",\n",
      "                    \"结束时间\": \"1999年\",\n",
      "                    \"职称\": \"副院长兼总工程师\",\n",
      "                    \"地点\": \"\",\n",
      "                    \"所在单位\": \"电信科学技术研究院\"\n",
      "                }\n",
      "            ]\n",
      "        }\n",
      "    },\n",
      "    \"任免_辞职\": \"\",\n",
      "    \"其他职务\": {\n",
      "        \"学术兼职\": \"\",\n",
      "        \"技术工作兼职\": \"\",\n",
      "        \"社会兼职\": [\n",
      "            {\n",
      "                \"起始时间\": \"2008年\",\n",
      "                \"结束时间\": \"\",\n",
      "                \"组织机构\": \"第十一届全国政协委员\",\n",
      "                \"职位_职称\": \"教科文卫体委员会专委\"\n",
      "            },\n",
      "            {\n",
      "                \"起始时间\": \"2011年\",\n",
      "                \"结束时间\": \"\",\n",
      "                \"组织机构\": \"中国电子学会物联网专家委员\",\n",
      "                \"职位_职称\": \"主任委员\"\n",
      "            }\n",
      "        ]\n",
      "    },\n",
      "    \"科研方向\": \"\",\n",
      "    \"研究领域\": [\n",
      "        \"数字通信技术\"\n",
      "    ],\n",
      "    \"主要荣誉\": [\n",
      "        {\n",
      "            \"时间点\": \"1998年\",\n",
      "            \"颁奖单位\": \"\",\n",
      "            \"授予奖项名称\": \"“中国国家科技进步二等奖\",\n",
      "            \"消歧标记\": 1\n",
      "        },\n",
      "        {\n",
      "            \"时间点\": \"1998年\",\n",
      "            \"颁奖单位\": \"\",\n",
      "            \"授予奖项名称\": \"“中国国家科技进步二等奖”\",\n",
      "            \"消歧标记\": 1\n",
      "        },\n",
      "        {\n",
      "            \"时间点\": \"1997年\",\n",
      "            \"颁奖单位\": \"\",\n",
      "            \"授予奖项名称\": \"中国邮电部科技进步一等奖\"\n",
      "        },\n",
      "        {\n",
      "            \"时间点\": \"1988年\",\n",
      "            \"颁奖单位\": \"\",\n",
      "            \"授予奖项名称\": \"中国国家科技进步一等奖\"\n",
      "        }\n",
      "    ],\n",
      "    \"主要成果\": {\n",
      "        \"学术论著类\": \"\",\n",
      "        \"散文类\": \"\",\n",
      "        \"承担项目类\": \"\",\n",
      "        \"研究成果类\": [\n",
      "            {\n",
      "                \"时间点\": \"1979年\",\n",
      "                \"研究成果名称\": \"中国第一套PCM30/32路通信设备和120路复用通信设备\"\n",
      "            }\n",
      "        ],\n",
      "        \"发明专利类\": \"\",\n",
      "        \"人才培养类\": [\n",
      "            {\n",
      "                \"时间点\": \"2018年\",\n",
      "                \"指导学生\": \"培养博士7名、硕士9名\"\n",
      "            },\n",
      "            {\n",
      "                \"时间点\": \"2018年\",\n",
      "                \"指导学生\": \"\"\n",
      "            },\n",
      "            {\n",
      "                \"时间点\": \"2018年\",\n",
      "                \"指导学生\": \"培养博士7名、硕士9名\"\n",
      "            },\n",
      "            {\n",
      "                \"时间点\": \"2018年\",\n",
      "                \"指导学生\": \"培养博士7名、硕士9名\"\n",
      "            },\n",
      "            {\n",
      "                \"时间点\": \"2018年\",\n",
      "                \"指导学生\": \"\"\n",
      "            }\n",
      "        ]\n",
      "    },\n",
      "    \"学术报告\": \"\",\n",
      "    \"外界评价\": \"\",\n",
      "    \"人物影响\": \"\",\n",
      "    \"个性寄语\": \"\",\n",
      "    \"社会争议_争议事件\": \"\",\n",
      "    \"获奖争议\": \"\"\n",
      "}\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "e:\\anaconda3\\lib\\re.py:212: FutureWarning: split() requires a non-empty pattern match.\n",
      "  return _compile(pattern, flags).split(string, maxsplit)\n"
     ]
    }
   ],
   "source": [
    "from SStack import SStack\n",
    "import cpca\n",
    "from cpca import drawer\n",
    "from DateFormatconvert2 import DateFormatHelper2\n",
    "from cilin import CilinSimilarity\n",
    "from queue import Queue,LifoQueue\n",
    "import collections\n",
    "import json\n",
    "import re\n",
    "import copy\n",
    "import Levenshtein #字符串的编辑距离\n",
    "import json\n",
    "import os\n",
    "import sys\n",
    "sys.setrecursionlimit(999)  # set the maximum depth as 5000\n",
    "\n",
    "cs = CilinSimilarity()\n",
    "# 获取指定目录下的json文件\n",
    "def get_files(path='D:\\zyt\\\\azyt\\sfx', rule=\".json\"):\n",
    "    all = []\n",
    "    for fpathe,dirs,fs in os.walk(path):   # os.walk获取所有的目录\n",
    "        for f in fs:\n",
    "            filename = os.path.join(fpathe,f)\n",
    "            if filename.endswith(rule):  # 判断是否是\".json\"结尾\n",
    "                all.append(filename)\n",
    "    return all\n",
    "\n",
    "#用于将地址信息进行对齐统一，接收参数为两个地址内容\n",
    "def merge_local(fang_360, fang_baidu):\n",
    "    location = []\n",
    "    res_list = [] #返回值以列表形式，列表里的第一个数字表示返回值的状态\n",
    "    #前面先处理为空的情况\n",
    "    if fang_360!='' and fang_baidu=='':\n",
    "        res_list = [0, fang_360]\n",
    "    elif fang_baidu!='' and fang_360=='':\n",
    "        res_list = [1, fang_baidu]\n",
    "    elif fang_360=='' and fang_baidu=='':\n",
    "        res_list = [4]\n",
    "    else:\n",
    "        if fang_360==fang_baidu:\n",
    "            res_list = [2, fang_360]\n",
    "        else:\n",
    "            location = [fang_360,fang_baidu]\n",
    "            df = cpca.transform(location) #实现地址信息格式的统一\n",
    "            province = set()\n",
    "            city = set()\n",
    "            zone = set()\n",
    "            address = set()\n",
    "            for i in range(len(df['省'])):\n",
    "                if df['省'][i]:\n",
    "                    province.add(df['省'][i])\n",
    "                if df['市'][i]:\n",
    "                    city.add(df['市'][i])\n",
    "                if df['区'][i]:\n",
    "                    zone.add(df['区'][i])\n",
    "                if df['地址'][i]:\n",
    "                    address.add(df['地址'][i])\n",
    "            if len(province)>1 or len(city)>1 or len(zone)>1 or len(address)>1: #表示地址描述不一致，需要消歧\n",
    "                res_list = [3]\n",
    "            else:\n",
    "                last_location = '' #将对齐的内容挨个拼接起来作为返回值\n",
    "                if len(province)==1:\n",
    "                    last_location = last_location + list(province)[0]\n",
    "                if len(city)==1:\n",
    "                    last_location = last_location + list(city)[0]\n",
    "                if len(zone)==1:\n",
    "                    last_location = last_location + list(zone)[0]\n",
    "#                 if len(address)==1:\n",
    "#                     last_location = last_location + list(address)[0]\n",
    "                res_list = [2, last_location]\n",
    "    return res_list\n",
    "\n",
    "# 用于将日期信息进行对齐统一,接收参数为两个日期内容\n",
    "def merge_date(fang_360, fang_baidu):\n",
    "    res_list = []\n",
    "    date = set()\n",
    "    if fang_360!='' and fang_baidu=='': #第一个不为空\n",
    "        formal_date = DateFormatHelper2.str2date(fang_360) #将日期格式进行统一\n",
    "        res_list = [0, formal_date]\n",
    "    elif fang_baidu!='' and fang_360=='': #第二个不为空\n",
    "        formal_date = DateFormatHelper2.str2date(fang_baidu)\n",
    "        res_list = [1, formal_date]\n",
    "    elif fang_baidu=='' and fang_360=='': #两个都为空时\n",
    "        res_list = [4]\n",
    "    else: #都不为空时比较\n",
    "        date.add(DateFormatHelper2.str2date(fang_baidu))\n",
    "        date.add(DateFormatHelper2.str2date(fang_360))\n",
    "        if len(date)==1: #两个相等时\n",
    "            res_list = [2, list(date)[0]] #两个相等时\n",
    "        else:\n",
    "            year = set()\n",
    "            month = set()\n",
    "            day = set()\n",
    "            for j in list(date):\n",
    "                if j.find('-')>0:\n",
    "                    res = j.split('-')\n",
    "                    m = 1\n",
    "                    for i in res:\n",
    "                        if m==1:\n",
    "                            year.add(i)\n",
    "                            m += 1\n",
    "                        elif m==2:\n",
    "                            month.add(i)\n",
    "                            m += 1\n",
    "                        else:\n",
    "                            day.add(i)\n",
    "                            m += 1\n",
    "                else:\n",
    "                    year.add(j)\n",
    "            if len(year)>1 or len(month)>1 or len(day)>1:\n",
    "                res_list = [3] #表示日期不一致，无法对齐，需要消歧\n",
    "            else:\n",
    "                last_date = ''\n",
    "                if len(year)==1:\n",
    "                    last_date = last_date + list(year)[0]\n",
    "                if len(month)==1:\n",
    "                    last_date = last_date + '-' + list(month)[0]\n",
    "                if len(day)==1:\n",
    "                    last_date = last_date + '-' + list(day)[0]\n",
    "                res_list = [2, last_date]\n",
    "    return res_list #返回对齐合并后的日期\n",
    "\n",
    "# 两个字符串的比较(看一个字符串是否是另一个字符串的子集)\n",
    "def string_compile(str1, str2):\n",
    "    str1 = re.split('_|\\,|\\/|\\，|\\、|\\-|\\ ' ,str1) #以这几个符号作为分割符切分两个字符串\n",
    "    str2 = re.split('_|\\,|\\/|\\，|\\、|\\-|\\ ' ,str2)\n",
    "    str1_len = len(str1)\n",
    "    str2_len = len(str2)\n",
    "    var_set = set(str1)\n",
    "    return_str = ''\n",
    "    for i in str2:\n",
    "        var_set.add(i)\n",
    "    if len(var_set) == str1_len:\n",
    "        j = 0 \n",
    "        for i in str1:\n",
    "            if j+1 == str1_len:\n",
    "                return_str = return_str+i\n",
    "            else:\n",
    "                return_str = return_str+i+'/'\n",
    "            j += 1\n",
    "        return return_str\n",
    "    elif len(var_set) == str2_len:\n",
    "        j = 0 \n",
    "        for i in str2:\n",
    "            if j+1 == str2_len:\n",
    "                return_str = return_str+i\n",
    "            else:\n",
    "                return_str = return_str+i+'/'\n",
    "            j += 1\n",
    "        return return_str\n",
    "    else:\n",
    "        return 1\n",
    "  \n",
    "'''\n",
    "# 文件都是列表时的对齐，接收参数是属性内容列表attribute_value_list\n",
    "整体思路与内容是字典时的比较一样，也是先比较内容列表里的前两个值，比较的结果放入列表后面\n",
    "当列表长度为1的时候就返回，否则继续比较\n",
    "'''\n",
    "def compile_list(attribute_value_list):\n",
    "    new_attribute_list = []\n",
    "    # 循环的目的是为了将属性内容为空的值去掉，只比较不为空的内容\n",
    "    for i in attribute_value_list:\n",
    "        if i != '':\n",
    "            new_attribute_list.append(i)\n",
    "    if len(new_attribute_list)>1: #当列表长度大于1的时候，继续比较\n",
    "        list_baike1 = new_attribute_list[0]\n",
    "        list_baike2 = new_attribute_list[1]\n",
    "        year = set() #年份集合\n",
    "        list_360_new = []\n",
    "        list_baidu_new = []\n",
    "        for dict_info1 in list_baike1: #依次取出360百科文件列表里的元素，对其中是时间的键值进行格式统一(只取年份)\n",
    "            for key,value in dict_info1.items():\n",
    "                if key=='时间点' or key=='起始时间':\n",
    "                    value = get_year(value)\n",
    "                    if value!='':\n",
    "                        year.add(value) #将年份添加到集合中,对齐比较时，只看相同的起始时间的内容\n",
    "                    dict_info1[key] = value\n",
    "                if key=='结束时间':\n",
    "                    value = get_year(value)\n",
    "                    dict_info1[key] = value\n",
    "            list_360_new.append(dict_info1)\n",
    "        for dict_info2 in list_baike2: #依次取出百度百科文件列表里的元素，对其中是时间的键值进行格式统一(只取年份)\n",
    "            for key,value in dict_info2.items():\n",
    "                if key=='时间点' or key=='起始时间':\n",
    "                    value = get_year(value)\n",
    "                    if value!='':\n",
    "                        year.add(value)\n",
    "                    dict_info2[key] = value\n",
    "                if key=='结束时间':\n",
    "                    value = get_year(value)\n",
    "                    dict_info2[key] = value\n",
    "            list_baidu_new.append(dict_info2)\n",
    "        return_list = [] #最终返回的字典集合\n",
    "        flag2 = 0 #用于标记是否出现需要消歧的情况(在当前子属性下)\n",
    "        for i in list(year):\n",
    "            tmp_list1 = [] #中间过度列表，用于存放两个文件中年份相同的字典\n",
    "            tmp_list2 = [] #中间过度列表，用于存放两个文件中年份相同的字典\n",
    "            for dict_info1 in list_360_new:\n",
    "                for key,value in dict_info1.items():\n",
    "                    if (key=='起始时间' or key=='时间点') and value == i:\n",
    "                        tmp_list1.append(dict_info1)\n",
    "            tmp_list1_copy = copy.deepcopy(tmp_list1) #因为下面在做的过程中会根据对齐消歧的情况不断改变tmp_list1的值，所以先用一个变量保存\n",
    "            for dict_info2 in list_baidu_new:\n",
    "                for key,value in dict_info2.items():\n",
    "                    if (key=='起始时间' or key=='时间点') and value == i:\n",
    "                        tmp_list2.append(dict_info2)\n",
    "            if len(tmp_list1)==0 and len(tmp_list2)!=0:\n",
    "                for q in tmp_list2:\n",
    "                    return_list.append(q)\n",
    "            elif len(tmp_list1)!=0 and len(tmp_list2)==0:\n",
    "                for q in tmp_list1:\n",
    "                    return_list.append(q)\n",
    "            else:\n",
    "                keys = list(tmp_list1[0].keys())\n",
    "                flag_list = [] #记录360百科文件与百度百科文件的对齐的字典部分\n",
    "                for content_year_baidu in tmp_list2:\n",
    "                    flag = 0 #标识是否需要进行对齐操作\n",
    "                    tmp_dict1 = copy.deepcopy(content_year_baidu) #用另一个中间变量来表示当前遍历到的字典\n",
    "                    for content_year_360 in tmp_list1:\n",
    "                        flag5 = 0 #标识结束时间是否不相等\n",
    "                        flag6 = 0 #标识其他非关键信息是否一样\n",
    "                        flag7 = 0 #标识是否是时间点\n",
    "                        flag4 = 0 #标记是否需要消歧\n",
    "                        temp_dict = {} #用于存储两个文件对齐字典的中间结果\n",
    "                        createVar = locals() #动态创建全局变量\n",
    "                        tmp_dict2 = copy.deepcopy(content_year_360) #用另一个中间变量来表示当前遍历到的字典\n",
    "                        for tmp_key in keys:\n",
    "                            #这里之所以会只看这些键的值，是因为这些键的值更具有唯一性，先看具有唯一性的键值是否一样，一样才继续进行下面其他键值的比较，不一样则认为两个字典不是需要对齐的块\n",
    "                            if tmp_key!='时间点' and tmp_key!='起始时间' and tmp_key!='所在单位' and tmp_key!='信息公布权威机关' and tmp_key!='组织机构' and tmp_key!='方向' and tmp_key!='颁奖单位' and tmp_key!='演讲/报告题目' and tmp_key!='事件' and tmp_key!='语录' and tmp_key!='争议起因' and tmp_key!='事件起因' and tmp_key!='教育理念/指导学生' and tmp_key!='专利名称' and tmp_key!='研究成果名称' and tmp_key!='项目名称' and tmp_key!='散文名称' and tmp_key!='论著名称' and tmp_key!='消歧标记' and tmp_key!='来源':\n",
    "                                createVar['tmp_360_'+tmp_key] = content_year_360[tmp_key] #分别保存两个文件该键值对应的值\n",
    "                                createVar['tmp_baidu_'+tmp_key] = content_year_baidu[tmp_key]\n",
    "                            if tmp_key=='所在单位' or tmp_key=='组织机构' or tmp_key=='方向' or tmp_key=='信息公布权威机关' or tmp_key=='颁奖单位' or tmp_key=='演讲/报告题目' or tmp_key=='事件' or tmp_key=='语录' or tmp_key=='争议起因' or tmp_key=='事件起因' or tmp_key=='教育理念/指导学生' or tmp_key=='专利名称' or tmp_key=='研究成果名称' or tmp_key=='项目名称' or tmp_key=='散文名称' or tmp_key=='论著名称':\n",
    "                                if content_year_360[tmp_key] == content_year_baidu[tmp_key]:\n",
    "                                    flag = 1\n",
    "                                elif cs.similarity(content_year_360[tmp_key], content_year_baidu[tmp_key])==1:\n",
    "                                    flag = 1\n",
    "                                elif Levenshtein.distance(content_year_360[tmp_key],content_year_baidu[tmp_key])<4:\n",
    "                                    flag = 1\n",
    "                                else:\n",
    "                                    continue\n",
    "                        # flag等于1表示可以继续下面的对齐比较\n",
    "                        if flag==1:\n",
    "                            specific_key = ['职称', '职位_职称', '所获奖项']\n",
    "                            for tmp_key in keys:\n",
    "                                if tmp_key=='时间点' or tmp_key=='起始时间':\n",
    "                                    temp_dict[tmp_key] = i\n",
    "                                    if tmp_key=='时间点':\n",
    "                                        flag7 = 1\n",
    "                                elif tmp_key=='所在单位' or tmp_key=='信息公布权威机关' or tmp_key=='组织机构' or tmp_key=='方向' or tmp_key=='颁奖单位' or tmp_key=='演讲/报告题目' or tmp_key=='事件' or tmp_key=='语录' or tmp_key=='争议起因' or tmp_key=='事件起因' or tmp_key=='教育理念/指导学生' or tmp_key=='专利名称' or tmp_key=='研究成果名称' or tmp_key=='项目名称' or tmp_key=='散文名称' or tmp_key=='论著名称':\n",
    "                                    temp_dict[tmp_key] = content_year_360[tmp_key]\n",
    "                                else:\n",
    "                                    #这里主要比较结束时间\n",
    "                                    if tmp_key=='结束时间':\n",
    "                                        if eval('tmp_360_'+tmp_key)==eval('tmp_baidu_'+tmp_key):\n",
    "                                            temp_dict[tmp_key] = content_year_360[tmp_key]\n",
    "                                            for k in specific_key:\n",
    "                                                if k in keys:\n",
    "                                                    if content_year_360[k] == content_year_baidu[k]:\n",
    "                                                        temp_dict[k] = content_year_360[k]\n",
    "                                                    elif content_year_360[k]!='' and content_year_baidu[k]=='':\n",
    "                                                        temp_dict[k] = content_year_360[k]\n",
    "                                                    elif content_year_360[k]=='' and content_year_baidu[k]!='':\n",
    "                                                        temp_dict[k] = content_year_baidu[k]\n",
    "                                                    else:\n",
    "                                                        str_res = string_compile(content_year_360[k], content_year_baidu[k])\n",
    "                                                        if str_res!=1:\n",
    "                                                            temp_dict[k] = str_res\n",
    "                                                        else:\n",
    "                                                            flag2 += 1\n",
    "                                                            flag4 = 1\n",
    "                                                            tmp_dict1['消歧标记'] = flag2\n",
    "                                                            tmp_dict2['消歧标记'] = flag2\n",
    "                                                            flag_list.append(content_year_360)\n",
    "                                                            break #通过百科或其他方式实现对齐\n",
    "                                            if flag4 ==1:\n",
    "                                                break\n",
    "                                        else:\n",
    "                                            flag5 = 1\n",
    "                                    #这里主要比较地点\n",
    "                                    elif tmp_key=='地点':\n",
    "                                        res = merge_local(eval('tmp_360_'+tmp_key), eval('tmp_baidu_'+tmp_key))\n",
    "                                        if res[0]==3: #表示需要消歧\n",
    "                                            flag2 += 1\n",
    "                                            flag4 = 1\n",
    "                                            tmp_dict1['消歧标记'] = flag2\n",
    "                                            tmp_dict2['消歧标记'] = flag2\n",
    "                                            flag_list.append(content_year_360)\n",
    "                                            break #未对齐，需要消歧\n",
    "                                        elif res[0]==4: #表示都为空\n",
    "                                            temp_dict[tmp_key] = ''\n",
    "                                        else: #表示对齐了的且有结果\n",
    "                                            temp_dict[tmp_key] = res[1]\n",
    "                                    #这里比较其他内容的值\n",
    "                                    else:\n",
    "                                        if tmp_key!='消歧标记' and tmp_key!='来源':\n",
    "                                            if eval('tmp_360_'+tmp_key) != eval('tmp_baidu_'+tmp_key):\n",
    "                                                sim = cs.similarity(eval('tmp_360_'+tmp_key), eval('tmp_baidu_'+tmp_key))\n",
    "                                                str_res = string_compile(eval('tmp_360_'+tmp_key), eval('tmp_baidu_'+tmp_key))\n",
    "                                                if sim == 1 or str_res!=1:\n",
    "                                                    if str_res!=1:\n",
    "                                                        temp_dict[tmp_key] = str_res\n",
    "                                                    else:\n",
    "                                                        temp_dict[tmp_key] = eval('tmp_baidu_'+tmp_key) #相似性得分1，即存在于词库中，直接返回\n",
    "                                                    if '结束时间' in keys:\n",
    "                                                        if content_year_360['结束时间'] == content_year_baidu['结束时间']:\n",
    "                                                            temp_dict['结束时间'] = get_year(content_year_360['结束时间'])\n",
    "                                                        elif content_year_360['结束时间']!='' and content_year_baidu['结束时间']=='':\n",
    "                                                            temp_dict['结束时间'] = get_year(content_year_360['结束时间'])\n",
    "                                                        elif content_year_360['结束时间']=='' and content_year_baidu['结束时间']!='':\n",
    "                                                            temp_dict['结束时间'] = get(content_year_baidu['结束时间'])\n",
    "                                                        else:\n",
    "                                                            flag2 += 1\n",
    "                                                            flag4 = 1\n",
    "                                                            tmp_dict1['消歧标记'] = flag2\n",
    "                                                            tmp_dict2['消歧标记'] = flag2\n",
    "                                                            flag_list.append(content_year_360)\n",
    "                                                            break #通过百科或其他方式实现对齐\n",
    "                                                    else: #表示是时间点,且有除时间点和关键内容外的其他信息相一致，则认为对齐\n",
    "                                                        flag_list.append(content_year_360)\n",
    "                                                        temp_dict = content_year_baidu\n",
    "                                                        if str_res!=1:\n",
    "                                                            temp_dict[tmp_key] = str_res\n",
    "                                                        else:\n",
    "                                                            temp_dict[tmp_key] = eval('tmp_baidu_'+tmp_key)\n",
    "                                                        break\n",
    "                                                else:\n",
    "                                                    if '结束时间' in keys:\n",
    "                                                        flag6 = 1\n",
    "                                                    else: #表示时间点情况下需要消歧\n",
    "                                                        flag2 += 1\n",
    "                                                        flag4 = 1\n",
    "                                                        tmp_dict1['消歧标记'] = flag2\n",
    "                                                        tmp_dict2['消歧标记'] = flag2\n",
    "                                                        flag_list.append(content_year_360)\n",
    "                                                        break\n",
    "                                            else:\n",
    "                                                temp_dict[tmp_key] = eval('tmp_baidu_'+tmp_key)\n",
    "                                                if '结束时间' in keys:\n",
    "                                                    if content_year_360['结束时间'] == content_year_baidu['结束时间']:\n",
    "                                                        temp_dict['结束时间'] = content_year_360['结束时间']\n",
    "                                                    elif content_year_360['结束时间']!='' and content_year_baidu['结束时间']=='':\n",
    "                                                        temp_dict['结束时间'] = content_year_360['结束时间']\n",
    "                                                    elif content_year_360['结束时间']=='' and content_year_baidu['结束时间']!='':\n",
    "                                                        temp_dict['结束时间'] = content_year_baidu['结束时间']\n",
    "                                                    else:\n",
    "                                                        flag2 += 1\n",
    "                                                        flag4 = 1\n",
    "                                                        tmp_dict1['消歧标记'] = flag2\n",
    "                                                        tmp_dict2['消歧标记'] = flag2\n",
    "                                                        flag_list.append(content_year_360)\n",
    "                                                        break #通过百科或其他方式实现对齐\n",
    "                                                else: #表示时间点情况下是对齐的\n",
    "                                                    flag_list.append(content_year_360)\n",
    "                                                    temp_dict = content_year_baidu\n",
    "                                                    break\n",
    "                                        else:\n",
    "                                            pass\n",
    "                            if flag5==1 and flag6==1: #结束时间和非关键其他信息都不相同时\n",
    "                                pass\n",
    "                            else:\n",
    "                                flag_list.append(content_year_360)\n",
    "                                break\n",
    "                    if flag4!=0: #先判断是否需要消歧，如果要消歧就直接把需要消歧的两个文件的内容加入返回列表\n",
    "                        return_list.append(tmp_dict1)\n",
    "                        return_list.append(tmp_dict2)\n",
    "                        #tmp_list1.remove(content_year_360)\n",
    "                    else:\n",
    "                        if flag==0:\n",
    "                            return_list.append(content_year_baidu)\n",
    "                        else:\n",
    "                            if flag5==1 and flag6==1: #第一层循环的一行比较到第二个循环的最后一个时都没有实现对齐\n",
    "                                return_list.append(content_year_baidu)\n",
    "                            else:\n",
    "                                return_list.append(temp_dict)\n",
    "                                #tmp_list1.remove(content_year_360)\n",
    "                for content_year_360 in tmp_list1_copy: #找出360百科文件中未与百度百科对齐的部分\n",
    "                    flag = 0\n",
    "                    for align_content_360 in flag_list:\n",
    "                        for tmp_key in keys:\n",
    "                            if tmp_key=='所在单位' or tmp_key=='信息公布权威机关' or tmp_key=='组织机构' or tmp_key=='方向' or tmp_key=='颁奖单位' or tmp_key=='演讲/报告题目' or tmp_key=='事件' or tmp_key=='语录' or tmp_key=='争议起因' or tmp_key=='事件起因' or tmp_key=='教育理念/指导学生' or tmp_key=='专利名称' or tmp_key=='研究成果名称' or tmp_key=='项目名称' or tmp_key=='散文名称' or tmp_key=='论著名称':\n",
    "                                if content_year_360[tmp_key] == align_content_360[tmp_key]:\n",
    "                                    flag = 1 #做一个关键信息相等时的标记\n",
    "                    if flag==0:\n",
    "                        return_list.append(content_year_360)\n",
    "        new_attribute_list.append(return_list)\n",
    "        del new_attribute_list[0]\n",
    "        del new_attribute_list[0]\n",
    "        return compile_list(new_attribute_list)\n",
    "    elif len(attribute_value_list) == 0:\n",
    "        return 0\n",
    "    else:\n",
    "        return attribute_value_list[0]\n",
    "\n",
    "# 将结果写入到新json文件中，接收参数为当前属性名word和要存入的结果res\n",
    "def list_to_newjson(word, res):\n",
    "    if word=='本科' or word=='硕士研究生' or word=='博士研究生' or word=='博士后':\n",
    "        align_json['人物履历']['教育经历'][word]=res\n",
    "    elif word=='任职' or word=='任免辞职':\n",
    "        align_json['人物履历']['工作经历'][word]=res\n",
    "    elif word=='学术兼职' or word=='技术工作兼职' or word=='社会兼职':\n",
    "        align_json['其他职务'][word]=res\n",
    "    elif word=='学术论著类' or word=='散文类' or word=='承担项目类' or word=='研究成果类' or word=='发明专利类' or word=='人才培养类':\n",
    "        align_json[\"主要成果\"][word]=res\n",
    "    else:\n",
    "        align_json[word]=res\n",
    "\n",
    "# 只取日期前面的年份\n",
    "def get_year(date):\n",
    "    if date!='':\n",
    "        date = date.strip()\n",
    "        year = date[:4]\n",
    "        year = year + '年'\n",
    "        return year\n",
    "    return date\n",
    "\n",
    "# 维护一个键的队列，输入参数为当前的属性名key和当前的队列的状态key_queue\n",
    "# 当遇到key为下面的值的时候，不仅弹出当前的key，还弹出其前一个即父类的key\n",
    "def preserve_key_queue(key, key_queue):\n",
    "    if key=='任免_辞职':\n",
    "        delete = key_queue.get()\n",
    "        delete = key_queue.get()\n",
    "    elif key=='社会兼职' or key=='人才培养类' or key=='博士后':\n",
    "        delete = key_queue.get()\n",
    "    else:\n",
    "        pass\n",
    "    \n",
    "'''\n",
    "比较字典型数据里的子属性的值,输入参数是不同百科改子属性值的列表和对应的属性名\n",
    "这里主要的思路是每次比较属性内容列表里前两个的值，比较的结果放入到列表末尾(无论是对齐的还是需要消歧的)\n",
    "当列表长度为1的时候，即表明比较结束，将比较结果返回\n",
    "'''\n",
    "def compare(content_list, index, baike_name):\n",
    "    if index=='起始时间' or index=='结束时间' or index=='出生日期':\n",
    "        if len(content_list)>1: #当content_list列表里不止一个元素时，继续比较，直到只剩一个元素才返回\n",
    "            tmp_dict1 = {}\n",
    "            tmp_dict2 = {}\n",
    "            tmp_list = []\n",
    "            # 这里处理列表前两个都是字符串时的情况\n",
    "            if type(content_list[0]).__name__=='str' and type(content_list[1]).__name__=='str':\n",
    "                res = merge_date(content_list[0], content_list[1])\n",
    "                if res[0]==2: #标识都不为空且是对齐了的\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = baike_name[0]+','+baike_name[1]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==4: #表示两个都为空值\n",
    "                    pass\n",
    "                elif res[0]==0: #表示content_list[0]不为空，content_list[1]为空\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==1: #表示content_list[0]为空，content_list[1]不为空\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = baike_name[1]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                else: #标识两个都不为空，且未对齐\n",
    "                    tmp_dict1[index] = DateFormatHelper2.str2date(content_list[0])\n",
    "                    tmp_dict1['消歧标志'] = 1\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    tmp_dict2[index] = DateFormatHelper2.str2date(content_list[1])\n",
    "                    tmp_dict2['消歧标志'] = 1\n",
    "                    tmp_dict2['来源'] = baike_name[1]\n",
    "                    tmp_list = [tmp_dict1, tmp_dict2]\n",
    "                    content_list.append(tmp_list)\n",
    "                del baike_name[0] #注意删除的时候的问题，连续删除两个的话，删除了第1个过后列表长度会减1\n",
    "                del baike_name[0]\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            #这里处理列表第一个是字符串，第二个是字典的情况\n",
    "            elif type(content_list[0]).__name__=='str' and type(content_list[1]).__name__=='dict':\n",
    "                res = merge_date(content_list[0], content_list[1][index])\n",
    "                if res[0]==2: #标识都不为空且是对齐了的\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = content_list[1]['来源']+','+baike_name[0]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==4: #表示两个都为空值\n",
    "                    pass\n",
    "                elif res[0]==0: #表示content_list[0]不为空，content_list[1]为空\n",
    "                    pass\n",
    "                elif res[0]==1: #表示content_list[0]为空，content_list[1]不为空\n",
    "                    content_list.append(content_list[1])\n",
    "                else: #标识两个都不为空，且未对齐\n",
    "                    tmp_dict1[index] = DateFormatHelper2.str2date(content_list[0])\n",
    "                    tmp_dict1['消歧标志'] = 1\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    content_list[1]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[1], tmp_dict1]\n",
    "                    content_list.append(tmp_list)\n",
    "                del baike_name[0]\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            #这里处理前两个都是字典的结构\n",
    "            elif type(content_list[0]).__name__=='dict' and type(content_list[1]).__name__=='dict':\n",
    "                res = merge_date(content_list[0][index], content_list[1][index])\n",
    "                if res[0]==2: #标识都不为空且是对齐了的\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = content_list[1]['来源']+','+content_list[0]['来源']\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==3:\n",
    "                    content_list[0]['消歧标志'] = 1\n",
    "                    content_list[1]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[0], content_list[1]]\n",
    "                    content_list.append(tmp_list)\n",
    "                else:\n",
    "                    pass\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            #这里处理第一个是字符串，第二个是列表的情况\n",
    "            elif type(content_list[0]).__name__=='str' and type(content_list[1]).__name__=='list':\n",
    "                flag = 0\n",
    "                for i in content_list[1]:\n",
    "                    res = merge_date(content_list[0], i[index])\n",
    "                    if res[0]==2: #标识都不为空且是对齐了的\n",
    "                        i[index] = res[1]\n",
    "                        i['来源'] = i['来源']+','+baike_name[0]\n",
    "                        content_list.append(content_list[1])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    elif res[0]==4: #表示两个都为空值\n",
    "                        pass\n",
    "                    elif res[0]==0: #表示content_list[0]不为空，content_list[1]为空\n",
    "                        pass\n",
    "                    elif res[0]==1: #表示content_list[0]为空，content_list[1]不为空\n",
    "                        content_list.append(content_list[1])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    else: #标识两个都不为空，且未对齐\n",
    "                        pass\n",
    "                if flag==1:\n",
    "                    del baike_name[0]\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "                else:\n",
    "                    tmp_dict1[index] = DateFormatHelper2.str2date(content_list[0])\n",
    "                    tmp_dict1['消歧标志'] = 1\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    tmp_list = [tmp_dict1]\n",
    "                    for i in content_list[1]:\n",
    "                        tmp_list.append(i)\n",
    "                    content_list.append(tmp_list)\n",
    "                    del baike_name[0]\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "            #这里处理第一个是字典，第二个是列表的情况\n",
    "            elif type(content_list[0]).__name__=='dict' and type(content_list[1]).__name__=='list':\n",
    "                flag = 0\n",
    "                for i in content_list[1]:\n",
    "                    res = merge_date(content_list[0][index], i[index])\n",
    "                    if res[0]==2:\n",
    "                        i[index] = res[1]\n",
    "                        i['来源'] = i['来源']+','+content_list[0]['来源']\n",
    "                        content_list.append(content_list[1])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    else:\n",
    "                        pass\n",
    "                if flag==1:\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "                else:\n",
    "                    content_list[0]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[0]]\n",
    "                    for i in content_list[1]:\n",
    "                        tmp_list.append(i)\n",
    "                    content_list.append(tmp_list)\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "            #这里处理第一个是列表第二个是字典的情况\n",
    "            elif type(content_list[0]).__name__=='list' and type(content_list[1]).__name__=='dict':\n",
    "                flag = 0\n",
    "                for i in content_list[0]:\n",
    "                    res = merge_date(content_list[1][index], i[index])\n",
    "                    if res[0]==2:\n",
    "                        i[index] = res[1]\n",
    "                        i['来源'] = i['来源']+','+content_list[1]['来源']\n",
    "                        content_list.append(content_list[0])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    else:\n",
    "                        pass\n",
    "                if flag==1:\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "                else:\n",
    "                    content_list[1]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[1]]\n",
    "                    for i in content_list[0]:\n",
    "                        tmp_list.append(i)\n",
    "                    content_list.append(tmp_list)\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "            #这里处理前两个都是列表的情况\n",
    "            elif type(content_list[0]).__name__=='list' and type(content_list[1]).__name__=='list':\n",
    "                flag_list = []\n",
    "                for i in content_list[0]:\n",
    "                    flag = 0\n",
    "                    for j in content_list[1]:\n",
    "                        res = merge_date(i[index], j[index])\n",
    "                        if res[0]==2:\n",
    "                            i[index] = res[1]\n",
    "                            i['来源'] = i['来源']+','+j['来源']\n",
    "                            tmp_list.append(i)\n",
    "                            flag = 1\n",
    "                            flag_list.append(j)\n",
    "                            break\n",
    "                        else:\n",
    "                            pass\n",
    "                    if flag==0:\n",
    "                        tmp_list.append(i)\n",
    "                for i in content_list[1]:\n",
    "                    flag = 0\n",
    "                    for j in flag_list:\n",
    "                        if i[index]!=j[index]:\n",
    "                            pass\n",
    "                        else:\n",
    "                            flag = 1\n",
    "                            break\n",
    "                    if flag == 0:\n",
    "                        tmp_list.append(i)\n",
    "                content_list.append(tmp_list)\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            else:\n",
    "                pass\n",
    "            return compare(content_list, index, baike_name)\n",
    "        else:\n",
    "            return content_list[0]\n",
    "    elif index=='出生地' or index=='原籍':\n",
    "        if len(content_list)>1: #当content_list列表里不止一个元素时，继续比较，直到只剩一个元素才返回\n",
    "            tmp_dict1 = {}\n",
    "            tmp_dict2 = {}\n",
    "            tmp_list = []\n",
    "            if type(content_list[0]).__name__=='str' and type(content_list[1]).__name__=='str':\n",
    "                res = merge_local(content_list[0], content_list[1])\n",
    "                if res[0]==2: #标识都不为空且是对齐了的\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = baike_name[0]+','+baike_name[1]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==4: #表示两个都为空值\n",
    "                    pass\n",
    "                elif res[0]==0: #表示content_list[0]不为空，content_list[1]为空\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==1: #表示content_list[0]为空，content_list[1]不为空\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = baike_name[1]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                else: #标识两个都不为空，且未对齐\n",
    "                    tmp_dict1[index] = content_list[0]\n",
    "                    tmp_dict1['消歧标志'] = 1\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    tmp_dict2[index] = content_list[1]\n",
    "                    tmp_dict2['消歧标志'] = 1\n",
    "                    tmp_dict2['来源'] = baike_name[1]\n",
    "                    tmp_list = [tmp_dict1, tmp_dict2]\n",
    "                    content_list.append(tmp_list)\n",
    "                del baike_name[0] #注意删除的时候的问题，连续删除两个的话，删除了第1个过后列表长度会减1\n",
    "                del baike_name[0]\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='str' and type(content_list[1]).__name__=='dict':\n",
    "                res = merge_local(content_list[0], content_list[1][index])\n",
    "                if res[0]==2: #标识都不为空且是对齐了的\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = content_list[1]['来源']+','+baike_name[0]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==4: #表示两个都为空值\n",
    "                    pass\n",
    "                elif res[0]==0: #表示content_list[0]不为空，content_list[1]为空\n",
    "                    pass\n",
    "                elif res[0]==1: #表示content_list[0]为空，content_list[1]不为空\n",
    "                    content_list.append(content_list[1])\n",
    "                else: #标识两个都不为空，且未对齐\n",
    "                    tmp_dict1[index] = content_list[0]\n",
    "                    tmp_dict1['消歧标志'] = 1\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    content_list[1]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[1], tmp_dict1]\n",
    "                    content_list.append(tmp_list)\n",
    "                del baike_name[0]\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='dict' and type(content_list[1]).__name__=='dict':\n",
    "                res = merge_local(content_list[0][index], content_list[1][index])\n",
    "                if res[0]==2: #标识都不为空且是对齐了的\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = content_list[1]['来源']+','+content_list[0]['来源']\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==3:\n",
    "                    content_list[0]['消歧标志'] = 1\n",
    "                    content_list[1]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[0], content_list[1]]\n",
    "                    content_list.append(tmp_list)\n",
    "                else:\n",
    "                    pass\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='str' and type(content_list[1]).__name__=='list':\n",
    "                flag = 0\n",
    "                for i in content_list[1]:\n",
    "                    res = merge_local(content_list[0], i[index])\n",
    "                    if res[0]==2: #标识都不为空且是对齐了的\n",
    "                        i[index] = res[1]\n",
    "                        i['来源'] = i['来源']+','+baike_name[0]\n",
    "                        content_list.append(content_list[1])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    elif res[0]==4: #表示两个都为空值\n",
    "                        pass\n",
    "                    elif res[0]==0: #表示content_list[0]不为空，content_list[1]为空\n",
    "                        pass\n",
    "                    elif res[0]==1: #表示content_list[0]为空，content_list[1]不为空\n",
    "                        content_list.append(content_list[1])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    else: #标识两个都不为空，且未对齐\n",
    "                        pass\n",
    "                if flag==1: #表示对齐了的情况下，进入删除百科名操作和删除内容列表操作\n",
    "                    del baike_name[0]\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "                else:\n",
    "                    tmp_dict1[index] = content_list[0]\n",
    "                    tmp_dict1['消歧标志'] = 1\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    tmp_list = [tmp_dict1]\n",
    "                    for i in content_list[1]:\n",
    "                        tmp_list.append(i)\n",
    "                    content_list.append(tmp_list)\n",
    "                    del baike_name[0]\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='dict' and type(content_list[1]).__name__=='list':\n",
    "                flag = 0\n",
    "                for i in content_list[1]:\n",
    "                    res = merge_local(content_list[0][index], i[index])\n",
    "                    if res[0]==2:\n",
    "                        i[index] = res[1]\n",
    "                        i['来源'] = i['来源']+','+content_list[0]['来源']\n",
    "                        content_list.append(content_list[1])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    else:\n",
    "                        pass\n",
    "                if flag==1:\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "                else:\n",
    "                    content_list[0]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[0]]\n",
    "                    for i in content_list[1]:\n",
    "                        tmp_list.append(i)\n",
    "                    content_list.append(tmp_list)\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='list' and type(content_list[1]).__name__=='dict':\n",
    "                flag = 0\n",
    "                for i in content_list[0]:\n",
    "                    res = merge_local(content_list[1][index], i[index])\n",
    "                    if res[0]==2:\n",
    "                        i[index] = res[1]\n",
    "                        i['来源'] = i['来源']+','+content_list[1]['来源']\n",
    "                        content_list.append(content_list[0])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    else:\n",
    "                        pass\n",
    "                if flag==1:\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "                else:\n",
    "                    content_list[1]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[1]]\n",
    "                    for i in content_list[0]:\n",
    "                        tmp_list.append(i)\n",
    "                    content_list.append(tmp_list)\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='list' and type(content_list[1]).__name__=='list':\n",
    "                flag_list = []\n",
    "                for i in content_list[0]:\n",
    "                    flag = 0\n",
    "                    for j in content_list[1]:\n",
    "                        res = merge_local(i[index], j[index])\n",
    "                        if res[0]==2:\n",
    "                            i[index] = res[1]\n",
    "                            i['来源'] = i['来源']+','+j['来源']\n",
    "                            tmp_list.append(i)\n",
    "                            flag = 1\n",
    "                            flag_list.append(j)\n",
    "                            break\n",
    "                        else:\n",
    "                            pass\n",
    "                    if flag==0:\n",
    "                        tmp_list.append(i)\n",
    "                for i in content_list[1]:\n",
    "                    flag = 0\n",
    "                    for j in flag_list:\n",
    "                        if i[index]!=j[index]:\n",
    "                            pass\n",
    "                        else:\n",
    "                            flag = 1\n",
    "                            break\n",
    "                    if flag == 0:\n",
    "                        tmp_list.append(i)\n",
    "                content_list.append(tmp_list)\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            else:\n",
    "                pass\n",
    "            return compare(content_list, index, baike_name)\n",
    "        else:\n",
    "            return content_list[0]\n",
    "    else: #除开时间、地址的其他情况对齐\n",
    "        if len(content_list)>1: #当content_list列表里不止一个元素时，继续比较，直到只剩一个元素才返回\n",
    "            tmp_dict1 = {} #中间变量，用于对其中一个文件的内容在对齐与消歧时做标记\n",
    "            tmp_dict2 = {} #中间变量，用于对另一个文件的内容在对齐与消歧时做标记\n",
    "            tmp_list = [] #临时变量，用于在消歧时记录两个文件内容的状态\n",
    "            if type(content_list[0]).__name__=='str' and type(content_list[1]).__name__=='str':\n",
    "                res = compare_other(content_list[0], content_list[1])\n",
    "                if res[0]==2: #标识都不为空且是对齐了的\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = baike_name[0]+','+baike_name[1]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==4: #表示两个都为空值\n",
    "                    pass\n",
    "                elif res[0]==0: #表示content_list[0]不为空，content_list[1]为空\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==1: #表示content_list[0]为空，content_list[1]不为空\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = baike_name[1]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                else: #标识两个都不为空，且未对齐\n",
    "                    tmp_dict1[index] = content_list[0]\n",
    "                    tmp_dict1['消歧标志'] = 1\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    tmp_dict2[index] = content_list[1]\n",
    "                    tmp_dict2['消歧标志'] = 1\n",
    "                    tmp_dict2['来源'] = baike_name[1]\n",
    "                    tmp_list = [tmp_dict1, tmp_dict2]\n",
    "                    content_list.append(tmp_list)\n",
    "                del baike_name[0] #注意删除的时候的问题，连续删除两个的话，删除了第1个过后列表长度会减1\n",
    "                del baike_name[0]\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='str' and type(content_list[1]).__name__=='dict':\n",
    "                res = compare_other(content_list[0], content_list[1][index])\n",
    "                if res[0]==2: #标识都不为空且是对齐了的\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = content_list[1]['来源']+','+baike_name[0]\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==4: #表示两个都为空值\n",
    "                    pass\n",
    "                elif res[0]==0: #表示content_list[0]不为空，content_list[1]为空\n",
    "                    pass\n",
    "                elif res[0]==1: #表示content_list[0]为空，content_list[1]不为空\n",
    "                    content_list.append(content_list[1])\n",
    "                else: #标识两个都不为空，且未对齐\n",
    "                    tmp_dict1[index] = content_list[0]\n",
    "                    tmp_dict1['消歧标志'] = 1\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    content_list[1]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[1], tmp_dict1]\n",
    "                    content_list.append(tmp_list)\n",
    "                del baike_name[0]\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='dict' and type(content_list[1]).__name__=='dict':\n",
    "                res = compare_other(content_list[0][index], content_list[1][index])\n",
    "                if res[0]==2: #标识都不为空且是对齐了的\n",
    "                    tmp_dict1[index] = res[1]\n",
    "                    tmp_dict1['来源'] = content_list[1]['来源']+','+content_list[0]['来源']\n",
    "                    content_list.append(tmp_dict1)\n",
    "                elif res[0]==3:\n",
    "                    content_list[0]['消歧标志'] = 1\n",
    "                    content_list[1]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[0], content_list[1]]\n",
    "                    content_list.append(tmp_list)\n",
    "                else:\n",
    "                    pass\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='str' and type(content_list[1]).__name__=='list':\n",
    "                flag = 0\n",
    "                for i in content_list[1]:\n",
    "                    res = compare_other(content_list[0], i[index])\n",
    "                    if res[0]==2: #标识都不为空且是对齐了的\n",
    "                        i[index] = res[1]\n",
    "                        i['来源'] = i['来源']+','+baike_name[0]\n",
    "                        content_list.append(content_list[1])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    elif res[0]==4: #表示两个都为空值\n",
    "                        pass\n",
    "                    elif res[0]==0: #表示content_list[0]不为空，content_list[1]为空\n",
    "                        pass\n",
    "                    elif res[0]==1: #表示content_list[0]为空，content_list[1]不为空\n",
    "                        content_list.append(content_list[1])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    else: #标识两个都不为空，且未对齐\n",
    "                        pass\n",
    "                if flag==1:\n",
    "                    del baike_name[0]\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "                else:\n",
    "                    tmp_dict1[index] = content_list[0]\n",
    "                    tmp_dict1['消歧标志'] = 1\n",
    "                    tmp_dict1['来源'] = baike_name[0]\n",
    "                    tmp_list = [tmp_dict1]\n",
    "                    for i in content_list[1]:\n",
    "                        tmp_list.append(i)\n",
    "                    content_list.append(tmp_list)\n",
    "                    del baike_name[0]\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='dict' and type(content_list[1]).__name__=='list':\n",
    "                flag = 0\n",
    "                for i in content_list[1]:\n",
    "                    res = compare_other(content_list[0][index], i[index])\n",
    "                    if res[0]==2:\n",
    "                        i[index] = res[1]\n",
    "                        i['来源'] = i['来源']+','+content_list[0]['来源']\n",
    "                        content_list.append(content_list[1])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    else:\n",
    "                        pass\n",
    "                if flag==1:\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "                else:\n",
    "                    content_list[0]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[0]]\n",
    "                    for i in content_list[1]:\n",
    "                        tmp_list.append(i)\n",
    "                    content_list.append(tmp_list)\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='list' and type(content_list[1]).__name__=='dict':\n",
    "                flag = 0\n",
    "                for i in content_list[0]:\n",
    "                    res = compare_other(content_list[1][index], i[index])\n",
    "                    if res[0]==2:\n",
    "                        i[index] = res[1]\n",
    "                        i['来源'] = i['来源']+','+content_list[1]['来源']\n",
    "                        content_list.append(content_list[0])\n",
    "                        flag = 1\n",
    "                        break\n",
    "                    else:\n",
    "                        pass\n",
    "                if flag==1:\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "                else:\n",
    "                    content_list[1]['消歧标志'] = 1\n",
    "                    tmp_list = [content_list[1]]\n",
    "                    for i in content_list[0]:\n",
    "                        tmp_list.append(i)\n",
    "                    content_list.append(tmp_list)\n",
    "                    del content_list[0]\n",
    "                    del content_list[0]\n",
    "            elif type(content_list[0]).__name__=='list' and type(content_list[1]).__name__=='list':\n",
    "                flag_list = []\n",
    "                for i in content_list[0]:\n",
    "                    flag = 0\n",
    "                    for j in content_list[1]:\n",
    "                        res = compare_other(i[index], j[index])\n",
    "                        if res[0]==2:\n",
    "                            i[index] = res[1]\n",
    "                            i['来源'] = i['来源']+','+j['来源']\n",
    "                            tmp_list.append(i)\n",
    "                            flag = 1\n",
    "                            flag_list.append(j)\n",
    "                            break\n",
    "                        else:\n",
    "                            pass\n",
    "                    if flag==0:\n",
    "                        tmp_list.append(i)\n",
    "                for i in content_list[1]:\n",
    "                    flag = 0\n",
    "                    for j in flag_list:\n",
    "                        if i[index]!=j[index]:\n",
    "                            pass\n",
    "                        else:\n",
    "                            flag = 1\n",
    "                            break\n",
    "                    if flag == 0:\n",
    "                        tmp_list.append(i)\n",
    "                content_list.append(tmp_list)\n",
    "                del content_list[0]\n",
    "                del content_list[0]\n",
    "            else:\n",
    "                pass\n",
    "            return compare(content_list, index, baike_name)\n",
    "        else:\n",
    "            return content_list[0]\n",
    "    \n",
    "# 根据库比较除时间、地点外其他值是否对齐，接收的参数为两个文件属性的值，以列表形式返回，一个是内容一个是标识\n",
    "def compare_other(content1, content2):\n",
    "    res_list = [] #以列表形式返回，一个是内容一个是标识\n",
    "    if content1!='' and content2=='':\n",
    "        res_list = [0, content1] #标识第一个不为空，第二个为空\n",
    "    elif content1=='' and content2!='': \n",
    "        res_list = [1, content2] #标识第一个为空，第二个不为空\n",
    "    elif content1!='' and content2!='':\n",
    "        if content1==content2:\n",
    "            res_list = [2, content1]\n",
    "        else:\n",
    "            res = cs.similarity(content1, content2)\n",
    "            if res==1:\n",
    "                res_list = [2, content1] #标识两个都不为空且是对齐的\n",
    "            else:\n",
    "                res_list = [3] #标识两个都不为空，但未对齐\n",
    "    else:\n",
    "        res_list = [4] #标识两个都为空\n",
    "    return res_list\n",
    " \n",
    "'''\n",
    "# 对非列表且是字典形式的内容进行对齐(这里主要关注基本信息、本科、硕士、博士、博士后这几个模块)\n",
    "# 接收参数为属性值列表和百科文件名\n",
    "# 按照时间、地点和其他信息处理\n",
    "'''\n",
    "def align_dict(attribute_value_list, baike_name):\n",
    "    keys = list(attribute_value_list[0].keys()) #得到该属性下的所有键的名字，并放到一个list里\n",
    "    new_dict = {} #用于存放对齐与未对齐(需消歧)后的内容\n",
    "    for index in keys:\n",
    "        value = []\n",
    "        for i in attribute_value_list:\n",
    "            value.append(i[index])\n",
    "        var_baike_name = copy.deepcopy(baike_name)\n",
    "        res = compare(value, index, var_baike_name)\n",
    "        new_dict[index] = res\n",
    "    return new_dict\n",
    "                                                        \n",
    "# 对非列表非字典形式的内容对齐(也包括都是列表，但列表里面都是字符串，不是字典的情况)\n",
    "def string_align(word, content_list):\n",
    "    new_list = []\n",
    "    list_to_set = set() #把list里的内容放到集合中，实现自动去重\n",
    "    for i in content_list:\n",
    "        if i=='':\n",
    "            pass\n",
    "        else:\n",
    "            for j in i:\n",
    "                list_to_set.add(j)\n",
    "    new_list = list(list_to_set)\n",
    "    return new_list\n",
    "\n",
    "'''本函数用户判断某个属性对应的值的类型，并根据类型调用相应的函数处理，\n",
    "   接受参数为维护的栈和队列，以及各百科文件的来源名\n",
    "   当属性队列为空的时候，返回0\n",
    "'''\n",
    "def other_align(st, key_queue, baike_name):\n",
    "    if not st.is_empty():\n",
    "        content = set()\n",
    "        word = st.pop() #弹出当前栈里面顶上的内容\n",
    "        key_queue.put(word) #键值队列，用于保存前面已出现的键值(目的是方便后面迭代时能准确找到进行到什么地方了)\n",
    "        index = 0 #index变量，用于在json_file(百科的json文件列表)里找到对应的百科文件\n",
    "        attribute_value_list = [] #局部列表变量，用于存储不同百科文件当前属性下的值\n",
    "        for i in baike_name:\n",
    "            p = json_file[index] #将当前遍历获得的百科文件存入到变量P里面\n",
    "            key_str = 'p'\n",
    "            for j in key_queue.queue: #通过维护的键的队列取到对应的键值\n",
    "                key_str = key_str+'[\\''+j+'\\']'\n",
    "            attribute_value_list.append(eval(key_str))\n",
    "            index += 1\n",
    "        flag = 0 #标记这几个百科json文件的当前属性值是否为空\n",
    "        '''\n",
    "        这里之所以遍历查看的原因是可能五个文件中有些该属性的值为空，但其他文件却为list或dict，\n",
    "        如果先遍历到为空的文件，也先不管，还是继续遍历，直到找到不为空的，执行相应的操作,\n",
    "        但一旦遍历到了不为空的，就可以break退出循环，以免重复进行操作\n",
    "        '''\n",
    "        for i in attribute_value_list:\n",
    "            if type(i).__name__ == 'list': #处理百科json文件中该属性下的值如果是列表时的情况，则取出列表里的每一个字典\n",
    "                flag = 1\n",
    "                if word=='人物影响' or word=='研究领域': #这两个属性的值没有子属性了，其值直接就是字符串形式，所以单独处理\n",
    "                    res = string_align(word, attribute_value_list)\n",
    "                    list_to_newjson(word, res)\n",
    "                    key = key_queue.get()\n",
    "                    preserve_key_queue(key, key_queue)\n",
    "                    other_align(st, key_queue, baike_name)\n",
    "                else: #其他情况的属性值里还有子属性，此时如果是列表的话也是单独处理\n",
    "                    res = compile_list(attribute_value_list) #返回的是一个列表，列表里面是多个字典\n",
    "                    if res==0:\n",
    "                        res=''\n",
    "                    list_to_newjson(word,res)\n",
    "                    key = key_queue.get()\n",
    "                    preserve_key_queue(key, key_queue) #得到动态维护的键的队列\n",
    "                    other_align(st, key_queue, baike_name)\n",
    "                break\n",
    "            elif type(i).__name__ == 'dict': #处理百科json文件中该属性下的值如果是字典时的情况，这里主要是针对单属性值\n",
    "                flag = 1\n",
    "                if word=='基本信息' or word=='本科' or word=='硕士研究生' or word=='博士研究生' or word=='博士后':\n",
    "                    res = align_dict(attribute_value_list, baike_name)\n",
    "                    list_to_newjson(word,res)\n",
    "                    key = key_queue.get()\n",
    "                    preserve_key_queue(key, key_queue)\n",
    "                    other_align(st, key_queue, baike_name)\n",
    "                else: #当不是单属性值时，说明其还不是最外层的属性(也即为父属性)，则将其压入栈中后续出栈时再处理\n",
    "                    dict_key1 = list(i.keys()) #将字典里的键都放入栈中，稍后依次取出进行对齐\n",
    "                    dict_key1.reverse()\n",
    "                    for i in dict_key1:\n",
    "                        st.push(i)\n",
    "                    other_align(st, key_queue, baike_name)\n",
    "                break\n",
    "            else:\n",
    "                pass\n",
    "        if flag==0: #表示这几个文件的当前属性都为空\n",
    "            res = ''\n",
    "            list_to_newjson(word, res)\n",
    "            key = key_queue.get()\n",
    "            preserve_key_queue(key, key_queue)\n",
    "            other_align(st, key_queue, baike_name)\n",
    "    else:\n",
    "        return 0\n",
    "\n",
    "# 对齐处理的入口函数，接收参数为最外层的属性名列表和对应的百科json文件名列表\n",
    "def process_entrace(key_list, baike_name):\n",
    "    tree=lambda:collections.defaultdict(tree)\n",
    "    global align_json #全局变量，用于存储对齐和未对齐(做标记)的结果\n",
    "    align_json=tree()\n",
    "    st = SStack() #用栈存放每一轮的属性\n",
    "    lq = LifoQueue(maxsize=0) #用后进先出队列用于存放文件操作过程中的中间键值(用于新建新的对齐json)\n",
    "    key_list.reverse() #属性名列表反向，为了使最后按照正向的方式写入\n",
    "    for i in key_list:\n",
    "        st.push(i) #将最开始外层的属性名压入栈中\n",
    "    res = other_align(st, lq, baike_name) #调用对齐的控制函数\n",
    "    print(\"  \",json.dumps(align_json,ensure_ascii=False,indent=4))\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    b = get_files(r\"./baike file/wu\")\n",
    "    global json_file #全局列表变量，用于存放不同百科json文件的内容\n",
    "    json_file = []\n",
    "    baike_name = [] #局部变量，用于存放json百科文件的名字，对应数据来源\n",
    "    for i in b:\n",
    "        if i.split('\\\\')[1]!='fang_merge.json' and i.split('\\\\')[1]!='merge.json':\n",
    "            with open(i) as f: #打开json文件并保存到json文件列表里\n",
    "                json_file.append(json.load(f))\n",
    "            baike_name.append(i.split('\\\\')[1].split('.')[0]) #取出百科json文件的文件名\n",
    "    key_list = list(json_file[0].keys()) #局部变量，用于存放百科json文件的最外层父属性\n",
    "    process_entrace(key_list, baike_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1985-10\n"
     ]
    }
   ],
   "source": [
    "from DateFormatconvert2 import DateFormatHelper2\n",
    "dict1 = [{'起始时间':'1985年','结束时间':'1988年'},{'起始时间':'1989年','结束时间':'1993年'}]\n",
    "print(\"  \",DateFormatHelper2.str2date('1985.10'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   [3, 7]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1,2,[3,7],4,5]\n",
    "def test(list2):\n",
    "    return list2[2]\n",
    "res = test(list1)\n",
    "print(\"  \",res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}