[Python知识库]python学习记录（基础知识+案例实现）

day01

1、变量

"""
变量
    在内存中创建一个空间，专门存储数据
    name = zhangsan
    命名规范
        不能以数字、特殊字符开头，不能以关键字命名
        英文单词、数字、下划线的组合
        first_name_1 = 'zhangsan'
        大驼峰
            FirstName = 'zhangsan'
        小驼峰
            firstName = 'zhangsan'
    见名知意


    第一次出现变量名就是定义
    后续再次出现相同变量名时就是重新赋值
"""

name = '张三'
name = '李四'
print(name)

2、数据类型

"""
number
    int     <class 'int'>
    float   <class 'float'>
    bool    <class 'bool'>

"""

num = 100
print(num)
print( type(num) )

folat_1 = 100.123
print(folat_1)
print( type(folat_1) )

bool_1 = True  # False
print(bool_1)
print(type(bool_1))

"""
字符串
    单引号
    双引号
    三引号
    区别
        单引号、双引号 存储单行的数据
        三引号 存储多行数据
    <class 'str'>

    序列
        下标、索引

"""
name = '暴走萝莉'
name = "孙尚香"
# name = """马克菠萝"""
print(name)
print(type(name))

str1 = "好看的皮囊千篇一律，有趣的灵魂万一挑一"
# 从左边往右边进行计算 0、1、2、3、4、5。。。。
# 从右边往左边进行计算 -1、-2、-3、-4.。。
# 单个提取字符
# str1[下标数值]
print( str1[0] )
print( str1[-1])
print( len(str1)  )
# 范围（多个）提取
# str1[起始下标 ： 结束下标 -1 ]
# 左闭右开的原则
# 0 <= 范围 < 2
print( str1[0:2])
print( str1[:])  #如果不写起始位置或者不写结束位置，默认从0开始，到结尾
print( str1[::] ) #两个冒号 作用同上
# print( str1[17:19])
# print( str1[:2])
# print( str1[10:])
# print( str1[-2:])

# 步长 step
# str1[ :: step]
# str1[ 0:3  ]
print( str1[::3] )
# print( str1[10:2])
print( str1[::-2]  )

# 提取后面字符 有趣的灵魂万一挑一  并且进行倒叙
print(  str1[10::-1]  )
str2 = str1[10:]
print(str2[::-1])

print( str1[10:][::-1]   )

3、列表、元组

"""
列表
    []  <class 'list'>
    一个存储容器
    可以存储任意的类型
    增删改查的操作
    列表也是一个序列

"""
list_1 = []
print( list_1)
print( type(list_1))

# 根据关键字创建空列表
list_2 = list()
print( list_2)
print( type(list_2))

list_3 = ['周一','周二','周三','周四','周五']
# 查找操作，
print( list_3[-1] )
# 范围查找
print( list_3[0:3])  # 列表范围提取，返回的也是一个列表的类型

# 添加元素
#1、append( 添加的元素内容  )   #只添加到列表的最后
list_3.append('周六')
print(list_3)
#2、insert(第一参数添加的位置， 第二参数添加的元素)   可在任意位置进行添加
list_3.insert(1,'周天')
print(list_3)
#3、extend(添加多元素内容)  # 同时添加多个元素
list_4 = [1,2,3,True]
list_3.extend(list_4)
print(list_3)
#4、拼接 +        并不是在原来的列表中进行添加，而是组合成了新的元素。
list_3 = [0, False, '周一'] + list_3
print(list_3)

#删除
# remove( 你要删除的元素 )   从左到右边第一个匹配到的内容，进行删除
list_3.remove(False)
list_3.remove(False)
list_3.remove('周一')
print(list_3)
#  pop()  移除列表中最后一位
# 如果不需要这个移除的元素，不用变量进行接收
# 用变量进行接受一下
# res = list_3.pop()
# print(res)

#
# del list_3[0]
# print(list_3)

# del list_3
# print(list_3)  #会报一个没有定义的错误
# print(  abcd )

#更改元素   先定位到这个元素，然后再重新赋值
list_3[0] = '周天'
print(list_3)



#排序
# list_5 = [5,6,3,9,2,8,1,8,4]
# print(list_5)
# print( list_5[::-1] )
# list_5.sort()  # 这个方法么有返回值  从小到大顺序
# print(  list_5.sort()  )
# print(list_5)
# list_5.reverse() # 反转
# print(list_5)

# list_5.sort( reverse=True  )
# print(list_5)```

```python
"""
元组
    ()  <class 'tuple'>

    特点
        元组的元素是不可以更改的


"""
#创建方法一
tuple_1 = ()
print(tuple_1)
print(type(tuple_1))
#方法二
tuple_2 = tuple()


#查询方法
# 根据下标索引进行定位
tuple_3 = ('周一','周二','周三','周四','周五')
print(tuple_3)
print( tuple_3[0] )
print( tuple_3[2:])    #返回的是元组类型



# 类型的转换
# 元组类型转换成列表
list_1 = list(tuple_3)
list_1.append('周六')
print(list_1)
tuple_3 = tuple(list_1)
print(tuple_3)


#拼接
tuple_3 = tuple_3 + ('周天',)
print(tuple_3)

# res = ('周天',)  # 当元组 只有一个元素的时候，元素后面必须要加一个英文逗号
# print(res)
# print(type(res))

4、set集合、字典

"""
set集合
    {}
    特点
        去重
        无序

"""
#创建
set_1 = set()
print(set_1)
print(type(set_1))

# set_2 = {}   如果以大括号来创建空集合的话，必然是一个字典类型
# print(set_2)
# print(type(set_2))

set_3 = { '周一','周二','周三','周四','周五','周五','周一' }
print(set_3)

# 查找不行
# print(  set_3[0] )

# 更改也不行
# 删除
set_3.remove('周一')
print(set_3)
# set_3.pop()

#添加元素
set_3.add( 123  )
print(set_3)
set_3.update( ['周天','周六'] )   # extend
print(set_3)


set_4 = { 3,6,5,8, '周天','周六',4,9,7,2,1,6,8,2 }  # 如果set集合里面有数值，会进行排序
print(set_4)

"""
字典
    常用的特殊容器

    { key ： value , key:value, key:value }

    <class 'dict'>

    key是不可以更改， 唯一的
    value可以是任意类型，随意更改


"""
# 创建
dict_1 = {}
print(dict_1)
print(type(dict_1))
#
dict_2 = dict()
print(dict_2)
print(type(dict_2))

dict_3 = {'name': '张三', 'class': 1, 1.123: [1, 2, 3]}
print(dict_3)


# 查找
# 根据字典的 key来定位，获取value
print( dict_3['name'] )
print( dict_3[1.123] )
# print( dict_3['hobby'])  # 在查找过程中，没有这个key，会返回一个 keyerror

# 更改   先定位到这个位置，然后在重新赋值  , 必须是有这个key，进行赋值操作，是更改
dict_3['class'] = 10
print(dict_3)

# 添加     必须没有这个key，进行赋值操作，就是添加
dict_3['hobby'] = '玩游戏'
print(dict_3)

# 删除
del dict_3['hobby']
print(dict_3)
# del dict_3
# print(dict_3)


#获取所有的key
print( dict_3.keys()  )  #返回的就是之前定义的所有key

#获取所有的value
print( dict_3.values() ) # 返回的就是定义的所有值
#获取所有的key 和 value
print( dict_3.items() ) # [ (key,value),(key,value),(key,value) ]

5、分支结构

"""
分支结构
    if 条件表达式:
        代码块...
    else:
        代码块...

    条件表达式
        返回 要么为true  要么为False

    True：正数、负数、不包含0的 其他所有非空的字符串、列表、元组、集合、字典。。
    False：0、None、null、其他所有为空的 字符串、列表、元组、集合、字典。。

    else 可写可不写

"""
a = 1
if a < 10 :
    print('正确')
else:
    print('错误')

# if -0.01:
#     print('正确')
# else:
#     print('错误')

#逻辑运算
# and
# if [0] and {0} and 0 :
#     print('正确')
# or
# if [] or {} or 1 < 2 or 1+1 != 2:
#     print('正确')
# not
# if not [0]:
#     print('打印输出正确')

# 多重判断
"""
if 条件表达式:
    代码块...
elif 条件表达式：
    代码块。。。
elif 条件表达式：
    代码块
else：
    代码块
    
如果第一个条件表达式为True，那么后面的所有判断将不会在执行
如果第一个为False，那么紧跟着判断第二个条件是否为True，
"""
if True:
    print('第一条件表达式成立')
elif True:
    print('第二条件表达式成立')
elif True:
    print('第三条件表达式成立')
else:
    print('不成立')


# 嵌套判断

a = 1
b = 5
if a**a < b:
    a +=1  # 2
    b *= 2 # 10
    if b*5 < 50:
        print('正确')
    else:
        print('错误')

day02

1、分支结构

"""
分支结构
    if 条件表达式:
        代码块...
    else:
        代码块...

    条件表达式
        返回 要么为true  要么为False

    True：正数、负数、不包含0的 其他所有非空的字符串、列表、元组、集合、字典。。
    False：0、None、null、其他所有为空的 字符串、列表、元组、集合、字典。。

    else 可写可不写

"""
a = 1
if a < 10 :
    print('正确')
else:
    print('错误')

# if -0.01:
#     print('正确')
# else:
#     print('错误')

#逻辑运算
# and
# if [0] and {0} and 0 :
#     print('正确')
# or
# if [] or {} or 1 < 2 or 1+1 != 2:
#     print('正确')
# not
# if not [0]:
#     print('打印输出正确')

# 多重判断
"""
if 条件表达式:
    代码块...
elif 条件表达式：
    代码块。。。
elif 条件表达式：
    代码块
else：
    代码块
    
如果第一个条件表达式为True，那么后面的所有判断将不会在执行
如果第一个为False，那么紧跟着判断第二个条件是否为True，
"""
if True:
    print('第一条件表达式成立')
elif True:
    print('第二条件表达式成立')
elif True:
    print('第三条件表达式成立')
else:
    print('不成立')


# 嵌套判断

a = 1
b = 5
if a**a < b:
    a +=1  # 2
    b *= 2 # 10
    if b*5 < 50:
        print('正确')
    else:
        print('错误')

2、函数

"""
函数
    用过哪些函数
        print() 控制台输出打印
        input() 键盘输入
        type()  查看数据类型的
        len()   返回长度
    什么是函数
        有特定功能、完成指定任务的一段代码块
    为什么使用函数
        可以隐藏代码的实现细节
        提高代码的复用性
        代码的可读性、可维护性
    定义
        def 自定义名称(参数1，参数2，参数3.。。。):
            函数体
            return
    参数：
        形参：形式上的参数，并没有实际意义，也可以称之为占位符，在定义函数的地方出现
        实参：实际的参数，在调用函数的地方出现
    传递参数的方法
        位置传递：按照位置的先后顺序进行传递参数
        关键字传递： 在调用地方，传递变量值，通过变量名称去定义函数地方找寻，
                    有没有相对应的关键字，如果没有，报错。
                    如果有这个关键字，那么会把这个变量值赋值给这个关键字

    return
        返回一个值：默认是什么类型就返回什么类型
        返回多个值：默认是元组类型
        自定义返回值： 设定返回的 类型
        不返回值： 是空类型
"""
#定义一个函数
def addition( a , b ):
    c = a + b
    return
#调用函数
res = addition( ['10'], ['20'] )
print(type(res))
print( res )


res_2 = addition( b=30, a=50)
print(type(res_2))
print(res_2)

3、类和对象

"""
面向过程
    面向过程的核心思想就是以 过程为主，流水线式的一套生产模式
    优点
        简单明了，方便理解
    缺点
        扩展性差
    应用范围
        linux、git代码管理工具

面向对象
    面向对象的核心思想就是以 对象为主。想知道对象是什么，先把自己当成上帝，看待一切事务都是对象。
    优点
        扩展性强
    缺点
        可控性差
    应用范围
        应用用户层，抖音、快手 游戏

类、对象\实例、实例化
类：类别、物以聚类。相同属性、相同行为的事务的统称为类
对象： 在类中的一个具体事例 称之为对象
实例化： 从类生成到对象的一个过程 称之为实例化

定义
    class 自定义变量名():
        属性
        行为方法

"""
#创建学生类
class Student():
    #属性
    name = ''
    age = 0
    userid = ''
    #行为方法
    def eat(self):
        # self： 谁调用方法，谁就是self
        # zhangsan调用的eat方法， zhangsan就是self，
        # zhangsan = self
        # zhangsan.name   zhangsan.age,  zhangsan.userid
        # self.name   self.age,   self.userid
        print(self.name, '正在吃饭')
        # self.sleep()  ?
        self.sleep()

    def sleep(self):
        print(self.name, '正在休息')
# 创建对象
zhangsan = Student()
# 通过对象访问属性
# 对象名.属性名
zhangsan.name = '张三'
zhangsan.age = 20
zhangsan.userid = '001'
print( zhangsan.name )
#通过对象访问行为
#对象名.方法名(),  如果不加括号的话，只是查看这个方法的地址信息。加上括号才是调用
zhangsan.eat()


lisi = Student()
lisi.name = '李四'
lisi.age = 21
lisi.userid = '002'
lisi.eat()

4、初始化方法

"""
初始化方法
    构造方法

    __init__
    运行类的第一个启动方法，就是初始化方法

"""
class Student(object):

    def __init__(self, name, age, userid):
        print('我是一个初始化方法')
        # self.name 是创建的对象属性
        self.name = name
        self.age = age
        self.userid = userid

    def sleep(self):
        print('正在休息')

zhangsan = Student(  '张三', 20, '001' )

print( zhangsan.name )

5、学生管理系统

"""
1、欢迎界面
    1、
    2、
    3、
    ...
2、数据保存位置：内存
3、一个是针对学生信息录入保存， 对象
    另一个是针对这个系统的增删改查
4、添加学生信息
    键盘输入input
    添加到对象里（集合）进行保存
5、删除学生信息
    先判断，集合中有没有学生信息
    如果有学生信息
        通过某个属性来定位学生，进行删除
    没有学生信息
        提示先录入才可进入删除模块
6、更改学生信息
    先判断，集合中有没有学生信息
    有
        通过某个属性定位学生，进行更改操作
    没有
        提示录入才可以进入更改模块
7、查询学生
    直接遍历显示学生信息
8、退出
"""

# 创建学生保存对象功能
class Student:
    def __init__(self, name , age, userid):
        self.name = name
        self.age = age
        self.userid = userid


# 创建管理的类
class studentManage():
    def __init__(self):
        #创建 保存的集合容器
        self.data = set()

    def addStudent(self):
        #添加学生信息方法
        name = input('请输入学生姓名：')
        age = input('请输入学生年龄：')
        userid = input('请输入学生学号：')
        # 把输入的内容，保存到学生对象中
        stu = Student(name, age, userid)
        #将学生对象保存到set集合里
        self.data.add(stu)
        print('添加学生{} 成功！'.format(name))

    def delStudent(self):
        #删除学生信息方法
        if self.data:
            uid = input('请输入需要删除的学生id：')
            # { stu1, stu2, stu3, stu4 }
            for stu in self.data:
                #循环出来的内容，都是每个对象
                if stu.userid == uid:
                    #如果学号相等，我们就可以删除这个学生对象
                    print('学生{}信息删除成功！'.format( stu.name ))
                    self.data.remove(stu)
                    # break
                    return

            else: # 因为，集合中如果没有查找到的学生，需要进行提示
                print('当前集合没有找寻到删除的学生')
        else:
            print('你需要先录入学生信息之后再进入删除功能！')

    def updateStudent(self):
        #更改学生信息
        if self.data:
            uid = input('请输入需要更改的学生学号:')
            for stu in self.data:
                if stu.userid == uid:
                    #将学生对象属性重新赋值
                    stu.name = input('重新输入姓名：')
                    stu.age = input('重新输入年龄：')
                    return
            else:
                print('当前集合没有找寻到此学生')
        else:
            print('你需要先录入学生信息之后再进行更改的功能！')

    def showStudent(self):
        #展示学生信息
        for stu in self.data:
            print("{}\t\t\t{}\t\t\t{}".format(stu.name,stu.age,stu.userid))


    def run(self):
        #启动方法
        while True:
            print('欢迎来到管理系统')
            print('1、添加学生信息')
            print('2、删除学生信息')
            print('3、更改学生信息')
            print('4、查找学生信息')
            print('5、退出')
            num = input('请输入选择的编号：')
            if num == '1':
                self.addStudent()
            elif num == '2':
                self.delStudent()
            elif num == '3':
                self.updateStudent()
            elif num == '4':
                self.showStudent()
            else:
                print('退出')
                break


sm = studentManage()
sm.run()

day03

1、爬虫

"""
爬虫基础
    是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本。

爬虫的分类
    通用网络爬虫
        从一些种子url扩充到整个web页面
        一般都是搜索引擎： 百度、必应、搜狗、谷歌
    聚焦(主题)网络爬虫
        有目的性的爬虫，是指选择性地爬取定义好的主题相关内容
    增量式网络爬虫
        对下载网页采取增量式更新和只爬取新产生的数据，或者说是已经发生变化的网页
    深度网络爬虫
        对于一些提交表单信息、需要查询参数的网页，采取的爬取方式是深度网络爬虫

爬虫的原理

数据的分类
    用户产生的数据：百度指数、微信朋友圈
    政府产生的数据：
    公司管理的数据：聚合数据
    爬虫

数据能干什么
    人工智能、机器学习、数据分析
    alphago 围棋
    李世石、柯洁
    卖

robots协议
    网站跟爬虫之间的协议，txt格式的文件，告诉对方哪些站点不能访问，哪些是可以访问的。

反爬
    ip封禁，  代理ip
    验证码
        静态
            图片验证码
            文字验证
        动态
            苹果验证
    文字混淆
        douyin
    js加密
        通过你逆向js
    点击验证码
    滑动验证码
    cookie  身份验证
    九宫格图片点选
    滑动轨迹

静态数据
    在页面中包含的所有数据   html、css、js、img、 data
动态数据
    二次加载的数据

chrmoe 进行调试

url
请求头
请求数据


cookie
session
"""

2、requests

"""
requests
    网络请求库   urllib
    模拟浏览器发送请求

安装requests
    pip install -i https://pypi.douban.com/simple requests

"""

import requests

#get方法
#1、先指定url地址
url = "https://www.baidu.com"
douban_url = "https://movie.douban.com/subject/35422807/comments"
#2、指定请求头
hd = {
    "user-agent": "Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36 Edg/96.0.1054.29"
}
#3、请求
res = requests.get(douban_url, headers=hd)
# print(res)
#4、响应
#状态码
# print( res.status_code )
# 头部信息
# print( res.headers )
# 文本  源码
# print( res.text)
# json数据
# print( res.json() )
# 二进制流
print( res.content )

3、英雄联盟所有的英雄皮肤图片案例

"""

1、目的 下载所有的英雄皮肤图片
2、分析网页
    1、找寻所有英雄
    2、查看单个英雄皮肤内容
    3、根据英雄皮肤的页面 进行分析接口（皮肤的接口是通过英雄的id进行加载）
        https://game.gtimg.cn/images/lol/act/img/js/hero/1.js?ts=2729565
"""
import requests
import time

# 保存文件的方法
def save_img( data , filename):
    # data是图片的二进制流
    with open('./img/{}.jpg'.format(filename), 'wb') as file:
        file.write( data )
        print('{}图片下载成功！'.format(filename))


# 访问提取单个英雄的皮肤
def get_hero_skins( heroId ):

    url = "https://game.gtimg.cn/images/lol/act/img/js/hero/{}.js?ts=2729565".format(heroId)
    hd = {
        "user-agent":"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36"
    }
    res = requests.get(url, headers=hd)
    data = res.json()
    skins = data['skins']
    for skin in skins:
        # print(skin)
        mainImg = skin['mainImg']
        heroName = skin['name']
        if mainImg:
            print(mainImg)
            img_res = requests.get(mainImg)
            # 保存文件
            save_img(img_res.content, heroName)


#获取所有的英雄id
def get_hero_ids():
    url = "https://game.gtimg.cn/images/lol/act/img/js/heroList/hero_list.js?ts=2729567"
    hd = {
        "user-agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36"
    }
    res = requests.get(url, headers=hd)
    data = res.json()
    heros = data['hero']
    for hero in heros:
        # hero是个字典
        heroId = hero['heroId']
        print(heroId,  '='*100)
        get_hero_skins(heroId)
        time.sleep(1)# 强制等待1秒
get_hero_ids()

# get_hero_skins()

4、json

"""
json数据
    特点
        跟python中的字典格式是一摸一样
        json数据必须要用双引号来表示
    轻量级的数据交互格式

    { key:value, key:value }


"""
import json

# json_1 = '{"name":"张三", "age":18}'
# print( type(json_1))
# print(json_1)
# # json字符串转化成字典格式
# data = json.loads(json_1)
# print(data)
# print(type(data))

# '单引号'的json字符串是否可以转化成字典
# json_2 = "{'name':'张三','age':18}"
# data = json.loads(json_2)
# print(data)

# 字典转化成json数据   如不想转义中文， 可使用 ensure_ascii=False
dict_1 = {'name':'张三'}
res = json.dumps(dict_1, ensure_ascii=False)
print(res)
print(type(res))

dict_2 = {"name":"张三"}
res_2 = json.dumps(dict_2, ensure_ascii=False)
print(res_2)

day04

1、 requests-post

"""
post方法
    某些网站需要提交表单信息才会返回数据的请求
    例如，登录、注册

"""
import requests

# 请求的地址
url = "https://passport.17k.com/ck/user/login"
# 请求头
hd = {
    "user-agent":"Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36 Edg/96.0.1054.29"
}

# 表单的数据
data = {
    "loginName":"13168837959",
    "password":"a343105980"
}


res = requests.post(url, headers=hd,  data=data)
# print(res)
# 响应头
set_cookie = res.headers['Set-Cookie']
split_res_list = set_cookie.split(';')  # 根据set_cookie里的token值，进行提取
cookie = ''
for i in split_res_list:
    if 'accessToken' in i:
        cookie = i.split(',')[-1].strip()
print(cookie)


# 书架的接口链接
books_url = "https://user.17k.com/ck/author/shelf?page=1&appKey=2406394919"
# 请求头中，添加cookie身份令牌
hd2 = {
    "user-agent": "Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36 Edg/96.0.1054.29",
    "cookie":cookie
}
res_books = requests.get(books_url, headers=hd2)
# 处理编码
res_books.encoding = 'utf-8'
print( res_books.status_code)
books_data = res_books.json()
data_list = books_data['data']
for i in data_list:
    bookName = i['bookName']
    print(bookName)

2、链家网案例

"""
链家网的详细信息

1、目的：爬取房源信息
    房源的标题
    位置
    户型
    总价
    单价/平米

2、链接  https://zz.lianjia.com/ershoufang/rs%E5%B0%8F%E5%8C%BA/
3、分析是否静态或动态页面
4、针对性标签定位

"""
import time
import csv
import requests
from urllib.parse import quote
from bs4 import BeautifulSoup

# url编码
# wd = '小区'
# res = quote(wd)
# print(res)

class LianJia():
    def __init__(self):
        self.base_url = "https://zz.lianjia.com/ershoufang/pg{}rs{}"
        self.headers = {
            "user-agent": "Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36 Edg/96.0.1054.29"
        }

        file = open('链家网.csv', 'w', encoding='utf-8-sig', newline='')
        self.csv_file = csv.writer(file)
        self.csv_file.writerow(['房源名','地理位置','户型朝向','总价','单价'])


    def requests_get(self, url, headers):
        # 请求
        return requests.get(url , headers=headers)

    def parse(self, html):
        #进行解析提取数据
        soup = BeautifulSoup(html, 'html.parser')

        div_list = soup.find_all('div', attrs={"class":"info clear"})
        for div in div_list:
            # print(div)
            # 获取名称标题
            title = div.find('div', attrs={"class":"title"}).find('a').string
            print(title)
            # 获取位置
            positionInfo = div.find('div', attrs={"class":"positionInfo"}).text.strip()
            print(positionInfo)
            # 获取房间信息
            houseInfo = div.find('div', attrs={"class":"houseInfo"}).text
            print(houseInfo)
            # 获取总价
            totalprice = div.find('div', attrs={"class":"totalPrice totalPrice2"}).text.strip()
            print(totalprice)
            # 获取单价
            unitPrice = div.find('div', attrs={"class":"unitPrice"}).text
            print(unitPrice)

            self.csv_file.writerow([
                title,
                positionInfo,
                houseInfo,
                totalprice,
                unitPrice
            ])
            print('='*200)



    def run(self):
        #启动函数

        for page in range(1,10):
            url = self.base_url.format( page,  quote('小区'))
            #请求链接
            res = self.requests_get(url, self.headers)
            self.parse(res.text)
            time.sleep(1)




LianJia().run()

day05

1、selenium

"""
selenium
    Selenium是一个用于Web应用程序测试的工具。Selenium测试直接运行在浏览器中，就像真正的用户在操作一样

    代码 > 驱动 > 浏览器
    chrome
        版本
            版本 96.0.4664.45（正式版本） （32 位）
    chromedriver
            网址  https://npm.taobao.org/mirrors/chromedriver/
            对应版本  96....

    安装selenium
        pip install selenium

"""
#导入selenium模块
from selenium import webdriver
import time
# 创建driver对象
driver = webdriver.Chrome(executable_path='C:\chromedriver_win32\chromedriver.exe')
# 浏览器最大化
driver.maximize_window()

# driver 访问网址
# driver.get('https://www.baidu.com')
driver.get('https://www.jd.com/')

# # 1、找寻到输入框
# kw = driver.find_element_by_css_selector('#kw')
# # 2、输入内容
# kw.send_keys('中国知网')
# # 3、找寻到百度一下按钮
# su = driver.find_element_by_css_selector('#su')
# # 4、点击这个按钮
# su.click()

time.sleep(3)


# 在浏览器中截图
# driver.save_screenshot('百度一下.png')


# lg_img = driver.find_element_by_css_selector('#s_lg_img_new')
# lg_img.screenshot('百度log.png')

#  {{http://www...}}
# 获取当前页面的源码
# html = driver.page_source
# print(html)
# time.sleep(999)


#执行js脚本
for i in range(20):
    driver.execute_script('window.scrollBy(0,500);')
    time.sleep(1)

2、网易云音乐案例

"""
网易云音乐下载

"""

import requests
from bs4 import BeautifulSoup


#指定访问链接
url = "https://music.163.com/artist?id=11127"  # 歌手主页的链接，里面有50首歌曲
#请求头
hd = {
    "user-agent":"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36"
}
res = requests.get(url, headers=hd)
# print(res.text)
html = res.text

#创建soup对象
soup = BeautifulSoup(html, 'html.parser')
# span标签得到的内容为空
# span_all = soup.find_all('span', attrs={"class":"txt"})
# for span in span_all:
#     a = span.find('a')
#     print(a)
#     print('='*100)
# ul标签
a_list = soup.find('ul', attrs={"class":"f-hide"}).find_all('a')
for a in a_list:

    # 提取标签中的属性 href
    # 第一种方式提取属性
    href = a['href']
    # 第二种方式提取属性
    # href2 = a.attrs['href']
    # print(href2)
    ids = href[9:]
    # ids = href.split('=')[-1]
    # 歌曲名称
    name = a.text
    song_url = 'https://music.163.com/song/media/outer/url?id=' + ids
    print(song_url)

    #请求这个歌曲链接，进行保存下载
    song_res = requests.get(song_url)
    with open('./音乐/{}.mp3'.format(name), 'wb') as f:
        f.write(song_res.content)
    print('='*100)