python爬虫（一）

03基础语法

三引号注释：
三个单引号’’‘配合三个单引号’’’
集合最好的用处是去重，无重复的值
乘法口诀表
#'end='代表不换行输出

#乘法口诀
for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j,end=' ')
    print()

1 * 1 = 1 
2 * 1 = 2 2 * 2 = 4 
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16 
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36 
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49 
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64 
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81 

作业：逆向完成乘法口诀表

#乘法口诀
i=9
while(i):
    j=1
    while(j<=i):
        print(i,'*',j,'=',i*j,end=' ')
        j+=1
    i-=1
    print('\n')

9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81 

8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64 

7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49 

6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36 

5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 

4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16 

3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 

2 * 1 = 2 2 * 2 = 4 

1 * 1 = 1 

老师给的代码：

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

05，06函数，模块

import 模块名
from —import —
模块的类别：1.自带模块2.第三方模块3.自定义模块4.anaconda
自己想要自定义的模块，先把写好的模块放进lib文件夹里，然后import

07文件操作

open（文件地址，操作形式）
‘w’：写入
’b’：二进制
‘r’：读取
’a’：追加

 data='一起学python！'
 fh2=open('D:/我的教学/python'，’w')
 fh2.write(data)
 fh2.close()

08异常处理

爬虫爬到一半可能会崩溃，需要进行跳过这次然后进行下一次
try：
程序
except Exception as 异常名称：
异常处理部分

#异常处理,让异常处理后的程序继续进行
for i in range(0,10):
    try:
       print(i)
       if(i==4):
          print(jkj)
    except Exception as err:
        print(err)
print('hello')

0
1
2
3
4
name 'jkj' is not defined
5
6
7
8
9
hello

09面对对象编程

类和对象
1.在类中的方法必须加上self参数
构造函数def __init __(self):
构造函数有参数时，实例化对象的时候必须有实参传进来
2.属性：类中的变量——self.属性名
3.方法：类中的函数——def 函数名（self，参数）
继承与重载
继承：把一个或多个类的特征拿过来
重载：在子类里面对继承过来的特征重新定义
class 子类（父类）
xlrd,xlwt操作excel表格

10 #做合并表格

import xlrd,xlsxwriter
allxls=[‘E:/第一个测试文件.xls’,‘E:/第二个测试文件.xls’，‘E:第三个测试文件.xls’]
#设置合并到的文件
endxls=‘E:/endxls.xls’
#打开表格
def openxls(file):
try:
fh=xlrd.open_workbook(file)
return fh
except Exception as e:
print(str(‘打开错误，错误为：’)+e)
#获取所有sheet
def getsheet(fh):
return fh.sheets()
#读取某个sheet的行数
def getnrows(fh,sheet):
table=fh.sheets()[sheet]
content=table.nrows
return content
#读取某个文件的内容并返回所有行的值
def getfilect(fh,fl,shnum):
fh=openxls(fl)
table=fh.sheet_by_name(shname[shnum])
num=getnrows(fh,shnum)
lenrvalue=len(rvalue)
for row in range(0,num):
rdata=table.row_values(row)
rvalue.append(rdata)
#print(rvalue[lenrvalue:])
filevalue.append(rvalue[lenrvalue:])
return filevalue
#存储所有读取的结果
filevalue=[]
#存储一个标签的结果
svalue=[]
#存储一行结果
rvalue=[]
#存储各sheet名
shname=[]
#读取第一个待读文件，获得sheet数
fh=openxls(allxls[0])
sh=getsheet(fh)
x=0
for sheet in sh:
shname.append(sheet.name)
svalue.append([])
x+=1
#依次读取各个sheet中的内容
#依次读取各文件当前sheet的内容
for shnum in range(0,x):
for fl in allxls:
print(‘正在读取文件:’+)

---

11网络爬虫

包括通用网络爬虫和聚集网络爬虫
主要体现在定向和不定向
一般爬虫应用在：
1.搜索引擎
2.采集金融数据
3.采集商品数据
4.自动过滤广告
5.采集竞争对手的客户数据
6.采集行业相关数据，进行数据分析
爬虫工作原理
做scrapy框架就是聚集网络爬虫，需要进行过滤无关链接，将过滤后的放入URL对列中，目的更加明确，要进行选择

12正则表达式:原子表

有xpath，和正则用于进行数据筛选，很基础
正则表达式最基本组成单位：原子
每个正则表达式至少包含一个原子
常见原子类型：a普通字符，b非打印字符，c通用字符，d原子表
1.普通字符作为原子的情况

#正则表达式
import re
#普通字符作为原子的情况
string='danaotiangong'
pat='nao'
result=re.search(pat,string)
print(result)

结果

<_sre.SRE_Match object; span=(2, 5), match='nao'>

2.#非打印字符，\n,\r,换行符，\t制表符

import re
#非打印字符作为原子，\n,\r,换行符，\t制表符
string='''danaotiangong
baidu'''
pat='\n'
result=re.search(pat,string)
print(result)

结果

<_sre.SRE_Match object; span=(13, 14), match='\n'>

3.通用字符作为原子，用一个字符代替一类东西 ,很重要！！
\w 字母，数字，下划线
\W 除字母，数字，下划线外的
\d 十进制
\D 除十进制以外的
\s 空白字符
\S 除空白字符以为的字符
有几个\d可以匹配几个数字出来

import re
#非打印字符作为原子，\n,\r,换行符，\t制表符
string='''danao546546454tiangongbaidu'''
pat='\w\d\d\d\w'
result=re.search(pat,string)
print(result)

2个任意的，3个\d的，但是要将这5个组合在一起

<_sre.SRE_Match object; span=(4, 9), match='o5465'>

4.原子表
需要列表的括号[xyz]，换句话说就是从原列表里面挖下去一个字母，然后从这个你给的原子表[xyadsda]中，去挑一个看看能不能把你想匹配这句话给连成完整的话，连不上就会显示None

import re
#非打印字符作为原子，\n,\r,换行符，\t制表符
string='''danao546546454tiangongbaidu'''
pat='da[abcnd][abdcojp]o'
result=re.search(pat,string)
print(result)

<_sre.SRE_Match object; span=(0, 5), match='danao'>

再加上数字的试试（扩充一下原子表），这个不能跨开吧，跟上面那个\w\d\d\d\w差不多，要连号的

import re
#非打印字符作为原子，\n,\r,换行符，\t制表符
string='''danao546546454tiangongbaidu'''
pat='da[abcnd][abdcojp]o[1213213259][123456789]'
result=re.search(pat,string)
print(result)

<_sre.SRE_Match object; span=(0, 7), match='danao54'>

综上，一个原子表的[ ]里面只能挑一个出来塞上去匹配
此外，原子表中加上[ ^ ]表示‘非’的意思

import re
#非打印字符作为原子，\n,\r,换行符，\t制表符
string='''danao546546454tiangongbaidu'''
pat='da[abcnd][abdcojp]o[^6789][^5]'
result=re.search(pat,string)
print(result)

<_sre.SRE_Match object; span=(0, 7), match='danao54'>

13正则表达式：元字符

匹配除换行符以外任意一个字符
注意使用‘ ^ ’，如果在原子表外表示匹配开始位置，在原子表内表示取反
注意使用‘ $ ’，表示结束位置
注意使用‘ * ’，前面的原子重复出现 0\1\多次，计数的？
注意使用 ‘ ？ ’，前面的原子出现 0\1次
注意使用 ‘ + ’，前面的原子出现 1\多次
{5}前面的原子恰好出现n次
{4, }前面的原子至少出现4次
{n,m}至少出现n次，至多m次
注意使用 ‘ | ’,模式选择符
注意使用 ‘ ( ) ’,模式单元
’ . ’ 好像可以当任意字符使用

import re
# ^在[]外的使用和$的使用
string='''danao546546454tiangongbaidu'''
pat='da...'
dat='^nao'
da='....du$'
ress=re.search(da,string)
res=re.search(dat,string)
result=re.search(pat,string)
print(result)
print(res)
print(ress)

<_sre.SRE_Match object; span=(0, 5), match='danao'>
None
<_sre.SRE_Match object; span=(21, 27), match='gbaidu'>

然后是+和*的使用
感觉，string里有5777777
然后你用57+去匹配就可以，但是5777777前面不能再有57了，不然就走不到这后面来，直接跟前面的57相匹配终止了

import re
# +的使用和*的使用,
string='''danaoooo5465777776454tiangongbaidu'''
pat='657*'
result=re.search(pat,string)
print(result)

<_sre.SRE_Match object; span=(10, 17), match='6577777'>

然后下面是{n,m}的使用

import re
# +的使用和*的使用,
string='''danaoooo5465777777776454tiangongbaidu'''
pat='657{4}'
result=re.search(pat,string)
print(result)
pat='657{3,6}'#大于等于3,小于等于6
result=re.search(pat,string)
print(result)

结果

<_sre.SRE_Match object; span=(10, 16), match='657777'>
<_sre.SRE_Match object; span=(10, 18), match='65777777'>

14正则表达式：模式修正符

l,匹配时忽略大小写
M ，多行匹配
L ,本地化识别匹配
U，unicode编码解析
S , 让.匹配包括换行符
三个加粗的是重点
实例：

import re
# +的使用和*的使用,
string='Python'
pat='pyt'
result=re.search(pat,string,re.I)#模式修正符，忽略大小写
print(result)

<_sre.SRE_Match object; span=(0, 3), match='Pyt'>

15正则表达式：贪婪模式与懒惰模式

贪婪：尽可能多的去匹配
懒得：尽可能少的去匹配
一般默认是贪婪模式

# +的使用和*的使用,
string='Poythonyjsdkajsd'
pat='p.*y'
result=re.search(pat,string,re.I)#模式修正符，忽略大小写
print(result)

一直到pat的截至位置y都可以截取到，而且以后面的y为准

<_sre.SRE_Match object; span=(0, 8), match='Poythony'>

懒得模式启动的符号是 .*?
下面是懒得和贪婪的比较

import re
# +的使用和*的使用,
string='Poythonyjsdkajsd'
pat='p.*y'
pat2='p.*?y'
result=re.search(pat,string,re.I)#模式修正符，忽略大小写
result2=re.search(pat2,string,re.I)
print(result)
print(result2)

懒得找到第一个y后就不再往后走了，可能会精确一些

<_sre.SRE_Match object; span=(0, 8), match='Poythony'>
<_sre.SRE_Match object; span=(0, 3), match='Poy'>