XPATH语法笔记

最新推荐文章于 2024-02-01 11:42:23 发布
最新推荐文章于 2024-02-01 11:42:23 发布
阅读量613 收藏 1
点赞数
分类专栏： XML应用开发 文章标签： 文档 div xml c

目录

1.      基本的XPath语法类似于在一个文件系统中定位文件,如果路径以斜线 / 开始, 那么该路径就表示到一个元素的绝对路径     1

2.      如果路径以双斜线 // 开头, 则表示选择文档中所有满足双斜线//之后规则的元素(无论层级关系)2

3.      星号 * 表示选择所有由星号之前的路径所定位的元素... 3

4.      方块号里的表达式可以进一步的指定元素, 其中数字表示元素在选择集里的位置, 而last()函数则表示选择集中的最后一个元素.6

5.      属性通过前缀 @ 来指定... 6

6.      属性的值可以被用来作为选择的准则, normalize-space函数删除了前部和尾部的空格, 并且把连续的空格串替换为一个单一的空格... 7

7.      count()函数可以计数所选元素的个数... 8

8.      name()函数返回元素的名称, start-with()函数在该函数的第一个参数字符串是以第二个参数字符开始的情况返回true, contains()函数当其第一个字符串参数包含有第二个字符串参数时返回true.10

9.      string-length函数返回字符串的字符数,你应该用&lt;替代<, 用&gt;代替>. 11

10.        多个路径可以用分隔符 | 合并在一起... 12

11.        child轴(axis)包含上下文节点的子元素, 作为默认的轴,可以忽略不写.13

12.        descendant (后代)轴包含上下文节点的后代,一个后代是指子节点或者子节点的子节点等等, 因此descendant轴不会包含属性和命名空间节点.14

13.        parent轴(axis)包含上下文节点的父节点, 如果有父节点的话... 17

14.        ancestor轴(axis)包含上下节点的祖先节点, 该祖先节点由其上下文节点的父节点以及父节点的父节点等等诸如此类的节点构成,所以ancestor轴总是包含有根节点,除非上下文节点就是根节点本身.17

15.        following-sibling轴(axis)包含上下文节点之后的所有兄弟节点... 19

16.        preceding-sibling 轴(axis)包含上下文节点之前的所有兄弟节点... 20

17.        following轴(axis)包含同一文档中按文档顺序位于上下文节点之后的所有节点, 除了祖先节点,属性节点和命名空间节点     21

18.        preceding轴(axis)包含同一文档中按文档顺序位于上下文节点之前的所有节点, 除了祖先节点,属性节点和命名空间节点     22

19.        descendant-or-self 轴(axis)包含上下文节点本身和该节点的后代节点... 24

20.        ancestor-or-self 轴(axis)包含上下文节点本身和该节点的祖先节点... 25

21.        ancestor, descendant, following, preceding 和self轴(axis)分割了XML文档(忽略属性节点和命名空间节点), 不能交迭, 而一起使用则包含所有节点... 26

22.        div运算符做浮点除法运算, mod运算符做求余运算, floor函数返回不大于参数的最大整数(趋近于正无穷), ceiling返回不小于参数的最小整数(趋近于负无穷)30

 

 

1.       基本的XPath语法类似于在一个文件系统中定位文件,如果路径以斜线 / 开始, 那么该路径就表示到一个元素的绝对路径

/AAA

选择根元素AAA


       <AAA>
            <BBB/>
            <CCC/>
            <BBB/>
            <BBB/>
            <DDD>
                 <BBB/> 
            </DDD>
            <CCC/>
       </AAA>

/AAA/CCC

选择AAA的所有CCC子元素


       <AAA>
            <BBB/>
            <CCC/>
            <BBB/>
            <BBB/>
            <DDD>
                 <BBB/> 
            </DDD>
            <CCC/>
       </AAA>

/AAA/DDD/BBB

选择AAA的子元素DDD的所有子元素


       <AAA>
            <BBB/>
            <CCC/>
            <BBB/>
            <BBB/>
            <DDD>
                 <BBB/>
            </DDD>
            <CCC/>
       </AAA>

2.       如果路径以双斜线 // 开头, 则表示选择文档中所有满足双斜线//之后规则的元素(无论层级关系)

//BBB

选择所有BBB元素


       <AAA>
            <BBB/>
            <CCC/>
            <BBB/>
            <DDD>
                 <BBB/>
            </DDD>
            <CCC>
                 <DDD> 
                      <BBB/>
                      <BBB/>
                 </DDD> 
            </CCC>
       </AAA>

//DDD/BBB

选择所有父元素是DDD的BBB元素


       <AAA>
            <BBB/>
            <CCC/>
            <BBB/>
            <DDD>
                 <BBB/> 
            </DDD>
            <CCC>
                 <DDD> 
                      <BBB/> 
                      <BBB/> 
                 </DDD> 
            </CCC>
       </AAA>

3.       星号 * 表示选择所有由星号之前的路径所定位的元素

/AAA/CCC/DDD/*

选择所有路径依附于/AAA/CCC/DDD的元素


       <AAA>
            <XXX>
                 <DDD> 
                      <BBB/> 
                      <BBB/> 
                      <EEE/> 
                      <FFF/> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD> 
                      <BBB/>
                      <BBB/>
                      <EEE/>
                      <FFF/>
                 </DDD> 
            </CCC>
            <CCC>
                 <BBB> 
                      <BBB> 
                           <BBB/> 
                      </BBB> 
                 </BBB> 
            </CCC>
       </AAA>

/*/*/*/BBB

选择所有的有3个祖先元素的BBB元素


       <AAA>
            <XXX>
                 <DDD> 
                      <BBB/>
                      <BBB/>
                      <EEE/> 
                      <FFF/> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD> 
                      <BBB/>
                      <BBB/>
                      <EEE/> 
                      <FFF/> 
                 </DDD> 
            </CCC>
            <CCC>
                 <BBB> 
                      <BBB>
                           <BBB/> 
                      </BBB>
                 </BBB> 
            </CCC>
       </AAA>

//*

选择所有元素


       <AAA>
            <XXX>
                 <DDD>
                      <BBB/>
                      <BBB/>
                      <EEE/>
                      <FFF/>
                 </DDD>
            </XXX>
            <CCC>
                 <DDD>
                      <BBB/>
                      <BBB/>
                      <EEE/>
                      <FFF/>
                 </DDD>
            </CCC>
            <CCC>
                 <BBB>
                      <BBB>
                           <BBB/>
                      </BBB>
                 </BBB>
            </CCC>
       </AAA>

4.       方块号里的表达式可以进一步的指定元素, 其中数字表示元素在选择集里的位置, 而last()函数则表示选择集中的最后一个元素.

/AAA/BBB[1]

选择AAA的第一个BBB子元素


       <AAA>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
       </AAA>

/AAA/BBB[last()]

选择AAA的最后一个BBB子元素


       <AAA>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
       </AAA>

5.       属性通过前缀 @ 来指定

//@id

选择所有的id属性


       <AAA>
            <BBB id =  "b1"/>
            <BBB id =  "b2"/>
            <BBB name =  "bbb"/>
            <BBB/>
       </AAA>

//BBB[@id]

选择有id属性的BBB元素


       <AAA>
            <BBB id =  "b1"/>
            <BBB id =  "b2"/>
            <BBB name =  "bbb"/>
            <BBB/>
       </AAA>

//BBB[@name]

选择有name属性的BBB元素


       <AAA>
            <BBB id =  "b1"/>
            <BBB id =  "b2"/>
            <BBB name =  "bbb"/>
            <BBB/>
       </AAA>

//BBB[@*]

选择有任意属性的BBB元素


       <AAA>
            <BBB id =  "b1"/>
            <BBB id =  "b2"/>
            <BBB name =  "bbb"/>
            <BBB/>
       </AAA>

//BBB[not(@*)]

选择没有属性的BBB元素


       <AAA>
            <BBB id =  "b1"/>
            <BBB id =  "b2"/>
            <BBB name =  "bbb"/>
            <BBB/>
       </AAA>

6.       属性的值可以被用来作为选择的准则, normalize-space函数删除了前部和尾部的空格,并且把连续的空格串替换为一个单一的空格

//BBB[@id='b1']

选择含有属性id且其值为'b1'的BBB元素


       <AAA>
            <BBB id =  "b1"/>
            <BBB name =  " bbb "/>
            <BBB name =  "bbb"/>
       </AAA>

//BBB[@name='bbb']

选择含有属性name且其值为'bbb'的BBB元素


       <AAA>
            <BBB id =  "b1"/>
            <BBB name =  " bbb "/>
            <BBB name =  "bbb"/>
       </AAA>

//BBB[normalize-space(@name)='bbb']

选择含有属性name且其值(在用normalize-space函数去掉前后空格后)为'bbb'的BBB元素


       <AAA>
            <BBB id =  "b1"/>
            <BBB name = "  bbb "/>
            <BBB name =  "bbb"/>
       </AAA>

7.       count()函数可以计数所选元素的个数

//*[count(BBB)=2]

选择含有2个BBB子元素的元素


       <AAA>
            <CCC>
                 <BBB/> 
                 <BBB/> 
                 <BBB/> 
            </CCC>
            <DDD>
                 <BBB/> 
                 <BBB/> 
            </DDD>
            <EEE>
                 <CCC/> 
                 <DDD/> 
            </EEE>
       </AAA>

//*[count(*)=2]

选择含有2个子元素的元素


       <AAA>
            <CCC>
                 <BBB/> 
                 <BBB/> 
                 <BBB/> 
            </CCC>
            <DDD>
                 <BBB/> 
                 <BBB/> 
            </DDD>
            <EEE>
                 <CCC/> 
                 <DDD/> 
            </EEE>
       </AAA>

//*[count(*)=3]

选择含有3个子元素的元素


       <AAA>
            <CCC>
                 <BBB/> 
                 <BBB/> 
                 <BBB/> 
            </CCC>
            <DDD>
                 <BBB/> 
                 <BBB/> 
            </DDD>
            <EEE>
                 <CCC/> 
                 <DDD/> 
            </EEE>
       </AAA>

8.       name()函数返回元素的名称,start-with()函数在该函数的第一个参数字符串是以第二个参数字符开始的情况返回true, contains()函数当其第一个字符串参数包含有第二个字符串参数时返回true.

//*[name()='BBB']

选择所有名称为BBB的元素(这里等价于//BBB)


       <AAA>
            <BCC>
                 <BBB/>
                 <BBB/>
                 <BBB/>
            </BCC>
            <DDB>
                 <BBB/>
                 <BBB/>
            </DDB>
            <BEC>
                 <CCC/> 
                 <DBD/> 
            </BEC>
       </AAA>

//*[starts-with(name(),'B')]

选择所有名称以"B"起始的元素


       <AAA>
            <BCC>
                 <BBB/>
                 <BBB/>
                 <BBB/>
            </BCC>
            <DDB>
                 <BBB/>
                 <BBB/>
            </DDB>
            <BEC>
                 <CCC/> 
                 <DBD/> 
            </BEC>
       </AAA>

//*[contains(name(),'C')]

选择所有名称包含"C"的元素


       <AAA>
            <BCC>
                 <BBB/> 
                 <BBB/> 
                 <BBB/> 
            </BCC>
            <DDB>
                 <BBB/> 
                 <BBB/> 
            </DDB>
            <BEC>
                 <CCC/>
                 <DBD/> 
            </BEC>
       </AAA>

9.       string-length函数返回字符串的字符数,你应该用&lt;替代<, 用&gt;代替>

//*[string-length(name())  = 3]

选择名字长度为3的元素


       <AAA>
            <Q/>
            <SSSS/>
            <BB/>
            <CCC/>
            <DDDDDDDD/> 
            <EEEE/>
       </AAA>

//*[string-length(name())  < 3]

选择名字长度小于3的元素


       <AAA>
            <Q/>
            <SSSS/>
            <BB/>
            <CCC/>
            <DDDDDDDD/> 
            <EEEE/>
       </AAA>

//*[string-length(name())  > 3]

选择名字长度大于3的元素


       <AAA>
            <Q/>
            <SSSS/>
            <BB/>
            <CCC/>
            <DDDDDDDD/>
            <EEEE/>
       </AAA>

10.   多个路径可以用分隔符 | 合并在一起

//CCC | //BBB

选择所有的CCC和BBB元素


       <AAA>
            <BBB/>
            <CCC/>
            <DDD>
                 <CCC/>
            </DDD>
            <EEE/>
       </AAA>

/AAA/EEE | //BBB

选择所有的BBB元素和所有是AAA的子元素的EEE元素


       <AAA>
            <BBB/>
            <CCC/>
            <DDD>
                 <CCC/> 
            </DDD>
            <EEE/>
       </AAA>

/AAA/EEE |  //DDD/CCC | /AAA | //BBB

可以合并的路径数目没有限制


       <AAA>
            <BBB/>
            <CCC/>
            <DDD>
                 <CCC/>
            </DDD>
            <EEE/>
       </AAA>

11.   child轴(axis)包含上下文节点的子元素, 作为默认的轴,可以忽略不写.

/AAA

等价于 /child::AAA


       <AAA>
            <BBB/>
            <CCC/>
       </AAA>

/child::AAA

等价于/AAA


       <AAA>
            <BBB/>
            <CCC/>
       </AAA>

/AAA/BBB

等价于/child::AAA/child::BBB


       <AAA>
            <BBB/>
            <CCC/>
       </AAA>

/child::AAA/child::BBB

等价于/AAA/BBB


       <AAA>
            <BBB/>
            <CCC/>
       </AAA>

/child::AAA/BBB

二者都可以被合并


       <AAA>
            <BBB/>
            <CCC/>
       </AAA>

12.   descendant (后代)轴包含上下文节点的后代,一个后代是指子节点或者子节点的子节点等等, 因此descendant轴不会包含属性和命名空间节点.

/descendant::*

选择文档根元素的所有后代.即所有的元素被选择


       <AAA>
            <BBB>
                 <DDD>
                      <CCC>
                           <DDD/>
                           <EEE/>
                      </CCC>
                 </DDD>
            </BBB>
            <CCC>
                 <DDD>
                      <EEE>
                           <DDD>
                                <FFF/>
                           </DDD>
                      </EEE>
                 </DDD>
            </CCC>
       </AAA>

/descendant::*

选择文档根元素的所有后代.即所有的元素被选择


       <AAA>
            <BBB>
                 <DDD>
                      <CCC>
                           <DDD/>
                           <EEE/>
                      </CCC>
                 </DDD>
            </BBB>
            <CCC>
                 <DDD>
                      <EEE>
                           <DDD>
                                <FFF/>
                           </DDD>
                      </EEE>
                 </DDD>
            </CCC>
       </AAA>

在XLab中打开实例 | 树视图 (JPG)

 

/AAA/BBB/descendant::*

选择/AAA/BBB的所有后代元素


       <AAA>
            <BBB>
                 <DDD>
                      <CCC>
                           <DDD/>
                           <EEE/>
                      </CCC>
                 </DDD>
            </BBB>
            <CCC>
                 <DDD> 
                      <EEE> 
                           <DDD> 
                                <FFF/> 
                           </DDD> 
                      </EEE> 
                 </DDD> 
            </CCC>
       </AAA>

//CCC/descendant::*

选择在祖先元素中有CCC的所有元素


       <AAA>
            <BBB>
                 <DDD> 
                      <CCC> 
                           <DDD/>
                           <EEE/>
                      </CCC> 
                 </DDD> 
            </BBB>
            <CCC>
                 <DDD>
                      <EEE>
                           <DDD>
                                <FFF/>
                           </DDD>
                      </EEE>
                 </DDD>
            </CCC>
       </AAA>

//CCC/descendant::DDD

选择所有以CCC为祖先元素的DDD元素


       <AAA>
            <BBB>
                 <DDD> 
                      <CCC> 
                           <DDD/>
                           <EEE/> 
                      </CCC> 
                 </DDD> 
            </BBB>
            <CCC>
                 <DDD>
                      <EEE> 
                           <DDD>
                                <FFF/> 
                           </DDD>
                      </EEE> 
                 </DDD>
            </CCC>
       </AAA>

13.   parent轴(axis)包含上下文节点的父节点, 如果有父节点的话

//DDD/parent::*

选择DDD元素的所有父节点


       <AAA>
            <BBB>
                 <DDD> 
                      <CCC>
                           <DDD/> 
                           <EEE/> 
                      </CCC>
                 </DDD> 
            </BBB>
            <CCC>
                 <DDD> 
                      <EEE>
                           <DDD> 
                                <FFF/> 
                           </DDD> 
                      </EEE>
                 </DDD> 
            </CCC>
       </AAA>

14.   ancestor轴(axis)包含上下节点的祖先节点, 该祖先节点由其上下文节点的父节点以及父节点的父节点等等诸如此类的节点构成,所以ancestor轴总是包含有根节点,除非上下文节点就是根节点本身.

/AAA/BBB/DDD/CCC/EEE/ancestor::*

选择一个绝对路径上的所有节点


       <AAA>
            <BBB>
                 <DDD>
                      <CCC>
                           <DDD/> 
                           <EEE/> 
                      </CCC>
                 </DDD>
            </BBB>
            <CCC>
                 <DDD> 
                      <EEE> 
                           <DDD> 
                                <FFF/> 
                           </DDD> 
                      </EEE> 
                 </DDD> 
            </CCC>
       </AAA>

//FFF/ancestor::*

选择FFF元素的祖先节点


       <AAA>
            <BBB>
                 <DDD> 
                      <CCC> 
                           <DDD/> 
                           <EEE/> 
                      </CCC> 
                 </DDD> 
            </BBB>
            <CCC>
                 <DDD>
                      <EEE>
                           <DDD>
                                <FFF/> 
                           </DDD>
                      </EEE>
                 </DDD>
            </CCC>
       </AAA>

15.   following-sibling轴(axis)包含上下文节点之后的所有兄弟节点

/AAA/BBB/following-sibling::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <DDD/> 
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/> 
                      <DDD/> 
                      <CCC/> 
                      <FFF/> 
                      <FFF> 
                           <GGG/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

//CCC/following-sibling::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <DDD/>
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/> 
                      <DDD/> 
                      <CCC/> 
                      <FFF/>
                      <FFF>
                           <GGG/> 
                      </FFF>
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

16.   preceding-sibling 轴(axis)包含上下文节点之前的所有兄弟节点

/AAA/XXX/preceding-sibling::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <DDD/> 
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/> 
                      <DDD/> 
                      <CCC/> 
                      <FFF/> 
                      <FFF> 
                           <GGG/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

//CCC/preceding-sibling::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <DDD/> 
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/>
                      <DDD/>
                      <CCC/> 
                      <FFF/> 
                      <FFF> 
                           <GGG/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

17.   following轴(axis)包含同一文档中按文档顺序位于上下文节点之后的所有节点, 除了祖先节点,属性节点和命名空间节点

/AAA/XXX/following::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <ZZZ> 
                      <DDD/> 
                      <DDD> 
                           <EEE/> 
                      </DDD> 
                 </ZZZ> 
                 <FFF> 
                      <GGG/> 
                 </FFF> 
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/> 
                      <DDD/> 
                      <CCC/> 
                      <FFF/> 
                      <FFF> 
                           <GGG/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/>
            </CCC>
       </AAA>

//ZZZ/following::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <ZZZ> 
                      <DDD/> 
                      <DDD> 
                           <EEE/> 
                      </DDD> 
                 </ZZZ> 
                 <FFF>
                      <GGG/>
                 </FFF>
            </BBB>
            <XXX>
                 <DDD>
                      <EEE/>
                      <DDD/>
                      <CCC/>
                      <FFF/>
                      <FFF>
                           <GGG/>
                      </FFF>
                 </DDD>
            </XXX>
            <CCC>
                 <DDD/>
            </CCC>
       </AAA>

18.   preceding轴(axis)包含同一文档中按文档顺序位于上下文节点之前的所有节点, 除了祖先节点,属性节点和命名空间节点

/AAA/XXX/preceding::*


       <AAA>
            <BBB>
                 <CCC/>
                 <ZZZ>
                      <DDD/>
                 </ZZZ>
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/> 
                      <DDD/> 
                      <CCC/> 
                      <FFF/> 
                      <FFF> 
                           <GGG/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

//GGG/preceding::*


       <AAA>
            <BBB>
                 <CCC/>
                 <ZZZ>
                      <DDD/>
                 </ZZZ>
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/>
                      <DDD/>
                      <CCC/>
                      <FFF/>
                      <FFF> 
                           <GGG/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

19.   descendant-or-self 轴(axis)包含上下文节点本身和该节点的后代节点

/AAA/XXX/descendant-or-self::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <ZZZ> 
                      <DDD/> 
                 </ZZZ> 
            </BBB>
            <XXX>
                 <DDD>
                      <EEE/>
                      <DDD/>
                      <CCC/>
                      <FFF/>
                      <FFF>
                           <GGG/>
                      </FFF>
                 </DDD>
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

//CCC/descendant-or-self::*


       <AAA>
            <BBB>
                 <CCC/>
                 <ZZZ> 
                      <DDD/> 
                 </ZZZ> 
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/> 
                      <DDD/> 
                      <CCC/>
                      <FFF/> 
                      <FFF> 
                           <GGG/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/>
            </CCC>
       </AAA>

20.   ancestor-or-self 轴(axis)包含上下文节点本身和该节点的祖先节点

/AAA/XXX/DDD/EEE/ancestor-or-self::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <ZZZ> 
                      <DDD/> 
                 </ZZZ> 
            </BBB>
            <XXX>
                 <DDD>
                      <EEE/>
                      <DDD/> 
                      <CCC/> 
                      <FFF/> 
                      <FFF> 
                           <GGG/> 
                      </FFF> 
                 </DDD>
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

//GGG/ancestor-or-self::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <ZZZ> 
                      <DDD/> 
                 </ZZZ> 
            </BBB>
            <XXX>
                 <DDD>
                      <EEE/> 
                      <DDD/> 
                      <CCC/> 
                      <FFF/> 
                      <FFF>
                           <GGG/>
                      </FFF>
                 </DDD>
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

21.   ancestor, descendant, following, preceding 和self轴(axis)分割了XML文档(忽略属性节点和命名空间节点), 不能交迭, 而一起使用则包含所有节点

//GGG/ancestor::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <ZZZ/> 
            </BBB>
            <XXX>
                 <DDD>
                      <EEE/> 
                      <FFF>
                           <HHH/> 
                           <GGG> 
                                <JJJ> 
                                     <QQQ/> 
                                </JJJ> 
                                <JJJ/> 
                           </GGG> 
                           <HHH/> 
                      </FFF>
                 </DDD>
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

//GGG/descendant::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <ZZZ/> 
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/> 
                      <FFF> 
                           <HHH/> 
                           <GGG> 
                                <JJJ>
                                     <QQQ/>
                                </JJJ>
                                <JJJ/>
                           </GGG> 
                           <HHH/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

//GGG/following::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <ZZZ/> 
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/> 
                      <FFF> 
                           <HHH/> 
                           <GGG> 
                                <JJJ> 
                                     <QQQ/> 
                                </JJJ> 
                                <JJJ/> 
                           </GGG> 
                           <HHH/>
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/>
            </CCC>
       </AAA>

//GGG/preceding::*


       <AAA>
            <BBB>
                 <CCC/>
                 <ZZZ/>
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/>
                      <FFF> 
                           <HHH/>
                           <GGG> 
                                <JJJ> 
                                     <QQQ/> 
                                </JJJ> 
                                <JJJ/> 
                           </GGG> 
                           <HHH/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

//GGG/self::*


       <AAA>
            <BBB>
                 <CCC/> 
                 <ZZZ/> 
            </BBB>
            <XXX>
                 <DDD> 
                      <EEE/> 
                      <FFF> 
                           <HHH/> 
                           <GGG>
                                <JJJ> 
                                     <QQQ/> 
                                </JJJ> 
                                <JJJ/> 
                           </GGG>
                           <HHH/> 
                      </FFF> 
                 </DDD> 
            </XXX>
            <CCC>
                 <DDD/> 
            </CCC>
       </AAA>

//GGG/ancestor::*  | //GGG/descendant::* | //GGG/following::* | //GGG/preceding::* |  //GGG/self::*


       <AAA>
            <BBB>
                 <CCC/>
                 <ZZZ/>
            </BBB>
            <XXX>
                 <DDD>
                      <EEE/>
                      <FFF>
                           <HHH/>
                           <GGG>
                                <JJJ>
                                     <QQQ/>
                                </JJJ>
                                <JJJ/>
                           </GGG>
                           <HHH/>
                      </FFF>
                 </DDD>
            </XXX>
            <CCC>
                 <DDD/>
            </CCC>
       </AAA>

22.   div运算符做浮点除法运算,mod运算符做求余运算, floor函数返回不大于参数的最大整数(趋近于正无穷),ceiling返回不小于参数的最小整数(趋近于负无穷)

//BBB[position()  mod 2 = 0 ]

选择偶数位置的BBB元素


       <AAA>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <CCC/>
            <CCC/>
            <CCC/>
       </AAA>

//BBB[  position() = floor(last() div 2 + 0.5) or position() = ceiling(last() div 2 +  0.5) ]

选择中间的BBB元素


       <AAA>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <CCC/>
            <CCC/>
            <CCC/>
       </AAA>

//CCC[  position() = floor(last() div 2 + 0.5) or position() = ceiling(last() div 2 +  0.5) ]

选择中间的CCC元素


       <AAA>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <BBB/>
            <CCC/>
            <CCC/>
            <CCC/>
       </AAA>

 

wwang196988
关注
专栏目录
【xpath】使用 descendant 定位子孙节点
浮点型队友
06-20 5380
. . 我们在使用selenium 的xpath方式定位某个元素时，如果这个元素前半部分的路径是确定的，后半部分的路径不确定，并且其中有个img节点是需要我们定位出来的，但是不知道它是第几级子孙节点，这时候就可以用下面的xpath路径写法，总结起来就是 ‘//确定的或固定节点/descendant::子孙节点’ 。 descendant 是子孙后裔的意思。 用这个办法的好处，就是不用管目标节点在...
python爬虫学习笔记：XPath语法和使用示例
WhyLW的博客
08-14 566
python爬虫：XPath语法和使用示例 XPath(XML Path Language)是一门在XML文档中查找信息的语言，可以用来在XML文档中对元素和属性进行遍历。 选取节点 XPath使用路径表达式来选取XML文档中的节点或者节点集。这些路径表达式和我们在常规的电脑文件系统中看到的表达式非常相似。 常用路径表达式： 实例 在下面的表格中，列出一些路径表达式以及表达式的结果： 查找特定的节点 注意点：在xpath中，第一个元素的位置是1，最后一个元素的位置是last()，倒数第二个是last.
XPath学习:轴(3)——descendant
weixin_30853329的博客
09-10 247
XPath 是一门在 XML 文档中查找信息的语言。XPath 可用来在 XML 文档中对元素和属性进行遍历。 XPath 是 W3C XSLT 标准的主要元素，并且 XQuery 和 XPointer 同时被构建于 XPath 表达之上。 推荐一个挺不错的网站：http://www.zvon.org/xxl/XPathTutorial/General_chi/e...
XPath实例教程十一、descendant (后代)轴
weixin_34228617的博客
07-01 437
descendant (后代)轴包含上下文节点的后代,一个后代是指子节点或者子节点的子节点等等, 因此descendant轴不会包含属性和命名空间节点. /descendant::* 选择文档根元素的所有后代.即所有的元素被选择 ...
XPATH
你真有意思的博客
05-03 279
今天学习了scrapy中的spiders部分，爬虫名name，start_url起始点，以及xpath的语法：nodename选取此节点的所有子节点。/从根节点选取。//从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置。.选取当前节点。..选取当前节点的父节点。@选取属性。bookstore选取 bookstore 元素的所有子节点。/bookstore选取根元素 bookstore。注释...
XPath总结
Chenglin(Ben) Yu's Miracle
04-26 589
文章目录XPath总结4.1 XPath中的数据类型序列序列的表示序列的性质项4.2 Xpath表达式的书写XML文档树ancestor，ancestor-or-selfdescendant, descendant-or-selfchild , parentfollowing, precedingfollowing-sibling, preceding-siblingselfnamespaceat...
爬虫笔记02--xpath常用语法
qq_36850938的博客
10-26 228
xpath是一门在XML文档中查找信息的语言 概念 节点(Node) ​ 元素、属性、文本、命名空间、文档（根）节点 节点关系 ​ 父（parent） ​ 子 （Children） ​ 同胞 （Sibling） ​ 先辈 （Ancestor） ​ 后代 （Descendant） xpath语法 表达式 描述 nodename 选取此节点的所有子节点 // 从任意子节点中选取...
爬虫笔记3 Xpath语法与多进程爬虫
兰博怎么玩儿的博客
01-13 305
@兰博怎么玩儿 本文介绍：本文介绍Xpath语法，并用一个实例对比BeautifulSoup与Xpath的爬取速度，最后我们再介绍如何多线程地运行爬虫程序 1、Xpath的使用 1.1 基本用法 Xpath需要第三方库：lxml。其语法是： 获取文本： //标签1[@属性1=“属性值1”]/标签2[@属性2=“属性值2”]/.../text() 获取属性值 //标签1[@属性1=“属性值1”]...
(完整版)python+xpath笔记.docx
12-04
#### 三、XPath基本语法 1. **绝对路径**：以 `/` 开头。 - 例如：`/html/body/div` 2. **相对路径**：不以 `/` 开头。 - 例如：`body/div` #### 四、XPath选择器详解 1. **选择指定位置的节点** - **`/body/...
c#使用正则表达式获取TR中的多个TD_python爬虫学习笔记：XPath语法和使用示例
weixin_39845206的博客
11-20 575
python爬虫：XPath语法和使用示例XPath(XML Path Language)是一门在XML文档中查找信息的语言，可以用来在XML文档中对元素和属性进行遍历。选取节点XPath使用路径表达式来选取XML文档中的节点或者节点集。这些路径表达式和我们在常规的电脑文件系统中看到的表达式非常相似。常用路径表达式：实例在下面的表格中，列出一些路径表达式以及表达式的结果：查找特定的节点注意点：在x...
XPATH语法(一)
weixin_30731287的博客
06-14 158
Xpath简介 XPath即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某部分位置的语言。XPath基于XML的树状结构，有不同类型的节点，包括元素节点，属性节点和文本节点，提供在数据结构树中找寻节点的能力。起初 XPath 的提出的初衷是将其作为一个通用的、介于XPointer与XSLT间的语法模型。但是 XPath 很快的被开发者采用来当作...
笔记-爬虫-XPATH
akuibpt23191的博客
10-18 112
笔记-爬虫-XPATH 1. xpath XPath是W3C的一个标准。它最主要的目的是为了在XML1.0或XML1.1文档节点树中定位节点所设计。目前有XPath1.0和XPath2.0两个版本。其中Xpath1.0是1999年成为W3C标准，而XPath2.0标准的确立是在2007年 XPath 是一门在 XML 文档中查找信息的语言 全称为XML Path ...
Python + selenium 元素定位（六）----Xpath的高级用法
weixin_56349063的博客
12-10 4443
Xpath的高级用法 Xpath： 即为xml路径语言（XML path language）。 Xml不是用来取代HTML，而是对HTML的补充，用来与HTML协同工作的。 Xml是元标记 语言。 元标记： 表示可以从标记中就可以看出描述的内容本身什么。 Xpath使用路径表达式来选取XML文件中的节点或者节点集。 路径： 绝对路径 和 相对路径 xpath定位元素的原理遍历的原理。 1、绝对路径定位元素 使用绝对路径来定位元素 定位到第一个输入框并输入内容 driver.find_elemen
XPath从入门到精通：基础和高级用法完整指南，附美团APP匹配示例
最新发布
程序员李林
02-01 1499
父节点 (Parent)： HTML 是 DIV 和 P 节点的父节点；子节点 (Child)：DIV 和 P 是 HTML 的子节点；兄弟节点 (Sibling)：拥有同样的一个父节点，DIV 和 P 就是兄弟节点。类似的 span、img 和 i 也是兄弟节点。祖先节点 (Ancestor)：html 是 span 的祖先节点，隔开一级；后代节点 (Descendant)：span 是 HTML 的后代节点，隔开一级。
在selenium测试中使用XPATH功能函数starts-with、contains、descendant、ancestor、text()定位网页元素
可口可乐的博客
01-07 5127
转载地址：http://blog.csdn.net/godenbird312/article/details/41444587 项目中一些使用xpath函数的复杂例子，记录于此 1. 使用starts-with //div[starts-with(@id,'res')]//table//tr//td[2]//table//tr//td//a//span[contains(.,
xpath元素定位常用的5种方法（相对路径）
热门推荐
adorable_的博客
05-08 3万+
一、xpath定位 定位 说明 //ul/* ul的所有子元素 //input[2] 第2个input元素 //input[last() 最后一个input元素 input[position()< 3] 前2个input元素 //input[@value] 有value属性的input元素 //input[@name=‘password’ and @pwd=‘123456’] 属性name的值等于password并且属性pwd的值等于123456的input元素
Xpath中关于部分常用轴表达式使用总结
测试之美
01-29 1万+
我们在自动化测试中会经常使用到xpath来进行对象的选择。之前我写过的一篇关于自动化测试对象定位的八种常用方式中，也介绍了一些xpath的基本表达式。但有些比较特殊的情况中，仅靠这些比较基本的xpath表达式还不够灵活，所以今天继续介绍几种比较常用的基于“轴（Axes）”的表达式。本文中的示例HTML代码为http://www.guru99.com，代码使用的区域为如下图所示，大家可以在该页面中对照
XPath详解，总结
weixin_30247159的博客
04-16 1681
经常在工作中会使用到XPath的相关知识，但每次总会在一些关键的地方不记得或不太清楚，所以免不了每次总要查一些零碎的知识，感觉即很烦又浪费时间，所以对XPath归纳及总结一下。 在这篇文章中你将能学习到： XPath简介 XPath 路径表达式详解 XPath在DOM，XSLT及XQuery中的应用 XPath简介 XPath是W3C的一个标准。它最主要的目的是为了在...
Xpath 学习整理
maverick17的博客
03-19 323
 学习scrapy的时候需要用到Xpath的知识，故整理下知识点。什么是 XPath?XPath 使用路径表达式在 XML 文档中进行导航XPath 包含一个标准函数库XPath 是 XSLT 中的主要元素XPath 是一个 W3C 标准    XPath 使用路径表达式来选取 XML 文档中的节点或者节点集。XPath 含有超过 100 个内建的函数。这些函数用于字符串值、数值、日期和时间比较、...
# Selenium自动化测试笔记：学习初级语法及介绍
本文是一份针对初学者的自动化测试语法笔记，包括了Selenium的介绍以及其支持的语言。通过学习这份笔记，读者可以对Selenium进行初步的了解并进行回顾。 ## 一、Selenium介绍 ### 1. 什么是Selenium? Selenium是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值