实习 week（一）

一、环境搭建：

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的作用是让大容量信息在用数字签名软件签署私人密钥前被"压缩"成一种保密的格式

五、任务

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')