day1
#coding:utf-8
#设置当前编码格式 utf-8 国际标准编码格式
#单行注释
'''
多行注释
'''
print 'hello world!'
print '你好'
#变量
#python 是弱类型语言,变量类型是根据其值的类型决定的
# + - * /
a = 10
b = 20
c = a + b
print c
f = a*1.0 / b
print f
#两个整数相除,得到的还是一个整数,如果想得到一个小数,必须保证其中一个是小数
if
#coding:utf-8
# 设置字符编码
# 声明一个变量
a = 10
# 如果a 大于20 ,输出a大于20
# if 单个条件的if判断 (如果条件成立,执行代码块的内容,
# 如果条件不成立,直接跳过代码块)
# if 判断条件:
# 代码块内容
if a>20:
print 'a大于20'
# 两种情况的判断,if else 如果条件成立,执行条件后的代码块,
# 如果条件不成立,执行else后的代码块,有且只会执行一个代码块
if a >= 20:
print 'a大于等于20'
else:
print 'a小于20'
# 三种或三种以上的情况 if elif else
if a > 20:
print 'a大于20'
elif a < 20:
print 'a小于20'
else:
print 'a等于20'
while
#coding:utf-8
# 循环, 如果有一部分代码需要重复循环执行,我们只需要将代码放在循环中
# 执行即可,没必要将代码写很多遍
if 1 == 1:
pass # 保证代码完整性
# 只要条件成立就去执行条件后的代码块,条件不成立,代码块不执行
a = 1
# 1、结束while循环方式一:更改 while循环的条件,循环结束
while a == 1:
number = input('请输入一个数字(输入0结束):')
if number == 0:
# 更改a的值,使循环条件不成立
a = 2
# 2、使用break结束循环、
# 布尔类型 True(真,可以用数字1表示)成立 False(假,
# 可以用数字0表示)不成立
while 1:
number = input('请输入一个数字(输入0结束):')
if number == 0:
break
input
#coding:utf-8
# input() python中的内置函数
# 将 input 执行的结果赋值给变量a
# 输入一些数字或者计算表达式
a = input('请输入一个数字:')
print a
# raw_input() 可以用来输入字符串的输入函数,会将所有输入的内容
# 看成一个完整的字符串
b = raw_input('请输入内容:')
print b
# type() 查看变量类型
print type(a)
print type(b)
例子:
BMI
#coding:utf-8
while 1 == 1:
#声明两个变量 身高 和 体重
height = input('请输入您的身高(m,0结束):')
# 如果输入的为0 结束循环
if height == 0:
break
weight = input('请输入您的体重(kg):')
# 体质指数(BMI)= 体重(kg)/身高*2 (m)
bmi = weight / (height * height)
print bmi
# 判断bmi所在范围
# and 与 ;or 或 ; ! (取反)非
if bmi < 18.5:
print '您的体重过轻,该增肥了!'
elif bmi >= 18.5 and bmi < 24:
print '您的体重正常,请继续保持!'
elif bmi >= 24 and bmi < 28:
print '您的体重过重,请适当减肥!'
elif bmi >= 28 and bmi <= 32:
print '您属于肥胖人群,请及时减肥!'
else:
print '您属于非常肥胖人群,请立即减肥!'
#coding:utf-8
# 出租车费用计算器
# 根据行驶公里数,计算价格
# 起步价8块,包含2公里,超过2公里到12公里部分,每公里收费
# 1.2元,超过12公里部分,每公里1.5元,计算对应的费用
d = input('请输入您的行驶距离(公里):')
if d <= 2:
print '您的车费是8元'
elif d > 2 and d <= 12:
c = 8 + 1.2 * (d - 8)
print '您的车费是', c ,'元'
else:
c = 1.5*(d - 12) + 8 + 12
print '您的车费是', c ,'元'
猜数字游戏
#coding:utf-8
'''
1、产生一个随机整数,范围在0~100之间,包含0和100
2、在循环中输入一个猜测的数字
3、对比猜测数字和正确答案
3.1、猜测数字大于正确答案 输出你猜大了
3.2、猜测数字小于正确答案 输出你猜小了
3.3、猜测数字等于正确答案 输出你猜对了
3.3.1、给两个选项 继续玩 or 退出
'''
# random python内置的随机数模块
import random
# random.randint()使用random模块中的randint功能函数生成随机整数
number = random.randint(0,100)
while 1:
a = input('请输入你猜测的数字(0~100):')
# 使用while循环对输入的数字做判断
while a < 0 or a > 100:
a = input('输入的数字不合法,请重输:')
if a > number:
print('抱歉,你猜大了!')
elif a < number:
print('抱歉,你猜小了!')
else:
print('恭喜你,猜对了!')
print '1、继续玩'
print '2、退出'
selc_num = input('请输入你的操作:')
while selc_num != 1 and selc_num != 2:
selc_num = input('选项不存在,请重选:')
if selc_num == 1:
# 继续玩
number = random.randint(0, 100)
else:
break
#coding:utf-8
'''
1、输入一个税前工资数
2、计算需要交纳的社保费用 五险一金费用=工资*社保比例(22.5%)
2.1、缴纳五险一金有上限,上限为 7662
如果税前工资大于等于7662,五险一金费用 = 7662 * 社保比例(22.5%)
如果税前工资小于7662,五险一金费用 = 税前工资*社保比例(22.5%)
3、计算应纳税所得额,应纳税所得额 = 税前工资 - 五险一金 - 起征点(3500)
3.1、根据应纳税所得额,判断所在的阶梯,根据阶梯税率和速算
扣除数,计算税额
4、应纳税额 = 应纳税所得额*税率-速算扣除数
5、输出到手工资、应纳税额、五险一金 金额
'''
#continue 跳过此次循环,直接执行下次循环
while 1:
sr = 0.225
# 输入工资数
pre_tax = input('输入税前工资:')
#计算五险一金
if pre_tax < 7662:
insurance = pre_tax*sr
else:
insurance = 7662*sr
#计算应纳税所得额
if pre_tax > 3500:
income = pre_tax - insurance - 3500
else:
income = 0
if income <= 1500:
tax = income*0.03
elif income <= 4500:
tax = income*0.10 - 105
elif income <= 9000:
tax = income*0.20 - 555
elif income <= 35000:
tax = income*0.25 - 1005
elif income <= 55000:
tax = income*0.30 - 2755
elif income <= 80000:
tax = income*0.35 - 5505
else:
tax = income*0.45 - 13505
# 计算到手工资
salary = pre_tax - insurance - tax
print '到手工资金额为:',salary
print '五险一金费用为:',insurance
print '应纳税额为:',tax
day 2
for
# for循环指定循环次数 range范围 包含开始不包含结束
# 利用for 循环 输出9*9乘法表
for x in range(0,10):
print x,
print '--------------------------------'
for a in range(1,10):
for b in range(1,a+1):
c = a * b
print a, '*', b, '=', c,
print
列表
#coding:utf-8
# list列表 容器类 列表中存取的数据是有顺序的,可以存放数字、字符串
# 、对象。。。
# 声明一个列表,列表中如果有多个元素,每个元素之间用,号隔开
list_1 = [1,'hello',True,3.1415926,'world']
print list_1
#-----向列表中添加数据----
# 1、追加数据,会把添加的数据放在列表的末尾
list_1.append('zhangsan')
print list_1
# 2、插入数据,可以在指定的位置,添加数据
# 2.1、指定的位置(如果指定的位置超过最大索引,会把数据放在最后)
# 2.2、要插入的数据
list_1.insert(2,False)
print list_1
# 3、可以扩展列表 将另外一个列表的数据全部添加到该列表中
list_2 = [1,2,3]
list_1.extend(list_2)
print list_1
#-------修改列表中数据------
#根据索引修改列表中的数据
list_1[4]=3.14
print list_1
#-------查询列表中的数据-----
# 根据索引取数据,索引不能超过最大索引范围
# 支持负值取值,负值从后面向前取值,最后一个元素的索引
# 为-1
pi = list_1[4]
print pi
print list_1
# pop()函数,从列表中取出数据,取出之后列表中就没有了
pi = list_1.pop(4)
print pi
print list_1
# 取出列表中所有的数据
# python 中内置函数len() 获取列表的长度(列表中存放的
# 的数据个数)
l = len(list_1)
print '列表中存放的个数为:',l
# len也可以获取字符串的长度
string = 'abcdefghijklmn'
print len(string)
# for循环 ,遍历列表
for x in range(0,l):
# 把x的值作为索引,从列表中取出数据
content = list_1[x]
print content
print '-----------------------------------'
# for循环做列表遍历,泛型遍历
for content in list_1:
print content
#-----------删除列表中的数据----------------------
print '*****************************************'
print list_1
# 1、使用pop()函数,取出列表中的数据,会把数据从列表
# 中移除
# 如果pop()不填写索引,默认取出最后一个元素
list_1.pop()
print list_1
# 2、del 关键字 删除指定索引的元素
del list_1[3]
print list_1
# 3、使用remove()函数,移除指定的元素
# remove只会移除第一个匹配到的元素
list_1.remove('zhangsan')
print list_1
# 怎么能把列表中所有的元素删除
while len(list_1):
list_1.pop()
print list_1
字典
# coding:utf-8
# 字典:以 key:value键值模式存储数据的,可以存储任何类型的数据,字典中存
# 储的数据是无序的
# 声明字典
# 字典中的key必须是不可变的,一般推荐使用字符串/数字作为字典中的key,key
# 必须是唯一的
dict_1 = {'name':'zhangsan','age':22,'phone':'10'}
print dict_1
# 如果字典中有这个key,做修改的操作,如果没有这个key,做添加操作
# 添加数据
dict_1['sex'] = 'male'
dict_1['adress'] = 'China'
print dict_1
# 修改数据
dict_1['name'] = 'lisi'
print dict_1
# 查询获取数据
# 通过key取出key对应的值
name = dict_1['name']
# get()函数根据key取值,如果key不存在,可以指定获取一个默认值
name = dict_1.get('qwer','123')
print name
# 根据key删除字典中的数据
del dict_1['name']
print dict_1
# 输出字典所有的数据
# clear()清空字典中的所有键值
dict_1.clear()
print dict_1
# 获取字典中的所有key,返回一个列表
keys = dict_1.keys()
print keys
for key in keys:
# 根据key从字典中取出值
value = dict_1[key]
print key,value
# values()获取字典中所有的值,返回一个列表
values = dict_1.values()
print values
# items() 获取字典中所有的key和value,返回的是一个列表中嵌套的小元组
items = dict_1.items()
print items
for item in items:
# item 是存放了键值对的小元组
print item[0],item[1]
# has_ker()判断字典中是否拥有某个key,返回是布尔类型的数据
# 如果不存在这个key,返回False,如果存在返回True
is_have = dict_1.has_key('phone')
print is_have
例子
简易学生管理系统
%s 占位符
name = raw_input('请输入您修改后的姓名(%s):'%old_name)
l = len(student_list)
for x in range(0, l):
name = student_list[x]
print '序号:%s 姓名:%s'%(x, name)
#coding:utf-8
'''
有一个存放所有学员信息的列表student_list
有五个功能
1 添加学员
1.1 输入一个学员的姓名、年龄、电话,添加到所有学员列表中
2 查询学员
2.1 输出所有学员的信息,学员的序号和学员的姓名、年龄、联系方式
3 修改学员
3.1 展示所有学员信息
3.2 选择学员的序号,修改姓名
4 删除学员
4.1 展示学员信息,根据选择的序号删除学员
4.2 删除所有学员
5 退出程序
'''
# 声明一个用来存放所有学员信息的列表student_list
student_list = []
while True:
print '********学员管理系统********'
print '1、添加学员'
print '2、查询学员'
print '3、修改学员'
print '4、删除学员'
print '0、退出程序'
print '***************************'
# 选择操作
selc_num = input('请选择您的操作:')
#判断选择的数字是否符合要求
while selc_num not in range(0,5):
selc_num = input('没有该选项,请重选:')
#根据选择的数字,做出对应的操作
if selc_num == 1:
#1.输入学员信息
name = raw_input('请输入姓名')
age = raw_input('请输入年龄')
phone = raw_input('请输入手机')
#2.组装一个完整信息的小列表
person = [name,age,phone]
#3.将小列表添加到大列表中
student_list.append(person)
elif selc_num == 2:
for x in range(0,len(student_list)):
#根据x的值,取出对应的小列表
person = student_list[x]
#取出姓名,年龄,电话
name = person[0]
age = person[1]
phone = person[2]
print '序号:%s 姓名:%s 年龄:%s 电话:%s'%(x,name,age,phone)
elif selc_num == 3:
#1.输出信息
for x in range(0,len(student_list)):
#根据x的值,取出对应的小列表
person = student_list[x]
print '序号:%s 姓名:%s 年龄:%s 电话:%s'%(x,person[0],person[1],person[2])
#2.选择序号
index = input('请输入要修改的序号:')
while index not in range(0,len(student_list)):
index = input('序号无效,请选择:')
#3.根据序号取出小列表
person = student_list[index]
new_name = raw_input('请输入修改后的名字(%s):'%person[0])
new_age = raw_input('请输入修改后的年龄(%s):' % person[1])
new_phone = raw_input('请输入修改后的电话(%s):' % person[2])
#4.修改数据
person[0] = new_name
person[1] = new_age
person[2] = new_phone
print '修改成功!'
elif selc_num == 4:
print '1.删除指定学员信息'
print '2.删除所有学员信息'
selc_num = input('请输入您的选择:')
while selc_num not in range(1, 3):
selc_num = input('没有此选项,请重选:')
if selc_num == 1:
# 1.学员信息展示
for x in range(0, len(student_list)):
# 根据x的值,取出对应的小列表
person = student_list[x]
print '序号:%s 姓名:%s 年龄:%s 电话:%s' % (x, person[0], person[1], person[2])
#2.输入要删除的序号
index = input('请输入要删除的序号:')
while index not in range(0, len(student_list)):
index = input('没有该序号,请重选:')
# 取出要删除的姓名
old_name = student_list[index][0]
rs = raw_input('您确定要删除:%s?y/n:' % old_name)
if rs == 'y':
del student_list[index]
else:
# 做删除数据的提醒
rs = raw_input('您确定要清除所有数据?y/n:')
if rs == 'y':
while len(student_list):
student_list.pop()
else:
print '成功退出'
break
day 3
函数
# coding:utf-8
# 函数,将一段代码,封装起来,可以在任何区域进行调用执行
# define 定义
def eat():
print '中午该吃饭了。。。'
# 调用函数
eat()
# 带参数的函数
# def 函数名(参数列表):
def sleep(hour):
print '天冷最适合睡觉了~,睡了%s小时'%hour
# 调用带参数的函数
sleep(8)
# 买水的函数
# 带有两个或者多个参数时,每个参数之间用,逗号隔开
def buy_water(money,name):
print '给你%s块钱,我要买%s'%(money,name)
# 调用多个参数的函数
buy_water(10,'康师傅矿泉水')
# 买水函数
# 买水需要两个参数:钱,水名称
# 买水执行完成后,返回执行结果
def buy_water(money,name):
# 执行一定业务代码之后,返回一个或者多个结果
print '买了%s,消费1元'%name
money = money - 1
# return 返回执行的结果
return money
# 声明变量接收返回结果
money = buy_water(20, '康师傅矿泉水~')
money = buy_water(money, '康师傅矿泉水')
print money
json
例子
学员信息管理系统(函数)
# coding:utf-8
# dict_1 = {}
# dict_1['name'] = 'jj'
# del dict_1['name']
# name = dict_1.get['name']
#
# dict_1.has_key()
# dict_1.keys()
# dict_1.values()
# dict_1.items[('name','jj'),('age','11')]
def add_stu():
name = raw_input('请输入学员姓名:')
age = input('请输入学员年龄:')
phone = input('请输入学员联系方式:')
person = {'name': name, 'age': age, 'phone': phone}
student_list.append(person)
print '添加成功'
def find_stu():
print '查询结果如下'
for x in range(0, len(student_list)):
person = student_list[x]
name = person.get('name', 'None')
age = person.get('age', '0')
phone = person.get('phone', 'None')
print '序号:%s 姓名:%s 年龄:%s 联系方式:%s' % (x, name, age,phone)
def yz():
index = input('请输入要修改的信息序号:')
while index not in range(0, len(student_list)):
index = input('不存在,请重新输入:')
return index
def update_stu():
find_stu()
index = yz()
person = student_list[index]
person['name'] = raw_input('请输入修改后的名字(%s):' % person['name'])
person['age'] = input('请输入修改后的年龄(%s):' % person['age'])
person['phone'] = input('请输入修改后的电话(%s):' % person['phone'])
# # 4.修改数据
# person['name'] = new_name
# person['age'] = new_age
# person['phone'] = new_phone
print '修改成功'
def delete_stu():
print '1.删除指定学员信息'
print '2.删除所有学员信息'
selc_num = input('请输入您的选择:')
while selc_num not in range(1, 3):
selc_num = input('没有此选项,请重选:')
if selc_num == 1:
find_stu()
index = yz()
old_name = student_list[index]['name']
rs = raw_input('您确定要删除:%s?y(删除)/n(取消):' % old_name)
if rs == 'y':
del student_list[index]
else:
rs = raw_input('您确定要清除所有数据?y/n:')
if rs == 'y':
while len(student_list):
student_list.pop()
student_list = []
while 1:
print '********学员管理系统********'
print '1、添加学员'
print '2、查询学员'
print '3、修改学员'
print '4、删除学员'
print '0、退出程序'
print '***************************'
selc_num = input('请选择您的操作:')
while selc_num not in range(0, 5):
selc_num = input('没有该选项,请重选:')
if selc_num == 1:
add_stu()
elif selc_num == 2:
find_stu()
elif selc_num == 3:
update_stu()
elif selc_num == 4:
delete_stu()
else:
break
天气预报查询系统
# coding:utf-8
# url 统一资源定位符
# 在python中发送请求
# 下载requests包,使用requests发送请求
import requests
# python 内置的包,json
import json
while True:
print '***************欢迎使用天气查询系统***************'
city = raw_input('请输入您要查询天气的城市(输入q退出):')
if city == 'q':
break
# 1、准备url地址
url = 'http://api.map.baidu.com/telematics/v3/weather?location=%s&output=json&ak=TueGDhCvwI6fOrQnLM0qmXxY9N0OkOiQ&callback=?'%city
# 2、发送一个get请求,获取url地址下的资源信息
# get(url)需要将url地址作为参数进行传递
# response 接收服务器返回的响应数据
response = requests.get(url)
# 把json字符串转换python中的字典或列表
weather_dict = json.loads(response.content)
#print type(weather_dict)
# 根据key取出字典对应的值
date = weather_dict.get('date')
print 'date:',date
# 取出results列表
results = weather_dict['results']
# 取出results中的字典
detail_dict = results[0]
# 取出当前城市
current_city = detail_dict['currentCity']
print 'city:',current_city
pm25 = detail_dict['pm25']
# 把取出的pm25字符串转化为数字,在进行比较
pm25 = int(pm25)
if pm25 <= 50:
print 'pm值%s,优'% pm25
elif pm25 <= 100:
print 'pm值%s,良' % pm25
elif pm25 <= 150:
print 'pm值%s,轻度污染' % pm25
elif pm25 <= 200:
print 'pm值%s,中度污染' % pm25
elif pm25 <= 300:
print 'pm值%s,重度污染' % pm25
else:
print 'pm值%s,严重污染' % pm25
# 取出index列表
indexs = detail_dict['index']
# 取出index中的字典
for index in indexs:
title = index['title']
zs = index['zs']
tipt = index['tipt']
des = index['des']
print u'标题:%s 指数:%s 提示:%s 建议:%s'%(title,zs,tipt,des)
# 取出weather_data天气情况列表
weather_data = detail_dict['weather_data']
# 取出weather_data中的字典
for weather_dict in weather_data:
date = weather_dict['date']
# dayPictureUrl = weather_dict1['dayPictureUrl']
# nightPictureUrl = weather_dict1['nightPictureUrl']
weather = weather_dict['weather']
wind = weather_dict['wind']
temperature = weather_dict['temperature']
print u'日期:%s 天气:%s 风级:%s 温度:%s'%(date, weather, wind, temperature)
day 4
练习:旅游信息查询系统**
# coding:utf-8
# 发送请求的requests包
import requests
import json
while 1:
print '********欢迎使用旅游信息查询系统********'
city = raw_input('请输入您要查询的城市(输入0查询结束):')
if city == 0:
break
url = 'http://api.map.baidu.com/telematics/v3/travel_city?location=%s&ak=TueGDhCvwI6fOrQnLM0qmXxY9N0OkOiQ&output=json'%city
response = requests.get(url)
travel_dict = json.loads(response.content)
date = travel_dict.get('date')
print 'date:',date
result = travel_dict.get('result')
city_id = result['cityid']
print u'城市编号:%s'%city_id
city_name = result['cityname']
print u'城市名称:%s'%city_name
location = result['location']
lng = location['lng']
lat = location['lat']
print u'经度:%s 纬度:%s'%(lng,lat)
star = result['star']
print u'星级:%s'%star
url = result['url']
print u'链接:%s'%url
abstract = result['abstract']
print u'简介:%s'%abstract
description = result['description']
print u'详细介绍:%s'%description
itineraries = result['itineraries']
for travel_dict in itineraries:
name = travel_dict['name']
description = travel_dict['description']
print u'%s: %s'%(name,description)
itineraries = travel_dict['itineraries']
for day_dict in itineraries:
path = day_dict['path']
for travel_attractions_dict in path:
name = travel_attractions_dict['name']
detail = travel_attractions_dict['detail']
print u'景点:%s 链接:%s'%(name,detail)
print '安排如下:'
description = day_dict['description']
dinning = day_dict['dinning']
accommodation = day_dict['accommodation']
print u'%s; %s; %s'%(description,dinning,accommodation)
day 5
一些简单的网页基础知识点
<!DOCTYPE html>
<!--声明当前文档类型,让浏览器加载网页,按照H5的标准进行加载-->
<!--hyper text markup language 超文本标记语言-->
<html lang="en">
<head>
<meta charset="UTF-8">
<title>exo</title>
</head>
<body>
<span>标记普通文字</span>
<p>段落标签
anacondaanacondaanacondaanacondaanacondaanaconda
anacondaanacondaanacondaanacondaanaconda</p>
<!--h1~h6-->
<h1>标题标签</h1>
<!--h${这是h$标题标签}*6 按tab键--->
<!--写标签名称 按tab键-->
<h1>这是h1标题标签</h1>
<h2>这是h2标题标签</h2>
<h3>这是h3标题标签</h3><h4>这是h4标题标签</h4><h5>这是h5标题标签</h5><h6>这是h6标题标签</h6>
<!--img 标记网页中的图像-->
<!--src source:来源 图片路径-->
<!--alt 提醒:当图片加载失败时,以文本的方式代替图片显示-->
<!--title 当鼠标停留在图片上时 显示的文字-->
<img src="i.jpg" alt="" title="朴灿烈">
<!--a 标签 标记网页中的超链接-->
<!--target="blank" 新增一个网页打开目标标签-->
<a href="https://www.baidu.com">百度一下</a>
</body>
</html>
截取字符串
# coding:utf-8
# 字符串中的函数
string = 'abcdefg'
# 1、取出字符串中的函数
c = string[2]
print c
# 遍历取出所有字符
for s in string:
print s
# 2、字符串的切片,包含开始位置,不包含结束位置
s = string[3:6]
print s
# 从第0个字符开始截取,直到第N个字符
s = string[:6]
print s
# 从第n个字符开始截取,直到最后一个字符
s = string[2:]
print s
# 列表也可以切片
list_1 = [1,2,3,4,5,6,7,8,9]
l = list_1[:2]
print l
# 3.find()查找某个字符出现的位置,找到返回对应的位置,
# 找不到返回-1
# start 开始查找的位置 end 结束查找的位置
index = string.find('e', 5, 8)
print index
# 4.count()统计某个字符出现的次数
count = string.count('d')
print count
# 5.split() 分割字符串,返回一个分割完成后的列表
s2 = 'zhangsan,110,23'
# maxsplit 指定最大分割的次数
result = s2.split(',',2)
print result
# 6.把列表中的字符串,拼接成一个完整的字符串
s3 = ';'.join(result)
print s3
# 7.string.startswith()判断字符是否以某个字符开头,
# 是 返回True ,不是返回False
rs = string.startswith('acb')
print rs
# 8.endswith()
rs = string.endswith('kl')
print rs
例子
从一串字符串中提取图片链接
# coding:utf-8
# 引入python内置的网络请求包,可以使用该包下载图片
import urllib
string = '<cc><div id="post_content_115101375872" class="d_post_content j_d_post_content ">秋高气爽<br><img class="BDE_Image" src="https://imgsa.baidu.com/forum/w%3D580/sign=16a7318cd2f9d72a17641015e42b282a/353680cb39dbb6fd5e8db0950224ab18952b379e.jpg" size="65387" changedsize="true" width="560" height="420" size="65387"><br><img class="BDE_Image" src="https://imgsa.baidu.com/forum/w%3D580/sign=80df3901b9b7d0a27bc90495fbee760d/1ddd0b55b319ebc49aae232a8926cffc1c17169e.jpg" size="50323" changedsize="true" width="560" height="420" size="50323"><br><img class="BDE_Image" src="https://imgsa.baidu.com/forum/w%3D580/sign=078b542b55df8db1bc2e7c6c3922dddb/33c010dfa9ec8a1338cc0253fc03918fa2ecc09f.jpg" size="78770" changedsize="true" width="560" height="373" size="78770"><br><img class="BDE_Image" src="https://imgsa.baidu.com/forum/w%3D580/sign=f4602793b212c8fcb4f3f6c5cc0292b4/b0c62934349b033bdd5ea9691ece36d3d739bd9f.jpg" size="95035" changedsize="true" width="560" height="373" size="95035"><br><img class="BDE_Image" src="https://imgsa.baidu.com/forum/w%3D580/sign=1f8f63cc73f0f736d8fe4c093a54b382/300b37d12f2eb9382fbb2f41de628535e7dd6f9f.jpg" size="100285" changedsize="true" width="560" height="373" size="100285"><br><img class="BDE_Image" src="https://imgsa.baidu.com/forum/w%3D580/sign=cf96d68331f33a879e6d0012f65d1018/6b5f0e2442a7d933d23ab1c0a64bd11371f001da.jpg" size="65247" changedsize="true" width="560" height="420" size="65247"><br><img class="BDE_Image" src="https://imgsa.baidu.com/forum/w%3D580/sign=dfff2f41de62853592e0d229a0ee76f2/4a9f8ad4b31c8701e524e7552c7f9e2f0508ffdb.jpg" size="79750" changedsize="true" width="560" height="414" size="79750"><br><img class="BDE_Image" src="https://imgsa.baidu.com/forum/w%3D580/sign=b4a6d35d9782d158bb8259b9b00b19d5/35d1279759ee3d6d3054d27848166d224d4adedb.jpg" size="103175" changedsize="true" width="560" height="414" size="103175"></div><br></cc>'
# 定义开始截取需要查找的字符
start_str = '<img class="BDE_Image" src="'
end_str = '.jpg'
# 查找开始位置和结束位置
start = string.find(start_str)
print start
end = string.find(end_str)
print end
# 截取字符串 start是<左尖括号的位置,需要加上start_str
# 的长度得到才是https中h的位置
# rs = string[start:end]
# print rs
rs = string[start+len(start_str):end+len(end_str)]
print rs
# 查找第二张图的src 应该从第一个。jpg之后进行查找
start = string.find(start_str,end+len(end_str),len(string))
print start
# 查找第二个.jpg的位置,应该从第二个<img的位置开始查找
end = string.find(end_str,start, len(string))
print end
# 截取第二个src的值
rs1 = string[start+len(start_str):end+len(end_str)]
print rs1
start = string.find(start_str)
start_str = '<img class="BDE_Image" src="'
end_str = '.jpg'
while start != -1:
end = string.find(end_str, start, len(string))
href = string[start + len(start_str):end + len(end_str)]
# 分割url地址 获取图片名称
href_list = href.split('/')
pic_name = href_list[-1]
# urlretrieve()
urllib.urlretrieve(href,pic_name)
# 找到下一个链接开始的位置,如果找不到则为-1 ,循环结束
start = string.find(start_str, end + len(end_str), len(string))
爬取nba贴吧一个精品贴的全部图片
# coding:utf-8
'''
1. 准备要爬取的url地址
2. 根据url地址发起请求,接受响应数据
3. 从html源代码中,提取该帖共有多少页
4. 准备用于查找图片位置的开始和结束的字符串
5. for循环循环总页数次
5.1 把x的值作为页码,拼接完整的url地址
5.2 根据url发起请求,接收当前页的相应数据(网页源代码)
5.3 搜索该页中共有多少张图片,使用string.count()函数
5.4 查找第一张图片的开始位置
5.5 while循环,只要图片的开始位置不等于-1,表示找到了,
执行循环内容
5.5.1 找到图片结束位置,从上一次找到图片开始位置之后查找
5.5.2 根据开始和结束位置,截取字符串(图片链接)
5.5.3 通过分割字符串,获取图片名称
5.5.4 使用urllib.urlretrieve()函数 下载图片
'''
# 引入requests请求包
import requests
import urllib
# 1.准备url
numbers = raw_input('请输入要下载图片的帖子编号:')
url = 'https://tieba.baidu.com/p/%s'%numbers
# 2.发起请求,拿回响应数据
response = requests.get(url)
# 3.取出网页源代码
html = get_datasource()
# 查找页数
page_start = '共<span class="red">'
start = html.find(page_start)
page_end = '</span>页'
end = html.find(page_end,start)
total_page = html[start+len(page_start):end]
# 4.查找的开始字符串
start_str = '<img class="BDE_Image" src="'
index = html.find(start_str)
if index == -1:
start_str = '<img class="BDE_Image" pic_type="0" src="">'
end_str = '.jpg'
# 循环总页数次
for x in range(1,int(total_page)+1):
# 获取每一页html源代码
url = 'https://tieba.baidu.com/p/%s?pn=%s' % (numbers, x)
response = requests.get(url)
html = response.content
# 获取改页有多少张图片
total_count = html.count(start_str)
print '正在解析第%s页,该页共搜索到%s张图片'%(x,total_count)
# 5.查找开始字符串的位置
start = html.find(start_str)
# 6.是要start不等于-1 ,那就说明找到图片标签
count = 0
while start != -1:
# 7.从start开始,向后查找到end结束的位置
end = html.find(end_str,start,len(html))
href = html[start+len(start_str):end+len(end_str)]
print href
# 9.继续查找下一个图片标签的位置,如果找不到为-1,循环结束
start = html.find(start_str,end+len(end_str),len(html))
# 10.分割图片名称
pic_name = href.split('/')[-1]
count += 1
print '正在下载第%s张。。。'%count
# 11.下载图片
urllib.urlretrieve(href,pic_name)
函数版
#coding:utf-8
# 引入requests请求包
import requests
import urllib
# 给一个url参数,返回源代码
def get_datasource(url):
response = requests.get(url)
return response.content
# 获取总页数,参数 html源代码
def get_totalpage(html):
# 查找页数
page_start = '共<span class="red">'
start = html.find(page_start)
page_end = '</span>页'
end = html.find(page_end, start)
total_page = html[start + len(page_start):end]
# 返回数字总页码
return int(total_page)
# 根据总页数,for循环轮流解析每页图片的url地址
def parse_href(total_page, html, numbers):
# 4.查找的开始字符串和结束字符串
start_str = '<img class="BDE_Image" src="'
index = html.find(start_str)
if index == -1:
start_str = '<img class="BDE_Image" pic_type="0" src="'
end_str = '.jpg'
# 循环总页数次
for x in range(1, int(total_page) + 1):
# 获取每一页的html源代码
url = 'https://tieba.baidu.com/p/%s?pn=%s' % (numbers, x)
print url
response = requests.get(url)
html = response.content
# 获取该页共有多少张图片
total_count = html.count(start_str)
print '正在解析第%s页,共搜索到%s张图片!' % (x, total_count)
# 5.查找开始字符串的位置
start = html.find(start_str)
# 6.只要start不等于-1,那就说明找到了图片标签
count = 0
while start != -1:
# 7.从start开始,向后查找到end结束的位置
end = html.find(end_str, start, len(html))
# 8.截取图片的链接字符串
href = html[start + len(start_str): end + len(end_str)]
# 9.继续查找下一个图片标签的位置,如果找不到为-1,循环结束
start = html.find(start_str, end + len(end_str), len(html))
# 10.分割图片名称
pic_name = href.split('/')[-1]
# 计算正在下载第几张 count+=1 和 count = count+1
count += 1
print '正在下载第%s张......' % count
# 11.下载图片
urllib.urlretrieve(href, pic_name)
# 入口函数
def main():
# 1.准备url
numbers = raw_input('请输入要下载图片帖子编号:')
url = 'https://tieba.baidu.com/p/%s' % numbers
# 2.发起请求,拿回响应数据
html = get_datasource(url)
# 3.根据源代码获取总页数
total_page = get_totalpage(html)
# 4.根据总页数提取图片、下载图片
parse_href(total_page, html, numbers)
# 执行main函数即可执行爬虫
main()
day 6
正则表达式
# coding:utf-8
# python 内置re模块 ,用来支持正则表达式
import re
# 正则表达式
string = 'abcccccccdedfdggds'
# 1. 构造正则表达式
# a.* 贪婪模式 匹配到全部
# a.*?非贪婪模式 匹配到a 尽可能少的匹配字符
pattern = re.compile('a.*b')
# 2.使用正则表达式,在大字符串中搜索数据
# match()1.正则表达式 2.要进行搜索的字符串
# match()如果搜索的字符是以正则表达式开头的字符,则可以搜索到结果
# 返回结果对象,如果搜不到,则返回none
rs = re.match(pattern, string)
# 判断结果是否为空,如果为空,就不取值
if rs:
print rs.group()
else:
print '没有查询结果'
# search() 搜索函数 不需要以正则表达式开头,只要在大字符中存在,符合
# 正则表达式,就可以查到,会搜索第一个匹配的数据
pattern1 = re.compile('b.*?d')
# search()1.正则表达式 2.要进行搜索的字符串
rs = re.search(pattern1,string)
if rs:
print rs.group()
else:
print '没有匹配数据'
# findall()会将大字符串中所有符合规则字符全部找到,并且以列表的
# 形式返回,如果搜索不到,会返回一个空列表
# 1.正则 2.搜索字符串
rs = re.findall(pattern1,string)
if rs:
for content in rs:
print content
# r 把后面字符原样保存 原样字符串,不会对字符串中的转义字符进行转译
string_2 = r'1.查找学员\n2.添加学员\n3.退出'
print string_2
# replace() 替换原字符串中某些字符
rs = string_2.replace(r'\n',',')
print rs
# sub()替换原字符串中的某些符合条件的数据
pattern2 = re.compile(r'\\n')
# 1.正则 2.替换后的字符串 3.要进行替换的字符串
rs = re.sub(pattern2, ',', string_2)
print rs
string3 = 'abcdefghijklmn'
pattern3 = re.compile(r'd.*?h')
rs = re.sub(pattern3,'----',string3)
print rs
文件的读写
# coding:utf-8
import os
# 1.打开文件
# open()参数1.要打开的文件名称 2.打开的方式
# w只允许写入 r只读 a追加
# w+读写 r+读写 a+读写
# wb+ 读写二进制数据
# w模式:如果文件不存在,会自动创建文件,如果文件存在,打开文件,并且一旦向
# 文件中写入内容,原来的内容将会被覆盖
# a模式:如果文件不存在,会自动创建文件,如果文件存在,打开文件,并且会一直
# 向文件中追加数据,不会将原来的数据覆盖
# r模式:不会自动创建文件,假设文件不存在,直接抛出异常(报错)
# os.path.exists()判断某文件是否存在,如果存在返回True 不存在返回False
# is_exist = os.path.exists('1.txt')
# if is_exist == True:
# file_handle = open('1.txt','r')
file_handle = open('1.txt', 'a')
# 2.写入数据
# write()
file_handle.write('hello world\n')
file_handle.write('你好\n')
# writelines()将一个存放字符串的列表整个写入文件,不会自动添加换行符
name_list = ['张三', '李四', '王五']
file_handle.writelines(name_list)
# 3.关闭文件
file_handle.close()
# 读取文件内容
is_exist = os.path.exists('1.txt')
if is_exist == True:
# 1.打开文件
file_handle = open('1.txt','r')
# 2.读取文件
# 2.1 read()会将文件中的所有数据都读取出来
content = file_handle.read()
# 2.2 readline()会读取一行数据,会把光标移动到该行末尾,下次再执行readline将会读取下一行
content = file_handle.readline()
print content
# 2.3 readlines()会读取文件中的所有行,把每一行的数据放在列表中返回
con_list = file_handle.readlines()
print con_list
# 3.关闭文件
file_handle.close()
例子
糗事百科(爬虫)
# coding:utf-8
import requests
import re
# 1.准备url
url = 'https://www.qiushibaike.com/'
# 2.发起请求,拿回源代码
response = requests.get(url)
# 取出html源代码
html = response.content
# 需要从html中根据正则匹配到总页数,转化为整数
pattern1 =re.compile(r'class="dots.*?<span.*?>(.*?)</span>', re.S)
rs = re.search(pattern1,html)
# group(index) 根据分组索引
total_page = rs.group(1)
total_page = total_page.strip('\n')
total_page = int(total_page)
print '共%s页段子内容'%total_page
# 1.打开文件
file_hand = open('qsbk.txt','w')
# for 循环获取每一页的html代码
for x in range(1,total_page+1):
print '正在爬取第%s页段子'%x
url = 'https://www.qiushibaike.com/hot/page/%s/'%x
html = requests.get(url).content
# 根据正则匹配每一页的段子内容
# 3.准备正则
# re.S DOTALL 模式,可以用来匹配任意字符
pattern = re.compile(r'<div class=".*?qiushi_tag.*?<h2>(.*?)</h2>.*?'
r'<div class="articleGender.*?>(.*?)</div>.*?'
r'<span>(.*?)</span>.*?<i class="n.*?>(.*?)</i>.*?'
r'<i.*?>(.*?)</i>', re.S)
# 4.查找所有符合规则的数据
rs = re.findall(pattern, html)
# 写入每页的分割线
file_hand.write('=================第%s页===================='%x)
for detail in rs:
# 取出数据
# print detail
name = detail[0]
# strip()函数去除字符中的某些字符
name = name.strip('\n')
age = detail[1]
content = detail[2]
content = content.strip('\n')
# 准备正则
pattern1 = re.compile(r'<br/>')
content = re.sub(pattern1, '\n', content)
vote_number = detail[3]
comment_number = detail[4]
# print '--------------------------------------------------'
# print '用户名:%s 年龄:%s'%(name, age)
# print '好笑数:%s 评论数:%s'%(vote_number, comment_number)
# print content
# print '--------------------------------------------------'
# 写入的段子第二行 用户信息
s1 = '用户名:%s 年龄:%s\n'%(name, age)
file_hand.write(s1)
# 写入段子的第二行 段子评论数 好笑数
s2 = '好笑数:%s 评论数:%s'%(vote_number, comment_number)
file_hand.write(s2)
# 写入段子内容
file_hand.write(content)
file_hand.write('\n\n')
# 3.关闭文件
file_hand.close()
print '数据写入成功'
day 7
例子
百度贴吧(爬虫)
# coding: utf-8
# 引入请求包
import requests
# 引入正则表达式包
import re
# 1.准备url
url = 'https://tieba.baidu.com/p/5082744218'
# 2.获取网页源代码,发起请求接收响应
response = requests.get(url)
html = response.content
# 3.获取网页标题
# 3.1 准备网页标题的正则表达式
title_pat = re.compile(r'<title>(.*?)</title>')
# 3.2 使用search()函数搜索符合正则的字符串
rs = re.search(title_pat, html)
# 3.3 根据当前帖子的标题,拼接文件名称
file_name = rs.group(1)+'.txt'
file_handle = open(file_name.decode('utf-8'),'w')
# 4.获取总页数
# 4.1 准备总页数的正则表达式
pages_pat = re.compile(r'共<span class="red">(.*?)</span>')
# 4.2 使用search()函数搜索符合正则的字符串
rs = re.search(pages_pat, html)
# 4.3 取出总页数字符,转换为整数类型
total_page = int(rs.group(1))
print '该帖子共有%s页!'%total_page
# for循环遍历总页码次
for x in range(1, total_page+1):
print '正在爬取第%s页,请稍后.....'%x
# 5.根据x的值,拼接完整的url地址
url = 'https://tieba.baidu.com/p/5082744218?pn=%s'%x
# 6.发起请求,获取该页的html源代码
response = requests.get(url)
html = response.content
# print html
# 7.准备提取数据的正则,使用re.S 可以匹配到任何字符
pattern = re.compile(r'<li class="d_name".*?<a data-.*?>(.*?)</a>.*?<div class="d_badge_title.*?>(.*?)</div>.*?d_badge_lv">(.*?)</div>.*?<cc>(.*?)</cc>.*?<span class="tail-info.*?<a.*?>(.*?)</a>.*?<spa.*?>(.*?)</spa.*?info">(.*?)</span>', re.S)
# 8.使用findall()查找所有符合正则的字符
rs = re.findall(pattern, html)
# for 循环所有数据
for detail in rs:
# print detail
# 1.取出用户名
name = detail[0]
# 1.1 对用户名信息进行处理
replace_img = re.compile(r'<img.*?>')
# 1.2 替换为-
name = re.sub(replace_img, '-', name)
# 2.取出头衔
rank = detail[1]
# 3.取出等级
level = detail[2]
# 4.楼层内容
content = detail[3]
# 4.1 替换<br>标签为\n
content = content.replace('<br>', '\n')
# 4.2 剔除所有的标签
strip_ele = re.compile(r'<.*?>')
content = re.sub(strip_ele, '', content)
# 4.3 去除空格
content = content.strip()
# print content
# 5.取出客户端
from_device = '来自' + detail[4]
# 如果没有客户端,就设置为来自电脑端
if 'img' in detail[4]:
from_device = '来自PC电脑端'
# 6.取出楼层
floor_num = detail[5]
if 'a' in floor_num:
floor_num = '未知'
# 7.取出时间
datetime = detail[6]
if 'a' in detail[6]:
datetime = '未知'
file_handle.write('***************%s******************\n'%floor_num)
file_handle.write('用户名:%s 头衔:%s 等级%s\n'%(name, rank, level))
file_handle.write(content)
file_handle.write('\n')
file_handle.write('%s 日期:%s\n\n'%(from_device, datetime))
file_handle.close()
任意贴吧中全部帖子信息的爬取(两个.py文件相连接)
bdtb_demo.py
# coding: utf-8
# 引入请求包
import requests
# 引入正则表达式包
import re
# 根据帖子编号和页码获取html源代码
def get_html(number,page):
# 1.根据帖子编号和页码拼接完整的url地址
url = 'https://tieba.baidu.com/p/%s?pn=%s'%(number,page)
# 2.根据url地址请求该页的html地址
response = requests.get(url)
html = response.content
return html
# 获取存储文件名称,给一个html源代码,返回一个存储文件名称
def get_filename(html):
# 3.1 准备网页标题的正则表达式
title_pat = re.compile(r'<title>(.*?)</title>')
# 3.2 使用search()函数搜索符合正则的字符串
rs = re.search(title_pat, html)
print '正在爬取:%s......'%rs.group(1)
# 3.3 根据当前帖子的标题,拼接文件名称
file_name = rs.group(1) + '.txt'
return file_name
# 获取帖子的总页数
def get_total_page(html):
# 4.1 准备总页数的正则表达式
pages_pat = re.compile(r'共<span class="red">(.*?)</span>')
# 4.2 使用search()函数搜索符合正则的字符串
rs = re.search(pages_pat, html)
# 4.3 取出总页数字符,转换为整数类型
total_page = int(rs.group(1))
print '该贴共%s页,正在准备爬取,请稍后...'%total_page
return total_page
# 获取帖子每一页的数据
def get_result_data(total_page, numbers):
# 声明一个大列表 用来存放所有页的数据
result_list = []
# for循环遍历总页码次
for x in range(1, total_page + 1):
print '正在爬取第%s页,请稍后.....' % x
# 传入一个numbers和页码,获取网页源代码
html = get_html(numbers,x)
# 7.准备提取数据的正则,使用re.S 可以匹配到任何字符
pattern = re.compile(
r'<li class="d_name".*?<a data-.*?>(.*?)</a>.*?<div class="d_badge_title.*?>(.*?)</div>.*?d_badge_lv">(.*?)</div>.*?<cc>(.*?)</cc>.*?<span class="tail-info.*?<a.*?>(.*?)</a>.*?<spa.*?>(.*?)</spa.*?info">(.*?)</span>',
re.S)
# 8.使用findall()查找所有符合正则的字符
rs = re.findall(pattern, html)
# 把爬取的这一页数据放入大列表
result_list.append(rs)
# 返回大列表
return result_list
# 根据数据列表和文件名称,存储数据
def save_data(file_name,result_list):
# 1.打开文件
file_handle = open(file_name.decode('utf-8'),'w')
# 2.for循环每一页的数据
for rs in result_list:
# for 循环遍历每一条数据
for detail in rs:
# print detail
# 1.取出用户名
name = detail[0]
# 1.1 对用户名信息进行处理
replace_img = re.compile(r'<img.*?>')
# 1.2 替换为-
name = re.sub(replace_img, '-', name)
# 2.取出头衔
rank = detail[1]
# 3.取出等级
level = detail[2]
# 4.楼层内容
content = detail[3]
# 4.1 替换<br>标签为\n
content = content.replace('<br>', '\n')
# 4.2 剔除所有的标签
strip_ele = re.compile(r'<.*?>')
content = re.sub(strip_ele, '', content)
# 4.3 去除空格
content = content.strip()
# print content
# 5.取出客户端
from_device = '来自' + detail[4]
# 如果没有客户端,就设置为来自电脑端
if 'img' in detail[4]:
from_device = '来自PC电脑端'
# 6.取出楼层
floor_num = detail[5]
if 'a' in floor_num:
floor_num = '未知'
# 7.取出时间
datetime = detail[6]
if 'a' in detail[6]:
datetime = '未知'
file_handle.write('***************%s******************\n' % floor_num)
file_handle.write('用户名:%s 头衔:%s 等级%s\n' % (name, rank, level))
file_handle.write(content)
file_handle.write('\n')
file_handle.write('%s 日期:%s\n\n' % (from_device, datetime))
# 关闭文件
file_handle.close()
print '数据爬取完毕,已存入《%s》,请稍后自行查看'%file_name
# 主函数,启动爬虫程序,进行数据抓取和存储工作
# url 参数:爬取的帖子地址
def start(numbers):
# 1.根据帖子编号,获取html源代码
html = get_html(numbers, 1)
# 2.从第一页的html源代码中提取帖子的名称并且拼接一个完整的文件名称
file_name = get_filename(html)
# 3.从第一页的html源代码中提取帖子的总页数,返回一个数字总页数
total_page = get_total_page(html)
# 4.for循环获取网页中的数据,需要传入总页数和帖子编号
result_list = get_result_data(total_page, numbers)
# 5.写入数据,传入文件名称,传入爬取的所有页数据
save_data(file_name, result_list)
# 启动爬虫
# start(5082744218)
# # 1.准备url
# url = 'https://tieba.baidu.com/p/5082744218'
# # 2.获取网页源代码,发起请求接收响应
# response = requests.get(url)
# html = response.content
# # 3.获取网页标题
#
# file_handle = open(file_name.decode('utf-8'),'w')
# # 4.获取总页数
#
# print '该帖子共有%s页!'%total_page
获取贴吧内每个帖子的链接
# coding:utf-8
import requests
import re
from bdtb_demo import start
# 根据url地址获取html源代码
def get_html(tb_name, pn_num):
url = 'https://tieba.baidu.com/f?kw=%s&tab=good&pn=%s'%(tb_name,pn_num)
html = requests.get(url).content
return html
#根据html源代码,提取总帖子数,计算并返回总页数
def get_total_page(html):
# 准备搜索精品贴个数的正则
count_pat = re.compile(r'精品数<span.*?>(.*?)</span>')
# 找到精品贴个数
rs = re.search(count_pat, html)
# 转换并计算精品贴总页数
counts = int(rs.group(1))
if counts % 50 == 0:
total_page = counts / 50
else:
total_page = counts / 50 + 1
print '共有%s页,%s个精品贴,正在准备爬取,请稍后...'%(total_page,counts)
# 返回总页数
return total_page
def start_bdtb(tb_name,total_page):
for x in range(0,total_page):
print '正在爬取第%s页精品贴'%(x+1)
html = get_html(tb_name,x*50)
# 1.准备正则
pattern = re.compile(r'<div class="threadlist_title.*?herf="(.*?)"', re.S)
# 2.查找符合条件的字符
rs = re.findall(pattern, html)
# for 循环遍历,取出每个帖子的编号
for link in rs:
# split()分割后是一个列表,取出列表中最后一条数据
numbers = link.split('/')[-1]
# 根据帖子编号爬取数据
start(numbers)
def run_spider():
# url = 'https://tieba.baidu.com/f?kw=nba&ie=utf-8&tab=good'
tb_name = raw_input('请输入要爬取的贴吧名称:')
# 获取第一页的数据
html = get_html(tb_name,0)
# 获取总页数
total_page = get_total_page(html)
# 循环总页数次,爬取每一页帖子的编号
start_bdtb(tb_name,total_page)
# 调用函数
run_spider()
day 8
类、对象
# coding:utf-8
# 面向过程的编程语言,如c
# python面向对象的编程语言,封装、继承、多态
# 类:具有相同属性和行为方法的事物的抽象的集合
# 对象:类的具体的实例化
# class:群体、班级、理解为类的意思
# object python中的基类 祖宗类
class People(object):
# 初始化函数,在创建对象时,通过初始化函数给对象属性赋值
# init 函数会在创建对象时,自动调用
def __init__(self,sex,age, height, weight):
# 给对象属性赋值
# 对象.属性名 = 属性值
self.sex = sex
self.age = age
self.height = height
self.weight = weight
# 定义对象功能函数
# 对象函数,只有用对象才能调用
def eat(self):
# self 哪个对象调用这个函数,在函数中self指的就是这个对象
print self
# 创建一个People类的对象
# 对象名 = 类名(属性值1,属性值2,,,,)
p1 = People('男', 0.83,30, 8.8)
# 获取对象属性
# 变量 = 对象.属性名
age = p1.age
print age
# 对象打点调属性在等号的右边 获取属性值
# 对象打点调属性在等号的左边 设置属性值
# 修改或添加对象的属性,如果有这个属性 修改,没有就添加
# 对象.函数名()
p1.eat()
# 动态给对象添加属性
# 对象.属性 = 属性值
p1.name = '张三'
print p1.run(20)
# 删除对象的属性
del p2.name
# print p2.name
表格
#coding:utf-8
# 打开cmd命令行工具(windows+r 输入cmd 回车)
# 输入 pip install xlwt 下载xlwt包
import xlwt
# 创建一个工作簿
workbook = xlwt.Workbook(encoding='utf-8')
# 新增一张表,用于存储数据
sheet = workbook.add_sheet(u'智联招聘python职位表')
# 向表中填写数据
# 1.行号 2.列号 3.要写入的数据
sheet.write(0, 0, '职位名称')
sheet.write(0, 1, '公司名称')
sheet.write(0, 2, '职位月薪')
sheet.write(0, 3, '工作地点')
sheet.write(1, 0, 'Python开发工程师')
sheet.write(1, 1, '智游臻龙科技有限公司')
sheet.write(1, 2, '9000-20000')
sheet.write(1, 3, '郑州')
# 保存工作簿文件
workbook.save(u'智联招聘python职位信息表.xls')
例子
智联招聘、百度贴吧、糗事百科(爬虫)
# coding:utf-8
from link_spider import LinkSpider
from qsbk_demo import QSBK
from zlzp_demo import ZLZP
print '1.百度贴吧数据爬取'
print '2.糗事百科数据爬取'
print '3.智联招聘数据爬取'
sele_num = input('请选择:')
if sele_num == 1:
obj = LinkSpider()
elif sele_num == 2:
obj = QSBK()
else:
obj = ZLZP()
obj.start()
bdtb_demo.py
# coding: utf-8
# 引入请求包
import requests
# 引入正则表达式包
import re
# 百度贴吧爬虫类
class BDTB(object):
# 初始化函数,初始化爬虫需要的基本信息
def __init__(self,numbers):
# 帖子编号
self.numbers = numbers
# 记录帖子的总页数
self.total_page = 0
# 记录当前帖子存储文件的名称
self.filename = ''
# 记录html源代码的属性
self.html = ''
# 记录该贴所有页的数据
self.result_list = []
# 获取html源代码的函数
def get_html(self,page):
# 拼接url地址
url = 'https://tieba.baidu.com/p/%s?pn=%s'%(self.numbers,page)
response = requests.get(url)
self.html = response.content
# 获取要保存的文件名称
def get_filename(self):
title_pat = re.compile(r'<title>(.*?)</title>')
rs = re.search(title_pat,self.html)
print '正在爬取:%s...'%rs.group(1)
# 修改filename的属性
self.filename = rs.group(1) + '.txt'
# 获取总页数
def get_total_page(self):
pages_pat = re.compile(r'共<span class="red">(.*?)</span>')
rs = re.search(pages_pat,self.html)
# 修改total_page属性值
self.total_page = int(rs.group(1))
print '该帖共%s页,正准备爬取,请稍后。。'%self.total_page
# 获取内容
def get_result_data(self):
for x in range(1,self.total_page+1):
print '正在爬取%s页,请稍后。。。'%x
self.get_html(x)
pattern = re.compile(
r'<li class="d_name".*?<a data-.*?>(.*?)</a>.*?<div class="d_badge_title.*?>(.*?)</div>.*?d_badge_lv">(.*?)</div>.*?<cc>(.*?)</cc>.*?<span class="tail-info.*?<a.*?>(.*?)</a>.*?<spa.*?>(.*?)</spa.*?info">(.*?)</span>',
re.S)
rs = re.findall(pattern,self.html)
self.result_list.append(rs)
# 保存数据
def save_data(self):
file_handle = open(self.filename.decode('utf-8'))
for rs in self.result_list:
for detail in rs:
# print detail
# 1.取出用户名
name = detail[0]
# 1.1 对用户名信息进行处理
replace_img = re.compile(r'<img.*?>')
# 1.2 替换为-
name = re.sub(replace_img, '-', name)
# 2.取出头衔
rank = detail[1]
# 3.取出等级
level = detail[2]
# 4.楼层内容
content = detail[3]
# 4.1 替换<br>标签为\n
content = content.replace('<br>', '\n')
# 4.2 剔除所有的标签
strip_ele = re.compile(r'<.*?>')
content = re.sub(strip_ele, '', content)
# 4.3 去除空格
content = content.strip()
# print content
# 5.取出客户端
from_device = '来自' + detail[4]
# 如果没有客户端,就设置为来自电脑端
if 'img' in detail[4]:
from_device = '来自PC电脑端'
# 6.取出楼层
floor_num = detail[5]
if 'a' in floor_num:
floor_num = '未知'
# 7.取出时间
datetime = detail[6]
if 'a' in detail[6]:
datetime = '未知'
file_handle.write('***************%s******************\n' % floor_num)
file_handle.write('用户名:%s 头衔:%s 等级%s\n' % (name, rank, level))
file_handle.write(content)
file_handle.write('\n')
file_handle.write('%s 日期:%s\n\n' % (from_device, datetime))
# 3.关闭文件
file_handle.close()
print '数据爬取完毕,已存入*[%s]*,请稍后自行查看!' % self.filename
# 写一个启动爬虫的函数
def start(self):
self.get_html(1) # self.html = 第一页的html源代码
self.get_filename() # self.filename = 帖子的标题.txt
self.get_total_page() # self.total_page = 帖子的总页数
self.get_result_data() # self.result_list = 该贴所有页的数据
self.save_data() # 保存数据
# # 创建一个对象,传入一个帖子的编号
# bdtb = BDTB(5328438222)
# # 对象执行开始爬虫的函数
# bdtb.start()
link_spider.py
# coding:utf-8
import requests
import re
# 从bdtb_demo中引入BDTB这个类
from bdtb_demo import BDTB
class LinkSpider(object):
def __init__(self):
self.tb_name = ''
# 声明属性用来记录总页数
self.total_page = 0
# 声明属性记录html源代码
self.html = ''
# 获取html源代码函数,需要一个page参数
def get_html(self,page):
url = 'https://tieba.baidu.com/f?kw=%s&ie=utf-8&tab=good&pn=%s' % (self.tb_name, (page * 50))
response = requests.get(url)
# 修改对象的html属性值
self.html = response.content
# 获取所有页码
def get_total_page(self):
count_pat = re.compile(r'精品数<span.*?>(.*?)</span>')
rs = re.search(count_pat, self.html)
counts = int(rs.group(1))
if counts % 50 == 0:
total_page = counts / 50
else:
total_page = counts / 50 + 1
print '共有%s页,%s个精品贴,正在准备爬取,请稍后......' % (total_page, counts)
# 修改对象的total_page 属性值
self.total_page = total_page
# 获取所有页数据
def get_result_data(self):
for x in range(0, self.total_page):
print '正在爬取第%s页精品贴.....' % (x + 1)
# 修改了对象的html属性值
self.get_html(x)
# 1.准备正则
pattern = re.compile(r'<div class="threadlist_titl.*?href="(.*?)"', re.S)
# 2.查找符合条件的字符
rs = re.findall(pattern, self.html)
# for循环遍历,取出每一个帖子的编号
for link in rs:
# split()分割之后是一个列表,取出列表中中最后一条数据
numbers = link.split('/')[-1]
# 创建BDTB对象,执行start爬虫
bdtb = BDTB(numbers)
bdtb.start()
def start(self):
tb_name = raw_input('请输入要爬取的贴吧名称:')
self.tb_name = tb_name
self.get_html(0)
self.get_total_page()
self.get_result_data()
# link = LinkSpider()
# link.star()
qsbk_demo.py
# coding: utf-8
import requests
import re
class QSBK(object):
def __init__(self):
# html属性保存html源代码
self.html = ''
self.total_page = 0
self.result_data = []
def get_html(self, page):
url = 'https://www.qiushibaike.com/hot/page/%s/'%page
response = requests.get(url)
self.html = response.content
def get_total_page(self):
pattern1 = re.compile(r'class="dots.*?<span.*?>(.*?)</span>', re.S)
rs = re.search(pattern1, self.html)
# group(index)根据分组索引 查找内容
total_page = rs.group(1)
total_page = total_page.strip('\n')
self.total_page = int(total_page)
print '共%s页段子内容!' % total_page
def get_result_data(self):
# for 循环获取每一页的html源代码x
for x in range(1, self.total_page + 1):
print '正在爬取第%s页段子....' % x
self.get_html(x)
pattern = re.compile(
r'<div class=".*?qiushi_tag.*?<h2>(.*?)</h2>.*?<div class="articleGender.*?>(.*?)</div>.*?<span>(.*?)</span>.*?<i class="n.*?>(.*?)</i>.*?<i.*?>(.*?)</i>',
re.S)
# 4.查找所有的符合规则的数据
rs = re.findall(pattern, self.html)
self.result_data.append(rs)
def save_data(self):
file_handle = open('qsbk.txt', 'w')
for x in range(1, len(self.result_data)+1):
rs = self.result_data[x-1]
# 写入每页的分割线
file_handle.write('=================第%s页===============\n' % x)
for detail in rs:
# 取出数据
name = detail[0]
# strip函数()去除字符串中的某些字符
name = name.strip('\n')
age = detail[1]
content = detail[2]
content = content.strip('\n')
# 准备正则
pattern1 = re.compile(r'<br/>')
# 使用sub函数做替换
content = re.sub(pattern1, '\n', content)
vote_number = detail[3]
comment_number = detail[4]
# 写入的段子第一行 用户信息
s1 = '用户名:%s 年龄:%s\n' % (name, age)
file_handle.write(s1)
# 写入的段子第二行 段子评论数 好笑数
s2 = '好笑数:%s 评论数:%s\n' % (vote_number, comment_number)
file_handle.write(s2)
# 写入段子内容
file_handle.write(content)
file_handle.write('\n\n')
# 3.关闭文件
file_handle.close()
def start(self):
self.get_html(1)
self.get_total_page()
self.get_result_data()
self.save_data()
zlzp_demo.py
# coding:utf-8
import requests
import re
import xlwt
# 智联招聘的爬虫类
class ZLZP(object):
def __init__(self):
self.html = ''
self.nextlink = ''
self.filename = ''
self.headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0'}
self.result_data = []
# 根据url获取源代码
def get_html(self):
# 携带请求头
response = requests.get(self.nextlink, headers=self.headers)
self.html = response.content
# 获取搜索职位首页的url地址
def get_index_url(self):
# 把kw设置为属性
self.kw = raw_input('请输入要爬取的职位名称:')
city_list = []
# 输入查询的城市,最多五个
while len(city_list) < 5:
city = raw_input('请输入要查询的城市(最多5个,输入0结束):')
if city == '0':
break
city_list.append(city)
# 可以把列表中的每一条数据使用字符串隔开,最终返回一个字符串
citys = '%2B'.join(city_list)
# 拼接第一页的url地址,并赋值给nextlink
self.nextlink = 'https://sou.zhaopin.com/jobs/searchresult.ashx?jl=%s&kw=%s'%(citys, self.kw)
# 获取下一页的链接
def get_next_link(self):
pattern = re.compile(r'<li class="pagesDown.*?<a.*?href="(.*?)" class="next-page">',re.S)
rs = re.search(pattern,self.html)
# 如果搜索到结果,说明有下一页链接
if rs:
self.nextlink = rs.group(1)
else:
self.nextlink = None
# 获取所有页的数据
def get_result_data(self):
# 只要有下一页的链接,执行获取数据
count = 0
while self.nextlink:
count += 1
print '正在爬取第%s页数据.....' % count
# 获取html源代码
self.get_html()
# 准备正则
pattern = re.compile(r'<table class="newlist.*?<td class="zwmc.*?<a.*?>(.*?)</a>.*?<td class="gsmc.*?<a.*?>(.*?)</a>.*?<td class="zwyx.*?<a.*?>(.*?)</a>', re.S)
rs = re.findall(pattern,self.html)
# 把所有的数据添加到大列表
self.result_data.append(rs)
# 获取下一页链接
self.get_next_link()
# 保存数据
def save_data(self):
# 创建工作簿
workbook = xlwt.Workbook(encoding='utf-8')
sheet = workbook.add_sheet(u'%s职位表'%unicode(self.kw, 'utf-8'))
sheet.write(0, 0, '职位名称')
sheet.write(0, 1, '公司名称')
sheet.write(0, 2, '职位月薪(最低)')
sheet.write(0, 3, '职位月薪(最高)')
sheet.write(0, 4, '工作地点')
# 从1行开始写入
count = 1
# for循环遍历所有页数据
for rs in self.result_data:
for detail in rs:
# 去除职位名称中的标签
strip_ele = re.compile(r' |<.*?>')
# 取出 职位名称 公司名称 职位月薪 工作地点
zwmc = re.sub(strip_ele, '', detail[0])
gsmc = detail[1]
zwyx = detail[2]
if '-' in zwyx:
min_money = zwyx.split('-')[0]
max_money = zwyx.split('-')[1]
else:
min_money = max_money = '面议'
gzdd = detail[3]
sheet.write(count, 0, zwmc)
sheet.write(count, 1, gsmc)
sheet.write(count, 2, min_money)
sheet.write(count, 3, max_money)
sheet.write(count, 4, gzdd)
# 行号+1
count += 1
# 保存
workbook.save(u'%s职位爬取数据.xls' % unicode(self.kw, 'utf-8'))
# 启动爬虫
def start(self):
self.get_index_url()
self.get_html()
self.get_result_data()
self.save_data()
# zlzp = ZLZP()
# zlzp.start()
day 9
浏览器(火狐、Google)
# coding: utf-8
# 打开cmd命令行 输入pip install selenium 下载包
# 从selenium中引入webdriver
from selenium import webdriver
# 引入时间模块
import time
# 1.创建浏览器对象,并打开浏览器
driver = webdriver.Firefox()
# 2.在浏览器中访问网址
driver.get('http://www.baidu.com')
# 当前页的网页源代码
# print driver.page_source
# 根据id查找某个标签
# element = driver.find_element_by_id('kw')
# # 输入搜索关键词
# element.send_keys(u'淘宝')
# 通过id找到百度一下按钮
news_link = driver.find_element_by_link_text('新闻')
# # 执行点击操作
news_link.click()
# 程序休眠3秒
time.sleep(3)
# 退出浏览器
driver.quit()
# element 不加s 找到的是一个标签
# driver.find_element_by_id() # 根据id查找
# driver.find_element_by_class_name() # 根据class查找
# driver.find_element_by_css_selector() # 根据css选择器查找
# driver.find_element_by_name() # 根据name查找
# driver.find_element_by_link_text() # 根据链接文本查找
# elements 查找多个符合条件的标签,并且返回一个列表
# rs = driver.find_elements_by_class_name('mnav')
# print rs
例子
淘宝(爬虫)
# coding:utf-8
from selenium import webdriver
import time
# 1.创建浏览器对象
driver = webdriver.Firefox()
# 2.打开淘宝首页
driver.get('http://www.taobao.com')
# 3.找到搜索框
search_ele = driver.find_element_by_id('q')
# 4.输入搜索关键词
search_ele.send_keys(u'笔记本电脑')
# 5.找到搜索按钮
search_btn = driver.find_element_by_class_name('btn-search')
# 6.点击按钮
search_btn.click()
# 打开文件
file_handle = open('shops.txt', 'w')
for i in range(1, 11):
print '正在爬取第%s页数据。。。。'%i
# 让浏览器滚动加载数据
for x in range(1, 11, 2):
# 暂停1秒开始滚动
time.sleep(0.5)
j = x/10.0
# %f float小数类型的占位符
js = 'document.documentElement.scrollTop = document.documentElement.scrollHeight * %f'%j
#执行js代码
driver.execute_script(js)
# 浏览器滚动结束后,取出数据
# 找到所有的class名称为info-cont的标签
shops = driver.find_elements_by_class_name('info-cont')
# for循环遍历列表,取出每一个商品
for shop in shops:
# 写入数据 编码
file_handle.write(shop.text.encode('utf-8'))
# 写入换行符
file_handle.write('\n\n')
# 查找下一页
next_page = driver.find_element_by_link_text('下一页')
next_page.click()
# 关闭文件
file_handle.close()
day 10
练习 电影天堂
movie.demo
# coding:utf-8
import requests
import re
class ListDetail(object):
def __init__(self):
self.html = ''
self.movie_list = []
self.headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:53.0) Gecko/20100101 Firefox/53.0'}
def get_html(self,page):
url = 'http://www.ygdy8.net/html/gndy/dyzz/list_23_%s.html'%page
response = requests.get(url, headers=self.headers)
self.html = response.content
def get_movie_list(self):
for x in range(1,11):
self.get_html(x)
# 准备正则
pattern = re.compile(r'<td height="26".*?<a href="(.*?)" class="ulink',re.S)
movies = re.findall(pattern,self.html)
self.movie_list.append(movies)
# print self.movie_list
def start(self):
self.get_html(1)
self.get_movie_list()
# list_detail = ListDetail()
# list_detail.start()
# num_list = [[1,2,3],['a','b','c'],['A','B','C']]
# for x in range(0,len(num_list)):
# for num in num_list[x]:
# print num
movie.detai
# coding:utf-8
import requests
import re
import xlwt
from movie_demo import ListDetail
list_detail = ListDetail()
class MovieDetail(object):
def __init__(self):
self.detail_html = ''
self.headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:53.0) Gecko/20100101 Firefox/53.0'}
# self.html_list = []
def get_detail_html(self):
for x in range(0,1):
for y in range(0,len(list_detail.movie_list[0])):
# for movie_link in list_detail.movie_list[0]:
# print movie_link
url = 'http://www.ygdy8.net%s'% list_detail.movie_list[x][y]
response = requests.get(url, headers=self.headers)
html = response.content
self.detail_html = unicode(html, "gb18030").encode("utf8")
print url
def get_result_data(self):
count = 0
workbook = xlwt.Workbook(encoding='utf-8')
sheet = workbook.add_sheet(u'电影详情表')
sheet.write(0, 0, '电影名称')
sheet.write(0, 1, '电影类别')
sheet.write(0, 2, '上映时间')
sheet.write(0, 3, '电影片长')
sheet.write(0, 4, '下载地址')
for x in range(0,10):
for y in range(0,len(list_detail.movie_list[0])):
url = 'http://www.ygdy8.net%s'% list_detail.movie_list[x][y]
response = requests.get(url, headers=self.headers)
html = response.content
self.detail_html = unicode(html, "gb18030").encode("utf8")
pattern = re.compile(r'<div class="title_all.*?src=.*?名(.*?)<br />.*?别(.*?)<br />.*?上映日期(.*?)<br />.*?长(.*?)<br />.*?href=".*?>(.*?)</a>',re.S)
rs = re.findall(pattern, self.detail_html)
for detail in rs:
count += 1
name = detail[0]
movie_class = detail[1]
date = detail[2]
time = detail[3]
address = detail[4]
sheet.write(count, 0, name)
sheet.write(count, 1, movie_class)
sheet.write(count, 2, date)
sheet.write(count, 3, time)
sheet.write(count, 4, address)
workbook.save(u'电影详情表.xls')
def start(self):
list_detail.start()
# self.get_detail_html()
self.get_result_data()
# print list_detail.movie_list[0][0]
MD = MovieDetail()
MD.start()
day 11
xpath
# coding: utf-8
import requests
# lxml 包 专门用处理一些html和xml的 打开cmd命令 输入pip install lxml
# 引入etree模块
from lxml import etree
# xpath 一组特定的规则,可以根据特殊的语法结构,匹配网页中的数据
# // 从当前的标签开始查找
# @ 表示获取属性或者根据属性查找
# //a[@class="archive-title"] 找到class为archive-title的所有的a标签
# //a[@class="archive-title"]/@href 找到class为archive-title的所有的a标签中的href属性值
# //nav[@id="top-nav"]/div/div[1] 根据id查找标签 并且找到div下第1个div
# //img 找到所有的img标签
# //div[@class="post-meta"]/p[1]/text() 获取第一个p标签中直接文本内容,不包含子标签的内容
# //div[@class="post-meta"]/p[1]//text() //双斜杠,获取包含子标签文本在内的文本内容
url = 'http://blog.jobbole.com/all-posts/'
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0'
}
resposne = requests.get(url,headers=headers)
# 将html源代码转换为树形结构数据
html = etree.HTML(resposne.content)
# 根据xpath从html中提取img标签,返回的是列表,列表中存放就是找到的标签对象
# imgs = html.xpath('//img')
# for img in imgs:
# # 查找img标签src属性值
# src = img.xpath('@src')
# print src
links = html.xpath('//a[@class="archive-title"]/text()')
for link in links:
# 找到href属性值,返回的是列表,可以取出列表中的第0个元素
href = link.xpath('@href')[0]
title = link.xpath('text()')[0]
print u'博客标题:%s 链接:%s'%(title, href)
例子
用xpath做电影天堂的爬虫
# coding: utf-8
import requests
from lxml import etree
import xlwt
headers = {
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0'
}
# 1.url
url = 'http://www.ygdy8.net/html/gndy/dyzz/index.html'
# 2.发起请求,接受响应
response = requests.get(url, headers=headers)
# 3.转成树形节点结构
html = etree.HTML(response.content)
# //select[@name="sldd"]/option[last()]/text() last()找到多个标签中的最后一个标签
total_page = html.xpath('//select[@name="sldd"]/option[last()]/text()')[0]
print '共有%s页电影信息,正在准备爬取!'%total_page
workbook = xlwt.Workbook(encoding='utf-8')
sheet = workbook.add_sheet(u'最新电影信息')
sheet.write(0, 0, '电影名称')
sheet.write(0, 1, '电影类型')
sheet.write(0, 2, '电影时长')
sheet.write(0, 3, '电影下载地址')
count = 0
# 循环遍历所有页
for x in range(1,int(total_page)+1):
print '正在爬取第%s页数据,请稍后....'%x
# 根据x的值,拼接完整页面url地址
url = 'http://www.ygdy8.net/html/gndy/dyzz/list_23_%s.html'%x
response = requests.get(url, headers=headers)
html = etree.HTML(response.content)
# 4.使用xpath查找所有的href属性值
hrefs = html.xpath('//a[@class="ulink"]/@href')
# for循环取出所有的href值
for href in hrefs:
count += 1
print '正在爬取第%s个电影信息..'%count
# 拼接完整的url地址
detail_url = 'http://www.ygdy8.net%s'%href
# 发送请求,拿回详情页面的数据
detail_response = requests.get(detail_url, headers=headers)
# print detail_response.content
# 转换树形节点结构
detail_html = etree.HTML(detail_response.content)
# 根据xpath从详情页提取数据
movie_info = detail_html.xpath('//div[@id="Zoom"]//text()')
# for中存放的就是电影的所有信息
for movie in movie_info:
if u'译 名' in movie:
movie_name = movie.split(u' ')[-1]
elif u'类 别' in movie:
movie_type = movie.split(u' ')[-1]
elif u'片 长' in movie:
movie_time = movie.split(u' ')[-1]
download_url = detail_html.xpath('//tbody/tr/td/a/@href')[0]
sheet.write(count, 0,movie_name)
sheet.write(count, 1,movie_type)
sheet.write(count, 2,movie_time)
sheet.write(count, 3,download_url)
workbook.save(u'电影天堂数据.xls')
scrapy框架
1. windows+r打开cmd命令行工具,cd Desktop进入到桌面目录
2. 输入创建项目命令 scrapy startproject 项目名
3. cd 到 项目目录下 cd项目名
4. 执行创建爬虫的命令 scrapy genspider 爬虫名 爬虫起始网址
5. 使用pycharm打开项目,查看项目目录结构
6. 启动爬虫,找到pycharm自带的命令行工具输入启动爬虫命令 scrapy crawl 爬虫名(例如:jobs),回车即可
PS:可以使用另外一种方式以debug模式启动爬虫,可以断点调试
6.1 新建一个py文件,例如debug.py,在该文件中写入以下代码,右键debug运行即可使用断点调试
6.2修改robots协议
day 12-14
学习scrapy框架(不一一整理) 中间穿插学习一点html css知识点。接下来总结完成作业:
爬取http://www.ivsky.com/tupian/ziranfengguang//网页的照片,分类整理到不同文件然后放入一个文件夹,再生成表格,存放图片的名称,类别,下载地址。
debug.py
# coding:utf-8
from scrapy.cmdline import execute
execute(['scrapy','crawl','hwt_tt'])
hwt_tt.py
# -*- coding: utf-8 -*-
import scrapy
from ..items import ImgItem
class HwtTtSpider(scrapy.Spider):
name = 'hwt_tt'
allowed_domains = ['ivsky.com']
start_urls = ['http://www.ivsky.com/tupian/ziranfengguang//']
def parse(self, response):
# 根据xpath找到每一类图片详情页面的链接
detail_links = response.xpath('//div[@class="il_img"]/a/@href').extract()
# for 循环遍历所有图片的链接
for link in detail_links:
# 拼接完整的url地址
detail_url = 'http://www.ivsky.com' + link
# yield 一个请求对象
yield scrapy.Request(
url = detail_url,
callback=self.parse_detail
)
# 找到下一页
next_href = response.xpath('//a[@class="page-next"]/@href').extract_first('')
if next_href:
# 拼接下一页完整的url地址
next_url = 'http://www.ivsky.com' + next_href
yield scrapy.Request(next_url)
# 解析详细页面
def parse_detail(self,response):
# 获取图片分类
classify = response.xpath('//div[@class="al_tit"]/h1/text()').extract_first('')
# 获取每一张图片页面详细地址
detail_links = response.xpath('//div[@class="il_img"]/a/@href').extract()
# for 循环遍历所有图片的链接
for link in detail_links:
# 拼接完整的url地址
detail_url = 'http://www.ivsky.com' + link
# yield 一个请求对象
yield scrapy.Request(
url=detail_url,
callback=self.parse_list,
meta={'classify': classify}
)
# 解析高清图片页面
def parse_list(self,response):
classify = response.meta['classify']
# 获取图片标题
title = response.xpath('//div[@id="al_tit"]/h1/text()').extract_first('')
# 获取高清图片下载地址
img_src = response.xpath('//img[@id="imgis"]/@src').extract_first('')
#所有高清图片下载地址、标题、分类 存放入列表中
img = ImgItem()
img['title'] = title
img['classify'] = classify
img['img_src'] = [img_src]
yield img
items.py
import scrapy
class ImgItem(scrapy.Item):
# 图片标题
title = scrapy.Field()
# 图片分类
classify = scrapy.Field()
# 下载地址
img_src = scrapy.Field()
pipelines.py
import xlwt
class HwtSpiderPipeline(object):
def __init__(self):
self.workbook = xlwt.Workbook(encoding='utf-8')
self.sheet = self.workbook.add_sheet(u'图片信息表')
self.sheet.write(0,0,'图片标题')
self.sheet.write(0,1,'图片分类')
self.sheet.write(0,2,'下载地址')
self.count = 1
def close_spider(self,spider):
self.workbook.save(u'天堂网图片信息.xls')
def process_item(self, item, spider):
self.sheet.write(self.count,0,item['title'])
self.sheet.write(self.count,1,item['classify'])
self.sheet.write(self.count,2,item['img_src'][0])
self.count += 1
return item
from scrapy.pipelines.images import ImagesPipeline
import scrapy
# 自定义图片下载pipelines 指定图片存放目录
class MyImagePipeline(ImagesPipeline):
# 获取图片下载的请求
def get_media_requests(self, item, info):
# 取出图片下载的url地址
url = item['img_src'][0]
# 根据url地址创建请求对象
request = scrapy.Request(
url=url,
meta={"item":item}
)
return [request]
def file_path(self, request, response=None, info=None):
item = request.meta['item']
classify = item['classify']
title = item['title'] + '.jpg'
return '%s/%s'%(classify,title)
settings.py
断点调试