How to Python Important things for 2026?

How to take two separate inputs in Python using a single line of code, but treating them as if entered on two separate lines?

n, m = int(input()), input().split()

In this code:

• n takes the first input as an integer (int(input())).

• m takes the second input as a space-separated list of strings (input().split()), where the split() method splits the input into individual components based on spaces.

Even though both inputs are on the same line of code, this effectively simulates two separate inputs, as m is treated as a list (from the space-separated input) and n as an integer.

Alternatively, the code could be split into two lines as:

n = int(input()) 
m = input().split()

Here, n is assigned the integer value from the first input, and m is assigned the space-separated values from the second input, treated as a list of strings.

How to consider the non-negative number?

If element or number is greater than or equal to  zero that  means its non-negative

cause reale number

num <=0

5<=0

 e.g. 4 is bigger than 0 

4,5,8,9, all whole and real number if bigger than the 0

How to iterate set() items?

s = {1,2,3,4,5}

or

s = set(1,2,3,4,5,6,) 

or

s = set(map(int(input("Enter space separated element:").split()))

#Using for loop

for item in s:

print(item)

or

for x in s:

print(x)

How to sum entire set() of digits or set() or using sum()?

s = {1,2,3,4,5}

print(sum(s))

How to bound set() input size with single line?

n = int(input("Enter set size:"))

s =  set(map(int, input("Enter elements to  set:").split()[:n]))

Why Does Converting a String to a Set in Python Give Unique Characters?

s = "Hackeer"

print(set(s))

print(set("Hacker"))

{'c', 'H', 'k', 'r', 'a', 'e'}

{'c', 'H', 'k', 'r', 'a', 'e'}

because set eliminated duplicate items it gives use each things as character

This phrasing focuses on the behavior of set() when applied to a string, explaining why each character appears only once in the output set, even if it repeats in the original string.

How Set() union works with string?

s1 = set("Hacker")

s2 = set("Human")

print(s1|s2)

{'c', 'u', 'H', 'k', 'n', 'r', 'a', 'e', 'm'}

In Python, when you use the set() function with strings, it treats each character as an individual element. A set automatically removes duplicate characters, so only unique characters are kept.

s1 = set("Hacker")
s2 = set("Human")
print(s1 | s2)

• set("Hacker") creates the set {'H', 'a', 'c', 'k', 'e', 'r'}.

• set("Human") creates the set {'H', 'u', 'm', 'a', 'n'}.

The | operator performs a union of the two sets, combining all unique elements from both. The result is:

{'c', 'u', 'H', 'k', 'n', 'r', 'a', 'e', 'm'}

In the union, all characters from both sets are included, and duplicates (like 'H' and 'a') are removed.

Why Does {} Treat the Whole String as One Element, While set() Breaks It into Characters in Python?

Under-the-Hood Answer:

When you use curly braces {} in Python, it's creating a set literal. A set literal can hold any kind of object, and if you pass a string directly to it, Python adds the entire string as one single element in the set. So, { "Hacker" } creates a set with the whole string as one element.

Example:

s2 = {"Hacker"}
print(s2)

Output:

{'Hacker'}

On the other hand, when you pass a string to set(), Python iterates through each character in the string, creating a set of those individual characters. It breaks the string into individual components before adding them to the set, and duplicates are automatically removed.

Example:

s = "Hackeer"
print(set(s))

Output:

{'H', 'a', 'c', 'k', 'e', 'r'}

Behind the scenes, it’s about intent.

Curly Braces {} (Set Literal): Python sees { "Hacker" } as a direct command. 
It takes the object as a single unit, calculates hash("Hacker"), 
and places it in one bucket. It doesn't "look inside" because you didn't tell it to.

Set Function set(): This is a constructor that expects an iterable. 
It internally runs a C-level loop (a for loop). 
It grabs each character individually ('H', then 'a', etc.), 
calculates a separate hash for each character, 
and places them into multiple buckets.

The Rule: Literals hash the item; the function hashes the contents.

Key Difference:

• Curly braces {} create a set where the entire string is one single element.

• set() treats the string as a sequence of characters, breaking it down into individual elements and removing duplicates.

So, the behavior differs because {} is designed for creating sets with specific objects (like the string as a whole), while set() is a built-in function that turns any iterable (like a string) into a set of its individual elements.

How to use Map() and lambda together?

lam = lambda x,y : x+y*2

print(lam(2,5))

#12

mapped = map(lambda function, iterables)

list(mapped)

num = [2,4,8,5]

multiply = list(map(lambda x:x*2, num))

print(multiply)

#[4, 8, 16, 10]

sum = list(map(lambda x:x+2, num))

print(sum)

#[4, 6, 10, 7]

#Complex