python数据预处理练习

2024-09-01 22:58
文章标签 python 数据 练习 预处理

本文主要是介绍python数据预处理练习，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

[python]  view plain  copy
  1. #ecoding=utf-8  
  2. import math  
  3. import re  
  4. import csv  
  5.   
  6. def fileREAD(fileURL,access):  
  7.     "传入文件路径，返回存储文件内容的二维列表"  
  8.     localArray = []  # 创建一个列表用于存储文件内容  
  9.     csvfile = file(fileURL, access)  
  10.     reader = csv.reader(csvfile)  
  11.     for line in reader:  
  12.         localArray.append(line)  
  13.     csvfile.close()  
  14.     return localArray  
  15.   
  16. def getLine(inList,Line):  
  17.     "获得某一行数据"  
  18.     return inList[Line]  
  19.   
  20. def getRow(inList,Row):  
  21.     "获得某一列数据"  
  22.     listReturn = []  
  23.     for i in inList:  
  24.         listReturn.append(i[Row])  
  25.     return listReturn  
  26.   
  27. def setLine(inList,childList,Line):  
  28.     "设置矩阵某一行数据"  
  29.     inList[Line] = childList  
  30.   
  31. def setRow(inList,chikdList,Row):  
  32.     "设置矩阵的某一列"  
  33.     i = 0  
  34.     for i in range(0,len(chikdList)):  
  35.         inList[i][Row] = chikdList[i]  
  36.   
  37. def addLine(inList,childLine):  
  38.     "给数据矩阵添加一行"  
  39.     inList.append(childLine)  
  40.   
  41. def addRow(inList,childRow):  
  42.     "给数据矩阵添加一列"  
  43.     j = 0  
  44.     for i in inList:  
  45.         i.append(childRow[j])  
  46.         j = j+1  
  47.   
  48. def getAVG(inList):  
  49.     "求数值属性的均值"  
  50.     sumOfList = 0  
  51.     lengOfList = 0  
  52.     for i in inList:  
  53.         if re.match(r'[0-9]+',i):  
  54.             sumOfList = sumOfList + float(i)  
  55.             lengOfList = lengOfList + 1  
  56.         else:  
  57.             continue  
  58.     if lengOfList != 0 :  
  59.         return sumOfList/lengOfList  
  60.     else:  
  61.         return "当前特征无平均值"  
  62.   
  63. def getAVE(inList):  
  64.     "求数值属性的方差"  
  65.     #先求平均数  
  66.     sumOfList = 0  
  67.     lengOfList = 0  
  68.     su = 0  
  69.     for i in inList:  
  70.         if re.match(r'[0-9]+', i):  
  71.             sumOfList = sumOfList + float(i)  
  72.             lengOfList = lengOfList + 1  
  73.         else:  
  74.             continue  
  75.     if lengOfList != 0:  
  76.         avg = sumOfList / lengOfList  
  77.         for j in inList:  
  78.             if re.match(r'[0-9]+',j):  
  79.                 su += (float(j) - avg) ** 2  
  80.             else:  
  81.                 continue  
  82.         return math.sqrt(su)  
  83.     else:  
  84.         return "当前特征无方差"  
  85.   
  86. def average(seq, total=0.0):  
  87.   num = 0  
  88.   for item in seq:  
  89.     total += item  
  90.     num += 1  
  91.   return total / num  
  92.   
  93. def getQUANTILE(inList,inlocaltion):  
  94.     "求数值属性的分位数"  
  95.     if inlocaltion >1 or inlocaltion<0 or inlocaltion == 1:  
  96.         return "输入的分位数数值错误"  
  97.     localLst = []  
  98.     leng = 0  
  99.     for i in inList:  
  100.         if re.match(r'[0-9]+',i):  
  101.             localLst.append(float(i))  
  102.             leng = leng + 1  
  103.         else:  
  104.             continue  
  105.     if leng == 0:  
  106.         return "当前特征不可求中位数"  
  107.     localLst.sort()  
  108.     if inlocaltion == 0.5:  
  109.          if len(localLst)%2 == 1:  
  110.              return localLst[len(localLst)//2]  
  111.          else:  
  112.              return (localLst[len(localLst)//2-1]+localLst[len(localLst)//2])/2.0  
  113.     elif inlocaltion<1 and inlocaltion>=0:  
  114.         return localLst[int(len(localLst)*inlocaltion)]  
  115.   
  116. def fileREAD(fileURL,access):  
  117.     "传入文件路径，返回存储文件内容的二维列表"  
  118.     localArray = []  # 创建一个列表用于存储文件内容  
  119.     csvfile = file(fileURL, access)  
  120.     reader = csv.reader(csvfile)  
  121.     for line in reader:  
  122.         localArray.append(line)  
  123.     csvfile.close()  
  124.     return localArray  
  125.   
  126. def removeNoiseAuto(inList):  
  127.     "利用IRQ识别噪声数据并去除该数据"  
  128.     Q3 = getQUANTILE(inList,0.75)  
  129.     Q1 = getQUANTILE(inList,0.25)  
  130.     IRQ = Q3 - Q1  
  131.     for i in range(1,len(inList),1):  
  132.         if float(inList[i]) - Q3 > 1.5*IRQ or Q1 - float(inList[i]) > 1.5*IRQ:  
  133.             inList[i] = ''  
  134.     return inList  
  135.   
  136. def removeNoiseByThresholdMin(inList,inThresholdMin):  
  137.     "根据最小阈值去除噪声数据去除该数据"  
  138.     for i in range(1, len(inList), 1):  
  139.         if float(inList[i]) < inThresholdMin:  
  140.             inList[i] = ''  
  141.     return inList  
  142.   
  143. def removeNoiseByThresholdMax(inList,inThresholdMax):  
  144.     "根据最大阈值去除噪声数据去除该数据"  
  145.     for i in range(1, len(inList), 1):  
  146.         if float(inList[i]) > inThresholdMax:  
  147.             inList[i] = ''  
  148.     return inList  
  149.   
  150. def autoPaddingByAVG(inList):  
  151.     "利用均值补全缺失值"  
  152.     avg = getAVG(inList)  
  153.     for i in range(1, len(inList), 1):  
  154.         if inList[i] == '':  
  155.             inList[i] = str(avg)  
  156.     return inList  
  157.   
  158. def autoPaddingByMedian(inList):  
  159.     "利用中位数补全缺失值"  
  160.     avg = getQUANTILE(inList,0.5)  
  161.     for i in range(1, len(inList), 1):  
  162.         if inList[i] == '':  
  163.             inList[i] = str(avg)  
  164.     return inList  
  165.   
  166. def binningWidth(inList,width):  
  167.     "数据离散化：等宽分箱"  
  168.     dic = {}  
  169.     for i in range(1,len(inList)):  
  170.         dic[i] =float(inList[i])  
  171.     dict = sorted(dic.iteritems(), key=lambda d: d[1], reverse= False)  # 先将列表按value排序  
  172.     dictList = []  # 将排序后元素赋值给一个列表，用于存储K-V对  
  173.     for varlo in dict:  
  174.         dictList.append(list(varlo))  
  175.     i = 0  # 用于记录每个箱开始位置  
  176.     j = 0  #用于记录每个箱结束位置  
  177.     innerList = []  
  178.     for i in range(0, len(dictList)):  
  179.         if dictList[i][1] - dictList[j][1] > width:  
  180.             avg = average(innerList)  
  181.             for k in range(j, i, 1):  
  182.                 dictList[k][1] = avg  
  183.             innerList = []  
  184.             j = i  
  185.         innerList.append(dictList[i][1])  
  186.         if (i == len(dictList)-1):  
  187.             avg = average(innerList)  
  188.             for k in range(j, i, 1):  
  189.                 dictList[k][1] = avg  
  190.             innerList = []  
  191.             dictList[i][1] = avg  
  192.   
  193.     dic1 = {}  
  194.     for i in range(0, len(dictList)):  
  195.         dic1[dictList[i][0]] = dictList[i][1]  
  196.     ad = sorted(dic1.iteritems(), key=lambda d: d[0], reverse=False)  # 先将列表按KEY排序  
  197.     for i in range(0, len(ad)):  
  198.         inList[i + 1] = ad[i][1]  
  199.     return inList  
  200.   
  201. def binningDeep(inList,deep1):  
  202.     "数据离散化：等频分箱"  
  203.     deep = deep1 -1  
  204.     dic = {}  
  205.     for i in range(1,len(inList)):  
  206.         dic[i] =float(inList[i])  
  207.     dict = sorted(dic.iteritems(), key=lambda d: d[1], reverse= False)  # 先将列表按value排序  
  208.     dictList = []  # 将排序后元素赋值给一个列表，用于存储K-V对  
  209.     for varlo in dict:  
  210.         dictList.append(list(varlo))  
  211.     innerList = []  
  212.     for i in range(0,deep):  #为了排除0的干扰，首先处理掉deep个元素  
  213.         innerList.append(dictList[i][1])  
  214.     for i in range(deep, len(dictList)):  
  215.         if i % deep == 0:  
  216.             avg = average(innerList)  
  217.             for j in range(i-deep,i):  
  218.                 dictList[j][1] = avg  
  219.             innerList = []  
  220.         innerList.append(dictList[i][1])  
  221.         if i == len(dictList)-1:  
  222.             avg = average(innerList)  
  223.             for j in range((i+1)/deep*deep,i+1):  
  224.                 dictList[j][1] = avg  
  225.   
  226.     dic1 = {}  
  227.     for i in range(0, len(dictList)):  
  228.         dic1[dictList[i][0]] = dictList[i][1]  
  229.     ad = sorted(dic1.iteritems(), key=lambda d: d[0], reverse= False)  # 先将列表按KEY排序  
  230.     for i in range(0,len(ad)):  
  231.         inList[i+1] = ad[i][1]  
  232.     return inList  
  233.   
  234. def oneHot(inList,Row):  
  235.     "对输入数据矩阵的某一列使用oneHot编码"  
  236.     rowList0 = getRow(inList,Row)  
  237.     rowHead = rowList0[0]  
  238.     rowList = []  
  239.     for i in range(1,len(rowList0)):  
  240.         rowList.append(rowList0[i])  
  241.     rowmsg = {}  
  242.     j = 0  
  243.     for i in rowList:  
  244.         if rowmsg.has_key(i):  
  245.             rowmsg[i] = rowmsg[i] + 1  
  246.         else:  
  247.             rowmsg[i] = 1  
  248.     for i in rowmsg.keys():  
  249.         addList = []  
  250.         addList.append(i)  
  251.         for j in rowList:  
  252.             if j == i:  
  253.                 addList.append('1')  
  254.             else:  
  255.                 addList.append('0')  
  256.         addRow(inList,addList)  
  257.     for i in inList:  
  258.         print i  
  259.   
  260. def  minMax(inList):  
  261.     "最大最小归一化"  
  262.     innerList = []  
  263.     for i in range(1,len(inList)):  
  264.         if re.match(r'[0-9]+', inList[i]):  
  265.             innerList.append(float(inList[i]))  
  266.     maxvalue = max(innerList)  
  267.     minvalue = min(innerList)  
  268.   
  269.     for i in range(1,len(inList)):  
  270.         if re.match(r'[0-9]+', inList[i]):  
  271.             a = (float(inList[i])-minvalue)/(maxvalue - minvalue)  
  272.             b = "%.4f" %a  
  273.             inList[i] = str(b)  
  274.     return inList  
  275.   
  276. def  zScore(inList):  
  277.     "zScore归一化"  
  278.     print inList  
  279.     u = getAVG(inList)  
  280.     ave = getAVE(inList)  
  281.     stand = math.sqrt(ave)  
  282.     for i in range(1,len(inList)):  
  283.         if re.match(r'[0-9]+', inList[i]):  
  284.             a = (float(inList[i])-u)/stand  
  285.             b = "%.4f" % a  
  286.             inList[i] = str(b)  
  287.     return inList  
  288.   
  289. def similarityDistance(inList1,inList2,n):  
  290.     "距离相似度"  
  291.     sum = 0  
  292.     for i in range(1,len(inList1)):  
  293.        sum = sum + abs(float(inList1[i])-float(inList2[i])) ** n  
  294.     a = float(1)/2  
  295.     return pow(sum,a)  
  296.   
  297. def similaritySim(inList1,inList2):  
  298.     "余弦相似度计算"  
  299.     sum = 0  
  300.     for i in range(1,len(inList1)):  
  301.         sum = sum + float(inList1[i])*float(inList2[i])  
  302.     sum1 = 0  
  303.     sum2 = 0  
  304.     for i in range(1,len(inList1)):  
  305.         sum1 = sum1 + float(inList1[i])**2  
  306.     for i in range(1, len(inList2)):  
  307.         sum2 = sum2 + float(inList2[i]) ** 2  
  308.   
  309.     return sum/(math.sqrt(sum1)*math.sqrt(sum2))  
  310.   
  311. fileInput = fileREAD("D:\\PythonWorkSpace\\ExternalFile\\train.csv","r")  
  312.   
  313. # #获得某一行数据  
  314. # print getLine(fileInput,1)  
  315. #  
  316. # #获得某一列数据  
  317. # print getRow(fileInput,0)  
  318.   
  319. # #设置某一行数据  
  320. # print "设置前："  
  321. # print getLine(fileInput,1)  
  322. # setLine(fileInput,getLine(fileInput,2),1)  
  323. # print "设置后："  
  324. # print getLine(fileInput,1)  
  325.   
  326. # #设置某一列数据  
  327. # print "设置前："  
  328. # print getRow(fileInput,1)  
  329. # setRow(fileInput,getRow(fileInput,2),1)  
  330. # print "设置后："  
  331. # print getRow(fileInput,1)  
  332.   
  333. # #均值  
  334. # print getAVG(getRow(fileInput,9))  
  335.   
  336. # #方差  
  337. # print getAVE(getRow(fileInput,9))  
  338.   
  339. # #分位数  
  340. # print getQUANTILE(getRow(fileInput,9),0.5)  
  341.   
  342. # #噪声数据过滤1  
  343. # print removeNoiseAuto(getRow(fileInput,1))  
  344. #  
  345. # #噪声数据过滤2  
  346. # print removeNoiseByThresholdMin(getRow(fileInput,0),10)  
  347. #  
  348. # #噪声数据过滤3  
  349. # print removeNoiseByThresholdMax(getRow(fileInput,0),10)  
  350.   
  351. # #缺失值补全1  
  352. # print autoPaddingByAVG(getRow(fileInput,0))  
  353. #  
  354. # #缺失值补全2  
  355. # print autoPaddingByMedian(getRow(fileInput,0))  
  356.   
  357. # #等宽分箱  
  358. # print binningWidth(getRow(fileInput,0),3)  
  359. #  
  360. # #等频分箱  
  361. # print binningDeep(getRow(fileInput,0),3)  
  362.   
  363. # #ONE-HOT编码  
  364. # oneHot(fileInput,1)  
  365. # for i in fileInput:  
  366. #     print i  
  367.   
  368. # #最大最小归一化  
  369. # print minMax(getRow(fileInput,0))  
  370. #  
  371. # #zScore归一化  
  372. # print zScore(getRow(fileInput,0))  
  373.   
  374. # #距离相似度  
  375. # print similarityDistance(getRow(fileInput,0),getRow(fileInput,0),2)  
  376.   
  377. # # 余弦相似度计算  
  378. # print similaritySim(getRow(fileInput,0),getRow(fileInput,1))  



原文地址:http://blog.csdn.NET/u012155582/article/details/52051776

这篇关于python数据预处理练习的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1128283。

相关文章

大模型研发全揭秘：客服工单数据标注的完整攻略

大模型研发全揭秘：客服工单数据标注的完整攻略

在人工智能（AI）领域，数据标注是模型训练过程中至关重要的一步。无论你是新手还是有经验的从业者，掌握数据标注的技术细节和常见问题的解决方案都能为你的AI项目增添不少价值。在电信运营商的客服系统中，工单数据是客户问题和解决方案的重要记录。通过对这些工单数据进行有效标注，不仅能够帮助提升客服自动化系统的智能化水平，还能优化客户服务流程，提高客户满意度。本文将详细介绍如何在电信运营商客服工单的背景下进行
阅读更多...
基于MySQL Binlog的Elasticsearch数据同步实践

基于MySQL Binlog的Elasticsearch数据同步实践

一、为什么要做 随着马蜂窝的逐渐发展，我们的业务数据越来越多，单纯使用 MySQL 已经不能满足我们的数据查询需求，例如对于商品、订单等数据的多维度检索。 使用 Elasticsearch 存储业务数据可以很好的解决我们业务中的搜索需求。而数据进行异构存储后，随之而来的就是数据同步的问题。 二、现有方法及问题 对于数据同步，我们目前的解决方案是建立数据中间表。把需要检索的业务数据，统一放到一张M
阅读更多...
关于数据埋点，你需要了解这些基本知识

关于数据埋点，你需要了解这些基本知识

产品汪每天都在和数据打交道，你知道数据来自哪里吗？ 移动app端内的用户行为数据大多来自埋点，了解一些埋点知识，能和数据分析师、技术侃大山，参与到前期的数据采集，更重要是让最终的埋点数据能为我所用，否则可怜巴巴等上几个月是常有的事。   埋点类型 根据埋点方式，可以区分为： 手动埋点半自动埋点全自动埋点 秉承“任何事物都有两面性”的道理：自动程度高的，能解决通用统计，便于统一化管理，但个性化定
阅读更多...
python: 多模块(.py)中全局变量的导入

python: 多模块(.py)中全局变量的导入

文章目录 global关键字可变类型和不可变类型数据的内存地址单模块(单个py文件)的全局变量示例总结 多模块(多个py文件)的全局变量from x import x导入全局变量示例 import x导入全局变量示例 总结 global关键字 global 的作用范围是模块(.py)级别： 当你在一个模块（文件）中使用 global 声明变量时，这个变量只在该模块的全局命名空
阅读更多...
使用SecondaryNameNode恢复NameNode的数据

使用SecondaryNameNode恢复NameNode的数据

1）需求： NameNode进程挂了并且存储的数据也丢失了，如何恢复NameNode 此种方式恢复的数据可能存在小部分数据的丢失。 2）故障模拟 （1）kill -9 NameNode进程 [lytfly@hadoop102 current]$ kill -9 19886 （2）删除NameNode存储的数据（/opt/module/hadoop-3.1.4/data/tmp/dfs/na
阅读更多...
异构存储（冷热数据分离）

异构存储（冷热数据分离）

异构存储主要解决不同的数据，存储在不同类型的硬盘中，达到最佳性能的问题。 异构存储Shell操作 （1）查看当前有哪些存储策略可以用 [lytfly@hadoop102 hadoop-3.1.4]$ hdfs storagepolicies -listPolicies （2）为指定路径（数据存储目录）设置指定的存储策略 hdfs storagepolicies -setStoragePo
阅读更多...
Hadoop集群数据均衡之磁盘间数据均衡

Hadoop集群数据均衡之磁盘间数据均衡

生产环境，由于硬盘空间不足，往往需要增加一块硬盘。刚加载的硬盘没有数据时，可以执行磁盘数据均衡命令。（Hadoop3.x新特性） plan后面带的节点的名字必须是已经存在的，并且是需要均衡的节点。 如果节点不存在，会报如下错误： 如果节点只有一个硬盘的话，不会创建均衡计划： （1）生成均衡计划 hdfs diskbalancer -plan hadoop102 （2）执行均衡计划 hd
阅读更多...
【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

✨✨ 欢迎大家来到景天科技苑✨✨ 🎈🎈 养成好习惯，先赞后看哦~🎈🎈 🏆 作者简介：景天科技苑 🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。 🏆《博客》：Python全栈，前后端开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi
阅读更多...
【Python编程】Linux创建虚拟环境并配置与notebook相连接

【Python编程】Linux创建虚拟环境并配置与notebook相连接

1.创建 使用 venv 创建虚拟环境。例如，在当前目录下创建一个名为 myenv 的虚拟环境： python3 -m venv myenv 2.激活 激活虚拟环境使其成为当前终端会话的活动环境。运行： source myenv/bin/activate 3.与notebook连接 在虚拟环境中，使用 pip 安装 Jupyter 和 ipykernel： pip instal
阅读更多...
【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程（Gaussian Process，简称GP）是一种概率模型，用于描述一组随机变量的联合概率分布，其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数（或核函数） 1.3 核函数1.4 高斯过程回归（Gauss
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2