Babus
Babus

Python

Python_第1张图片
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("")
  • 注释

  1. 注释法

print("")

  1. 三引号注释法


    Python_第2张图片
    image.png

  • 标识符


    Python_第3张图片
    image.png

  • 变量

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


    Python_第4张图片
    image.png
Python_第5张图片
image.png
Python_第6张图片
image.png
  • 运算符
      • / %（求余数） //求模

  • 缩进


    Python_第7张图片
    image.png

    Python_第8张图片
    image.png

Python控制流

三种基本控制流：

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

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


Python_第9张图片
image.png
Python_第10张图片
image.png

中断结构

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


Python_第11张图片
image.png

Python_第12张图片
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()
Python_第13张图片
image.png

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


Python_第14张图片
image.png

Python函数详解

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

局部变量与全局变量

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


image.png

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


image.png

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

函数的定义与调用

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

函数的参数

Python_第15张图片
image.png

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


Python_第16张图片
image.png

Python的模块

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

模块的导入

  1. import 模块名
  2. 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))

第一种导入方法


Python_第17张图片
image.png

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

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

自定义模块

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

文件操作概述

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


Python_第18张图片
image.png
Python_第19张图片
image.png

Python异常处理

Python_第20张图片
image.png

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


Python_第21张图片
image.png
Python_第22张图片
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+ )

Python_第23张图片
image.png

爬虫初识

Python_第24张图片
image.png

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


Python_第25张图片
image.png

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


Python_第26张图片
image.png

网络爬虫原理

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

正则表达式

Python_第27张图片
image.png

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

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


Python_第28张图片
image.png

通用字符：

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

  • \D与\d同样也相反


    Python_第29张图片
    image.png

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


Python_第30张图片
image.png

元字符

Python_第31张图片
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(二选一）

  • ()


    Python_第32张图片
    image.png

学到模式修正符

Python_第33张图片
image.png

模式修正符：

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

  • S让.的匹配也匹配上换行符


    Python_第34张图片
    image.png

贪婪模式，懒惰模式

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

Python_第35张图片
image.png

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

正则表达式函数

Python_第36张图片
image.png

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

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

Python_第37张图片
image.png
Python_第38张图片
image.png

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


Python_第39张图片
image.png

Python_第40张图片
image.png

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

image.png

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


Python_第41张图片
image.png

单双引号区别：


Python_第42张图片
image.png

第二次作业爬取图书馆

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

写入


image.png

Urllib库实战

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

  • geturl：现在爬的是哪个网页


    Python_第43张图片
    image.png

超时测试：

Python_第44张图片
image.png

image.png
Python_第45张图片
image.png

自动模拟http请求

Python_第46张图片
image.png
Python_第47张图片
image.png

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


Python_第48张图片
image.png

涉及到汉字的编码问题


Python_第49张图片
image.png

post

请求：（地址，数据）


Python_第50张图片
image.png

爬虫异常处理

200是正常进行


Python_第51张图片
image.png
Python_第52张图片
image.png

urlerror：

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

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


Python_第53张图片
image.png

浏览器伪装技术

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


Python_第54张图片
image.png

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

Python_第55张图片
image.png

爬新闻程序

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


Python_第56张图片
image.png

第三次作业

Python_第57张图片
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)

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

Python_第58张图片
image.png

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

Python_第59张图片
image.png

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


Python_第60张图片
image.png

图片爬虫

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


    Python_第61张图片
    image.png

将图片显示出来


Python_第62张图片
image.png

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


Python_第63张图片
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抓包分析

Python_第64张图片
image.png

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

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


Python_第65张图片
image.png

腾讯视频评论的抓取

Python_第66张图片
image.png
Python_第67张图片
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='

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

多线程爬虫

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


Python_第68张图片
image.png

分别爬奇数，一个偶数。


Python_第69张图片
image.png

Python_第70张图片
image.png

Python_第71张图片
image.png

Python_第72张图片
image.png

Scrapy框架

利用做大型的爬虫项目


Python_第73张图片
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交互终端，通常测试会用到）


    Python_第74张图片
    image.png

    在交互终端可以提取一些相应的信息

  • startproject（创建爬虫项目）后面接项目名
  • version查看对应的版本信息

  • view（下载这个网页并查看）


    image.png

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

  • bench测试本机性能

一些文件功能

Python_第75张图片
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


Python_第76张图片
image.png

//表示寻找所有的标签

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


image.png

image.png

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

Scrapy自动爬虫

Python_第77张图片
image.png

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

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


Python_第78张图片
image.png

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


Python_第79张图片
image.png
Python_第80张图片
image.png

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

自动登录

Python_第81张图片
image.png

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

当当网爬取

引入数据库

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

补充内容

  • jason数据：键值对


    Python_第82张图片
    image.png

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

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


image.png

u字符的翻译查看


image.png

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

数据挖掘的步骤

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

Python_第83张图片
image.png

Python_第84张图片
image.png

数据挖掘相关模块

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

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

相关模块的基本使用

Python_第87张图片
image.png

Python_第88张图片
image.png

模块的一些基本操作

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

  • 不知道格式的字符串排在最后
  • 三维数组排序（排数组里面元素排）

  • 切片 数组[起始下标:最终下标+1]
    省略不写代表衍生到头


    Python_第89张图片
    image.png

pandas模块

  • Series概念，指某一串数字（一串数字叫做一个series数字）有索引（不指定的话就是0,1,2...等排下去；指定索引加上index数组）

  • DataFrame类似表格，代表行列整合出来的数据，指定列名（加一个columns），还可以通过字典的方式，pandas中数字不够会自动填充的，填充为它本身


    Python_第90张图片
    image.png
Python_第91张图片
image.png

结果输出


Python_第92张图片
image.png

head和tail


Python_第93张图片
image.png

Python_第94张图片
image.png

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


    Python_第95张图片
    image.png

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


    Python_第96张图片
    image.png

数据导入学习

Python_第97张图片
image.png

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

  • sql导入，设置connect，然后设置查询语句
  • html读取是读取网页标签里的table标签。

  • 导入数据，只导入数据部分不导入文字部分


    Python_第98张图片
    image.png

    Python_第99张图片
    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()

数据板块作业：

Python_第100张图片
image.png

数据探索与清洗

数据探索核心：

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

数据清理的步骤

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

  • 插补方式：均值


    Python_第101张图片
    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不代表商品）
同意不同名


Python_第102张图片
image.png

数据规约

  1. 简单变换


    Python_第103张图片
    image.png

  2. 数据规范化


    Python_第104张图片
    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
  1. 离散化（将连续数据变成离散数据，把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=无

规约

规约=精简

  1. 属性规约（采用降维度，丢掉一些属性）
  2. 数值规约（化范围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：用来评估一个词对于文件的
重要性。与出现的次数成正比，用来相似度的计算。

稀疏向量和稀疏矩阵

相似度分析的步骤


Python_第105张图片
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)
Python_第106张图片
image.png

从后到左，从后往前

目前的问题

pca 稀疏向量 127.0.0.1

Python数据建模

Python_第107张图片
image.png

模型的建立依赖算法

Python数据分类实现过程

Python_第108张图片
image.png

常见的分类算法

Python_第109张图片
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

贝叶斯算法

Python_第110张图片
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个有
信息熵表示信息增益，越大表示占越大权重，更有用


Python_第111张图片
image.png

聚类

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

聚类三法

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

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

kmeans的步骤

Python_第112张图片
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算法的实现：

  1. 设定阈值：最小支持度，最小置信度

  2. 计算，置信度和支持度。支持度利用发生的频率去除概率。


    Python_第113张图片
    image.png
  3. 筛选
  4. 继续计算

关于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环境的一些问题以及解释

  1. pycharm也是可以直接下载包的，终端的pip3 install是为idle服务，而不是为pycharm。http://www.360doc.com/content/16/0827/13/35922414_586284807.shtml
  2. 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']

新浪微博的几种爬虫方式

  1. 接口
  2. 传统爬虫

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

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


Python_第114张图片
image.png

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


Python_第115张图片
image.png

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

phantomjs

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

你可能感兴趣的:(Python)

  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Python编译器 鹿鹿~ Python编译器Pythonpython开发语言后端
    嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • python中的深拷贝与浅拷贝 anshejd70787 python
    深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
  • 用Python实现简单的猜数字游戏 程序媛了了 python游戏java
    猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn
  • 用Python实现读取统计单词个数 程序媛了了 python游戏java
    完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
  • eclipse maven IXHONG eclipse
    eclipse中使用maven插件的时候，运行run as maven build的时候报错 -Dmaven.multiModuleProjectDirectory system propery is not set. Check $M2_HOME environment variable and mvn script match.   可以设一个环境变量M2_HOME指
  • timer cancel方法的一个小实例 alleni123 多线程timer
    package com.lj.timer; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class MyTimer extends TimerTask { private int a; private Timer timer; pub
  • MySQL数据库在Linux下的安装 ducklsl mysql
    1.建好一个专门放置MySQL的目录 /mysql/db数据库目录 /mysql/data数据库数据文件目录 2.配置用户，添加专门的MySQL管理用户 >groupadd mysql ----添加用户组 >useradd -g mysql mysql ----在mysql用户组中添加一个mysql用户 3.配置，生成并安装MySQL >cmake -D
  • spring------>>cvc-elt.1: Cannot find the declaration of element Array_06 springbean
    将-------- <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3
  • maven发布第三方jar的一些问题 cugfy maven
    maven中发布 第三方jar到nexus仓库使用的是 deploy:deploy-file命令 有许多参数，具体可查看 http://maven.apache.org/plugins/maven-deploy-plugin/deploy-file-mojo.html 以下是一个例子： mvn  deploy:deploy-file -DgroupId=xpp3
  • MYSQL下载及安装 357029540 mysql
        好久没有去安装过MYSQL，今天自己在安装完MYSQL过后用navicat for mysql去厕测试链接的时候出现了10061的问题，因为的的MYSQL是最新版本为5.6.24，所以下载的文件夹里没有my.ini文件，所以在网上找了很多方法还是没有找到怎么解决问题，最后看到了一篇百度经验里有这个的介绍，按照其步骤也完成了安装，在这里给大家分享下这个链接的地址
  • ios TableView cell的布局 张亚雄 tableview
      cell.imageView.image = [UIImage imageNamed:[imageArray objectAtIndex:[indexPath row]]];           CGSize itemSize = CGSizeMake(60, 50);   &nbs
  • Java编码转义 adminjun java编码转义
    import java.io.UnsupportedEncodingException; /** * 转换字符串的编码 */ public class ChangeCharset { /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */ public static final Strin
  • Tomcat 配置和spring aijuans spring
    简介 Tomcat启动时，先找系统变量CATALINA_BASE，如果没有，则找CATALINA_HOME。然后找这个变量所指的目录下的conf文件夹，从中读取配置文件。最重要的配置文件：server.xml 。要配置tomcat，基本上了解server.xml，context.xml和web.xml。 Server.xml --  tomcat主
  • Java打印当前目录下的所有子目录和文件 ayaoxinchao 递归File
    其实这个没啥技术含量，大湿们不要操笑哦，只是做一个简单的记录，简单用了一下递归算法。   import java.io.File; /** * @author Perlin * @date 2014-6-30 */ public class PrintDirectory { public static void printDirectory(File f
  • linux安装mysql出现libs报冲突解决 BigBird2012 linux
    linux安装mysql出现libs报冲突解决 安装mysql出现 file /usr/share/mysql/ukrainian/errmsg.sys from install of MySQL-server-5.5.33-1.linux2.6.i386 conflicts with file from package mysql-libs-5.1.61-4.el6.i686  
  • jedis连接池使用实例 bijian1013 redisjedis连接池jedis
    实例代码： package com.bijian.study; import java.util.ArrayList; import java.util.List; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoo
  • 关于朋友 bingyingao 朋友兴趣爱好维持
      成为朋友的必要条件：    志相同，道不合，可以成为朋友。譬如马云、周星驰一个是商人，一个是影星，可谓道不同，但都很有梦想，都要在各自领域里做到最好，当他们遇到一起，互相欣赏，可以畅谈两个小时。     志不同，道相合，也可以成为朋友。譬如有时候看到两个一个成绩很好每次考试争做第一，一个成绩很差的同学是好朋友。他们志向不相同，但他
  • 【Spark七十九】Spark RDD API一 bit1129 spark
    aggregate package spark.examples.rddapi import org.apache.spark.{SparkConf, SparkContext} //测试RDD的aggregate方法 object AggregateTest { def main(args: Array[String]) { val conf = new Spar
  • ktap 0.1 released bookjovi kerneltracing
    Dear, I'm pleased to announce that ktap release v0.1, this is the first official release of ktap project, it is expected that this release is not fully functional or very stable and we welcome bu
  • 能保存Properties文件注释的Properties工具类 BrokenDreams properties
            今天遇到一个小需求：由于java.util.Properties读取属性文件时会忽略注释，当写回去的时候，注释都没了。恰好一个项目中的配置文件会在部署后被某个Java程序修改一下，但修改了之后注释全没了，可能会给以后的参数调整带来困难。所以要解决这个问题。     &nb
  • 读《研磨设计模式》-代码笔记-外观模式-Facade bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* * 百度百科的定义： * Facade（外观）模式为子系统中的各类（或结构与方法）提供一个简明一致的界面， * 隐藏子系统的复杂性，使子系统更加容易使用。他是为子系统中的一组接口所提供的一个一致的界面 * * 可简单地
  • After Effects教程收集 cherishLC After Effects
    1、中文入门 http://study.163.com/course/courseMain.htm?courseId=730009 2、videocopilot英文入门教程（中文字幕） http://www.youku.com/playlist_show/id_17893193.html 英文原址： http://www.videocopilot.net/basic/ 素
  • Linux Apache 安装过程 crabdave apache
    Linux Apache 安装过程   下载新版本： apr-1.4.2.tar.gz（下载网站：http://apr.apache.org/download.cgi） apr-util-1.3.9.tar.gz（下载网站：http://apr.apache.org/download.cgi） httpd-2.2.15.tar.gz（下载网站：http://httpd.apac
  • Shell学习 之 变量赋值和引用 daizj shell变量引用赋值
    本文转自：http://www.cnblogs.com/papam/articles/1548679.html Shell编程中，使用变量无需事先声明，同时变量名的命名须遵循如下规则： 首个字符必须为字母（a-z，A-Z） 中间不能有空格，可以使用下划线（_） 不能使用标点符号 不能使用bash里的关键字（可用help命令查看保留关键字） 需要给变量赋值时，可以这么写：
  • Java SE 第一讲（Java SE入门、JDK的下载与安装、第一个Java程序、Java程序的编译与执行） dcj3sjt126com javajdk
    Java SE 第一讲： Java SE：Java Standard Edition Java ME: Java Mobile Edition Java EE：Java Enterprise Edition Java是由Sun公司推出的（今年初被Oracle公司收购）。 收购价格：74亿美金 J2SE、J2ME、J2EE JDK：Java Development
  • YII给用户登录加上验证码 dcj3sjt126com yii
    1、在SiteController中添加如下代码： /** * Declares class-based actions. */ public function actions() { return array( // captcha action renders the CAPTCHA image displ
  • Lucene使用说明 dyy_gusi Lucenesearch分词器
    Lucene使用说明 1、lucene简介 1.1、什么是lucene     Lucene是一个全文搜索框架，而不是应用产品。因此它并不像baidu或者googleDesktop那种拿来就能用，它只是提供了一种工具让你能实现这些产品和功能。 1.2、lucene能做什么     要回答这个问题，先要了解lucene的本质。实际
  • 学习编程并不难,做到以下几点即可! gcq511120594 数据结构编程算法
    不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各 异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发 各种神奇的软件啦。 1、确定目标 学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
  • Java面试十问之三：Java与C++内存回收机制的差别 HNUlanwei javaC++finalize()堆栈内存回收
    大家知道， Java 除了那 8 种基本类型以外，其他都是对象类型（又称为引用类型）的数据。 JVM 会把程序创建的对象存放在堆空间中，那什么又是堆空间呢？其实，堆（ Heap）是一个运行时的数据存储区，从它可以分配大小各异的空间。一般，运行时的数据存储区有堆（ Heap）和堆栈（ Stack），所以要先看它们里面可以分配哪些类型的对象实体，然后才知道如何均衡使用这两种存储区。一般来说，栈中存放的
  • 第二章 Nginx+Lua开发入门 jinnianshilongnian nginxlua
    Nginx入门 本文目的是学习Nginx+Lua开发，对于Nginx基本知识可以参考如下文章： nginx启动、关闭、重启 http://www.cnblogs.com/derekchen/archive/2011/02/17/1957209.html agentzh 的 Nginx 教程 http://openresty.org/download/agentzh-nginx-tutor
  • MongoDB windows安装 基本命令 liyonghui160com
      windows安装    安装目录：   D:\MongoDB\   新建目录   D:\MongoDB\data\db   4.启动进城：   cd D:\MongoDB\bin   mongod -dbpath D:\MongoDB\data\db   &n
  • Linux下通过源码编译安装程序 pda158 linux
    一、程序的组成部分 　　Linux下程序大都是由以下几部分组成： 　　二进制文件：也就是可以运行的程序文件 　　库文件：就是通常我们见到的lib目录下的文件 　　配置文件：这个不必多说，都知道 　　帮助文档：通常是我们在linux下用man命令查看的命令的文档 　　 二、linux下程序的存放目录 　　linux程序的存放目录大致有三个地方： 　　/etc, /b
  • WEB开发编程的职业生涯４个阶段 shw3588 编程Web工作生活
    觉得自己什么都会 2007年从学校毕业，凭借自己原创的ASP毕业设计，以为自己很厉害似的，信心满满去东莞找工作，找面试成功率确实很高，只是工资不高，但依旧无法磨灭那过分的自信，那时候什么考勤系统、什么OA系统、什么ERP，什么都觉得有信心，这样的生涯大概持续了约一年。 根本不是自己想的那样 2008年开始接触很多工作相关的东西，发现太多东西自己根本不会，都需要去学，不管是asp还是js，
  • 遭遇jsonp同域下变作post请求的坑 vb2005xu jsonp同域post
    今天迁移一个站点时遇到一个坑爹问题,同一个jsonp接口在跨域时都能调用成功,但是在同域下调用虽然成功,但是数据却有问题. 此处贴出我的后端代码片段 $mi_id = htmlspecialchars(trim($_GET['mi_id '])); $mi_cv = htmlspecialchars(trim($_GET['mi_cv ']));  贴出我前端代码片段: $.aj
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他