# Namespaces and Bindings

RDFLib provides several short-cuts to working with many URIs in the same namespace.

The `rdflib.namespace` defines the `rdflib.namespace.Namespace` class which lets you easily create URIs in a namespace:

        from rdflib import Namespace

        EX = Namespace("http://example.org/")
        EX.Person  # a Python attribute for EX. This example is equivalent to rdflib.term.URIRef("http://example.org/Person")

    # use dict notation for things that are not valid Python identifiers, e.g.:
        n['first%20name']  # as rdflib.term.URIRef("http://example.org/first%20name")

These two styles of namespace creation - object attribute and dict - are equivalent and are made available just to allow for valid RDF namespaces and URIs that are not valid Python identifiers. This isn’t just for syntactic things like spaces, as per the example of `first%20name` above, but also for Python reserved words like `class` or `while`, so for the URI `http://example.org/class`, create it with `EX['class']`, not `EX.class`.

## Common Namespaces

The `namespace` module defines many common namespaces such as RDF, RDFS, OWL, FOAF, SKOS, PROF, etc. The list of the namespaces provided grows with user contributions to RDFLib.

These Namespaces, and any others that users define, can also be associated with prefixes using the `rdflib.namespace.NamespaceManager`, e.g. using `foaf` for `http://xmlns.com/foaf/0.1/`.

Each RDFLib graph has a `namespace_manager` that keeps a list of namespace to prefix mappings. The namespace manager is populated when reading in RDF, and these prefixes are used when serialising RDF, or when parsing SPARQL queries. Prefixes can be bound with the `rdflib.graph.Graph.bind()` method:

    from rdflib import Graph, Namespace
    from rdflib.namespace import FOAF

    EX = Namespace("http://example.org/")

    g = Graph()
    g.bind("foaf", FOAF)  # bind an RDFLib-provided namespace to a prefix
    g.bind("ex", EX)      # bind a user-declared namespace to a prefix

The `rdflib.graph.Graph.bind()` method is actually supplied by the `rdflib.namespace.NamespaceManager` class - see next.

## NamespaceManager

Each RDFLib graph comes with a `rdflib.namespace.NamespaceManager` instance in the `namespace_manager` field; you can use the `bind()` method of this instance to bind a prefix to a namespace URI, as above, however note that the `NamespaceManager` automatically performs some bindings according to a selected strategy.

Namespace binding strategies are indicated with the `bind_namespaces` input parameter to `NamespaceManager` instances and may be set via `Graph` also:

    from rdflib import Graph
    from rdflib.namespace import NamespaceManager

    g = Graph(bind_namespaces="rdflib")  # bind via Graph

    g2 = Graph()
    nm = NamespaceManager(g2, bind_namespaces="rdflib")  # bind via NamespaceManager

Valid strategies are:

- core:

    - binds several core RDF prefixes only

    - owl, rdf, rdfs, xsd, xml from the NAMESPACE_PREFIXES_CORE object

    - this is default

- rdflib:

    - binds all the namespaces shipped with RDFLib as DefinedNamespace instances

    - all the core namespaces and all the following: brick, csvw, dc, dcat

    - dcmitype, dcterms, dcam, doap, foaf, geo, odrl, org, prof, prov, qb, sdo

    - sh, skos, sosa, ssn, time, vann, void

    - see the NAMESPACE_PREFIXES_RDFLIB object in `rdflib.namespace` for up-to-date list

- none:

    - binds no namespaces to prefixes

    - note this is NOT default behaviour

- cc:

    - using prefix bindings from prefix.cc which is a online prefixes database

    - not implemented yet - this is aspirational

### Re-binding

Note that regardless of the strategy employed, prefixes for namespaces can be overwritten with users preferred prefixes, for example:

    from rdflib import Graph
    from rdflib.namespace import GEO  # imports GeoSPARQL's namespace

    g = Graph(bind_namespaces="rdflib")  # binds GeoSPARQL's namespace to prefix 'geo'

    g.bind('geosp', GEO, override=True)

`NamespaceManager` also has a method to normalize a given url:

    from rdflib.namespace import NamespaceManager

    nm = NamespaceManager(Graph())
    nm.normalizeUri(t)

For simple output, or simple serialisation, you often want a nice readable representation of a term. All RDFLib terms have a `.n3()` method, which will return a suitable N3 format and into which you can supply a NamespaceManager instance to provide prefixes, i.e. `.n3(namespace_manager=some_nm)`:

    >>> from rdflib import Graph, URIRef, Literal, BNode
    >>> from rdflib.namespace import FOAF, NamespaceManager

    >>> person = URIRef("http://xmlns.com/foaf/0.1/Person")
    >>> person.n3()
    '<http://xmlns.com/foaf/0.1/Person>'

    >>> g = Graph()
    >>> g.bind("foaf", FOAF)

    >>> person.n3(g.namespace_manager)
    'foaf:Person'

    >>> l = Literal(2)
    >>> l.n3()
    '"2"^^<http://www.w3.org/2001/XMLSchema#integer>'

    >>> l.n3(NamespaceManager(Graph(), bind_namespaces="core"))
    '"2"^^xsd:integer'

The namespace manage also has a useful method `compute_qname` `g.namespace_manager.compute_qname(x)` (or just `g.compute_qname(x)`) which takes a URI and decomposes it into the parts:

    self.assertEqual(g.compute_qname(URIRef("http://foo/bar#baz")),
                    ("ns2", URIRef("http://foo/bar#"), "baz"))

## Namespaces in SPARQL Queries

The `initNs` argument supplied to `query()` is a dictionary of namespaces to be expanded in the query string. If you pass no `initNs` argument, the namespaces registered with the graphs namespace_manager are used:

    from rdflib.namespace import FOAF
    graph.query('SELECT * WHERE { ?p a foaf:Person }', initNs={'foaf': FOAF})

In order to use an empty prefix (e.g. `?a :knows ?b`), use a `PREFIX` directive with no prefix in the SPARQL query to set a default namespace:

    PREFIX : <http://xmlns.com/foaf/0.1/>