DEV Community: KENNEDY NDUNGU WANJIRU

A Pythonic Guide to Functions

KENNEDY NDUNGU WANJIRU — Fri, 02 Oct 2026 17:11:45 +0000

You’ve seen def a hundred times. You know how to write a function, call it, and return a value. But do you know what really happens when Python executes a function definition? Do you know why args and kwargs exist, or how a function can remember the environment where it was created? In Python, functions are more than just reusable blocks of code — they’re objects with attributes, they can be nested, passed as arguments, and wrapped by decorators. In this article, we’ll move from the basics of def and return to the powerful patterns that make Python feel like Python. Whether you’re a beginner or brushing up, there’s something here for you.
A function is a block of organised,reusable code that is used to perform an action.
There are two basic types of functions we can work with: built-in functions and user-defined functions.
We can break down the creation of a function into five components.

Function definition

In Python, we use the keyword "def" to define a function, followed by round brackets and a colon. The colon is used to indicate the start of a new block of code.

Function name

We need to give our function a name which we will use to call it later.
There are some guidelines on how to name a function, such as the name must begin with a letter or an underscore, it must be in lowercase, it can have numbers and be any length (it's best to keep it short), it cannot be the same as any Python keyword, and must describe the function's purpose.

Function inputs

Inputs, also known as parameters, define the variables required for the function to perform its tasks. It's worth noting that we don't have to submit an input every time. If the function tasks do not require any inputs, we can leave this field empty.
It is essential to differentiate between function parameters and arguments.
Parameters are variables listed in the function declaration, serving as placeholders for the values that the function will receive during its execution. They act as local variables within the function, defining its input structure. On the other hand, arguments are the actual values passed to a function when it is called. These values are assigned to the corresponding parameters defined in the function, allowing for dynamic and flexible behaviour.

Function instructions/tasks

This is the block of code within the function that serves as the set of instructions that the function must follow. To indicate that the code that follows belongs to the function, we type it one tab away from the declaration line.

Return statement

The return statement defines what the result of the function or the output should be.

Note: A return statement is not required for the function to be created successfully. However, because every function in Python must return something, functions that do not have a return statement return None by default.

Create the function

We start by typing def to define the function, followed by the function name, which we called calc_forest_area.

Our function has two arguments, the forest length and width.
We add these arguments in the brackets and end the declaration with a colon after the brackets.

Pressing enter in most coding environments will take us to the next line at the correct level of indentation. However, if it doesn't, we hit the tab button, which is equivalent to four or eight whitespaces, depending on the Python editor.

Inside the function, we define a new variable called area and set it equal to our input length multiplied by our input width. This is the instruction that will calculate our area.

Next, we define what we want our function to return using the return statement. In our case, we want our function to return the area of the forest calculated by the function.
Therefore, we add “return” and the area variable.

Call the function

Assume we wanted to use our newly created function to determine the area of the Zambesi forest which has a length of 300 kilometres and a width of 5000 kilometres.

We could also store our output in a variable in order to use it later.

Remember when we made use of built-in functions and could read the documentation using the help() function? We can employ documentation strings to perform something similar for user-defined functions.

Documentation strings, abbreviated docstrings, are used to describe the functionality of a function, including the arguments and expected return, if they exist. Docstrings can also be used in other code constructs, such as classes and methods, to provide additional information to the user.

The purpose of any docstring is to explain the function's purpose and functionality so that anyone new viewing or using it understands what the function does.

Doc Strings

A docstring is most commonly defined under the function definition with triple double quotation marks and is divided into three distinct sections:

Functionality of the function.
Breakdown of the input(s), if applicable.
Breakdown of the output, if applicable.

Let's add some docstrings to our calc_forest_area function.

Docstrings are not required for our functions to execute successfully, however, there are some advantages to using them.
Docstrings improve code readability by allowing anyone viewing it to grasp its intent without having to decipher it, making collaboration easier. In our code base, we tend to construct several functions that perform a variety of tasks. Having documentation that explains what the function does and how to use it makes it easier to keep track of all our functions. We are also able to access the documentation for all our functions using the doc attribute, as well as the built-in help() function.

Scope

Now that we understand how to create a function, we need to understand scope, which refers to the parts of our code where an object or variable is available for use.
We can distinguish between a local variable and a global variable.

Local variable

When we created our function, within it we created a variable called area.
This variable is known as a local variable.
A local variable is defined in or by a function and is only available for use inside that function.
For instance, if we attempted to access our area variable from outside the function, we would receive an error stating that the variable name has not been defined.

Global variable

In contrast, a global variable is one that is defined outside of any function's construct and can be accessed anywhere in our code.
The zambesi_forest variable we created earlier, for example, is a global variable that can be used globally in our code, even inside a function.

Function inputs

Functions in Python are like tools that perform specific tasks. To make these tools versatile, we need a way to provide them with information. Inputs in functions serve this purpose, allowing us to customise the function's behaviour based on different situations.

Types of inputs

No input

Sometimes, a function doesn't require any input to perform its task. For example, suppose we wanted to write a function that would print a general deforestation message throughout our program at various phases.

This function does not require any input from the user in order to produce the desired outcome.

Default inputs

Default inputs provide a way to set default values for named arguments in a function. If a value is not provided when calling the function, the default value is used.
Suppose we wanted to give the user the option of entering their own personalised message if they so desired. In this case, we could use default arguments.

A user who does not need a personalised message could use the function without providing a value for the message argument.

Alternatively, a user that needs a unique message can use the message parameter to specify it.

In the above examples, the message parameter has a default value, making it optional when calling the function.

Variable inputs

Sometimes, we might want a function to accept an arbitrary number of arguments without specifying their names.

Python provides us with two variadic inputs – *args and **kwargs.

For us to understand *args and **kwargs, it's important for us to understand the difference between keyword arguments and non-keyword arguments.

Keyword arguments

Keyword arguments are used when we call a function and explicitly assign an argument to a parameter. The sequence in which we pass the arguments does not matter when using keyword arguments, because we explicitly assign the parameters to the variable.

In the function call above, we used keyword parameters to call the create_deforestation_message function. We entered the message and then the location to explicitly assign each argument to its parameter, regardless of order.

Positional arguments/Non-keyword arguments

When we call a function in Python and supply arguments based on the position of the parameters, the arguments are referred to as positional arguments. Positional arguments are thus matched with parameters based on their position. Positional arguments are often known as "non-keyword arguments".

We utilised positional parameters in the function call above to call the create_deforestation_message function. The arguments were entered in the correct sequence depending on their placement in the function parameters.
Unlike keyword arguments, if we changed the order of these parameters, the function wouldn't perform as expected.

*args: Variable non-keyword arguments

*args enable a function to accept any number of positional arguments, that is, non-keyword arguments in a variable-length argument list.

An *args parameter is created in the same way as any other parameter, with the exception that an asterisk is added before the parameter name.
Suppose we also wanted to create a function that allows the user to track the impact of deforestation on their forest. We could write a function that takes each consequence as an argument, but users may want to list a varying number of consequences or arguments. This would be possible with *args.

**kwargs: Keyword arguments

**kwargs indicate that our function can accept any number of keyword arguments by placing ** before the parameter name. The arguments will be wrapped in a dictionary with the key being the parameter name and the value being the parameter value.

Suppose we want to create a function that collects detailed and varying characteristics of a forest. The user must be able to decide what information they would like to share using this function.

We can create a function named list_forest_details that accepts any number of keyword arguments and uses a combination of the parameter name and value to output labelled information about the forest.

In this function, **details allows the function to accept any number of keyword arguments. It iterates through the dictionary and prints each key-value pair.

Note: If our function were to make use of both *args and **kwargs, it is important to remember that we always place *args before **kwargs in the argument list.

Multiple return values

Python functions are very versatile and can be configured to meet the needs of the user. We just proved this through our exploration of the number of ways users can enter inputs into our functions. This remains true for function return values.

Python functions can return function results in several ways. We can return a string, a number, a dictionary, a tuple, or even a table as a value.

Python can also return multiple values.

In some cases, a function needs to provide more than one piece of information back to the user. This can be accomplished by separating the values with a comma. The values returned can then be allocated to numerous variables. This can come in handy in a variety of scenarios.

Let's create a function that calculates the impact of deforestation caused by carbon emissions.

We want our function to compute the percentage of tree cover loss by subtracting the initial forest area from the remaining forest area.
We also want it to estimate the increase in CO2 emissions by multiplying the tree cover percentage, the remaining forest area, and the carbon emission factor.

The function returns a tuple containing the percentage of tree cover loss, the remaining forest area, and the estimated increase in CO2 emissions. To use these values, we unpack the tuple into separate variables (loss_percentage, remaining_area, and co2_increase) when calling the function.
We can then use or view each variable separately.

By exploring the above concepts, we have gained practical insights into how to create versatile and useful functions in Python.

Mastering OOP in Python Without any Headache

KENNEDY NDUNGU WANJIRU — Fri, 02 Oct 2026 15:29:27 +0000

You know lists, dictionaries, loops, functions and control flows. You stared at class Dog: and def __init__(self, name): and wondered whether you have by mistake opened a Java tutorial.
Once you understand a few concepts, you will find that you have been using OOP in Python all the time. You will see that it is straightforward and intuitive - a natural extension to your Python knowledge.Object oriented programming has 4 pillars and they are
1. Encapsulation
2. Inheritance
3. Polymorphism
4. Abstraction

Classes in OOP are like blueprints or templates for creating objects. An object is a specific instance of a class, containing attributes and behaviors defined in the class. For instance, if a class represents the concept of a 'tree', then each 'tree' planted is an object of that class, with its own unique characteristics.

Imagine a forest with various tree species. Each species has unique characteristics like height, age, and species type. We can model this diversity using a class for trees, where each tree object represents a specific tree in the forest.
In this article, we explore the basic concepts of OOP using Python code examples. We will learn about classes, instances, inheritance and dunder methods.

An object oriented programming start with a class,a class is created using the keyword class and the name of the class folllowed by a fullcolon :.Follow it by a constructor method to initialise class attributes the method should end in fullcolon.Attributes are variables stored on the object like self.name.self refers to the specific instance being created or used. It must be the first parameter of instance methods.
A method is simply a function defined inside a class. It describes what objects of that class can do.We can create as many methods as we want in a class.

Encapsulation is a fundamental OOP principle that involves bundling data (attributes) and methods (functions) that operate on the data into a single unit or class. It also restricts direct access to some of the object's components, which is a means of preventing accidental interference and misuse of the data.

The Tree class in the code defines a blueprint for creating tree objects with specific attributes: species, height, and age. The __init__ method, known as the constructor, initialises these attributes when a new tree object is created. The describe method provides a simple way to output a description of the tree, demonstrating how methods can operate on the data encapsulated within the same object, allowing for clear and maintainable code structures.
In our Tree class, encapsulation is demonstrated by how the attributes (species, height, age) and the method (describe) are enclosed within the class. This design allows us to create tree objects with their properties and behaviors neatly packaged together.
Once we have a class ready we need to create an instance,an instance is a concrete object built from that blueprint.To get an object call the class like a function.

This example shows how encapsulation makes our code more manageable and secure. By keeping the data (attributes like species, height and age) and methods (describe) within the class, we maintain a structured and organised approach to coding, which is particularly helpful in complex programming scenarios.

Inheritance in OOP allows us to define a class that inherits all the methods and properties from another class. The parent (or base) class is the class being inherited from, and the child (or derived) class is the class that inherits from the parent class.

Imagine a tree ecosystem where we have a Tree class as our base class with attributes like species, age, and height, and methods grow() and reseed(). From this base class, we derive two subclasses: Oak and Pine.

The Oak class inherits the properties and methods from Tree and adds its own method budding(). Similarly, the Pine class inherits from Tree and adds a cone_count() method.

The Oak and Pine classes illustrate inheritance by reusing the code from the Tree class. They also demonstrate how we can extend the functionality of a base class by adding new methods that are specific to the subclass. This not only saves time by not having to rewrite shared code but also helps maintain a natural and understandable hierarchy within the codebase, mirroring real-world relationships.

**Polymorphism **in OOP allows objects of different classes to respond to the same message—or method call—in ways appropriate to their types. This means that the same method can behave differently in different classes.

Let's say we have two subclasses, Oak and Pine, that stem from the same parent class Tree. Each subclass can respond to common messages like grow() and reseed(). However, due to polymorphism, when the grow() signal is sent, both Oak and Pine trees will grow, but the way they grow and how much they grow can vary. When the reseed() signal is sent, both types of trees will disperse seeds, but the types of seeds and the method of dispersal might be different. Furthermore, each type of tree may have additional processes that are unique to its kind, such as budding() in Oaks or cone_count() in Pines.

Abstraction in OOP is the concept of hiding the complex reality while exposing only the necessary parts. It's like using a simple user interface (UI) that hides the complex code behind it. For example, we often log in to websites via simple UIs, which abstracts us from the complex code.

Let's say we want to provide a simple interface for the growth of various types of trees without needing to understand the intricate details of how each tree grows. The Tree class will represent the abstract concept of a tree with the method grow(), which is an abstract method because it's not implemented. Specific types of trees, such as EvergreenTree, will provide concrete implementations of the grow() method.
For abstraction to work we have to import abstractmethod into our code.

The Tree class serves as an abstract base class, similar to the user-friendly login interface. It defines the structure and expectations (like the login fields) without detailing the specifics. The EvergreenTree class extends Tree and provides the specifics of how an evergreen tree grows. This hides the complexity from the user, who simply needs to know that they can make a tree grow by calling the grow() method, much like a user only needs to enter a username and password and click 'login' to start a session. This abstraction makes the code easier to use and maintain, as well as to extend with new types of trees.
I hope this article helps you understand object oriented programming.

The Art of Looping in Python

KENNEDY NDUNGU WANJIRU — Mon, 28 Sep 2026 14:36:02 +0000

Now consider writing that code 100 times. That would be quite painful wouldn't it? Now consider writing that code 10,000 times. It isn't just bad, it is a nightmare. Luckily for us, Python has a way of solving this problem for code and that way is through loops. In this article, I will cover what loops are, when you should use loops and why you will soon have loops in your toolbox.
Two official python loop statements are for and while loops.

for loops: They are ideal for going through a sequence (like a list, tuple, or string), one by one. We use for loops when we know how many things there are in a list.

For example, for each element i in list_of_numbers, print out the value of i:

Syntax and structure

The syntax of a for loop in Python is straightforward. It includes the for keyword, an item variable, the in operator, and a collection object, where collection refers to an object we can iterate through, like a list, dictionary, or tuple. The instructions we want to run in each loop are in the loop body.

For example:

Here the loop accesses each value in the list, one by one. We can iterate through our list of animals too, one by one:

We can add as many instructions as we like in the body of the loop. Once a loop is complete, it executes the next line of code after the loop.

We can loop through any iterable data structure like tuples, sets, dictionaries, and even strings:

While loops

A while loop in Python repeatedly executes its body as long as a condition is true. Its syntax is:

while loops are ideal for scenarios where you don't know how many times you need to iterate. For example, adding 10% to a value, until it is > 5. It is hard to know before we start how many times we have to repeat the calculation, so if we use a while loop, we can keep going until we get to the answer.It can be stopped if the condition is false or by using break key word.

This loop prints the population with 10% added to each iteration, until the population is 2.85, and the loop stops because the next number is larger than 3.

Be cautious with while loops, because they result in infinite loops if the condition never becomes false. Always ensure there's a way for the condition to become false eventually.

If your loop is infinitely looping, press the i key twice rapidly, or click on the stop/interrupt button to interrupt the kernel. The cell below contains an example of an infinite loop. It will go into an infinite loop when running it, so beware!

Loop controls

Loop control statements are used to change the execution flow of loops. They provide flexibility and control over how loops behave in different scenarios. The primary loop control statements in Python are break, continue, and pass.

`break` statement

break immediately stops the execution of a loop, and the control flows to the statement immediately after the loop.

break is often used when searching for an item in a list. Once the item is found, there's no need to continue the loop.

The loop stopped once we reached the African Elephant animal, so printing out print(f"The last animal checked = {animal}") after the loop has completed, results in African Elephant, showing that the loop stopped there.

`continue` statement

continue skips the rest of the loop's body for the current iteration and moves to the next iteration.

This is useful when we need to skip certain elements in a loop, like filtering out specific values.

`pass` statement

pass is a statement that does nothing. It's used as a placeholder.

pass is used when we need a statement to have the correct syntax but want to implement no action, like in empty definitions, loops, or conditionals. pass is very useful as a placeholder for the code we are going to add later.
Suppose we want to check all animals, but skip African Elephants:

We've learned that loops are essential for automating repetitive tasks and efficiently processing collections of data. By understanding the nuances of for and while loops, as well as loop control statements like break, continue, and pass, we can write more effective and efficient Python code.

Teaching Python to Think: A Guide to Operators and Conditionals

KENNEDY NDUNGU WANJIRU — Mon, 21 Sep 2026 18:53:50 +0000

Introduction: Teaching Python to Think

Every Python program, no matter how sophisticated it appears, ultimately boils down to two fundamental capabilities: the ability to compare values and the ability to make decisions based on those comparisons. A banking app checks whether your balance exceeds the purchase amount. A game determines whether your character has collided with an obstacle. A script decides whether a file exists before attempting to open it. Strip away the libraries and the elegant syntax, and you'll find the same humble building blocks at work: operators and conditionals.

Operators are the tools Python gives us to perform computations and comparisons—adding numbers, checking equality, combining logical statements with and, or, and not. Conditionals are the structures that let our programs branch, choosing one path over another depending on the outcome of those comparisons. With Python's readable if, elif, and else syntax, these concepts feel almost like plain English, but they hide surprising depth. Should you use == or is? How does Python's truthiness treat empty lists versus zero? What's the difference between and returning a boolean and returning one of its operands? These subtleties trip up beginners and seasoned developers alike.

In this article, we'll explore how operators and conditionals work in Python, examine the different categories of each, and look at practical examples that show how these concepts combine to create logic that's greater than the sum of its parts. Whether you're writing your first if statement or brushing up on the nuances of comparison chaining and short-circuit evaluation, understanding these fundamentals will make you a more deliberate and effective Python programmer.

Let's dive in.

For one to understand conditionals its important to know arithmetic,comparison and Logical operators.
Arithmetic operators include

Operator	Name	Example	Result
`+`	Addition	`5 + 3`	`8`
`-`	Subtraction	`5 - 3`	`2`
`*`	Multiplication	`5 * 3`	`15`
`/`	Division	`5 / 3`	`1.6666...`
`//`	Floor Division	`5 // 3`	`1`
`%`	Modulus (remainder)	`5 % 3`	`2`
`**`	Exponentiation	`5 ** 3`	`125`

Comparison operators include

Comparison operators	Description
==	Equal to
!=	Not equal to
<	Less than
>	Greater than
<=	Less than or equal to
>=	Greater than or equal to

Logical operators include

Logical operators	Description
and	True if both are true(`x and y`). This operator is used to check whether both conditions are true.
or	True if at least one is true (`x or y`). This operator is used to check if either of the conditions is true.
not	True only if false (`not x`). This operator is used to check for inequality.

`if`, `elif`, and `else`

Conditional statements in programming are used to execute specific blocks of code based on whether certain conditions are met. They are fundamental for decision-making in our code, allowing for different outcomes depending on variable states or inputs. Typically, we use if, elif, and else statements to handle these scenarios, providing flexibility and control over the flow of our program's execution.

`if` statements

if statements are the most basic form of conditional execution. They are used to execute a block of code only if a specified condition is True. For example, if we wanted to issue a warning when deforestation exceeds a certain level.

Nested `if` statements

Nested if statements are used when we need to perform another conditional check within an if block. They are useful for more complex decision-making processes. For example, suppose we want to prioritise environmental protection in sensitive areas. We must check whether the deforestation rate exceeds a certain level and if an area is protected.

`if`-`else` statements

The if-else structure executes one block of code if the condition is True and another block if it is False. For example, suppose we want to create a simple notification system for deforestation activity.

`elif` statements

elif (short for else if) provides a middle ground between if and else. It is used when we have multiple conditions to check sequentially. For example, suppose we need to categorise deforestation rates into different levels of concern, such as "Critical level", "High level", or "Normal level", based on predefined thresholds.

Chained conditional statements

Chained conditionals use elif (else if) for multiple checks. They are used when there are more than two possibilities and exactly one must be chosen. For example, suppose we need to implement specific environmental actions based on varying levels of deforestation.

The program sequentially evaluates each condition from the top down. It stops further checks as soon as one condition is fulfilled. In a scenario where there are mistakenly two true conditions for a variable, the program executes only up to the first met condition, ignoring subsequent ones. For example, both elif deforestation_rate == 0.1 and elif deforestation_rate >= 0.1 are true when deforestation_rate is 0.1. However, only the first true condition is executed.

Conditional statement keywords: `not` and `pass`

In Python, there are keywords within conditional statements that allow us to add more flexibility to our code.

`if` `not` statements

if not is used to check the negation of a condition. It's a more readable way to check if not true. For example, suppose we want to create an automated alert system for forest conservation that tells us the forest is healthy if no deforestation is detected and alerts us if this is not the case.

`pass` statements

pass is a null statement in Python. It is used when a statement is syntactically required but we do not want any command or code to execute. It is often used as a placeholder for future code. When the pass statement is executed, nothing happens, but we avoid getting an error when empty code is not allowed. For example, suppose we are creating a system to monitor deforestation and take action only when necessary. However, we are still planning what should be done if deforestation exceeds the predefined limits.

We can attempt to leave an if statement block empty, meaning no code is executed within it. However, this approach results in an error, as Python expects to find an indented block following an if statement, even if no action is to be performed.

To resolve this error, we can insert a pass statement in the if block. The pass statement serves as a placeholder, doing nothing but preventing the error caused by an empty code block.
Note: It's essential to use pass wisely as it can hide real issues in the code by overlooking errors that could offer valuable insights.

By exploring the above concepts, I hope you have gained practical insights into why and how we use various types of conditional statements in Python.

Python Basics

KENNEDY NDUNGU WANJIRU — Mon, 21 Sep 2026 17:14:29 +0000

Variables. Data Types. Input/Output. Syntax.

Every programmer who you idolize began their journey right where you are, staring at a blinking cursor, searching for answers.

The good news is that all of them had to learn these four concepts:

Variables – the labeled boxes where a computer stores its information.

Data types – numbers, words, and booleans.

Input/output – the ways a program consumes and produces information.

Syntax – what makes computer languages different than English.

These concepts are the foundation of any successful coding journey. You won’t be able to build something meaningful without understanding them at a fundamental level.

Once you learn the basics, you’ll unlock the knowledge that can help you achieve extraordinary outcomes. Instagram and AI revolution are all built with computer programs.

This guide will give you an overview of the most important programming concepts in Python. It will explain what you need to know to become a better programmer, regardless of your goals. Some of these ideas are universal, and you’ll encounter them in any language. Moreover, Python is exceptionally beginner-friendly because it isolates these concepts and makes them easier to grasp.

Whether you just opened a Python book for the first time or haven’t touched the language in years, this guide will bring you up to speed. Let’s get started!

Assigning a variable

Assigning a variable in programming refers to the process of associating a value with a symbolic name (the variable name) so that the program can refer to and manipulate that value using the given name. It is essentially storing a piece of data in a memory location and giving it a label for convenient reference.
To assign a variable, we need three components:

Variable name: We can decide what we would like to name our variable but keep in mind it can be short and descriptive. We will learn about certain naming conventions we must follow in a bit.
Assignment operator: The variable name will be followed by the assignment operator. The assignment operator is an equal sign (=).
The value: The value we assign to a variable can be numerical or consist of characters, known as strings. In this part of the lesson, we will only be focusing on using numerical values.

We assign values to variables for the following reasons:

To label and store information in memory.
This information can then be referenced later on and even be manipulated.
It makes it easier for a reader, and even ourselves, to understand our code.

examples

Many variables can be assigned to one value.

Rules

When naming variables, certain rules must be followed:

Rule	Example
Must start with a letter or underscore	`myvarname` or `_myvarname`
Not allowed to start with a number	`2myvarname`
Only allowed to contain alpha-numeric characters and underscores	`myvarname_2`
Variable names are case-sensitive	`myvar` $\neq$ `Myvar`

Case types

It is also important to be consistent when using a naming convention for variables.
We can use the following case types to ensure consistency:

Case type	Description	Example
Pascal case	All the first letters in the variable name are capitalised, with no spaces and characters between the words	`MyVarName`
Camel case	The first word's letter is not capitalised, and it doesn't have any characters between the words	`myVarName`
Snake case	Words are separated by underscores and usually all lowercase	`my_var_name`

Data types

Like other programming languages, variables in Python have values and types. Data types dictate what kind of data a variable can store and, in some cases, the amount of memory allocated to it. Allocating variable types allows us to make assumptions about the kind of operations that can be applied to a given variable.

Python makes use of five primitive variable types:

Integers
Floats
Complex numbers
Strings
Booleans

(a) Numbers
Three main data types exist to store numerical data:

Integers (ints): These are positive or negative whole numbers with no fractional components. By using built-in functions in Python, such as type(), we can determine if a number is an integer or a float, for example, 5, -10.
Floats: This is another numerical data type that is used to represent real numbers. A decimal point is used to divide the integer and fractional components of the value, for example, 3.14, -0.5.
Complex numbers: A complex number is a distinct data type used to represent numbers in the form a + bj, where a and b are real numbers, and j is the imaginary unit (for example, the square root of -1). Complex numbers play a crucial role in various mathematical and engineering applications, and Python provides native support for them, for example, 2 + 3j, 1 - 1j.

Strings in Python are sequences of characters enclosed in quotes, either single (') or double ("). They are versatile and widely used for representing textual data.

Characteristics of strings include:

Sequence of characters: Strings can contain letters, numbers, symbols, and spaces.

Immutable: Once a string is defined, its content cannot be changed. Any operation that appears to modify a string actually creates a new string.

(c) Booleans
Booleans are built-in data types capable of taking one of two possible values: True or False(interchangeable with the integers 1 and 0). Booleans control the flow of a program and are used to make comparisons, showing that despite the fancy name (nicknamed bool in Python) they play an integral role.

Boolean data types can be used with comparison and logical operators:

Comparison operators	Description
==	Equal to
!=	Not equal to
<	Less than
>	Greater than
<=	Less than or equal to
>=	Greater than or equal to

Logical operators	Description
and	True if both are true(`x and y`). This operator is used to check whether both conditions are true.
or	True if at least one is true (`x or y`). This operator is used to check if either of the conditions is true.
not	True only if false (`not x`). This operator is used to check for inequality.

These boolean operators will either equate to True if the condition is met or False if the condition is not met.
Below we will be testing some conditions using logical operators.

The print() function is used for output in various formats and the input() function enables interaction with users.

input() function is used to take user input and it returns the user input in form of a string.

print() function allows us to display text, variables and expressions on the console.

Casting variables to different data types is a fundamental concept in programming that involves transforming a variable from one data type to another. In Python, this process is commonly referred to as "type casting" or simply "casting." The ability to cast variables enables programmers to adapt and manipulate data efficiently, ensuring that the correct operations, methods, and functions can be applied to specific types of data.
We can confirm data type using the following syntax
variable_type = type(variable)

Casting data types is a more explicit or forceful change in type, normally actioned by the user.
new_variable = target_data_type(existing_variable)

I hope this article will be useful to you the reader and any python beginner.If you find this article useful share it widely.

WINDOW FUNCTIONS

KENNEDY NDUNGU WANJIRU — Sun, 13 Sep 2026 11:16:33 +0000

What are Window Functions?
It is a function that performs calculations across a set of rows related to the current one and returns the result of its computation for each row. Unlike GROUP BY, Window functions in PostgreSQL do not aggregate values and therefore do not reduce the number of rows in the output dataset. All rows from the input table are present in the output, and computations are attached to the corresponding rows.

In other words, you can think of a window function as a computation that for each row requests a value that is the result of some calculation applied to a certain set of rows (a window).

In our previous article we have 'Postgresql functions' we had gone through aggregate functions,therefore we will not repeat aggregate functions . A Window function has the following syntax

1.Value
1.1 FIRST_VALUE()
The FIRST_VALUE() function allows the retrieval of the value of a column from the first row within a partition.

The FIRST_VALUE() function is applied to the First_name column and ordered by Start_date. It returns the First_name from the
first row as First_in_dept.

1.2 LAST_VALUE()
The LAST_VALUE() function allows the retrieval of the value of a column from the last row within a window frame.

The LAST_VALUE() function is applied to the First_name column
and ordered by Start_date. It returns the First_name from the
first row as Last_employee.

1.3 LEAD()
The LEAD(column, n) function allows access of a value within a column from the following nth-row relative to the current row. It is the counterpart of the LAG() function.

The LEAD(Salary, 1) function is applied to the Salary column and
ordered by Date_started. It returns the salary from the previous
row, since n = 1, as the column Next_salary.

1.4 LAG()
The LAG(column, n) function allows access of a value within a column from the previous nth-row relative to the current row.

The LAG(Salary, 1) function is applied to the Salary column and
ordered by Date_started. It returns the salary from the previous
row, since n = 1, as the column Previous_salary.

2.0 Ranking()
Ranking window functions assign a rank or row number to each row within a specified window or subset of rows. Ranking window functions typically need an ORDER BY clause in order to work as intended. They include

2.1 RANK()
The RANK() function assigns a rank to each row based on the order specified within the window. Rows with the same values receive the same rank, and the next rank is skipped.

2.2 DENSE_RANK()
The DENSE_RANK() function operates similarly to the RANK() function except it does not skip any ranks even if rows have the same values.

2.3 ROW_NUMBER()
The ROW_NUMBER() function assigns a unique sequential number to each row within a partition, regardless of the column values. It makes sure that no two rows can have the same row number within a division.

2.4 NTILE()
NTILE() divides sorted partitions into n-number of equal groups. Each row in a partition is assigned a group number.

I would advise you to read and practice these functions for you to master them.

POSTRESQL FUNCTIONS

KENNEDY NDUNGU WANJIRU — Sun, 13 Sep 2026 08:38:37 +0000

Forget about using your database simply as an advanced version of Microsoft Excel.
When you are bringing down thousands of rows of unrefined data to your app in order to perform simple actions such as calculating average, counting distinct users, and formatting dates, then you are wasting your valuable bandwidth and time. The truth is that SQL is more than just data storage; it is a highly advanced computational tool. With the help of SQL functions, one can refine data and derive useful insights even before it gets downloaded from the server.In this article we shall ocus on the commoly used postgresql functions.

Postgresql functions are built-in operations that can be used to perform various calculations, manipulations, or transformations on data within an postgresql database.

Function Types
Functions can be categorized by what input they take.

Syntax of postgresql functions
The output of a function in postgresql is treated as a derived column and appears in the SELECT clause of a query. The general syntax of an postgresql function is:

1.Numeric Functions
These functions perform calculations on a set of values in a
column and return a numerical value.Numeric functions is grouped
into aggregate numeric functions and scalar numeric functions.
Aggregate numeric functions include
1.1 SUM()
The SUM() function returns the total sum of a specified numeric column.

1.2 AVG()
The AVG() function returns the average value of the selected numeric column.

1.3 MIN()
The MIN() function returns the smallest or lowest value of the selected column.

1.4 MAX()
The MAX() function returns the largest or highest value of the selected column.

scalar numeric functions include
1.5 ROUND()
The ROUND() function rounds a numerical value to a specified number of decimal places.
The following is the syntax of round function.

1.6 SQRT()
The SQRT() function returns the square root of a numerical value.

2.0 String Functions
These functions operate on string values and perform
operations such as concatenation, manipulation, and text
formatting.They include

2.1 UPPER() and LOWER() functions
The UPPER() function is used to convert a string to uppercase while the LOWER() function is used to convert a string to lowercase. Their syntaxes are as follows:

example

2.2 LTRIM() and RTRIM() functions
The LTRIM() function is used to remove leading spaces from the left end of a string while the RTRIM() function is used to remove trailing spaces from the right end of a string.You can use TRIM()
to remove both the leading and trailing spaces.

example

2.3 LEFT() and RIGHT() functions
The LEFT() function is used to extract a specified number of characters from the beginning (leftmost side) of a string while the RIGHT() function is used to extract a specified number of
characters from the end (rightmost side) of a string.

2.4 SUBSTRING() function
The SUBSTRING() function is used to extract a substring from a string. It takes three arguments: the original string, the starting position of the substring, and optionally, the length
of the substring.

example

2.5 CONCAT() function
The CONCAT() function is used to concatenate or join multiple strings together. It takes two or more string arguments (separated by commas) and returns a single concatenated string.

example

2.6 REPLACE() function
The REPLACE() function is used to replace all occurrences of a specified substring within a string with a new substring. It takes three arguments: the original string, the substring to be
replaced, and the new substring.

example

3.0 Miscellaneous functions
This category represents a variety of functions that do a
variety of things such as converting data types and dealing
with NULL values.They include

3.1 CAST() function
The CAST() function is used to convert a value from its current data type into a specified data type. Its basic syntax is as follows

example

3.2 CONVERT() function
CONVERT() is another function that can be used for conversion from one data type to another. Its basic syntax is as follows:

example

3.3 IFNULL() function
The IFNULL() function returns a specified value if the given expression is null. Otherwise, it returns the value of the expression itself. Its basic syntax is as follow

example

3.4 NULLIF() function
The NULLIF() function is used to compare two expressions and return NULL if they are equal. Otherwise, the first expression is returned. Its basic syntax is as follows:

example

3.5 ISNULL() function
The ISNULL() function helps to determine whether an expression is NULL or not. If the expression is NULL, this function returns 1. Otherwise, it returns 0. Its basic syntax is as follows:

example

3.6 COALESCE() function
The COALESCE() function evaluates a list of expressions from left to right, searching for the first non-NULL value and returning it. If all the expressions are NULL, the function returns
NULL. Its basic syntax is as follows:

example

4.0 Datetime
These are functions used to handle date and time values and
perform operations like formatting, extraction, and manipulation.They include

4.1 CURRENT_DATE()
The CURRENT_DATE() function is used to retrieve the current date without the time component.

4.2 NOW()
The NOW() function is used to retrieve the current date and time from the system. It returns a datetime value representing the current timestamp.

4.3 DATEDIFF()
The DATEDIFF() function is used to calculate the difference between two dates. It takes three parameters: the part of the date for which to calculate the difference (day, month, or year), the start date, and the end date.

example

*4.4 DATE_ADD() *
The DATE_ADD() function is used to add a specified interval to a date or datetime value. It takes three parameters: a date or datetime to which the interval will be added, a value representing the interval you want to add, and an interval unit, which can be DAY, MONTH, or YEAR.

example

4.5 TO_DATE()
TO_DATE function evaluates a character string according to the date-formatting directive that you specify and returns a DATETIME value.

4.6 TO_CHAR
It converts a date, number, or other value into a text string.

I hope you read this article and continuously practice these functions because that is the only way you will master them.

SUBQUERIES AND CTEs

KENNEDY NDUNGU WANJIRU — Fri, 11 Sep 2026 19:17:41 +0000

There comes a time in the life of any SQL student when they find themselves writing queries in a certain way. Before this moment, they write their queries in a straight line, selecting this, joining that, grouping by the other. After this moment, they write queries like dragons: constructing a query from blocks, each one giving a small amount of data, naming it something understandable, and moving on. All the complex beasts of SQL that once terrified them are now simple littleizards that they can debug without fear. This moment comes when they learn about subqueries and Common Table Expressions (CTEs).

A subquery is simply a query nested within another query. A CTE is a named subquery, useful for organizing more complex SQL statements.

In this article, we will explore both, using each to solve the same problem in order to highlight their similarities and differences.

Subqueries serve many different purposes and can be used in the SELECT, FROM, WHERE, JOIN, and HAVING clauses.

1.Subqueries in SELECT

A subquery in the SELECT section of a query always has to return a scalar value.

2.Correlated subquery
A correlated subquery is a type of query that uses values from the outer query. The inner query executes, referencing these value(s), and returns the result to the outer query. This happens
row by row.

3. Subqueries in FROM/JOIN
ubqueries can be used in FROM and JOIN to create intermediate or derived tables, which can be queried again. This is particularly useful when we would like to use aggregated data along with
column data.
This is the syntax

example

4.Subqueries in WHERE/HAVING
Subqueries can be used in WHERE and HAVING to enable customized or advanced filtering of results.

Common Table Expressions
A Common Table Expression, or CTE, is a named query that exists within the context of a larger query. Its results are temporarily stored such that they can be referenced later by other queries, other CTEs, or even itself.
CTE syntax

Example

Multiple CTEs
It is possible to specify more than one CTE within a single query. In such a case, each CTE definition is separated by a comma.

SQL JOINS

KENNEDY NDUNGU WANJIRU — Fri, 11 Sep 2026 15:19:45 +0000

Think of your database as a city.

Your tables are the different buildings; the library, the hospital, the post office. Each has their own records, their own purpose, their own filing system.

A primary key is the address of the building, a foreign key is a note saying "see the hospital on 5th street" and a JOIN is the road that connects them.

Without these connecting roads, otherwise known as join clauses, your city is pretty much useless as each building is isolated. By joining two or more tables you can answer questions that required information from more than one table, like "which patients checked out medical books from the library?"

In structured query language (SQL), a join is used to join two or more tables in a relational database. As their name suggests, relational databases are ones that store data according to pre-defined relationships, which define how data that is stored in one table connects to that which is stored in another (or several others).

The join clause is used to retrieve data from related tables in a database. Because it retrieves data from multiple tables, the SQL join clause is much more complex than a simple query that retrieves data from just one.

TYPES OF SQL JOINS

1. Inner join

An inner join combines two tables by using a key. For instance, the key might be a column called “product id” where each user has a unique number. You could combine this table with another that contains information about each user by joining on the “product id” column. The following example uses an inner join clause to join two tables:In this example we are joining the drivers_trips table to safari.drivers on common column driver_id.

2. Left outer join
The left outer joins return all rows from the first table and only those rows from the second table that match,the tables are joined on a common column.Left outer join and Left join is one and the same thing .Here is an example of how to use the Left outer join clause to join two tables:

3. Right outer join
Right joins are logical opposites of left joins: they return all rows from the second table, and only the rows in the first table that match.Left outer join and Left join is one and the same thing,both of them can be used interchangeably. This example shows how to use a right outer join clause to join two tables:

4. Full outer join
Full joins combine both left and right joins, and return all rows from both tables, provided that both have at least one matching row. Here is an example of using the full outer join clause to join two tables:

To visually understand what is how join happens take a look at the following table.

Postgres commands

KENNEDY NDUNGU WANJIRU — Tue, 21 Jul 2026 11:04:33 +0000

These commands can be classified into group based on their nature
1.Data Definition Language - (DDL)
The commands include
CREATE,ALTER,DROP
2.Data Manipulation Language -(DML)
The commands include
INSERT,UPDATE,DELETE
3.Data Control Language - (DCL)
The commands include
GRANT,GRANT
4.Dta Query Language - (DQL)
The commands include
SELECT
We shall learn these commands through practice,first its important to create a Schema where most of our tables will reside.

Go ahead and set the path to schema.

Create a table with the following syntax.

create the following 2 tables.

INSERT INTO command is used to insert data into tables.When inserting data into a table its important to specify the columns
in chronological order.Make sure the data being inserted is presented in the correct way.Date,texts and phone_numbers should be in single quotes.Integers,decimals and percentages should not be in single quotes.

To confirm if the tables have data run the following commands.

It's evident that we have 3 tables exams_result,students and subjects table.

In the comment section(/* ...*/) of the data definition language
,there is a syntax showing how to write such a query.
Data definition language like alter table can be used to rename
a table,rename a column,change dat type,remove a column and add a column.

I have also outlined the syntax for the where clause in the comment section.The where clause can be used in a filtering context and combining logic.On combining logic we use different operators such as between,and,or,greater than,less than and eaqual to.

Count function can be used in different way.First to count the number of rows in the dataset with the following syntax SELECT COUNT(*) FROM table_name;.Second to count the number of values in a certain column with the following syntax SELECT COUNT(column_name) FROM table_name WHERE condition;

The CASE expression is used to define different results based on specified conditions in an SQL statement.
The CASE expression goes through the conditions and stops at the first match (like an if-then-else statement). So, once a condition is true, it will stop processing and return the result. If no conditions are true, it returns the value in the ELSE clause. If there is no ELSE clause and no conditions are true, it returns NULL.

JOINING DATABASES TO POWER BI

KENNEDY NDUNGU WANJIRU — Sat, 04 Jul 2026 12:43:24 +0000

Databases are like containers used to store data,the data may be structured, semi structured, or unstructured.The databases may be located on the local machines or on the cloud. In this article we shall discuss how to join databases to powerbi.
On our local machines we need to have a database management system like Dbeaver to manage all the activities happening on the database.
In Dbeaver , there is a ribbon with Database title.Click it, a drop down will appear and select a new connection.

Select your preferred database in this case we choose postgresql.

In the connection settings we are given the host,database,port,username but we have to input the password(The password should be the one we created when we were installing postgresql).

Proceed by clicking Test Connection ,if you are prompted to download database drivers click download.Once connection has been established click ok .

On the defaultdb create a database and and Schema with the following SQL commands.
CREATE database mytrial;
CREATE Schema Powerbi;

The database is empty and it's important to load data into the database.Hover the cursor on the Schema,right click it and import data.Click input files and then browse the file in your computer.Select the file you want in your computer and select open.The file will be loaded in your database.
To connect the database to powerbi open powerbi, click Get Data then more and select Database. On the Database tab select your preferred database e.g. postgresql.

On the Postgresql database tab there are server and database spaces and it's important to fill the spaces. On the server paste this ip 127.0.0.1 full colon and the port 5432.Type the database.
Type the username and the password.

Now we have connected database on our machines with power bi.
If the database is on the cloud we need to have a Saas subscription (Software as a service) platforn that gives us the password,host,ca certificate,port,username and password.

Once we have the above information open powerbi and select Get Data,select more and click Database.On the database tab click on Postgres.A small tab will appear titled Postgres database with database and server spaces.On the Saas platform copy host,port fullcolon and database.

Go ahead and type the username and password then click connect.
You will encounter "Unable to connect" error in powerbi.

On the Saas platform download ca certificate.

In your computer there is a start button,search Manage user certificate and select it.Select the Trusted Root Certification Authorities.Click on the greater than sign before Trusted Root Certification Authorities.Right click on certificates.A dropdown will appear,click on the greater sign on "All Task" an import table will appear select it.Click next then browse,select the ca certificate then open it.Click next and finish.Certificate import wizard will appear showing th import was successful.

On powerbi click the close button and open powerbi.

Select Get Data,select more and click Database.On the database tab click on Postgres.A small tab will appear titled Postgres database with database and server spaces.On the Saas platform copy host,port fullcolon and database.

Go ahead and type the username and password then click connect.

We have successfully connected database on aiven to powerbi

POWER BI

KENNEDY NDUNGU WANJIRU — Tue, 23 Jun 2026 06:30:40 +0000

Data modeling in Power bi is the process of structuring, organizing, and defining relationships between your data tables so they can be accurately analyzed and visualized.
There are different Schemas in data analysis; they are Star Schema and Snowflake Schema. Star Schema entails a fact table (central table) surrounded by many dimensional tables.Dimensional tables are joined to the central table using one to many relationship, many to one relationship or one to one. In one to many relationships one record can be attributed to many other records and vice versa . In one to one one record can be attributed to another record.This is possible by having primary key columns and foreign key columns..Furthermore, one is able to move from one table to another through a defined direction.

Snowflake Schema is built on Star Schema’s structure but the dimensional tables are joined to other subdimensional tables through table relationships.

In power bi there different types of joins they include

-Inner Join
This is where two tables are joined through a common column in both tables.
-Left Join
This is where the table on the left is joined to the table on the right through a common column.The empty cells in the left table will be joined to the right and they will be highlighted as NULL.
-Right Join
This is where the table on the right is joined to the table on the left through a common column.The empty cells in the right table will be joined to the left and they will be highlighted as NULL.
-full outer join
It joins both the tables from the left and right.

DEV Community: KENNEDY NDUNGU WANJIRU

A Pythonic Guide to Functions

Function definition

Function name

Function inputs

Function instructions/tasks

Return statement

Create the function

Call the function

Doc Strings

Scope

Local variable

Global variable

Function inputs

Types of inputs

No input

Default inputs

Variable inputs

Keyword arguments

Positional arguments/Non-keyword arguments

*args: Variable non-keyword arguments

**kwargs: Keyword arguments

Multiple return values

Mastering OOP in Python Without any Headache

The Art of Looping in Python

Syntax and structure

While loops

Loop controls

break statement

continue statement

pass statement

Teaching Python to Think: A Guide to Operators and Conditionals

Introduction: Teaching Python to Think

if, elif, and else

if statements

Nested if statements

if-else statements

elif statements

Chained conditional statements

Conditional statement keywords: not and pass

if not statements

pass statements

Python Basics

Variables. Data Types. Input/Output. Syntax.

Assigning a variable

Rules

Case types

Data types

WINDOW FUNCTIONS

POSTRESQL FUNCTIONS

SUBQUERIES AND CTEs

1.Subqueries in SELECT

SQL JOINS

1. Inner join

Postgres commands

JOINING DATABASES TO POWER BI

POWER BI

`break` statement

`continue` statement

`pass` statement

`if`, `elif`, and `else`

`if` statements

Nested `if` statements

`if`-`else` statements

`elif` statements

Conditional statement keywords: `not` and `pass`

`if` `not` statements

`pass` statements