实习 week（一）

痛定思痛。 2022-05-21 11:59 132阅读 0赞

# 一、环境搭建： #

1、Python+Pycharm

2、Phpstudy:该程序包集成最新的Apache+PHP+MySQL+[phpMyAdmin][]\+[ZendOptimizer][],一次性安装，无须配置即可使用，是非常方便、好用的PHP调试环境·该程序不仅包括PHP调试环境，还包括了开发工具、开发手册等·总之学习PHP只需一个包。

# 二、操作平台 #

Windows+Linux（服务器）

Xshell：windows下SSH远程登录Linux软件。一个强大的安全终端模拟软件，它支持SSH1、SSH2以及Microsoft Windows 平台的TELNET 协议。Xshell 通过互联网到远程主机的安全连接以及它创新性的设计和特色，帮助用户在复杂的网络环境中享受他们的工作。Xshell适合于初级用户和高级用户。它的界面友好，为高级用户提供了更强大的功能。

# 三、Linux命令及MySQL #

Linux：

wget：下载

unzip：解压zip文件

less：查看文档

ls：查看当前文件夹下的所有文件

tree：当前文件夹下的目录缩进列表

tree命令行参数：  
\-a 显示所有文件和目录。  
\-A 使用ASNI绘图字符显示树状图而非以ASCII字符组合。  
\-C 在文件和目录清单加上色彩，便于区分各种类型。  
\-d 显示目录名称而非内容。  
\-D 列出文件或目录的更改时间。  
\-f 在每个文件或目录之前，显示完整的相对路径名称。  
\-F 在执行文件，目录，Socket，符号连接，管道名称名称，各自加上"\*","/","=","@","|"号。  
\-g 列出文件或目录的所属群组名称，没有对应的名称时，则显示群组识别码。  
\-i 不以阶梯状列出文件或目录名称。  
\-I 不显示符合范本样式的文件或目录名称。  
\-l 如遇到性质为符号连接的目录，直接列出该连接所指向的原始目录。  
\-n 不在文件和目录清单加上色彩。  
\-N 直接列出文件和目录名称，包括控制字符。  
\-p 列出权限标示。  
\-P 只显示符合范本样式的文件或目录名称。  
\-q 用"?"号取代控制字符，列出文件和目录名称。  
\-s 列出文件或目录大小。  
\-t 用文件和目录的更改时间排序。  
\-u 列出文件或目录的拥有者名称，没有对应的名称时，则显示用户识别码。  
\-x 将范围局限在现行的文件系统中，若指定目录下的某些子目录，其存放于另一个文件系统上，则将该子目录予以排除在寻找范围外。

MySQL：

查看数据库（DB）、表（TB）的信息：show databases; show tables;先使用USE DB名进入数据中才可以查看表列。

创建DB、TB：CREATE DATABASE DB名;       CREATE TABLE TB名;

增（加入）：INSERT INTO  表名（属性字段）VALUES（字段对应的值）

删：DROP TABLE TBNAME;（释放空间）DELETE \*FROM TBNAME ;（不释放空间）

改：UPDATE TBNAME SET 字段=字段值

查：SELECT \*FROM  TB  ;表示对整张表的查看

SELECT  属性字段 FROM TB;表示对表中的某一字段的查看

SELECT DISTINCT:查看表中无重复的。

SELECT ...........WHERE  字段操作条件（逻辑：and ,or,not；比较：=，>,<,>=,<=,!=,（<>） 特殊：is null,between and ,in ,like（匹配%表任意，-表相同的））

ORDER BY：对某字段排序查看，默认升序（ASC）；降序：DESC

# 四、加密方法（校验文件） #

MD5：  即Message-Digest Algorithm 5(信息-摘要算法5)，用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一  ，主流编程语言普遍已有MD5实现。将数据(如汉字)运算为另一固定长度值，是杂凑算法的基础原理。

MD5算法具有以下特点:

1、压缩性:任意长度的数据，算出的MD5值长度都是固定的。

2、容易计算:从原数据计算出MD5值很容易。

3、抗修改性:对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别。

4、强抗碰撞:已知原数据和其MD5值，想找到一个具有相同MD5值的数据(即伪造数据)是非常困难的。

MD5的作用是让大容量信息在用[数字签名][Link 1]软件签署私人密钥前被"[压缩][Link 2]"成一种保密的格式

# 五、任务 #

cms版本识别提取模块

从phpmyadmin的若干版本源码包中，找出一个路径（包括文件名），该路径大多数源码包中都包含，并且md5值不一样，寻找的文件类型为css或js  
程序输出：  
\{  
 "url": "/test/test.css",  
 "data": \{  
  "xxxversion": "32位md5",  
  "yyyversion": "32位md5"  
 \}

phpmyadmin版本网址： https://github.com/phpmyadmin/phpmyadmin/releases

在服务器中用wget命令下载各版本的phpmyadmin，使用unzip解压Zip压缩包。

使用命令：find ./phpmyadmin-RELEASE\_4\_6\_6/ -regextype posix-extended -regex ".\*\\.(css|js)" -exec md5sum \{\} \\;>filename.txt

命令解释：

find命令查找当前目录下phpmyadmin-RELEASE\_4\_6\_6文件夹下

regextype posix-extended ：正则类型为posix-extended

\-regex ".\*\\.(css|js)"：找到后缀名为css和js文件

\-exec ：选项后面跟随着所要执行的命令或脚本，然后是一对儿 \{\}，一个空格和一个\\，最后是一个分号

md5sum：计算文件的MD5------命令行终端直接执行

>filename.txt：执行结果保存到改文件中

下载了16个版本计算出各版本对应的MD5保存在txt文件中。

version information：

0.txt---466
    1.txt---401020
    2.txt---470
    .......
    .......
    12---480
    13---4801
    14---481
    15---482

代码：

*对数据分割重组---all\_file\_to\_merge\_1.py*

#对数据分割重组
    import re
    
    #--------------创建all_file_merge.txt----V/P:MD5-----------
    #所有版本内容合并： V/P:md5
    all_file_to_dict={}
    for i in range(16):
        filepath='Data/'+str(i)+'.txt'
        file=open(filepath,'r')
    
        for line in file.readlines():
            key,value=line.strip().split('./')
            all_file_to_dict[value]=key
    
    all_file_merge=open('txt/all_file_merge.txt','w')
    for (key,value) in all_file_to_dict.items():
        all_file_merge.write('%s:%s\n'%(key,value))
    
    
    #------------创建path_md5.txt---P:MD5------------
    list=[]
    for i in range(16):
        filepath = 'Data/' + str(i) + '.txt'
        file = open(filepath, 'r')
        dict={}
        for line in file.readlines():
            key,value=line.strip().split('./')
            value=value[::-1]
            match=re.match('.*/',value)
            value=match.group()[::-1]
            dict[value]=key
        list.append(dict)
    
    path_ma5=open('txt/path_md5.txt','w')
    for i in range(16):
        for key,value in list[i].items():
            path_ma5.write('%s:%s\n'%(key,value))
    
    
    #--------------创建version_md5.txt-V:MD5---------------
    file=open('txt/all_file_merge.txt','r')
    version_md5=open('txt/version_md5.txt','w')
    for line in file.readlines():
        key1,value1=line.strip().split('/',1)
        key2,value2=line.strip().split(':')
        version_md5.write('%s:%s\n'%(key1,value2))

#文件排序--path_md5_sort_2.py

#文件排序
    file=open('txt/path_md5.txt','r')
    #对path_md5排序：结果写入path_md5_sort.txt文件中
    list=[]
    for line in file.readlines():
        list.append(line)
    
    # print(len(list))
    
    list.sort()#返回值是None，其表示是在原对象上进行的操作。返回排序后结果意味着创建了一个副本。
    # print(len(list))
    
    file_sort=open(r'txt/path_md5_sort.txt','w')
    for l in range(len(list)):
        file_sort.write('%s'%(list[l]))

找到相同文件下的路径---find\_16\_samepath\_file\_3.py

#小心：在同一个文件中不能写读同一个文件，否则读会出错
    
    #找到16个文件中共同的文件
    find_file=open(r'txt/path_md5_sort.txt','r')
    
    
    path_list=[]
    # countx=0
    for line in find_file.readlines():
        (path,value)=line.strip().split(':')
        path_list.append(path)
        # countx+=1
    # print(path_list)
    # print(countx)
    
    #记录16个相同路径的第一个序号:与源文件少1，是因为列表从0开始遍历而源文件是从1开始计数
    record_num=[]
    # print(len(path_list))
    for i in range(len(path_list)):
        # print(i)
        count=i+15
        if count<len(path_list) and path_list[i]==path_list[count]  :
            record_num.append(i)
        # print(path_list[i])
    # print(record_num)

找到相同文件下文件位置----find\_16\_samepath\_file\_position\_4.py

import find_16_samepath_file_3
    
    
    find_file_=open(r'txt/path_md5_sort.txt','r')
    list=[]
    list_=[]
    
    # for i in range(len(sort_process.record_num)):
    #     for line in find_file_.readlines()[sort_process.record_num[i]:sort_process.record_num[i]+16]:
    #         list.append(line)
    #     # list_.append(list)
    # print(list_)
    
    num=0
    i=0
    count=0
    for line in find_file_.readlines():
        if num<len(find_16_samepath_file_3.record_num) and i>=find_16_samepath_file_3.record_num[num] and i<=find_16_samepath_file_3.record_num[num]+15  :
            list_.append(line)
            count+=1
            # print(line)
        if(count==16):#计数到16时，count归0，并且列表指向下一个元素
            num+=1
            count=0
        i+=1
    
    print('获得文件数量：',len(find_16_samepath_file_3.record_num))
    print('存储的序号：\n',find_16_samepath_file_3.record_num)
    
    print('列表元素个数：',len(list_))
    
    finded_file=open('txt/finded.txt','w')
    for i in range(len(list_)):
        finded_file.write('%s'%list_[i])

找到相同文件路径不同的MD5值----find\_16\_samepath\_different\_md5\_5.py

file=open('txt/finded.txt','r')
    list=[]
    
    for line in file.readlines():
        path,md5=line.strip().split(':',1)
        list.append(line)
    # print(len(list))
    
    md5_list=[]
    num=0
    for i in range(len(list)):
        # for j in range(16):
            if i+1<len(list) and list[i]==list[i+1]:
                continue
            else:
                md5_list.append(list[i])
    
    # print(md5_list)
    
    find_different_md5=open('txt/find_different_md5.txt','w')
    for i in range(len(md5_list)):
        find_different_md5.write('%s'%md5_list[i])

相同路径的文件不同的MD5值-----samepath\_file\_different\_md5\_6.py

file=open('txt/find_different_md5.txt','r')
    
    list=[]
    #读取文本中的内容将路径保存在list中方便后面统计相同路径的数目
    for line in file.readlines():
        key,value=line.strip().split(':')
        list.append(key)
    
    print(len(list))
    
    
    count=1
    num=0
    tmp=list[0]
    list_num=[]
    path=''
    dict={}
    #用list_num记录列表中相同路径下的MD5不同的数量，并且将路径+数量保存到字典中
    for i in range(1,len(list)):
        if(list[i]==tmp):
            count+=1
        else:
            list_num.append(count)
            dict[tmp]=count
            tmp=list[i]
            count=1
    
    print(list_num)
    print(len(list_num))
    for (key,value) in dict.items():
        print(key,value)
        num+=1
    print(num)
    
    # 找到列表中的最大值,并判断最大值个数
    max_list_num=max(list_num)
    
    print(max_list_num)
    # count_max=0
    # for i in range(len(list_num)):
    #     if(list_num[i]==max(list_num)):
    #         count_max+=1
    
    # 找到最大的数（MD5不同），将对应的路径及MD5以key，value形式保存在字典中
    dict_result={}
    for path,num in dict.items():
        if(num==max(list_num)):
            dict_result[path]=num
    
    
    print("fined the result:")
    for path,num in dict_result.items():
        print(path,num)
    
    # dict_to_list=list(dict_result)
    
    #将记录的路径保存在列表中
    list_path=[]
    for path,num in dict_result.items():
        list_path.append(path)
    
    # print(list_path)
    
    
    ## 记录需要文件的数量
    need_file_num=len(list_path)
    print(need_file_num)

找到最终所要的路径及MD5值----final\_path\_md5\_7.py

import samepath_file_different_md5_6
    
    file=open('txt/find_different_md5.txt','r')
    
    num=0
    count=0
    list_path_md5=[]
    # print(len(same_file_different_md5.list_path))
    
    # 从所有的相同路径不同MD5文件中遍历
    for line in file.readlines():
        # print(line)
        path,md5=line.strip().split(':')
        # print(key)
        #相同路径下含有最多不同的MD5的内容
        if num<len(samepath_file_different_md5_6.list_path) and (path==samepath_file_different_md5_6.list_path[num]):
            list_path_md5.append(line)
            count+=1
        #当计数到同文件下不同MD5的最大数量时，num++即遍历列表中的下一个保存路径
        if count==samepath_file_different_md5_6.max_list_num:
            num+=1
    
    print(list_path_md5)
    
    # 将找到的内容保存起来
    P_M=open('txt/final_path_md5.txt','w')
    for i in range(len(list_path_md5)):
        P_M.write('%s\n'%list_path_md5[i].strip())

找到文件路径和MD5所对应的版本----final\_version\_path\_md5\_8.py

import final_path_md5_7
    
    file1=open('txt/version_md5.txt','r')
    
    
    list=[]
    # 用MD5来找对应的版本，然后将version+path+md5保存到列表中
    for line in file1.readlines():
        version,md5=line.strip().split(':')
        for i in range(len(final_path_md5_7.list_path_md5)):
            path,md5_=final_path_md5_7.list_path_md5[i].strip().split(':')
            if md5==md5_:
                list.append(version+final_path_md5_7.list_path_md5[i])
    
    print(list)
    # 将version+path+文本中md5写入
    final_result=open('txt/final_result.txt','w')
    for i in range(len(list)):
        final_result.write('%s\n'%list[i].strip())

最终输出结果-----output\_final\_result\_9.py

import samepath_file_different_md5_6
    
    file=open('txt/final_result.txt','r')
    
    #list中保存了16*samepath_file_different_md5_6.need_file_num个文件
    list=[]
    for line in file.readlines():
        list.append(line)
    
    # print(len(list))
    
    list.sort()
    for i in range(len(list)):
        print(list[i].strip())
    
    
    save_final_output=open('txt/final_output.txt','w')
    num=0
    print('output_result:')
    #一般性，可能含有多个相同的最大的MD5数量
    # 遍历有可能多个MD5的不同数量即符合要求多于1个其数量为samepath_file_different_md5_6.need_file_num
    for i in range(samepath_file_different_md5_6.need_file_num):
        key,value=list[num].strip().split(':')#分割version_path：MD5，初始标志
        print('{')
    
        save_final_output.write('{\n')
    
        # vp,md5=key.strip().split(':')
        ver,path=key.strip().split('/',1)#分割version:path
        print('  url:',path)
        save_final_output.write('  url:%s\n'%path)
    
        print('  {\n    data:\n    {')
        save_final_output.write('  {\n    data:\n    {\n')
    
        for j in range(num+1,(i+1)*16):#
            key1,value1=list[j].strip().split(':')
            if(value==value1):#与前一个MD5对比，相同跳过
                continue
            else:
                version,mad5=key.strip().split('/',1)#MD5不同，记录初始位置的V_M
    
                print('        ',version,':',value)
                save_final_output.write('        %s:%s\n'%(version,value))
    
                key,value=key1,value1 #更新比较的值
    
        num = num+16
        key2,value2=list[num-1].strip().split(':')#最后一个
        version_, mad5_= key2.strip().split('/', 1)
    
        print('        ',version_, ':', value)
        save_final_output.write('        %s:%s\n' % (version_, value))
    
        print('    }')
        save_final_output.write('    }\n')
    
    print('  }')
    save_final_output.write('  }\n')
    # print(samepath_file_different_md5_6.max_list_num)
    
    
    
    
    # #特殊性：只有一个最大的MD5数量
    # key,value=list[0].strip().split(':')
    # print('{')
    # # vp,md5=key.strip().split(':')
    # v,p=key.strip().split('/',1)
    # print('url:',p)
    # print('{\n    data:\n    {')
    # for j in range(1,len(list)):
    #     key1,value1=list[j].strip().split(':')
    #     if(value==value1):
    #         continue
    #     else:
    #         version,mad5_=key.strip().split('/',1)
    #         print('        ',version,':',value)
    #         key,value=key1,value1
    #
    # key1,value1=list[len(list)-1].strip().split(':')
    # version, mad5= key1.strip().split('/', 1)
    # print('        ',version, ':', value)
    # print('    }')
    
    print('}')
    save_final_output.write('}\n')

输出结果：

phpmyadmin-RELEASE_4_8_0_1/js/functions.js:d4a5bf4e8132866616b8075e8827bad0
    phpmyadmin-RELEASE_4_6_6/js/functions.js:db63c463875d1cae7e693a6c1e7f28a3
    phpmyadmin-RELEASE_4_7_2/js/functions.js:0897dbca1c58de900ac8021056a6c7d3
    phpmyadmin-RELEASE_4_8_2/js/functions.js:ef34ef55580ee6df3904c70860e6e88c
    phpmyadmin-RELEASE_4_7_4/js/functions.js:71c5e608aa26796e50c6a4529c1cd5ce
    phpmyadmin-RELEASE_4_8_1/js/functions.js:ef34ef55580ee6df3904c70860e6e88c
    phpmyadmin-RELEASE_4_7_8/js/functions.js:ef4d5b7a6c2c1be01e1eec495db4c774
    phpmyadmin-RELEASE_4_7_5/js/functions.js:67a365b16667782bdd24a6202cefd18d
    phpmyadmin-RELEASE_4_8_0/js/functions.js:d4a5bf4e8132866616b8075e8827bad0
    phpmyadmin-RELEASE_4_0_10_20/js/functions.js:5756175e11213f350447abd31b93f109
    phpmyadmin-RELEASE_4_7_0/js/functions.js:82ae0a4ae237df3aab11a9da0048cf3f
    phpmyadmin-RELEASE_4_7_7/js/functions.js:ef4d5b7a6c2c1be01e1eec495db4c774
    phpmyadmin-RELEASE_4_7_6/js/functions.js:4e871fb0acc54b581d666bf41db280bb
    phpmyadmin-RELEASE_4_7_1/js/functions.js:0897dbca1c58de900ac8021056a6c7d3
    phpmyadmin-RELEASE_4_7_9/js/functions.js:ac9eb9d6b69a9b2b86675243fe603f29
    phpmyadmin-RELEASE_4_7_3/js/functions.js:e230f74a598be7b4ac16536309f423ff

以及：

{
      url:js/functions.js
      {
        data:
        {
            phpmyadmin-RELEASE_4_0_10_20:5756175e11213f350447abd31b93f109
            phpmyadmin-RELEASE_4_6_6:db63c463875d1cae7e693a6c1e7f28a3
            phpmyadmin-RELEASE_4_7_0:82ae0a4ae237df3aab11a9da0048cf3f
            phpmyadmin-RELEASE_4_7_1:0897dbca1c58de900ac8021056a6c7d3
            phpmyadmin-RELEASE_4_7_3:e230f74a598be7b4ac16536309f423ff
            phpmyadmin-RELEASE_4_7_4:71c5e608aa26796e50c6a4529c1cd5ce
            phpmyadmin-RELEASE_4_7_5:67a365b16667782bdd24a6202cefd18d
            phpmyadmin-RELEASE_4_7_6:4e871fb0acc54b581d666bf41db280bb
            phpmyadmin-RELEASE_4_7_7:ef4d5b7a6c2c1be01e1eec495db4c774
            phpmyadmin-RELEASE_4_7_9:ac9eb9d6b69a9b2b86675243fe603f29
            phpmyadmin-RELEASE_4_8_0:d4a5bf4e8132866616b8075e8827bad0
            phpmyadmin-RELEASE_4_8_2:ef34ef55580ee6df3904c70860e6e88c
        }
      }
    }

所有代码合并到一个文件中----cms.py

#------------------------------第1步：文件重组 # all_file_to_merge_1 #对数据分割重组 import re
    import os
    import sys
    #--------------创建all_file_merge.txt----V/P:MD5----------- #所有版本内容合并： V/P:md5 all_file_to_dict={}
    
    
    path='Data1/file_txt/' ######*********######### 可修改 ls = os.listdir(path)
    file_num = 0 for i in ls:
        if os.path.isfile(os.path.join(path,i)):
            file_num += 1 print (file_num)
    
    
    for i in range(file_num):#文件数量 filepath='Data1/file_txt/'+str(i)+'.txt' ######*********######### 可修改 file=open(filepath,'r')
    
        for line in file.readlines():
            key,value=line.strip().split('./')
            all_file_to_dict[value]=key
    
    print(all_file_to_dict)                        #all_file_merge.txt # all_file_merge=open('txt/all_file_merge.txt','w') # for (key,value) in all_file_to_dict.items(): # all_file_merge.write('%s:%s\n'%(key,value)) #------------创建path_md5.txt---P:MD5------------ list_path_md5_dict=[]
    for i in range(file_num):#文件数量 filepath = 'Data1/file_txt/' + str(i) + '.txt' ######*********######### file = open(filepath, 'r')
        dict={}
        for line in file.readlines():
            key,value=line.strip().split('./')
            value=value[::-1]
            match=re.match('.*/',value)
            value=match.group()[::-1]
            dict[value]=key
        list_path_md5_dict.append(dict)
    
    # print(list_path_md5_dict) #path_md5.txt # path_ma5=open('txt/path_md5.txt','w') # for i in range(file_num): # for key,value in list[i].items(): # path_ma5.write('%s:%s\n'%(key,value)) # print(list) # # # #--------------创建version_md5.txt-V:MD5--------------- list_version_md5=[]
    # file=open('txt/all_file_merge.txt','r') # version_md5=open('txt/version_md5.txt','w') # for line in file.readlines(): # key1,value1=line.strip().split('/',1) # key2,value2=line.strip().split(':') # version_md5.write('%s:%s\n'%(key1,value2)) for (key,value) in all_file_to_dict.items():
        version,path=key.strip().split('/',1)
        list_version_md5.append(version+':'+value)
    
    # print(list_version_md5) print('success!')
    
    # #--------------------------------第2步： #文件排序 # file=open('txt2/path_md5.txt','r') ######*********######### #对path_md5排序：结果写入path_md5_sort.txt文件中 list_path_md5=[]
    for i in range(len(list_path_md5_dict)):
        for key,value in list_path_md5_dict[i].items():
            list_path_md5.append(key+':'+value)
    
    
    
    # for line in file.readlines(): # list.append(line) # print(len(list)) list_path_md5.sort()#返回值是None，其表示是在原对象上进行的操作。返回排序后结果意味着创建了一个副本。 list_path_md5_sort=list_path_md5
    
    # print(len(list_path_md5_sort)) # print(list_path_md5_sort) #----------------------------------第三步： #小心：在同一个文件中不能写读同一个文件，否则读会出错 #找到所有版本中共同的文件 路径相同 list_path=[]
    for i in range(len(list_path_md5_sort)):
         parh,md5=list_path_md5_sort[i].strip().split(':')
         list_path.append(parh)
    
    print(len(list_path))
    print(list_path)
    
    
    #记录列表中相同路径的第一个序号:与源文件少1，是因为列表从0开始遍历而源文件是从1开始计数 list_path_record_num=[]
    # print(len(path_list)) for i in range(len(list_path)):
        # print(i) count=i+file_num-1 #############修改 if count<len(list_path) and list_path[i]==list_path[count]  :
            list_path_record_num.append(i)
        # print(path_list[i]) print(len(list_path_record_num))
    if(len(list_path_record_num)==0):
        print('所有版本中不存在与版本数量相同路径下的文件！')
        sys.exit()
    print('list_path_record_num:',list_path_record_num)
    
    
    #-------------------第4步找出相同路径的文件的位置 # import find_16_samepath_file_3 # import all_file_to_merge_1 # find_file_=open(r'txt2/path_md5_sort.txt','r') list_all_samefile_path=[]
    num=0 # 列表中的序号 i=0 #第i位置 count=0 #计数，记到所有文件的数量时，归0 for j in list_path_md5_sort:
        if num<len(list_path_record_num) and \
                i>=list_path_record_num[num] and \
                i<=list_path_record_num[num]+file_num-1:############## list_all_samefile_path.append(j)
            count+=1 # print(line) if(count==file_num):#计数到16时，count归0，并且列表指向下一个元素#########修改 num+=1 count=0 i+=1 print('获得文件数量：',len(list_path_record_num))
    print('存储的序号：\n',list_path_record_num)
    
    print('列表元素个数：',len(list_all_samefile_path))
    
    
    print(list_all_samefile_path)
    
    
    
    #-----------第5步从相同路径下的文件中找到不同的MD5 list_samepath_different_md5=[]
    num=0 for i in range(len(list_all_samefile_path)):
        # for j in range(16): if i+1<len(list_all_samefile_path) and list_all_samefile_path[i]==list_all_samefile_path[i+1]:
                continue else:
                list_samepath_different_md5.append(list_all_samefile_path[i])
    
    print(list_samepath_different_md5)
    
    # find_different_md5=open('txt/find_different_md5.txt','w') # for i in range(len(md5_list)): # find_different_md5.write('%s'%md5_list[i]) #------------------------------第6步：相同路径下的不同的MD5 # file=open('txt/find_different_md5.txt','r') list_samepath_path=[]
    #读取文本中的内容将路径保存在list中方便后面统计相同路径的数目 for i in range(len(list_samepath_different_md5)):
        path,md5_=list_samepath_different_md5[i].strip().split(':')
        list_samepath_path.append(path)
    
    # for line in file.readlines(): # key,value=line.strip().split(':') # list.append(key) print(len(list_samepath_path))
    
    
    count=1 count_different_md5_num=0 tmp=list_samepath_path[0]
    list_different_md5_count=[]
    path='' dict={}
    #用list_num记录列表中相同路径下的MD5不同的数量，并且将路径+数量保存到字典中 for i in range(1,len(list_samepath_path)):
        if(list_samepath_path[i]==tmp):
            count+=1 else:
            list_different_md5_count.append(count)
            dict[tmp]=count
            tmp=list_samepath_path[i]
            count=1 print(list_different_md5_count)#输出不同MD5 print(len(list_different_md5_count))#输出不同MD5的总数 for (key,value) in dict.items():
        print(key,value)
        count_different_md5_num+=1 print(count_different_md5_num)
    
    # 找到列表中的最大值,并判断最大值个数 max_different_md5_count=max(list_different_md5_count)
    
    print(max_different_md5_count)
    
    # count_max=0 # for i in range(len(list_num)): # if(list_num[i]==max(list_num)): # count_max+=1 # 找到最大的数（MD5不同），将对应的路径及MD5以key，value形式保存在字典中 dict_result={}
    for path,num in dict.items():
        if(num==max(list_different_md5_count)):
            dict_result[path]=num
    
    print("fined the result:")
    #输出满足要求的路径及对应的不同的MD5的数量 for path,num in dict_result.items():
        print(path,num)
    
    # dict_to_list=list(dict_result) #将记录的路径保存在列表中 list_find_final_path=[]
    for path,num in dict_result.items():
        list_find_final_path.append(path)
    
    # print(list_path) ## 找到满足要求的不同路径的数量 need_file_num=len(list_find_final_path)
    print(need_file_num)
    
    
    #---------------第7步找到相同路径下不同的MD5 find_next_num=0 max_different_md5_count_=0 list_find_final_samepath_different_md5=[]
    
    
    # 从所有的相同路径不同MD5文件中遍历 for i in range(len(list_samepath_different_md5)):
        # print(line) path,md5__=list_samepath_different_md5[i].strip().split(':')
        # print(key) #相同路径下含有最多不同的MD5的内容 if find_next_num<len(list_find_final_path) and (path==list_find_final_path[find_next_num]):
            list_find_final_samepath_different_md5.append(list_samepath_different_md5[i])
            max_different_md5_count+=1 #当计数到同文件下不同MD5的最大数量时，num++即遍历列表中的下一个保存路径 if max_different_md5_count_==max_different_md5_count:
            find_next_num+=1 print(list_find_final_samepath_different_md5)
    
    # # 将找到的内容保存起来 # P_M=open('txt/final_path_md5.txt','w') # for i in range(len(list_path_md5)): # P_M.write('%s\n'%list_path_md5[i].strip()) #-----------------------第8步 找到相同路径下不同的MD5 list_result=[]
    # 用MD5来找对应的版本，然后将version+path+md5保存到列表中 for i in range(len(list_version_md5)):
        version,md51=list_version_md5[i].strip().split(':')
        for j in range(len(list_find_final_samepath_different_md5)):
            path,md5_1=list_find_final_samepath_different_md5[j].strip().split(':')
            if md51==md5_1:
                list_result.append(version+list_find_final_samepath_different_md5[j])
    
    print(len(list_result))
    print(list_result)
    
    #-----------------第9步格式化输出 # import samepath_file_different_md5_6 # file=open('txt/final_result.txt','r') # # #list中保存了16*samepath_file_different_md5_6.need_file_num个文件 # list=[] # for line in file.readlines(): # list.append(line) # print(len(list)) list_result.sort()
    for i in range(len(list_result)):
        print(list_result[i].strip())
    
    
    save_final_output=open('final_output.txt','w')
    num=0 print('output_result:')
    #一般性，可能含有多个相同的最大的MD5数量 # 遍历有可能多个MD5的不同数量即符合要求多于1个其数量为samepath_file_different_md5_6.need_file_num for i in range(need_file_num):
        key,value=list_result[num].strip().split(':')#分割version_path：MD5，初始标志 print('{')
    
        save_final_output.write('{ \n')
    
        # vp,md5=key.strip().split(':') ver,path=key.strip().split('/',1)#分割version:path print(' url:',path)
        save_final_output.write(' url:%s\n'%path)
    
        print(' { \n data:\n {')
        save_final_output.write(' { \n data:\n { \n')
    
        for j in range(num+1,(i+1)*file_num):# key1,value1=list_result[j].strip().split(':')
            if(value==value1):#与前一个MD5对比，相同跳过 continue else:
                version,mad5=key.strip().split('/',1)#MD5不同，记录初始位置的V_M print(' ',version,':',value)
                save_final_output.write(' %s:%s\n'%(version,value))
    
                key,value=key1,value1 #更新比较的值 num = num+file_num
        key2,value2=list_result[num-1].strip().split(':')#最后一个 version_, mad5_= key2.strip().split('/', 1)
    
        print(' ',version_, ':', value)
        save_final_output.write(' %s:%s\n' % (version_, value))
    
        print(' }')
        save_final_output.write(' }\n')
    
    print(' }')
    save_final_output.write(' }\n')
    # print(samepath_file_different_md5_6.max_list_num) # #特殊性：只有一个最大的MD5数量 # key,value=list[0].strip().split(':') # print('{') # # vp,md5=key.strip().split(':') # v,p=key.strip().split('/',1) # print('url:',p) # print('{\n data:\n {') # for j in range(1,len(list)): # key1,value1=list[j].strip().split(':') # if(value==value1): # continue # else: # version,mad5_=key.strip().split('/',1) # print(' ',version,':',value) # key,value=key1,value1 # # key1,value1=list[len(list)-1].strip().split(':') # version, mad5= key1.strip().split('/', 1) # print(' ',version, ':', value) # print(' }') print('}')
    save_final_output.write('}\n')

[phpMyAdmin]: https://baike.so.com/doc/536514-568003.html
[ZendOptimizer]: https://baike.so.com/doc/1762891-1864173.html
[Link 1]: https://baike.so.com/doc/2871106-3029793.html
[Link 2]: https://baike.so.com/doc/3143727-3313214.html