pandas es una herramienta basada en NumPy, el nombre es muy kawaii y la fuente se compone de dos palabras "Panel data" (panel data, un término econométrico). Pandas incorpora una gran cantidad de bibliotecas y algunos modelos de datos estándar, lo que brinda las herramientas necesarias para manipular de manera eficiente grandes conjuntos de datos. Se utiliza principalmente para procesar grandes conjuntos de datos. La velocidad de procesamiento de datos es la característica más importante, y el resto es una versión Python de Excel.
Documentación de la API: http://pandas.pydata.org/pandas-docs/stable/user_guide/visualization.html
estructura de datos:
Serie: una matriz unidimensional, muy similar a una matriz en NumPy. De hecho, Series se basa básicamente en el objeto de matriz de NumPy. A diferencia de la matriz de NumPy, Series puede personalizar la etiqueta de los datos, es decir, el índice (índice), y luego acceder a los datos de la matriz a través del índice.
DataFrame: estructura de datos tabular bidimensional. Muchas funciones son similares a data.frame en R. DataFrame puede entenderse como un contenedor de Series.
Panel: Una matriz tridimensional, que puede entenderse como un contenedor DataFrame.
Por ejemplo:
import numpy as np
import pandas as pd
datafile='.\opt\list.csv'
outfile='.\opt\output.csv'
df = pd.DataFrame(pd.read_csv(datafile,encoding="utf_8"))#导入文件
print(df.shape)#输入维度
print(df.head())#输出默认前10行
df.pop('video')#删除列
print(df['type'])#输出列
df['type'].replace('科技','科学',inplace = True)#列替换
df.to_csv(outfile,encoding="utf_8")#输出文件lista.csv:
salida.csv:
El algoritmo a priori se presenta a continuación:
El algoritmo Apriori es un algoritmo de uso común para la minería de reglas de asociación de datos. El objetivo del algoritmo es encontrar el conjunto frecuente de elementos K más grande. Utiliza un método iterativo para buscar conjuntos de elementos de 1 candidato y su soporte correspondiente, y la poda para eliminar bajo Basado en el 1-itemset del grado de apoyo, se obtiene el 1-itemset frecuente. Luego, conecte los conjuntos de 1 elemento frecuentes restantes para obtener los conjuntos de 2 elementos frecuentes candidatos, filtre los conjuntos de 2 elementos frecuentes candidatos que sean más bajos que el grado de soporte y obtenga los conjuntos binomiales frecuentes reales, y así sucesivamente, iterar hasta que no pueda Hasta se encuentran conjuntos de elementos k+1 frecuentes, el conjunto de conjuntos de elementos k frecuentes correspondientes es la salida del algoritmo.
Flujo de algoritmo:
1) Escanee todo el conjunto de datos para obtener todos los datos que han aparecido como un conjunto de elementos frecuente candidato. k=1, el conjunto de elementos 0 frecuente es un conjunto vacío.
2) Minería de elementos k frecuentes
a) Escanee los datos para calcular el soporte de conjuntos de elementos k frecuentes candidatos
b) Eliminar los conjuntos de datos cuyo grado de soporte sea inferior al umbral en el k-itemset frecuente candidato y obtener el k-itemset frecuente. Si el conjunto de elementos k frecuentes obtenido está vacío, el conjunto de conjuntos de elementos k-1 frecuentes se devuelve directamente como el resultado del algoritmo y el algoritmo finaliza. Si el k-itemset frecuente obtenido tiene solo un elemento, el conjunto de k-itemsets frecuentes se devuelve directamente como el resultado del algoritmo y el algoritmo finaliza.
c) Con base en conjuntos de elementos k frecuentes, conéctese para generar conjuntos de elementos k+1 frecuentes candidatos.
3) Sea k=k+1, vaya al paso 2.
Código de referencia https://spaces.ac.cn/archives/3380
#-*- coding: utf-8 -*-
from __future__ import print_function
import pandas as pd
d = pd.read_csv('./opt/test.csv',header=None, dtype = object)
print(u'\n转换原始数据至0-1矩阵...')
import time
start = time.clock()
ct = lambda x : pd.Series(1, index = x)
b = map(ct, d.values)
d = pd.DataFrame(list(b)).fillna(0)
d = (d==1)
end = time.clock()
print(u'\n转换完毕，用时：%0.2f秒' %(end-start))
print(u'\n开始搜索关联规则...')
del b
support = 0.06 #最小支持度
confidence = 0.75 #最小置信度
ms = '--' #连接符，用来区分不同元素，如A--B。需要保证原始表格中不含有该字符
#自定义连接函数，用于实现L_{k-1}到C_k的连接
def connect_string(x, ms):
x = list(map(lambda i:sorted(i.split(ms)), x))
l = len(x[0])
r = []
for i in range(len(x)):
for j in range(i,len(x)):
if x[i][:l-1] == x[j][:l-1] and x[i][l-1] != x[j][l-1]:
r.append(x[i][:l-1]+sorted([x[j][l-1],x[i][l-1]]))
return r
#寻找关联规则的函数
def find_rule(d, support, confidence):
import time
start = time.clock()
result = pd.DataFrame(index=['support', 'confidence']) #定义输出结果
support_series = 1.0*d.sum()/len(d) #支持度序列
column = list(support_series[support_series > support].index) #初步根据支持度筛选
k = 0
while len(column) > 1:
k = k+1
print(u'\n正在进行第%s次搜索...' %k)
column = connect_string(column, ms)
print(u'数目：%s...' %len(column))
sf = lambda i: d[i].prod(axis=1, numeric_only = True) #新一批支持度的计算函数
#创建连接数据，这一步耗时、耗内存最严重。当数据集较大时，可以考虑并行运算优化。
d_2 = pd.DataFrame(list(map(sf,column)), index = [ms.join(i) for i in column]).T
support_series_2 = 1.0*d_2[[ms.join(i) for i in column]].sum()/len(d) #计算连接后的支持度
column = list(support_series_2[support_series_2 > support].index) #新一轮支持度筛选
support_series = support_series.append(support_series_2)
column2 = []
for i in column: #遍历可能的推理，如{A,B,C}究竟是A+B-->C还是B+C-->A还是C+A-->B？
i = i.split(ms)
for j in range(len(i)):
column2.append(i[:j]+i[j+1:]+i[j:j+1])
cofidence_series = pd.Series(index=[ms.join(i) for i in column2]) #定义置信度序列
for i in column2: #计算置信度序列
cofidence_series[ms.join(i)] = support_series[ms.join(sorted(i))]/support_series[ms.join(i[:len(i)-1])]
for i in cofidence_series[cofidence_series > confidence].index: #置信度筛选
result[i] = 0.0
result[i]['confidence'] = cofidence_series[i]
result[i]['support'] = support_series[ms.join(sorted(i.split(ms)))]
result = result.T.sort_values(['confidence','support'], ascending = False) #结果整理，输出
end = time.clock()
print(u'\n搜索完成，用时：%0.2f秒' %(end-start))
print(u'\n结果为：')
print(result)
return result
find_rule(d, support, confidence).to_csv('./opt/out.csv')Texto de prueba: https://spaces.ac.cn/usr/uploads/2015/07/3424358296.txt
Blog de referencia recomendado:
https://www.jianshu.com/p/a77b0bc736f2
https://www.cnblogs.com/pinard/p/6293298.html
https://spaces.ac.cn/archives/3380