Some links:

• Advanced PyQGIS tutorial
• Full code to generate maps
• Tips on PyQGIS in standalone mode
• PyQGIS Developer Cookbook

Open layers

Open some shapes

# Main path
monCheminDeBase = r'C:\\Users\\Georges\\Downloads\\'
 
project = QgsProject.instance()
 
# Path of layers
peaks = QgsVectorLayer(monCheminDeBase + 'peaks_selection/peaks_selection.shp', 'Sommets', 'ogr')
glaciers = QgsVectorLayer(monCheminDeBase + 'glaciers/glaciers.shp', 'Glaciers', 'ogr')
eau = QgsVectorLayer(monCheminDeBase + 'eau/eau.shp', 'Fleuves', 'ogr')
troncons_routes = QgsVectorLayer(monCheminDeBase + 'troncons_routes/troncons_routes.shp', 'Grandes routes', 'ogr')
iris = QgsVectorLayer(monCheminDeBase + 'iris/iris.shp', 'IRIS', 'ogr')
 
# Open layers
project.addMapLayer(peaks)
project.addMapLayer(glaciers)
project.addMapLayer(eau)
project.addMapLayer(troncons_routes)
project.addMapLayer(iris)
 
iface.mapCanvas().refresh()

Open OSM

(Carefull to the &)

project = QgsProject.instance()
 
urlWithParams = "type=xyz&url=http://tile.openstreetmap.org/{z}/{x}/{y}.png"
osm = QgsRasterLayer(urlWithParams, "OpenStreetMap", "wms")
 
project.addMapLayer(osm)
osm.setOpacity(0.75)
 
iface.mapCanvas().refresh()

As we open OSM, which use a specific projection (3857), better to define and force the projection of the project, and the ellipsoid:

project = QgsProject.instance()
...
crs = QgsCoordinateReferenceSystem.fromEpsgId(4326)
project.setCrs(crs)
project.setEllipsoid('EPSG:4326')

Open a Geojson

monCheminDeBase = r'C:\\Users\\georg\\Downloads\\'
 
project = QgsProject.instance()
 
eau = QgsVectorLayer(monCheminDeBase + 'MyGeoJson.geojson', 'Rivières', 'ogr')
 
project.addMapLayer(eau)

Open a Geojson online

iface.addVectorLayer('https://d2ad6b4ur7yvpq.cloudfront.net/naturalearth-3.3.0/ne_50m_populated_places.geojson', 'Populated places', 'ogr')

Change a layer's encoding

myLayer = QgsVectorLayer(r'C:/Users/Georges/Downloads/my layer/new_file.tab', new_file, 'ogr')
myLayer.setProviderEncoding('ISO-8859-1')

Open a CSV

csv_path = 'file:///' + monCheminDeBase + 'World Stats.csv?delimiter=;'
my_csv = QgsVectorLayer(csv_path, 'Countries', 'delimitedtext')
project.addMapLayer(my_csv)

Analyze layers

Count layer fields

project = QgsProject.instance()
myLayer = project.mapLayersByName("My layer")[0]
print(myLayer.fields().count())

Count layer features

project = QgsProject.instance()
myLayer = project.mapLayersByName("Adresses")[0]
layerNumberFeatures = myLayer.featureCount()
print(layerNumberFeatures)

Display layer fields names

project = QgsProject.instance()
myLayer = project.mapLayersByName("My layer")[0]
print(myLayer.fields().names())

Get layer projection

project = QgsProject.instance()
myLayer = project.mapLayersByName("Adresses")[0]
layerProj = myLayer.crs()
print(layerProj)

Manage layers

Remove all the layers from the QGIS canvas

project = QgsProject.instance()
project.removeAllMapLayers()
project.clear()
iface.mapCanvas().refresh()

Clone a layer

oldLayer = project.mapLayersByName("Old layer")[0]
newLayer = oldLayer.clone()
newLayer.setName('New layer')
project.addMapLayer(newLayer)

Rename a layer

mes_sommets.setName('New name')

Copy-paste a layer with all his files (tab, shp ...) and open them

If you have a layer named test in a directory named my layer, you can create a copy named new file in the same directory and open them in QGIS:

import os
import shutil
 
QgsProject.instance().removeAllMapLayers()
iface.mapCanvas().refresh()
 
directory = r'C:/Users/Georges/Downloads/my layer'
new_file = 'new file'
 
# REMOVE NEW LAYER IF EXISTS
files = os.listdir(directory)
for f in files:
    if f.startswith(new_file):
        try:
            os.remove(directory + '/' + f)
        except:
            pass
 
# COPY LAYER
files = os.listdir(directory)
for f in files:
    if not f.startswith(new_file):
        shutil.copyfile(directory + '/' + f, directory + '/' + new_file + '.' + f.split('.')[1])
print('Layer copied!')
 
test = QgsVectorLayer(directory + '/test.tab', 'test', 'ogr')
QgsProject.instance().addMapLayer(test)
 
new = QgsVectorLayer(directory + '/' + new_file + '.tab', 'new file', 'ogr')
QgsProject.instance().addMapLayer(new)

Change a layer's encoding

myLayer = QgsVectorLayer(r'C:/Users/Georges/Downloads/my layer/new_file.tab', new_file, 'ogr')
myLayer.setProviderEncoding('ISO-8859-1')

Create a group and put a layer into

directory = r'C:/Users/Georges/Downloads/my layer'
newfile = QgsVectorLayer(directory + '/new file.tab', 'newfile', 'ogr')
QgsProject.instance().addMapLayer(newfile)
 
groupName = 'Mon joli groupe'
root = QgsProject.instance().layerTreeRoot()
group = root.addGroup(groupName)
 
layer = QgsProject.instance().mapLayersByName('newfile')[0]
 
mylayer = root.findLayer(layer.id())
myClone = mylayer.clone()
parent = mylayer.parent()
 
group = root.findGroup('Mon joli groupe')
group.insertChildNode(0, myClone)
 
parent.removeChildNode(mylayer)

Hide the rasters bands

root = QgsProject.instance().layerTreeRoot()
for layer in QgsProject.instance().mapLayers().values():
    if layer.type() == QgsMapLayerType.RasterLayer:
        LayerNode = root.findLayer(layer.id())
        LayerNode.setExpanded(False)

Uncheck a layer

project = QgsProject.instance()
myLayer = project.mapLayersByName('My layer')[0]
project.layerTreeRoot().findLayer(myLayer.id()).setItemVisibilityCheckedParentRecursive(False)

Transform a layer projection

project = QgsProject.instance()
 
myLayer = project.mapLayersByName("My layer")[0]
 
my_projection = QgsCoordinateReferenceSystem(4326)
myLayer.setCrs(my_projection)
my_transform = QgsCoordinateTransform(myLayer.crs(), iface.mapCanvas().mapSettings().destinationCrs(), project)
myLayerExtent = my_transform.transform(myLayer.extent())
 
iface.mapCanvas().setExtent(myLayerExtent)
iface.mapCanvas().refresh()

Manage the layers display order

firstLayer = project.mapLayersByName("First layer")[0]
secondLayer = project.mapLayersByName("Second layer")[0]
thirdLayer = project.mapLayersByName("Third layer")[0]
 
root = project.layerTreeRoot()
root.setHasCustomLayerOrder (True)
 
order = root.customLayerOrder()
order.insert(0, order.pop(order.index(firstLayer)))
order.insert(1, order.pop(order.index(secondLayer)))
order.insert(2, order.pop(order.index(thirdLayer)))
 
root.setCustomLayerOrder(order)

Zoom on a layer

countries = QgsVectorLayer(monCheminDeBase + 'simple_countries/simple_countries.shp', 'Countries', 'ogr')
extent_countries = countries.extent()
iface.mapCanvas().setExtent(extent_countries)
iface.mapCanvas().refresh()

Filter/Select

Select features

monCheminDeBase = r'C:\\Users\\georg\\Downloads\\'
 
project = QgsProject.instance()
project.removeAllMapLayers()
project.clear()
iface.mapCanvas().refresh()
 
myLayer = QgsVectorLayer(monCheminDeBase + 'peaks_selection/peaks_selection.shp', 'Sommets', 'ogr')
QgsProject.instance().addMapLayer(myLayer)
 
# SELECT
myExpr = u"NAME LIKE '{}'".format('Grand Pic de la Meije')
mySelect = myLayer.getFeatures(QgsFeatureRequest().setFilterExpression(myExpr))
 
myLayer.selectByIds([f.id() for f in mySelect])

Select function

def SelectAndZoom(layername, field, value):
    mylayer = QgsProject.instance().mapLayersByName(layername)[0]
    myselect = mylayer.getFeatures( QgsFeatureRequest().setFilterExpression ( u'"%s" = \'%s\'' % (field, value)) )
    mylayer.selectByIds( [ f.id() for f in myselect ] )
    iface.mapCanvas().zoomToSelected(mylayer)

Then use it like that:

SelectAndZoom('My layer', 'My field', 'Some value')

Select features after click on another layer

layer_selected = QgsProject.instance().mapLayersByName("decathlon_france")[0]
layer_to_select = QgsProject.instance().mapLayersByName("iso_iris")[0]
 
def SelectionAuto():
    selected_features = layer_selected.selectedFeatures()
    for i in selected_features:
        attrs = i.__geo_interface__
        id_mag = i['id']
        # print (id_mag)
 
        myselect = layer_to_select.getFeatures( QgsFeatureRequest().setFilterExpression ( u'"id_mag" = \'%s\'' % id_mag ) )
        layer_to_select.selectByIds( [ f.id() for f in myselect ] )
        # iface.mapCanvas().zoomToSelected(layer_to_select)
 
layer_selected.selectionChanged.connect(SelectionAuto)

Filter a layer

myFilter = u"field_a <> '{}'".format('A value')
myLayer.setSubsetString(myFilter)

Remove a filter

myLayer.setSubsetString('')

Edit layers

Add a point in a shape

(Attention to &)

monCheminDeBase = r'C:\\Users\\georg\\Downloads\\'
 
project = QgsProject.instance()
project.removeAllMapLayers()
project.clear()
iface.mapCanvas().refresh()
 
myLayer = QgsVectorLayer(monCheminDeBase + 'peaks_selection/peaks_selection.shp', 'Sommets', 'ogr')
project.addMapLayer(myLayer)
 
crs = QgsCoordinateReferenceSystem.fromEpsgId(4326)
project.setCrs(crs)
project.setEllipsoid('EPSG:4326')
 
# ADD A POINT
myPoints = project.mapLayersByName('Sommets')[0]
aPoint = QgsVectorLayer(myPoints.dataProvider().dataSourceUri(), '', 'ogr')
caps = aPoint.dataProvider().capabilities()
 
if caps & QgsVectorDataProvider.AddFeatures:
    feat = QgsFeature(aPoint.fields())
    feat.setAttributes([1, 'Université de Cergy-Pontoise'])
    feat.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(2.0616833, 49.0297879)))
    res, outFeats = aPoint.dataProvider().addFeatures([feat])

Add fields in a layer

myLayer = QgsVectorLayer(r'C:/Users/Georges/Downloads/my layer/new_file.tab', 'new file', 'ogr')
myLayerInstance = QgsProject.instance().mapLayersByName('new file')[0]
 
myLayerInstance.startEditing()
 
myLayerInstance.dataProvider().addAttributes(
[QgsField("newfield1", QVariant.String), QgsField("newfield2", QVariant.String)])
 
myLayerInstance.updateFields()
 
myLayerInstance.commitChanges()

Fill a field

myLayerInstance = QgsProject.instance().mapLayersByName('new file')[0]
 
with edit(myLayerInstance):
    for feature in myLayerInstance.getFeatures():
        # A VALUE
        feature['newfield1'] = 'Abc Xyz'
 
        # CONCATENATE OTHER FIELD
        feature['newfield2'] = feature['name'] + '-' + feature['id']
 
        myLayerInstance.updateFeature(feature)

Create a shape

layer = QgsProject.instance().mapLayersByName('peaks')[0]
layer.selectByExpression('"NAME" LIKE \'Aiguille%\'')
 
root = r'C:/Users/georg/Downloads/Aiguilles/'
if not os.path.exists(root):
    os.makedirs(root)
 
file = str(root)+'Aiguilles.shp'
writer = QgsVectorFileWriter.writeAsVectorFormat(layer, file, 'utf-8', driverName='ESRI Shapefile', onlySelected=True)

Temporary layers

Add a temporary layers

point_vector = QgsVectorLayer("Point", "my_points", "memory")
project.addMapLayer(point_vector)

Add fields

from qgis.PyQt.QtCore import QVariant
...
pr = point_vector.dataProvider()
pr.addAttributes([QgsField("id", QVariant.Int), QgsField("name", QVariant.String)])
point_vector.updateFields()

Add a point

f = QgsFeature()
f.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(7.7633340, 48.5785590)))
f.setAttributes([8, 'My 8'])
pr.addFeature(f)
point_vector.updateExtents()
project.addMapLayer(point_vector)
iface.mapCanvas().refresh()

Symbology

Simple symbology on points

my_layer = QgsProject.instance().mapLayersByName("My points")[0]
 
symbol_peak = QgsMarkerSymbol.createSimple({'name': 'Triangle', 'color': 'green', 'outline_color': 'black', 'size': '4'})
mylayer.renderer().setSymbol(symbol_peak)
mylayer.triggerRepaint()

Other point markers: 

circle square cross rectangle diamond pentagon triangle equilateral_triangle star regular_star arrow filled_arrowhead x

Simple symbology on lines

With HTML color.

myroads = QgsProject.instance().mapLayersByName("Roads")[0]
myrivers = QgsProject.instance().mapLayersByName("Rivers")[0]
 
# Roads
symbol = QgsLineSymbol.createSimple({'line_style': 'dash', 'line_width': '0.5', 'color': 'black'})
myroads.renderer().setSymbol(symbol)
myroads.triggerRepaint()
 
# Rivers
symbol = QgsLineSymbol.createSimple({'line_style': 'solid', 'line_width': '0.75', 'color': '#0088CC'})
myrivers.renderer().setSymbol(symbol)
myrivers.triggerRepaint()

Simple symbology on polygons

With RGB color (50,165,77,75), and some transparency (here 75, from 0 to 255), et on rafraîchit le panneau des couches afin que notre légende y soit aussi prise en compte:

myground = QgsProject.instance().mapLayersByName("Ground")[0]
 
symbol = QgsFillSymbol.createSimple({'line_style': 'solid', 'line_width': '0.2', 'color': '50,165,77,75'})
myground.renderer().setSymbol(symbol)
 
myground.triggerRepaint()
iface.layerTreeView().refreshLayerSymbology(myground.id())
iface.mapCanvas().refresh()

Check current symbology properties

my_layer = QgsProject.instance().mapLayersByName("My points")[0]
print(my_layer.renderer().symbol().symbolLayers()[0].properties())

Categorized Symbology

For a categorized symbology, we will need to define several symbologies, then assign them based on attribute values.

Here we put all our peaks in blue triangle (▲, then we will look for a single peak based on its name (My best peak, in the NAME field). This will change to a dark blue triangle and larger size (▲).

symbol_peak = QgsMarkerSymbol.createSimple({'name': 'Triangle', 'color': '#0088CC', 'outline_color': 'black', 'size': '4'})
symbol_peak_selected = QgsMarkerSymbol.createSimple({'name': 'Triangle', 'color': 'blue', 'outline_color': 'black', 'size': '7'})
 
color_peak = QgsRendererCategory(None, symbol_peak, 'Peaks', True)
color_peak_selected = QgsRendererCategory('My best peak', symbol_peak_selected, 'My best peak', True)
 
renderer = QgsCategorizedSymbolRenderer("NAME", [color_peak,color_peak_selected])
 
mylayer.setRenderer(renderer)
mylayer.triggerRepaint()
iface.mapCanvas().refresh()

Transparency on a basemap (OSM)

osm = QgsRasterLayer(urlWithParams, "OpenStreetMap", "wms")
project.addMapLayer(osm)
osm.setOpacity(0.75)
 
iface.mapCanvas().refresh()

Labeling

Usual labels

project = QgsProject.instance()
 
myLayers = QgsVectorLayer(monCheminDeBase + 'myLayers/myLayers.shp', 'myLayers', 'ogr')
 
project.addMapLayer(myLayers)
 
myLayerLabelSettings = QgsPalLayerSettings()
myLayerLabelSettings.fieldName = 'name'
myLayerLabelSettings.enabled = True
 
myLayerText = QgsTextFormat()
myLayerText.setFont(QFont('Verdana', 8))
myLayerText.setSize(8)
 
myLayerLabelSettings.setFormat(myLayerText)
 
myLayerSettings = QgsVectorLayerSimpleLabeling(myLayerLabelSettings)
myLayers.setLabeling(myLayerSettings)
myLayers.setLabelsEnabled(True)
 
myLayers.triggerRepaint()
iface.mapCanvas().refresh()
time.sleep(0.5)

Intersection

import os
import shutil
 
monCheminDeBase = r'C:\\Users\\georg\\Downloads\\'
 
project = QgsProject.instance()
project.removeAllMapLayers()
project.clear()
iface.mapCanvas().refresh()
 
peaks = QgsVectorLayer(monCheminDeBase + 'peaks_selection/peaks_selection.shp', 'Sommets', 'ogr')
iris = QgsVectorLayer(monCheminDeBase + 'iris/iris.shp', 'IRIS', 'ogr')
 
QgsProject.instance().addMapLayer(peaks)
QgsProject.instance().addMapLayer(iris)
 
# Directory for created layer
_peaks_iris = monCheminDeBase + '_peaks_iris'
if os.path.isdir(_peaks_iris) == True:
    shutil.rmtree(_peaks_iris)
if os.path.isdir(_peaks_iris) == False:
    os.mkdir(_peaks_iris)
 
# Intersect peaks and IRIS
peaks_iris_path = _peaks_iris + r'\\peaks_iris.shp'
 
processing.run('qgis:intersection', { \
"INPUT": peaks, \
"OVERLAY": iris, \
"INPUT_FIELDS": ["OSM_ID", "NAME", "OTHER_TAGS"], \
"OVERLAY_FIELDS": ["CODE_IRIS", "NOM_COM"], \
"OVERLAY_FIELDS_PREFIX": "", \
"OUTPUT": peaks_iris_path})
 
# Remove layers
project.removeMapLayer(peaks)
project.removeMapLayer(iris)
 
# Open the new intersected layer
peaks_iris = QgsVectorLayer(peaks_iris_path, "Sommets", "ogr")
project.addMapLayer(peaks_iris)
 
# Register layer
mes_sommets = project.mapLayersByName("Sommets")[0]

Other params here!

Buffer

import os
import shutil
 
monCheminDeBase = r'C:\\Users\\georg\\Downloads\\'
 
project = QgsProject.instance()
project.removeAllMapLayers()
project.clear()
iface.mapCanvas().refresh()
 
crs = QgsCoordinateReferenceSystem.fromEpsgId(4326)
project.setCrs(crs)
project.setEllipsoid('EPSG:4326')
 
peaks = QgsVectorLayer(monCheminDeBase + 'peaks_selection/peaks_selection.shp', 'Sommets', 'ogr')
QgsProject.instance().addMapLayer(peaks)
 
# Directory for created layer
_peaks_buffer = monCheminDeBase + '_peaks_buffer'
if os.path.isdir(_peaks_buffer) == True:
    shutil.rmtree(_peaks_buffer)
if os.path.isdir(_peaks_buffer) == False:
    os.mkdir(_peaks_buffer)
 
# Buffer on peaks
peaks_buffer_path = _peaks_buffer + r'\\peaks_buffer.shp'
 
processing.run('native:buffer', { \
"INPUT": peaks, \
"DISTANCE": 5, \
"SEGMENTS": 10, \
"END_CAP_STYLE": 0, \
"DISSOLVE": False, \
"OUTPUT": peaks_buffer_path})
 
# Open the buffer layer
peaks_buffer = QgsVectorLayer(peaks_buffer_path, "Buffer area", "ogr")
project.addMapLayer(peaks_buffer)
 
# Register layer
my_buffer = project.mapLayersByName("Buffer area")[0]
 
# Buffer below
root = project.layerTreeRoot()
myBelowLayer = root.findLayer(peaks_buffer.id())
myClone = myBelowLayer.clone()
parent = myBelowLayer.parent()
parent.insertChildNode(-1, myClone)
parent.removeChildNode(myBelowLayer)

import os
import shutil
 
monCheminDeBase = r'C:\\Users\\georg\\Downloads\\'
 
project = QgsProject.instance()
project.removeAllMapLayers()
project.clear()
iface.mapCanvas().refresh()
 
crs = QgsCoordinateReferenceSystem.fromEpsgId(2154)
project.setCrs(crs)
project.setEllipsoid('EPSG:2154')
 
address = QgsVectorLayer(monCheminDeBase + 'adresses/ADRESSE_05.shp', 'Adresses', 'ogr')
 
QgsProject.instance().addMapLayer(address)
 
# Directory for created layer
_address_buffer = monCheminDeBase + '_address_buffer'
if os.path.isdir(_address_buffer) == True:
    shutil.rmtree(_address_buffer)
if os.path.isdir(_address_buffer) == False:
    os.mkdir(_address_buffer)
 
# Buffer on address
address_buffer_path = _address_buffer + r'\\address_buffer.shp'
 
processing.run('native:buffer', { \
"INPUT": address, \
"DISTANCE": 2000, \
"SEGMENTS": 10, \
"END_CAP_STYLE": 0, \
"DISSOLVE": False, \
"OUTPUT": address_buffer_path})
 
# Open the buffer layer
address_buffer = QgsVectorLayer(address_buffer_path, "Buffer area", "ogr")
project.addMapLayer(address_buffer)
 
# Register layer
my_buffer = project.mapLayersByName("Buffer area")[0]
 
# Buffer below
root = project.layerTreeRoot()
myBelowLayer = root.findLayer(address_buffer.id())
myClone = myBelowLayer.clone()
parent = myBelowLayer.parent()
parent.insertChildNode(-1, myClone)
parent.removeChildNode(myBelowLayer)

Miscellaneous about processing

Fix invalid geometry (and register the output to use it later)

Here we register the output with the name MyFixedLayer. So we can use it later.

alg_params = {
    'INPUT':'E:\\Downloads\\MyLayer.shp',
    'METHOD':1,
    'OUTPUT':'E:\\Downloads\\MyFixedLayer.shp'
}
outputs['MyFixedLayer'] = processing.run('native:fixgeometries', alg_params, context=context)

Fix invalid geometry (from a previous output registered)

alg_params = {
'INPUT': outputs['MyPreviousOutput']['OUTPUT'],
'METHOD':1,
'OUTPUT': QgsProcessing.TEMPORARY_OUTPUT
}
outputs['MyNewOutput'] = processing.run('native:fixgeometries', alg_params, context=context)

Joins

Join a CSV

import os
import shutil
 
monCheminDeBase = r'C:\\Users\\georg\\Downloads\\'
 
project = QgsProject.instance()
project.removeAllMapLayers()
project.clear()
iface.mapCanvas().refresh()
 
crs = QgsCoordinateReferenceSystem.fromEpsgId(4326)
project.setCrs(crs)
project.setEllipsoid('EPSG:4326')
 
countries = QgsVectorLayer(monCheminDeBase + 'simple_countries/simple_countries.shp', 'Countries', 'ogr')
 
project.addMapLayer(countries)
myCountries = project.mapLayersByName('Countries')[0]
 
extent_countries = countries.extent()
iface.mapCanvas().setExtent(extent_countries)
iface.mapCanvas().refresh()
 
# IMPORT CSV
csv_path = 'file:///' + monCheminDeBase + 'World Stats.csv?delimiter=;'
my_csv = QgsVectorLayer(csv_path, 'Countries', 'delimitedtext')
project.addMapLayer(my_csv)
 
# JOIN 
shpField='COUNTRY_HB'
csvField='Country'
 
myJoin = QgsVectorLayerJoinInfo()
myJoin.setJoinFieldName(csvField)
myJoin.setTargetFieldName(shpField)
myJoin.setJoinLayerId(my_csv.id())
myJoin.setUsingMemoryCache(True)
myJoin.setJoinLayer(my_csv)
myJoin.setJoinFieldNamesSubset(['Population (2024)'])
myJoin.setPrefix('')
 
countries.addJoin(myJoin)
countries.dataProvider().forceReload()

Classifications

You can use any of these classification method classes:

• QgsClassificationQuantile()
• QgsClassificationEqualInterval()
• QgsClassificationJenks()
• QgsClassificationPrettyBreaks()
• QgsClassificationLogarithmic()
• QgsClassificationStandardDeviation()

Available ramps

default_style = QgsStyle().defaultStyle()
available_ramps = default_style.colorRampNames()
for ramp in available_ramps:
    print(ramp)

Equal intervals

# Set layer name and desired params
ramp_name = 'Spectral'
value_field = 'Population (2024)'
num_classes = 10
classification_method = QgsClassificationEqualInterval()
 
layer = QgsProject().instance().mapLayersByName('Countries')[0]
 
format = QgsRendererRangeLabelFormat()
format.setTrimTrailingZeroes(True)
 
default_style = QgsStyle().defaultStyle()
 
color_ramp = default_style.colorRamp(ramp_name)
 
renderer = QgsGraduatedSymbolRenderer()
renderer.setClassAttribute(value_field)
renderer.setClassificationMethod(classification_method)
renderer.setLabelFormat(format)
renderer.updateClasses(layer, num_classes)
 
renderer.updateColorRamp(color_ramp)
 
layer.setRenderer(renderer)
layer.triggerRepaint()

Jenks

# Set layer name and desired params
ramp_name = 'PuRd'
value_field = 'Population (2024)'
num_classes = 20
classification_method = QgsClassificationJenks()
 
layer = QgsProject().instance().mapLayersByName('Countries')[0]
 
format = QgsRendererRangeLabelFormat()
format.setTrimTrailingZeroes(True)
 
default_style = QgsStyle().defaultStyle()
 
color_ramp = default_style.colorRamp(ramp_name)
 
renderer = QgsGraduatedSymbolRenderer()
renderer.setClassAttribute(value_field)
renderer.setClassificationMethod(classification_method)
renderer.setLabelFormat(format)
renderer.updateClasses(layer, num_classes)
 
renderer.updateColorRamp(color_ramp)
 
layer.setRenderer(renderer)
layer.triggerRepaint()

Round zeroes

format = QgsRendererRangeLabelFormat()
format.setTrimTrailingZeroes(True)

Decimals

format = QgsRendererRangeLabelFormat()
format.setPrecision(2)

Separator

format = QgsRendererRangeLabelFormat()
format.setFormat("%1 - %2")

Invert colors

color_ramp = default_style.colorRamp(ramp_name)
 
# Manually invert the color ramp
if isinstance(color_ramp, QgsGradientColorRamp):
    inverted_ramp = QgsGradientColorRamp(
        color_ramp.color2(), # Use the second color as the start color
        color_ramp.color1() # Use the first color as the end color
    )
else:
    inverted_ramp = color_ramp
...
renderer.updateColorRamp(inverted_ramp)

Install a third-party Python module in QGIS

You will have to go through the OSGeo4W shell.

We will use Pip, but Pip is already in the Python of QGIS.

Follow this tutorial to install a module on the version of Python used by your QGIS on Windows, or more simply just below.

In the OSGeo shell (and not in the usual Windows shell), with some old QGIS version, maybe start to target the environment:

py3_env

On more recent versions (QGIS 3.34 for example), just enter:

python -m pip install wikipedia

If you have some users rights restrictions:

python -m pip install wikipedia --user

You may need to restart QGIS to take your new library into account (no need with the Wikipedia lib, but it depends of the library).

Maybe you will need to register Pip or Python in your Path System Variable, just follow the instructions from the OSGeo shell.

Other libraries examples

pip install requests-html

py -m pip install requests-html

pip install wikidata

pip install requests

PIP on Windows

But maybe you would install Pip on Windows. Pip is a Python extensions installer, check this:

• Pip installation tutorial on Windows

Miscellaneous

Get executed QGIS Python code

In the QGIS menu: Processing/History.

In a plugin (from QGIS 3.28): Advanced/Copy as Python Command

Set projection and ellipsoid

project = QgsProject.instance()
...
crs = QgsCoordinateReferenceSystem.fromEpsgId(4326)
project.setCrs(crs)
project.setEllipsoid('EPSG:4326')

See the available process and scripts

for alg in QgsApplication.processingRegistry().algorithms():
    print("{}:{} --> {}".format(alg.provider().name(), alg.name(), alg.displayName()))

Using QGIS Buttons in Python Code

eMenu = iface.viewMenu()
eMenu.actions()[12].trigger()