Python

渔阳镇节度使

已于 2024-06-13 21:59:41 修改

阅读量338

点赞数 10

分类专栏：学习笔记文章标签： python 开发语言

于 2024-05-19 12:23:18 首次发布

本文链接：https://blog.csdn.net/Forbidden_City/article/details/139039474

版权

学习笔记专栏收录该内容

13 篇文章 1 订阅

订阅专栏

在这里插入图片描述

第一个python程序

print('hello world')

运行python程序的两种方式

'''
运行python程序的两种方式：

方式一：交互式 直接输入代码运行

    最好用来测试代码

        cmd

        使用方法 win + R

    输入python启动，要有环境变量添加的情况下才能启动

    优点：

        输入一行代码立刻就返回

    缺点：

        无法永久保存代码

方式二： 运行python文件

    cmd 运行python文件

    1.python python文件的绝对路径

    2.python python文件的相对路径(这个是必须切换到python运行文件的文件夹下)  tab可以补全

    3.pycharm运行python代码，右键代码空白部分run

    优点：

        pycharm自动保存代码

        语法错误pycharm可以自动检查红色波浪线

    注意： python文件的后缀名是py
'''

在这里插入图片描述

变量

'''
什么是变量
量：是衡量/记录现实世界中的某种特征/状态
变：指的是记录的状态是可以发生变化的
'''
'''
为什么要用变量
    是为了让计算机能够像人一样去将一个事物的特征/状态记忆下来（存到计算机内存）
    以后可以取出来使用

'''
'''
如何使用变量
'''
# 定义变量的语法
name = '大海'
# 变量名：相当于一个门牌号，是访问的唯一方式
# # = ：是赋值
# # 值 ： 表示状态
# 变量的使用
print('大海')
print(name)
# name = '小红'
# print(name)
# 变量的命名规则
# 1见名知意
# 2变量名的第一个字符不能是数字
# 3变量名只能是字母、数字或下划线的任意组合，（区分大小写）
a1 = '小明'
print(a1)
# 形容一个复杂的变量
# 下划线
age_of_dahai = 18
# 驼峰体
AgeOfDahai = 18

# 常量(全部写大写)：就是不变的量 可以改，告诉别人不能改
NAME = '小海'

# 变量的特性
# 1.id相当于在内存中位置或者地址
print(id(name))
print(id(NAME))
# 2.类型
print(type(name))
print(type(NAME))

字符串类型

#字符类型：str
#作用：记录描述性质的数据，比如人的名字、性别、家庭地址、公司简介
#定义：在引号内按照从左到右的顺序依次包含一个个字符，引号可以是单引号、双引号、三引号
name = '大海1'
name1 = "大海2"
name2 = '''大海3'''
print(name,name1,name2)
# 字符串里面要有引号
print('my name is "dahai"')
print("my name is 'dahai'")

# 字符串还可以加起来
print('大海'+'dsb')
print('大海'*10)

name4 = 'abcdef'
# 索引从0开始，现实中书本的页码从1开始
# 取出第一个英文字符
print(name4[0])
print(name4[1])
print(name4[-1])# 取出最后一个英文字符
# 取出第一个中文字符
print(name[0])

用户与交互

'''
什么是与用户交互
    程序等待用户输入一些数据，然后程序执行完毕后为用户反馈信息
为何程序要与用户交互
    为了让计算机能够像人一样与用户的交互
如何用
    input输入
    print输出
'''
## cmd输入和输出不需要input和print 用于测试
# input(提示用户的输入信息) 输入的数据都会变成字符串类型
name = input('>>>')
print(name)

print(type(name))
print(type(1111))

在这里插入图片描述

字符串之格式化输出

'''
# 程序中经常会有这样场景：要求用户输入信息，然后打印成固定的格式
#
#     比如要求用户输入用户名和年龄，然后打印如下格式：
#
#     My name is xxx，my age is xxx.
这就用到了占位符，如：%s、%d
'''
name = input('输入名字')
# # 一个值的话直接放到%后面
print('my name is %s'%name)
# %s 占位符 可以接受所有的数据类型 %d只能接受数字 有局限性
# 多个值的话直接放到%后面要有括号
print('My name is %s，my age is %d'%('dahai',18))

在这里插入图片描述

数字类型

#一：数字类型
# 整型int
#作用：记录年龄，等级，QQ号，各种号码
# 定义：
age = 18
print(type(age))
# 2.浮点型：float
#作用：记录身高、体重weight、薪资
#定义：
weight = 151.2
print(type(weight))

在这里插入图片描述

数字类型之运算符

# 算术运算
# age = 18
# print(type(age))
# 加 +
# 减 -
# 乘 *
# 除 /
# 地板除 //
# 取余 %
# 乘方 **
# print(2+2)
# print(2-2)
# print(2*3)
# print(int(4/2))
# print(7//3)# 取整
# print(7%3) # 余数是1
# print(4**2)

# 比较运算符
# 等于 ==
# 不等于 !=
# 大于 >
# 小于 <
# 大于或等于 >=
# 小于或等于 <=
print(3 == 4)
print(3 == 3)
# 返回对就是True，False就是错误的
print(3 != 3)
print(3 > 2)
print(3 < 3)
print(3 < 3)
print(4 >= 4)
print(4 <= 5)
print(type('4 <= 5'))

在这里插入图片描述

布尔类型

在这里插入图片描述

复数类型

# 复数类型complex 是一个线性的参数(了解)
x = 1 - 2j
print(type(x))

在这里插入图片描述

列表类型（LIST）

# 字符串，数字，布尔，复数 都是一个值
'''
# 列表类型：list
#作用：记录/存多个值，可以方便地取出来指定位置的值，比如人的多个爱好，一堆学生姓名
#定义：在[]内用逗号分隔开多个任意类型的值
'''
L = ['大海',1,1.2,[1.22,'小海']]
#     0     1  2   3
print(L)
# # 索引从0开始  相当于我们书的页码
print(L[0])
print(L[1])
print(L[2])
print(L[3]) # 正向取
print(L[-1]) # 反向取
print(L[-2]) # 反向取
print(L[3][1])
xiaohai_list=L[3]
print(xiaohai_list)
print(xiaohai_list[1])
L[0]='红海'
print(L)

在这里插入图片描述

字典类型（MAP）

'''
#字典类型:dict
#作用:记录多个key:value值,优势是每一个值value都有其对应关系/映射关系key,而key对value有描述性的功能
#定义: 在{}内用逗号分隔开多个key:value元素,其中value可以是任意的数据类型,而key通常应该是字符串类型
'''
info = {'name':'大海','age':18}
# name 相当于新华字典里面的偏旁部首
print(info['name'])
print(info['age'])
print(info)
# 列表和字典的区别
# 列表是依靠索引
# 字典是依靠键值对 # key描述性的信息

在这里插入图片描述

元组类型

#一：基本使用：tuple
# 1 用途：记录多个值，当多个值没有改的需求，此时用元组更合适
# 2 定义方式：在()内用逗号分隔开多个任意类型的值
t = (1,2,'大海',(2,3),['红海',2,3])
print(t)
print(type(t))
print(t[0])
# t[0]=5
print(t)
print(t[4][0])

在这里插入图片描述

集合类型

#一：基本使用:set
# 1 用途: 关系运算
# 2 定义方式: 在{}内用逗号分开个的多个值
# 3. 1.元素不能重复(定义不能这样写相同的)
#    2.集合里面的元素是无序
s = {1,2,'大海'}
print(s)
print(type(s))
s1 = {'a','b','c'}
s2 = {'a','c','d'}

print(s1 & s2) # # 拿2个集合相同的元素 shift + 7交集符合  交集
print(s1 | s2)# 拿2个集合所有的元素  并集
print(s1 - s2)# s1 去 抵消它们的交集 差集

在这里插入图片描述

数据类型常用操作和方法

#字符类型：str
#作用：记录描述性质的数据，比如人的名字、性别、家庭地址、公司简介
#定义：在引号内按照从左到右的顺序依次包含一个个字符，引号可以是单引号、双引号、三引号
# name = '大海1'
# name1 = "大海2"
# name2 = '''大海3'''
# print(name,name1,name2)
# # 字符串里面要有引号
# print('my name is "dahai"')
# print("my name is 'dahai'")
#
# # 字符串还可以加起来
print('大海'+'dsb')
print('大海'*10)

# name4 = 'abcdef'
# 索引从0开始，现实中书本的页码从1开始
# 取出第一个英文字符
print(name4[0])
print(name4[1])
print(name4[-1])
# # 取出第一个中文字符
# print(name[0])
#字符串不能通过索引修改
# name4[0] = 'g'
# print(name4)
msg = 'hello world'
#      012345
print(msg[0])
print(msg[-1])
#2、切片(顾头不顾尾，步长)查找字符串当中的一段值 [起始值:终止值:步长]
#   相当于切黄瓜 一节一节
print(msg[0:5])
print(msg[0:5:1])
# 提取不会改变原值
print(msg)
print(msg[0:5:2])
# 了解
print(msg[::])
print(msg[0::])
print(msg[0::2])
# 步长是负数
print(msg[::-1])
print(msg[10::-1])
print(msg[10:5:-1])
#3、长度len方法 可以计算长度
print(len(msg))
#4、成员运算in和not in: 判断一个子字符串是否存在于一个大的字符串中
# 返回布尔类型 True False
print('dahai' in 'dahai is dsb')
print('xialuo' not in 'dahai is dsb')

# 字符串的方法
# 增
# 字符串拼接
print('dahai'+'dsb')

# format
print('my name is {}'.format('dahai'))
print('my name is {1} my age is {0}'.format(18,'dahai'))
print('my name is {name} my age is {age}'.format(age=18,name='dahai'))
# join
str1 = '真正的勇士'
str2 = '敢于直面惨淡的人生'
str3 = '敢于正视淋漓的鲜血'
# 可以把列表里面的元素组合成字符串
print(''.join([str1,str2,str3]))
print(','.join([str1,str2,str3]))
print('哇塞'.join([str1,str2,str3]))
# 空格也属于字符
print('  '.join([str1,str2,str3]))
# 删
# name1 = 'dahai'
#
# del name1
# print(name1)
# 改
#1、 字符串字母变大写和变小写 lower,upper
msg1 = 'abc'
msg2=msg1.upper()
# 原值
print(msg1)
print(id(msg1))
# 修改后的值
print(msg2)
print(id(msg2))
# 注意字符串进行改变需要重新赋值，所以它也是不可变类型，它的原值的变量不会变，
# 只是做了一个方法改变了它的值，重新赋值给一个新的变量

# 2把第一个字母转换成大写 capitalize
letter = 'abcd'
print(letter.capitalize())
#3 每个单词的首字母进行大写转换 title
letter_msg = 'hello world'
print(letter_msg.title())

# 4把字符串切分成列表  split 默认空格字符切分
msgg = 'hello world python'
# 默认以空格切分
print(msgg.split())
# 可以切分你想要的字符 比如*
msgg1 = 'hello*world*python'
print(msgg1.split('*'))
#切分split的作用:针对按照某种分隔符组织的字符串，可以用split将其切分成列表，进而进行取值
msggg = 'root:123456'
print(msggg[0:4])
print(msggg.split(':')[0])
print(msggg.split(':')[1])
#5、去掉字符串左右两边的字符strip不写默认是空格字符，不管中间的其他的字符
user = '      dahai      '
print(user)
print(user.strip())
# name = input('请输入用户名').strip()
# print(name)

# 了解
# center,ljust,rjust 多余添加自己想要的字符
print('dahai'.center(11,'*'))#11表示总共有11个字符串
print('dahai'.ljust(11,'*'))
print('dahai'.rjust(11,'*'))
# 查
#1、find,index
# 查找子字符串在大字符串的那个位置（起始索引）
msga = 'hello dahai is dsb dahai'
print(msga.find('dahai'))
# 没找到会返回-1
print(msga.find('ddddd'))


print(msga.index('dahai'))
# 没找到会报错
# print(msga.index('ddddd'))
# 统计一个子字符串在大字符串中出现的次数 count
print(msga.count('dahai'))

# 判断一个字符串里的数据是不是都是数字 isdigit # 返回布尔值
num = '1818'
num1 = '18aaa18'
aaaa = 'aaa'
print(num.isdigit())
print(num1.isdigit())
# print(type(input('>>>')))
# 判断每个元素是不是都是字母 isalpha
print(aaaa.isalpha())
print(num.isalpha())
print(num1.isalpha())
# 比较开头的元素是否相同 startswith
# 比较结尾的元素是否相同 endswith
# 返回布尔类型
mm = 'dahai xialuo'
print(mm.startswith('dahai'))
print(mm.endswith('uo'))
# 判断字符串中的值是否全是小写的 islower
# 判断字符串中的值是否全是大写的 isupper
letter2 = 'ABC'
letter3 = 'abc'
letter4 = 'aAbc'
print(letter2.isupper())
print(letter3.isupper())
print(letter4.isupper())
print(letter2.islower())
print(letter3.islower())
print(letter4.islower())
# 字符串的转义
# 字符串的转义   加了 \  字符不再表示它本身的含义
# 常用的  \n  \t
# \n 换行符
print('hello \n python')
# \t 横向换行符 相当于一个tab
print('hello \t python')
# 取消换行标识符
print(r'hello \n python \t')
print('hello \\n python \\t')

数字类型转换和赋值运算

#一：数字类型
# 整型int
#作用：记录年龄，等级，QQ号，各种号码
# 定义：
age = 18
print(type(age))
# 2.浮点型：float
#作用：记录身高、体重weight、薪资
#定义：
weight = 151.2
print(type(weight))

# 赋值运算
# 普通赋值 =
# 加法赋值 +=
# 减法赋值 -=
# 乘法赋值 *=
# 除法赋值 /=
# 取余赋值 %=
# 乘方赋值 **=
# 地板除赋值 //=
# 语法 n = n + XXX 相等于 n += XXX
n = 2
# n = n + 3
# 等价于
# n += 3
# print(n)
n -= 1   # n = n - 1
print(n)

布尔类型的特性

'''
#布尔类型:bool
#作用:用来作为判断的条件去用
#布尔值，一个True一个False
#计算机俗称电脑，即我们编写程序让计算机运行时，
应该是让计算机无限接近人脑，或者说人脑能干什么，
计算机就应该能干什么，
# 人脑的主要作用是数据运行与逻辑运算，此处的布尔类型就模拟人的逻辑运行，
即判断一个条件成立时，用True标识，不成立则用False标识
'''
# tag = True
# tag = False
# print(type(tag))

# 重点知识
# 不仅仅是真假 还是有无
# 所有的数据类型都自带布尔值
# 1.None,0,空(空字符串，空列表，空字典,)三种情况下布尔值为False,
# 2.其余均为真
# if
tag1 = {'name':'dahai'}
print(bool(tag1))
#tag2=[]
#tag2=''
tag2={}
if tag1:
    print('数据类型自带True')
else:
    print('数据类型自带False')

列表的常用操作和内置方法

# 字符串，数字，布尔，复数 都是一个值
'''
# 列表类型：list
#作用：记录/存多个值，可以方便地取出来指定位置的值，比如人的多个爱好，一堆学生姓名
#定义：在[]内用逗号分隔开多个任意类型的值
'''
L = ['大海',1,1.2,[1.22,'小海']]
#     0     1  2   3
# print(L)
# # # 索引从0开始  相当于我们书的页码
# print(L[0])
# print(L[1])
# print(L[1])
# print(L[1])
# print(L[1])
# print(L[-1]) # 反向取
# print(L[3]) # 正向取
# print(L[3][1])
# xiaohai_list=L[3]
# print(xiaohai_list)
# print(xiaohai_list[1])
print(L)
print(id(L))
# 把原值改了
L[0]='红海'
print(L)
print(id(L))
# 2、切片(顾头不顾尾，步长)
# 查找列表当中的一段值 [起始值:终止值:步长]
# 和字符串提取字符一样,只不过字符串取的是字符，列表取的是一个数据类型/元素
# 但是字符串不能索引改值
# 默认步长为1
print(L[0:3])
print(L[0:3:1])
print(L[0:3:2])
# 3.len长度  列表元素的多少
print(len(L))
# 4.成员运算in和not in
print('红海' in L)
print('红海'not  in L)
# 查看列表某个元素的个数 count
print(L.count('红海'))
# 在列表中从左至右查找指定元素，找到了放回该值的下标/索引
print(L.index('红海'))
# print(L.index('海'))
#增

# append(元素) 往列表末尾追加一个元素
L.append('蓝海')
print(L)
# 规律列表的修改和增加都不需要重新复制，直接改变了原值，所以是可变类型
# 字符串，数字，布尔，复数 都是一个值，改变需要重新赋值，都是不可变类型
L.append('蓝海')
print(L)
# extend() 往列表当中添加多个元素 括号里放列表 也是末尾追加
L.extend(['绿海','紫海'])
# L.extend(['绿海','紫海'])
print(L)
# insert(索引，元素) 往指定索引位置前插入一个元素
L.insert(1,'黄海')
print(L)
# 删除

# del L[0]
# print(L)
# 指定删除
# L.remove('紫海')
# print(L)
# pop # 从列表里面拿走一个值
# # 按照索引删除值
# # 默认是删除最后一个
# L.pop()
# print(L)
# res=L.pop(0)
# # 返回值指定的索引元素
# print(res)
# print(L)
# 清空列表clear
# L.clear()
# print(L)
# 改
# L[0]='白海'
# print(L)
# 反序
# L.reverse()
# print(L)
# sort 排序 对数字
list_num = [1,3,2,5]
# 不写默认是正序
# reverse=True参数是倒序
list_num.sort(reverse=True)
print(list_num)
# reverse=False参数是正序
list_num.sort(reverse=False)
print(list_num)

元组的常用操作和内置方法

#一：基本使用：tuple
# 1 用途：记录多个值，当多个值没有改的需求，此时用元组更合适
# 2 定义方式：在()内用逗号分隔开多个任意类型的值
t = (1,2,'大海',(2,3),['红海',2,3])
#    0 1   2     3     4
print(t)
print(type(t))
print(t[0])
# 不能索引修改，
# t[0]=5
print(t)
print(t[4][0])

# t[3][0]=1
# 但是元组里面的列表是可以改的
t[4][0]='小海'
print(t)
# 元组是不能修改和添加所以元组是不可变类型
# 如果想修改可以转换成列表
t1=list(t)  #转列表
print(t1)   
t1[0]=8
t= tuple(t1)#转元组
print(t)
# 查
# 与列表一样索引，切片，长度len，count个数，index查找元素所在索引，成员运算

# del t[0]

字典的常用操作和内置方法

'''
#字典类型:dict
#作用:记录多个key:value值,优势是每一个值value都有其对应关系/映射关系key,而key对value有描述性的功能
#定义: 在{}内用逗号分隔开多个key:value元素,其中value可以是任意的数据类型,而key通常应该是字符串类型
'''
info = {'name':'大海','age':18}
# name 相当于新华字典里面的偏旁部首
# print(info['name'])
# print(info['age'])
# print(info)
# 列表和字典的区别
# 列表是依靠索引
# 字典是依靠键值对 # key描述性的信息

# 生成字典的方式2
# dic = dict(x=1,y=2)
# print(dic)
# 字典的增加操作
print(info)
# 直接赋值一个不存在的key和value
info['addr']='changsha'
print(info)
# 字典我在添加的时候也没有进行重新赋值，所以字典是可变类型
# 列表却不行,添加和修改必须是操作存在的索引
# 字典 len 查看的是键值对的个数
print(len(info))

# 成员运算in和not in:字典的成员运算判断的是key 返回值是布尔类型
print('name'in info)
print('大海' in info)
# 删
# clear   清空字典
# info.clear()
# print(info)
# del
# del info['name']
# print(info)
# 不存在的key会报错
# del  info['xxx']
# print(info)

# # pop 删除 返回值是value   实际上就是拿走了字典的value
# res = info.pop('addr')
# print(info)
# print(res)
# # 不存在的key会报错
# info.pop('xxx')
# # popitem 最后一对键值对删除 字典无序 返回的是一个元组
# res1=info.popitem()
# print(res1)
# print(info)
# # 改
print(info)
info['name']='红海'
print(info)
info.update({'name':'xiaohai'})
print(info)
# setdefault
# 有则不动/返回原值,无则添加/返回新值
# 字典中已经存在key则不修改,返回已经存在的key对应的value
res=info.setdefault('name','xxx')
print(info)
print(res)
# 字典不存在key则添加"sex":"male",返回新的value
res2 = info.setdefault('sex','male')
print(info)
print(res2)

# 查
# print(info['name'])
# # 查一个不存在的key会报错
# print(info['xxx'])

# print(info.get('name'))
# # 没有key就返回None，不会报错
# print(info.get('xxxx'))

# 取出所有的key
print(list(info.keys()))
# 取出所有的值
print(list(info.values()))
# 取出所有的键值对
print(list(info.items()))

集合的常用操作和内置方法

#一：基本使用:set
# 1 用途: 关系运算
# 2 定义方式: 在{}内用逗号分开个的多个值
# 3. 1.元素不能重复(定义不能这样写相同的)
#    2.集合里面的元素是无序
# s = {1,2,'大海'}
# # print(s)
# # print(type(s))
# # s1 = {'a','b','c'}
# # s2 = {'a','c','d'}
# #
# # print(s1 & s2) # # 拿2个集合相同的元素 shift + 7交集符合  交集
# # print(s1 | s2)# 拿2个集合所有的元素  并集
# # print(s1 - s2)# s1 去 抵消它们的交集 差集
#
# # 补充
# # 3 每一个值都必须是不可变类型
# # 错误示范
# # sss = {'aa',1,{'name':'dahai'}}
# # 增  add
# s.add('小海')
# # 集合是可变类型
# print(s)
# # 删 pop 看你的pycharm是怎样无序排列的，从第一个元素删除
# s.pop()
# print(s)
# # 指定删除remove
# # s.remove('大海')
# print(s)
# # 改
# # update
# s.update(['蓝海','紫海'])
# print(s)
#
# s1=list(s)
# s1[0]=8
# s=set(list(s1))
# print(type(s))
# print(s)

# 集合去重
# 局限性
#1、无法保证原数据类型的顺序
#2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重
names =['dahai','xialuo','xishi','dahai','dahai','dahai']
s = set(names)
print(s)
l=list(s)
print(l)

# 要用for循环和if判断去重就可以保证顺序和对可变类型去重
# 总结
# 字符串，数字，布尔，复数 都是一个值，改变需要重新赋值，都是不可变类型
# 容器元组是不可变类型，字典，列表，集合都是可变类型

控制流程

if判断

#语法1：
# if 条件:
#     代码体
#     code1
#     code2
#     code3
#     ....
# 语法记忆方法
#   if+空格+条件+冒号
#   tab缩进代码体
#   tab缩进代码体
#   tab缩进代码体
# 键盘Q 左边tab
#  代表电脑需要一个条件进行判断  冒号可以理解成代表计算机要说话了
#  那么通过tab横向换行确定要说的话
tag = False
if tag:
    print('条件满足')
    print('条件满足')
    print('条件满足')
else :
    print('条件不满足')
    print('条件不满足')
    print('条件不满足')

#语法2：
# if 条件:
#     代码体
#     code1
#     code2
#     code3
#     ....
#else:
#     代码体
#     code1
#     code2
#     code3
# tag = 1 == 3
# if tag:
#     print('条件满足')
#     print('条件满足')
#     print('条件满足')
# # 其他
# else:
# # tab 右边缩减  shift + tab 左边缩进
#     print('条件不满足')
#     print('条件不满足')
#语法3：多分枝
# 强调：if的多分枝=但凡有一个条件成立，就不会再往下判断其他条件了
# elif可以有无限个
# if 条件1:
#     code1
#     code2
#     code3
#     ....
# elif 条件2:
#     code1
#     code2
#     code3
#     ....
# elif 条件3:
#     code1
#     code2
#     code3
#     ....
# ........
# else:
#     code1
#     code2
#     code3
#     ....

# 优先级if最高  elif 依次从上往下 else
# 注意必须要有if
# 如果：成绩>=90，那么：优秀
#
# 如果成绩>=80且<90,那么：良好
#
# 如果成绩>=70且<80,那么：普通
#
# 其他情况：很差

score = int(input('>>>'))
if score >= 90:
    print('优秀')
elif score >= 80:
    print('良好')
elif score >= 70:
    print('普通')
elif score <70:
    print('很差')
# 等价
# else:
#     print('很差')
# if 嵌套
# 语法
# if 条件:
#     code1
#     code2
#     code3
#     if 条件:
#           code1
#           code2
#           code3
#     else:
#           code1
#           code2
#           code3
# else:
#     code1
#     code2
#     code3
#     if 条件:
#           code1
#           code2
#           code3
#     else:
#           code1
#           code2
#           code3
cls = 'human'
sex = 'female'
age = 20
# 条件都要满足
if cls =='human' and sex == 'female' and age > 18 and age < 26:
    print('开始表白..... 以下省略一万字')
    is_success = input('女孩输入我愿意')
    # 嵌套里面当然也是可以用if 语法 1 2 3
    if is_success == '我愿意':
        print('在一起')
    else:
        print('我逗你玩呢....')
else:
    print('姐姐好')

逻辑运算符

#逻辑运算and or not
# and 与:连接左右两个条件,只有在两个条件同时成立的情况下最终结果才为True
# 快速判断方法
# 全部都是and的情况下，如果判断到位假后面都是and就没必要看了，就是假
# 要求全部都是真才是真
name = 'dahai'
num = 20
print(num > 18 and 1>3 and name == 'dahai' and num < 26)
print(num > 18 and 3>1 and name == 'dahai' and num < 26)

# or 或:连接左右两个条件,但凡有一个条件成立最终结果就为True
# 快速判断方法
# 全部都是or的情况下，如果判断到位真后面都是or就没必要看了，就是真
# 全是假才是假
print( 1>3or 1 ==1 or 'x'== 'y' or 2 > 4)
# not 非
print(not 1 > 3)
'''
原理为：
(1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割

(2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可

(3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
'''
print(not 3 > 1 or 3 >1)
#  是先判断not 3>1  而不是 3>1 or 3>1
# not 相当于小学学的乘除法  ，and和or相当于加减法
res=not False and True or False or False or True
# #2、最好使用括号来区别优先级，这样别人容易读懂你的代码
res1 =  (3>4 and 4>3) or (1==3 and ('x'=='x' or 3>3))
print(res1)

if并列

# 如果：成绩>=90，那么：优秀
#
# 如果成绩>=80且<90,那么：良好
#
# 如果成绩>=70且<80,那么：普通
#
# 其他情况：很差
score = int(input('>>>'))
if score >= 90:
    print('优秀')
if  90>score >= 80:
    print('良好')
if 80>score >= 70:
    print('普通')
if score < 70:
    print('很差')
# elif 与if并列的区别
# if并列是每个if都是独立的  也就是说每一个if条件 是独立的
# 而elif的条件  是在上个if 或者 上一个elif 不满足的条件下执行的条件

whlie循环

'''
1 什么是循环
    循环就是一个重复的过程

2 为何要有循环
    人可以重复的去做某一件事
    程序中必须有一种机制能够控制计算机像人一样重复地去做某一件事

3 如何用循环
'''
# 语法
# while 条件:
#     code1
#     code2
#     code3
# 条件为满足  一直循环
# while + True的情况
# while True:
#     print('1111')
#     print('2222')
# 在登录的情况需要循环
# db_user = 'dahai'
# db_pwd = '123'
# while 1:
#     input_user = input('请输入用户名')
#     input_pwd = input('请输入密码')
#     if input_user == db_user and input_pwd == db_pwd:
#         print('登录成功')
#     else:
#         print('登录失败')
# while + break: break代表结束本层循环
# db_user = 'dahai'
# db_pwd = '123'
# while True:
#     input_user = input('请输入用户名')
#     input_pwd = input('请输入密码')
#     if input_user == db_user and input_pwd == db_pwd:
#         print('登录成功')
#         break
#     else:
#         print('登录失败')

# while + 一个条件范围 不满足这个条件范围就会跳出循环
# start = 0
# while start < 8:
#     start += 1
#     print(start)

# while+continue:continue代表结束本次循环
# （本次循环continue之后的代码不在运行），直接进入下一次循环
start = 0
while start < 8:
    start += 1
    if start == 4:
        continue
    print(start)
    # continue
# 强调：continue一定不要作为循环体的最后一步代码
# 了解
# while + else # break

n = 0
while n < 6:
    n+=1
    if n == 6:
        break
    print(n)
else:
    # else的代码会在while循环没有break打断的情况下最后运行
    print('===================')
print('----------------')

if与whlie结合

# 登录取款程序
# 理解while嵌套
user = '大海'
pwd = 123
balance = 5000
tag = True
while True:
    while tag:
        user1 = input('输入用户名')
        if user1 != user:
            print('你输入的用户名有错误，请重新输入')
            continue
        pwd1 = int(input('请输入密码'))
        if pwd == pwd1:
            print('登录成功')
            break
            # 跳出本层循环 ，也就是说这一层while tag循环直接结束
            # 虽然跳出了while tag:
            # 外面的while True还是又会进入while tag
        else:
            print('输入密码错误')
    # 目的只是为了不进入里面的循环
    # 下面我要写取款程序
    tag = False
    # print('走后面取款的代码')
    money = int(input('输入你的取款金额'))
    if balance > money:
        balance = balance - money
        print('恭喜你取走了%s'%money)
        print('还剩%s'%balance)
        break
    else:
        print('余额不足')

for循环

# # whlie遍历列表
# names = ['dahai','xialuo','guan','xishi']
# # #         0        1      2       3
# # i = 0
# # while i < len(names):
# #     # print(i)
# #     print(names[i])
# #     i += 1
# # # for循环遍历列表(按照索引顺序遍历的)
# # for n in names:
# #     print(n)
# # for循环遍历字典
namess = {'name1':'dahai','name2':'xialuo','name3':'xishi'}
# # # 默认遍历key值
# # 所有的key
for i in namess:
    print(i)
for i in namess.keys():
    print(i)
# # # 遍历value值
for i in namess:
    # i是namess的key
    print(namess[i])

for i in namess.values():

    print(i)
#
# # # 遍历键值对
for i in namess.items():

    print(i)
# # # for可以不依赖于索引取指，是一种通用的循环取值方式
# # # for的循环次数是由被循环对象包含值的个数决定的，而while的循环次数是由条件决定的
#
# # # range(起始索引,结束索引,步长)
# # # range(结束索引,步长) # 相当于起始索引是0
# # a = range(0,5)
# # print(a)
# # print(type(a))
# # # 它是一个迭代器
# # print(list(a))
# # # 为什么不直接变成列表，因为会浪费内存
# # print(range(0,100000000000000000000000))
# # # 一般和for循环连用, 循环一次取一次
# # #  range相当于母鸡下蛋 一次下一个  下了0 1 2 3 4 这5个鸡蛋
# # for i in range(0,5):
# #     print(i)
# # 步长
for i in range(0,5,2):
    print(i)
# # 虽然结果一样但是列表浪费内存
# #  列表相当于一筐鸡蛋 一次性就是 0 1 2 3 4 这5个鸡蛋
for i in [0,1,2,3,4]:
    print(i)
# for + break  或者 加continue
names = ['dahai','xialuo','xishi','顾安','欢喜']
for n in names:
    if n == '顾安':
        # continue
        break
    print(n)

# for+else 了解
#  else的代码会在for循环没有break打断的情况下最后运行
# for i in range(0,10):
#     if i == 4:
#         print('没有被break打断')
#         # break
#     print(i)
# else:
#     print('=============')

# for循环的嵌套
# 打印9*9乘法口诀表
# i是乘数，j是被乘数
# # print有一个参数end  默认是\n
# print(1,end='')
# print(1,end='')
# print(1,end='')
# 打印9*9乘法口诀表
# i是乘数，j是被乘数
# for i in range(1,10):
#     # 控制9行 #
#     # print('i是%s'%i)
#     for j in range(1,i+1):
#         # 控制每一行出现的公式的个数
#         # 第1次范围是range(1,2)    i  1      (1,2)    j  1  只循环了一次
#         # 第2次范围是range(1,3)    i  2      (1,3)    j  1  j  2  只循环了二次
#         # 第3次范围是range(1,4)    i  3      (1,4)    j  1  j  2   j  3 只循环了三次
#         # print('j是%s'%j)
#         print('%s*%s=%s'%(i,j,i*j),end=' ')
#     # print(end='\n')
#     # 等价于
#     print()
# 集合去重
# 局限性
#1、无法保证原数据类型的顺序
#2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重
# names =['dahai','xialuo','xishi','dahai','dahai','dahai']
# s = set(names)
# print(s)
# l=list(s)
# print(l)

# 要用for循环和if判断去重就可以保证顺序和对可变类型去重
info =[
    {'name':'dahai','age':18},
    {'name':'xialuo','age':78},
    {'name':'xishi','age':8},
    {'name':'dahai','age':18},
    {'name':'dahai','age':18}
]
# set(info)
L = []
for i in info:
    # print(i)
    if i not in L:
        L.append(i)
info=L
print(info)

断点

# 断点
# 打断点
# 启动断点 鼠标右键
# ctrl + F5 重启程序
# ctrl + F2 停止
# F9 绿色的三角形是调到下一个断点
# F8 蓝色朝下的箭头是单步走
# Alt + F9 移动到光标处

函数

类似于java中的方法
三大特性：功能，参数，返回值

# 编程来源于生活
# 1、什么是函数？ *****
# 在程序中,函数就具备某一功能的工具事先将工具准备好   锤子  扳手   工厂
# 即函数的定义遇到应用场景拿来就用即函数的调用所以务必记住：
# 函数的使用必须遵循先定义,后调用的原则（先制造了工具，工具才能使用）
# 2、为何要用函数 不用函数产生问题是：
# 1、程序冗长
#
# 2 程序的扩展性差
#
# 3 程序的可读性差
# 3.如何用函数:
# 1、函数定义阶段: *****
# 只检测函数体的语法( 工厂合不合格)，不执行函数体代码 （不使用工厂）
# def 函数名+括号+冒号
# # # 缩进+体代码
# 制造一个工厂
def factory():
    '''
    这是一个工厂的函数
    :return:
    '''
    print('正在制造手机') # 代码相当于员工和机器
    print('正在制造电脑') # 代码相当于员工和机器
    print('正在制造电视机') # 代码相当于员工和机器
# 2、函数调用阶段: *****
# 函数的调用：函数名加括号
# 1 先找到名字   (找到工厂的位置)
# 2 根据名字调用代码   ( 加了括号执行工厂进行加工)
# # # 函数的内存地址
print(factory)
factory()
factory()
factory()

# 函数的三大特性
# 功能，参数，返回值
#### 有代码(有功能)
def factory():   #  制造一个工厂
	print('正在制造手机')  # 代码相对于员工或者机器
factory()
#### 无代码（用来测试，先做好项目的需求）
def shopping():
    pass
shopping()
# 参数
# 无参函数
# 应用场景仅仅只是执行一些操作，比如与用户交互，打印（工厂制造手机，不需要外接资源）
def factory():   #  制造一个工厂
 	print('正在制造手机')  # 代码相对于员工或者机器
factory()
# 有参
# 需要根据外部传进来的参数，才能执行相应的逻辑，计算 （工厂制造手机，需要a零件和b零件）
def factory(a,b):  #  制造一个工厂,需要a零件和b零件
	# 1 形参: 指的是在定义函数阶段括号内指定变量名,即形参本质就是"变量名"
	#  形参可以看做一个变量名
	print('a是%s'%a)
	print('b是%s'%b)
#2 实参: 指的是在调用函数阶段括号内传入的值,即实参本质就是"值"
# 位置实参
factory(1,2)
# 调用函数的参数称为实参
# 形参与实参的关系:在调用函数时,会将实参(值)赋值(绑定)给形参(变量名)
# 注意:但凡按照位置定义的形参,必须被实参传值,多一个不行,少一个也不行
# 位置参数 *****
#关键字实参: *****
# 在调用函数阶段,按照key=value的形式指名道姓地为形参传值
def factory(a,b):  #  制造一个工厂,需要a零件和b零件
	# 1 形参: 指的是在定义函数阶段括号内指定变量名,即形参本质就是"变量名"
	#  形参可以看做一个变量名
	print('a是%s'%a)
	print('b是%s'%b)
#注意:
#1. 可以完全打乱顺序,但仍然能指名道姓为指定的形参传值
#2. 可以混合使用位置实参与关键字实参,但是必须注意:
#    2.1 位置实参必须放到关键字实参前面
#    2.2 不能对一个形参重复赋值
factory(a=1,b=2)
factory(b=1,a=2)
# 错误示范
# factory(a=1,b=2,a=2)
# factory(a=1,2)
# 混用位置实参和关键字实参的正确方式
factory(1,b=2)

#默认参数  *****
#默认参数:指的是在定义函数阶段,就已经为某个形参赋值了,改形参称之为有默认值的形参,简称默认形参
#注意:
#1. 在定义阶段就已经被赋值,意味着在调用阶段可以不用为其赋值
#2. 位置形参应该放到默认形参前面
#3. 默认参数的值在函数定义阶段就已经固定死了
# def factory(a,b=2): #  b=2
#     #1 在定义阶段就已经被赋值，意味着在调用可以不用为其赋值,
#     #2 也可以对其重新赋值
#     c = a + b
#     print(c)
#
# factory(1,6)
# 位置形参vs默认形参
# 对于大多情况下传的值都不相同的,应该定义成位置形参
# 对于大多情况下传的值都相同的,应该定义成默认形参
def register(name,age,sex='男'):
    print(name,age,sex)

register('dahai',18)
register('xialuo',18)
register('zuge',18)
register('guan',18)
register('xishi',18,'女')
#  可变长度的参数(不定长参数) **** 0到多
# 1. 在形参中带*:会将调用函数时溢出位置实参保存成元组的形式,然后赋值*后的变量名
def foo(x,y,*z):
    print(x,y)
    print(z)
    print(*z)
foo(1,2,3,4,5,6)
# # 实参打散
# 序列类型可以被*打散
# (3)
# foo(1,*(2,3))
# foo(1,2)
# foo(*[1,2,3])
# foo(*[1,2,3])
# foo(*'abc')
# print(type((3,)))
# 3. 在形参中带**:会将调用函数时溢出关键字实参保存成字典的形式,然后赋值**后的变量名
# def foo(x,y,**z):
#     print(x,y)
#     print(z)
# **只能接受关键字实参
# 错误是否
# foo(1,2,3)
# foo(1,2,a=1,b=2,c=3)
# 打散字典
# 实参可以打散字典变成关键字实参进行传参
# a = {'a':1,'b':2,'c':3}
# foo(1,2,**a)
# 字典独立打散
# dic = {'a':1,'b':2,'c':3}
# print(**dic)
#5. 规范: 在形参中带*与**的,*后的变量名应该为args,**后跟的变量名应该时kwargs

# def factory(*args,**kwargs):
#     print(args)
#     print(kwargs)
# factory(1,2,3,x=3,y=4)
# 了解
# 命名关键字参数: 放到*与**之间的参数称之为命名关键字参数 ***
def foo(x,y,*args,m,n,**kwargs):
    print(x,y)
    print(args)
    print(m,n)
    print(kwargs)
# 错误示范
# foo(1,2,3,4,5,6,a=1,b=2,c=3)

foo(1,2,3,4,5,6,m=100,n=200,a=1,b=2,c=3)

拆包

# 拆包 *****
# 一个元素对应一个变量
a , b ,c= [1,2,3]
print(a)
print(b)
print(c)
# 多个元素对应一个变量
*a,b,c = [1,2,3,4,5,6]
print(a)
print(b)
print(c)
# 打散
print(*a)

函数返回值

# 什么是返回值？
# L = [1,2,3,4]
# # n=L.pop()
# # print(L)
# # print(n)
# 返回值是一个函数的处理结果（物流）return
# 函数属于局部
'''
注意：
        1、return是一个函数结束的标志，函数内可以有多个return，
            但只要执行一次，整个函数就会结束运行
            默认return None  *****
        2、return 的返回值无类型限制，即可以是任意数据类型  *****
        3、return 的返回值无个数限制，即可以用逗号分隔开多个任意类型的值  *****
            0个：返回None，ps：不写return默认会在函数的最后一行添加return None
            1个:返回的值就是该值本身
            多个：返回值是元组
        4.return关键字:return也可以作为函数结束的标志, ****
#         那么利用这一点就可以结束循环
'''
def factory(a):
    #这个是在函数里面用的，工厂里面自己用
    # c = a + 1
    # print(c)
    if a == 1:
        return [1,2,3],True,'aaaa'
    # print('制造手机')
    # return 2
    # return 1
    # print('制造电脑')
    # return 2
    # return c
    # return None
a=factory(1)
print(a)

# 4.return关键字:return也可以作为函数结束的标志, ****
#         那么利用这一点就可以结束循环
def factory(a):
    print('======')
    print('======')
    print('======')
    while True:
        while True:
            while True:
                if a == 3:
                    return
                a += 1
                print(a)
factory(1)

函数调用的三种方式

# 1.调用函数的三种形式
# 1 语句形式
def foo():
    print('from foo')
foo()
#2.2 表达式形式
def foo(x,y):
    res = x + y
    return res
# res = foo(1,2)
# print(res)
res1 = foo(1,2)*100
print(res1)
#2.3 可以当作参数传给另外一个函数
def max2(x,y):
    if x > y:
        return x
    else:
        return y
# print(max2(1, 2))
print(max2(max2(1,2),max2(4,5)))

函数的局部变量和全局变量的修改

# 1 外部不能访问函数内部的变量
# def fun1():
#     x =1
#
# print(x)
# 函数内部能够访问函数外部的变量
# x = 123
# def fun2():
#     print(x)
# fun2()
# 函数里面不能修改函数外部的变量
# x = 123
# def fun2():
#     x = x +1
# fun2()
# # global 能让我们在函数里面去修改全局变量的值
# x = 123
# def fun2():
#     global x
#     x = x +1
#     print(x)
# fun2()
# nonlocal 让嵌套函数能够修改嵌套函数之外的值
# def func2():
#     b = 100
#     def func3():
#         print('=====')
#         nonlocal b
#         b += 1
#         print(b)
#     func3()
# func2()

内置函数

# 常用的内置函数
#1 已经写好的一些函数   美观，强大
#
# 绝对值
print(abs(-5))
print(abs(5))
# all(可迭代对象)# 返回的是布尔值
#  可迭代对象里面的值全部为真才是真,其余为假
#  可迭代对象是空则为真
print(all([1,'',None]))
print(all([1,'aaa',2]))
print(all([]))
print('------')
# # any(可迭代对象)
# #  可迭代对象里面的值全部为假才是假，其余为真
# #  可迭代对象是空则为假
print(any([0,'',None,1]))
print(any([0,'',None,[]]))
print(any([]))
# 求最大值
a = [1,2,4,5,7]
print(max(a))
# # 求最小值
print(min(a))
# 求和
print(sum(a))
# ascll 英文的字符编码
# ord() 可以把字符转换成编码
# chr() 可以把编码转换成字符
print(ord('a'))
print(chr(97))
print(ord('A'))
print(chr(65))
# 拉链函数 zip
# 序列类型进行拉链
# t1 = ['a','b','c','d','e']
t1 = ('a','b','c','d','e')
# t1 = 'abcde'
# e 被抛弃
t2 = [1,2,3,4]
# 通过索引
print(list(zip(t1,t2)))
print(dict(zip(t1,t2)))
# 介绍 exec 函数   可以执行字符串里面的代码 支持python语法
exec('print(1)')

exec('''
for i in range(0,10):
    print(i)
''')

匿名函数

'''
1 什么是递归函数
函数的递归调用是函数嵌套调用的一种特殊形式,在调用一个函数的过程中又直接或者间接地调用该函数
本身,称之为函数的递归调用
递归死循环是没有意义的
递归调用必须有两个明确的阶段:
        1. 回溯: 一次次递归调用下去,说白了就一个重复的过程,
        但需要注意的是每一次重复问题的规模都应该有所减少,
        直到逼近一个最终的结果,即回溯阶段一定要有一个明确的结束条件
        2. 递推: 往回一层一层推算出结果
'''
# 直接调用自己
# def foo(n):
#     print('from foo',n)
#     foo(n+1)
#
# foo(0)

# 第五个人年龄为第4个人加2岁
'''
age(5)=age(4)+2
age(4)=age(3)+2
age(3)=age(2)+2
age(2)=age(1)+2
age(1)=18
'''
# 第几个人定义成n
'''
age(n)=age(n-1)+2 # n > 1
age(n) = 18       # n = 1
'''
# 递归调用就是一个重复的过程,但是每一次重复问题的规模都应该有所减少,
# 并且应该在满足某种条件的情况下结束重复,开始进入递推阶段
def age(n):
    # 所以要在这里写递归结束条件
    #     # 在这个找到条件并且导致函数不再自己调用自己的时候
    #     # 叫做回溯
    #     # 从结束条件一步步进行返回的结果
    #     # 叫做递推
    if n == 1:
        return 18
    # 第一次 # age(5)=age(4)+2                 26
    #     # 第二次   age(4)=age(3)+2                 24
    #     # 第三次 # age(3)=age(2)+2                 22
    #     # 第四次 # age(2)=age(1)+2                 20
    #     # 但是我们不知道age(1)是多少
    #     # 第五次 age(1)=18                   递推  18
    return age(n-1)+2

print(age(5))
L = [1,[2,[3,100,[4,[5,[6,[7,]]]]]]]
# 循环需要考虑次数
for n in L:
    # print(n)
    if type(n) is not list:
        print('我是数字%s'%n)
    else:
        # 以下是重复的过程
        for i in n:
            print(i)
        else:
            pass

def search(L):
    for n in L:
        # print(n)
        if type(n) is not list:
            print('我是数字%s'%n)
        else:
            # print(n)
            search(n)
search(L)
# 递归与循环的区别，循环每一次都要判断，需要考虑多少次
# 而递归只需要确定结束条件就行，按照规律进行重复调用，不需要考虑次数

闭包函数

# 闭包函数
# 闭包
# 闭指的是:该函数是一个内部函数
# 包指的是:指的是该内部的函数名字在外部被引用
# # 1、函数定义阶段:
# # 只检测函数体的语法( 工厂合不合格)，不执行函数体代码 （不使用工厂）
def factory():#  制造一个工厂
    print('正在制造手机')# 代码相对于员工或者机器
# # 2、函数调用阶段:
# # 1 先找到名字   (找到工厂的位置)
# # # 2 根据名字调用代码   ( 加了括号执行工厂进行加工)
#
factory()

# 闭包
# 闭指的是:该函数是一个内部函数
# 包指的是:指的是该内部的函数名字在外部被引用
def outer():# 没有调用outer(),但是创造了outer这个函数
    # 1 只检测函数体outer的语法( 工厂合不合格)，不执行函数体代码 （不使用工厂）
    print('外面的函数正在运行')
    def inner():
        print('里面的函数正在运行')
    return inner# 3返回inner函数的内存地址  想象成一个钥匙 控制里面工厂

# 创造了inner这个函数
# print(outer())
# # 4 得到里面工厂的钥匙 钥匙取一个名字innera
#
inner=outer() #2 定义了inner函数
# print(inner)
# # 5 里面钥匙加括号就可以开启里面的工厂
inner()

# 为函数体传值的方式一：参数
def func(x,y):
    print(x+y)
func(1,2)
func(1,2)
func(1,2)
func(1,2)
# 为函数体传值的方式二：闭包
def outer(x,y):
    def func():
        print(x + y)
    return func

func=outer(1,2)
func()
func()
func()
func()

装饰器

# 装饰器就是一个特殊的闭包函数
# 1、什么是装饰器（就是一个函数，只不过这个函数不是给自己使用的，是给其他函数添加功能的）
#     器指的是工具，而程序中的函数就具备某一功能的工具
#     装饰指的是为被装饰器对象添加额外功能
# 2、为什么要用装饰器
#     软件的维护应该遵循开放封闭原则
#     开放封闭原则指的是：
#         软件一旦上线运行后对修改源代码是封闭的，对扩展功能的是开放的
#         这就用到了装饰器
#     装饰器的实现必须遵循两大原则：
#         1、不修改被装饰对象的源代码(人的原来的性格，生活方式)
#         2、不修改被装饰对象的调用方式(人的原来的外貌，名字)
def run():
    print('跑步')
    print('健身')
run()
def fitness():
    print('健身')
    run()
def run():
    print('跑步')
fitness()
run()
#     装饰器其实就在遵循1和2原则的前提下为被装饰对象添加新功能
# 比如男孩1给女朋友买衣服，项链或化妆品  ， 变的更加自信，原来的外貌，原来的性格没有发生改变 # 装饰器

# 比如男孩2带女朋友去整容   ， 变的更加自信(不一定)， 原来的外貌，原来的性格发生改变 # 不是装饰器

# name = '大海'
# def run(name):
#     print('=========')
#     print('我是%s'%name)
#     print('=========')
# # run(name)
#
# def decorate(func): # func等下我们要传入的run
#     def new_func(name):#  run(name) 的name
#         print('我是装饰函数前面的代码')
#         func(name)#  run(name)
#         print('我是装饰函数后面的代码')
#     return new_func
# # 一 1.定义了new_func(name)函数 ，2.返回 了new_func内存地址 3.传入了一个run函数名
# run=decorate(run)
#
#
# # print(a)
# run(name)
# # 测试for循环从1加到9000000的时间
n = 9000000

from datetime import datetime
def run_time(func):# func 是for1  这是一个用来计算程序执行时间的装饰器
    def new_func(*args,**kwargs):
        start_time = datetime.now()
        print('开始时间%s'%start_time)
        func(*args,**kwargs)#  for1(9000000)
        end_time=datetime.now()
        print('结束时间%s'%end_time)
        time1 = end_time-start_time
        print('花费时间%s'%time1)
    return new_func
# 一 1.定义了new_func(n)函数 ，2.返回 了new_func内存地址 3.传入了一个for1函数名
@run_time # for1=run_time(for1)
def for1(n):
    sum1 = 0
    for i in range(1,n+1):
        sum1 += i
    print(sum1)

@run_time # shopping=run_time(shopping)
def shopping():
    for i in range(1111111):
        pass
    print('我是shopping')
# for1(n)
shopping()
# 换了个马甲for1
# 装饰器的要求高于闭包
#         1、不修改被装饰对象的源代码(人的原来的性格，生活方式)
#         2、不修改被装饰对象的调用方式(人的原来的外貌，名字)

异常处理

'''
1.异常
    异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常
    没有被应用程序处理,那么该异常就会抛出来,程序的执行也随之终止
    异常包含三个部分:
         1.异常的追踪信息  File "D:/python代码2/day6/异常.py", line 9, in <module>
        2.异常的类型  NameError
        3. 异常的信息   name 'a' is not defined
    错误分为两大类:
        1. 语法上的错误:在程序运行前就应该立即修正  这个好避免
        2. 逻辑上的错误:比如：字典没有key，你非要取key，
                            列表没有索引
                            变量没有名字  这些不好避免
2.为何要异常处理
    避免程序因为异常而崩溃,所以在应用程序中应该对异常进行处理,从而增强程序的健壮性
3. 如何异常处理
try:
    代码1
    代码2
    代码3
    ......
except NameError:
    当抛出的异常是NameError时执行的子代码块
except ....:
    pass
else:
    pass
finally:
    pass
'''
# 常见异常
# NameError
# print(1+'1')# TypeError
# d = {'x':1,'y':2}
# d['z'] # KeyError
# L = [1,2]
# L[3] # IndexError
# 异常处理的单分支
try:
    a
    # a = 1
except NameError as e:
    print('兄弟请检查一些你的代码')
    print(e)
else:
    # 程序没有抛出异常的时候执行
    print('代码正确')
finally:
    # 不管有错没错 一定会执行的部分
    print('完成了异常捕获')

# 异常处理的多分支
try:
    a
    # 完成了捕获后面的代码不会走了
    print('========1')
    print('========1')
    print('========1')
    l = [1,2]
    l[3]
except IndexError as e:
    print(e)
except NameError as e:
    print(e)
else:
    # 程序没有抛出异常的时候执行
    print('代码正确')
finally:
    # 不管有错没错 一定会执行的部分
    print('完成了异常捕获')


# 合并一下
try:
    a
    # 完成了捕获后面的代码不会走了
    print('========1')
    print('========1')
    print('========1')
    l = [1,2]
    l[3]
except (NameError,IndexError) as e:
    print(e)
else:
    # 程序没有抛出异常的时候执行
    print('代码正确')
finally:
    # 不管有错没错 一定会执行的部分
    print('完成了异常捕获')


# 万能捕获

try:
    # a
    d = {'x':1,'y':2}
    d['z'] # KeyError
    # 完成了捕获后面的代码不会走了
    print('========1')
    print('========1')
    print('========1')
    l = [1,2]
    l[3]
except Exception as e:
    print(e)
else:
    # 程序没有抛出异常的时候执行
    print('代码正确')
finally:
    # 不管有错没错 一定会执行的部分
    print('完成了异常捕获')

# 了解
# 断言

# 自定义异常
# l = [1,2,3,4]
# # # 4
# # # if len(l) != 5:
# # #     raise TypeError('列表的长度必须为5,这个是我的规则')
# # # 列表的长度必须为5,这个是我的规则
# assert len(l) == 5

文件

文件操作

'''
1 什么是文件
    文件是操作系统为用户/应用程序提供的一种操作硬盘的抽象单位
2 为何要用文件
    用户/应用程序对文件的读写操作会由操作系统转换成具体的硬盘操作
    所以用户/应用程序可以通过简单的读\写文件来间接地控制复杂的硬盘的存取操作
    实现将内存中的数据永久保存到硬盘中

    user=input('>>>>: ') #user="大海"
3 如何用文件
    文件操作的基本步骤:
        f=open(...) #打开文件,拿到一个文件对象f,f就相当于一个遥控器,可以向操作系统发送指令
        f.read() # 读写文件,向操作系统发送读写文件指令
        f.close() # 关闭文件,回收操作系统的资源
    上下文管理:
        with open(...) as f:
            pass
'''
# 绝对路径
f = open(r'E:\Python-project\A\Day7\day7\a.txt',encoding='utf-8')
f1=f.read()
print(f1)
f.close()

# 读取当前文件
f = open('day7/a.txt',encoding='utf-8')
f1=f.read()
print(f1)
f.close()
# 相对路径
f = open(r'..\Day7\day7\zzz\yyyy\a.txt',encoding='utf-8')
print(f.read())
f.close()
# 上下文管理:
# with open(...) as f:
#     pass
# 可以自动关闭文件
# with open(r'a.txt',encoding='utf-8')as f:
#     print(f.read())

文件操作的常用模式

'''
*****
一 文件的打开模式
    r: 只读模式(默认的)
    w: 只写模式
    a: 只追加写模式
二 控制读写文件单位的方式(必须与r\w\a连用)
    t : 文本模式(默认的),一定要指定encoding参数
        优点: 操作系统会将硬盘中二进制数字解码成unicode然后返回
        强调:只针对文本文件有效
    b: 二进制模式,一定不能指定encoding参数
        优点:
'''
#一 rt: 只读模式(默认的)
# 1 当文件不存时,会报错
# 2 当文件存在时,文件指针指向文件的开头

with open('day7/a.txt',mode='rt',encoding='utf-8')as  f:
    res1 = f.read()
    # print('1>>>',res1)
    # # 第一次读完了
    res2 = f.read()
    # print('2>>>',res2)
    # 判断rt模块可读
    print(f.readable())
    # 判断rt模式可写
    print(f.writable())
    # read 文件太大不好
    print(f.readline(),end='')
    # #文件里面有换行符 print自带换行符\n
    print(f.readline())
    # for循环遍历文件对象
    # for line in f:
    #     print(line,end='')
    # L = []
    # for line in f:
    #     L.append(line)
    # print(L)
    # 一行代码搞定
    print(f.readlines())

# 二 wt: 只写模式
# 1 当文件不存时,新建一个空文档(无则创建)
# with open('b.txt',mode='wt',encoding='utf-8')as  f:
#     pass
# 2 当文件存在时,清空文件内容，文件指针跑到文件的开头（有则清空）
with open('b.txt',mode='wt',encoding='utf-8')as  f:
    # 全部清空
    # 下面写我们想要的内容
    # 不能读
    # print(f.readable())
    # # 可以写
    # print(f.writable())
    # f.write(字符串)
    f.write('海\n')
    f.write('海\n')
    f.write('海\n')
    f.write('海\n')
    # 一次性写多行
    f.write('111\n2222\n3333\n')
    # 把列表内容一行行写入
    info = ['xiao海\n', 'xiao海\n', 'xiao海\n']
    # for line in info:
    #     f.write(line)
    # 一行代码搞定
    # writelines(列表)
    f.writelines(info)

# 三 at: 只追加写模式
# 1 当文件不存时,新建一个空文档，文件指针跑到文件的末尾(开头就是末尾)
# with open('c.txt',mode='at',encoding='utf-8')as  f:
#     pass
# 2 当文件存在时,文件指针跑到文件的末尾
with open('c.txt',mode='at',encoding='utf-8')as  f:
    # # 不能读
    # print(f.readable())
    # # 能写
    # print(f.writable())
    f.write('a海\n')
    f.write('a海\n')
    f.write('a海\n')
    f.write('a海\n')
with open('c.txt',mode='at',encoding='utf-8')as  f:
    # # 不能读
    # print(f.readable())
    # # 能写
    # print(f.writable())
    f.write('b海\n')
    f.write('b海\n')
    f.write('b海\n')
    f.write('b海\n')
# w模式和a模式的区别
# wt模式
# 在文件打开不关闭的情况下，连续的写入，
# 下一次写入一定是基于上一次写入指针的位置而继续的
# # a模式关闭了下次打开是在文件末尾写，所以不会覆盖之前的内容
'''
二 控制读写文件单位的方式(必须与r\w\a连用)
    t : 文本模式(默认的),一定要指定encoding参数
        优点: 操作系统会将硬盘中二进制数字解码成unicode然后返回
        强调:只针对文本文件有效

    b: 二进制模式,一定不能指定encoding参数
        优点:
'''
#只能对文本文件操作 t 模式局限性

# 二进制文件 b 模式
# 图片和视频
with open('1.png',mode='rb') as  f:
    data=f.read()
    print(data)
    print(type(data))

# 复制
with open('2.png',mode='wb')as f1:
    f1.write(data)

# 用b模式，也可以对文本文件操作，但是要解码
# decode   二进制解码成字符
# encode   字符编码成二进制
#解码   读的时候转换成字符
# with open('b模式.txt',mode='rb')as f:
#     data = f.read()
#     print(data)
#     print(type(data))
#     print(data.decode('utf-8'))
#编码  写的时候把字符转换成二进制写入
with open('wb模式.txt',mode='wb')as f:
    f.write('dahai\n'.encode('utf-8'))
    f.write('dahai\n'.encode('utf-8'))
    f.write('dahai\n'.encode('utf-8'))

可读可写模式

# 可读可写:（了解）
# r+t

# w+t

# a+t

#  r + t
# 1 当文件不存时,会报错
# 2 当文件存在时,文件指针指向文件的开头
# 3 多了个末尾写
with open('可读可写r+t模式.txt',mode='r+t',encoding='utf-8')as f:
    print(f.readable())
    print(f.writable())
    msg = f.readline()
    print(msg)
    f.write('xxxxxxxxxxx')

# w+t
# 1 当文件不存时,新建一个空文档(无则创建)
# 2 当文件存在时,清空文件内容，文件指针跑到文件的开头（有则清空）
# 3 可以读
with open('可读可写w+t模式.txt',mode='w+t',encoding='utf-8')as f:
    print(f.readable())
    print(f.writable())
    f.write('aaaaaaaa\n')
    f.write('bbbbbbbb\n')
    # 指针移动seek（移动的字节数,开头开始0）
    # 从开头开始移动0
    f.seek(0,0)
    print(f.readline())
    #     还是在末尾写
    f.write('cccccccc\n')

# a+t# 第二次打开时候也是在末尾写
# a 和 w的区别
with open('可读可写a+t模式.txt',mode='a+t',encoding='utf-8')as f:
    print(f.readable())
    print(f.writable())
    f.write('aaaaaaaa\n')
    f.write('bbbbbbbb\n')
    # 指针移动seek（移动的字节数,开头开始0）
    # 从开头开始移动0
    f.seek(0,0)
    print(f.readline())
    #     还是在末尾写
    f.write('cccccccc\n')

# 图片和视频用不上
# r+b w+b a+b 规律和 r+t  w+t   a+t
# 乱掉 文件打不开

指针移动

# f.seek *****
# 文件内指针移动,只有t模式下的read(n),n代表的字符的个数
# b模式文件内指针的移动都是以字节为单位


# t模式
with open('指针移动.txt',mode='rt',encoding='utf-8')as f:
    print(f.read(1))
    print(f.read(1))
    print(f.read(1))
print('==============')
# b模式
with open('指针移动.txt', mode='rb')as f:
    #     # 2个16进制是2**4    2**8
    #     # 三分之一个汉字
    print(f.read(1))
    print(f.read(1).decode('utf-8'))
    print(f.read(3).decode('utf-8'))
# 指针操作
# f.seek(offset,whence)有两个参数:
# offset: 代表控制指针移动的字节数
# whence: 代表参照什么位置进行移动
#        whence = 0: 参照文件开头(默认的),特殊???,可以在t和b模式下使用
#        whence = 1: 参照当前所在的位置,必须在b模式下用
#        whence = 2: 参照文件末尾,必须在b模式下用
# t模式 移动的字节数算 读的按照字符算

print('==============')
with open('seek.txt',mode='rt',encoding='utf-8')as f:
    f.seek(2,0)
    print(f.read(1))

# b模式 移动的字节数 读的也是字节数
with open('seek.txt',mode='rb')as f:
    f.seek(2,0)
    print(f.read(3).decode('utf-8'))
#           whence = 1: 参照当前所在的位置,必须在b模式下用
#        whence = 2: 参照文件末尾,必须在b模式下用
print('==============')
with open('seek.txt',mode='rb')as f:
    msg =f.read(5)
    print(msg.decode('utf-8'))
    print(f.tell())# 长度
    f.seek(3,1)
    print(f.read(3).decode('utf-8'))
#        whence = 2: 参照文件末尾,必须在b模式下用
print('==============')
with open('seek.txt',mode='rb')as f:
    # f.seek(0,2)
    # print(f.tell())
    f.seek(-3,2)
    print(f.read(3).decode('utf-8'))

在这里插入图片描述

修改文件内容

# *****
# 修改文件的方式一:
# 1 将文件内容由硬盘全部读入内存
# 2 在内存中完成修改
# 3 将内存中修改后的结果覆盖写回硬盘
with open('文件修改.txt',mode='rt',encoding='utf-8')as f:
    all_data=f.read()
    print(all_data)
# # 读出来的数据已经存到all_data变量里面的了
with open('文件修改.txt',mode='wt',encoding='utf-8')as f1:
    f1.write(all_data.replace('红黄蓝','大海'))

# 修改文件的方式二:
# 1 以读的方式打开源文件,以写的方式打开一个临时文件
# 2 从源文件中每读一样内容修改完毕后写入临时文件,直到源文件读取完毕
# 3 删掉源文件,将临时文件重命名为源文件名
import os
with open('文件修改二.txt',mode='rt',encoding='utf-8')as read_f\
    ,open('临时文件.txt',mode='wt',encoding='utf-8')as write_f:
    for line in read_f:
        print(line)
        write_f.write(line.replace('大海','夏洛'))

# 文件修改二删除
os.remove('文件修改二.txt')
# # 临时文件.txt 改成 文件修改二
os.rename('临时文件.txt','文件修改二.txt')


# 方式一:
# 优点: 在文件修改的过程中硬盘上始终一份数据
# 缺点: 占用内存过多,不适用于大文件


# 方式二:
# 优点: 同一时刻在内存中只存在源文件的一行内容,不会过多地占用内存
# 缺点: 在文件修改的过程中会出现源文件与临时文件共存,硬盘上同一时刻会有两份数据,即在修改的过程中会过多的占用硬盘,

爬虫

在这里插入图片描述

urllib库使用

	urllib.request.urlopen() 模拟浏览器向服务器发送请求
	response 服务器返回的数据
		response的数据类型是HttpResponse
		字节‐‐>字符串
			解码decode
		字符串‐‐>字节
			编码encode
	read() 字节形式读取二进制 扩展：rede(5)返回前几个字节
	readline() 读取一行
	readlines() 一行一行读取 直至结束
	getcode() 获取状态码
	geturl() 获取url
	getheaders() 获取headers
urllib.request.urlretrieve()
	请求网页
	请求图片
	请求视频

爬取百度页面

import urllib.request

url = 'http://www.baidu.com'

response=urllib.request.urlopen(url)

content=response.read().decode('utf-8')

with open('百度.txt',mode='at',encoding='utf-8')as  f:
    f.write(content)

print(response.getheaders())

# 一个类型和六个方法
# response是HTTPResponse的类型
# print(type(response))

# 按照一个字节一个字节的去读
# content = response.read()
# print(content)

# 返回多少个字节
# content = response.read(5)
# print(content)

# 读取一行
# content = response.readline()
# print(content)

# content = response.readlines()
# print(content)

# 返回状态码  如果是200了 那么就证明我们的逻辑没有错
# print(response.getcode())

# 返回的是url地址
# print(response.geturl())

# 获取是一个状态信息
print(response.getheaders())

# 一个类型 HTTPResponse
# 六个方法 read  readline  readlines  getcode geturl getheaders

下载网页，下载图片，下载视频

import urllib.request
# 下载网页
# url_page = 'http://www.baidu.com'
#
# urllib.request.urlretrieve(url_page,'baidu.html')

# 下载图片
# url_img = 'https://image.baidu.com/search/detail?ct=503316480&z=undefined&tn=baiduimagedetail&ipn=d&word=%E5%AD%9F%E7%BE%8E%E5%B2%90&step_word=&lid=10371530376187963732&ie=utf-8&in=&cl=2&lm=-1&st=undefined&hd=undefined&latest=undefined&copyright=undefined&cs=212550885,3283528505&os=948129043,2026641091&simid=3216490777,3766704508&pn=9&rn=1&di=7360350738658099201&ln=1714&fr=&fmq=1717986078361_R&fm=&ic=undefined&s=undefined&se=&sme=&tab=0&width=undefined&height=undefined&face=undefined&is=0,0&istype=0&ist=&jit=&bdtype=0&spn=0&pi=0&gsm=1e&objurl=https%3A%2F%2Fq1.itc.cn%2Fimages01%2F20240328%2Fcbd339cf8b3547e38e880910703e9950.jpeg&rpstart=0&rpnum=0&adpicid=0&nojc=undefined&dyTabStr=MCwxLDMsMiw2LDQsNSw4LDcsOQ%3D%3D'
#
# urllib.request.urlretrieve(url=url_img,filename='1.jpg')
# 下载视频

url_video = 'https://vd3.bdstatic.com/mda-mhkku4ndaka5etk3/1080p/cae_h264/1629557146541497769/mda-mhkku4ndaka5etk3.mp4?v_from_s=hkapp-haokan-tucheng&auth_key=1629687514-0-0-7ed57ed7d1168bb1f06d18a4ea214300&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest='

urllib.request.urlretrieve(url_video,'hxekyyds.mp4')

请求对象的定制

url的组成
1.协议
2.主机
3.端口号
4.路径
5.参数
6.锚点

www.baidu.com/s?wd=三国演义

http/https www.baidu.com 80/443 s wd=三国演义

协议主机端口号路径参数锚点

import urllib.request

url = 'https://www.baidu.com'

response = urllib.request.urlopen(url=url)

content = response.read().decode('utf8')

print(content)

效果
在这里插入图片描述
UA
对付反爬的手段之一

获取UA的方式
在这里插入图片描述

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

脚本

import urllib.request

url = 'https://www.baidu.com'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

# 因为urlopen方法中不能存储字典 所以headers不能传递进去
# 请求对象的定制
request=urllib.request.Request(url=url,headers=headers)
# 执行
response=urllib.request.urlopen(request)
content=response.read().decode('utf8')
print(content)

效果
爬取了更多
在这里插入图片描述

编解码

编码的由来

编码集的演变---
由于计算机是美国人发明的，因此，最早只有127个字符被编码到计算机里，也就是大小写英文字母、数字和一些符号，
这个编码表被称为ASCII编码，比如大写字母A的编码是65，小写字母z的编码是122。
但是要处理中文显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。
你可以想得到的是，全世界有上百种语言，日本把日文编到shift_]IS里，韩国把韩文编到Euc-kr里，各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。因此,Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
Unicode标准也在不断发展，但最常用的是用两个字节表示一个字符(如果要用到非常偏僻的字符，就需要4个字节)。
现代操作系统和大多数编程语言都直接支持Unicode。"""

请求中中文字符变成编解码

# https://www.baidu.com/s?wd=%E5%91%A8%E6%9D%B0%E4%BC%A6

# 需求 获取 https://www.baidu.com/s?wd=周杰伦的网页源码
import urllib.request
import urllib.parse

url = 'https://www.baidu.com/s?wd='

# 请求对象的定制为了解决反爬的第一种手段
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

# 将周杰伦三个字变成unicode编码的格式
# 我们需要依赖于urllib.parse
name = urllib.parse.quote('周杰伦')

url = url + name

# 请求对象的定制
request = urllib.request.Request(url=url,headers=headers)

# 模拟浏览器向服务器发送请求
response = urllib.request.urlopen(request)

# 获取响应的内容
content = response.read().decode('utf-8')

# 打印数据
print(content)

urlencode get请求quote方法

# https://www.baidu.com/s?wd=%E5%91%A8%E6%9D%B0%E4%BC%A6

# 需求 获取 https://www.baidu.com/s?wd=周杰伦的网页源码

import urllib.request
import urllib.parse

url = 'https://www.baidu.com/s?wd='

# 请求对象的定制为了解决反爬的第一种手段
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

# 将周杰伦三个字变成unicode编码的格式
# 我们需要依赖于urllib.parse
name = urllib.parse.quote('周杰伦')
url = url + name
# 请求对象的定制
request = urllib.request.Request(url=url,headers=headers)
# 模拟浏览器向服务器发送请求
response = urllib.request.urlopen(request)
# 获取响应的内容
content = response.read().decode('utf-8')
# 打印数据
print(content)

urlencode应用场景：多个参数的时候

get传参

import urllib.request
import urllib.parse

base_url = 'https://www.baidu.com/s?'

data = {
    'wd':'周杰伦',
    'sex':'男',
    'location':'中国台湾省'
}

new_data = urllib.parse.urlencode(data)

# 请求资源路径
url = base_url + new_data

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

# 请求对象的定制
request = urllib.request.Request(url=url,headers=headers)

# 模拟浏览器向服务器发送请求
response = urllib.request.urlopen(request)

# 获取网页源码的数据
content = response.read().decode('utf-8')

# 打印数据
print(content)

urlencode post请求quote方法

post传参

import urllib.request
import urllib.parse


url = 'https://fanyi.baidu.com/sug'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

data = {
    'kw':'spider'
}

# post请求的参数 必须要进行编码
data = urllib.parse.urlencode(data).encode('utf-8')

# post的请求的参数 是不会拼接在url的后面的  而是需要放在请求对象定制的参数中
# post请求的参数 必须要进行编码
request = urllib.request.Request(url=url,data=data,headers=headers)

# 模拟浏览器向服务器发送请求
response = urllib.request.urlopen(request)

# 获取响应的数据
content = response.read().decode('utf-8')

# 字符串--》json对象

import json

obj = json.loads(content)
print(obj)

# post请求方式的参数 必须编码   data = urllib.parse.urlencode(data)
# 编码之后 必须调用encode方法 data = urllib.parse.urlencode(data).encode('utf-8')
# 参数是放在请求对象定制的方法中  request = urllib.request.Request(url=url,data=data,headers=headers)

反爬手段之一

解决方式，请求头
请求头获取
在这里插入图片描述

import urllib.request
import urllib.parse

url = 'https://fanyi.baidu.com/v2transapi?from=en&to=zh'

headers = {
    # 'Accept': '*/*',
    # 'Accept-Encoding': 'gzip, deflate, br',
    # 'Accept-Language': 'zh-CN,zh;q=0.9',
    # 'Connection': 'keep-alive',
    # 'Content-Length': '135',
    # 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
    'Cookie': 'BIDUPSID=DAA8F9F0BD801A2929D96D69CF7EBF50; PSTM=1597202227; BAIDUID=DAA8F9F0BD801A29B2813502000BF8E9:SL=0:NR=10:FG=1; __yjs_duid=1_c19765bd685fa6fa12c2853fc392f8db1618999058029; REALTIME_TRANS_SWITCH=1; FANYI_WORD_SWITCH=1; HISTORY_SWITCH=1; SOUND_SPD_SWITCH=1; SOUND_PREFER_SWITCH=1; BDUSS=R2bEZvTjFCNHQxdUV-cTZ-MzZrSGxhbUYwSkRkUWk2SkxxS3E2M2lqaFRLUlJoRVFBQUFBJCQAAAAAAAAAAAEAAAA3e~BTveK-9sHLZGF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFOc7GBTnOxgaW; BDUSS_BFESS=R2bEZvTjFCNHQxdUV-cTZ-MzZrSGxhbUYwSkRkUWk2SkxxS3E2M2lqaFRLUlJoRVFBQUFBJCQAAAAAAAAAAAEAAAA3e~BTveK-9sHLZGF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFOc7GBTnOxgaW; BDORZ=B490B5EBF6F3CD402E515D22BCDA1598; BAIDUID_BFESS=DAA8F9F0BD801A29B2813502000BF8E9:SL=0:NR=10:FG=1; BDRCVFR[feWj1Vr5u3D]=I67x6TjHwwYf0; PSINO=2; H_PS_PSSID=34435_31660_34405_34004_34073_34092_26350_34426_34323_22158_34390; delPer=1; BA_HECTOR=8185a12020018421b61gi6ka20q; BCLID=10943521300863382545; BDSFRCVID=boDOJexroG0YyvRHKn7hh7zlD_weG7bTDYLEOwXPsp3LGJLVJeC6EG0Pts1-dEu-EHtdogKK0mOTHv8F_2uxOjjg8UtVJeC6EG0Ptf8g0M5; H_BDCLCKID_SF=tR3aQ5rtKRTffjrnhPF3-44vXP6-hnjy3bRkX4Q4Wpv_Mnndjn6SQh4Wbttf5q3RymJ42-39LPO2hpRjyxv4y4Ldj4oxJpOJ-bCL0p5aHl51fbbvbURvD-ug3-7qqU5dtjTO2bc_5KnlfMQ_bf--QfbQ0hOhqP-jBRIE3-oJqC8hMIt43f; BCLID_BFESS=10943521300863382545; BDSFRCVID_BFESS=boDOJexroG0YyvRHKn7hh7zlD_weG7bTDYLEOwXPsp3LGJLVJeC6EG0Pts1-dEu-EHtdogKK0mOTHv8F_2uxOjjg8UtVJeC6EG0Ptf8g0M5; H_BDCLCKID_SF_BFESS=tR3aQ5rtKRTffjrnhPF3-44vXP6-hnjy3bRkX4Q4Wpv_Mnndjn6SQh4Wbttf5q3RymJ42-39LPO2hpRjyxv4y4Ldj4oxJpOJ-bCL0p5aHl51fbbvbURvD-ug3-7qqU5dtjTO2bc_5KnlfMQ_bf--QfbQ0hOhqP-jBRIE3-oJqC8hMIt43f; Hm_lvt_64ecd82404c51e03dc91cb9e8c025574=1629701482,1629702031,1629702343,1629704515; Hm_lpvt_64ecd82404c51e03dc91cb9e8c025574=1629704515; __yjs_st=2_MDBkZDdkNzg4YzYyZGU2NTM5NzBjZmQ0OTZiMWRmZGUxM2QwYzkwZTc2NTZmMmIxNDJkYzk4NzU1ZDUzN2U3Yjc4ZTJmYjE1YTUzMTljYWFkMWUwYmVmZGEzNmZjN2FlY2M3NDAzOThhZTY5NzI0MjVkMmQ0NWU3MWE1YTJmNGE5NDBhYjVlOWY3MTFiMWNjYTVhYWI0YThlMDVjODBkNWU2NjMwMzY2MjFhZDNkMzVhNGMzMGZkMWY2NjU5YzkxMDk3NTEzODJiZWUyMjEyYTk5YzY4ODUyYzNjZTJjMGM5MzhhMWE5YjU3NTM3NWZiOWQxNmU3MDVkODExYzFjN183XzliY2RhYjgz; ab_sr=1.0.1_ZTc2ZDFkMTU5ZTM0ZTM4MWVlNDU2MGEzYTM4MzZiY2I2MDIxNzY1Nzc1OWZjZGNiZWRhYjU5ZjYwZmNjMTE2ZjIzNmQxMTdiMzIzYTgzZjVjMTY0ZjM1YjMwZTdjMjhiNDRmN2QzMjMwNWRhZmUxYTJjZjZhNTViMGM2ODFlYjE5YTlmMWRjZDAwZGFmMDY4ZTFlNGJiZjU5YzE1MGIxN2FiYTU3NDgzZmI4MDdhMDM5NTQ0MjQxNDBiNzdhMDdl',
    # 'Host': 'fanyi.baidu.com',
    # 'Origin': 'https://fanyi.baidu.com',
    # 'Referer': 'https://fanyi.baidu.com/?aldtype=16047',
    # 'sec-ch-ua': '"Chromium";v="92", " Not A;Brand";v="99", "Google Chrome";v="92"',
    # 'sec-ch-ua-mobile': '?0',
    # 'Sec-Fetch-Dest': 'empty',
    # 'Sec-Fetch-Mode': 'cors',
    # 'Sec-Fetch-Site': 'same-origin',
    # 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
    # 'X-Requested-With': 'XMLHttpRequest',
}

data = {
    'from': 'en',
    'to': 'zh',
    'query': 'love',
    'transtype': 'realtime',
    'simple_means_flag': '3',
    'sign': '198772.518981',
    'token': '5483bfa652979b41f9c90d91f3de875d',
    'domain': 'common',
}
# post请求的参数  必须进行编码 并且要调用encode方法
data = urllib.parse.urlencode(data).encode('utf-8')

# 请求对象的定制
request = urllib.request.Request(url = url,data = data,headers = headers)

# 模拟浏览器向服务器发送请求
response = urllib.request.urlopen(request)

# 获取响应的数据
content = response.read().decode('utf-8')

import json

obj = json.loads(content)
print(obj)

ajax的get请求

爬取豆瓣电影

# get请求
# 获取豆瓣电影的第一页的数据 并且保存起来

import urllib.request

url = 'https://movie.douban.com/j/chart/top_list?type=5&interval_id=100%3A90&action=&start=0&limit=20'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

# (1) 请求对象的定制
request = urllib.request.Request(url=url,headers=headers)

# （2）获取响应的数据
response = urllib.request.urlopen(request)
content = response.read().decode('utf-8')

# (3) 数据下载到本地
# open方法默认情况下使用的是gbk的编码  如果我们要想保存汉字 那么需要在open方法中指定编码格式为utf-8
# encoding = 'utf-8'
fp = open('douban.json','w',encoding='utf-8')
fp.write(content)

#with open('douban1.json','w',encoding='utf-8') as fp:
#    fp.write(content)


# 下载豆瓣电影前10页的数据
# （1） 请求对象的定制
# （2） 获取响应的数据
# （3） 下载数据

import urllib.parse
import urllib.request

def create_request(page):
    base_url = 'https://movie.douban.com/j/chart/top_list?type=5&interval_id=100%3A90&action=&'

    data = {
        'start':(page - 1) * 20,
        'limit':20
    }

    data = urllib.parse.urlencode(data)

    url = base_url + data

    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
    }

    request = urllib.request.Request(url=url,headers=headers)
    return request

def get_content(request):
    response = urllib.request.urlopen(request)
    content = response.read().decode('utf-8')
    return content

def down_load(page,content):
    with open('douban_' + str(page) + '.json','w',encoding='utf-8')as fp:
        fp.write(content)


# 程序的入口
if __name__ == '__main__':
    start_page = int(input('请输入起始的页码'))
    end_page = int(input('请输入结束的页面'))

    for page in range(start_page,end_page+1):
#         每一页都有自己的请求对象的定制
        request = create_request(page)
#         获取响应的数据
        content = get_content(request)
#         下载
        down_load(page,content)

ajax的post请求

# 1页
# http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=cname
# post
# cname: 北京
# pid:
# pageIndex: 1
# pageSize: 10


# 2页
# http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=cname
# post
# cname: 北京
# pid:
# pageIndex: 2
# pageSize: 10

import urllib.request
import urllib.parse

def create_request(page):
    base_url = 'http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=cname'

    data = {
        'cname': '北京',
        'pid':'',
        'pageIndex': page,
        'pageSize': '10'
    }

    data = urllib.parse.urlencode(data).encode('utf-8')

    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
    }

    request = urllib.request.Request(url=base_url,headers=headers,data=data)
    
    return request

def get_content(request):
    response = urllib.request.urlopen(request)
    content = response.read().decode('utf-8')
    return content

def down_load(page,content):
    with open('kfc_' + str(page) + '.json','w',encoding='utf-8')as fp:
        fp.write(content)


if __name__ == '__main__':
    start_page = int(input('请输入起始页码'))
    end_page = int(input('请输入结束页码'))

    for page in range(start_page,end_page+1):
        # 请求对象的定制
        request = create_request(page)
        # 获取网页源码
        content = get_content(request)
        # 下载
        down_load(page,content)

异常

URLErrorlHTTPError

简介:1.HTTPError类是URLError类的子类
2.导入的包urllib.error.HTTPErrorurllib.error. URLError
3.http错误: http错误是针对浏览器无法连接到服务器而增加出来的错误提示。引导并告诉浏览者该页是哪里出了问题。
4.通过urllib发送请求的时候，有可能会发送失败，这个时候如果想让你的代码更加的健壮，可以通过try-except进行捕获异常，异常有两类，URLError \HTTPError

import urllib.request
import urllib.error

# url = 'https://blog.csdn.net/sulixu/article/details/1198189491'

url = 'http://www.doudan1111.com'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

try:
    request = urllib.request.Request(url = url, headers = headers)

    response = urllib.request.urlopen(request)

    content = response.read().decode('utf-8')

    print(content)
except urllib.error.HTTPError:
    print('系统正在升级。。。')
except urllib.error.URLError:
    print('我都说了 系统正在升级。。。')

cookie

反爬手段之一，cookie
个人信息页面是utf-8但是还报错了编码错误因为并没有进入到个人信息页面而是跳转到了登陆页面
那么登陆页面不是utf-8所以报错

# 适用的场景：数据采集的时候 需要绕过登陆 然后进入到某个页面
# 个人信息页面是utf-8  但是还报错了编码错误  因为并没有进入到个人信息页面 而是跳转到了登陆页面
# 那么登陆页面不是utf-8  所以报错

# 什么情况下访问不成功？
# 因为请求头的信息不够  所以访问不成功

import urllib.request

url = 'https://weibo.cn/6451491586/info'

headers = {
# ':authority': 'weibo.cn',
# ':method': 'GET',
# ':path': '/6451491586/info',
# ':scheme': 'https',
'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
# 'accept-encoding': 'gzip, deflate, br',
'accept-language': 'zh-CN,zh;q=0.9',
'cache-control': 'max-age=0',
#     cookie中携带着你的登陆信息   如果有登陆之后的cookie  那么我们就可以携带着cookie进入到任何页面
'cookie': '_T_WM=24c44910ba98d188fced94ba0da5960e; SUBP=0033WrSXqPxfM725Ws9jqgMF55529P9D9WFxxfgNNUmXi4YiaYZKr_J_5NHD95QcSh-pSh.pSKncWs4DqcjiqgSXIgvVPcpD; SUB=_2A25MKKG_DeRhGeBK7lMV-S_JwzqIHXVv0s_3rDV6PUJbktCOLXL2kW1NR6e0UHkCGcyvxTYyKB2OV9aloJJ7mUNz; SSOLoginState=1630327279',
# referer  判断当前路径是不是由上一个路径进来的    一般情况下 是做图片防盗链
'referer': 'https://weibo.cn/',
'sec-ch-ua': '"Chromium";v="92", " Not A;Brand";v="99", "Google Chrome";v="92"',
'sec-ch-ua-mobile': '?0',
'sec-fetch-dest': 'document',
'sec-fetch-mode': 'navigate',
'sec-fetch-site': 'same-origin',
'sec-fetch-user': '?1',
'upgrade-insecure-requests': '1',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
}
# 请求对象的定制
request = urllib.request.Request(url=url,headers=headers)
# 模拟浏览器向服务器发送请求
response = urllib.request.urlopen(request)
# 获取响应的数据
content = response.read().decode('utf-8')

# 将数据保存到本地
with open('weibo.html','w',encoding='utf-8')as fp:
    fp.write(content)

Handler 处理器

基本使用

# 需求 使用handler来访问百度  获取网页源码
import urllib.request

url = 'http://www.baidu.com'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

request = urllib.request.Request(url = url,headers = headers)

# handler   build_opener  open

# （1）获取hanlder对象
handler = urllib.request.HTTPHandler()

# （2）获取opener对象
opener = urllib.request.build_opener(handler)

# (3) 调用open方法
response = opener.open(request)

content = response.read().decode('utf-8')

print(content)

urllib代理

代理的常用功能?
1.突破自身IP访问限制，访问国外站点。
2.访问一些单位或团体内部资源

扩展:某大学F TP(前提是该代理地址在该资源的允许访问范围之内)，使用教育网内地址段免费代理服务器，就可以用于对教育网开放的各类FTP下载上传，以及各类资料查询共享等服务。

3.提高访问速度

扩展:通常代理服务器都设置-个较大的硬盘缓冲区，当有外界的信息通过时，同时也将其保存到缓冲区中，当其他用户再访问相同的信息时，则直接由缓冲区中取出信息，传给用户，以提高访问速度。

4.隐瘕真实IP

扩展:上网者也可以通过这种方法隐藏自己的IP,免受攻击。

List item
代码配置代理
创建Reuqest对象
创建ProxyHandler对象
用handler对象创建opener对象
使用opener。open函数发送请求

找代理ip，可以搜索快代理，里面可以花钱买也可以使用免费提供的
在这里插入图片描述

在这里插入图片描述

import urllib.request

url = 'http://www.baidu.com/s?wd=ip'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

# 请求对象的定制
request = urllib.request.Request(url = url,headers= headers)

# 模拟浏览器访问服务器
# response = urllib.request.urlopen(request)

proxies = {
    'http':'118.24.219.151:16817'
}
# handler  build_opener  open
handler = urllib.request.ProxyHandler(proxies = proxies)

opener = urllib.request.build_opener(handler)

response = opener.open(request)

# 获取响应的信息
content = response.read().decode('utf-8')

# 保存
with open('daili.html','w',encoding='utf-8')as fp:
    fp.write(content)

代理池

import urllib.request
# 多个代理的ip地址
proxies_pool = [
    {'http':'118.24.219.151:16817'},
    {'http':'118.24.219.151:16817'},
]
# 算法，类似于负载均衡
import random  

proxies = random.choice(proxies_pool)

url = 'http://www.baidu.com/s?wd=ip'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

request = urllib.request.Request(url = url,headers=headers)
# 用代理的话必须用handler
handler = urllib.request.ProxyHandler(proxies=proxies)

opener = urllib.request.build_opener(handler)

response = opener.open(request)

content = response.read().decode('utf-8')

with open('daili.html','w',encoding='utf-8')as fp:
    fp.write(content)

Xpath 解析

xpath使用：
注意：提前安装xpath插件
（1）打开chrome浏览器
（2）点击右上角小圆点
（3）更多工具
（4）扩展程序
（5）拖拽xpath插件到扩展程序中
（6）如果crx文件失效，需要将后缀修改zip
（7）再次拖拽
（8）关闭浏览器重新打开
（9）ctrl + shift + x
（10）出现小黑框
1.安装lxml库
pip install lxml ‐i https://pypi.douban.com/simple
2.导入lxml.etree
from lxml import etree
3.etree.parse() 解析本地文件
html_tree = etree.parse(‘XX.html’)
4.etree.HTML() 服务器响应文件
html_tree = etree.HTML(response.read().decode(‘utf‐8’)
4.html_tree.xpath(xpath路径)

在这里插入图片描述

开启快捷键ctrl + shift + x
在这里插入图片描述
xpath使用

xpath基本语法：
1.路径查询
//：查找所有子孙节点，不考虑层级关系
/ ：找直接子节点
2.谓词查询
//div[@id]
//div[@id="maincontent"]
3.属性查询
//@class
4.模糊查询
//div[contains(@id, "he")]
//div[starts‐with(@id, "he")]
5.内容查询
//div/h1/text()
6.逻辑运算
//div[@id="head" and @class="s_down"]
//title | //price

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8"/>
    <title>Title</title>
</head>
<body>
    <ul>
        <li id="l1" class="c1">北京</li>
        <li id="l2">上海</li>
        <li id="c3">深圳</li>
        <li id="c4">武汉</li>
    </ul>

<!--    <ul>-->
<!--        <li>大连</li>-->
<!--        <li>锦州</li>-->
<!--        <li>沈阳</li>-->
<!--    </ul>-->
</body>
</html>

from lxml import etree

# xpath解析
# （1）本地文件                                                etree.parse
# （2）服务器响应的数据  response.read().decode('utf-8') *****   etree.HTML()

# xpath解析本地文件
tree = etree.parse('test.html')

#tree.xpath('xpath路径')

# 查找ul下面的li
# li_list = tree.xpath('//body/ul/li')


# 查找所有有id的属性的li标签
# text()获取标签中的内容
# li_list = tree.xpath('//ul/li[@id]/text()')

# 找到id为l1的li标签  注意引号的问题
# li_list = tree.xpath('//ul/li[@id="l1"]/text()')

# 查找到id为l1的li标签的class的属性值
# li = tree.xpath('//ul/li[@id="l1"]/@class')

# 查询id中包含l的li标签
# li_list = tree.xpath('//ul/li[contains(@id,"l")]/text()')

# 查询id的值以l开头的li标签
# li_list = tree.xpath('//ul/li[starts-with(@id,"c")]/text()')

#查询id为l1和class为c1的
# li_list = tree.xpath('//ul/li[@id="l1" and @class="c1"]/text()')

li_list = tree.xpath('//ul/li[@id="l1"]/text() | //ul/li[@id="l2"]/text()')

# 判断列表的长度
print(li_list)
print(len(li_list))

爬虫_解析_获取百度网站的百度一下

# （1） 获取网页的源码
# （2） 解析   解析的服务器响应的文件  etree.HTML
# (3)  打印

import urllib.request

url = 'https://www.baidu.com/'

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}

# 请求对象的定制
request = urllib.request.Request(url = url,headers = headers)

# 模拟浏览器访问服务器
response = urllib.request.urlopen(request)

# 获取网页源码
content = response.read().decode('utf-8')

# 解析网页源码 来获取我们想要的数据
from lxml import etree

# 解析服务器响应的文件
tree = etree.HTML(content)

# 获取想要的数据  xpath的返回值是一个列表类型的数据
result = tree.xpath('//input[@id="su"]/@value')[0]

print(result)

效果
在这里插入图片描述

站长素材爬取图片网站的图片

# (1) 请求对象的定制
# （2）获取网页的源码
# （3）下载


# 需求 下载的前十页的图片
# https://sc.chinaz.com/tupian/qinglvtupian.html   1
# https://sc.chinaz.com/tupian/qinglvtupian_page.html

import urllib.request
from lxml import etree

def create_request(page):
    if(page == 1):
        url = 'https://sc.chinaz.com/tupian/qinglvtupian.html'
    else:
        url = 'https://sc.chinaz.com/tupian/qinglvtupian_' + str(page) + '.html'

    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
    }

    request = urllib.request.Request(url = url, headers = headers)
    return request

def get_content(request):
    response = urllib.request.urlopen(request)
    content = response.read().decode('utf-8')
    return content


def down_load(content):
#     下载图片
    # urllib.request.urlretrieve('图片地址','文件的名字')
    tree = etree.HTML(content)

    name_list = tree.xpath('//div[@id="container"]//a/img/@alt')

    # 一般设计图片的网站都会进行懒加载
    src_list = tree.xpath('//div[@id="container"]//a/img/@src2')

    for i in range(len(name_list)):
        name = name_list[i]
        src = src_list[i]
        url = 'https:' + src

        urllib.request.urlretrieve(url=url,filename='./loveImg/' + name + '.jpg')




if __name__ == '__main__':
    start_page = int(input('请输入起始页码'))
    end_page = int(input('请输入结束页码'))

    for page in range(start_page,end_page+1):
        # (1) 请求对象的定制
        request = create_request(page)
        # （2）获取网页的源码
        content = get_content(request)
        # （3）下载
        down_load(content)

JsonPath

jsonpath的安装及使用方式：
pip安装：
pip install jsonpath
jsonpath的使用：
obj = json.load(open(‘json文件’, ‘r’, encoding=‘utf‐8’))
ret = jsonpath.jsonpath(obj, ‘jsonpath语法’)

test_jsonpath.json

{ "store": {
    "book": [
      { "category": "修真",
        "author": "六道",
        "title": "坏蛋是怎样练成的",
        "price": 8.95
      },
      { "category": "修真",
        "author": "天蚕土豆",
        "title": "斗破苍穹",
        "price": 12.99
      },
      { "category": "修真",
        "author": "唐家三少",
        "title": "斗罗大陆",
        "isbn": "0-553-21311-3",
        "price": 8.99
      },
      { "category": "修真",
        "author": "南派三叔",
        "title": "星辰变",
        "isbn": "0-395-19395-8",
        "price": 22.99
      }
    ],
    "bicycle": {
      "author": "老马",
      "color": "黑色",
      "price": 19.95
    }
  }
}

import json
import jsonpath

obj = json.load(open('test_jsonpath.json','r',encoding='utf-8'))

# 书店所有书的作者
# author_list = jsonpath.jsonpath(obj,'$.store.book[*].author')
# print(author_list)

# 所有的作者
# author_list = jsonpath.jsonpath(obj,'$..author')
# print(author_list)

# store下面的所有的元素
# tag_list = jsonpath.jsonpath(obj,'$.store.*')
# print(tag_list)

# store里面所有东西的price
# price_list = jsonpath.jsonpath(obj,'$.store..price')
# print(price_list)

# 第三个书
# book = jsonpath.jsonpath(obj,'$..book[2]')
# print(book)

# 最后一本书
# book = jsonpath.jsonpath(obj,'$..book[(@.length-1)]')
# print(book)

# 	前面的两本书
# book_list = jsonpath.jsonpath(obj,'$..book[0,1]')
# book_list = jsonpath.jsonpath(obj,'$..book[:2]')
# print(book_list)

# 条件过滤需要在（）的前面添加一个？
# 	 过滤出所有的包含isbn的书。
# book_list = jsonpath.jsonpath(obj,'$..book[?(@.isbn)]')
# print(book_list)


# 哪本书超过了10块钱
book_list = jsonpath.jsonpath(obj,'$..book[?(@.price>10)]')
print(book_list)

淘票网站

jsonpath解析淘票票.json

{"returnCode":"0","returnValue":{"A":[{"id":3643,"parentId":0,"regionName":"阿坝","cityCode":513200,"pinYin":"ABA"},{"id":3090,"parentId":0,"regionName":"阿克苏","cityCode":652900,"pinYin":"AKESU"},{"id":3632,"parentId":0,"regionName":"阿拉善","cityCode":152900,"pinYin":"ALASHAN"},{"id":899,"parentId":0,"regionName":"安康","cityCode":610900,"pinYin":"ANKANG"},{"id":196,"parentId":0,"regionName":"安庆","cityCode":340800,"pinYin":"ANQING"},{"id":758,"parentId":0,"regionName":"鞍山","cityCode":210300,"pinYin":"ANSHAN"},{"id":388,"parentId":0,"regionName":"安顺","cityCode":520400,"pinYin":"ANSHUN"},{"id":454,"parentId":0,"regionName":"安阳","cityCode":410500,"pinYin":"ANYANG"}],"B":[{"id":3633,"parentId":0,"regionName":"白城","cityCode":220800,"pinYin":"BAICHENG"},{"id":356,"parentId":0,"regionName":"百色","cityCode":451000,"pinYin":"BAISE"},{"id":634,"parentId":0,"regionName":"白山","cityCode":220600,"pinYin":"BAISHAN"},{"id":275,"parentId":0,"regionName":"白银","cityCode":620400,"pinYin":"BAIYIN"},{"id":426,"parentId":0,"regionName":"保定","cityCode":130600,"pinYin":"BAODING"},{"id":188,"parentId":0,"regionName":"宝鸡","cityCode":610300,"pinYin":"BAOJI"},{"id":994,"parentId":0,"regionName":"保山","cityCode":530500,"pinYin":"BAOSHAN"},{"id":1181,"parentId":0,"regionName":"包头","cityCode":150200,"pinYin":"BAOTOU"},{"id":789,"parentId":0,"regionName":"巴彦淖尔","cityCode":150800,"pinYin":"BAYANNAOER"},{"id":925,"parentId":0,"regionName":"巴中","cityCode":511900,"pinYin":"BAZHONG"},{"id":358,"parentId":0,"regionName":"北海","cityCode":450500,"pinYin":"BEIHAI"},{"id":3,"parentId":0,"regionName":"北京","cityCode":110100,"pinYin":"BEIJING"},{"id":200,"parentId":0,"regionName":"蚌埠","cityCode":340300,"pinYin":"BENGBU"},{"id":760,"parentId":0,"regionName":"本溪","cityCode":210500,"pinYin":"BENXI"},{"id":390,"parentId":0,"regionName":"毕节","cityCode":522401,"pinYin":"BIJIE"},{"id":824,"parentId":0,"regionName":"滨州","cityCode":371600,"pinYin":"BINZHOU"},{"id":1126,"parentId":0,"regionName":"亳州","cityCode":341600,"pinYin":"BOZHOU"},{"id":5860,"parentId":0,"regionName":"巴音郭楞","cityCode":652800,"pinYin":"BYGL"}],"C":[{"id":430,"parentId":0,"regionName":"沧州","cityCode":130900,"pinYin":"CANGZHOU"},{"id":623,"parentId":0,"regionName":"长春","cityCode":220100,"pinYin":"CHANGCHUN"},{"id":573,"parentId":0,"regionName":"常德","cityCode":430700,"pinYin":"CHANGDE"},{"id":983,"parentId":0,"regionName":"昌吉","cityCode":652300,"pinYin":"CHANGJI"},{"id":5781,"parentId":0,"regionName":"昌江","cityCode":469026,"pinYin":"CHANGJIANG"},{"id":576,"parentId":0,"regionName":"长沙","cityCode":430100,"pinYin":"CHANGSHA"},{"id":883,"parentId":0,"regionName":"长治","cityCode":140400,"pinYin":"CHANGZHI"},{"id":651,"parentId":0,"regionName":"常州","cityCode":320400,"pinYin":"CHANGZHOU"},{"id":3244,"parentId":0,"regionName":"朝阳","cityCode":211300,"pinYin":"CHAOYANG"},{"id":1138,"parentId":0,"regionName":"潮州","cityCode":445100,"pinYin":"CHAOZHOU"},{"id":433,"parentId":0,"regionName":"承德","cityCode":130800,"pinYin":"CHENGDE"},{"id":70,"parentId":0,"regionName":"成都","cityCode":510100,"pinYin":"CHENGDU"},{"id":5859,"parentId":0,"regionName":"澄迈县","cityCode":469023,"pinYin":"CHENGMAI"},{"id":585,"parentId":0,"regionName":"郴州","cityCode":431000,"pinYin":"CHENZHOU"},{"id":791,"parentId":0,"regionName":"赤峰","cityCode":150400,"pinYin":"CHIFENG"},{"id":205,"parentId":0,"regionName":"池州","cityCode":341700,"pinYin":"CHIZHOU"},{"id":40,"parentId":0,"regionName":"重庆","cityCode":500100,"pinYin":"CHONGQING"},{"id":3640,"parentId":0,"regionName":"崇左","cityCode":451400,"pinYin":"CHONGZUO"},{"id":996,"parentId":0,"regionName":"楚雄","cityCode":532300,"pinYin":"CHUXIONG"},{"id":207,"parentId":0,"regionName":"滁州","cityCode":341100,"pinYin":"CHUZHOU"}],"D":[{"id":998,"parentId":0,"regionName":"大理","cityCode":532900,"pinYin":"DALI"},{"id":763,"parentId":0,"regionName":"大连","cityCode":210200,"pinYin":"DALIAN"},{"id":3071,"parentId":0,"regionName":"儋州","cityCode":460400,"pinYin":"DAN"},{"id":753,"parentId":0,"regionName":"丹东","cityCode":210600,"pinYin":"DANDONG"},{"id":514,"parentId":0,"regionName":"大庆","cityCode":230600,"pinYin":"DAQING"},{"id":885,"parentId":0,"regionName":"大同","cityCode":140200,"pinYin":"DATONG"},{"id":3638,"parentId":0,"regionName":"大兴安岭","cityCode":232700,"pinYin":"DAXINGANLING"},{"id":935,"parentId":0,"regionName":"达州","cityCode":511700,"pinYin":"DAZHOU"},{"id":3650,"parentId":0,"regionName":"德宏","cityCode":533100,"pinYin":"DEHONG"},{"id":937,"parentId":0,"regionName":"德阳","cityCode":510600,"pinYin":"DEYANG"},{"id":827,"parentId":0,"regionName":"德州","cityCode":371400,"pinYin":"DEZHOU"},{"id":5884,"parentId":0,"regionName":"定安","cityCode":469021,"pinYin":"DINGANXIAN"},{"id":1135,"parentId":0,"regionName":"定西","cityCode":621100,"pinYin":"DINGXI"},{"id":1000,"parentId":0,"regionName":"迪庆","cityCode":533400,"pinYin":"DIQINGZANGZU"},{"id":5742,"parentId":0,"regionName":"东方","cityCode":469007,"pinYin":"DONGFANG"},{"id":109,"parentId":0,"regionName":"东莞","cityCode":441900,"pinYin":"DONGGUAN"},{"id":829,"parentId":0,"regionName":"东营","cityCode":370500,"pinYin":"DONGYING"}],"E":[{"id":793,"parentId":0,"regionName":"鄂尔多斯","cityCode":150600,"pinYin":"EERDUOSI"},{"id":541,"parentId":0,"regionName":"恩施","cityCode":422800,"pinYin":"ENSHI"},{"id":543,"parentId":0,"regionName":"鄂州","cityCode":420700,"pinYin":"EZHOU"}],"F":[{"id":360,"parentId":0,"regionName":"防城港","cityCode":450600,"pinYin":"FANGCHENGGANG"},{"id":61,"parentId":0,"regionName":"佛山","cityCode":440600,"pinYin":"FOSHAN"},{"id":770,"parentId":0,"regionName":"抚顺","cityCode":210400,"pinYin":"FUSHUN"},{"id":1176,"parentId":0,"regionName":"阜新","cityCode":210900,"pinYin":"FUXIN"},{"id":1125,"parentId":0,"regionName":"阜阳","cityCode":341200,"pinYin":"FUYANG"},{"id":745,"parentId":0,"regionName":"抚州","cityCode":361000,"pinYin":"FUZHOU"},{"id":98,"parentId":0,"regionName":"福州","cityCode":350100,"pinYin":"FUZHOU"}],"G":[{"id":3658,"parentId":0,"regionName":"甘南","cityCode":623000,"pinYin":"GANNAN"},{"id":718,"parentId":0,"regionName":"赣州","cityCode":360700,"pinYin":"GANZHOU"},{"id":3644,"parentId":0,"regionName":"甘孜","cityCode":513300,"pinYin":"GANZI"},{"id":2166,"parentId":43,"regionName":"巩义市","cityCode":410181,"pinYin":"GONGYI","selected":1},{"id":3642,"parentId":0,"regionName":"广安","cityCode":511600,"pinYin":"GUANGAN"},{"id":3453,"parentId":0,"regionName":"广元","cityCode":510800,"pinYin":"GUANGYUAN"},{"id":8,"parentId":0,"regionName":"广州","cityCode":440100,"pinYin":"GUANGZHOU"},{"id":362,"parentId":0,"regionName":"贵港","cityCode":450800,"pinYin":"GUIGANG"},{"id":364,"parentId":0,"regionName":"桂林","cityCode":450300,"pinYin":"GUILIN"},{"id":394,"parentId":0,"regionName":"贵阳","cityCode":520100,"pinYin":"GUIYANG"},{"id":1183,"parentId":0,"regionName":"固原","cityCode":640400,"pinYin":"GUYUAN"}],"H":[{"id":508,"parentId":0,"regionName":"哈尔滨","cityCode":230100,"pinYin":"HAERBIN"},{"id":3659,"parentId":0,"regionName":"海东","cityCode":630200,"pinYin":"HAIDONG"},{"id":414,"parentId":0,"regionName":"海口","cityCode":460100,"pinYin":"HAIKOU"},{"id":5788,"parentId":0,"regionName":"海南州","cityCode":632500,"pinYin":"HAINANZHOU"},{"id":3665,"parentId":0,"regionName":"海西","cityCode":632800,"pinYin":"HAIXI"},{"id":3669,"parentId":0,"regionName":"哈密","cityCode":652200,"pinYin":"HAMI"},{"id":435,"parentId":0,"regionName":"邯郸","cityCode":130400,"pinYin":"HANDAN"},{"id":16,"parentId":0,"regionName":"杭州","cityCode":330100,"pinYin":"HANGZHOU","selected":0},{"id":902,"parentId":0,"regionName":"汉中","cityCode":610700,"pinYin":"HANZHONG"},{"id":460,"parentId":0,"regionName":"鹤壁","cityCode":410600,"pinYin":"HEBI"},{"id":1144,"parentId":0,"regionName":"河池","cityCode":451200,"pinYin":"HECHI"},{"id":210,"parentId":0,"regionName":"合肥","cityCode":340100,"pinYin":"HEFEI"},{"id":1154,"parentId":0,"regionName":"鹤岗","cityCode":230400,"pinYin":"HEGANG"},{"id":3637,"parentId":0,"regionName":"黑河","cityCode":231100,"pinYin":"HEIHE"},{"id":1148,"parentId":0,"regionName":"衡水","cityCode":131100,"pinYin":"HENGSHUI"},{"id":587,"parentId":0,"regionName":"衡阳","cityCode":430400,"pinYin":"HENGYANG"},{"id":3673,"parentId":0,"regionName":"和田","cityCode":653200,"pinYin":"HETIAN"},{"id":319,"parentId":0,"regionName":"河源","cityCode":441600,"pinYin":"HEYUAN"},{"id":832,"parentId":0,"regionName":"菏泽","cityCode":371700,"pinYin":"HEZE"},{"id":370,"parentId":0,"regionName":"贺州","cityCode":451100,"pinYin":"HEZHOU"},{"id":1002,"parentId":0,"regionName":"红河","cityCode":532500,"pinYin":"HONGHE"},{"id":666,"parentId":0,"regionName":"淮安","cityCode":320800,"pinYin":"HUAIAN"},{"id":1127,"parentId":0,"regionName":"淮北","cityCode":340600,"pinYin":"HUAIBEI"},{"id":590,"parentId":0,"regionName":"怀化","cityCode":431200,"pinYin":"HUAIHUA"},{"id":215,"parentId":0,"regionName":"淮南","cityCode":340400,"pinYin":"HUAINAN"},{"id":547,"parentId":0,"regionName":"黄冈","cityCode":421100,"pinYin":"HUANGGANG"},{"id":3661,"parentId":0,"regionName":"黄南","cityCode":632300,"pinYin":"HUANGNAN"},{"id":217,"parentId":0,"regionName":"黄山","cityCode":341000,"pinYin":"HUANGSHAN"},{"id":550,"parentId":0,"regionName":"黄石","cityCode":420200,"pinYin":"HUANGSHI"},{"id":796,"parentId":0,"regionName":"呼和浩特","cityCode":150100,"pinYin":"HUHEHAOTE"},{"id":163,"parentId":0,"regionName":"惠州","cityCode":441300,"pinYin":"HUIZHOU"},{"id":776,"parentId":0,"regionName":"葫芦岛","cityCode":211400,"pinYin":"HULUDAO"},{"id":801,"parentId":0,"regionName":"呼伦贝尔","cityCode":150700,"pinYin":"HULUNBEIER"},{"id":173,"parentId":0,"regionName":"湖州","cityCode":330500,"pinYin":"HUZHOU"}],"J":[{"id":523,"parentId":0,"regionName":"佳木斯","cityCode":230800,"pinYin":"JIAMUSI"},{"id":747,"parentId":0,"regionName":"吉安","cityCode":360800,"pinYin":"JIAN"},{"id":317,"parentId":0,"regionName":"江门","cityCode":440700,"pinYin":"JIANGMEN"},{"id":462,"parentId":0,"regionName":"焦作","cityCode":410800,"pinYin":"JIAOZUO"},{"id":156,"parentId":0,"regionName":"嘉兴","cityCode":330400,"pinYin":"JIAXING"},{"id":1136,"parentId":0,"regionName":"嘉峪关","cityCode":620200,"pinYin":"JIAYUGUAN"},{"id":327,"parentId":0,"regionName":"揭阳","cityCode":445200,"pinYin":"JIEYANG"},{"id":628,"parentId":0,"regionName":"吉林","cityCode":220200,"pinYin":"JILIN"},{"id":837,"parentId":0,"regionName":"济南","cityCode":370100,"pinYin":"JINAN"},{"id":3556,"parentId":0,"regionName":"金昌","cityCode":620300,"pinYin":"JINCHANG"},{"id":892,"parentId":0,"regionName":"晋城","cityCode":140500,"pinYin":"JINCHENG"},{"id":724,"parentId":0,"regionName":"景德镇","cityCode":360200,"pinYin":"JINGDEZHEN"},{"id":536,"parentId":0,"regionName":"荆门","cityCode":420800,"pinYin":"JINGMEN"},{"id":545,"parentId":0,"regionName":"荆州","cityCode":421000,"pinYin":"JINGZHOU"},{"id":142,"parentId":0,"regionName":"金华","cityCode":330700,"pinYin":"JINHUA"},{"id":842,"parentId":0,"regionName":"济宁","cityCode":370800,"pinYin":"JINING"},{"id":894,"parentId":0,"regionName":"晋中","cityCode":140700,"pinYin":"JINZHONG"},{"id":779,"parentId":0,"regionName":"锦州","cityCode":210700,"pinYin":"JINZHOU"},{"id":726,"parentId":0,"regionName":"九江","cityCode":360400,"pinYin":"JIUJIANG"},{"id":277,"parentId":0,"regionName":"酒泉","cityCode":620900,"pinYin":"JIUQUAN"},{"id":521,"parentId":0,"regionName":"鸡西","cityCode":230300,"pinYin":"JIXI"},{"id":1102,"parentId":0,"regionName":"济源","cityCode":410881,"pinYin":"JIYUAN"}],"K":[{"id":466,"parentId":0,"regionName":"开封","cityCode":410200,"pinYin":"KAIFENG"},{"id":985,"parentId":0,"regionName":"喀什","cityCode":653100,"pinYin":"KASHEN"},{"id":3667,"parentId":0,"regionName":"克拉玛依","cityCode":650200,"pinYin":"KELAMAYI"},{"id":3672,"parentId":0,"regionName":"克孜勒苏柯尔克孜","cityCode":653000,"pinYin":"KEZILESUKEERKEZI"},{"id":18,"parentId":0,"regionName":"昆明","cityCode":530100,"pinYin":"KUNMING"}],"L":[{"id":3639,"parentId":0,"regionName":"来宾","cityCode":451300,"pinYin":"LAIBIN"},{"id":419,"parentId":0,"regionName":"廊坊","cityCode":131000,"pinYin":"LANGFANG"},{"id":279,"parentId":0,"regionName":"兰州","cityCode":620100,"pinYin":"LANZHOU"},{"id":979,"parentId":0,"regionName":"拉萨","cityCode":540100,"pinYin":"LASA"},{"id":940,"parentId":0,"regionName":"乐山","cityCode":511100,"pinYin":"LESHAN"},{"id":3645,"parentId":0,"regionName":"凉山","cityCode":513400,"pinYin":"LIANGSHAN"},{"id":677,"parentId":0,"regionName":"连云港","cityCode":320700,"pinYin":"LIANYUNGANG"},{"id":847,"parentId":0,"regionName":"聊城","cityCode":371500,"pinYin":"LIAOCHENG"},{"id":1178,"parentId":0,"regionName":"辽阳","cityCode":211000,"pinYin":"LIAOYANG"},{"id":630,"parentId":0,"regionName":"辽源","cityCode":220400,"pinYin":"LIAOYUAN"},{"id":992,"parentId":0,"regionName":"丽江","cityCode":530700,"pinYin":"LIJIANG"},{"id":1008,"parentId":0,"regionName":"临沧","cityCode":530900,"pinYin":"LINCANG"},{"id":890,"parentId":0,"regionName":"临汾","cityCode":141000,"pinYin":"LINFEN"},{"id":5590,"parentId":0,"regionName":"临高","cityCode":469024,"pinYin":"LINGAO"},{"id":3498,"parentId":0,"regionName":"临夏","cityCode":622900,"pinYin":"LINXIA"},{"id":849,"parentId":0,"regionName":"临沂","cityCode":371300,"pinYin":"LINYI"},{"id":3657,"parentId":0,"regionName":"林芝","cityCode":542600,"pinYin":"LINZHI"},{"id":1039,"parentId":0,"regionName":"丽水","cityCode":331100,"pinYin":"LISHUI"},{"id":227,"parentId":0,"regionName":"六安","cityCode":341500,"pinYin":"LIUAN"},{"id":406,"parentId":0,"regionName":"六盘水","cityCode":520200,"pinYin":"LIUPANSHUI"},{"id":380,"parentId":0,"regionName":"柳州","cityCode":450200,"pinYin":"LIUZHOU"},{"id":288,"parentId":0,"regionName":"陇南","cityCode":621200,"pinYin":"LONGNAN"},{"id":263,"parentId":0,"regionName":"龙岩","cityCode":350800,"pinYin":"LONGYAN"},{"id":595,"parentId":0,"regionName":"娄底","cityCode":431300,"pinYin":"LOUDI"},{"id":5863,"parentId":0,"regionName":"陵水","cityCode":469028,"pinYin":"LS"},{"id":1194,"parentId":0,"regionName":"吕梁","cityCode":141100,"pinYin":"LULIANG"},{"id":495,"parentId":0,"regionName":"漯河","cityCode":411100,"pinYin":"LUOHE"},{"id":486,"parentId":0,"regionName":"洛阳","cityCode":410300,"pinYin":"LUOYANG"},{"id":959,"parentId":0,"regionName":"泸州","cityCode":510500,"pinYin":"LUZHOU"}],"M":[{"id":170,"parentId":0,"regionName":"马鞍山","cityCode":340500,"pinYin":"MAANSHAN"},{"id":348,"parentId":0,"regionName":"茂名","cityCode":440900,"pinYin":"MAOMING"},{"id":961,"parentId":0,"regionName":"眉山","cityCode":511400,"pinYin":"MEISHAN"},{"id":350,"parentId":0,"regionName":"梅州","cityCode":441400,"pinYin":"MEIZHOU"},{"id":944,"parentId":0,"regionName":"绵阳","cityCode":510700,"pinYin":"MIANYANG"},{"id":528,"parentId":0,"regionName":"牡丹江","cityCode":231000,"pinYin":"MUDANJIANG"}],"N":[{"id":738,"parentId":0,"regionName":"南昌","cityCode":360100,"pinYin":"NANCHANG"},{"id":968,"parentId":0,"regionName":"南充","cityCode":511300,"pinYin":"NANCHONG"},{"id":63,"parentId":0,"regionName":"南京","cityCode":320100,"pinYin":"NANJING"},{"id":372,"parentId":0,"regionName":"南宁","cityCode":450100,"pinYin":"NANNING"},{"id":254,"parentId":0,"regionName":"南平","cityCode":350700,"pinYin":"NANPING"},{"id":132,"parentId":0,"regionName":"南通","cityCode":320600,"pinYin":"NANTONG"},{"id":499,"parentId":0,"regionName":"南阳","cityCode":411300,"pinYin":"NANYANG"},{"id":970,"parentId":0,"regionName":"内江","cityCode":511000,"pinYin":"NEIJIANG"},{"id":147,"parentId":0,"regionName":"宁波","cityCode":330200,"pinYin":"NINGBO"},{"id":268,"parentId":0,"regionName":"宁德","cityCode":350900,"pinYin":"NINGDE"},{"id":3651,"parentId":0,"regionName":"怒江","cityCode":533300,"pinYin":"NUJIANG"}],"P":[{"id":784,"parentId":0,"regionName":"盘锦","cityCode":211100,"pinYin":"PANJIN"},{"id":951,"parentId":0,"regionName":"攀枝花","cityCode":510400,"pinYin":"PANZHIHUA"},{"id":502,"parentId":0,"regionName":"平顶山","cityCode":410400,"pinYin":"PINGDINGSHAN"},{"id":1137,"parentId":0,"regionName":"平凉","cityCode":620800,"pinYin":"PINGLIANG"},{"id":711,"parentId":0,"regionName":"萍乡","cityCode":360300,"pinYin":"PINGXIANG"},{"id":3198,"parentId":0,"regionName":"普洱","cityCode":530800,"pinYin":"PUER"},{"id":271,"parentId":0,"regionName":"莆田","cityCode":350300,"pinYin":"PUTIAN"},{"id":458,"parentId":0,"regionName":"濮阳","cityCode":410900,"pinYin":"PUYANG"}],"Q":[{"id":3647,"parentId":0,"regionName":"黔东南","cityCode":522600,"pinYin":"QIANDONGNAN"},{"id":1158,"parentId":0,"regionName":"潜江","cityCode":429005,"pinYin":"QIANJIANG"},{"id":3648,"parentId":0,"regionName":"黔南","cityCode":522700,"pinYin":"QIANNAN"},{"id":3646,"parentId":0,"regionName":"黔西南","cityCode":522300,"pinYin":"QIANXINAN"},{"id":51,"parentId":0,"regionName":"青岛","cityCode":370200,"pinYin":"QINGDAO"},{"id":3318,"parentId":0,"regionName":"庆阳","cityCode":621000,"pinYin":"QINGYANG"},{"id":102,"parentId":0,"regionName":"清远","cityCode":441800,"pinYin":"QINGYUAN"},{"id":446,"parentId":0,"regionName":"秦皇岛","cityCode":130300,"pinYin":"QINHUANGDAO"},{"id":1145,"parentId":0,"regionName":"钦州","cityCode":450700,"pinYin":"QINZHOU"},{"id":1124,"parentId":0,"regionName":"琼海","cityCode":469002,"pinYin":"QIONGHAI"},{"id":5851,"parentId":0,"regionName":"琼中","cityCode":469030,"pinYin":"QIONGZHONG"},{"id":530,"parentId":0,"regionName":"齐齐哈尔","cityCode":230200,"pinYin":"QIQIHAER"},{"id":3636,"parentId":0,"regionName":"七台河","cityCode":230900,"pinYin":"QITAIHE"},{"id":245,"parentId":0,"regionName":"泉州","cityCode":350500,"pinYin":"QUANZHOU"},{"id":1016,"parentId":0,"regionName":"曲靖","cityCode":530300,"pinYin":"QUJING"},{"id":145,"parentId":0,"regionName":"衢州","cityCode":330800,"pinYin":"QUZHOU"}],"R":[{"id":3654,"parentId":0,"regionName":"日喀则","cityCode":540200,"pinYin":"RIKEZE"},{"id":877,"parentId":0,"regionName":"日照","cityCode":371100,"pinYin":"RIZHAO"}],"S":[{"id":449,"parentId":0,"regionName":"三门峡","cityCode":411200,"pinYin":"SANMENXIA"},{"id":239,"parentId":0,"regionName":"三明","cityCode":350400,"pinYin":"SANMING"},{"id":410,"parentId":0,"regionName":"三亚","cityCode":460200,"pinYin":"SANYA"},{"id":1,"parentId":0,"regionName":"上海","cityCode":310100,"pinYin":"SHANGHAI"},{"id":897,"parentId":0,"regionName":"商洛","cityCode":611000,"pinYin":"SHANGLUO"},{"id":452,"parentId":0,"regionName":"商丘","cityCode":411400,"pinYin":"SHANGQIU"},{"id":713,"parentId":0,"regionName":"上饶","cityCode":361100,"pinYin":"SHANGRAO"},{"id":3653,"parentId":0,"regionName":"山南","cityCode":540500,"pinYin":"SHANNANSHI"},{"id":290,"parentId":0,"regionName":"汕头","cityCode":440500,"pinYin":"SHANTOU"},{"id":294,"parentId":0,"regionName":"汕尾","cityCode":441500,"pinYin":"SHANWEI"},{"id":296,"parentId":0,"regionName":"韶关","cityCode":440200,"pinYin":"SHAOGUAN"},{"id":66,"parentId":0,"regionName":"绍兴","cityCode":330600,"pinYin":"SHAOXING"},{"id":571,"parentId":0,"regionName":"邵阳","cityCode":430500,"pinYin":"SHAOYANG"},{"id":75,"parentId":0,"regionName":"沈阳","cityCode":210100,"pinYin":"SHENYANG"},{"id":28,"parentId":0,"regionName":"深圳","cityCode":440300,"pinYin":"SHENZHEN"},{"id":1200,"parentId":0,"regionName":"石河子","cityCode":659001,"pinYin":"SHIHEZI"},{"id":59,"parentId":0,"regionName":"石家庄","cityCode":130100,"pinYin":"SHIJIAZHUANG"},{"id":68,"parentId":0,"regionName":"十堰","cityCode":420300,"pinYin":"SHIYAN"},{"id":807,"parentId":0,"regionName":"石嘴山","cityCode":640200,"pinYin":"SHIZUISHAN"},{"id":3635,"parentId":0,"regionName":"双鸭山","cityCode":230500,"pinYin":"SHUANGYASHAN"},{"id":3629,"parentId":0,"regionName":"朔州","cityCode":140600,"pinYin":"SHUOZHOU"},{"id":621,"parentId":0,"regionName":"四平","cityCode":220300,"pinYin":"SIPING"},{"id":1174,"parentId":0,"regionName":"松原","cityCode":220700,"pinYin":"SONGYUAN"},{"id":511,"parentId":0,"regionName":"绥化","cityCode":231200,"pinYin":"SUIHUA"},{"id":922,"parentId":0,"regionName":"遂宁","cityCode":510900,"pinYin":"SUINING"},{"id":534,"parentId":0,"regionName":"随州","cityCode":421300,"pinYin":"SUIZHOU"},{"id":644,"parentId":0,"regionName":"宿迁","cityCode":321300,"pinYin":"SUQIAN"},{"id":193,"parentId":0,"regionName":"宿州","cityCode":341300,"pinYin":"SUZHOU"},{"id":107,"parentId":0,"regionName":"苏州","cityCode":320500,"pinYin":"SUZHOU"}],"T":[{"id":3674,"parentId":0,"regionName":"塔城","cityCode":654200,"pinYin":"TACHENG"},{"id":817,"parentId":0,"regionName":"泰安","cityCode":370900,"pinYin":"TAIAN"},{"id":81,"parentId":0,"regionName":"太原","cityCode":140100,"pinYin":"TAIYUAN"},{"id":181,"parentId":0,"regionName":"台州","cityCode":331000,"pinYin":"TAIZHOU"},{"id":640,"parentId":0,"regionName":"泰州","cityCode":321200,"pinYin":"TAIZHOU"},{"id":83,"parentId":0,"regionName":"唐山","cityCode":130200,"pinYin":"TANGSHAN"},{"id":22,"parentId":0,"regionName":"天津","cityCode":120100,"pinYin":"TIANJIN"},{"id":1159,"parentId":0,"regionName":"天门","cityCode":429006,"pinYin":"TIANMEN"},{"id":1119,"parentId":0,"regionName":"天水","cityCode":620500,"pinYin":"TIANSHUI"},{"id":1179,"parentId":0,"regionName":"铁岭","cityCode":211200,"pinYin":"TIELING"},{"id":1187,"parentId":0,"regionName":"铜川","cityCode":610200,"pinYin":"TONGCHUAN"},{"id":619,"parentId":0,"regionName":"通化","cityCode":220500,"pinYin":"TONGHUA"},{"id":787,"parentId":0,"regionName":"通辽","cityCode":150500,"pinYin":"TONGLIAO"},{"id":191,"parentId":0,"regionName":"铜陵","cityCode":340700,"pinYin":"TONGLING"},{"id":386,"parentId":0,"regionName":"铜仁","cityCode":522201,"pinYin":"TONGREN"}],"W":[{"id":5534,"parentId":0,"regionName":"万宁","cityCode":469006,"pinYin":"WANNING"},{"id":821,"parentId":0,"regionName":"潍坊","cityCode":370700,"pinYin":"WEIFANG"},{"id":853,"parentId":0,"regionName":"威海","cityCode":371000,"pinYin":"WEIHAI"},{"id":905,"parentId":0,"regionName":"渭南","cityCode":610500,"pinYin":"WEINAN"},{"id":5773,"parentId":0,"regionName":"文昌","cityCode":469005,"pinYin":"WENCHANG"},{"id":3269,"parentId":0,"regionName":"文山","cityCode":532600,"pinYin":"WENSHAN"},{"id":1047,"parentId":0,"regionName":"温州","cityCode":330300,"pinYin":"WENZHOU"},{"id":803,"parentId":0,"regionName":"乌海","cityCode":150300,"pinYin":"WUHAI"},{"id":10,"parentId":0,"regionName":"武汉","cityCode":420100,"pinYin":"WUHAN"},{"id":219,"parentId":0,"regionName":"芜湖","cityCode":340200,"pinYin":"WUHU"},{"id":5754,"parentId":0,"regionName":"五家渠","cityCode":659004,"pinYin":"WUJIAQU"},{"id":3630,"parentId":0,"regionName":"乌兰察布","cityCode":150900,"pinYin":"WULANCHABU"},{"id":987,"parentId":0,"regionName":"乌鲁木齐","cityCode":650100,"pinYin":"WULUMUQI"},{"id":284,"parentId":0,"regionName":"武威","cityCode":620600,"pinYin":"WUWEI"},{"id":151,"parentId":0,"regionName":"无锡","cityCode":320200,"pinYin":"WUXI"},{"id":3666,"parentId":0,"regionName":"吴忠","cityCode":640300,"pinYin":"WUZHONG"},{"id":374,"parentId":0,"regionName":"梧州","cityCode":450400,"pinYin":"WUZHOU"}],"X":[{"id":89,"parentId":0,"regionName":"厦门","cityCode":350200,"pinYin":"XIAMEN"},{"id":46,"parentId":0,"regionName":"西安","cityCode":610100,"pinYin":"XIAN"},{"id":599,"parentId":0,"regionName":"湘潭","cityCode":430300,"pinYin":"XIANGTAN"},{"id":602,"parentId":0,"regionName":"湘西","cityCode":433100,"pinYin":"XIANGXI"},{"id":731,"parentId":0,"regionName":"襄阳","cityCode":420600,"pinYin":"XIANGYANG"},{"id":538,"parentId":0,"regionName":"咸宁","cityCode":421200,"pinYin":"XIANNING"},{"id":569,"parentId":0,"regionName":"仙桃","cityCode":429004,"pinYin":"XIANTAO"},{"id":918,"parentId":0,"regionName":"咸阳","cityCode":610400,"pinYin":"XIANYANG"},{"id":1160,"parentId":0,"regionName":"孝感","cityCode":420900,"pinYin":"XIAOGAN"},{"id":3303,"parentId":0,"regionName":"锡林郭勒","cityCode":152500,"pinYin":"XILINGUOLE"},{"id":3631,"parentId":0,"regionName":"兴安盟","cityCode":152200,"pinYin":"XINGAN"},{"id":441,"parentId":0,"regionName":"邢台","cityCode":130500,"pinYin":"XINGTAI"},{"id":3679,"parentId":3646,"regionName":"兴义市","cityCode":522301,"pinYin":"XINGYI","selected":1},{"id":814,"parentId":0,"regionName":"西宁","cityCode":630100,"pinYin":"XINING"},{"id":472,"parentId":0,"regionName":"新乡","cityCode":410700,"pinYin":"XINXIANG"},{"id":470,"parentId":0,"regionName":"信阳","cityCode":411500,"pinYin":"XINYANG"},{"id":733,"parentId":0,"regionName":"新余","cityCode":360500,"pinYin":"XINYU"},{"id":3432,"parentId":0,"regionName":"忻州","cityCode":140900,"pinYin":"XINZHOU"},{"id":1010,"parentId":0,"regionName":"西双版纳","cityCode":532800,"pinYin":"XISHUANGBANNA"},{"id":224,"parentId":0,"regionName":"宣城","cityCode":341800,"pinYin":"XUANCHENG"},{"id":477,"parentId":0,"regionName":"许昌","cityCode":411000,"pinYin":"XUCHANG"},{"id":95,"parentId":0,"regionName":"徐州","cityCode":320300,"pinYin":"XUZHOU"}],"Y":[{"id":3438,"parentId":0,"regionName":"雅安","cityCode":511800,"pinYin":"YAAN"},{"id":912,"parentId":0,"regionName":"延安","cityCode":610600,"pinYin":"YANAN"},{"id":3634,"parentId":0,"regionName":"延边","cityCode":222400,"pinYin":"YANBIAN"},{"id":642,"parentId":0,"regionName":"盐城","cityCode":320900,"pinYin":"YANCHENG"},{"id":329,"parentId":0,"regionName":"阳江","cityCode":441700,"pinYin":"YANGJIANG"},{"id":5750,"parentId":0,"regionName":"洋浦","cityCode":469000,"pinYin":"YANGPU"},{"id":1195,"parentId":0,"regionName":"阳泉","cityCode":140300,"pinYin":"YANGQUAN"},{"id":660,"parentId":0,"regionName":"扬州","cityCode":321000,"pinYin":"YANGZHOU"},{"id":105,"parentId":0,"regionName":"烟台","cityCode":370600,"pinYin":"YANTAI"},{"id":949,"parentId":0,"regionName":"宜宾","cityCode":511500,"pinYin":"YIBIN"},{"id":565,"parentId":0,"regionName":"宜昌","cityCode":420500,"pinYin":"YICHANG"},{"id":3463,"parentId":0,"regionName":"伊春","cityCode":230700,"pinYin":"YICHUN"},{"id":716,"parentId":0,"regionName":"宜春","cityCode":360900,"pinYin":"YICHUN"},{"id":1104,"parentId":0,"regionName":"伊犁","cityCode":654000,"pinYin":"YILI"},{"id":810,"parentId":0,"regionName":"银川","cityCode":640100,"pinYin":"YINCHUAN"},{"id":774,"parentId":0,"regionName":"营口","cityCode":210800,"pinYin":"YINGKOU"},{"id":1170,"parentId":0,"regionName":"鹰潭","cityCode":360600,"pinYin":"YINGTAN"},{"id":4636,"parentId":151,"regionName":"宜兴市","cityCode":320282,"pinYin":"YIXINGSHI","selected":1},{"id":605,"parentId":0,"regionName":"益阳","cityCode":430900,"pinYin":"YIYANG"},{"id":1164,"parentId":0,"regionName":"永州","cityCode":431100,"pinYin":"YONGZHOU"},{"id":607,"parentId":0,"regionName":"岳阳","cityCode":430600,"pinYin":"YUEYANG"},{"id":378,"parentId":0,"regionName":"玉林","cityCode":450900,"pinYin":"YULIN"},{"id":914,"parentId":0,"regionName":"榆林","cityCode":610800,"pinYin":"YULIN"},{"id":888,"parentId":0,"regionName":"运城","cityCode":140800,"pinYin":"YUNCHENG"},{"id":332,"parentId":0,"regionName":"云浮","cityCode":445300,"pinYin":"YUNFU"},{"id":3664,"parentId":0,"regionName":"玉树","cityCode":632700,"pinYin":"YUSHU"},{"id":1012,"parentId":0,"regionName":"玉溪","cityCode":530400,"pinYin":"YUXI"}],"Z":[{"id":857,"parentId":0,"regionName":"枣庄","cityCode":370400,"pinYin":"ZAOZHUANG"},{"id":1236,"parentId":0,"regionName":"张家界","cityCode":430800,"pinYin":"ZHANGGUJIE"},{"id":443,"parentId":0,"regionName":"张家口","cityCode":130700,"pinYin":"ZHANGJIAKOU"},{"id":286,"parentId":0,"regionName":"张掖","cityCode":620700,"pinYin":"ZHANGYE"},{"id":243,"parentId":0,"regionName":"漳州","cityCode":350600,"pinYin":"ZHANGZHOU"},{"id":334,"parentId":0,"regionName":"湛江","cityCode":440800,"pinYin":"ZHANJIANG"},{"id":337,"parentId":0,"regionName":"肇庆","cityCode":441200,"pinYin":"ZHAOQING"},{"id":3649,"parentId":0,"regionName":"昭通","cityCode":530600,"pinYin":"ZHAOTONG"},{"id":43,"parentId":0,"regionName":"郑州","cityCode":410100,"pinYin":"ZHENGZHOU"},{"id":657,"parentId":0,"regionName":"镇江","cityCode":321100,"pinYin":"ZHENJIANG"},{"id":339,"parentId":0,"regionName":"中山","cityCode":442000,"pinYin":"ZHONGSHAN"},{"id":1184,"parentId":0,"regionName":"中卫","cityCode":640500,"pinYin":"ZHONGWEI"},{"id":93,"parentId":0,"regionName":"周口","cityCode":411600,"pinYin":"ZHOUKOU"},{"id":1055,"parentId":0,"regionName":"舟山","cityCode":330900,"pinYin":"ZHOUSHAN"},{"id":346,"parentId":0,"regionName":"珠海","cityCode":440400,"pinYin":"ZHUHAI"},{"id":484,"parentId":0,"regionName":"驻马店","cityCode":411700,"pinYin":"ZHUMADIAN"},{"id":597,"parentId":0,"regionName":"株洲","cityCode":430200,"pinYin":"ZHUZHOU"},{"id":860,"parentId":0,"regionName":"淄博","cityCode":370300,"pinYin":"ZIBO"},{"id":955,"parentId":0,"regionName":"自贡","cityCode":510300,"pinYin":"ZIGONG"},{"id":957,"parentId":0,"regionName":"资阳","cityCode":512000,"pinYin":"ZIYANG"},{"id":403,"parentId":0,"regionName":"遵义","cityCode":520300,"pinYin":"ZUNYI"}]}}

import urllib.request

url = 'https://dianying.taobao.com/cityAction.json?activityId&_ksTS=1629789477003_137&jsoncallback=jsonp138&action=cityAction&n_s=new&event_submit_doGetAllRegion=true'

headers = {
    # ':authority': 'dianying.taobao.com',
    # ':method': 'GET',
    # ':path': '/cityAction.json?activityId&_ksTS=1629789477003_137&jsoncallback=jsonp138&action=cityAction&n_s=new&event_submit_doGetAllRegion=true',
    # ':scheme': 'https',
    'accept': 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript, */*; q=0.01',
    # 'accept-encoding': 'gzip, deflate, br',
    'accept-language': 'zh-CN,zh;q=0.9',
    'cookie': 'cna=UkO6F8VULRwCAXTqq7dbS5A8; miid=949542021157939863; sgcookie=E100F01JK9XMmyoZRigjfmZKExNdRHQqPf4v9NIWIC1nnpnxyNgROLshAf0gz7lGnkKvwCnu1umyfirMSAWtubqc4g%3D%3D; tracknick=action_li; _cc_=UIHiLt3xSw%3D%3D; enc=dA18hg7jG1xapfVGPHoQCAkPQ4as1%2FEUqsG4M6AcAjHFFUM54HWpBv4AAm0MbQgqO%2BiZ5qkUeLIxljrHkOW%2BtQ%3D%3D; hng=CN%7Czh-CN%7CCNY%7C156; thw=cn; _m_h5_tk=3ca69de1b9ad7dce614840fcd015dcdb_1629776735568; _m_h5_tk_enc=ab56df54999d1d2cac2f82753ae29f82; t=874e6ce33295bf6b95cfcfaff0af0db6; xlly_s=1; cookie2=13acd8f4dafac4f7bd2177d6710d60fe; v=0; _tb_token_=e65ebbe536158; tfstk=cGhRB7mNpnxkDmUx7YpDAMNM2gTGZbWLxUZN9U4ulewe025didli6j5AFPI8MEC..; l=eBrgmF1cOsMXqSxaBO5aFurza77tzIRb8sPzaNbMiInca6OdtFt_rNCK2Ns9SdtjgtfFBetPVKlOcRCEF3apbgiMW_N-1NKDSxJ6-; isg=BBoas2yXLzHdGp3pCh7XVmpja8A8S54lyLj1RySTHq14l7vRDNufNAjpZ2MLRxa9',
    'referer': 'https://dianying.taobao.com/',
    'sec-ch-ua': '"Chromium";v="92", " Not A;Brand";v="99", "Google Chrome";v="92"',
    'sec-ch-ua-mobile': '?0',
    'sec-fetch-dest': 'empty',
    'sec-fetch-mode': 'cors',
    'sec-fetch-site': 'same-origin',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36',
    'x-requested-with': 'XMLHttpRequest',
}

request = urllib.request.Request(url = url, headers = headers)

response = urllib.request.urlopen(request)

content = response.read().decode('utf-8')

# split 切割
content = content.split('(')[1].split(')')[0]

with open('074_尚硅谷_爬虫_解析_jsonpath解析淘票票.json','w',encoding='utf-8')as fp:
    fp.write(content)

import json
import jsonpath

obj = json.load(open('jsonpath解析淘票票.json','r',encoding='utf-8'))

city_list = jsonpath.jsonpath(obj,'$..regionName')

BeautifulSoup

1.安装
pip install bs4
2.导入
from bs4 import BeautifulSoup
3.创建对象
服务器响应的文件生成对象
soup = BeautifulSoup(response.read().decode(), ‘lxml’)
本地文件生成对象
soup = BeautifulSoup(open(‘1.html’), ‘lxml’)
注意：默认打开文件的编码格式gbk所以需要指定打开编码格式

节点定位

1.根据标签名查找节点
soup.a 【注】只能找到第一个a
soup.a.name
soup.a.attrs
2.函数
(1).find(返回一个对象)
find(‘a’)：只找到第一个a标签
find(‘a’, title=‘名字’)
find(‘a’, class_=‘名字’)
(2).find_all(返回一个列表)
find_all(‘a’) 查找到所有的a
find_all([‘a’, ‘span’]) 返回所有的a和span
find_all(‘a’, limit=2) 只找前两个a
(3).select(根据选择器得到节点对象)【推荐】
1.element
eg:p
2…class
eg:.firstname
3.#id
eg:#firstname
4.属性选择器
[attribute]
eg:li = soup.select(‘li[class]’)
[attribute=value]
eg:li = soup.select(‘li[class=“hengheng1”]’)
5.层级选择器
element element
div p
element>element
div>p
element,element
div,p
eg:soup = soup.select(‘a,span’)

节点信息

(1).获取节点内容：适用于标签中嵌套标签的结构
obj.string
obj.get_text()【推荐】
(2).节点的属性
tag.name 获取标签名
eg:tag = find('li)
print(tag.name)
tag.attrs将属性值作为一个字典返回
(3).获取节点属性
obj.attrs.get(‘title’)【常用】
obj.get(‘title’)
obj[‘title’]

BeautifulSoup基本使用

bs4的基本使用.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

    <div>
        <ul>
            <li id="l1">张三</li>
            <li id="l2">李四</li>
            <li>王五</li>
            <a href="" id="" class="a1">尚硅谷</a>
            <span>嘿嘿嘿</span>
        </ul>
    </div>


    <a href="" title="a2">百度</a>

    <div id="d1">
        <span>
            哈哈哈
        </span>
    </div>

    <p id="p1" class="p1">呵呵呵</p>
</body>
</html>

from bs4 import BeautifulSoup


# 通过解析本地文件 来将bs4的基础语法进行讲解
# 默认打开的文件的编码格式是gbk 所以在打开文件的时候需要指定编码
soup = BeautifulSoup(open('bs4的基本使用.html',encoding='utf-8'),'lxml')

# 根据标签名查找节点
# 找到的是第一个符合条件的数据
# print(soup.a)
# 获取标签的属性和属性值
# print(soup.a.attrs)

# bs4的一些函数
# （1）find
# 返回的是第一个符合条件的数据
# print(soup.find('a'))

# 根据title的值来找到对应的标签对象
# print(soup.find('a',title="a2"))

# 根据class的值来找到对应的标签对象  注意的是class需要添加下划线
# print(soup.find('a',class_="a1"))


# （2）find_all  返回的是一个列表 并且返回了所有的a标签
# print(soup.find_all('a'))

# 如果想获取的是多个标签的数据 那么需要在find_all的参数中添加的是列表的数据
# print(soup.find_all(['a','span']))

# limit的作用是查找前几个数据
# print(soup.find_all('li',limit=2))


# （3）select（推荐）
# select方法返回的是一个列表  并且会返回多个数据
# print(soup.select('a'))

# 可以通过.代表class  我们把这种操作叫做类选择器
# print(soup.select('.a1'))

# print(soup.select('#l1'))


# 属性选择器---通过属性来寻找对应的标签
# 查找到li标签中有id的标签
# print(soup.select('li[id]'))

# 查找到li标签中id为l2的标签
# print(soup.select('li[id="l2"]'))


# 层级选择器
#  后代选择器
# 找到的是div下面的li
# print(soup.select('div li'))

# 子代选择器
#  某标签的第一级子标签
# 注意：很多的计算机编程语言中 如果不加空格不会输出内容  但是在bs4中 不会报错 会显示内容
# print(soup.select('div > ul > li'))


# 找到a标签和li标签的所有的对象
# print(soup.select('a,li'))

# 节点信息
#    获取节点内容
# obj = soup.select('#d1')[0]
# 如果标签对象中 只有内容 那么string和get_text()都可以使用
# 如果标签对象中 除了内容还有标签 那么string就获取不到数据 而get_text()是可以获取数据
# 我们一般情况下  推荐使用get_text()
# print(obj.string)
# print(obj.get_text())

# 节点的属性
# obj = soup.select('#p1')[0]
# name是标签的名字
# print(obj.name)
# 将属性值左右一个字典返回
# print(obj.attrs)

# 获取节点的属性
obj = soup.select('#p1')[0]

print(obj.attrs.get('class'))
print(obj.get('class'))
print(obj['class'])

爬取星巴克的数据

import urllib.request

url = 'https://www.starbucks.com.cn/menu/'

response = urllib.request.urlopen(url)

content = response.read().decode('utf-8')


from bs4 import BeautifulSoup

soup = BeautifulSoup(content,'lxml')

# //ul[@class="grid padded-3 product"]//strong/text()
name_list = soup.select('ul[class="grid padded-3 product"] strong')

for name in name_list:
    print(name.get_text())

Selenium

Selenium是一个用于Web应用程序测试的工具。
Selenium 测试直接运行在浏览器中，就像真正的用户在操作一样。
支持通过各种driver（FirfoxDriver，IternetExplorerDriver，OperaDriver，ChromeDriver）驱动真实浏览器完成测试。
selenium也是支持无界面浏览器操作的

如何安装selenium？
（1）操作谷歌浏览器驱动下载地址
http://chromedriver.storage.googleapis.com/index.html
（2）谷歌驱动和谷歌浏览器版本之间的映射表
http://blog.csdn.net/huilan_same/article/details/51896672
（3）查看谷歌浏览器版本
谷歌浏览器右上角‐‐>帮助‐‐>关于
（4）pip install selenium

selenium的使用步骤？
（1）导入：from selenium import webdriver
（2）创建谷歌浏览器操作对象：
path = 谷歌浏览器驱动文件路径
browser = webdriver.Chrome(path)
（3）访问网址
url = 要访问的网址
browser.get(url)

作用

import urllib.request

url = 'https://www.jd.com/'

response = urllib.request.urlopen(url)

content = response.read().decode('utf-8')

print(content)

基本使用

# （1）导入selenium
from selenium import webdriver

# (2) 创建浏览器操作对象
path = 'chromedriver.exe'

browser = webdriver.Chrome(path)

# （3）访问网站
# url = 'https://www.baidu.com'
#
# browser.get(url)
url = 'https://www.jd.com/'
browser.get(url)

# page_source获取网页源码
content = browser.page_source
print(content)

selenium的元素定位

	元素定位：自动化要做的就是模拟鼠标和键盘来操作来操作这些元素，点击、输入等等。操作这些元素前首先要找到它们，WebDriver提供很多定位元素的方法
	
方法：
find_element_by_id
	eg:button = browser.find_element_by_id('su')
find_elements_by_name
	eg:name = browser.find_element_by_name('wd')
find_elements_by_xpath
	eg:xpath1 = browser.find_elements_by_xpath('//input[@id="su"]')
find_elements_by_tag_name
	eg:names = browser.find_elements_by_tag_name('input')
find_elements_by_css_selector
	eg:my_input = browser.find_elements_by_css_selector('#kw')[0]
find_elements_by_link_text
	eg:browser.find_element_by_link_text("新闻")



from selenium import webdriver

path = 'chromedriver.exe'
browser = webdriver.Chrome(path)

url = 'https://www.baidu.com'
browser.get(url)

# 元素定位

# 根据id来找到对象
# button = browser.find_element_by_id('su')
# print(button)

# 根据标签属性的属性值来获取对象的
# button = browser.find_element_by_name('wd')
# print(button)

# 根据xpath语句来获取对象
# button = browser.find_elements_by_xpath('//input[@id="su"]')
# print(button)

# 根据标签的名字来获取对象
# button = browser.find_elements_by_tag_name('input')
# print(button)

# 使用的bs4的语法来获取对象
# button = browser.find_elements_by_css_selector('#su')
# print(button)

# button = browser.find_element_by_link_text('直播')
# print(button)

元素信息



from selenium import webdriver

path = 'chromedriver.exe'
browser = webdriver.Chrome(path)


url = 'http://www.baidu.com'
browser.get(url)


input = browser.find_element_by_id('su')

# 获取标签的属性
print(input.get_attribute('class'))
# 获取标签的名字
print(input.tag_name)

# 获取元素文本
a = browser.find_element_by_link_text('新闻')
print(a.text)

交互



from selenium import webdriver

# 创建浏览器对象
path = 'chromedriver.exe'
browser = webdriver.Chrome(path)

# url
url = 'https://www.baidu.com'
browser.get(url)

import time
time.sleep(2)

# 获取文本框的对象
input = browser.find_element_by_id('kw')

# 在文本框中输入周杰伦
input.send_keys('周杰伦')

time.sleep(2)

# 获取百度一下的按钮
button = browser.find_element_by_id('su')

# 点击按钮
button.click()

time.sleep(2)

# 滑到底部
js_bottom = 'document.documentElement.scrollTop=100000'
browser.execute_script(js_bottom)

time.sleep(2)

# 获取下一页的按钮
next = browser.find_element_by_xpath('//a[@class="n"]')

# 点击下一页
next.click()

time.sleep(2)

# 回到上一页
browser.back()

time.sleep(2)

# 回去
browser.forward()

time.sleep(3)

# 退出
browser.quit()