xPath常用语法实例版

原创 2006年05月26日 08:28:00

实例 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

选择所有父元素是DDDBBB元素


     <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]

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


     <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>

 

 

 

实例 10

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

 

//CCC | //BBB

选择所有的CCCBBB元素


     <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>

 

/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>

 

XPath语法要点

什么是XPath XML Path Language    访问xml中任意位置的一种语法,实际上是一种对于xml文档位置(路径)的描述,与文件系统的路径表达相似 XML是一种层次结构的文档,有一个...
  • emy_zj
  • emy_zj
  • 2017年03月11日 21:01
  • 308

xpath常用语法

XPath 示例 本主题回顾整个 XPath 参考中出现的语法示例。所有示例均基于本节后所附 《XPath 语法的示例 XML 文件》。 表达式 引用 ./author 当前上...
  • chuanzhongdu1
  • chuanzhongdu1
  • 2012年02月09日 12:26
  • 518

XPath常用语法

你所应该知道的XPATH 1.从根路径开始的绝对路径方式获取/AAA 例子:获取所有AAA下的BBB下的所有CCC:/AAA/BBB/CCC 2.所有指定名称的元素//AAA 例子:获取所有名称为...
  • qq_29720657
  • qq_29720657
  • 2018年01月03日 08:43
  • 44

XPath实例详解

XPath 是XML的查询语言,和SQL的角色很类似。以下面XML为例,介绍XPath 的语法。       Empire Burlesque     Bob Dylan     10.90...
  • sven_xu
  • sven_xu
  • 2015年06月02日 09:20
  • 1697

XPath实例教程

实例 1基本的XPath语法类似于在一个文件系统中定位文件,如果路径以斜线 / 开始, 那么该路径就表示到一个元素的绝对路径/AAA选择根元素AAA     AAA>           BBB/> ...
  • terryzero
  • terryzero
  • 2009年09月06日 00:05
  • 4692

Selenium使用Xpath定位元素及实例(1)

绝对路径/ 例子:①查找根元素,即/A(红色) ②查找A下面的C元素,即/A/C(绿色) ③查找A下面D的子元素B,即/A/D/B(蓝色) 模糊匹配// ① 查找所有的B元素,//B(红色)...
  • DaxiaLeeSuper
  • DaxiaLeeSuper
  • 2017年06月08日 22:01
  • 578

python xpath 例子

#coding:utf-8 import urllib import http.cookiejar import json from lxml import etree class MyWeb(o...
  • freshfox
  • freshfox
  • 2017年06月29日 15:31
  • 306

python scrapy xpath常用语法

Node[not(@class)] //不含class属性的node节点 Node[contains(text(),a)] //文本包含字符串a的node节点 Node[count(span)=2] ...
  • ShellDawn
  • ShellDawn
  • 2017年02月24日 16:29
  • 279

XPath与lxml库介绍及爬虫案例

XPath与lxml库介绍及爬虫案例XPath介绍XPath(XML Path Language)是一门在XML文档中查找信息的语言,可用来在XML文档中对元素和属性进行遍历。XPath的节点XPat...
  • qq_33689414
  • qq_33689414
  • 2017年11月16日 17:24
  • 478

python lxml xpath 使用实例!

python lxml xpath 使用实例 目标:使用xpath定位节点,也可以说好像在sql 上提取数据! 例子 #-*- coding:utf-8 -*- import lxml.html h...
  • heavyzero
  • heavyzero
  • 2015年03月19日 09:46
  • 3408
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:xPath常用语法实例版
举报原因:
原因补充:

(最多只允许输入30个字)