DEV Community: Francis kinyuru

Rate limiting with bucket4j, redis, Postgres in SpringBoot

Francis kinyuru — Wed, 26 Jul 2023 09:42:23 +0000

Redis rate limiting using Bucket4j, redis, postgres in springboot

Key Objective:

What specific API will be limited? This could be a single API endpoint, or a group of related endpoints.
How will the username be used to identify requests? This could be done by including the username in the request header or in the request body, or by using a token-based authentication system.
What is the custom TPS for each user? This is the maximum number of requests that each user will be allowed to make per second.
What will happen if a user exceeds their TPS limit? This could result in the request being rejected, or the user being temporarily banned from making requests.

Why Bucket4j

There are many reasons why you might use Bucket4j for rate limiting. Here are a few of the most important ones:

It is a mature and well-tested library. Bucket4j has been around for many years and has been used by a large number of projects. This means that it is a reliable and stable library that you can be confident in using.
It is easy to use. Bucket4j has a simple and straightforward API that makes it easy to implement rate limiting in your code. You don't need to be an expert in rate limiting to get started with Bucket4j.
It is flexible. Bucket4j allows you to configure rate limits in a variety of ways. You can specify the number of requests per second, minute, hour, or day. You can also specify burst limits, which allow for a certain number of requests to be made above the regular limit in a short period of time.
It is efficient. Bucket4j is a very efficient library. It uses a token bucket algorithm to track requests, which is a very efficient way to do rate limiting. This means that Bucket4j will not have a significant impact on the performance of your application.

Overall, Bucket4j is a great choice for rate limiting in Java. It is a mature, well-tested, easy-to-use, flexible, and efficient library.

Here are some additional benefits of using Bucket4j:

It can protect your API from DDoS attacks. By limiting the number of requests that can be made to your API, you can make it more difficult for attackers to overwhelm your server with requests.
It can ensure fair resource allocation. By limiting the number of requests that each client can make, you can ensure that all clients have fair access to your API's resources.
It can improve the performance of your API. By limiting the number of requests that can be made, you can reduce the load on your server, which can improve the performance of your API.

If you are looking for a rate limiting library for your Java application, I highly recommend Bucket4j. It is a great choice for protecting your API from DDoS attacks, ensuring fair resource allocation, and improving the performance of your API.

Lets get now to the actual implementation now on spring boot.

Below are the dependencies required for the implementation.

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.redisson/redisson-spring-boot-starter -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.23.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.giffing.bucket4j.spring.boot.starter/bucket4j-spring-boot-starter -->
        <dependency>
            <groupId>com.giffing.bucket4j.spring.boot.starter</groupId>
            <artifactId>bucket4j-spring-boot-starter</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

The implementation is maven based and using java 17 for the implementation.

Configuration under the config package

RedisConfig

package Rateimiting.config;

import com.giffing.bucket4j.spring.boot.starter.config.cache.SyncCacheResolver;
import com.giffing.bucket4j.spring.boot.starter.config.cache.jcache.JCacheCacheResolver;
import io.github.bucket4j.distributed.proxy.ProxyManager;
import io.github.bucket4j.grid.jcache.JCacheProxyManager;
import org.redisson.config.Config;
import org.redisson.jcache.configuration.RedissonConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.cache.CacheManager;
import javax.cache.Caching;

@Configuration
public class RedisConfig {

    @Bean
    public Config config(){
        Config config=new Config();
        config.useSingleServer().setAddress("redis://localhost:6379");
        return config;
    }
    @Bean
    public CacheManager cacheManager(Config config){
        CacheManager manager = Caching.getCachingProvider().getCacheManager();
        manager.createCache("cache", RedissonConfiguration.fromConfig(config));
        return manager;
    }
    @Bean
    ProxyManager<String> proxyManager(CacheManager cacheManager){
        return new JCacheProxyManager<>(cacheManager.getCache("cache"));
    }

    @Bean
    @Primary
    public SyncCacheResolver bucket4jCacheResolver(CacheManager cacheManager){
        return new JCacheCacheResolver(cacheManager);
    }
}

Config bean

This bean creates a configuration object for Redis. This object specifies the address of the Redis server

CacheManager bean

This bean creates a cache manager that uses Redis as its backing store. This cache manager will be used to store the rate limits.

ProxyManager bean

This bean creates a proxy manager that can be used to access the rate limits in the cache. This proxy manager makes it easy to use the rate limits in your code.

SyncCacheResolver Bean

This bean creates a cache resolver that uses the cache manager to resolve the rate limits. This cache resolver is used by Bucket4j to determine the current rate limit for a given request.

@primary annotation:

This annotation indicates that this is the default cache resolver that should be used by Bucket4j.

RateLimitConfig

package Rateimiting.config;

import io.github.bucket4j.Bandwidth;
import io.github.bucket4j.Bucket;
import io.github.bucket4j.BucketConfiguration;
import io.github.bucket4j.Refill;
import io.github.bucket4j.distributed.proxy.ProxyManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import java.time.Duration;
import java.util.function.Supplier;

@Configuration
public class RateLimitConfig {
    @Autowired
    public ProxyManager buckets;

    public Bucket resolveBucket(String key,int tps){
        Supplier<BucketConfiguration> configurationSupplier = getConfigSupplier(key,tps);
        return buckets.builder().build(key,configurationSupplier);
    }
    private Supplier<BucketConfiguration> getConfigSupplier(String key, int tps){
        Refill refill=Refill.intervally(tps, Duration.ofSeconds(1));
        Bandwidth limit=Bandwidth.classic(tps,refill);

        return () -> (BucketConfiguration.builder()
                .addLimit(limit)
                .build());
    }
}

resolveBucket() method:

This method takes two parameters: the key of the bucket and the number of requests per second (TPS) that the bucket should allow. The method first calls the getConfigSupplier() method to get a supplier of BucketConfiguration objects. The method then uses the supplier of BucketConfiguration objects to create a Bucket object. The Bucket object is used to rate limit requests.

getConfigSupplier() method:

This method creates a BucketConfiguration object that specifies the rate limit for the bucket. The rate limit is specified by the Bandwidth object. The Bandwidth object specifies the number of requests that the bucket can allow per second, and the refill rate. The refill rate specifies how often the bucket is refilled with tokens.

In my model package

model->request

package Rateimiting.model.request;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Request {
    private String username;
    private String Message;
}

This represents the sample request body i expect from a post request.

model Apiresponse

package Rateimiting.model;

import lombok.*;

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class ApiResponse {
    private String message;
    private String responseCode;
    private String status;
}

The expected api response

model TpsDb

package Rateimiting.model;

import jakarta.persistence.*;
import lombok.Data;

import java.io.Serializable;
import java.sql.Timestamp;

@Data
@Table(name="tbl_tps")
@Entity
public class TpsDb  implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    private String username;
    private String path;
    private int tps;
}

This represents the tables for where the tps details are stored in the DB.

Repository

package Rateimiting.repository;

import Rateimiting.model.TpsDb;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface TpsDbRepository extends JpaRepository<TpsDb, Long> {
    TpsDb findByUsernameAndPath(String username, String path);
}

Added the query tps details my username and path for post request.

Service

package Rateimiting.service;

import Rateimiting.config.RateLimitConfig;
import Rateimiting.model.ApiResponse;
import Rateimiting.model.TpsDb;
import Rateimiting.model.request.Request;
import Rateimiting.repository.TpsDbRepository;
import io.github.bucket4j.Bucket;
import org.redisson.api.RMapCache;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

@Service
public class RateLimitService {
    int tps;
    @Autowired
    private RedissonClient redissonClient;
    private final TpsDbRepository tpsD;

    private final RateLimitConfig rateLimitConfig;
    @Autowired
    public RateLimitService(TpsDbRepository tpsD, RateLimitConfig rateLimitConfig) {
        this.tpsD = tpsD;
        this.rateLimitConfig = rateLimitConfig;
    }

    public ResponseEntity<?> addInfo(Request request, String path) {
        String username = request.getUsername();
        // Check if the TpsDb is cached in Redis
        RMapCache<String, TpsDb> cache = redissonClient.getMapCache("tpsDbCache");
        TpsDb tpsDb = cache.get(username + "-" + path);

        if (tpsDb == null) {
            tpsDb = tpsD.findByUsernameAndPath(path, username);

            if (tpsDb == null) {
                tpsDb = new TpsDb();
                tpsDb.setUsername(username);
                tpsDb.setPath(path);
                tpsDb.setTps(10); // Default TPS value if not found in the database
            }
            cache.put(username + "-" + path, tpsDb);
        }


        int tps = tpsDb.getTps();
        Bucket bucket = rateLimitConfig.resolveBucket(username, tps);
        if (bucket.tryConsume(1)) {
            return ResponseEntity.status(200).body(new ApiResponse("Request Success for user " + username, "4000", "success"));
        } else {
            return ResponseEntity.status(429).body(new ApiResponse("Request failed for user " + username, "4003", "failed"));
        }
    }
}

addInfo() method:

This method takes a request object and a path as input and returns a response indicating whether the request was successful or not. The method first checks if the TpsDb object is cached in Redis. If the TpsDb object is not cached, the method retrieves it from the database. If the TpsDb object is not found in the database, the method creates a new TpsDb object with the default TPS value. The method then creates a Bucket object using the user ID and the TPS value from the TpsDb object. The Bucket object is used to rate limit the request. If the request is successful, the method returns a 200 status code and a success message. Otherwise, the method returns a 429 status code and an error message.

Finally,

Controller.

To create test post request

package Rateimiting.controller;

import Rateimiting.model.request.Request;
import Rateimiting.service.RateLimitService;
import jakarta.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.HandlerMapping;

@RestController
@RequestMapping("/v1/")
public class RateLimitController {
    @Autowired
    private HttpServletRequest requests;

    private final RateLimitService rateLimitService;
    @Autowired
    public RateLimitController(RateLimitService rateLimitService) {
        this.rateLimitService = rateLimitService;
    }

    @PostMapping("/rate")
    public ResponseEntity<?> addInfo(@RequestBody Request request){
        String uri = requests.getRequestURI();
        String path = (String) requests.getAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE);
    return rateLimitService.addInfo(request, path);
    }
}

@PostMapping("/rate") annotation:

This annotation marks the addInfo() method as a POST endpoint that can be used to add a new request to the rate limiting system.

@RequestBody Request request parameter:

This parameter specifies that the addInfo() method takes a request object as input.

String uri = requests.getRequestURI() statement:

This statement gets the URI of the request. The URI is used to get the path of the resource being requested.

String path = (String) requests.getAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE) statement:

This statement gets the path of the resource being requested from the HandlerMapping object.
return rateLimitService.addInfo(request, path); statement: This statement calls the addInfo() method on the RateLimitService class to add the request to the rate limiting system.

application.properties

spring.sql.init.platform=postgresql
spring.datasource.url=jdbc:postgresql://localhost:5432/dbname
spring.datasource.username=username
spring.datasource.password=password
spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
# Keep the connection alive if idle for a long time (needed in production)
spring.datasource.testWhileIdle=true
spring.jpa.hibernate.ddl-auto=update

You can access the code on my git repo here

USSD 101 with Africastalking

Francis kinyuru — Sun, 15 May 2022 15:41:27 +0000

What is USSD

USSD (Unstructured Supplementary Service Data) is a communications protocol used in GSM networks for sending short text messages. USSD is similar in format to SMS. However, it is an instant messaging service, so messages are not stored on the operator side or on the subscriber's device.

Simple Code with Africastalking ENV

Ussd with Africastalking demo code

<?php
#sessionId from the Post request
$sessionId=$_POST['sessionId'];
#serviceCode from the Post request
$serviceCode=$_POST['serviceCode'];
# phoneNumber from the Post request
$phoneNumber=$_POST['phoneNumber'];
# text from the Post request
$text=$_POST['text'];

if ($text == ""){
 # check is the first connection is empty and provice response stating with CON to indicate connection.
 $response="CON What would you want to check \n";
 $response .="1. My Account No \n";
 $response .="2. My phone Number";
}
# if you choose option 1
else if ($text == "1") {
 # business login for the first level response
 $response = "CON Choose account information you want to view \n";
 $response .= "1. Account Number \n";
 $response .= "2. Account Balance";
}
# if you choose option 2
else if ($text == "2") {
 # business login for the first level response with END t end the connection
 $response = "END You phone number is ".$phoneNumber;
# if you choose option 1 the second level supplied option 1
} else if($text == "1*1"){
# business login for the second i.e.*ussd*1*1# level response then END to end the Session
 $accountNumber = "ACC1001";

 $response = "END Your account Number is ".$accountNumber;
}
# if you choose option 1 the second level supplied option 2
else if ($text == "1*2") {
# business login for the second i.e.*ussd*1*1# level response then END to end the Session
 $balance = "KES 10,000";
 # code...
 $response= "END Your balance is ".$balance;
}
# include the Header
header('Content-type: text/plain');
# display the response
echo $response;

?>

Deploy the code on heroku my endpoint https://ussd-uat.herokuapp.com/index.php

Go to africastalking create account and then navigate to USSD code and create channel as below.

You will be provided with the details to simulate the USSD.

Then click Launch Simulator as below

Input you test number and click connect as below

Go ahead and test the USSD code

All done now you should have a display as below

Code on github Francis Kinyurufranciskinyuru

Credits to
Africastalking developers platform Developers platform
Francis Kagai youtube tutorial Francis Kagai

Python for everyone: Mastering Python the Right Way

Francis kinyuru — Tue, 01 Mar 2022 13:22:02 +0000

What is Python?

Python is a computer programming language often used to build websites and software, automate tasks, and conduct data analysis. Python is a general-purpose language, meaning it can be used to create a variety of different programs and isn't specialized for any specific problems.

Why is python popular?
The python language is one of the most accessible programming languages available because it has simplified syntax and not complicated, which gives more emphasis on natural language. Due to its ease of learning and usage, python codes can be easily written and executed much faster than other programming languages.

What is the application areas of python?

Web and Internet Development
Python has many uses for web development including

Django and Pyramid Frameworks for complex web apps
Flask and Bottle micro-framework for light applications

Scientific and Numeric
Widely used in scientific and numeric computing.
This is in the fields of mathematics and Data science
Popular libraries like scikit learn, pandas, NLTK, NumPy, SciPy used in data anaylis, machine-learning, AI, NLP and much more

Education
Used for teaching programming both fundamentals and advanced levels.

Software development
Used as a support language for software development, testing and build control

Best ways to learn python.

1. Figure out why you need to learn python.
This acts as a driving force to what you need to achieve and setting the goals you want to achieve after running python.
Pick an area you are interested in such as :

Data science / Machine learning
Mobile apps
Websites
Games
Data processing and analysis
Hardware / Sensors / Robots
Scripts to automate your work Select one or two areas that interests you and which will eventually help in building projects with them.

2. Learn the basic Syntax.
This is key to any programming language. You have to understand the basic syntax to be able to come up with structured and more complex projects.

3. Come up with structured projects
This will help you apply knowledge you have learned and aids in opening you mind and digging deep to complex projects and will greatly help in your learning.

4. More practice and more projects
Involve yourself in more projects and do more practice to master the concepts

Python installation and best practices

Python Installation
Check the python documentation for installation on the various platforms Python Documentation
Best practices
Also visit they python docs for best practice when writing you python code DOCS

All the best in your python career. Happy Coding!!!💯

Introduction to Data Structures and Algorithms With Python

Francis kinyuru — Mon, 21 Feb 2022 13:00:47 +0000

What is Data Structures?

This are containers that organize and group data according to type.
Data Structures allows you to organize your data in such a way that enables you to store collections of data, relate them and perform operations on them accordingly.

What are Algorithms?
An algorithm is a set of instructions for solving a problem or accomplishing a task.

Types of Data Structures
In-built
Python has implicit support for Data Structures which enable you to store and access data. These structures are called List, Dictionary, Tuple and Set.
User-defined
Python allows its users to create their own Data Structures enabling them to have full control over their functionality. The most prominent Data Structures are Stack, Queue, Tree, Linked List,Hashmap,Graph etc.

Built-in Data Structures

List Lists are used to store data of different data types in a sequential manner. There are addresses assigned to every element of the list, which is called an Index. The index value starts from 0 and goes on until the last element called the positive index. There is also negative indexing which starts from -1 enabling you to access elements from the last to first element.

Creating a list
To create a list, you use the square brackets and add elements into it accordingly.
If you dont pass any element in the list you get an empty list.

myList = [] # create empty list
print(myList)
myList = [1,3,"john"] #creating list with data
print(myList)

Output

[]
[1, 3, 'john']

Adding Elements.
Adding elements can be achieved by append(),insert(),extend() functions.

myList = [1,3,"john"]
print(myList)
myList.append(4) #add as a single element
print(myList)
myList.extend([10, 'more_example']) #add as different elements
print(myList)
myList.insert(3, 'insert_example') #add element i given position 
print(myList)

Ouput

[1, 3, 'john']
[1, 3, 'john', 4]
[1, 3, 'john', 4, 10, 'more_example']
[1, 3, 'john', 'insert_example', 4, 10, 'more_example']

Deleting Elements

If you want to delete an items to the list you can user del keyword, pop() or remove() functions.

myList=[1, 3, 'insert_example', 4, 10, 'more_example']
del myList[2] #delete element at index 2
print(myList)
myList.remove('more_example') #remove element with value
print(myList)
a = myList.pop(1) #pop element from list
print('Popped Element: ', a, ' List remaining: ', myList)
myList.clear() #empty the list
print(myList)

Output

[1, 3, 'john', 'insert_example', 4, 10, 'more_example']
[1, 3, 4, 10, 'more_example']
[1, 3, 4, 10]
Popped Element: 3 List remaining: [1, 4, 10]
[]

Accessing Elements
To access the values you pass the index of the values.

myList = [1, 2, 3, 'john', 10, 15]
for element in myList: #access elements one by one
    print(element)
print(myList) #access all elements
print(myList[4]) #access index 4 element
print(myList[0:2]) #access elements from 0 to 1 and exclude 2
print(myList[::-1]) #access elements in reverse

Ouput

1
2
3
john
10
15
[1, 2, 3, 'john', 10, 15]
10
[1, 2]
[15, 10, 'john', 3, 2, 1]

We other list functions which includes :-
The len() function returns to us the length of the list.
The index() function finds the index value of value passed where it has been encountered the first time.
The count() function finds the count of the value passed to it.
The sorted() and sort() functions do the same thing, that is to sort the values of the list. The sorted() has a return type whereas the sort() modifies the original list.

Dictionary
Dictionaries are used to store key-value pairs.

Creating a dictionary
Dictionaries can be created using the calledbrackets or using the dict() function.

myDict = {}  # empty dictionary
print(myDict)
myDict = {"key": "value", 1: "kenya", 2: "uganda"}  # with values
print(myDict)

output

{}
{'key': 'value', 1: 'kenya', 2: 'uganda'}

Changing and Adding key, value pairs
To change the values of the dictionary, you need to do that using the keys. So, you firstly access the key and then change the value accordingly. To add values, you simply just add another key-value pair as shown below.

myDict = {"key": "value", 1: "kenya", 2: "uganda"}  # with values
print(myDict)
myDict[1] = " Nigeria"  # access the key and give new  value
print(myDict)
myDict[3] = "Niger"  # adding a new key value pair
print(myDict)

output

{'key': 'value', 1: 'kenya', 2: 'uganda'}
{'key': 'value', 1: ' Nigeria', 2: 'uganda'}
{'key': 'value', 1: ' Nigeria', 2: 'uganda', 3: 'Niger'}

Deleting key, value pairs

To delete the values, you use the pop() function which returns the value that has been deleted.
To retrieve the key-value pair, you use the popitem() function which returns a tuple of the key and value.
To clear the entire dictionary, you use the clear() function.

myDict = {'key': 'value', 1: ' Nigeria', 2: 'uganda', 3: 'Niger'}
x = myDict.pop(3)  # pop element
print(x)
print(myDict)
y = myDict.popitem()  # empty dictionary
print(y)
print(myDict)
myDict.clear()
print(myDict)

Output

{'key': 'value', 1: ' Nigeria', 2: 'uganda', 3: 'Niger'}
Niger
{'key': 'value', 1: ' Nigeria', 2: 'uganda'}
(2, 'uganda')
{'key': 'value', 1: ' Nigeria'}
{}

Accessing Elements
You can access elements using the keys only. You can use either the get() function or just pass the key values and you will be retrieving the values.

myDict = {'key': 'value', 1: ' Nigeria', 2: 'uganda', 3: 'Niger'}
print(myDict[1])  # access elements using keys
print(myDict.get(3))  # access using get()

output

Nigeria
Niger

More functions
Other Functions
You have different functions which return keys(), values(), items().

myDict = {'key': 'value', 1: ' Nigeria', 2: 'uganda', 3: 'Niger'}
print(myDict.keys())  # get keys
print(myDict.values())  # get values
print(myDict.items())  # get key-value pairs

output

dict_keys(['key', 1, 2, 3])
dict_values(['value', ' Nigeria', 'uganda', 'Niger'])
dict_items([('key', 'value'), (1, ' Nigeria'), (2, 'uganda'), (3, 'Niger')])

Tuple
Tuples are the same as lists are with the exception that the data once entered into the tuple cannot be changed no matter what. The only exception is when the data inside the tuple is mutable, only then the tuple data can be changed

Creating a Tuple
You create a tuple using parenthesis or using the tuple() function.

myTuple = (1, 2, 3) #create tuple
print(myTuple)

output

(1, 2, 3)

Accessing Elements
Accessing elements is the same as it is for accessing values in lists.

myTuple = (1, 2, 3,5)
for x in myTuple:
    print(x)
print(myTuple)
print(myTuple[0])
print(myTuple[:])

output

1
2
3
5
(1, 2, 3, 5)
1
(1, 2, 3, 5)

Appending Elements
To append the values, you use the ‘+’ operator which will take another tuple to be appended to it.

myTuple = (1, 2, 3,5)
myTuple=myTuple + (101,102,104,"now")
print(myTuple)

Output

(1, 2, 3, 5, 101, 102, 104, 'now')

Sets
Sets are a collection of unordered elements that are unique. Meaning that even if the data is repeated more than one time, it would be entered into the set only once.

Creating a set
Sets are created using the Calledbrackets but instead of adding key-value pairs, you just pass values to it.

mySet={1,4,5,7,8,8,9,1,1}
print(mySet)

output

{1, 4, 5, 7, 8, 9}

Adding elements
To add elements, you use the add() function and pass the value to it.

mySet={1,4,5,7,8,8,9,1,1}
mySet.add("string ")
print(mySet)

output

{1, 4, 5, 7, 8, 9, 'string '}

Operations in sets
The different operations on set such as union, intersection and so on are shown below.

mySet = {1, 2, 3, 4}
mySet_2 = {3, 4, 5, 6}
print(mySet.union(mySet_2), '==', mySet | mySet_2) 
# union() function combines the data present in both sets.
print(mySet.intersection(mySet_2), '==', mySet & mySet_2) 
# intersection() function finds the data present in both sets only
print(mySet.difference(mySet_2), '==', mySet - mySet_2)  
# difference() function deletes the data present in both and outputs data present only in the set passed.
print(mySet.symmetric_difference(mySet_2), '==', mySet ^ mySet_2) # symmetric_difference() does the same as the difference() function but outputs the data which is remaining in both sets.
mySet.clear()
print(mySet)

output

{1, 2, 3, 4, 5, 6} == {1, 2, 3, 4, 5, 6}
{3, 4} == {3, 4}
{1, 2} == {1, 2}
{1, 2, 5, 6} == {1, 2, 5, 6}
set()

User-Defined Data Structures

Queue
A queue is a linear data structure which is based on the principle of First-In-First-Out (FIFO) where the data entered first will be accessed first. It is built using the array structure and has operations which can be performed from both ends of the Queue, that is, head-tail or front-back. Operations such as adding and deleting elements are called En-Queue and De-Queue and accessing the elements can be performed. Queues are used as Network Buffers for traffic congestion management, used in Operating Systems for Job Scheduling and many more.

Stack
Stacks are linear Data Structures which are based on the principle of Last-In-First-Out (LIFO) where data which is entered last will be the first to get accessed. It is built using the array structure and has operations namely, pushing (adding) elements, popping (deleting) elements and accessing elements only from one point in the stack called as the TOP. This TOP is the pointer to the current position of the stack. Stacks are prominently used in applications such as Recursive Programming, reversing words, undo mechanisms in word editors and more other applications.

Linked List
Linked lists are linear Data Structures which are not stored consequently but are linked with each other using pointers. The node of a linked list is composed of data and a pointer called next. These structures are most widely used in image viewing applications, music player applications.

Graph
Graphs are used to store data collection of points called vertices (nodes) and edges (edges). Graphs can be called as the most accurate representation of a real-world map. They are used to find the various cost-to-distance between the various data points called as the nodes and hence find the least path. Many applications such as Google Maps, Uber, and many more use Graphs to find the least distance and increase profits in the best ways.

Python 101:Introduction to Modern Python

Francis kinyuru — Sat, 12 Feb 2022 08:41:13 +0000

What is python?
Python is an interpreted, general-language, high-level programming language invented by Guido van Rossum and was conceived in the late 1980s and released in 1991.

Python is easy to read and write
This is because since its syntax emphasizes readability thus easy and simple to read and write.

Lets see what makes it simple.

Sample helloworld.

In PHP
<?php echo "Hello World!"; ?>
Above is a three line code in Php.

Lets see same code in Python.
print("Hello World!")
3 lines of code in PHP to one line of Code in python.

Lets check how to install python in different environments

Python installation steps

1. Visit https://www.python.org/downloads/
2. Select your Operating system(Windows,Linux/UNIX,MacOS,Other
3. Select the release or version, click on it to download.
Double click on the file to execute and install. -- For window mark “add to system paths” An alternative way to install python on Linux is to run sudo apt install python3 or sudo apt install python on the terminal. For more check on the python Documentationfor more documentations.

Lets now test our installation

Open Terminal on Linux or cmd on windows
Run the python --version command to check if you installed the correct version. If python is installed you will se something similar to below

C:\Users\Florida>python --version
Python 3.10.2

Lets now start learning python.
On your terminal type Python hit enter and then type print("Hello Your_name!")

python
print("hello your_name!")

See below expected output. Remember to use your name after hello

We have different Platforms where you can start writing your codes on. Including Visual Studio code, Pycharm, Sublime-text and much more. Select a platform where you are best suited of and lets continue learning python.

Lets see how Variables are declared also need to check on best practises guidelines on PEP 8 -- Style Guide for Python Code

Variables-are containers for storing data values.

Python has no command for declaring a variable.
A variable is created the moment you first assign a value to it

Here i will be using pycharm to write my sample code.
I have created a file example.py

Have declared 2 variables as below.

a = "I" b = 10 print(a) print(b)
See below expected output

Also you don't need to declare type.

a ="I" is of type str
a =10 is of type int

If you need to know the type you just do as below

print(type(a))

Output

<class 'int'>

Casting
This is done if you want to specify the data type of your variable.

a = int(10)

Case sensitive

Note Variable names are case sensitive

a = 10
A = "John"
a cannot overwrite A since python is case sensitive

Let now check the type of variables:

Local variables
Global Variables

Local Variables:
This are variables declared inside a function and without global keyword.

def myfunc():
a="Francis"
This variables are accessed inside but not outside the function.

Global Variables:

This are variables created outside of a function and can be used by everyone, both inside of functions and outside.

a = "Kenya"
 def myfunc():
   print("I live in " + a)
myfunc()

Output

I live in Kenya

You can also create a global variable using global keyword

def myfunc():
    global a
    a = "kenya"

myfunc()
print(a)

Hope this guide gives you an Introduction to Python 101 .

Let me know your thoughts in the comment section 👇

Like, share and follow me 🚀 for more content.