python中xpath怎么使用呢？不知道的小伙伴来看看小编今天的分享吧!
一、xpath简介
XPath 是一门在 XML 文档中查找信息的语言。XPath 可用来在 XML 文档中对元素和属性进行遍历。XPath 是 W3C XSLT 标准的主要元素，并且 XQuery 和 XPointer 都构建于 XPath 表达之上。
二、安装
pip3 install lxml
三、使用
1、导入
from lxml import etree
2、基本使用
from lxml import etree
wb_data = """
<div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a>
</ul>
</div>
"""
html = etree.HTML(wb_data)
print(html)
result = etree.tostring(html)
print(result.decode("utf-8"))
从下面的结果来看，我们打印机html其实就是一个python对象，etree.tostring(html)则是不全里html的基本写法，补全了缺胳膊少腿的标签。
<Element html at 0x39e58f0>
<html><body><div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a>
</li></ul>
</div>
</body></html>
3、获取某个标签的内容(基本使用)，注意，获取a标签的所有内容，a后面就不用再加正斜杠，否则报错。
写法一
html = etree.HTML(wb_data)
html_data = html.xpath('/html/body/div/ul/li/a')
print(html)
for i in html_data:
print(i.text)
<Element html at 0x12fe4b8>
first item
second item
third item
fourth item
fifth item
写法二（直接在需要查找内容的标签后面加一个/text()就行）
html = etree.HTML(wb_data)
html_data = html.xpath('/html/body/div/ul/li/a/text()')
print(html)
for i in html_data:
print(i)
<Element html at 0x138e4b8>
first item
second item
third item
fourth item
fifth item
4、打开读取html文件
#使用parse打开html的文件
html = etree.parse('test.html')
html_data = html.xpath('//*')<br>#打印是一个列表，需要遍历
print(html_data)
for i in html_data:
print(i.text)
html = etree.parse('test.html')
html_data = etree.tostring(html,pretty_print=True)
res = html_data.decode('utf-8')
print(res)
打印：
<div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
5、打印指定路径下a标签的属性（可以通过遍历拿到某个属性的值，查找标签的内容）
html = etree.HTML(wb_data)
html_data = html.xpath('/html/body/div/ul/li/a/@href')
for i in html_data:
print(i)
打印：
link1.html
link2.html
link3.html
link4.html
link5.html
6、我们知道我们使用xpath拿到得都是一个个的ElementTree对象，所以如果需要查找内容的话，还需要遍历拿到数据的列表。
查到绝对路径下a标签属性等于link2.html的内容。
html = etree.HTML(wb_data)
html_data = html.xpath('/html/body/div/ul/li/a[@href="link2.html"]/text()')
print(html_data)
for i in html_data:
print(i)
打印：
['second item']
second item
7、上面的找到全部都是绝对路径（每一个都是从根开始查找），下面是查找相对路径，例如，查找所有li标签下的a标签内容。
html = etree.HTML(wb_data)
html_data = html.xpath('//li/a/text()')
print(html_data)
for i in html_data:
print(i)
打印：
['first item', 'second item', 'third item', 'fourth item', 'fifth item']
first item
second item
third item
fourth item
fifth item
8、上面我们使用绝对路径，查找了所有a标签的属性等于href属性值，利用的是/---绝对路径，下面我们使用相对路径，查找一下l相对路径下li标签下的a标签下的href属性的值，注意，a标签后面需要双//。
html = etree.HTML(wb_data)
html_data = html.xpath('//li/a//@href')
print(html_data)
for i in html_data:
print(i)
打印：
['link1.html', 'link2.html', 'link3.html', 'link4.html', 'link5.html']
link1.html
link2.html
link3.html
link4.html
link5.html
9、相对路径下跟绝对路径下查特定属性的方法类似，也可以说相同。
html = etree.HTML(wb_data)
html_data = html.xpath('//li/a[@href="link2.html"]')
print(html_data)
for i in html_data:
print(i.text)
打印：
[<Element a at 0x216e468>]
second item
10、查找最后一个li标签里的a标签的href属性
html = etree.HTML(wb_data)
html_data = html.xpath('//li[last()]/a/text()')
print(html_data)
for i in html_data:
print(i)
打印：
['fifth item']
fifth item
11、查找倒数第二个li标签里的a标签的href属性
html = etree.HTML(wb_data)
html_data = html.xpath('//li[last()-1]/a/text()')
print(html_data)
for i in html_data:
print(i)
打印：
['fourth item']
fourth item
12、如果在提取某个页面的某个标签的xpath路径的话，可以如下图：
//*[@id="kw"]
解释：使用相对路径查找所有的标签，属性id等于kw的标签。
以上就是小编今天的分享了，希望可以帮助到大家。
python 内置方法都有哪些？通过分类整合成一套简单的备忘教程
一、入门函数1.input()功能：
接受标准输入，返回字符串类型
语法格式：
input([提示信息])
实例：
# input 函数介绍text = input("请输入信息:")print("收到的数据是:%s" % (text))#输出：请输入信息: hello world收到的数据是: hello world2.print()
功能：
输出打印信息
语法格式：
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)# 参数说明：sep : 在值之间插入字符串，默认为空格。end : 在最后一个值之后附加的字符串，默认为换行符flush: 是否强制刷新，这个参数一般和file一起使用 。file : 输出到文件
实例：
# print 函数介绍str1 = "hello"str2 = "python"# 1.打印第一个字符串print(str1)# 2.同时打印两个字符串print(str1,str2)# 3.sep示例 ： 如果打印多个字符串的话，可以使用sep进行分割，不加sep默认为空格print("加入字符串分隔符",str1,str2,sep="::")#输出hellohello python加入字符串分隔符::hello::python3.help()
功能：
用来查看函数或模块的详细信息
语法格式：
help(对象)# 参数说明：对象可以是一个具体的函数，也可以是一个数据类型
实例：
help('str') #查看str模块的的详细信息tp = (1,23,345)help(tp) #查看元祖的详细信息二、数学函数1.sum()
功能：
对序列进行求和计算。
语法格式：
sum(seq,[number])# 参数说明：seq : 代表一个序列 ，可以是列表 ，字符串 、集合等number : 相加的参数值
实例：
sum([2,3,4]) # 输出 ： 9sum([2,3,4],6) # 输出 ： 152.max()
功能：
返回序列中的最大值。
语法格式：
sum(a,b,c,...)# 参数说明：a,b,c 需要是同一数据类型
实例：
max(2,3,4,5) # 输出 ： 5max('hello','world') # 输出：worldmax([2,3,4,5]) # 输出 ：53.min()
功能：
返回给定参数的最小值。
语法格式：
sum(a,b,c,...)# 参数说明：a,b,c 需要是同一数据类型
实例：
min(2,3,4,5) # 输出 ： 2min('hello','world') # 输出：hellomin([2,3,4,5]) # 输出 ：24.divmod()
功能：
接受两个数字，返回商和余数的元祖(a//b , a%b)。
语法格式：
divmod(a,b)# 参数说明：a,b 是两个数字
实例：
divmod(10,2) # 输出 ：(5, 0)divmod(9,2) # 输出：(4, 1)5.abs()
功能：
返回数字的绝对值。
语法格式：
abs(a)
实例：
abs(-2.3) # 输出 ： 2.36.pow()
功能：
返回 xy（x 的 y 次方） 的值。
语法格式：
pow(x,y)
实例：
pow(3,3) # 输出 ： 277.round()
功能：
返回浮点数x的四色五入的值
语法格式：
round( x ，[ n] )# 参数说明：x 是一个浮点数 n 是一个整数
实例：
round(3.326,2) # 输出 ： 3.33三、数据类型函数1.int()
功能：
将一个字符串或数字转换为整型
语法格式：
int(x)# 参数说明：x 是一个数字或者字符串
实例：
int(4.5) #输出: 4int('3') #输出: 32.str()
功能：
将其它数据类型转化为字符串
语法格式：
str(data) # 参数说明：data 为具体的数据类型
实例：
str(12) #输出: '12'str([12,13]) #输出: '[12, 13]'str({'a':1}) #输出: "{'a': 1}"str(bool) #输出: "<class 'bool'>"3.bool()
功能：
将给定参数转换为布尔类型，如果没有参数，返回 False。
语法格式：
bool(x)# 参数说明：x 要转化的参数
实例：
bool(1) #输出: Truebool('hello') #输出: Truebool(1==1) #输出: Truebool([12]) #输出: True4.float()
功能：
用于将整数和字符串转换成浮点数。
语法格式：
float(x)# 参数说明：x 要转化的参数
实例：
float(32) #输出: 32.0float('32') #输出 32.0float(32.00) #输出: 32.05.tuple()
功能：
将序列转化为元祖。
语法格式：
tuple(seq)# 参数说明：seq 要转化的序列
实例：
tuple(['a',1,3]) #输出: ('a', 1, 3)tuple('abcd') #输出: ('a', 'b', 'c', 'd')tuple({'a':1,'b':2}) #输出: ('a', 'b')tuple({'a','b','c'}) #输出: ('c', 'a', 'b')6.list()
功能：
将序列转化为列表。
语法格式：
list(seq)# 参数说明：seq 要转化的序列
实例：
list((1,2,3,5)) #输出: [1, 2, 3, 5]list("abcd") #输出: ['a', 'b', 'c', 'd']list({'a':1,'b':1}) #输出: ['a', 'b']7.dict()
功能：
用于创建字典。
语法格式：
dict(**kwarg)# 参数说明：kwarg 一组或多组键值对
实例：
dict() #输出: {}dict(a=1,b=2) #输出: {'a': 1, 'b': 2}dict((('a',1),('b',2))) #输出: {'a': 1, 'b': 2}8.set()
功能：
创建一个无序不重复的集合。
语法格式：
set(seq)# 参数说明：seq 要转化的序列
实例：
set('hello') #输出: {'e', 'h', 'l', 'o'}set([1,2,33,3,2]) #输出: {1, 2, 3, 33}四、序列迭代器函数1.len()
功能：
返回序列的长度
语法格式：
len(seq)# 参数说明：seq 序列
实例：
len((1,2,3,4,5)) #输出: 5len([1,2,3,4]) #输出: 4len("helloworld") #输出: 10len({'a':1,"b":2}) #输出: 22.slice()
功能：
函数返回一个切片(slice)对象。slice对象用于指定如何对序列进行切片
语法格式：
slice(start, end, step)# 参数说明：start 一个整数，指定在哪个位置开始切片。 默认为0end 一个整数，指定在哪个位置结束切片step 一个整数，指定切片的步骤。 默认为1
实例：
tp = ("c", "c ", "java", "php", "go", "python", "c#")x = slice(2, 4)print(tp[x])#输出 ：('java', 'php')3.sorted()
功能：
函数对所有可迭代的对象进行排序操作。
语法格式：
sorted(iterable, cmp=None, key=None, reverse=False)# 参数说明：iterable -- 可迭代对象。cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse - - 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
实例：
sorted([3,7,23,4,9]) #输出: [3, 4, 7, 9, 23]city = [('chongqin',3011),('beijing',2300),('shanghai',2600)]sorted(city,key=lambda x:x[1])#输出: [('beijing', 2300), ('shanghai', 2600), ('chongqin', 3011)]sorted(city,key=lambda x:x[1],reverse=True)#输出: [('chongqin', 3011), ('shanghai', 2600), ('beijing', 2300)]4.reverse()
功能：
用于反转列表中的元素。。
语法格式：
list.reverse()
实例：
lst = [3,45,6]lst.reverse()lst #输出: [6, 45, 3]5.filter()
功能：
用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
语法格式：
filter(function, iterable)# 参数说明：function 判断函数。iterable 可迭代对象。
实例：
def qos(n): return n % 2 == 0it = filter(qos,[1,23,77,4,5,67,8,9])print(it) #输出 ：<filter object at 0x03131230>for x in it: print(x,) #输出<filter object at 0x03131230>48#实例2：it1 = filter(lambda x:x%2==0,[1,23,77,4,5,67,8,9])for x in it1: print(x) #输出：486.all()
功能：
用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
其中 ： 0、空、None、False 这几个值返回False外 ，其它的值都返回Ture
语法格式：
all(iterable)# 参数说明：iterable 元组或列表。
实例：
all((1,0,-1)) #输出: False ，因为这里面有个0 ，0返回Falseall(('a','')) #输出: False ，因为这里有个空 ，空返回Falseall((True,False)) #输出: False ，因为这里面有个False all((12,None)) #输出: False ，因为这里面有个None 7.any()
功能：
用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
这个函数跟all()正好相反
语法格式：
any(iterable)# 参数说明：iterable 元组或列表。
实例：
any([1,0,-1]) #输出: Trueany(['a','']) #输出: Trueany([True,False]) #输出: True8.iter()
功能：
用来生成迭代器。
语法格式：
iter(object)# 参数说明：object 一个迭代对象
实例：
it = iter(["java","python","go"])print(it) #输出 ：<list_iterator object at 0x055CE710>for x in it: print(x)#输出 ：javapythongo9.next()
功能：
返回迭代器的下一个元素
语法格式：
next(iterable,[default])# 参数说明：iterable 一个可迭代对象default 如果迭代器已结束，则返回默认值。
实例：
lst = iter(["java","python","go"])next(lst) #输出: 'java'next(lst) #输出: 'python'next(lst) #输出: 'go'next(lst,"c ") #输出: 'c '10.range()
功能：
返回一个数字序列，默认情况下从0开始，然后递增，并以指定的数字结束。
语法格式：
range([start], end, [step])# 参数说明：start 一个整数，指定从哪个位置开始。 默认为0end 一个整数，指定在哪个位置结束。step 一个整数，指定增量。 默认为1
实例：
# 设置end=6 ,其它都走默认for x in range(3): print(x,end=" ")print()print("="*30)# 设置start=1，end=6for y in range(1,6): print(y,end=" ")print()print("="*30)#设置start=2,end=10,step=3for z in range(2,10,3): print(z,end=" ") #输出 ：0 1 2 ==============================1 2 3 4 5 ==============================2 5 8 11.enumerate()
功能：
用于将一个可遍历的序列(如列表、元组或字符串)组合为一个索引序列，同时列出数据和对应的索引
语法格式：
enumerate(iterable)# 参数说明：iterable 可迭代对象
实例：
lst = ['java', 'go', 'php']for index,value in enumerate(lst): print(index,"==",value) #输出 0 == java1 == go2 == php12.zip()
功能：
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
语法格式：
zip([iterable})# 参数说明：iterable 迭代器
实例：
a = [1,2,3]b = [4,5,6]tuple(zp) #输出: ((1, 4), (2, 5), (3, 6))13.map()
功能：
为迭代器中的每个项目指定执行的函数。该项目将作为参数发送到函数。
语法格式：
map(function, iterables)# 参数说明：function 函数iterable 序列，集合或迭代器对象。
实例：
def sq(x): return x ** 2 map(sq,[1,2,3,4,5]) #输出: <map at 0x532e2d0>mp = map(sq,[1,2,3,4,5])list(mp) #输出: [1, 4, 9, 16, 25]五、对象函数1.id()
功能：
返回对象的唯一标识符，标识符是一个整数。
语法格式：
id([object])# 参数说明：object 对象
实例：
id('hello world') #输出 : 85404512id(10) #输出: 1705170112id('') #输出: 122450882.type()
功能：
返回指定对象的类型
语法格式：
type(object)# 参数说明：object 对象
实例：
type([1,2,3,4]) #输出: listtype((1,2,3)) #输出: tupletype("abc") #输出: strtype({'a':1,'b':1}) #输出: dict3.isinstance()
功能：
为迭代器中的每个项目指定执行的函数。该项目将作为参数发送到函数。
语法格式：
isinstance(object, type)# 参数说明：object 对象type 类型
实例：
isinstance('abc', str) #输出: Trueisinstance([1,2], list) #输出: Trueisinstance((1,2), tuple) #输出: Trueisinstance({'a':1,'b':2}, dict) #输出: True4.issubclass()
功能：
对象是指定对象的子类，则该函数返回 True，否则返回False。
语法格式：
issubclass(object, subclass)# 参数说明：object 对象subclass 对象的父类
实例：
class Person(): passclass Student(Person): name = "zhangsan" age = 21res = issubclass(Student,Person) #判断Student是Person的子类print(res)#输出 ： True5.staticmethod()
功能：
返回函数的静态方法。
语法格式：
staticmethod()
实例：
class Person(): passclass Student(Person): name = "zhangsan" age = 21 @staticmethod def study(content): print("学生学习的内容是：{}".format(content))Student.study('python')6.super()
功能：
用于调用父类的一个方法。
语法格式：
super()
实例：
class Person(): def study(self): print("人人都需要学习")class Student(Person): name = "zhangsan" age = 21 def study(self,content): super().study() #调用父类的study方法 print("学生学习的内容是：{}".format(content))s = Student()s.study('python')六、对象操作函数1.format()
功能：
字符串的格式化
语法格式：
"{}".format("字符串")
实例：
"hello {}".format("python") #输出: 'hello python'"{} {}".format("hello","python") #输出: 'hello python'"{1} {0}".format("python","hello") #输出: 'hello python'"{} {lg}".format('hello',lg="python") #输出: 'hello python'2.repr()
功能：
转化为供解释器读取的形式。
语法格式：
repr(object)# 参数介绍object 对象
实例：
>>>repr([0,1,2,3])'[0,1,2,3]'>>> repr('Hello')"'Hello'">>> str(1.0/7.0)'0.142857142857'>>> repr(1.0/7.0)'0.14285714285714285'3.eval()
功能：
用来执行一个字符串表达式，并返回表达式的值。
语法格式：
eval(expression)#参数expression -- 表达式。
实例：
eval("3 * 2") #输出: 6eval("sum([2,3])") #输出: 5eval("isinstance([1,2,3],list)") #输出: True4.exec()
功能：
执行指定的Python代码。 exec() 函数接受较大的代码块，与 eval仅接受单个表达式的函数不同
语法格式：
exec(expression)#参数expression -- 表达式。
实例：
score = 63def get_result(sc): if sc > 60: print("及格") else: print("不及格")exec('get_result(score)') #注意 ： 这里传递的是一个字符串，而字符串其实就是上面的函数5.open()
功能：
将打开一个文件，并将其作为文件对象返回。
语法格式：
open(file, mode)# 参数说明file 文件的路径和名称mode 打开模式，具体打开包括如下几种： “r” - 读取-默认值。 打开文件进行读取，如果文件不存在，则报错 “a” - 附加-打开文件进行附加，如果文件不存在，则创建该文件 “w” - 写入-打开要写入的文件，如果文件不存在，则创建该文件 “x” - 创建-创建指定的文件，如果文件存在则返回错误 “t” - 文本-默认值。 文字模式 “b” - 二进制-二进制模式（例如图像）
实例：
f = open('a.txt') #打开a.txtres = f.read() #读取a.txt的内容print(res)# 输出：输出的是a.txt中的内容hello world七、对象属性函数1.setattr()
功能：
用于设置属性值，该属性不一定是存在的
语法格式：
setattr(object, name, value)#参数说明：object 对象。name 字符串，对象属性。value 属性值。
实例：
class Student(): name = "zhangsan"s = Student()setattr(s,'age',21) #设置属性ageprint(s.age) #输出：212.getattr()
功能：
返回一个对象属性值。
语法格式：
getattr(object, name，[default])#参数说明：object 对象。name 字符串，对象属性。default 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
实例：
class Student(): name = "zhangsan"s = Student()name = getattr(s,'name')print(name)age1 = getattr(s,'age',21)print(age1)age = getattr(s,'age') # 如果获取的属性不存在，又没有默认值，则会报错 。print(age)#输出：zhangsan21Traceback (most recent call last): File "E:/project/python_lx/ts_nz/ts_en.py", line 25, in <module> age = getattr(s,'age')AttributeError: 'Student' object has no attribute 'age'3.hasattr()
功能：
用于判断对象是否包含对应的属性。
语法格式：
hasattr(object, name)#参数说明：object 对象。name 字符串，属性名。
实例：
class Student(): name = "zhangsan"s = Student()# 判断是否存在name属性print(hasattr(s,'name')) #输出 ：True#判断是否存在age属性print(hasattr(s,'age')) #输出：False#判断是否存在sex属性print(hasattr(s,'sex')) #输出：False4.delattr()
功能：
用于删除属性。
语法格式：
delattr(object, name)#参数说明：object 对象。name 必须是对象的属性。
实例：
class Student(): name = "zhangsan"s = Student()# 判断是否存在name属性print(hasattr(s,'name')) #输出 ：True# 删除属性namedelattr(Student,'name')# 再次判断是否存在name属性 # 输出 ：False ，这是因为name属性已经被删除了print(hasattr(s,'name'))5.property()
功能：
将类方法转换为类属性，可以用 对象 . 直接获取属性值或者对属性进行赋值
语法格式：
@propertydef func(): pass
实例：
class Student(): def get_age(self): return self._age def set_age(self,value): if not isinstance(value,int): raise ValueError('age must be an integer!') if value < 0 or value > 120: raise ValueError('age must between 0 ~ 120!') self._age = values = Student()s.set_age(23) # 我们这里调用的是通过对象.方法的方式进行调用 print(s.get_age())s.set_age(180)
问题 ： 如果说想要调用的方法像调用属性一样 ，也能完成同样的功能 ，是否也可以实现呢 ？答案就是使用property
接下来我们通过property来设置 ，看看该如何设置呢 ？
class Student(): @property def age(self): return self._age @age.setter def age(self,value): if not isinstance(value,int): raise ValueError('age must be an integer!') if value < 0 or value > 120: raise ValueError('age must between 0 ~ 120!') self._age = values = Student()s.age = 23 #这里的age调用明显就是一个属性方式的调用 ，但是也有函数上的功能 print(s.age) #输出 ：23s.age = 180 #同样会检查该属性是否符合业务#输出：23Traceback (most recent call last): File "E:/project/python_lx/ts_nz/ts_en.py", line 30, in <module> s.age = 180 File "E:/project/python_lx/ts_nz/ts_en.py", line 23, in age raise ValueError('age must between 0 ~ 120!')ValueError: age must between 0 ~ 120!6.vars()
功能：
返回对象object的属性和属性值的字典对象。
语法格式：
vars([object])#参数说明object 对象
实例：
class Student(): name = "zhangsan" age = 23 sex = '男' def get_age(self): return self.ageprint(vars(Student))#输出：以字典形式输出{'__module__': '__main__', 'name': 'zhangsan', 'age': 23, 'sex': '男', 'get_age': <function Student.get_age at 0x032034B0>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
