Viktigt

Översättning är en gemenskapsinsats du kan gå med i. Den här sidan är för närvarande översatt till 100.00%.

11. Uttryck, filtrering och beräkning av värden

Råd

Kodsnuttarna på den här sidan behöver följande import om du befinner dig utanför pyqgis-konsolen:

from qgis.core import (
    edit,
    QgsExpression,
    QgsExpressionContext,
    QgsFeature,
    QgsFeatureRequest,
    QgsField,
    QgsFields,
    QgsVectorLayer,
    QgsPointXY,
    QgsGeometry,
    QgsProject,
    QgsExpressionContextUtils
)

QGIS har visst stöd för parsning av SQL-liknande uttryck. Endast en liten delmängd av SQL-syntaxen stöds. Uttrycken kan utvärderas antingen som booleska predikat (returnerar True eller False) eller som funktioner (returnerar ett skalärt värde). Se Uttryck i användarhandboken för en fullständig lista över tillgängliga funktioner.

Tre grundläggande typer stöds:

• tal — både heltal och decimaltal, t.ex. 123, 3,14

• sträng — måste de omslutas av enkla citattecken: 'hej världen'

• kolumnreferens — vid utvärdering ersätts referensen med fältets faktiska värde. Namnen är inte escapade.

Följande funktioner är tillgängliga:

• aritmetiska operatorer: +, -, *, /, ^

• parenteser: för att förstärka operatörens företräde: (1 + 1) * 3

• unär plus och minus: -12, +5

• matematiska funktioner: qrt, sin, cos, tan, asin, acos, atan

• omvandlingsfunktioner: to_int, to_real, to_string, to_date

• geometrifunktioner: $area, $längd

• funktioner för geometrihantering: $x, $y, $geometri, num_geometrier, centroid

Och följande predikat stöds:

• jämförelse: =, !=, >, >=, <, <=

• mönstermatchning: LIKE (använder % and _), ~ (reguljära uttryck)

• logiska predikat: OCH, ELLER, INTE

• Kontroll av NULL-värde: IS NULL, IS NOT NULL

Exempel på predikat:

• 1 + 2 = 3

• sin(vinkel) > 0

• 'Hello' LIKE 'He%'

• (x > 10 OCH y > 10) ELLER z = 0

Exempel på skalära uttryck:

• 2 ^ 10

• sqrt(val)

• $längd + 1

11.1. Parsning av uttryck

I följande exempel visas hur man kontrollerar om ett visst uttryck kan analyseras korrekt:

exp = QgsExpression('1 + 1 = 2')
assert(not exp.hasParserError())

exp = QgsExpression('1 + 1 = ')
assert(exp.hasParserError())

assert(exp.parserErrorString() == '\nsyntax error, unexpected end of file')

11.2. Utvärdering av uttryck

Uttryck kan användas i olika sammanhang, t.ex. för att filtrera funktioner eller för att beräkna nya fältvärden. I vilket fall som helst måste uttrycket utvärderas. Det innebär att dess värde beräknas genom att utföra de angivna beräkningsstegen, som kan variera från enkel aritmetik till aggregerade uttryck.

11.2.1. Grundläggande uttryck

Detta grundläggande uttryck utvärderar en enkel aritmetisk operation:

exp = QgsExpression('2 * 3')
print(exp)
print(exp.evaluate())

<QgsExpression: '2 * 3'>
6

Uttrycket kan också användas för jämförelse och utvärderas till 1 (True) eller 0 (False)

exp = QgsExpression('1 + 1 = 2')
exp.evaluate()
# 1

11.2.2. Uttryck med funktioner

För att utvärdera ett uttryck mot en funktion måste ett QgsExpressionContext-objekt skapas och skickas till evaluate-funktionen för att uttrycket ska få tillgång till funktionens fältvärden.

I följande exempel visas hur man skapar en funktion med ett fält som heter ”Column” och hur man lägger till denna funktion i uttryckskontexten.

fields = QgsFields()
field = QgsField('Column')
fields.append(field)
feature = QgsFeature()
feature.setFields(fields)
feature.setAttribute(0, 99)

exp = QgsExpression('"Column"')
context = QgsExpressionContext()
context.setFeature(feature)
exp.evaluate(context)
# 99

Följande är ett mer komplett exempel på hur man använder uttryck i samband med ett vektorlager för att beräkna nya fältvärden:

from qgis.PyQt.QtCore import QMetaType

# create a vector layer
vl = QgsVectorLayer("Point", "Companies", "memory")
pr = vl.dataProvider()
pr.addAttributes([QgsField("Name", QMetaType.Type.QString),
                  QgsField("Employees",  QMetaType.Type.Int),
                  QgsField("Revenue", QMetaType.Type.Double),
                  QgsField("Rev. per employee", QMetaType.Type.Double),
                  QgsField("Sum", QMetaType.Type.Double),
                  QgsField("Fun", QMetaType.Type.Double)])
vl.updateFields()

# add data to the first three fields
my_data = [
    {'x': 0, 'y': 0, 'name': 'ABC', 'emp': 10, 'rev': 100.1},
    {'x': 1, 'y': 1, 'name': 'DEF', 'emp': 2, 'rev': 50.5},
    {'x': 5, 'y': 5, 'name': 'GHI', 'emp': 100, 'rev': 725.9}]

for rec in my_data:
    f = QgsFeature()
    pt = QgsPointXY(rec['x'], rec['y'])
    f.setGeometry(QgsGeometry.fromPointXY(pt))
    f.setAttributes([rec['name'], rec['emp'], rec['rev']])
    pr.addFeature(f)

vl.updateExtents()
QgsProject.instance().addMapLayer(vl)

# The first expression computes the revenue per employee.
# The second one computes the sum of all revenue values in the layer.
# The final third expression doesn’t really make sense but illustrates
# the fact that we can use a wide range of expression functions, such
# as area and buffer in our expressions:
expression1 = QgsExpression('"Revenue"/"Employees"')
expression2 = QgsExpression('sum("Revenue")')
expression3 = QgsExpression('area(buffer($geometry,"Employees"))')

# QgsExpressionContextUtils.globalProjectLayerScopes() is a convenience
# function that adds the global, project, and layer scopes all at once.
# Alternatively, those scopes can also be added manually. In any case,
# it is important to always go from “most generic” to “most specific”
# scope, i.e. from global to project to layer
context = QgsExpressionContext()
context.appendScopes(QgsExpressionContextUtils.globalProjectLayerScopes(vl))

with edit(vl):
    for f in vl.getFeatures():
        context.setFeature(f)
        f['Rev. per employee'] = expression1.evaluate(context)
        f['Sum'] = expression2.evaluate(context)
        f['Fun'] = expression3.evaluate(context)
        vl.updateFeature(f)

print(f['Sum'])

876.5

11.2.3. Filtrera ett lager med uttryck

Följande exempel kan användas för att filtrera ett lager och returnera alla funktioner som matchar ett predikat.

layer = QgsVectorLayer("Point?field=Test:integer",
                           "addfeat", "memory")

layer.startEditing()

for i in range(10):
    feature = QgsFeature()
    feature.setAttributes([i])
    assert(layer.addFeature(feature))
layer.commitChanges()

expression = 'Test >= 3'
request = QgsFeatureRequest().setFilterExpression(expression)

matches = 0
for f in layer.getFeatures(request):
   matches += 1

print(matches)

7

11.3. Hantering av uttrycksfel

Uttrycksrelaterade fel kan uppstå under parsning eller utvärdering av uttryck:

exp = QgsExpression("1 + 1 = 2")
if exp.hasParserError():
   raise Exception(exp.parserErrorString())

value = exp.evaluate()
if exp.hasEvalError():
   raise ValueError(exp.evalErrorString())