DEV Community: Dr. Azad Rasul

26- A Guide to Creating QGIS Plugins in a Step-by-Step Manner

Dr. Azad Rasul — Mon, 27 Mar 2023 23:01:37 +0000

If you're looking to create QGIS plugins, then you've come to the right place! In this step-by-step guide, we'll show you how to create your own plugin by creating essential files such as metadata.txt and mainPlugin.py, as well as how to use Python to create the init.py file. We'll also walk you through how to install your plugin and provide a tip on using the Plugin Builder to create a template for your plugin. Follow these instructions to create your own QGIS plugin and take your GIS analysis to the next level!

The first requirement for plugins is metadata.txt.

Use a text editor to create a metadata file:

[general]
name=TestPlugin
email=azad.rasul@soran.edu.iq
author=Azad Rasul
qgisMinimumVersion=3.0
description=This is an example plugin for greeting the world.
version=version 0.1

Save it as a "metadata" text document.

The second file is called "__init__.py" which includes the classFactory() method.

You can use Python to create a "__init__.py" file

from .mainPlugin import TestPlugin
def classFactory(iface):
  return TestPlugin(iface)

The third necessary file contains the main logic of the plugin. It must have initGui(), unload() and run() methods. We name it "mainPlugin.py" file that includes:

import os
import inspect
from PyQt5.QtWidgets import QAction
from PyQt5.QtGui import QIcon

# get the directory containing this script
cmd_folder = os.path.split(inspect.getfile(inspect.currentframe()))[0]

# define the TestPlugin class
class TestPlugin:

  def __init__(self, iface):
    self.iface = iface

  # initialize the plugin interface
  def initGui(self):
    # get the path to the plugin icon
    icon = os.path.join(os.path.join(cmd_folder, 'logo.png'))

    # create a new QAction with the plugin icon and label
    self.action = QAction(QIcon(icon), 'TestPlugin', self.iface.mainWindow())

    # connect the action to the run() method
    self.action.triggered.connect(self.run)

    # add the action to the toolbar and menu
    self.iface.addToolBarIcon(self.action)
    self.iface.addPluginToMenu("&TestPlugin", self.action)

  # unload the plugin
  def unload(self):
    # remove the action from the toolbar and menu
    self.iface.removePluginMenu("&TestPlugin", self.action)
    self.iface.removeToolBarIcon(self.action)

    # delete the action object
    del self.action

  # run the plugin
  def run(self):
    # display a message in the QGIS message bar
    self.iface.messageBar().pushMessage('Hello from TestPlugin!')

Save these three files and a logo in one folder and name it "TestPlugin" or the name of the plugin.

Then, copy the "TestPlugin" folder and paste it into QGIS 3 Plugins directory. On Windows, it is typically located at:

C:\Users\username\AppData\Roaming\QGIS\QGIS3\profiles\default\python\plugins

Restart QGIS software, and you will be able to see your "TestPlugin" plugin in the list of installed plugins. By clicking on the TestPlugin icon, you can view the "Hello from TestPlugin!" text.

Alternatively, you can use the "Plugin Builder" to create a template plugin and then modify it to suit your needs.

In conclusion, creating QGIS plugins may seem daunting, but this step-by-step guide can help anyone create their customized plugin. By following the instructions provided, users can create necessary files such as metadata.txt and mainPlugin.py, and use Python to create the init.py file. The article also provides a tip on using the Plugin Builder to create a template for the plugin. With the plugin created and installed, users can take their GIS analysis to the next level.

The credit for my tutorials goes to Anita Graser and Ujaval Gandhi.

External resources:

1- PyQGIS Developer Cookbook

2- PyQGIS 101: Introduction to QGIS Python programming for non-programmers

3- Customizing QGIS with Python (Full Course Material)

4- PyQGIS samples

25- Personalize QGIS Icon using PyQGIS

Dr. Azad Rasul — Mon, 27 Mar 2023 22:15:26 +0000

Learn how to customize the QGIS icon using PyQGIS with this step-by-step guide. Follow along as we show you how to download the icon image, import the necessary module, specify the icon name and directory, and create an instance of the QIcon class. You'll also learn how to set the QGIS window icon to the QIcon instance using Python. Whether you're a GIS professional or a Python developer, this tutorial will help you add a personal touch to your QGIS application.

Download the QGIS icon image.

Import the os module:

import os

Specify the icon name, directory, and file path:

icon = 'qgis_orange.png'
data_dir = os.path.join(os.path.expanduser('~'), 'D://', 'Python_QGIS')
icon_path = os.path.join(data_dir, icon)

Create an instance of the QIcon class:

icon = QIcon(icon_path)

Set the QGIS window icon to the QIcon instance:

iface.mainWindow().setWindowIcon(icon)

Here's the overall code:

# import os module
import os

# specify the name of the icon
icon = 'qgis_orange.png'

# specify the data directory where the icon file is stored
data_dir = os.path.join(os.path.expanduser('~'), 'D://', 'Python_QGIS')

# create the path to the icon file
icon_path = os.path.join(data_dir, icon)

# create an instance of the QIcon class using the icon path
icon = QIcon(icon_path)

# set the QGIS window icon to the QIcon instance
iface.mainWindow().setWindowIcon(icon)

In conclusion, customizing the QGIS icon using PyQGIS is a straightforward process that can help add a personal touch to your QGIS application. By following the step-by-step guide provided in this article, you can download the icon image, import the necessary module, specify the icon name and directory, and create an instance of the QIcon class. You'll also learn how to set the QGIS window icon to the QIcon instance using Python. Whether you're a GIS professional or a Python developer, this tutorial can be a valuable resource to help you customize your QGIS icon.

24- Improve Your QGIS Toolbar with a Button Showing the Current Time

Dr. Azad Rasul — Mon, 27 Mar 2023 21:54:17 +0000

Learn how to enhance your PyQGIS toolbar with a time button by following this step-by-step guide. With the help of necessary modules and code, you can create a QGIS toolbar icon that displays the current time when clicked. Download the time icon and define the path to the icon to get started with this tutorial. Follow along with the instructions to create your own time button and upgrade your PyQGIS toolbar.

First, download the time icon image.

Then, import the necessary modules:

import os
import pytz
from datetime import datetime

Next, define the path to the icon:

icon = 'time.png'
data_dir = os.path.join(os.path.expanduser('~'), 'D://', 'Python_QGIS')
icon_path = os.path.join(data_dir, icon)

Next, define Baghdad local time by creating the "WhatTime" function:

def WhatTime():
    tz_Ba = pytz.timezone('Asia/Baghdad') 
    now = datetime.now(tz_Ba)
    current_time = now.strftime("%H:%M:%S")
    iface.messageBar().pushInfo('Baghdad Time', current_time)

Finally, create a QGIS toolbar icon that displays the current time when clicked:

action = QAction('What time is it?')
action.triggered.connect(WhatTime)
action.setIcon(QIcon(icon_path))
iface.addToolBarIcon(action)

Here's the overall code:

# Import the necessary modules:
import os
import pytz
from datetime import datetime

Define the path to the icon:
icon = 'time.png'
data_dir = os.path.join(os.path.expanduser('~'), 'D://', 'Python_QGIS')
icon_path = os.path.join(data_dir, icon)

# Define Baghdad local time
def WhatTime():
    tz_Ba = pytz.timezone('Asia/Baghdad') 
    now = datetime.now(tz_Ba)
    current_time = now.strftime("%H:%M:%S")
    iface.messageBar().pushInfo('Baghdad Time', current_time)

# Create a QGIS toolbar icon that displays the current time when clicked:    
action = QAction('What time is it?')
action.triggered.connect(WhatTime)
action.setIcon(QIcon(icon_path))
iface.addToolBarIcon(action)

In conclusion, this step-by-step guide provides a clear and concise tutorial on how to enhance your PyQGIS toolbar with a time button. By following the instructions and using the necessary modules and code, users can create a QGIS toolbar icon that displays the current time when clicked. This feature can be useful for those who need to keep track of time while working with PyQGIS. Overall, this tutorial is a useful resource for those looking to upgrade their PyQGIS toolbar.

23- Modifying Toolbar Visibility in QGIS Using PyQGIS

Dr. Azad Rasul — Mon, 27 Mar 2023 12:46:47 +0000

Learn how to customize the appearance of QGIS by changing the visibility of its toolbars with PyQGIS. In this tutorial, you will discover how to use the setVisible() method to show or hide specific toolbars such as Help, Vector, and Raster. With these simple lines of code, you can tailor QGIS to your needs and preferences.

To hide the Help toolbar in QGIS, use the following line of code:

iface.helpToolBar().setVisible(False)

To show the Help toolbar in QGIS, use the following line of code:

iface.helpToolBar().setVisible(True)

To hide the vector toolbar in QGIS, use the following line of code:

iface.vectorToolBar().setVisible(False)

To show the vector toolbar in QGIS, use the following line of code:

iface.vectorToolBar().setVisible(True)

To hide the raster toolbar in QGIS, use the following line of code:

iface.rasterToolBar().setVisible(False)

To show the raster toolbar in QGIS, use the following line of code:

iface.rasterToolBar().setVisible(True)

In conclusion, PyQGIS provides a simple and efficient way to customize the appearance of QGIS by changing the visibility of its toolbars. By using the setVisible() method, you can easily show or hide specific toolbars such as Help, Vector, and Raster, tailoring QGIS to your needs and preferences. With these lines of code, you can improve your workflow and make QGIS more user-friendly.

If you like the content, please SUBSCRIBE to my channel for the future content

22- Personalize the Title of Your QGIS Window using PyQGIS

Dr. Azad Rasul — Mon, 27 Mar 2023 12:06:48 +0000

Learn how to customize the title of your QGIS window using PyQGIS in this tutorial. With just a few lines of code, you can change the default title to any name you want, such as "My QGIS". Follow the step-by-step instructions and sample code to get started.

To get the current title of the QGIS window:

title = iface.mainWindow().windowTitle()

To create a new title by replacing the substring 'QGIS' with 'My QGIS':

my_title = title.replace('QGIS', 'My QGIS')

To set the new title to the QGIS window:

iface.mainWindow().setWindowTitle(my_title)

Here's the overall code:

title = iface.mainWindow().windowTitle()
my_title = title.replace('QGIS', 'My QGIS')
iface.mainWindow().setWindowTitle(my_title)

In conclusion, this tutorial provides a simple and easy-to-follow guide on how to customize the title of the QGIS window using PyQGIS. By following the step-by-step instructions and sample code provided in the article, users can easily change the default title of the QGIS window to any name they want. This feature can be useful for users who want to personalize their QGIS environment or create custom branding for their projects. Overall, this tutorial is a great resource for anyone looking to customize their QGIS window title using PyQGIS.

21- Add a New Menu Item to QGIS Software

Dr. Azad Rasul — Mon, 27 Mar 2023 10:36:13 +0000

Learn how to customize your QGIS software and improve your workflow by adding a new menu item with PyQGIS. This step-by-step guide explains how to import the webbrowser module, define a function that opens a specified website in a web browser, create a QAction instance, and add it to the help menu. With this new menu item, you can quickly access a website of your choice directly from QGIS. Follow the instructions in this article to enhance your QGIS experience and streamline your work.

Import the webbrowser module:

import webbrowser

Define a function that opens the specified website in a web browser:

def open_website(): webbrowser.open('https://smartrs.blog/series/pyqgis-basics')

Create a QAction instance with the label "Go to: Introduction to PyQGIS":

website_action = QAction('Go to: Introduction to PyQGIS')

Connect the triggered signal of the QAction to the open_website() function:

website_action.triggered.connect(open_website)

Add a separator to the help menu:

iface.helpMenu().addSeparator()

Add the website_action QAction to the help menu:

iface.helpMenu().addAction(website_action)

Now, from the "Help" menu, click on the newly created item "Go to: Introduction to PyQGIS" to open the website.

Here's the overall code:

# Import the webbrowser module
import webbrowser

# Define a function that opens the specified website in a web browser
def open_website():
    webbrowser.open('https://smartrs.blog/series/pyqgis-basics')

# Create a QAction instance with the label "Go to: Introduction to PyQGIS"
website_action = QAction('Go to: Introduction to PyQGIS')

# Connect the triggered signal of the QAction to the open_website() function
website_action.triggered.connect(open_website)

# Add a separator to the help menu
iface.helpMenu().addSeparator()

# Add the website_action QAction to the help menu
iface.helpMenu().addAction(website_action)

In conclusion, this article provides a step-by-step guide on how to add a new menu item to the QGIS software with PyQGIS. By following the instructions provided in the article, users can add a new menu item to the help menu, which will open a specified website in a web browser. This article is helpful for users who want to customize their QGIS software and improve their workflow.

20- Computing the distance between a pair of points using PyQGIS

Dr. Azad Rasul — Mon, 27 Mar 2023 00:40:07 +0000

# import the necessary module
from qgis.core import QgsDistanceArea

# create a new QgsDistanceArea instance
d = QgsDistanceArea()

# set the ellipsoid to use for the measurement (in this case, WGS84)
d.setEllipsoid('WGS84')

# create two QgsPointXY instances representing the coordinates of Erbil and Duhok
Erbil = QgsPointXY(44.01, 36.19)
Duhok = QgsPointXY(42.99, 36.86)

# calculate the distance between the two points using the QgsDistanceArea instance
distance = d.measureLine([Erbil, Duhok])

# print the result of the distance calculation, converted from meters to kilometers
print("The distance between Erbil and Huhok is", distance / 1000, "KM")

19- Delete a Column from a Vector Layer Attribute in PyQGIS

Dr. Azad Rasul — Mon, 27 Mar 2023 00:27:45 +0000

Learn how to delete a column from a vector layer attribute in PyQGIS by following these simple steps. This tutorial will guide you through the process of opening a shapefile with an attribute table and using a code snippet to remove a specific column from the table. Whether you're a beginner or an experienced user, this guide will help you streamline your workflow and improve your data management skills in PyQGIS.

To begin, open a shapefile that has an attribute table. To delete the third column of the table, use the following code snippet:

# Get the currently active layer:
layer = iface.activeLayer()

# Begin editing the layer:
layer.startEditing()

# Delete the attribute with the index of 2 from the layer:
layer.deleteAttribute(2)

# Commit the changes made to the layer
layer.commitChanges()

In conclusion, deleting a column from a vector layer attribute in PyQGIS is a simple process that can be accomplished by following the steps outlined in this tutorial. With the help of the code snippet provided, users can easily remove a specific column from their attribute table and streamline their workflow in PyQGIS.

18- Creating a responsive dialogue box using PyQGIS

Dr. Azad Rasul — Mon, 27 Mar 2023 00:15:49 +0000

Are you tired of manually asking users if they want to save changes in QGIS? Look no further than this step-by-step guide on how to build an interactive dialog box! With the help of PyQGIS, you can create a user-friendly experience that saves time and effort. Follow along and learn how to streamline your workflow with this handy tool.

Building a dialog box to ask if users want to save changes:

# import the necessary modules
from PyQt5.QtWidgets import QMessageBox

# create a QMessageBox instance
qmb = QMessageBox()

# set the text displayed on the QMessageBox:
qmb.setText('Want to save your changes?')

# set the standard buttons for the QMessageBox (Save, Discard, and Cancel):
qmb.setStandardButtons(QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)

# execute the QMessageBox and store the return value:
return_value = qmb.exec()

# check the return value and print a message based on the button pressed:
if return_value == QMessageBox.Save:
    print("You pressed Save")
elif return_value == QMessageBox.Discard:
    print("You pressed Discard")
else:
    print('You pressed Cancel')

In conclusion, building an interactive dialog box in PyQGIS can greatly improve the user experience and streamline workflows in QGIS. With this step-by-step guide, users can easily create a dialog box to prompt users to save changes, saving time and effort. By utilizing PyQGIS, users can create a more efficient and user-friendly experience in QGIS.

17- Creating your PyQGIS processing script

Dr. Azad Rasul — Mon, 27 Mar 2023 00:00:00 +0000

Are you tired of manually processing your GIS data? Do you want to learn how to automate the process using PyQGIS? Look no further! In this article, we will guide you through the steps of creating your processing script in PyQGIS.

Firstly, let's look at some common tasks that can be automated using PyQGIS. These tasks include data conversion, spatial analysis, and map creation. By automating these tasks, you can save time and effort in your GIS projects, allowing you to focus on more important tasks.

To get started with creating your processing script in PyQGIS, follow these steps:

Open QGIS and click on Processing in the Menu Toolbar, then click on Toolbox.
In the Script Editor, choose "Create new script from template".
Edit the template to customize the script to your needs. You can use Python code to automate tasks such as loading data, performing spatial analysis, and exporting maps.
Save your script for future use.

It's important to note that creating a processing script in PyQGIS requires some knowledge of Python programming. However, even if you're new to Python, there are many resources available online to help you get started.

By automating GIS data processing using PyQGIS, you can greatly enhance your productivity and efficiency in GIS projects. This skill is particularly useful for professionals in industries such as urban planning, environmental science, and natural resource management.

In QGIS Menu Toolbar click on Processing then click on Toolbox. Next, in Script Editor, choose "Create new script from template". You can edit it and save it as your script like this example:

# Import necessary modules
from qgis.PyQt.QtCore import QCoreApplication
from qgis.core import (QgsProcessing,
                       QgsFeatureSink,
                       QgsProcessingException,
                       QgsProcessingAlgorithm,
                       QgsProcessingParameterFeatureSource,
                       QgsProcessingParameterFeatureSink,
                       QgsMarkerSymbolLayer,
                       QgsMarkerSymbol)
from qgis import processing


class ExampleProcessingAlgorithm(QgsProcessingAlgorithm):

    INPUT = 'INPUT'
    INPUT_PT = 'INPUT_PT'
    OUTPUT = 'OUTPUT'

    def tr(self, string):

        return QCoreApplication.translate('Processing', string)

    def createInstance(self):
        return ExampleProcessingAlgorithm()

    # Name of the algorithm as it appears in the Toolbox
    def name(self):
        return 'myscript'

    # Display name of the algorithm
    def displayName(self):
        return self.tr('My Processing Script')

    # Group name of the algorithm
    def group(self):
        return self.tr('Example scripts')

    # Group id of the algorithm
    def groupId(self):
        return 'examplescripts'

    # Short description of the algorithm
    def shortHelpString(self):
        return self.tr("Example algorithm short description")

    # Initialize the algorithm
    def initAlgorithm(self, config=None):

        # Add input parameter for the input layer
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT,
                self.tr('Input layer'),
                [QgsProcessing.TypeVectorAnyGeometry]
            )
        )

        # Add input parameter for the point layer
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.INPUT_PT,
                self.tr('Point layer'),
                [QgsProcessing.TypeVectorPoint]
            )
        )

        # Add output parameter for the output layer
        self.addParameter(
            QgsProcessingParameterFeatureSink(
                self.OUTPUT,
                self.tr('Output layer')
            )
        )

    # Process the algorithm
    def processAlgorithm(self, parameters, context, feedback):

        # Get the source input layer
        source = self.parameterAsSource(
            parameters,
            self.INPUT,
            context
        )

        # Raise an exception if the source layer is invalid
        if source is None:
            raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))

        # Get the sink output layer:
        (sink, dest_id) = self.parameterAsSink(
            parameters,
            self.OUTPUT,
            context,
            source.fields(),
            source.wkbType(),
            source.sourceCrs()
        )

        # Print the CRS of the input layer to the processing log:
        feedback.pushInfo('CRS is {}'.format(source.sourceCrs().authid()))

        # Get the point layer:
        point_layer = self.parameterAsVectorLayer(
            parameters,
            self.INPUT_PT,
            context
            )

        # Create a simple marker symbol and set it as the renderer for the point layer:
        pt_symbol = QgsMarkerSymbol.createSimple({"color": "0,0,255","name": "rectangle"})
        point_layer.renderer().setSymbol(pt_symbol)
        point_layer.triggerRepaint()

        # Raise an exception if the sink output layer is invalid:
        if sink is None:
            raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))

        # Calculate the total progress percentage
        total = 100.0 / source.featureCount() if source.featureCount() else 0
        features = source.getFeatures()

        for current, feature in enumerate(features):

            if feedback.isCanceled():
                break

            sink.addFeature(feature, QgsFeatureSink.FastInsert)

            feedback.setProgress(int(current * total))

        return {self.OUTPUT: dest_id}

To learn more about PyQGIS and GIS data processing, we recommend checking out the QGIS documentation and joining online communities such as the QGIS user group on LinkedIn.

In conclusion, automating GIS data processing using PyQGIS can save a lot of time and effort in GIS projects. With the help of the steps provided in this article, you can easily create and customize your own processing script in PyQGIS. This can greatly enhance your productivity and efficiency in GIS data processing.

16- Making the process of loading GeoPackage layers more efficient in PyQGIS using customized functions

Dr. Azad Rasul — Sun, 26 Mar 2023 16:23:33 +0000

In this article, we explain how to streamline GeoPackage layer loading in PyQGIS using custom functions. It provides examples of functions to add new layers, multiple layers, and all layers. It also includes a link to download sample data.

To get started, we need to download sample data in the GeoPackage format. We provide a link to download a GeoPackage file containing sample data. Once downloaded, we can unzip the file and load it into PyQGIS.

First, load a list of layer names in the GeoPackage:

from osgeo import ogr
gpkg1 = 'D:/Python_QGIS/data/osopentoid_202105_gpkg_sr/osopentoid_202105_sr.gpkg'
gpkg_layers = [n.GetName() for n in ogr.Open(gpkg1)]
print(gpkg_layers)
print('os_mastermap_topography_layer' in gpkg_layers)
# True
print('london_boroughs' in gpkg_layers)
# False (because the layer is not available)

Next, write a function to add new layers:

def add_layer(gpkg, layer):
    layers = [n.GetName() for n in ogr.Open(gpkg)]
    if layer in layers:
        iface.addVectorLayer(gpkg + "|layername=" + layer, layer, 'ogr')
    else:
        print('Error: there is no layer named "{}" in {}!'.format(layer, gpkg))

Use the defined add_layer function to add a new layer:

add_layer(gpkg1, 'os_mastermap_topography_layer')

Then, define a function to add multiple layers:

def add_layers(gpkg, layers):
    for layer in layers:
        add_layer(gpkg, layer)

# use add_layers function:
add_layers(gpkg1, ['os_mastermap_sites_layer', 'os_mastermap_highways_network'])

Finally, define a function to add all layers:

def add_all_layers(gpkg):
    layers = [n.GetName() for n in ogr.Open(gpkg)]
    add_layers(gpkg, layers)

 # use add_all_layers function:   
add_all_layers(gpkg1)

In conclusion, the article provides useful insights into how to streamline GeoPackage layer loading in PyQGIS using custom functions. It offers examples of functions to add new layers, multiple layers, and all layers. The article also includes a link to download sample data, which readers can use to practice the concepts discussed. Overall, this article is a valuable resource for anyone looking to improve their GeoPackage layer loading process in PyQGIS.

15- Easily calculate new field values in PyQGIS by following this detailed guide

Dr. Azad Rasul — Sun, 26 Mar 2023 10:27:54 +0000

If you are struggling with computing new field values in PyQGIS, this step-by-step tutorial is the perfect resource for you. In this tutorial, we will guide you through the process of creating a vector layer, adding an attributed table to it, adding data to its fields, and computing new field values using a for loop. Specifically, we will show you how to compute the density field. Whether you are a beginner or an experienced PyQGIS user, you will find this tutorial helpful in enhancing your skills and improving your data analysis capabilities.

By following the instructions in this tutorial, you will be able to create a vector layer, add data to its fields, and compute new field values using a for loop. We have provided a complete code for your reference. The tutorial is suitable for both beginners and experienced PyQGIS users. Key takeaways from this tutorial include the ability to:

Create a vector layer with an attributed table
Add data to the fields of the vector layer
Compute new field values using a for loop

First, create a vector layer:

from qgis.PyQt.QtCore import QVariant
from qgis.core import edit

vl = QgsVectorLayer("Point", "Cities_Kurdistan", "memory")

pr = vl.dataProvider()

Next, add an attributed table to it:

pr.addAttributes([QgsField("City", QVariant.String),
                  QgsField("Population",  QVariant.Double),
                  QgsField("Area", QVariant.Double),
                  QgsField("Density", QVariant.Double)])
vl.updateFields()

Then, define your data:

my_data = [
    {'x': 44.01, 'y': 36.19, 'City': 'Erbil', 'Population': 2932800, 'Area': 14872},
    {'x': 45.43, 'y': 35.55, 'City': 'Sulaymania', 'Population': 1967000, 'Area': 20143},
    {'x': 42.99, 'y': 36.86, 'City': 'Duhok', 'Population': 1292535, 'Area': 10955},
    {'x': 45.98, 'y': 35.17, 'City': 'Halabja', 'Population': 109000, 'Area': 889}]

After that, add data to the fields:

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

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

The density field is currently empty, and we will compute it with a for loop:

with edit(vl):
    for f in vl.getFeatures():
        f['Density'] = f['Population'] / f['Area']
        vl.updateFeature(f)

The complete code is:

from qgis.PyQt.QtCore import QVariant
from qgis.core import edit

vl = QgsVectorLayer("Point", "Cities_Kurdistan", "memory")
pr = vl.dataProvider()

# add attributes
pr.addAttributes([QgsField("City", QVariant.String),
                  QgsField("Population",  QVariant.Double),
                  QgsField("Area", QVariant.Double),
                  QgsField("Density", QVariant.Double)])
vl.updateFields()

#define your data
my_data = [
    {'x': 44.01, 'y': 36.19, 'City': 'Erbil', 'Population': 2932800, 'Area': 14872},
    {'x': 45.43, 'y': 35.55, 'City': 'Sulaymania', 'Population': 1967000, 'Area': 20143},
    {'x': 42.99, 'y': 36.86, 'City': 'Duhok', 'Population': 1292535, 'Area': 10955},
    {'x': 45.98, 'y': 35.17, 'City': 'Halabja', 'Population': 109000, 'Area': 889}]

# add data to the fields    
for rec in my_data:
    f = QgsFeature()
    pt = QgsPointXY(rec['x'], rec['y'])
    f.setGeometry(QgsGeometry.fromPointXY(pt))
    f.setAttributes([rec['City'], rec['Population'], rec['Area']])
    pr.addFeature(f)

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

# compute "Density":
with edit(vl):
    for f in vl.getFeatures():
        f['Density'] = f['Population'] / f['Area']
        vl.updateFeature(f)

In conclusion, this tutorial provides a comprehensive guide to computing new field values in PyQGIS. We hope that you find this tutorial helpful in enhancing your skills and improving your data analysis capabilities.