Python

作者: Babus | 来源:发表于2017-11-22 15:41 被阅读0次

QQ图片20171107234339.png

Jupyter Notebook 利器

入门基础

windows一键安装：3.5.2版本
第三方包：windows平台：pip install package（+包名）
因为防火墙问题，直接输入命令会失败
+verbose会讲如何失败
在windows命令器中输入：
pip install pandas（这个包名）

pip --verbose install pandas（打印失败原因）

pip list（列出本地已经安装的包）
一般用这种代码
pip install -i --trusted-host http：//pypi.douban.com/simple/ pandas

win10可能有坑：红字，cannot detect archive format
实在不行直接谷歌或者百度这个包然后来下载

环境搭建：notebook

如何学好编程

基础部分：

基本语法
数据结构
输入输出
异常处理

进阶提高：

常用算法
数据库访问
面向对象
-其他

基本语法

基本数据类型
对象的定义和声明
循环和判断：for，foreach，if，while，do
逻辑运算
位运算

数据结构

数组
字符串
系统标准库自带类型
如何实现常用数据结构：链表、堆栈、二叉树

输入输出

标准输入输出：print，echo，input
文件读写：文本（行读写）/二进制（偏移量+大小）
格式化字符串

异常

抛出和捕捉异常：try/catch，try/except
异常和错误的区别以及应用

pass：什么都不做，有时候需要做填充，解决语义的歧义
continue：跳出当前循环

：指数运算 102 =100
//：除法，且只留整数
not：取反
<<：左移位

：右移位（二进制）
16<<2(左移两位4）64
30<<3(左移三位8）240
100>>3（右移3位/8，取整数）

二进制：0b开头，八进制0o开头

Python 语法基础

输出
print("")
注释

注释法

print("")

三引号注释法

image.png

标识符

image.png
变量
数据类型
数，字符串，列表（list）a=["my","name"]，元组（tuple）cde=("my","name"),cde[0]=my,元组和列表的区别：元组不能修改元素，列表可以修改元素，集合（set），字典（dictionary）

image.png

image.png

运算符

- - / %（求余数） //求模

缩进

image.png
image.png

Python控制流

三种基本控制流：

顺序结构（做事情一直把他做下去）
条件分支结构（利用if来实现）
循环结构（）

if语句
while语句（循环）
for语句（循环）（遍历列表的内容）

image.png

中断结构

中途退出的一种结构，常有break语句与continue语句。

image.png

输出乘法口诀：

image.png

逆向乘法口诀作业

为什么要强制转换，因为*是字符，要相同的才能想加的，所以要转化
range(start, end, scan)

for i in range(9,0,-1):     
    for j in range(i,0,-1):         
        print(str(i) + " * " +str(j)+ " = " + str(i*j) + " " ,end=" ")     
    print()

image.png

注意最后一个print的位置，要与第二个for对齐才能这样输，反例

image.png

Python函数详解

函数的本质是功能的封装。

局部变量与全局变量

作用域：生效范围，全局变量：作用域从头到尾，局部变量：作用域在局部

image.png

把函数里面的局部变量变为全局变量

image.png

排错的时候可以利用二分段法（在中间，把后面注释掉，加一个print）

函数的定义与调用

def定义函数，一般命名不要用拼音
def abc():

函数的参数

image.png

实实在在将10和19传递给a,b。ab相当于形参

image.png

Python的模块

可以理解成函数的一个升级版本，模块按类别来分类（类似java的类），把一类的功能都放在一个模块里面。
系统自带的模块在lib目录中。

模块的导入

import 模块名
from...import...（from模块，import模块里的某一个方法）

不能跨层导入，要一层层导入，（urlopen在request下面）。

import urllib
from urllib.request import urlopen
data1=urllib.request.urlopen("http://www.baidu.com").read()
print(len(data1))

第一种导入方法

image.png

第二种
一开始就定位到相关的文件

from urllib import request
data3=request.urlopen("http://jd.com").read()
print(len(data3))

自定义模块

函数需要返回值，我们用return，执行完这个函数这个函数的整体就成了return的值。

文件操作概述

用Python做文件的打开，关闭，读取，写入等操作，例如合并多个excel表格文件的内容。

image.png

Python异常处理

image.png

try：试着去执行这一块代码

image.png

open("","a")

wb代表二进制写入

open(路径+文件名,读写模式)

读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式

如:'rb','wb','r+b'等等

读写模式的类型有：

rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w 以写方式打开，
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )

image.png

爬虫初识

image.png

cp指的是版本，直接搜索就行。

image.png

下载之后的安装：cmd下，进入下载的包的位置

image.png

网络爬虫原理

通用爬虫
聚焦爬虫：有一个过滤环节，有一个筛选环节

正则表达式

image.png

非打印字符：\n换行，\t制表符

格式：第一个是规则，第二个是目标

image.png

通用字符：

\w能匹配任意一个字母数字或者下划线
\d匹配任意一个十进制数
\s匹配任意一个空白字符
\W匹配小w相反的东西，匹配任意一个除了字母数字下划线以外的字符
\D与\d同样也相反

image.png

原子表，用来定义平等的原子。用[]，[jsz]三个原子，都是平等的，有其中一个就ok，只能其中一位匹配不能多位匹配。

image.png

元字符

image.png

.能够匹配任意的字符
^匹配字符串开始的位置
$匹配字符串结束的位置
*匹配一次或者多次还有0次例如s（右上角星号）匹配ss sss s
？匹配0次或者1次
+匹配一次或多次没有0次
{3}前面的原子恰好出现3次，t{6}恰好有6个- t（连在一起的） t{6，}（恰好至少出现了6次）
s{4,7}至少出现4次，至多出现7次。
|,t|s(二选一）
()

image.png

学到模式修正符

image.png

模式修正符：

I 可以让正则表达式忽略大小写
M 多行匹配
L 本地化识别匹配
U根据unique字符解析字符
S让.的匹配也匹配上换行符

image.png

贪婪模式，懒惰模式

p.y：贪婪模式，尽可能多的去匹配。中间的字符是什么，有多少都是ok的。.替换任意通用字符， 0,1，多个
p.*？y：懒惰模式，够用就溜了

image.png
懒惰模式：精确定位
贪婪模式：定位更广

正则表达式函数

image.png

match：是从头开始搜索，一开始就要满足才可以。

search：满足头的东西可以出现任意位置。但只给一个结果。

image.png

引入一个全局匹配complie
re.compile(对应的表达式).findall(待搜索字符)

image.png

image.png
写在[^{]表示非，只要是”}”这个字符是在中括号”[]”中被使用的话就是表示字符类的否定，如果不是的话就是表示限定开头。我这里说的是直接在”[]”中使用，不包括嵌套使用。
其实也就是说”[]”代表的是一个字符集，”^”只有在字符集中才是反向字符集的意思。

image.png

左右不需要输出来，打一个小括号，只输出这个小括号里面的东西。

image.png

单双引号区别：

image.png

第二次作业爬取图书馆

import urllib.request
data=urllib.request.urlopen("https://read.douban.com/provider/all").read()
import re
data=data.decode("utf-8")
pat1='<div class="name">(.*?)</div>'
mydata=re.compile(pat1).findall(data)
print(mydata)

写入

image.png

Urllib库实战

urlretrieve（要爬的参数，本地地址）：直接将某个网页爬到本地
urlcleanup：清除由于urlretrieve产生的缓存。
info：显示当前环境的一些信息
getcode：当前网页状态码，返回200（网页返回正确），403禁止访问。
geturl：现在爬的是哪个网页

image.png

超时测试：

image.png

自动模拟http请求

image.png

url直接爬还不支持https，要写成http

image.png

涉及到汉字的编码问题

image.png

post

请求：（地址，数据）

image.png

爬虫异常处理

200是正常进行

image.png

urlerror：

连不上服务器
远程Url不存在
本地没有网络
触发了http子类

防屏蔽了，因为没有模拟浏览器登陆

image.png

浏览器伪装技术

修改请求的报头
网页先用F12然后找，发生一次访问操作，点network，点header 在找到user-agent

image.png

然后复制进去
build_opener创建一个报头

image.png

爬新闻程序

有些网站utf-8有问题，可以在后面加一个ignore

image.png

第三次作业

image.png

作业代码：

import re
import urllib.request
headers=("User-Agent","Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36")
opener=urllib.request.build_opener()
opener.addheaders=[headers]
data=opener.open("https://www.csdn.net/").read()
data2=data.decode("utf-8","ignore")
pat='href="(https://.*?)"'
allurl=re.compile(pat).findall(data2)
for i in range(0,len(allurl)):
    try:
        print("第"+str(i)+"次爬取")
        thisurl=allurl[i]
        file="F:/python/test"+str(i)+".html"
        urllib.request.urlretrieve(thisurl,file)
        print("成功")
    except urllib.error.URLError as e:
        if hasattr(e,"code"):
            print(e.code)
        if hasattr(e,"reason"):
            print(e.reason)

爬虫防屏蔽手段之代理服务器

image.png

因为用自己的很有可能被ip封锁，所以需要代理服务器
ProxyHandler{“http”；“代理ip及其端口”}

image.png

多次换代理ip，变换成一个列表，用循环就行

image.png

图片爬虫

爬取淘宝图片
图片核心一直找不到，可以多换换浏览器看看。

image.png

将图片显示出来

image.png

找有js文件的地方，来看抓包的源码

image.png

第四次作业爬取千图网

import urllib.request
import re
keyname="5244251"
key=urllib.request.quote(keyname)
headers=("User-Agent","Mozilla/5.0 (Windows NT 10.0; WOW64; rv:57.0) Gecko/20100101 Firefox/57.0")
opener=urllib.request.build_opener()
opener.addheaders=[headers]
urllib.request.install_opener(opener)
page=['','?page=02','?page=03']
for i in range(0,3):
    url="http://www.58pic.com/c/"+keyname+str(page[i])
    data=urllib.request.urlopen(url).read().decode("utf-8","ignore")
    pat="background:url\('(.*?)'"
    imagelist=re.compile(pat).findall(data)
    for j in range(0,len(imagelist)):
        try:
            thisimg=imagelist[j]
            thisimgurl=thisimg
            file="F:/python/test/"+str(i)+str(j)+".jpg"
            urllib.request.urlretrieve(thisimgurl,filename=file)
        except urllib.error.URLError as e:
            if hasattr(e,"code"):
               print(e.code)
            if hasattr(e,"reason"):
               print(e.reason)

几个tips：假如正则匹配时候有括号，但本来括号用正则是选取里面内容的，所以需要用转义字符。"background:url('(.*?)'" 用\进行转义

空字符直接用一个空格表示：

找图片的方式：

换不同的浏览器，找原图的特殊字符。视频23，第32分钟有讲解
找缩略图与原图链接之间的匹配关系。

淘宝爬图片

import urllib.request
import re
keyname="q=%E6%96%87%E8%83%B8"
key=urllib.request.quote(keyname)
headers=("User-Agent","Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36")
opener=urllib.request.build_opener()
opener.addheaders=[headers]
urllib.request.install_opener(opener)
page=['','&s=44','&s=88']
for i in range(0,3):
    url="https://s.taobao.com/search?"+keyname+str(page[i])
    data=urllib.request.urlopen(url).read().decode("utf-8","ignore")
    pat='pic_url":"(.*?)","detail_url'
    imagelist=re.compile(pat).findall(data)
    for j in range(0,len(imagelist)):
        try:
            thisimg=imagelist[j]
            thisimgurl='http:'+thisimg
            file="F:/python/test/"+str(i)+str(j)+".jpg"
            urllib.request.urlretrieve(thisimgurl,filename=file)
        except urllib.error.URLError as e:
            if hasattr(e,"code"):
               print(e.code)
            if hasattr(e,"reason"):
               print(e.reason)

Python抓包分析

image.png

因为数据很有可能隐藏其中

右边分为response和request。上面是request（发送的请求）response（收到的回复）
复制出评论页，rate，右键copy，just url

image.png

腾讯视频评论的抓取

image.png

print(eval("u\'"+comdata[0]+"\'"))

相当于是固定住u' ，后面在固定住'。

微信爬虫

time模块（延时模块）
代码：

#http://weixin.sogou.com/
import re
import urllib.request
import time
import urllib.error
import urllib.request
#自定义函数，功能为使用代理服务器爬一个网址
def use_proxy(proxy_addr,url):
    #建立异常处理机制
    try:
        req=urllib.request.Request(url)
        req.add_header('User-Agent', 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.122 Safari/537.36 SE 2.X MetaSr 1.0')
        proxy= urllib.request.ProxyHandler({'http':proxy_addr})  
        opener = urllib.request.build_opener(proxy, urllib.request.HTTPHandler)  
        urllib.request.install_opener(opener)
        data = urllib.request.urlopen(req).read()
        return data
    except urllib.error.URLError as e:
        if hasattr(e,"code"):
            print(e.code)
        if hasattr(e,"reason"):
            print(e.reason)
        #若为URLError异常，延时10秒执行
        time.sleep(10)
    except Exception as e:
        print("exception:"+str(e))
        #若为Exception异常，延时1秒执行
        time.sleep(1)

#设置关键词            
key="Python"
#设置代理服务器，该代理服务器有可能失效，读者需要换成新的有效代理服务器
proxy="127.0.0.1:8888"
#爬多少页
for i in range(0,10):
    key=urllib.request.quote(key)
    thispageurl="http://weixin.sogou.com/weixin?type=2&query="+key+"&page="+str(i)
    #a="http://blog.csdn.net"
    thispagedata=use_proxy(proxy,thispageurl)
    print(len(str(thispagedata)))
    pat1='<a href="(.*?)"'
    rs1=re.compile(pat1,re.S).findall(str(thispagedata))
    if(len(rs1)==0):
        print("此次（"+str(i)+"页）没成功")
        continue
    for  j in range(0,len(rs1)):
        thisurl=rs1[j]
        thisurl=thisurl.replace("amp;","")
        file="F:/天善-Python数据分析与挖掘课程/result/32/第"+str(i)+"页第"+str(j)+"篇文章.html"
        thisdata=use_proxy(proxy,thisurl)
        try:
            fh=open(file,"wb")
            fh.write(thisdata)
            fh.close()
            print("第"+str(i)+"页第"+str(j)+"篇文章成功")
        except Exception as e:
            print(e)
            print("第"+str(i)+"页第"+str(j)+"篇文章失败")

=re.compile(pat1,re.S) 为了让（.*？）也匹配上换行符

多线程爬虫

程序并行执行。
threading模块，可以多线程。
class A（threading.Thread）创建A这个多线程。
A里面必须要两个函数。
上面的方法是初始化线程。
后面的方法是具体的用法。
要开启线程，先要实例化线程
t1=A（）
t1.start（）启动这个线程

image.png

分别爬奇数，一个偶数。

image.png

Scrapy框架

利用做大型的爬虫项目

image.png

Scrapy框架常见命令实战

常见命令：
在cmd输入：scrapy -h（看有哪些功能）
scrapy fetch -h（看这个功能的帮助）

scrapy fetch http://www.baidu.com 
(会显示出过程)
scrapy fetch http://www.baidu.com --nolog
（不显示过程）

fetch显示爬取过程
run spider（运行一个爬虫文件，不需要建一个工程）
shell（启动scrapy交互终端，通常测试会用到）

image.png

在交互终端可以提取一些相应的信息
startproject（创建爬虫项目）后面接项目名
version查看对应的版本信息
view（下载这个网页并查看）

image.png

除了全局命令，还有项目命令，要进入项目文件夹之后才能看到。
bench测试本机性能

一些文件功能

image.png

init初始化文件
pipelines，爬取之后的处理

image.png
在爬虫工程建爬虫文件，-l：看母版
basic：基本爬虫
crawl：自动爬虫
xmlfeed：基于xml文件
csvfeed：基于csv文件
http协议名 www主机名主机名例如：baidu.com

image.png
格式：
scrapy genspider -t 模板名（basic） peter（文件名） baidu.com（域名）

check（后面说到的都是项目命令）

image.png
crawl（用的非常多，运行某个爬虫）
list（展示当前项目下可以使用的爬虫文件）
edit（直接打开编辑器对爬虫编辑，linux环境下可以）
parse（获取某个网页）

第一个scrapy爬虫

XPath表达式（适合用标签的）

/ 代表从顶端开始寻找一个标签
/html（寻找这个标签里面的东西）
/html/head/title

image.png

//表示寻找所有的标签

text（）：用来提取文字信息
@：提取标签的属性信息：<a href>
标签[@属性=值]

image.png

先写items、pipelines、settings再写py程序
scrapy.Field创建容器

Scrapy自动爬虫

image.png

allow：设置那个标签
callback回调函数
follow：是否跟随：是否跟着爬下去

在setting里面接触useragent注释（让除了第一次以外每一次爬都是从useragent来的）

image.png

这个地方的要用yield返回。如果是return的话，返回几次就会崩溃掉。

image.png

init默认的初始化方法，这个类会一开始执行它。
close是最后执行的

自动登录

image.png

把cookiejar设为1，保留登录状态。

当当网爬取

引入数据库

用的是本机，本机数据库
db= 选择数据库
insert into插入信息（表名）
conn.query执行语句

补充内容

jason数据：键值对

image.png
构建分布式爬虫需要用的：redis（分布式的集群），scrapy-redis（结合scrapy与redis），scrapy

关闭cookie追踪防止爬虫发现的一种方法

image.png

u字符的翻译查看

image.png

快速了解数据分析与数据挖掘技术

数据挖掘的步骤

目标：获得什么样的目标等等
获取数据：爬虫采集
四类建模模型：分类，聚类，关联，预测

image.png

数据挖掘相关模块

image.png

numpy模块，有数组支持（python默认是没有数组支持，之前一般用list列表进行，当数据量大了，列表处理很慢，也是基础模块）
pandas很基础，基本数据相关都需要用到

image.png

选择numpy+mkl这个包，不是单独numpy单独的包

模块的一些基本操作

numpy模块（取别名，import numpy as aa）

不知道格式的字符串排在最后
三维数组排序（排数组里面元素排）
切片数组[起始下标:最终下标+1]
省略不写代表衍生到头

image.png

pandas模块

Series概念，指某一串数字（一串数字叫做一个series数字）有索引（不指定的话就是0,1,2...等排下去；指定索引加上index数组）
DataFrame类似表格，代表行列整合出来的数据，指定列名（加一个columns），还可以通过字典的方式，pandas中数字不够会自动填充的，填充为它本身

image.png

image.png

结果输出

image.png

head和tail

image.png

describe：统计数据情况，按列统计，count（计数，多少个元素，one这一列有三个元素）；mean（平均数）；std（标准差）；25%，50%，75%代表分位数（前25%的分位数，前50%分位数等）

image.png
数据转置（行列转换）
d.T

image.png

数据导入学习

image.png

按照排序，放数据表头第一个元素（按这个元素所有的分类的大小排序）降序利用：des和ascending=False
read_table：导入文本数据

sql导入，设置connect，然后设置查询语句
html读取是读取网页标签里的table标签。
导入数据，只导入数据部分不导入文字部分

image.png
image.png

matplotlib基础

#折线图/散点图plot
import matplotlib.pylab as pyl
import numpy as npy
x=[1,2,3,4,8]
y=[5,7,2,1,5]
#pyl.plot(x,y)#plot(x轴数据，y轴数据，展现形式)#多个plot的话会直接叠加上去
#pyl.show()
#默认为折线图，设置为o就是散点图
#pyl.plot(x,y,'o')
#pyl.show()
#改变散点的颜色
#pyl.plot(x,y,'oc') #不仅仅是青色还是散点图
#颜色
'''
c:青色；r：红色； m：品红；g：绿色； b：蓝色
y黄色 k黑色 w白色
'''
#形式
'''
直线 -
虚线 --
-.(就是-.形式)
:(细小虚线)
'''
'''
pyl.plot(x,y,'mp')
pyl.show()
'''
#点的样式(表示散点的类型，就不用重复用散点符号o)
'''
s方形 h/H六角形 *星形 +加号 x（x）型 d/D菱形 p五角形 
'''
#起名字，或者给x，y轴加名字
'''
pyl.plot(x,y)
x2=[1,3,6,8,10,12,19] 多条曲线的绘制
y2=[1,6,9,10,19,23,35]
pyl.plot(x2,y2)
pyl.title("show")
pyl.xlabel("peter")
pyl.ylabel("hah")
pyl.xlim(0,20) 给xy轴设定范围
pyl.ylim(1,18)
pyl.show()
'''
#随机数的生成
import numpy as npy
data=npy.random.random_integers(1,20,10)#整数的随机数（最小值，最大值，个数）
#生成具有正态分布的随机数(两个重要的参数：平均数和标准差，在平均数附近的人数很多，大概判断为正态分布)
#npy.random.normal(均数，西格玛(越小越陡，越大越平缓，生成的个数)
#同一个区域
#直方图hist
'''
data3=npy.random.normal(10.0,1.0,10000)
pyl.hist(data3)
pyl.show
'''
'''
data4=npy.random.random_integers(1,25,1000)
pyl.hist(data4)
pyl.show
'''
'''
data4=npy.random.random_integers(1,25,1000)
sty=npy.arange(2,17,4)#(横坐标起始，横坐标末端，间隔)
pyl.hist(data4,sty)
pyl.hist(data4,sty,histtype='stepfilled')(取消轮廓)
pyl.hist(data4,histtype='stepfilled')(取消间隔限制)
pyl.show()
'''
#子图(在同一张图片中绘制多张图片)
#pyl.subplot(4,4,3)(行，列，当前区域（）)subplot将整个绘图区域等分为行*列个子区域，
然后按照从左到右，从上到下的顺序对每个子区域进行编号，左上的子区域的编号为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,2,3,8,6]
y2=[7,9,12,12,3]
pyl.plot(x2,y2)

pyl.subplot(2,1,2)
#第三个区域
x3=[5,6,7,10,19,20,29]
y3=[6,2,4,21,5,1,5]
pyl.plot(x3,y3)
pyl.show()

读取和讯博客的数据并可视化分析

import pandas as pda
import numpy as npy
import matplotlib.pylab as pyl
data=pda.read_csv("F:/Python/代码/源码/第5周/hexun.csv")
#data.shape()#看有多少行多少列 雷士descrip
#data.values[][]#[第几行][第几列]自动变成数组
data.values #所有
data.values[1] #实际第二行
data.values[1][1]#具体的那个数

#本来五行 id  名字 网址 阅读数 评论数
#分析所有的数据中阅读数与评论数之间的关系
data2=data.T #转置行变列
y1=data2.values[3] #把这一块完全取出来
x1=data2.values[4]#获取评论数
#pyl.plot(x1,y1)
#pyl.show()
#分析id与阅读数之间的关系
x2=data2.values[0]#获取id
pyl.plot(x2,y1)
pyl.show()

数据板块作业：

image.png

数据探索与清洗

数据探索核心：

数据质量分析（跟数据清洗密切联系）
数据特征分析（分布，对比，周期性，相关性，常见统计量）

数据清理的步骤

先看数据有无缺失，describe统计所有有值的数据，len可以统计出没有值的数据，两者相对比。或者通过0数据发现缺失值（一些价格等数据不会为0，评论数这些可以不为0）
插补方式：均值

image.png

#导入数据
import pymysql
import numpy as npy
import pandas as pda
import matplotlib.pylab as pyl
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="root",db="csdn")
sql="select*from taob"
data=pda.read_sql(sql,conn)
print(data.describe())
#数据清洗
#发现缺失值
#price字段有缺失，利用插补法处理（36是中位数）
x=0
data["price"][(data["price"]==0)]=None #在price这个标签里面只要里面的内容=0，就赋值为空
for i in data.columns:
    for j in range(len(data)):
        if(data[i].isnull())[j]:
            data[i][j]="36"
            x+=1
print(x)
#异常值处理，画散点图（纵轴用评论数，横轴用价格）
#得到价格
data2=data.T
price=data2.values[2]
#得到评论数据
comt=data2.values[3]
pyl.plot(price,comt,'o')
pyl.show
#异常值处理（评论数异常200000以上，价格异常大于2300）
line=len(data.values)  #取出的是行数，data.values有所有的，加len得到行数
col=len(data.values[0]) #第0行加len，拿到列数
da=data.values
for i in range(0,line):
    for j in range(0,col):
        if(da[i][2]>2300):
            print(da[i][j])
            da[i][2]="36"
        if(da[i][3]>20000):
            print(da[i][j])
            da[i][2]="58"
da2=da.T
price=da2[2]
comt=da2[3]
pyl.plot(price,comt,'0')
pyl.show()
#分布分析
#得到价格的最大值最小值
pricemax=da2[2].max() #(价格是在第二行)
pricemin=da2[2].min()
#评论的最大值最小值
commentmax=da2[3].max() #(评论是在第三行)
commentmin=da2[3].min()
#极差：最大值-最小值
pricerg=pricemax-pricemin
commentrg=commentmax-commentmin
#组距：极差/组数（自己随便定）
pricedst=pricerg/12
commentdst=commentrg/12
#画出价格的直方图
pricesty=npy.arange(pricemin,pricemax,pricedst)
pyl.hist(da2[2],pricesty)
pyl.show()
#画出评论的直方图
commentsty=npy.arange(commentmin,commentmax,commentdst)
pyl.hist(da2[3],commentsty)
pyl.show()

数据集成

image.png

同名不同意（一张表title代表商品，另一张表title不代表商品）
同意不同名

image.png

数据规约

简单变换

image.png
数据规范化

image.png

离差标准化：消除单位影响

import pymysql
import pandas as pda
import numpy as npy
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="root",db="csdn")
sql="select price,comment from taob"
data=pda.read_sql(sql,conn)
#离差标准化 直接使用data2处理就可以了
data2=(data-data.min())/(data.max()-data.min())
print(data2)
#标准差标准化(也叫零-均值标准化)：有正负，一半一半，他们的平均数为0，标准差为1
data3=(data-data.mean())/data.std()
print(data3)
#小数定标规范化
k=npy.ceil(npy.log10(data.abs().max())) #ceil是取整数（3.1取到4，3.6取到4）
data4=data/10**k

离散化（将连续数据变成离散数据，把0-10的数据归为一类，10-20归为一类）

等宽离散化（将属性的值分为具有相同宽度的区间）
等频率离散化（相同数量的记录放进去，把相同频率的点放在一个区间）
一维聚类离散化（将属性的值先用聚类算法）

#连续性数据离散化
#等宽离散化
data5=data[u"price"].copy() #拷贝一份，加u固定数据
data6=data5.T
data7=data6.values
#cut 函数
# pda.cut(data,k,label=["便宜","适中","有点贵","天价"])
#k等分为几分，如果k=4，四份；也可以用数组[3,6,10,19]，label每个区域的标签名字
k=3
c1=pda.cut(data7,k,label=["便宜","适中","有点贵"])
print(c1)
#非等宽离散化
k=[0,50,100,300,500,2000,data7.max()]
c2=pda.cut(data7,k,label=["非常便宜","便宜","适中","有点贵","很贵","非常贵"])
print(c2)

属性构造

例如根据一个博客的评论数和点击数，构造一个点评比等

#属性构造
import pymysql
import pandas as pda
import numpy as npy
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="root",db="hexun")
sql="select * from myhexun"
data8=pda.read_sql(sql,conn)
print(data8)
ch=data8[u"comment"]/data8[u"hits"]
data[u"评点比"]=ch
#把这个评点比写进文件
file="./hexun.xls"
data8.to_excel(file,index=False)#索引index=无

规约

规约=精简

属性规约（采用降维度，丢掉一些属性）
数值规约（化范围0-100,100-200）

主成分分析

主要用来属性规约
PCA算法（主要用来属性降维，在尽量保持数据本质的情况下将数据维数降低，将n维特征映射到K维上，k是有正交特征，k维特征也称为组元）

#属性构造
import pymysql
import pandas as pda
import numpy as npy
from sklearn.decomposition import PCA
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="root",db="hexun")
sql="select hits,comment from myhexun"
data9=pda.read_sql(sql,conn)
print(data9)
ch=data9[u"comment"]/data9[u"hits"]
data[u"评点比"]=ch
#主成分分析进行中
pca1=PCA()
pca1.fit(data9) #利用pca来处理data9
Characteristic=pca1.components #返回模型中各个特征向量
print(Characteristic)
#各个成分中各自方差的百分比，贡献率
rate=pca1.explained_variance_ratio_
print(rate)
#主成分分析
pca2=PCA(2) #()内为希望的维数
pca2.fit(data9)
reduction=pca2.transform(data9) #降维
print(reduction)
recovery=pca2.inverse_transform(reduction) #对其还原
print(recovery)

文本挖掘

跟数据有关
遇到的问题：由于目标计算机积极拒绝，无法连接

一般txt不能分析的话，新建一个txt另存为utf-8，如果还是不行，存为一个html网页用urllib爬出来，在读取

import jieba
sentence="我喜欢上海东方明珠"
w1=jieba.cut(sentence,cut_all=True)#第一个参数要分词的话，第二个参数：分词模式：全模式（分词很全，可能叠加）
#遇到generator要用循环把他变出
for item in w1:
    print(item)
'''
#把cut_all改成false 精准模式(根据优先级)
w2=jieba.cut(sentence,cut_all=False)
for item in w2:
    print(item)

#第三种 搜索引擎模式(利用搜索引擎的原理)
w3=jieba._lcut_for_search(sentence)
for item in w3:
    print(item)

#默认的分词模式(默认采用精准模式)
w4=jieba.cut(sentence)
for item in w4:
    print(item)

#词性标注 利用posseg方法

import jieba.posseg
w5=jieba.posseg.cut(sentence)
#.flag词性
#.word词语
for item in w5:
    print(item.word+"---"+item.flag)
'''
'''
a：形容词 
c：连词
d：副词
e：叹词
f：方位语
i：成语
m：数词
n：名词
nr：人名
ns：地名
nt：机构团体
nz：其他专有名词
p：介词
r：代词
t:时间
u：助词
v：动词
vn：名动词
w：标点符号
un：未知词语
'''
'''
#新建词典之后，词典加载（新加词典记得更改为utf-8）
jieba.load_userdict("") #新加的词典目录,不是持久化存储的，每一个需要添加一次
sentence2="天善智能是一个很好的机构"
w6=jieba.posseg.cut(sentence2)
for item in w6:
    print(item.word+"---"+item.flag)

#更改词频，两种方式
sentence="我喜欢上海东方明珠"
w7=jieba.cut(sentence)
for item in w7:
    print(item)
#发现上海，东方是两个词语，我们想要得到上海东方，结合在一起
#add_word把词语添加在字典中，我们要修改词频(有点问题)
jieba.suggest_freq("上海东方",True)
w8=jieba.cut(sentence)
for item in w8:
    print(item)


#返回文本中词频高的词语，关键词
import jieba.analyse
sentence3="我喜欢上海东方明珠"
tag=jieba.analyse.extract_tags(sentence3,3) #第二个参数，提取词频高的前几个参数，默认20个
print(tag)

#返回词语的位置
w9=jieba.tokenize(sentence)
for item in w9:
    print(item)

#以搜索引擎的模式来返回词语的位置
w10=jieba.tokenize(sentence,mode="search")
for item in w10:
    print(item)
'''

#分析血尸的词频,一开始无法打开，加上utf-8还无法打开之后
#直接新建一个文本文档，全部复制过去，另存为的时候调为utf-8
#编码问题解决方案
import urllib.request
data=urllib.request.urlopen("http://127.0.0.1/dmbj.html").read.decode("utf-8","ignore")
tag=jieba.analyse.extract_tags(data,20)
print(tag)

Mysql爬虫补充

spider dangdang代码部分(注意Dangdangitem包的引用)

# -*- coding: utf-8 -*-
import scrapy
from scrapy.http import Request

from dangdang.dd.items import DangdangItem


class DdSpider(scrapy.Spider):
    name = "dd"
    allowed_domains = ["dangdang.com"]
    start_urls = (
        'http://www.dangdang.com/',
    )

    def parse(self, response):
        item=DangdangItem()
        item["title"]=response.xpath("//a[@class='pic']/@title").extract()
        item["link"] = response.xpath("//a[@class='pic']/@href").extract()
        item["comment"] = response.xpath("//a[@name='itemlist-review']/text()").extract()

        yield item
        for i in range(2,101):
            url="http://category.dangdang.com/pg"+str(i)+"-cp01.54.06.00.00.00.html"
            yield Request(url,callback=self.parse)

pipeline代码部分

# -*- coding: utf-8 -*-
import pymysql
# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: http://doc.scrapy.org/en/latest/topics/item-pipeline.html


class DangdangPipeline(object):
    def process_item(self, item, spider):
        conn = pymysql.connect(host="127.0.0.1", user="root", passwd="123456", db="dd")
        for i in range(0,len(item["title"])):
            title=item["title"][0]
            link=item["link"][0]
            comment=item["comment"][0]
#编码的问题解决方案
            conn.set_charset("utf8")
            cursor=conn.cursor()
            cursor.execute('SET NAMES utf8;')
            cursor.execute('SET CHARACTER SET utf8;')
            cursor.execute('SET character_set_connection=utf8;')
#sql插入的格式
            sql="insert into goods(title,link,comment) values('"+title+"','"+link+"','"+comment+"')"
            conn.query(sql)
            conn.commit()
        conn.close()
        return item

Navicat用法：
crtl+s 保存退出

Mysql基本的语句：
进入：F:\MySQL\mysql-5.7.20-winx64\bin>mysql -u root -p
mysql> use dd
Database changed
mysql> select * from goods（映射goods表内所有的内容）
sql语句中输入的时候想要退出；+enter

反思：耐心看cmd里面的error

文本相似度分析

TF-IDF：用来评估一个词对于文件的
重要性。与出现的次数成正比，用来相似度的计算。

稀疏向量和稀疏矩阵

相似度分析的步骤

image.png

#文本相似度计算，以词语为单位，分词
from gensim import corpora,models,similarities
import  jieba
from collections import  defaultdict
#1 得到文档的内容
doc1="F:/Python/test/peter/d1.txt"
doc2="F:/Python/test/peter/d2.txt"
d1=open(doc1).read()
d2=open(doc2).read()
#2 分词
data1=jieba.cut(d1)
data2=jieba.cut(d2)
#3 整理为指定格式"词语1 词语2 词语3....词语n"整理成这种格式
data11=""
for item in data1:
    data11+=item+" "
data21=""
for item in data2:
    data21+=item+" "
#如果有第三个文档直接加在后面就行
documents=[data11,data21]
#4 计算词语的频率（没看懂）
texts=[[word for word in document.split()]
        for document in  documents]
frequency=defaultdict(int)
for text in texts:
    for token in text:
        frequency[token]+=1
#5 过滤掉部分低频词汇
texts=[[word for word in text if frequency[token]>=1]
for text in texts]
#6 建立词典
dictionary=corpora.Dictionary(texts)
dictionary.save("F:/Python/test/peter/wenben2.dict")
#7 加载要对比的文档
doc3="F:/Python/test/peter/d3.txt"
d3=open(doc3).read()
data3=jieba.cut(d3)
data31=""
for item in data3:
    data31+=item+" "
new_doc=data31
#8 变为稀疏向量，可以直接使用doc2bow
new_vec=dictionary.doc2bow(new_doc.split())
#9 依据稀疏向量进一步处理得到语料库
corpus=[dictionary.doc2bow(text) for text in texts]
#10 通过models处理,得到tfidf
tfidf=models.TfidfModel(corpus)
corpora.MmCorpus.serialize("F:/Python/test/peter/d3.mm",corpus)
#11 通过tfidf得到特征向量
featureNum=len(dictionary.token2id.keys())
#12 稀疏矩阵相似度，建立索引
index=similarities.SparseMatrixSimilarity(tfidf[corpus],num_features=featureNum)
sim=index[tfidf[new_vec]]
print(sim)

image.png

从后到左，从后往前

目前的问题

pca 稀疏向量 127.0.0.1

Python数据建模

image.png

模型的建立依赖算法

Python数据分类实现过程

image.png

常见的分类算法

image.png

KNN算法

总的原则：物以类聚，人以群分。判断这一个事情的特征进行分类。

计算所有点到M点的距离，找出距离最近的点，KNN（中的k是指选择几个点，k=4，选择最近的4个点，图中选出cbgn，看哪个类别占的越多，就把他归为那一类）

knn算法实现步骤

处理数据
数据向量化
计算欧几里得距离
按照距离分类

from numpy import *
import operator
def knn(k,testdata,traindata,labels):
    traindatasize=traindata.shape[0] #取到行数，1取列数
    dif=tile(testdata,(traindatasize,1))-traindata#转换维度（范本有四个点，这边让他变成4个点）计算出差值
    #对已经存在的数组进行维度拓展，tile（要拓展的数组，重复多少次）
    #从纵方向拓展tile(a,(size,1)) 改成1，size是重复几次

    #计算差值平方
    sqdif=dif**2

    sumsqdif=sqdif.sum(axis=1) #每一行求和
    distance=sumsqdif**0.5
    sortdistance=distance.argsort() #排序，他的结果是每一位的序号
    count={}
    for i in range(0,k):
        vote=labels[sortdistance[i]]  #labels相当于一个字典
        count[vote]=count.get(vote,0)+1
    sortcount=sorted(count.items(),key=operator.itemgetter(1),revers=True)#reverse=true 降序
    sortcount[0][0]

参考文章
https://www.cnblogs.com/ybjourney/p/4702562.html

手写体数字的识别

读取每个像素，如果是黑色的就用数字1表示在这个像素上面
利用pillow模块处理模块

from numpy import *
import operator
def knn(k,testdata,traindata,labels):
    traindatasize=traindata.shape[0] #取到行数，1取列数
    dif=tile(testdata,(traindatasize,1))-traindata#计算出差值
    #对已经存在的数组进行维度拓展，tile（要拓展的数组，重复多少次）
    #从纵方向拓展tile(a,(size,1)) 改成1，size是重复几次

    #计算差值平方
    sqdif=dif**2

    sumsqdif=sqdif.sum(axis=1) #每一行求和
    distance=sumsqdif**0.5
    sortdistance=distance.argsort() #排序，他的结果是每一位的序号
    count={}
    for i in range(0,k):
        vote=labels[sortdistance[i]]  #labels相当于一个字典
        count[vote]=count.get(vote,0)+1
    sortcount=sorted(count.items(),key=operator.itemgetter(1),revers=True)#reverse=true 降序
    sortcount[0][0]


#图片处理
#先将所有图片转化为固定宽高(用图片软件就行)，然后再转化为文本
from PIL import Image
from numpy import *
from os import listdir
im=Image.open("C:/Users/me/Pictures/weixin3.jpg")#图片地址
fh=open("C:/Users/me/Pictures/weixin3.txt","a") #追加的模式
im.save("C:/Users/me/Pictures/weixin.bmp") #保存为一个新的图片
width=im.size[0]#图片宽和高size[0] 宽
height=im.size[1]
k=im.getpixel((1,9)) #获取像素（那个坐标点）颜色
#例如返回RGB(255，255，255)，白色的，加入三者之和为0，则黑色
for i in range(0,width):
    for j in range(0,height):
        cl=im.getpixel((i,j))
        clall=cl[0]+cl[0]+cl[0]
        if(clall==0):
            #黑色
            fh.write("1")
        else:
            fh.write("0")
    fh.write("\n")
fh.close()
#加载数据
def datatoarray(fname):
    arr=[]
    fh=open(fname)
    for i in range(0,32):
        thisline=fh.readline()
        for j in range(0,32):
            arr.append(int(thisline[j]))
    return arr
#建立一个函数取文件前缀
def seplabel(fname):
    filestr=fname.split(".")[0]
    label=int(filestr.split(".")[0])
    return label
#建立训练数据
def traindata():
    labels=[]
    #listdir("文件夹名字")可以的到一个文件夹下所有的文件名
    trainfile=listdir("")
    num=len(trainfile)
    #行的长度为1024（列），每一行存储一个文件
    #用一个数组存储所有的训练数据，行：文件总数，列：1024
    #zeros((2,5))生成两行五列的0
    trainarr=zeros((num,1024)) #相当于一个初始化
    for i in range(0,num):
        thisfname=trainfile[i]
        thislabel=seplabel(thisfname)
        labels.append(thislabel)
        trainarr[i,:]=datatoarray("traindata/"+thisfname) #理解为为i行上写上以下的的内容
    return trainarr,labels
#用测试数据调用KNN算法去测试，看是否能够准确识别
def datatest():
    trainarr,labels=traindata() #拿到训练集
    testlist=listdir("testdata")
    tnum=len(testlist)
    for i in range(0,tnum):
        thistestfile=testlist[i] #得到当前测试文件
        testarr=datatoarray("testdata/" + thistestfile)
        rknn = knn(3, testarr, trainarr, labels)
        print(rknn)
datatest()

#抽某一个测试文件出来进行试验
trainarr,labels=traindata()
thistestfile=""
testarr=datatoarray(""+thistestfile)
rknn=knn(3,testarr,trainarr,labels)
print(rknn)

逻辑回归

做不出来，可能是sklearn包有问题导致的

"""  
'''''1. data1 是40名癌症病人的一些生存资料， 
其中，X1表示生活行动能力评分（1~100）， 
X2表示病人的年龄，X3表示由诊断到直入研究时间（月）； 
X4表示肿瘤类型，X5把ISO两种疗法（“1”是常规，“0”是试验新疗法）； 
Y表示病人生存时间（“0”表示生存时间小于200天， 
“1”表示生存时间大于或等于200天） 
试建立Y关于X1~X5的logistic回归模型'''  
#######################################################  
#读取整理数据  
import pandas as pd  
from sklearn.linear_model import LogisticRegression as LR  
from sklearn.linear_model import RandomizedLogisticRegression as RLR   
data=pd.read_table('data1.txt',encoding='gbk')  
data  
x=data.iloc[:,1:6].as_matrix()  
y=data.iloc[:,6].as_matrix()  
rlr = RLR() #建立随机逻辑回归模型，筛选变量  
rlr.fit(x, y) #训练模型  
rlr.get_support() #获取特征筛选结果，也可以通过.scores_方法获取各个特征的分数  
print(u'通过随机逻辑回归模型筛选特征结束。')  
print(u'有效特征为：%s' % ','.join(data.columns[rlr.get_support()]))  
x = data[data.columns[rlr.get_support()]].as_matrix() #筛选好特征  
  
lr = LR() #建立逻辑回归模型  
lr.fit(x, y) #用筛选后的特征数据来训练模型  
print(u'逻辑回归模型训练结束。')  
print(u'模型的平均正确率为：%s' % lr.score(x, y)) #给出模型的平均正确率，本例为0.75

贝叶斯算法

image.png

import numpy
class Bayes:
    def _init_(self): #初始化这个类，最开始执行
        #初始化参数length
        self.length=-1 #length=-1 表示未经过训练，如果经过训练肯定是有数据的则大于等于0
        self.labelcount=dict()
        self.vectorcount=dict()
    def fit(self,dataSet:list,labels:list): #数据集，标签集
        if(len(dataSet)!=len(labels)):
            raise ValueError("输入的测试数组与类别数组长度不一致")
        self.length=len(dataSet[0]) #测试数据特征值的长度
        labelsnum=len(labels) #得到所有类别的数量
        norlabels=set(labels) #得到不重复类别的数量
        for item in norlabels:
            thislabel=item #得到当前类别,看当前类别一共有多少的数据
            self.labelcount[thislabel]=labels.count(thislabel)/labelsnum #求当前类别占总数的比例
        for vector,label in zip(dataSet,labels): #相当于是两个一起的循环 例如 [[A,100010].[B.110001]]的循环
            if(label not in self.vectorcount): #一开始为空，只要不在都往里面填入，但不要重复的，就可以写成 [A,100010,100011] [B,101000]
                self.vectorcount[label]=[]
            self.vectorcount[label].append(vector)
            print("训练结束")
            return  self
    def btest(self,TestData,labelsSet):
        if(self.length==-1):
            raise ValueError("还未训练")
        #计算当前testdata分别为各个类别的概率
        IbDict=dict()
        for thisIb in labelsSet:
            p=1
            alllabel=self.labelcount[thisIb] #先求出这个标签的总占比
            allvector=self.vectorcount[thisIb] #拿到这个标签对应的数据[A,100010,100011] ([B,101000]这个就没有了)
            vnum=len(allvector) #数据集的个数
            allvector=numpy.array(allvector).T
            for index in range(0,len(TestData)):
                vector=list(allvector[index])
                p*=vector.count(TestData[index])/vnum #相当于+= 累乘
            IbDict[thisIb]=p*alllabel
        thislabel=sorted(IbDict,key=lambda x:IbDict[x],reverse=True)[0]
        return thislabel

决策树算法

ID3 看信息的价值
C4.5
CART

信息熵的计算
log以2为底
去分析得到信息增益

import pandas as pda
from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO
from sklearn.tree import DecisionTreeClassifier as DTC
fname="F:/Python/code/code/8/xiaoliang.csv"
dataf=pda.read_csv(fname,encoding="gbk")
x=dataf.iloc[:,1:5].as_matrix()
y=dataf.iloc[:,5].as_matrix()
#遍历x这个二维数组
for i in range(0,len(x)):
    for j in range(0,len(x[i])):
        thisdata=x[i][j]
        if(thisdata=="是" or thisdata=="多" or thisdata=="高"):
            x[i][j]=int(1)
        else:
            x[i][j] = -1
for i in range(0,len(y)):
    thisdata=y[i]
    if(thisdata=="高"):
        y[i]=1
    else:
        y[i]=-1
"""
#容易错的地方： 如下直接使用
#建立决策树
from sklearn.tree import DecisionTreeClassifier as DTC
dtc=DTC(criterion="entropy") #将参数设置为信息熵的模式
dtc.fit(x,y) #此时训练就会出错，y是一维而且不是数字类型
"""
#正确的做法：转化好格式，将x，y转化为数据框，然后再转化为数组并指定格式
xf=pda.DataFrame(x) #把数据转化为数据框
yf=pda.DataFrame(y)
x2=xf.as_matrix().astype(int) #指定形式和格式，不让他们有那个type=object
y2=yf.as_matrix().astype(int)
dtc=DTC(criterion="entropy")
dtc.fit(x2,y2)
#可视化决策树
with open("F:/Python/code/code/8/dtc.dot","w") as file:  #打开建立这个文件
    export_graphviz(dtc,feature_names=["combat","num","promotion","datum"],out_file=file)#（决策树的名称，特征的名称,out_file=指定输出文件）

#利用程序直接预测销量高低，格式要保持与x2一致，构建一个二维数组
x3=npy.array([1,-1,-1,1],[1,1,1,1],[-1,1,-1,1])
result=dtc.predict(x3)
print(result)

决策树往左看是负能量，往右看是正能量
如图promotion【8，3】说明8个没有促销，3个有
信息熵表示信息增益，越大表示占越大权重，更有用

image.png

聚类

指定聚类的个数，自动将数据分为那么多类。

聚类三法

划分法（主要利用划分的方法聚类）、层次分析法（从上到下，从下到上两种）、密度分析法（观察数据密度，大于某个阈值，比较好的）、网格法、模型法。

kmeans算法属于划分法。
k个点就表示k类别

kmeans的步骤

image.png


#通过程序实现对录取学生的聚类
#通过程序实现淘宝商品的聚类
import numpy as npy
from sklearn.cluster import  Birch
from sklearn.cluster import KMeans
import pandas as pda
import matplotlib.pylab as pyl
fname="F:/Python/code/code/8/luqu2.csv"
dataf=pda.read_csv(fname)
x=dataf.iloc[:,1:4].as_matrix()
kms=KMeans(n_clusters=4,n_jobs=2,max_iter=500) #（指定聚类的个数,指定线程数，最大的循环次数）
y=kms.fit_predict(x)
print(y) #y为多少表示为在第几类
#画图 x代表学生序号 y代表学生类别
s=npy.arange(0,len(y))
pyl.plot(s,y,"o")
pyl.show()
#商品的聚类
import pymysql
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="root",db="tb")
sql="select price,comment from goods limit 30" #选择读出的字段，从哪个表，限制读出来的数量
dataf=pda.read_sql(sql,conn)
x=dataf.iloc[:,:].as_matrix()
kms=KMeans(n_clusters=3) #（指定聚类的个数,指定线程数，最大的循环次数）
y=kms.fit_predict(x)
print(y) #y为多少表示为在第几类
for i in range(0,len(y)):
    if(y[i]==0):  #绘制第0类
        pyl.plot(dataf.iloc[i:i+1,0].as_matrix(),dataf.iloc[i:i+1,1].as_matrix(),"*r")
    elif(y[i]==1):
        pyl.plot(dataf.iloc[i:i+1,0].as_matrix(),dataf.iloc[i:i+1,1].as_matrix(),"sy")
    elif(y[i]==2):
        pyl.plot(dataf.iloc[i:i+1,0].as_matrix(),dataf.iloc[i:i+1,1].as_matrix(),"pk")
pyl.show()

贝叶斯应用

import numpy
from numpy import *
from os import listdir
import numpy as npy
class Bayes:
    def __init__(self): #初始化这个类，最开始执行(四个杠，不要写错)
        #初始化参数length
        self.length=-1 #length=-1 表示未经过训练，如果经过训练肯定是有数据的则大于等于0
        self.labelcount=dict()
        self.vectorcount=dict()
    def fit(self,dataSet:list,labels:list): #数据集，标签集
        if(len(dataSet)!=len(labels)):
            raise ValueError("输入的测试数组与类别数组长度不一致")
        self.length=len(dataSet[0]) #测试数据特征值的长度
        labelsnum=len(labels) #得到所有类别的数量
        norlabels=set(labels) #得到不重复类别的数量
        for item in norlabels:
            thislabel=item #得到当前类别,看当前类别一共有多少的数据
            self.labelcount[thislabel]=labels.count(thislabel)/labelsnum #求当前类别占总数的比例
        for vector,label in zip(dataSet,labels): #相当于是两个一起的循环 例如 [[A,100010].[B.110001]]的循环
            if(label not in self.vectorcount): #一开始为空，只要不在都往里面填入，但不要重复的，就可以写成 [A,100010,100011] [B,101000]
                self.vectorcount[label]=[]
            self.vectorcount[label].append(vector)
        print("训练结束")
        return self
    def btest(self,TestData,labelsSet):
        if(self.length==-1):
            raise ValueError("还未训练")
        #计算当前testdata分别为各个类别的概率
        IbDict=dict()
        for thisIb in labelsSet:
            p=1
            alllabel=self.labelcount[thisIb] #先求出这个标签的总占比
            allvector=self.vectorcount[thisIb] #拿到这个标签对应的数据[A,100010,100011] ([B,101000]这个就没有了)
            vnum=len(allvector) #数据集的个数
            allvector=numpy.array(allvector).T
            for index in range(0,len(TestData)):
                vector=list(allvector[index])
                p*=vector.count(TestData[index])/vnum #相当于+= 累乘
            IbDict[thisIb]=p*alllabel
        thislabel=sorted(IbDict,key=lambda x:IbDict[x],reverse=True)[0]
        return thislabel
#加载数据
def datatoarray(fname):
    arr=[]
    fh=open(fname)
    for i in range(0,32):
        thisline=fh.readline()
        for j in range(0,32):
            arr.append(int(thisline[j]))
    return arr
#建立一个函数取文件前缀
def seplabel(fname):
    filestr=fname.split(".")[0]
    label=int(filestr.split("_")[0])
    return label
#建立训练数据
def traindata():
    labels=[]
    #listdir("文件夹名字")可以的到一个文件夹下所有的文件名
    trainfile=listdir("F:/Python/code/code/7/testandtraindata/traindata")
    num=len(trainfile)
    #行的长度为1024（列），每一行存储一个文件
    #用一个数组存储所有的训练数据，行：文件总数，列：1024
    #zeros((2,5))生成两行五列的0
    trainarr=zeros((num,1024)) #相当于一个初始化
    for i in range(0,num):
        thisfname=trainfile[i]
        thislabel=seplabel(thisfname)
        labels.append(thislabel)
        trainarr[i,:]=datatoarray("F:/Python/code/code/7/testandtraindata/traindata/"+thisfname) #理解为为i行上写上以下的的内容
    return trainarr,labels
bys=Bayes()
#训练数据
train_data,labels=traindata()
bys.fit(train_data,labels)
#测试
thisdata=datatoarray("F:/Python/code/code/7/testandtraindata/traindata/8_90.txt")
labelsall=[0,1,2,3,4,5,6,7,8,9]
#识别单个手写体数字
'''
result=bys.btest(thisdata,labelsall)
print(result)
'''
#识别多个手写体数字
testfileall=listdir("F:/Python/code/code/7/testandtraindata/testdata")
num=len(testfileall)
for i in range(0,num):
    thisfilename=testfileall[i] #得到当前文件名
    thislabel=seplabel(thisfilename)
    thisdataarray=datatoarray("F:/Python/code/code/7/testandtraindata/testdata/"+thisfilename)
    label=bys.btest(thisdataarray,labelsall)
    #print("该数字是："+str(thislabel)+",识别出来的是"+str(label))
    #计算错误率
    x=0
    if (label!=thislabel):
        x+=1
print(x)
print("错误率是：",str(float（x）/float（num))

人工神经网络

在分类用的很多

BP神经网络：会根据误差做一些计算，如图第一层两个节点（输入层），第二层五个节点（隐藏层），第三层一般只有一个节点（输出层）。每一个输入层的点在第二层进行计算，权值变动=学习率误差输出

人工神经网络实战

一些问题：

1、The nb_epoch argumenthas been renamed epochs everywhere.所以神经网络的训练次数需要用epochs来定义，不再是nb_epoch 。
以前写法：
model.fit(X_train, y_train,validation_data=(X_test, y_test), nb_epoch=69, batch_size=200, verbose=2)
正确写法：
model.fit(X_train, y_train,validation_data=(X_test, y_test), epochs=69, batch_size=200, verbose=2)
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
image.png

课程销量预测代码

#bp人工神经网络的实现
#1.读取数据
#2.keras.models Sequential （建立模型）/keras.layer.core 下面的Dense Activation(添加激活函数)主要建立输入层和输出层
#3.sequential建立模型
#4.dense建立层
#5.activation激活函数
#6.compile模型编译
#7.fit训练（学习）
#8.验证（测试，分类预测）

#读取数据
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import pandas as pda
fname="/Users/yuanxin/Desktop/lesson.csv"
dataf=pda.read_csv(fname,encoding="gbk")
x=dataf.iloc[:,1:5].as_matrix()
y=dataf.iloc[:,5].as_matrix()
for i in range(0,len(x)):
    for j in range(0,len(x[i])):
        thisdata=x[i][j]
        if(thisdata=="是" or thisdata=="多" or thisdata=="高"):
            x[i][j]=int(1)
        else:
            x[i][j]=0
for i in range(0,len(y)):
    thisdata=y[i]
    if(thisdata=="高"):
        y[i]=1
    else:
        y[i]=0
#下面四行是一个固定的套路，需要转化好格式，前两步将x，y转化为数据框，然后两步转化为数组并指定格式
xf=pda.DataFrame(x)
yf=pda.DataFrame(y)
x2=xf.as_matrix().astype(int)
y2=yf.as_matrix().astype(int)

#利用人工神经网络模型
from keras.models import Sequential
from keras.layers.core import Dense,Activation
model=Sequential()
model.add(Dense(10,input_dim=4)) #第一个表示输入层数，一般没什么要求；inputdim代表有多少个特征
model.add(Activation("relu"))#用acti建立激活函数,relu这个函数准确率比较高
#上面做完了输入层 现在做输出层
#输出层
model.add(Dense(1,input_dim=1))  #一般输出的话就用一个输出层,特征就一个
model.add(Activation("sigmoid")) #因为结果是二元的，所以我们用二元分类sigmod
#模型的编译
model.compile(loss="binary_crossentropy",optimizer="adam") #loss是损失函数，一般二元的就用这种;optimizer求解方法，常用adam；
#训练
model.fit(x2,y2,epochs=1000,batch_size=100) #epochs 学习的次数,batch_size?
#预测分类
rst=model.predict_classes(x).reshape(len(x))
x=0
for i in range(0,len(x2)):
    if(rst[i]!=y[i]):  #跟原来的结果做比较
        x+=1
print(1-x/len(x2))
import numpy as npy
x3=npy.array([[1,-1,-1,1],[1,1,1,1],[-1,1,-1,1]])
rst=model.predict_classes(x3).reshape(len(x3))
print("其中第一门课的预测结果为:"+str(rst[0]))

手写体识别代码

#使用人工神经网络实现手写体数字识别
#数据的读取与整理
#加载数据
from numpy import *
import operator
from os import listdir
import numpy as npy
import pandas as pda
import numpy
def datatoarray(fname):
    arr=[]
    fh=open(fname)
    for i in range(0,32):
        thisline=fh.readline()
        for j in range(0,32):
            arr.append(int(thisline[j]))
    return arr
#建立一个函数取文件名前缀
def seplabel(fname):
    filestr=fname.split(".")[0]
    label=int(filestr.split("_")[0])
    return label
#建立训练数据
def traindata():
    labels=[]
    trainfile=listdir("/Users/yuanxin/Desktop/traindata/")
    num=len(trainfile)
    #长度1024（列），每一行存储一个文件
    #用一个数组存储所有训练数据，行：文件总数，列：1024
    trainarr=zeros((num,1024))
    for i in range(0,num):
        thisfname=trainfile[i]
        thislabel=seplabel(thisfname)
        labels.append(thislabel)
        trainarr[i,:]=datatoarray("/Users/yuanxin/Desktop/traindata/"+thisfname)
    return trainarr,labels
trainarr,labels=traindata()
#固定格式用
xf=pda.DataFrame(trainarr)  #先转成数据框
yf=pda.DataFrame(labels)
tx2=xf.as_matrix().astype(int) #转成数组
ty2=yf.as_matrix().astype(int)

#使用人工神经网络模型
from keras.models import Sequential
from keras.layers.core import Dense,Activation
model=Sequential()
#输入层
model.add(Dense(10,input_dim=1024))
model.add(Activation("relu"))
#输出层
model.add(Dense(1,input_dim=1))
model.add(Activation("sigmoid"))
#模型的编译
model.compile(loss="mean_squared_error",optimizer="adam")
#训练
model.fit(tx2,ty2,nb_epoch=10000,batch_size=6)
#预测分类
rst=model.predict_classes(tx2).reshape(len(tx2))
x=0
for i in range(0,len(tx2)):
    if(rst[i]!=ty2[i]):
        x+=1
print(1-x/len(tx2))

输入层的层数无所谓
输出层可以根据数据量一般也就是10层

Apriori算法

关联分析：分析出关联性比较大的商品。
可以在超市里面把关联性高的商品摆放在一起。
Apriori也是一种关联性分析的算法。
Apriori中：

支持度：两件事物同时发生的概率 Support（A=>B）=P（A and B）
置信度：若A发生，B发生的概率 Confidence（A=>B）=P（B|A）

Apriori算法的实现：

设定阈值：最小支持度，最小置信度
计算，置信度和支持度。支持度利用发生的频率去除概率。

image.png
筛选
继续计算

关于series的解释

https://www.cnblogs.com/sirkevin/p/5741853.html

课程关联性代码

#计算学员购买课程的关联性
from apriori import *
import pandas as pda
import xlrd
filename="/Users/yuanxin/Desktop/lesson_buy.xls"
dataframe=pda.read_excel(filename,header=None) #header=none表示没有表头
print(dataframe)
dataframe1=dataframe.as_matrix()
print(dataframe1)
#转化一下数据（因为有中文汉字不好分析，所以要转化成矩阵）
change=lambda x:pda.Series(1,index=x[pda.notnull(x)])
#理解为依次去作为索引，先让java为索引去查，有的就置1，然后是php去查，有置为1.根据字母顺序来做的索引
#lamda是指 给一个数据x，他按照转换规则给出数据。规则（有数据为1）
mapok=map(change,dataframe.as_matrix())
data=pda.DataFrame(list(mapok)).fillna(0)
print(data)

#临界支持度、置信度设置
spt=0.2
cfd=0.5

#使用apriori算法计算关联结果
find_rule(data,spt,cfd)

自己电脑python环境的一些问题以及解释

pycharm也是可以直接下载包的，终端的pip3 install是为idle服务，而不是为pycharm。http://www.360doc.com/content/16/0827/13/35922414_586284807.shtml
idle增添源文件的方法，找到路径直接放进去。

import sys
>>> print(sys.path)
['/Users/yuanxin/Desktop', '/Users/yuanxin/Documents', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages']

新浪微博的几种爬虫方式

接口
传统爬虫

charles抓包
http://blog.csdn.net/u010187139/article/details/51986854

https:一般会是unknown 抓不到https的，在这里面添加设置

image.png

下图是可以只抓取特定的网站以及除了什么网站之外都抓。格式
" *.baidu.com "

image.png

一个新的知识点，布隆比较器。（很轻易检查容器类是否有重复的东西）http://blog.csdn.net/jiaomeng/article/details/1495500

phantomjs

安装selenium，可以利用python操作phantomjs这个

Python

入门基础

如何学好编程

基础部分：

进阶提高：

基本语法

数据结构

输入输出

异常

Python 语法基础

注释法

print("")

Python控制流

中断结构

输出乘法口诀：

逆向乘法口诀作业

Python函数详解

局部变量与全局变量

函数的定义与调用

函数的参数

Python的模块

模块的导入

自定义模块

文件操作概述

Python异常处理

open(路径+文件名,读写模式)

读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件.常用模式

爬虫初识

网络爬虫原理

正则表达式

元字符

学到模式修正符

模式修正符：

贪婪模式，懒惰模式

正则表达式函数

第二次作业爬取图书馆

Urllib库实战

超时测试：

自动模拟http请求

post

爬虫异常处理

浏览器伪装技术

爬新闻程序

第三次作业

爬虫防屏蔽手段之代理服务器

图片爬虫

第四次作业爬取千图网

Python抓包分析

腾讯视频评论的抓取

微信爬虫

多线程爬虫

Scrapy框架

Scrapy框架常见命令实战

一些文件功能

第一个scrapy爬虫

XPath表达式（适合用标签的）

Scrapy自动爬虫

自动登录

当当网爬取

补充内容

快速了解数据分析与数据挖掘技术

数据挖掘的步骤

数据挖掘相关模块

相关模块的基本使用

模块的一些基本操作

numpy模块（取别名，import numpy as aa）

pandas模块

数据导入学习

matplotlib基础

读取和讯博客的数据并可视化分析

数据板块作业：

数据探索与清洗

数据清理的步骤

数据集成

数据规约

属性构造

规约

主成分分析

文本挖掘

Mysql爬虫补充