1、数据处理
1.1 模块的使用
Pandas的使用
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
import pandas as pda
'''
series:系列数据
'''
a=pda.Series([8,9,2,1])
'''
结果：
0 8
1 9
2 2
3 1
dtype: int64
默认索引是从0开始的
'''
#指定索引
# a=pda.Series([8,9,2,1],index=["two","three","four","five"])
b=pda.DataFrame([[8,8,3,2],[1,2,3,4],[5,7,3,2]])
'''
结果：
0 1 2 3
0 8 8 3 2
1 1 2 3 4
2 5 7 3 2
'''
#指定列名
c=pda.DataFrame([[8,8,3,2],[1,2,3,4],[5,7,3,2]],columns=["two","three","four","five"])
#以字典的形式创建数据框
d=pda.DataFrame({
"one":4,
"two":[6,2,3],
"three":list(str(982))
})
'''
结果：
one three two
0 4 9 6
1 4 8 2
2 4 2 3
'''
# print(d.head())#默认取前五行
# print(d.head(2))#取前两行
# print(d.tail())#默认取后五行
# print(d.tail(2))#取后两行
print(d)
print(d.T)#转置
print(d.describe())
print(c.describe())#按列统计结果
'''
two three four five
count 3.000000 3.000000 3.0 3.000000
mean 4.666667 5.666667 3.0 2.666667
std 3.511885 3.214550 0.0 1.154701
min 1.000000 2.000000 3.0 2.000000
25% 3.000000 4.500000 3.0 2.000000 分位数
50% 5.000000 7.000000 3.0 2.000000
75% 6.500000 7.500000 3.0 3.000000
max 8.000000 8.000000 3.0 4.000000
'''
# print(a)
# print(b)
# print(d)pandas导入数据
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
import pandas as pda
import pymysql
'''
#读取csv文件中的数据
data=pda.read_csv("F:\\网络爬虫\\视频课程\\源码\\源码\\luqu.csv")
#统计每一列的信息只展现有数字的列
# print(data.describe())
#按照gre进行排序,默认是从小到大
print(data.sort_values(by="gre"))
'''
'''
#读取数据库中的数据
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="123456",db="dd",charset="utf8")
sql="select * from book"
k=pda.read_sql(sql,conn)
print(k)
'''
'''
#读取网页中的表格数据
k=pda.read_html("https://book.douban.com/")
print(k)
'''
#读取文本数据
txt=pda.read_table("J:\\论文\\小论文\\审稿修改.txt",)
print(txt)Matplotlib的使用
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
#折线图/散点图plot
import matplotlib.pylab as pyl
import numpy as np
'''
x=[1,2,3,4,8]
y=[5,7,2,1,5]
x2=[3,2,6,4,8]
y2=[5,9,2,1,5]
# pyl.plot(x,y)#默认是折线图
# pyl.plot(x,y)#plot(x轴数据，y轴数据,展现形式)
点的颜色
c-cyan---青色
r-red---红色
m-magente---品红色
g-green---绿色
b-blue---蓝色
y-yellow--黄色
k-black---黑色
w-whilte---baise
连接线方式
- 直线
-- 虚线
-. -.形式
: 细小虚线
点的展现形式
o 点形
s 方行
h 六角形
H 六角形
* 星形
+ 加号
x X形
d 菱形
D 菱形
p 五角形
pyl.plot(x,y)#以黄色的散点图的形式展现，比如颜色、线条等参数可以叠加
pyl.plot(x2,y2)#同一个图中展现两条折线，只需要在show之前再画一条就行
pyl.title("show")#代表标题
pyl.xlabel("ages")#x轴的标题
pyl.ylabel("temp")#y轴的标题
pyl.xlim(0,20)#设置横轴的范围
pyl.ylim(5,18)#设置纵轴的范围
pyl.show()
'''
'''
#随机数生成
data=np.random.random_integers(1,20,10)#(最小值，最大值，随机数个数)
# print(data)
#随机生成正太分布的随机数
data2=np.random.normal(5.0,2.0,10)#(均数，西格玛，个数)
print(data2)
'''
'''
#直方图hist
data3=np.random.normal(10.0,1.0,1000)
#绘制成直方图
# pyl.hist(data3)
sty=np.arange(0,20,2)#设置0-20，直方图的宽度为2
pyl.hist(data3,sty,histtype="stepfilled")#stepfilled：取消直方图的轮廓
pyl.show()
'''
#绘制子图
# pyl.subplot(1,2,1)#行，列，当前图的区域
# pyl.show()
#--------------------------
pyl.subplot(2,2,1)#整体分为两行两列，当前图位于第一个区域
x1=[1,2,3,4,5]
y1=[5,3,5,23,5]
pyl.plot(x1,y1)#在这个中间的区域会绘制在上面那个区域中
#############
pyl.subplot(2,2,2)#两行两列，第二区域,每一个不受上面的影响
x2=[5,8,3,4,5]
y2=[2,3,7,33,5]
pyl.plot(x2,y2)
#######################
pyl.subplot(2,1,2)#两行一列，第二区域
#最后呈现的结构是个倒立的品字
pyl.show()
数据可视化分析
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
import pandas as pda
import numpy as np
import matplotlib.pylab as pl
file=open("J:\\Program\\Python\\Python爬虫\\数据分析与数据挖掘\\hexun1.csv",encoding="utf-8")
#建议打开采用panda打开文件的时候先用open打开，它能解决路径中存在中文的问题以及编码问题，打开之后再用pandas打开
#遇到编码问题先将其转换成utf-8无bom格式
data=pda.read_csv(file)
# print(data.shape)#获取数据的大小，是一个二维数组
# print(data.values)#
# print(data.values[0])#获取第一行数据（实际上为表格中的第二行数据，表格中的第一行数据作为表头）
# print(data.values[1][1])
#转置
data2=data.T
# print(data2.values[3])
# print(data2.values[4])
#绘图
# pl.hist(data2.values[3])
# pl.show()
pl.plot(data2.values[0],data2.values[3])
pl.show()1.2 数据变换
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
import pymysql
import numpy as np
import pandas as pda
import matplotlib.pylab as pyl
'''
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="123456",db="taobao",charset="utf8")
sql="select price,comment from taob"
data=pda.read_sql(sql,conn)
# print(data.max())
'''
'''
# 离差标准化用于消除量纲（单位）影响以及变异大小因素的影响（最小-最大标准化）
# data2=(data-data.min())/(data.max()-data.min())
# print(data2)
'''
'''
#标准差标准化,最终数据均值为0，标准差为1,用于消除单位影响以及变量自身变异影响（零-均值标准化）
data3=(data-data.mean())/data.std()
print(data3)
'''
'''
#小数定标规范化,用于消除单位影响
#np.ceil：向上取整
k=np.ceil(np.log10(data.abs().max()))
data4=data/10**k
print(data4)
'''
'''
#连续型数据离散化
#等宽离散化
data5=data["price"].copy()
data6=data5.T
data7=data6.values
# print(data7)
#4：将数据data7等分为4等份，labels:是每一份对应的标签
# pda.cut(data7,4,labels=["便宜","适中","有点贵","天价"])
#非等宽离散化
#将数据data7 按[3,6,10,19]划分为：(3,6] (6,10] (10,19]三个区间
print(pda.cut(data7,[0,50,100,300,500,data7.max()],labels=["非常便宜","便宜","适中","有点贵","很贵"]))
'''
#属性构造
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="123456",db="hexun",charset="utf8")
sql="select * from myhexun"
data8=pda.read_sql(sql,conn)
# print(data)
ch=data8["comment"]/data8["hits"]
data8["评点比"]=ch
file="J:\\Program\\Python\\Python爬虫\\数据分析与数据挖掘\\hexun4.csv"
data8.to_csv(file,index=False)#相当于在原文件的基础上增加一列,index=false表示行名不变
数据清洗
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
import pymysql
import numpy as np
import pandas as pda
import matplotlib.pylab as pyl
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="123456",db="taobao",charset="utf8")
sql="select * from taob"
data=pda.read_sql(sql,conn)
# print(data.describe())
#数据清洗
'''
#发现缺失值,如果price为0就将它设置为空值
data["price"][(data["price"]==0)]=None#panda是按表头操作数据的，这句表示将price这一列中价格为0的数据的price置为空
x=0
for i in data.columns:
for j in range(len(data)):#len(data)为总长度，即总行数
#data[i].isnull()获取每一列值的空值分布的一维数组，是一个true、false数组，如果为空则为true,否则为false
#(data[i].isnull())[j]：定位到每一个值，如果为true，也就证明该值为空，所以就执行下面的语句，将其置为36
if (data[i].isnull())[j]:#d[i]是获取第i列数据，相当于一维数组，如果其中有空值，则将其该空值置为36
data[i][j]="36"
x+=1
print(x)
'''
'''
#异常值处理,可视化异常
#画散点图（横轴为价格，纵轴为评论数 ）
#得到价格
data2=data.T
price=data2.values[2]
#得到评论数
comment=data2.values[3]
pyl.plot(price,comment,'o')
pyl.show()
'''
'''
#评论数异常>200000,价格异常>2300
# print(data.values)#将其转为数组,9614行4列
# print(data.values.shape)
line=len(data.values)
col=len(data.values[0])
da=data.values
for i in range(0,line):
for j in range(0,col):
#如果价格大于2300,则将其设置为中位数36
if(da[i][2]>2300):
print(da[i])#打印该条数据,因为它只会进来一次
da[i][2]=36#当执行了这条语句之后，这个位置已经使得da[i][2]<2300，后面的da[i][3]不会再进来
# #如果评论大于200000,则将其设置为中位数58
if(da[i][3]>200000):
print(da[i])
da[i][3]=58
'''
#分布分析
line=len(data.values)
col=len(data.values[0])
da=data.values
da2=da.T
price=da2[2]
comt=da2[3]
pricemax=price.max()
pricemin=price.min()
commentmax=comt.max()
commentmin=comt.min()
#极差：最大值-最小值
pricerg=pricemax-pricemin
commenterg=commentmax-commentmin
#组距：极差/组数
pricedst=pricerg/12
commentdst=commenterg/12
#画价格的直方图
# pricesty=np.arange(pricemin,pricemax,pricedst)
# pyl.hist(da2[2],pricesty)
# pyl.show()
#画评论的直方图
commensty=np.arange(commentmin,commentmax,commentdst)
pyl.hist(da2[3],commensty)
pyl.show()数据降维
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
#主成分分析
from sklearn.decomposition import PCA
import pymysql
import numpy as np
import pandas as pda
import matplotlib.pylab as pyl
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="123456",db="hexun",charset="utf8")
sql="select hits,comment from myhexun"
data=pda.read_sql(sql,conn)
# print(data)
pcal=PCA()
pcal.fit(data)
#返回模型中的各个特征向量
# print(pcal.components_)
#返回各个成分中各自方差百分比，贡献率
# print(pcal.explained_variance_ratio_)
#PCA降维
pca2=PCA(1)#将其将为1维
pca2.fit(data)
result=pca2.transform(data)
# print(result)#降维
#恢复数据
result2=pca2.inverse_transform(result)
print(result2)2、文本挖掘
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
import jieba
import jieba.posseg
import jieba.analyse
sentence="我喜欢上海东方明珠"
w1=jieba.cut(sentence,cut_all=True)#cut_all指定分词模式，为true是全模式，词汇存在叠加
'''
结果：
我
喜欢
上海
上海东方
海东
东方
东方明珠
'''
# for item in w1:
# print(item)
#精准模式，词汇不存在叠加，默认使用精准模式
'''
结果：
我
喜欢
上海
东方明珠
'''
w2=jieba.cut(sentence,cut_all=False)
# for item in w2:
# print(item)
#搜索引擎模式,按照所有引擎模式
'''
我
喜欢
上海
东方
方明
明珠
东方明珠
'''
# w3=jieba.cut_for_search(sentence)
# for item in w3:
# print(item)
#词性标注
w5=jieba.posseg.cut(sentence)
#.flag 词性
'''
a 代表形容词
c 代表连词
d 代表副词
e 代表叹词
f 代表方位词
i 代表成语
m 代表数词
n 代表名词
nr 代表人名
ns 代表地名
nt 代表机构团体（比如：百度）
nz 代表其他专有名词
p 代表代词
r 代表代词
t 代表时间
u 代表助词
v 代表动词
vn 代表动名词
w 代表标点符号
un 代表未知词语
'''
'''
结果：
我----------r
喜欢----------v
上海----------ns
东方明珠----------nr
'''
#.word 词语
# for item in w5:
# print(item.word+"----------"+item.flag)
'''
#词典加载（词典可以按照dict格式自定义），它是加载到内存中，不会持久化输出，即只能用一次就失效了，每次需要手动加载
#如果要持久化则需要加载到jieba的dict中
jieba.load_userdict("E:\\Anaconda\\Lib\\site-packages\\jieba\\dict2.txt")
sentence2="三峡大学位于宜昌"
# w6=jieba.cut(sentence2)
w6=jieba.posseg.cut(sentence2)
'''
# 结果：
# 三峡大学
# 位于
# 宜昌
'''
for item in w6:
print(item.word+"----------"+item.flag)
'''
'''
#更改词频
sentence3="三峡大学是以水利水电为特色的综合型研究性大学"
w7=jieba.cut(sentence3)
for item in w7:
print(item)
jieba.add_word("研究")
'''
'''
#根据词频提取关键词，指定为3个，默认是20个
sentence3="三峡大学是以水利水电为特色的综合型研究性大学"
tags=jieba.analyse.extract_tags(sentence3,4)
print(tags)
'''
#返回词语的位置
w9=jieba.tokenize(sentence)
'''
结果：
('我', 0, 1)
('喜欢', 1, 3)
('上海', 3, 5)
('东方明珠', 5, 9)
'''
# for item in w9:
# print(item)
#返回搜索引擎模式下的词语位置
w10=jieba.tokenize(sentence,mode="search")
'''
结果：
('我', 0, 1)
('喜欢', 1, 3)
('上海', 3, 5)
('东方', 5, 7)
('方明', 6, 8)
('明珠', 7, 9)
('东方明珠', 5, 9)
'''
for item in w10:
print(item)文本相似度分析
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
from gensim import corpora,models,similarities
import jieba
from collections import defaultdict
doc1=open("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\gud.txt",encoding="utf-8").read()
doc2=open("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\ljm.txt",encoding="utf-8").read()
data1=jieba.cut(doc1)
data2=jieba.cut(doc2)
#获取文本1中的分词,组成一个字符串
data11=""
for item in data1:
data11+=item+" "
#获取文本2中的分词，组成一个字符串
data21=""
for item in data2:
data21+=item+""
#合并文本1和文本2中的分词
documents=[data11,data21]
texts=[[word for word in document.split()]
for document in documents]#里面是两个列表，每个列表中包含一个文档的词汇
# print(texts)
#创建频率对象
frequency=defaultdict(int)
for text in texts:
for token in text:
#统计出词频，相同的词加1，frequency返回的是一个字典，词为key,数量为values
frequency[token]+=1
# #过滤掉频率比较低的词汇
# texts=[[word for word in text if frequency[token]>25
# for text in texts]]
#通过语料库建立字典，格式：{单词id，在多少文档中出现}
dictionary=corpora.Dictionary(texts)
dictionary.save("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\wenben.txt")
'''
dictionary的一些用法：
# print(dictionary.dfs) #字典，{单词id，在多少文档中出现}
# print(dictionary.num_docs)#文档数目
# print(dictionary.num_pos)#所有词的个数
# for key in dictionary.items():
# print(key)#(17183, '龙骨随葬') 单词id:单词
# print(dictionary.num_nnz) #每个文件中不重复词个数的和
'''
#加载要对比的文档
doc3="F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\盗墓笔记.TXT"
d3=open(doc3,encoding="utf-8").read()
data3=jieba.cut(d3)
data31=""
for item in data3:
data31+=item+" "
new_doc=data31
#将要对比的文档通过doc2bow转化为稀疏向量
new_vec=dictionary.doc2bow(new_doc.split())#注意必须通过同一个字典dictionary
# print(new_vec)#词袋new_vec，列表[(单词id，词频)]，结果：[(0, 108), (1, 75), (2, 74), (3, 25), (4, 32),...]
#对稀疏向量进行进一步处理，得到新的语料库
corpus=[dictionary.doc2bow(text) for text in texts]
# print(corpus)#结果：[[(0, 1), (1, 2), (2, 2), (3, 3), (4, 1), (5, 9), ...],[...]]
#将新的语料库通过tfidfmodel进行处理，得到tfidf
#完成对corpus中出现的每一个特征的IDF值的统计工作即词语普遍重要性的度量,返回一个权重
tfidf=models.TfidfModel(corpus)
# print(len(tfidf[corpus]))
# for i in tfidf[corpus]:
# print(i)
# '''
# 结果：
# [(0, 6.278644801648022e-05), (1, 0.00012557289603296043),..]
# 返回的是两个文档中的每一个特征的权重
#得到特征数
#dictionary.token2id:字典，{词，对应的单词id} dictionary.token2id.keys():单词个数
featureNum=len(dictionary.token2id.keys())
# #计算稀疏矩阵的相似性,稀疏矩阵相似度，从而建立索引，通过tfidf[corpus]和特征对应起来，则可直接找到相应的权重（相似度），也就是建立了索引
#???????????????
index=similarities.SparseMatrixSimilarity(tfidf[corpus],num_features=featureNum)
# #得到最终相似度结果
# print(tfidf[new_vec])
sim=index[tfidf[new_vec]]
# print(sim)
'''
[9.8796403e-01 1.8048293e-05]
9.8796403e-01表示盗墓笔记和gud的相似度
1.8048293e-05表示盗墓笔记和ljm的相似度
'''分析盗墓笔记
#!/usr/bin/python
# -*-coding:utf-8-*-
# __author__ = 'ShenJun'
import jieba
import jieba.analyse
'''
#分析血尸的词频
data=open("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\血尸.txt",encoding="utf8").read()
tags=jieba.analyse.extract_tags(data)
print(tags)
'''
data2=open("F:\\网络爬虫\\视频课程\\源码\\源码\\第7周\\盗墓笔记.TXT",encoding="utf8").read()
tags=jieba.analyse.extract_tags(data2)
print(tags)