对python脚本readDataToDic脚本进行模块化拆分多个类（V1.0）

关于该篇博客，可以参考博文：http://blog.csdn.net/henni_719/article/category/6297962进行理解

封装的模块目录视图：

下面附上模块代码：

__init__.py

该文件是，键DealCsv文件转换成一个包

from BaseData import *
from BaseList import *
from CreatePropertyDic import *
from CreatePropertyList import *
from printData import *

BaseData.py

该模块是把csv中的数据写入内存

#coding=utf8
import csv
import os,logging
'''
Author:ewang
Data:2017/07/18
该模块的主要功能函数：
读取csv中的数据到内存中
'''
PATH=lambda p:os.path.abspath(os.path.join(
    os.path.dirname(__file__), p))


logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename=PATH('../../Log/readDate.log'),
                filemode='w')

class BaseExceptData(object):
    def __init__(self,filePah=PATH("../../LastCSV/20170510174450.csv")):
        try:
            #存放csv中读取的数据
            self.mdbuffer=[]
            #打开csv文件，设置读的权限
            csvHand=open(filePah,"r")
            #创建读取csv文件句柄
            readcsv=csv.reader(csvHand)
            #把csv的数据读取到mdbuffer中
            for row in readcsv:
                    self.mdbuffer.append(row)  
            #把数据穿件为为字典类型的
        except Exception,e:
            logging.error("Read Excel  error:"+e) 
        finally:
            #关闭csv文件
            csvHand.close()
            
    
def test():
    baseData=BaseExceptData()
    print baseData.mdbuffer
    
if __name__=="__main__":
    test()

BaseList.py

把把数据转成相应的数据列表

#coding=utf8
from BaseData import BaseExceptData
import logging,os
'''
Author:ewang
Data:2017/07/19
该模块的主要功能函数：
readDataToList():把csv中的数据，数据项以字典类型存储在列表中。
'''

PATH=lambda p:os.path.abspath(os.path.join(
    os.path.dirname(__file__), p))

logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename=PATH('../Log/readDate.log'),
                filemode='w')
class BaseDataList(BaseExceptData):
    def readDataToList(self):
        try:
            #在数组最后添加一个空白行
            #该行的作用是为了成功获取最后一条json数据
            #在数组endLine添加空白字符
            endLine=[" " for num in range(len(self.mdbuffer[1])) if num>=0] 
            #把以空字符的endLine添加到末尾
            self.mdbuffer.append(endLine)
            #获取mdbuffer中的元素个数
            rowNumber=len(self.mdbuffer)
            #设置当前行号
            currentrow=1
            #设置json数据的属性值
            propertyJson={}
            #读取列表中的元素   
            dataList=[]  
            try: 
                for row in range(1,rowNumber):
                    #创建一个临时变量用来存取一次循环的属性键值
                    temp={}
                    #获取列表中一个元素
                    item=self.mdbuffer[row]
                    #获取当前元素，当前元素代表的是每个
                    #事件起始的位置
                    currentItem=self.mdbuffer[currentrow]
                    #获取serviceId并进行解码
                    mdEvent=currentItem[0].decode("gbk")
                    serviceId= currentItem[2].decode("gbk")
                    #获取属性并进行解码，把解码的值存入propertyName
                    propertyName=item[3].decode("gbk")
                    #获取属性值并进行解码，把解码的值存入propertyValue
                    propertyValue=item[4].decode("gbk")
                    try:
                        #判断埋点事件与serviceId是否相等
                        if item[0]==currentItem[0] and item[2]==currentItem[2]:
                            #用来保存埋点事件
                            propertyJson["mdEvent"]=mdEvent 
                            #把serviceId方式字典propertyJson中
                            propertyJson["serviceId"]=serviceId 
                            #把属性/值对放入temp字典中                                                 
                            temp[propertyName]=propertyValue
                            #调用字典的update函数，把temp中的键值对
                            #添加到 propertyJson字典中
                            propertyJson.update(temp)
                            #使用continue，如果为if条件为true则循环执行if语句模块
                            continue  
                        else:
                            #把行号设置为当前行
                            currentrow=row  
                            #把当前的属性解码放入propertyName                    
                            propertyName=currentItem[3].decode("gbk")
                            #把当前的属性值解码放入propertyName
                            propertyValue=currentItem[4].decode("gbk")
                            #用来保存埋点事件
                            mdEvent=currentItem[0].decode("gbk")
                            #把serviceId方式字典propertyJson中 
                            propertyJson["serviceId"]=serviceId    
                            #把属性/值对放入propertyJson字典中  
                            propertyJson[propertyName]=propertyValue
                            #propertyJsonList.append(propertyJson) 
                            dataList.append(propertyJson)
                            '''
                            在这说下：
                            propertyJson.clear()与propertyJson={}的区别：
                            propertyJson.clear()是删除字典的值，不创建引用，会改变字典本身的值；
                            propertyJson={}是创建新的引用，字典的中的值不发现变化；
                            如果想让 self.dataDic.append(propertyJson)该语句执行成功，而且添加每次循环的值，
                            需要使用propertyJson={}方法；
                            如果使用propertyJson.clear(),只会把最后一次propertyJson存储的值，添加到self.dataDic中
                            '''
                            propertyJson={}
                    except Exception,e:
                        logging.error("Get Property Json Error:" +e) 
                        #print "Get Property Json Error:",e
            except Exception,e:
                logging.error("Get Date Error:"+e) 
                #print "Get Date Error:",e
            #返回dataList
            return  dataList     
        except Exception,e:
            #把信息写入日志中
            logging.error("Reading Data TO Dic Error:"+e) 
            #print "Reading Data TO Dic Error:",e
            
def test():
    readList=BaseDataList()
    print readList.readDataToList()
    
if __name__=="__main__":
    test()

CreatePropertyDic.py

创建以属性为键的属性字典

#coding=utf8
from CreatePropertyList import  ExceptPropertyList 
import os,logging
from printData import printDicData
'''
Author:ewang
Data:2017/07/19
该模块的主要功能函数：
__createDataDic(properyName,propetyList):创建一个数据字典表
 get_ServiceId_DataDic():创建一个数据字典表，以serviceId为key，相同的数据项列表为value
 get_srcPage_DataDic():创建一个数据字典表，以srcPage为key，相同的数据项列表为value
 get_srcPageId_DataDic():创建一个数据字典表，以srcPageId为key，相同的数据项列表为value
 get_srcModule_DataDic():创建一个数据字典表，以srcModule为key，相同的数据项列表为value
 get_item_DataDic():创建一个数据字典表，以item为key，相同的数据项列表为value
 get_itemId_DataDic():创建一个数据字典表，以itemId为key，相同的数据项列表为value
 get_srcPosition_DataDic():创建一个数据字典表，以srcPosition为key，相同的数据项列表为value
 get_memberType_DataDic():创建一个数据字典表，以memberType为key，相同的数据项列表为value
 get_eventGroup_DataDic():创建一个数据字典表，以eventGroup为key，相同的数据项列表为value
 get_albumType_DataDic():创建一个数据字典表，以albumType为key，相同的数据项列表为value
 get_srcSubModule_DataDic():创建一个数据字典表，以srcSubModule为key，相同的数据项列表为value
 get_type_DataDic():创建一个数据字典表，以type为key，相同的数据项列表为value
 get_function_DataDic():创建一个数据字典表，以function为key，相同的数据项列表为value
 get_shareType_DataDic():创建一个数据字典表，以shareType为key，相同的数据项列表为value
'''


PATH=lambda p:os.path.abspath(os.path.join(
    os.path.dirname(__file__), p))

logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename=PATH('../Log/readDate.log'),
                filemode='w')

class ExceptPropertyDic(ExceptPropertyList):
    
    #创建数据字典
    def __createDataDic(self,properyName,propetyList):
        try:
            #定义个数据字典变量
            dataDic={}    
            #调用函数readDataToList创建一个dataList表  
            dataList=self.readDataToList()   
            #判断列表中是否有元素，如果有执行if语句
            if len(propetyList)>0 and len(dataList)>0:
                #对propetyList进行循环，以property作为key
                for Property in propetyList:
                    #创建一个list用来存放Property相同的数据项
                    samePropertyJosnList=[]
                    #对数据列表执行循环
                    for item in dataList:
                        #获取字典中键为Property值，放入变量中 
                        if properyName in item.keys():                 
                            itemProperyName=item[properyName]
                            #如果值不为空，执行if语句
                            if itemProperyName:
                                #判断Property与数据项中itemProperyName的值是否相等
                                #如果相等执行if语句块
                                if Property==itemProperyName: 
                                    #把数据项加入samePropertyJosnList列表中
                                    samePropertyJosnList.append(item)                                                              
                            else:
                                logging.debug("Property is null")
                    #给字典赋值，以Property作为key，
                    #Property相同的数据项列表作为值
                    dataDic[Property]=samePropertyJosnList                     
            else:
                logging.debug("Property List  or dataList is null")
            #返回字典类型的数据
            return dataDic
        except Exception,e:
            logging.error("Create  %s Data Dictionary Error:%s"  %(properyName,e))
        
    #创建以serviceId为键的数据字典
    def get_serviceId_DataDic(self):
        try:
            servicIdList=self.getAllServiceId()
            return self.__createDataDic("serviceId", servicIdList)
        except Exception,e:
            logging.debug("create serviceId data dictionary:"+e)
     
    #创建以srcPage为键的数据字典                
    def get_srcPage_DataDic(self):
        try:
            srcPageList=self.getAllsrcPage()
            return self.__createDataDic("srcPage", srcPageList)
        except Exception,e:
            print "create srcPage data dictionary:",e
            
    #创建以srcPageId为键的数据字典        
    def get_srcPageId_DataDic(self):
        try:
            srcPageIdList=self.getAllsrcPageId()
            return self.__createDataDic("srcPageId", srcPageIdList)
        except Exception,e:
            logging.debug("create srcPageId data dictionary:"+e)     
    
    #创建以srcModule为键的数据字典        
    def get_srcModule_DataDic(self):
        try:
            srcModuleList=self.getAllsrcModule()
            return self.__createDataDic("srcModule", srcModuleList)
        except Exception,e:
            logging.debug("create srcModule data dictionary:"+e)     
            
    #创建以item为键的数据字典
    def get_item_DataDic(self):
        try:
            itemList=self.getAllitem()
            return self.__createDataDic("item", itemList)
        except Exception,e:
            logging.debug("create item data dictionary:"+e) 
      
    #创建以itemId为键的数据字典    
    def get_itemId_DataDic(self):
        try:
            itemIdList=self.getAllitemId()
            return self.__createDataDic("itemId", itemIdList)
        except Exception,e:
            logging.debug("create itemId data dictionary:"+e)    
     
    #创建以srcPosition为键的数据字典   
    def get_srcPosition_DataDic(self):
        try:
            srcPositionList=self.getAllsrcPosition()
            return self.__createDataDic("srcPosition", srcPositionList)
        except Exception,e:
            logging.debug("create srcPosition data dictionary:"+e)        
    
    #创建以memberType为键的数据字典      
    def get_memberType_DataDic(self):
        try:
            memberTypeList=self.getAllmemberType()
            return self.__createDataDic("memberType", memberTypeList)
        except Exception,e:
            logging.debug("create memberType data dictionary:"+e)   
    
    #创建以eventGroup为键的数据字典       
    def get_eventGroup_DataDic(self):
        try:
            eventGroupList=self.getAlleventGroup()
            return self.__createDataDic("eventGroup", eventGroupList)
        except Exception,e:
            logging.debug("create eventGroup data dictionary:"+e)  
      
    #创建以albumType为键的数据字典      
    def get_albumType_DataDic(self):
        try:
            albumTypeList=self.getAllalbumType()
            return self.__createDataDic("albumType", albumTypeList)
        except Exception,e:
            logging.debug("create albumType data dictionary:"+e) 
     
    #创建以srcSubModule为键的数据字典       
    def get_srcSubModule_DataDic(self):
        try:
            srcSubModuleList=self.getAllsrcSubModule()
            return self.__createDataDic("srcSubModule", srcSubModuleList)
        except Exception,e:
            logging.debug("create srcSubModule data dictionary:"+e)   
     
    #创建以type为键的数据字典       
    def get_type_DataDic(self):
        try:
            typeList=self.getAlltype()
            return self.__createDataDic("type", typeList)
        except Exception,e:
            logging.debug("create type data dictionary:"+e)      
     
    #创建以function为键的数据字典       
    def get_function_DataDic(self):
        try:
            functionList=self.getAllfunction()
            return self.__createDataDic("function", functionList)
        except Exception,e:
            logging.debug("create function data dictionary:"+e)      
     
    #创建以shareType为键的数据字典      
    def get_shareType_DataDic(self):
        try:
            shareTypeList=self.getAllshareType()
            return self.__createDataDic("shareType", shareTypeList)
        except Exception,e:
            logging.debug("create shareType data dictionary:"+e)  
                                      
    
    def getDicDataValue(self,PropertyValue,dataDic):
        try:
            '''
            例如：item="album"
                    dataDic=get_item_DataDic()
            使用方法是：getDicDataValue("album",dataDic)
            功能：获取字典中对应键获取的值列表
            '''
            if PropertyValue in dataDic.keys():
                return dataDic[PropertyValue]
        except Exception,e:
            logging.error("Get %s  Dic Data Error:%s"(PropertyValue,e))  
            
def test():
    dataDic=ExceptPropertyDic()
    itemDic=dataDic.get_item_DataDic()
    printDicData(itemDic)

if __name__=="__main__":
    test()

CreatePropertyList.py

创建以属性作为元素的属性列表

#coding=utf8
from BaseList import BaseDataList
import os,logging
from printData import printPropertyList
'''
Author:ewang
Data:2017/07/19
该模块的主要功能函数：
__propertyValueList(propetryName):创建不同属性值列表

getAllServiceId():获取所有的serviceId列表
getAllsrcPage():获取所有srcPage列表  
getAllsrcPageId():获取所有srcPageId列表
 getAllsrcModule():获取所有srcModule列表
getAllitem(): 获取所有item列表
getAllitemId():获取所有itemId列表
getAllsrcPosition():获取所有srcPosition列表
getAllmemberType():获取所有memberType列表
getAlleventGroup():获取所有eventGroup列表
getAllalbumType():获取所有albumType列表
 getAllsrcSubModule():获取所有srcSubModule列表
 getAlltype():获取所有type列表
getAllfunction():获取所有function列表 
getAllshareType():获取所有shareType列表 
'''

PATH=lambda p:os.path.abspath(os.path.join(
    os.path.dirname(__file__), p))

logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename=PATH('../Log/readDate.log'),
                filemode='w')
class ExceptPropertyList(BaseDataList):
    
    def __propertyValueList(self,propertyName): 
        try:
            #调用readDataToList函数创建一个数据list
            dataList=self.readDataToList()
            #把数据list中的所有propertyName放入表propertyValueList中
            #propertyValueList=[item[propertyName] for item in dataList if item[propertyName] ] 
            propertyValueList=[]
            for item in dataList:
                #print propertyName
                if propertyName in item.keys():
                    if item[propertyName]:
                        propertyValueList.append(item[propertyName])
            #对propertyValueList中的数据去重，分为两步：
            #第一步把列表转换成集合：set(propertyValueList)
            #第二步：把集合转换为list：list(set(propertyValueList))
            #集合和list的区别：集合中的数据是唯一性，不存在相同部分
            propertyValueList=list(set(propertyValueList))
            #返回serList
            return propertyValueList
        except Exception,e:
            logging.error("Create Property  %s  Value  List Error: %s"  %(propertyName,e))
            #print "Create Property  %s  Value  List Error: %s"  %(propertyName,e)
     
        
        
    #获取所有serviceId列表  
    def getAllServiceId(self,):
        
        return self.__propertyValueList("serviceId")
       
    #获取所有srcPage列表  
    def getAllsrcPage(self):
        return self.__propertyValueList("srcPage")
    
    #获取所有srcPageId列表  
    def getAllsrcPageId(self):
        return self.__propertyValueList("srcPageId")
      
    #获取所有srcModule列表        
    def getAllsrcModule(self):
        return self.__propertyValueList("srcModule")
    
    #获取所有itemId列表        
    def getAllitem(self):
        return self.__propertyValueList("item")
        
    #获取所有itemId列表        
    def getAllitemId(self):
        return self.__propertyValueList("itemId")    
    
    #获取所有srcPosition列表        
    def getAllsrcPosition(self):
        return self.__propertyValueList("srcPosition")    
    
    #获取所有memberType列表        
    def getAllmemberType(self):
        return self.__propertyValueList("memberType")  

    #获取所有eventGroup列表        
    def getAlleventGroup(self):
        return self.__propertyValueList("eventGroup")   
    
    #获取所有albumType列表        
    def getAllalbumType(self):
        return self.__propertyValueList("albumType")   
    
    #获取所有srcSubModule列表        
    def getAllsrcSubModule(self):
        return self.__propertyValueList("srcSubModule") 
    
    #获取所有type列表        
    def getAlltype(self):
        return self.__propertyValueList("type") 
    
    #获取所有function列表        
    def getAllfunction(self):
        return self.__propertyValueList("function")  
    
    #获取所有shareType列表        
    def getAllshareType(self):
        return self.__propertyValueList("shareType")    
                        
def test():
    baseList=ExceptPropertyList()
    itemlist=baseList.getAllitem()
    printPropertyList(itemlist)
   
if __name__=="__main__":
    test()

printData.py

输出数据信息

#coding=utf8
import logging,os
'''
Author:ewang
Data:2017/07/18
该模块的主要功能函数：
printAllListData(dataList):输出以字典类型为数据项的数据list 
printPropertyList(propertyList):输出数据项为字符串类型的属性列表
printDicData(propertydic):输出指定属性字典中的数据
printIOSCodeData(dataList):参数类型是以字典类型作为单个数据项的列表
'''
PATH=lambda p:os.path.abspath(os.path.join(
    os.path.dirname(__file__), p))

logging.basicConfig(level=logging.DEBUG,
                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                datefmt='%a, %d %b %Y %H:%M:%S',
                filename=PATH('../Log/readDate.log'),
                filemode='w')

#输出以字典类型为数据项的数据list                                  
def printAllListData(dataList):
    try:
        if len(dataList)>0:
            #对列表中的数据执行for循环
            #并输出类似与json样式的数据
            for item in dataList:  
                    print u"埋点事件:",item["mdEvent"] 
                    item.pop("mdEvent")                         
                    print "{"   
                    #输出键值对
                    for key,val in item.items(): 
                        print "\t",key,":",val,","
                    print "}"
                    #设置以#格式的分隔符
                    print "#"*50
                    print
    except Exception,e:
        logging.error("OutPut  List Data  Error:%s" %e)
        #print "OutPut  List Data  Error:"+e
        
#输出数据项为字符串类型的属性列表                                  
def printPropertyList(propertyList):
    try:
        if len(propertyList)>0:
            #对列表中的数据执行for循环
            print "["
            for item in propertyList: 
                print item,","
            print "]"             
    except Exception,e:
        logging.error("OutPut Property List  Error:%s" %e)
        #print "OutPut  List Data  Error:"+e
        
#打印字典信息         
def printDicData(propertydic):
    try:            
            #对字典中的数据进行循环，获取键值对
        for Property,dataitem in propertydic.items():                      
                print "{"   
                print "\t",Property,":","["   
                #由于值是列表，列表中的数据项类型是字典类型
                #每一数据项是哈希表
                for item in dataitem:
                    print "\t\t{"
                    #输出哈希表中的数据
                    for key,val in item.items(): 
                        print "\t\t\t",key,":",val,","
                    print "\t\t},"
                print"\t]"
                print "}\n"
                print "#"*50
    except Exception,e:
        logging.error("OutPut Property Dictionary  Error:%s" %e)

#输出IOS埋点代码模块
#参数类型是以字典类型作为单个数据项的列表
def printIOSCodeData(dataList):
        try:
            if len(dataList)>0:
                #对列表中的数据执行for循环
                #并输出类似与json样式的数据
                for item in dataList:
                        print u"埋点事件:",item["mdEvent"]                                              
                        #输出键值对
                        print "[XMBehaviorMgr postStaticWithAppName:@\"event\""   
                        print  "\t\t\t serviceId:@\"%s\"" %item["serviceId"]
                        item.pop("serviceId")
                        item.pop("mdEvent")
                        print   "\t\t\t  otherProps:@{"
                        for key,val in item.items():                           
                            print "\t\t\t\t","@\""+key+"\"",":","@\""+val+"\"",","
                        print "\t\t\t }"
                        print " \t\t\t trackDic:nil];"
                        #设置以#格式的分隔符
                        print "#"*50
                        print
        except Exception,e:
            logging.error("OutPut IOS Data Error:%s" %e)     

总结：

该模块是基于之前的基础上进行代码模块化，把一个大文件拆分成多个子文件，每个文件负责一部分功能，使方法组合更灵活!