Navigation

  • index
  • modules |
  • next |
  • previous |
  • rdflib 4.2.0 documentation »

Navigating Graphs¶

An RDF Graph is a set of RDF triples, and we try to mirror exactly this in RDFLib, and the graph tries to emulate a container type:

Graphs as Iterators¶

RDFLib graphs override __iter__() in order to support iteration over the contained triples:

for subject,predicate,obj in someGraph:
   if not (subject,predicate,obj) in someGraph:
      raise Exception("Iterator / Container Protocols are Broken!!")

Contains check¶

Graphs implement __contains__(), so you can check if a triple is in a graph with triple in graph syntax:

from rdflib import URIRef
from rdflib.namespace import RDF
bob = URIRef("http://example.org/people/bob")
if ( bob, RDF.type, FOAF.Person ) in graph:
   print "This graph knows that Bob is a person!"

Note that this triple does not have to be completely bound:

if (bob, None, None) in graph:
   print "This graph contains triples about Bob!"

Set Operations on RDFLib Graphs¶

Graphs override several pythons operators: __iadd__(), __isub__(), etc. This supports addition, subtraction and other set-operations on Graphs:

operation effect
G1 + G2 return new graph with union
G1 += G1 in place union / addition
G1 - G2 return new graph with difference
G1 -= G2 in place difference / subtraction
G1 & G2 intersection (triples in both graphs)
G1 ^ G2 xor (triples in either G1 or G2, but not in both)

Warning

Set-operations on graphs assume bnodes are shared between graphs. This may or may not do what you want. See Merging graphs for details.

Basic Triple Matching¶

Instead of iterating through all triples, RDFLib graphs support basic triple pattern matching with a triples() function. This function is a generator of triples that match the pattern given by the arguments. The arguments of these are RDF terms that restrict the triples that are returned. Terms that are None are treated as a wildcard. For example:

g.load("some_foaf.rdf")
for s,p,o in g.triples( (None, RDF.type, FOAF.Person) ):
   print "%s is a person"%s

for s,p,o in g.triples( (None,  RDF.type, None) ):
   print "%s is a %s"%(s,o)

bobgraph = Graph()

bobgraph += g.triples( (bob, None, None) )

If you are not interested in whole triples, you can get only the bits you want with the methods objects(), subjects(), predicates(), predicates_objects(), etc. Each take parameters for the components of the triple to constraint:

for person in g.subjects(RDF.type, FOAF.Person):
   print "%s is a person"%person

Finally, for some properties, only one value per resource makes sense (i.e they are functional properties, or have max-cardinality of 1). The value() method is useful for this, as it returns just a single node, not a generator:

name = g.value(bob, FOAF.name) # get any name of bob
# get the one person that knows bob and raise an exception if more are found
mbox = g.value(predicate = FOAF.name, object = bob, any = False)

Graph methods for accessing triples¶

Here is a list of all convenience methods for querying Graphs:

Logo

Table Of Contents

  • Navigating Graphs
    • Graphs as Iterators
    • Contains check
    • Set Operations on RDFLib Graphs
    • Basic Triple Matching
    • Graph methods for accessing triples

Previous topic

Creating RDF triples

Next topic

Querying with SPARQL

This Page

  • Show Source

Quick search

Enter search terms or a module, class or function name.

Navigation

  • index
  • modules |
  • next |
  • previous |
  • rdflib 4.2.0 documentation »
© Copyright 2009 - 2013, RDFLib Team. Created using Sphinx 1.3.6.
Theme based on Read The Docs