DEV Community: Karthick (k)

List Comprehension in Python

Karthick (k) — Thu, 24 Sep 2026 12:51:07 +0000

List comprehension is a concise way to create new lists by applying an expression to each item in an existing iterable like a list, tuple or range. It helps to write clean, readable and efficient code compared to traditional loops.

Suppose you want to square every number in a list:

a = [2, 3, 4, 5]
res = [val ** 2 for val in a]
print(res)

Output

[4, 9, 16, 25]

Explanation: res = [val ** 2 for val in a] use **list comprehension **to create a new list by squaring each number in a.

Syntax

[expression for item in iterable if condition]

Parameters:

expression: operation or value to include in the new list.
item: current element from the iterable.
iterable: sequence like a list, tuple or range.
if condition (optional): filter to include only items that satisfy the condition.

Conditional Statements in List Comprehension

List comprehensions can use conditions to select or transform items based on specific rules. This allows creating customised lists more concisely and improves code readability and efficiency.

Example 1: This code uses a list comprehension with a condition to create a new list with only even numbers from list a.

a = [1, 2, 3, 4, 5]
res = [val for val in a if val % 2 == 0]
print(res)

Output

[2, 4]

Example 2: Here, list comprehension is used with a condition to create a new list with numbers greater than 10 from list b.

b = [5, 12, 7, 18, 3, 20]
res = [val for val in b if val > 10]
print(res)

Output

[12, 18, 20]

For Loop vs List Comprehension

For Loop

Uses multiple lines of code
Requires manual appending of elements
Better for complex logic and conditions
More readable for long operations

List Comprehension

Uses a single line of code.
Creates the list directly.
Better for simple and concise operations
More compact and faster to write

# 🐍 Python Functions: 13–19 — Scope, Arguments, Nested Functions & More

Karthick (k) — Wed, 23 Sep 2026 07:56:52 +0000

While learning Python functions, I came across several concepts that initially looked confusing. After practising them one by one, they became much easier to understand.

In this post, I’m sharing my notes and examples for:

Positional-only arguments
Keyword-only arguments
Variable scope
Local vs global variables
global
Nested functions
Returning multiple values
Functions as objects

1. Positional-Only Arguments `/`

Sometimes we want a function parameter to be passed only by position, not by its parameter name.

We can use / for this.

def student(name, age, /):
    print(name, age)

This works:

student("Karthick", 25)

But this does not:

student(name="Karthick", age=25)

Everything before / is positional-only.

Example

def calculate(a, b, /):
    return a + b

print(calculate(10, 20))

Output:

The / tells Python that a and b must be supplied positionally.

2. Keyword-Only Arguments `*`

We can also force parameters to be passed using their names.

For this, we use *.

def student(name, *, age):
    print(name, age)

This works:

student("Karthick", age=25)

But this does not:

student("Karthick", 25)

Everything after * is keyword-only.

Easy way to remember

/  → before / = positional-only

*  → after * = keyword-only

3. Variable Scope

Scope means where a variable can be accessed in a program.

For example:

def test():
    x = 10
    print(x)

test()

Here, x is available inside the function.

But:

print(x)

outside the function will cause an error because x belongs to the function's local scope.

4. Local vs Global Variables

Local Variable

A variable created inside a function is normally a local variable.

def test():
    x = 100
    print(x)

test()

Here, x is local to test().

Global Variable

A variable created outside a function is a global variable.

x = 50

def test():
    print(x)

test()

Output:

The function can access the global variable.

Easy rule

Created inside a function → Local variable

Created outside a function → Global variable

5. The `global` Keyword

What if we want to modify a global variable from inside a function?

We can use global.

x = 10

def change():
    global x
    x = 20

change()

print(x)

Output:

Without global, this:

def change():
    x = 20

would create a new local x instead of modifying the global one.

Important point

global x does not create a global variable.

It tells Python:

"Inside this function, I want to use the existing global x."

6. Nested Functions

A function defined inside another function is called a nested function.

def outer():

    def inner():
        print("Hello")

    inner()

outer()

Output:

Hello

Here:

outer()
   ↓
inner()
   ↓
Hello

The inner function can also access variables from the outer function.

def outer():
    name = "Karthick"

    def inner():
        print(name)

    inner()

outer()

Output:

Karthick

inner() doesn't have its own name, so it can access name from outer().

7. Functions Returning Multiple Values

A Python function can return multiple values.

def calculate(a, b):
    return a + b, a * b, a - b

We can store the returned values separately:

sum_value, product, difference = calculate(5, 2)

print(sum_value)
print(product)
print(difference)

Output:

7
10
3

Python actually packs the returned values into a tuple:

(7, 10, 3)

Then we unpack them:

(7, 10, 3)
 ↓   ↓   ↓
sum product difference

Important rule

The number of variables should match the number of values being unpacked.

For example:

def test():
    return 10, 20, 30

a, b, c = test()

This works.

But:

a, b = test()

causes an error because there are 3 returned values but only 2 variables.

8. Functions as Objects

One of the interesting things about Python is that functions are objects.

Consider:

def greet():
    return "Hello"

We can assign the function to another variable:

x = greet

Notice that there are no parentheses.

Now x refers to the same function.

So we can do:

print(x())

Output:

Hello

Important difference

x = greet

means:

x refers to the function itself.

Whereas:

x = greet()

means:

Call the function and store its returned value in x.

For example:

def square(n):
    return n * n

operation = square

result = operation(5)

print(result)

Output:

The flow is:

square
  ↓
function object
  ↓
operation = square
  ↓
operation(5)
  ↓
square(5)
  ↓
25

This is the foundation for passing functions to other functions.

I'm continuing my Python function learning with the next concept: passing functions to other functions.

Master Python Lists: The Only Guide You'll Ever Need 🐍

Karthick (k) — Tue, 22 Sep 2026 16:02:17 +0000

Whether you are just starting your Python journey or brushing up on your core data structures, Python lists are something you will use every single day. They are versatile, powerful, and packed with built-in features.

In this quick guide, we will cover everything from the absolute basics to some advanced tricks that will make your code cleaner and faster. Let’s dive in! 🚀

1. What is a Python List?

In Python, a list is a built-in, mutable (changeable), and ordered collection of items.

Unlike arrays in some other languages, Python lists can hold a mixture of different data types at the same time—integers, strings, floats, and even other lists!

# A simple list of strings
fruits = ["apple", "banana", "cherry"]

# A list with mixed data types
mixed_bag = [42, "Python", True, 3.14]

2. Navigating Lists: Indexing & Slicing 🗺️

Python uses zero-based indexing, meaning the first item is always at index 0. You can also use negative indexing to look at items starting from the back of the list.

Slicing Syntax: `list[start:stop:step]`

Slicing lets you extract a specific chunk of your list. Keep in mind that the stop index is exclusive (not included in the result).

numbers = [10, 20, 30, 40, 50]

print(numbers[0])   # Output: 10
print(numbers[-1])  # Output: 50 (the last item)

# Get items from index 1 up to (but not including) 4
print(numbers[1:4]) # Output: [20, 30, 40]

# Reverse a list using slicing step trick
print(numbers[::-1]) # Output: [50, 40, 30, 20, 10]

3. Essential List Methods Cheat Sheet 🛠️

Because lists are mutable, you can add, remove, and modify items on the fly. Here are the heavy hitters you need to memorize:

append(x): Adds an item to the end of the list.
insert(i, x): Inserts an item x at a specific index i.
extend(iterable): Appends all items from another list/iterable.
remove(x): Removes the first occurrence of value x.
pop(i): Removes and returns the item at index i (defaults to the last item if i is left blank).

tech_stack = ["Python", "JavaScript"]

tech_stack.append("Rust")      # ['Python', 'JavaScript', 'Rust']
tech_stack.insert(1, "HTML")   # ['Python', 'HTML', 'JavaScript', 'Rust']
tech_stack.pop()               # Removes 'Rust'

4. Next-Level Trick: List Comprehensions ⚡

If you want to write Pythonic code, you have to learn list comprehensions. They give you a short, elegant way to create new lists based on existing ones.

Instead of writing a bulky for loop like this:

squares = []
for x in range(1, 6):
    squares.append(x**2)
# Result: [1, 4, 9, 16, 25]

You can do it all in a single line:

squares = [x**2 for x in range(1, 6)]
# Result: [1, 4, 9, 16, 25]

Wrap Up 🎁

Python lists are incredibly dynamic. Master these fundamentals, play around with list comprehensions, and you will find handling data in Python becomes a breeze.

What is your favourite Python list trick? Do you prefer slicing or built-in methods? Let me know in the comments below! 👇

Pattern Problem

Karthick (k) — Mon, 21 Sep 2026 05:15:50 +0000

n=5; Here are the outputs for each of the 6 patterns provided in your blog. You can run each code snippet to see the respective output.

Pattern 1

n=5;

for i in range(n):
    for j in range(n):
        print("*",end=" ");
    print()

Output:

* * * * * 
* * * * * 
* * * * * 
* * * * * 
* * * * *

Pattern 2

n=5;

for i in range(n):
    for j in range(i+1):
        print("*",end=" ");
    print()

Output:

* 
* * 
* * * 
* * * * 
* * * * *

Pattern 3

n=5;

for i in range(1,n+1):
    for j in range(1,i+1):
        print(j,end=" ")
    print()

Output:

Pattern 4

n=5;

for i in range(1,n+1):
    for j in range(1,i+1):
        print(i,end=" ")
    print()

Output:

Pattern 5

n=5;

for i in range(n):
    for j in range(n-i):
        print("*",end=" ");
    print()

Output:

* * * * * 
* * * * 
* * * 
* * 
*

Pattern 6

n=5;

for i in range(n):
    for j in range(1,n-i+1):
        print(j,end=' ');
    print()

Output:

Feel free to copy and paste these code snippets into your Python environment to see the results yourself!

for i in range(n):
for j in range(1,n-i+1):
print(j,end=' ');
print()

React Interview Prep: Breaking Down the Core Fundamentals

Karthick (k) — Sun, 20 Sep 2026 15:34:29 +0000

Mastering technical interviews isn't about cramming the night before—it's about building a consistent daily habit. As part of my daily 75-minute interview prep routine, I break down core React concepts into concise, high-impact answers.

Here is Part 1 of the core React concepts every developer should master for technical rounds.

1. What is React?

15-Second Answer:

"React is an open-source, component-based JavaScript library used for building fast, interactive user interfaces. It uses a Virtual DOM to optimise rendering by updating only the specific parts of the real DOM that change."

Key Interview Points

View Layer ($V$ in MVC): React only handles the UI layer, giving developers full flexibility over routing and state tools.
Declarative UI: You describe what the UI should look like for a given state, and React handles the DOM updates.

2. Library vs. Framework

15-Second Answer:

"The core difference is Inversion of Control. A framework dictates your architecture and calls your code, whereas a library like React gives you full control—you call it only when you need it."

Quick Comparison

Framework (e.g., Angular, Next.js): "Don't call us, we'll call you." It provides a pre-defined blueprint and architecture.
Library (e.g., React Core): A set of specialised tools focused strictly on rendering UI.

3. Virtual DOM & Reconciliation

15-Second Answer:

"The Virtual DOM is an in-memory representation of the real DOM. When state changes, React creates a new Virtual DOM tree, compares it with the previous one using a diffing algorithm, and patches only the changed nodes in the real DOM."

Reconciliation Workflow

Price Range Slider with Min-Max Input using HTML, CSS and JavaScript

Karthick (k) — Sat, 19 Sep 2026 01:42:25 +0000

Here, we implement a Price Range Slider using HTML, CSS, and JavaScript. Users can select their desired price range by moving the slider or by manually entering minimum and maximum values. JavaScript is used to synchronise inputs and add interactivity.

HTML structures the slider and input fields.
CSS styles the slider for a clean, user-friendly UI.
JavaScript handles price updates and user interactions.

Index.html

<html>
    <head>
        <link rel="stylesheet" href="style.css">
    </head>
    <body>
        <div class="main">
            <div class="gfg">
                <p>GeeksForGeeks</p>
            </div>
            <div class="customer-wrapper">
                <div class="header">
                    <h1 class="protitle">Price Range Slider</h1>
                </div>
                <div class="price-input-container">
                    <div class="price-input">
                        <div class="price-field">
                            <span>Minimum Price</span>
                            <input type="number" class="min-input" value="2500">
                        </div>
                        <div class="price-field">
                            <span>Maximum Price</span>
                            <input type="number" class="max-input" value="8500">
                        </div>
                    </div>
                    <div class="slider">
                        <div class="price-slider"></div>
                    </div>
                </div>
                <div class="range-input">
                    <input type="range" class="min-range" min="0" max="10000" value="2500" step="1">
                    <input type="range" class="max-range" min="0" max="10000" value="8500" step="1">
                </div>
            </div>
        </div>
        <script src="script.js"></script>
    </body>
</html>

Style.css

*{
    margin: 0;
    padding:0;
}

body{
    display: flex;
    align-items: center;
    justify-content:center;
    min-height:100vh;
    background:#ffffff;
    flex-direction:column;
}

.main{
    background-color:#fff;
    border-radius:15px;
    box-shadow: 0 0 20px rgba(0, 0, 0, 0.2);
    padding:20px;
    transition:transform 0.2s;
    width:600px;
    box-sizing: border-box;
}

.main:hover{
    transform:scale(1.05);
}

.gfg{
    display: flex;
    align-items:center;
    justify-content:center;
    font-size:24px;
    font-weight:600;
    color:#01940b;
}

.customer-wrapper{
    margin: 0;
    width: 100%;
    padding: 0px 25px 40px;
    position:relative;
    box-sizing: border-box;
}
.header h1{
    font-size:30px; 
    color: #01940b;
    display:flex;
    justify-content: center;
    padding: 20px;
}

.price-input-container{
    width:100%;
}
.price-input .price-field{
    display:flex;
    margin-bottom:22px;
}

.price-field span{
    margin-right:10px;
    margin-top:6px;
    font-size:17px;
}

.price-field input{
    flex:1;
    height: 35px;
    font-size:15px;
    font-family: "DM Sans", sans-serif;
    border-radius:9px;
    text-align: center;
    border:0px;
    background:#e4e4e4;
}

.price-input{
    width:100%;
    font-size:19px;
    color:#555;
}

/* Remove Arrows/Spinners */
input::-webkit-outer-spin-button,
input::-webkit-inner-spin-button {
    -webkit-appearance: none;
    margin: 0;
}

.slider{
    width:100%;
}

.slider{
    height: 6px;
    position:relative;
    background:#e4e4e4;
    border-radius: 5px;

}

.slider .price-slider{
    height:100%;
    left:25%;
    right:15%;
    position: absolute;
    border-radius:5px;
    background:#01940b;
}

.range-input{
    position:relative;
}
.range-input input{
    position:absolute;
    width:100%;
    height:5px;
    background:none;
    top:-5px;
    pointer-events: none;
    cursor:pointer;
    -webkit-appearance: none;
    appearance: none;

}

input[type="range"]::-webkit-slider-thumb{
    height:18px;
    width:18px;
    border-radius:70%;
    background:#555;
    pointer-events:auto;
    -webkit-appearance:none;
}
@media screen and (max-width: 768px) {
    .main {
        width: 90%;
        margin-right: 5px;
    }

    .customer-wrapper {
        width: 100%;
        left: 0;
        padding: 0 10px;
    }

    .protitle {
        width: 100%;
        position: relative;

    }

    .price-input {
        display:flex;
        flex-direction: column;
        align-items: center;
    }

    .price-field {
        margin-bottom: 10px;
    }
}

Script.js

// Script.js
const rangevalue = document.querySelector(".slider .price-slider");
const rangeInputvalue = document.querySelectorAll(".range-input input");

// Set the price gap
let priceGap = 500;

// Adding event listeners to price input elements
const priceInputvalue = document.querySelectorAll(".price-input input");
for (let i = 0; i < priceInputvalue.length; i++) {
    priceInputvalue[i].addEventListener("input", e => {

        // Parse min and max values of the range input
        let minp = parseInt(priceInputvalue[0].value);
        let maxp = parseInt(priceInputvalue[1].value);
        let diff = maxp - minp

        if (minp < 0) {
            alert("minimum price cannot be less than 0");
            priceInputvalue[0].value = 0;
            minp = 0;
        }

        // Validate the input values
        if (maxp > 8000) {
            alert("maximum price cannot be greater than 10000");
            priceInputvalue[1].value = 10000;
            maxp = 10000;
        }

        if (minp > maxp - priceGap) {
            priceInputvalue[0].value = maxp - priceGap;
            minp = maxp - priceGap;

            if (minp < 0) {
                priceInputvalue[0].value = 0;
                minp = 0;
            }
        }

        // Check if the price gap is met and max price is within the range
        if (diff >= priceGap && maxp <= rangeInputvalue[1].max) {
            if (e.target.className === "min-input") {
                rangeInputvalue[0].value = minp;
                let value1 = rangeInputvalue[0].max;
                rangevalue.style.left = `${(minp / value1) * 100}%`;
            }
            else {
                rangeInputvalue[1].value = maxp;
                let value2 = rangeInputvalue[1].max;
                rangevalue.style.right = `${100 - (maxp / value2) * 100}%`;
            }
        }
    });

    // Add event listeners to range input elements
    for (let i = 0; i < rangeInputvalue.length; i++) {
        rangeInputvalue[i].addEventListener("input", e => {
            let minVal = parseInt(rangeInputvalue[0].value);
            let maxVal = parseInt(rangeInputvalue[1].value);

            let diff = maxVal - minVal

            // Check if the price gap is exceeded
            if (diff < priceGap) {

                // Check if the input is the min range input
                if (e.target.className === "min-range") {
                    rangeInputvalue[0].value = maxVal - priceGap;
                }
                else {
                    rangeInputvalue[1].value = minVal + priceGap;
                }
            }
            else {

                // Update price inputs and range progress
                priceInputvalue[0].value = minVal;
                priceInputvalue[1].value = maxVal;
                rangevalue. style.left = `${(minVal / rangeInputvalue[0].max) * 100}%`;
                rangevalue. style.right = `${100 - (maxVal / rangeInputvalue[1].max) * 100}%`;
            }
        });
    }
}

Output

Exciting Announcement: Kicking Off My New Python Project!

Karthick (k) — Fri, 18 Sep 2026 17:09:06 +0000

Hello Team and Dev Community,

I’m thrilled to share that I’m starting a new Python development project! As I wrap up the system design and architecture, I can't wait to dive deeper into the implementation phase.

In this project, I aim to leverage the latest technologies and best practices to create something truly innovative. I’m currently finalizing the user stories and synchronising our objectives, and I’m open to any feedback or suggestions you might have.

I’ll be posting regular updates on my progress on dev.to, so stay tuned for insights and lessons learned along the way. Let’s collaborate and share knowledge as we embark on this journey together!In the future, I will update you soon about the idea and all of us.

Looking forward to your thoughts and support!

What is a callback function, and how do you use it for asynchronous operations in JavaScript?

Karthick (k) — Thu, 17 Sep 2026 08:43:31 +0000

In this brief overview, we'll cover what a callback function is and how Node.js uses it to handle asynchronous operations. We’ll start with a straightforward definition and then explore its practical applications through examples.

Callback functions are functions that you pass as an argument to another function to be executed after some operation is completed. In the context of Node.js, they are particularly useful for managing non-blocking I/O operations, ensuring your application remains responsive without waiting for these operations to complete.

To understand this better, let's first define a basic callback and see how it works in practice.

// Example of a simple callback function
function asyncOperation(callback) {
  setTimeout(() => {
    console.log('Async operation completed');
    // Call the callback when done
    callback();
  }, 2000);
}

asyncOperation(() => {
  console.log('Callback executed after 2 seconds');
});

What is the arguments object in a regular function, and why is it unavailable in arrow functions?

Karthick (k) — Wed, 16 Sep 2026 17:09:23 +0000

The arguments object in JavaScript allows you to access all the arguments passed to a function as an array-like object. This feature is particularly useful when dealing with older or more complex functions where you might not know how many arguments will be passed at runtime. However, this object is unavailable in arrow functions due to their lexical scoping nature.

Let's break down the key points and discuss why the arguments object works differently between regular functions and arrow functions.

Code

// Example of using `arguments` in a regular function
function sum() {
    let total = 0;
    for (let i = 0; i < arguments.length; i++) {
        total += arguments[i];
    }
    return total;
}
console.log(sum(1, 2, 3)); // Output: 6

// Attempting to use `arguments` in an arrow function will result in an error
const sumArrow = (...args) => {
    let total = 0;
    for (let i = 0; i < arguments.length; i++) { // This line causes an error
        total += arguments[i];
    }
    return total;
};

Flowchart

Exploring Python Functions: A Comprehensive Guide

Karthick (k) — Tue, 15 Sep 2026 11:01:24 +0000

A function in Python is a block of code that enables a specific task to be performed multiple times within a program without needing to rewrite the code. This approach helps reduce code duplication, enhances readability and organisation, breaks a program into smaller, manageable sections, and simplifies debugging and testing.

Defining a Function

Python functions are defined using the def keyword, followed by the function name and parentheses.

# Define a function
def hello():
  print("Hello, world!")

# Call the function
hello()

In this example, the hello() function prints the given message to the console.

Here is the output:

Hello, world!

Defining a Function with Parameters

A Python function can be defined with parameters, which help in passing data to the function.

def hello(name):
    print(f'hello, {name}')


hello("Karthick")

Here is the output:

hello, Karthick

Note: Function names in Python are written in snake_case.

Returning Values from a Function

In Python, a value can be returned from a function in two ways.

Using the return keyword
Using the yield keyword

Returning Values Using return

The return keyword returns a value from a Python function. You can then store the returned value in a variable and use it in the program.

def check_leap_year(year):
    if year%4==0:
        return str(year) + " is a leap year!"
    else:
        return str(year) + " is not a leap year!"

year_to_check=2020;

return_values=check_leap_year(year_to_check);

print(return_values)

Here is the output:

2020 is a leap year!

Returning Values Using yield

A function can also return values with the yield keyword, like a ** return ** statement. Unlike return, the yield statement retains the state of the function and will resume where it left off on the next function call (i.e., execution resumes after the last yield statement). This way, the function can produce a number of values over time.

# Function to produce infinite Fibonacci numbers
def fibonacci():
  # Generate first number
  a = 1
  yield a

  # Generate second number
  b = 2
  yield b

  # Infinite loop
  while True:
    # Return sum of a + b
    c = a + b
    yield c

    # Function resumes loop here on next call
    a = b
    b = c

# Iterate through the Fibonacci sequence until a limit is reached
for num in fibonacci():
  if num > 50:
    break

  print(num)

Here is the output:

1 2 3 5 8 13 21 34
Frequently Asked Questions

What’s the difference between a parameter and an argument in a Python function?
What happens if you call a function before defining it?
What is a default parameter in a Python function?

What specific aspect of React would you like to know more about? Whether it's components, state management, hooks, or something else, I'm here to help!

Karthick (k) — Mon, 14 Sep 2026 19:10:58 +0000

A custom hook in React is a function that encapsulates state logic, side effects, or any other functionality and returns values or functions to be used within your component's lifecycle. Custom hooks allow you to extract complex behaviour from components, making them more reusable and easier to reason about.

For example, you can create a custom hook called useFetchData that fetches data from an API and stores it in localStorage. This hook can be reused across multiple components, reducing code duplication and improving maintainability.

Here's a basic implementation of such a custom hook:

import { useState, useEffect } from 'react';

function useFetchData(url) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const fetchData = async () => {
      try {
        const response = await fetch(url);
        const result = await response.json();
        setData(result);
        localStorage.setItem('fetchedData', JSON.stringify(result));
      } catch (err) {
        setError(err);
      } finally {
        setLoading(false);
      }
    };

    fetchData();
  }, [url]);

  return { data, loading, error };
}

export default useFetchData;

Working with Strings in Python 3

Karthick (k) — Thu, 10 Sep 2026 17:18:55 +0000

Creating a String
Strings can be created using single quotes, double quotes, or even triple quotes. Python treats single quotes the same as double quotes.

# creating string
# with single Quotes
String = 'Hello Geek'
print("Creating string with single quotes :", String)

# Creating String
# with double Quotes
String = "yes, I am Geek"
print("Creating String with double quotes :", String)

# Creating String
# with triple Quotes
String = ''' yes, I am Geek'''
print("Creating String with triple quotes :", String)

Output

Creating string with single quotes: Hello Geek
Creating String with double quotes: yes, I am Geek
Creating String with triple quotes yes, I am Geek

String Indexing
Strings are a sequence of characters, which means Python can use indexes to call parts of the sequence. There are two ways of indexing.

Positive Indexing
Negative Indexing

# creating a string
String = "GEEK"

# Show first element in string
print("The 1st element is : ", String[0])

# Show 2nd element in string
print("The 2nd element is : ", String[1])

print("The 3rd element is : ", String[2])
print("The 4th element is : ", String[3])

Output

The 1st element is: G
The 2nd element is E
The 3rd element is: E
The 4th element is: K

Negative indexing

# creating a string
String = "GEEK"

# Show last element in string
print("The 4th element is : ", String[-1])

# Show all elements in string
print("The 3rd element is : ", String[-2])

print("The 2nd element is : ", String[-3])
print("The 1th element is : ", String[-4])

Output

The 4th element is : K
The 3rd element is : E
The 2nd element is : E
The 1th element is : G

DEV Community: Karthick (k)

List Comprehension in Python

# 🐍 Python Functions: 13–19 — Scope, Arguments, Nested Functions & More

1. Positional-Only Arguments /

Example

2. Keyword-Only Arguments *

Easy way to remember

3. Variable Scope

4. Local vs Global Variables

Local Variable

Global Variable

Easy rule

5. The global Keyword

Important point

6. Nested Functions

7. Functions Returning Multiple Values

Important rule

8. Functions as Objects

Important difference

Master Python Lists: The Only Guide You'll Ever Need 🐍

1. What is a Python List?

2. Navigating Lists: Indexing & Slicing 🗺️

Slicing Syntax: list[start:stop:step]

3. Essential List Methods Cheat Sheet 🛠️

4. Next-Level Trick: List Comprehensions ⚡

Wrap Up 🎁

Pattern Problem

Pattern 1

Pattern 2

Pattern 3

Pattern 4

Pattern 5

Pattern 6

React Interview Prep: Breaking Down the Core Fundamentals

1. What is React?

Key Interview Points

2. Library vs. Framework

Quick Comparison

3. Virtual DOM & Reconciliation

Reconciliation Workflow

Price Range Slider with Min-Max Input using HTML, CSS and JavaScript

Exciting Announcement: Kicking Off My New Python Project!

What is a callback function, and how do you use it for asynchronous operations in JavaScript?

What is the arguments object in a regular function, and why is it unavailable in arrow functions?

Exploring Python Functions: A Comprehensive Guide

What specific aspect of React would you like to know more about? Whether it's components, state management, hooks, or something else, I'm here to help!

Working with Strings in Python 3

1. Positional-Only Arguments `/`

2. Keyword-Only Arguments `*`

5. The `global` Keyword

Slicing Syntax: `list[start:stop:step]`