Python 记录

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'&nbsp;|<.*?>')
                # 取出 职位名称 公司名称 职位月薪  工作地点
                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

断点调试