Solution: सही विकल्प : (D) All of the mentioned
EXPLANATION:
Python में:
in
operator का उपयोग यह check करने के लिए किया जाता है कि कोई item किसी collection में मौजूद है या नहीं।
यह operator कई data structures पर कार्य करता है जैसे:
List
Dictionary
Set
इसलिए सही उत्तर होगा:
All of the mentioned
1. Using “in” with List:
lst = [10,20,30]
20 in lst
Output:
True
क्योंकि 20 list में मौजूद है।
2. Using “in” with Dictionary:
Dictionary में:
in
operator keys को check करता है।
d = {"a":1, "b":2}
"a" in d
Output:
True
लेकिन:
1 in d
Output होगा:
False
क्योंकि यह values नहीं, keys check करता है।
3. Using “in” with Set:
s = {1,2,3}
2 in s
Output:
True
Other Options:
(A) Lists – valid।
(B) Dictionary – valid।
(C) Set – valid।
(D) All of the mentioned – सही उत्तर।
Important Uses of “in” Operator:
Membership Testing
→ Item present है या नहीं check करता है।
Conditional Statements
→ if condition में उपयोग होता है।
Loops and Searching
→ Collections में search करने के लिए।
Related Operator:
not in
→ Item मौजूद नहीं है या नहीं check करता है।
Example:
5 not in [1,2,3]
Output:
True
इसलिए सही उत्तर:
(D) All of the mentioned

Solution: सही विकल्प : (D) None of the above
EXPLANATION:
दिए गए सभी statements Python data types के बारे में सही हैं।
इसलिए कोई भी statement false नहीं है।
अतः सही उत्तर होगा:
(D) None of the above
Option (A):
In python, explicit data type conversion is possible
यह statement सही है।
Python में explicit type conversion किया जा सकता है।
इसे:
Type Casting
भी कहा जाता है।
Example:
x = "10"
y = int(x)
अब:
y = 10
और type integer हो जाएगी।
Option (B):
Mutable data types are those that can be changed
यह statement भी सही है।
Mutable objects की values modify की जा सकती हैं।
Examples of Mutable Data Types:
List
Dictionary
Set
Example:
lst = [1,2,3]
lst[0] = 10
अब list बदल जाएगी।
Option (C):
Immutable data types are those that cannot be changed
यह statement भी सही है।
Immutable objects create होने के बाद modify नहीं किए जा सकते।
Examples of Immutable Data Types:
int
float
tuple
string
Example:
s = "Python"
String के individual characters modify नहीं किए जा सकते।
Why Option (D) is Correct?
क्योंकि:
(A), (B), और (C)
तीनों statements सही हैं।
इसलिए कोई false statement नहीं है।
Important Concepts:
Mutable Types
→ Change possible
Immutable Types
→ Change not possible
Explicit Conversion
→ Programmer manually type convert करता है।
Implicit Conversion
→ Python automatically conversion करता है।
Example of Implicit Conversion:
5 + 2.5
Output:
7.5
यहाँ integer automatically float में convert हुआ।
इसलिए सही उत्तर:
(D) None of the above

Solution: सही विकल्प : (C) type()
EXPLANATION:
Python में किसी variable का data type जानने के लिए:
type()
function का उपयोग किया जाता है।
यह function variable या object का datatype return करता है।
Syntax:
type(variable_name)
Example 1:
x = 10
print(type(x))
Output:
<class 'int'>
Example 2:
y = "Python"
print(type(y))
Output:
<class 'str'>
Example 3:
z = [1,2,3]
print(type(z))
Output:
<class 'list'>
Other Options:
(A) datatype() – Python में ऐसा built-in function नहीं है।
(B) typeof() – यह JavaScript में उपयोग होता है, Python में नहीं।
(C) type() – सही उत्तर।
(D) vartype() – Python में ऐसा function नहीं है।
Common Python Data Types:
int
→ Integer numbers
float
→ Decimal numbers
str
→ Strings/Text
list
→ Ordered mutable collection
tuple
→ Ordered immutable collection
dict
→ Key-value pairs
set
→ Unordered unique elements
Important Point:
Python एक:
Dynamically Typed Language
है।
इसलिए variable का datatype automatically decide होता है।
Example:
a = 5
a = "Hello"
Python में यह valid है क्योंकि datatype runtime पर बदल सकता है।
इसलिए सही उत्तर:
(C) type()

Solution: सही विकल्प : (D) set()
EXPLANATION:
Python में empty set बनाने के लिए:
set()
का उपयोग किया जाता है।
Example:
s = set()
print(type(s))
Output:
<class 'set'>
Important Point:
यदि Python में:
{}
लिखा जाए, तो वह:
Empty Dictionary
create करता है, empty set नहीं।
इसलिए empty set बनाने के लिए हमेशा:
set()
का उपयोग करना आवश्यक है।
Other Options:
(A) [] – Empty List बनाता है।
(B) {} – Empty Dictionary बनाता है।
(C) () – Empty Tuple बनाता है।
(D) set() – सही उत्तर, empty set बनाता है।
Examples of Different Data Structures:
[]
→ List
{}
→ Dictionary
()
→ Tuple
set()
→ Set
Example:
a = []
b = {}
c = ()
d = set()
Properties of Set:
Unordered
→ Elements fixed order में नहीं रहते।
Unique Elements
→ Duplicate values allowed नहीं हैं।
Mutable
→ Elements add/remove किए जा सकते हैं।
Example:
s = {1,2,2,3}
print(s)
Output:
{1,2,3}
क्योंकि duplicate value automatically remove हो जाती है।
इसलिए सही उत्तर:
(D) set()

Solution: सही विकल्प : (B) {1,2,3,4}
EXPLANATION:
दिया गया expression है:
set([1,1,2,3,4,2,3,4])
Python में:
set()
का उपयोग unique elements का collection बनाने के लिए किया जाता है।
Set में:
Duplicate Values
allow नहीं होतीं।
इसलिए duplicate elements automatically remove हो जाते हैं।
Given List:
[1,1,2,3,4,2,3,4]
इसमें duplicates हैं:
1, 2, 3, 4
Set बनने के बाद केवल unique values बचेंगी:
{1,2,3,4}
अतः output होगा:
{1,2,3,4}
Step-by-Step:
Input List:
[1,1,2,3,4,2,3,4]
After set conversion:
{1,2,3,4}
Other Options:
(A) [1,1,2,3,4,2,3,4] – यह original list है।
(B) {1,2,3,4} – सही उत्तर।
(C) {1,1,2,3,4,2,3,4} – set duplicates store नहीं करता।
(D) Invalid Syntax – syntax बिल्कुल valid है।
Important Properties of Set:
Unique Elements
→ Duplicate values automatically remove होती हैं।
Unordered
→ Elements fixed order में नहीं रहते।
Mutable
→ Elements add/remove किए जा सकते हैं।
Example:
s = set([1,2,2,3])
print(s)
Output:
{1,2,3}
Important Note:
Set का output order different हो सकता है क्योंकि set unordered collection है।
लेकिन elements unique ही होंगे।
इसलिए सही उत्तर:
(B) {1,2,3,4}

Solution: सही विकल्प : (C) Dictionary
EXPLANATION:
Python में:
Dictionary
data type का उपयोग:
Key & Value
format में data store करने के लिए किया जाता है।
Dictionary में प्रत्येक value एक unique key से जुड़ी होती है।
Syntax:
dict_name = {key:value}
Example:
student = {
"name":"Rahul",
"age":20,
"marks":85
}
यहाँ:
"name", "age", "marks"
keys हैं और:
"Rahul", 20, 85
उनकी values हैं।
Accessing Values:
student["name"]
Output:
Rahul
Important Properties of Dictionary:
Key-Value Pair Storage
→ Data pair format में store होता है।
Mutable
→ Values modify की जा सकती हैं।
Keys Unique होती हैं
→ Duplicate keys allowed नहीं हैं।
Unordered Collection
→ Traditional concept में unordered माना जाता है।
Other Options:
(A) List – Ordered collection है, key-value format नहीं।
(B) Tuple – Immutable ordered collection।
(C) Dictionary – सही उत्तर।
(D) Set – Unique unordered elements store करता है।
Examples of Other Data Types:
List:
[1,2,3]
Tuple:
(1,2,3)
Set:
{1,2,3}
Dictionary:
{"a":1,"b":2}
Real-life Example of Dictionary:
Phone Book
→ Name = Key
→ Phone Number = Value
इसलिए सही उत्तर:
(C) Dictionary

Solution: सही विकल्प : (B) first, second
EXPLANATION:
दिया गया Python statement है:
abc = {"first":10, "second":20}
यह एक:
Dictionary
है।
Dictionary में data:
Key : Value
format में store होता है।
इस statement में:
"first"
और:
"second"
keys हैं।
जबकि:
10
और:
20
उनकी corresponding values हैं।
Dictionary Representation:
Key      Value
first     10
second   20
Accessing Values:
abc["first"]
Output:
10
abc["second"]
Output:
20
Other Options:
(A) 10, 20 – ये values हैं, keys नहीं।
(B) first, second – सही उत्तर।
(C) first, 10, second, 20 – इसमें keys और values दोनों शामिल हैं।
(D) first, 20 – एक key और एक value दी गई है।
Important Properties of Dictionary:
Keys Unique होती हैं
→ Duplicate keys allowed नहीं हैं।
Values Duplicate हो सकती हैं
→ Same value multiple keys के साथ हो सकती है।
Mutable
→ Dictionary modify की जा सकती है।
Example:
student = {"name":"Aman","age":21}
यहाँ:
"name", "age"
keys हैं।
"Aman", 21
values हैं।
इसलिए सही उत्तर:
(B) first, second

Solution: सही विकल्प : (B) The keys of a dictionary can be accessed using values
EXPLANATION:
Python Dictionary में data:
Key : Value
format में store होता है।
Dictionary में values को:
Keys
की सहायता से access किया जाता है।
लेकिन:
Values की सहायता से Keys
को directly access नहीं किया जा सकता।
इसलिए option:
(B)
false statement है।
Example:
student = {"name":"Rahul","age":20}
यहाँ:
"name", "age"
keys हैं।
"Rahul", 20
values हैं।
Correct Access:
student["name"]
Output:
Rahul
Other Options:
(A) Values can be accessed using keys – सही statement।
(B) Keys can be accessed using values – गलत statement, सही उत्तर।
(C) Dictionaries aren't ordered – traditional MCQ concept के अनुसार सही।
(D) Dictionaries are mutable – सही statement।
Important Properties of Dictionary:
Mutable
→ Data change किया जा सकता है।
Keys Unique होती हैं
→ Duplicate keys allowed नहीं हैं।
Values Duplicate हो सकती हैं
→ Same value multiple keys के साथ हो सकती है।
इसलिए सही उत्तर:
(B) The keys of a dictionary can be accessed using values

Solution: सही विकल्प : (D) Class
EXPLANATION:
Python के core data types में शामिल हैं:
• List
• Tuple
• Dictionary
• Set
• String
लेकिन:
Class
एक user-defined blueprint होता है, core data type नहीं।
Example:
x = [1,2,3] → List
y = (1,2,3) → Tuple
z = {"a":1} → Dictionary
जबकि:
class Student: pass
एक class declaration है।
निष्कर्ष:
Class core data type नहीं है। इसलिए सही उत्तर (D) है।

Solution: सही विकल्प : (A) [1,3,5]
EXPLANATION:
दिया गया code है:
arr = [1,2,3,4,5,6]

print(arr[::2])
यहाँ:
Slicing
का उपयोग किया गया है।
Slicing Syntax:
list[start : stop : step]
इस expression में:
arr[::2]
का अर्थ है:
Start → Beginning से
Stop → End तक
Step → 2
अर्थात list का हर दूसरा element print होगा।
Array Elements:
Index   Value
0        1
1        2
2        3
3        4
4        5
5        6
अब step size 2 होने के कारण selected elements होंगे:
1, 3, 5
अतः output होगा:
[1,3,5]
Other Options:
(A) [1,3,5] – सही उत्तर।
(B) [2,4,6] – यह odd indexes के elements हैं।
(C) [1,2] – incorrect slicing result।
(D) [5,6] – last elements हैं।
Important Slicing Examples:
arr[1:4]
→ [2,3,4]
arr[::-1]
→ Reverse List
arr[::2]
→ Alternate elements
arr[1::2]
→ Odd index elements
Important Point:
Python slicing में:
Start Index
default रूप से 0 होता है।
Stop Index
default रूप से list का अंत होता है।
इसलिए सही उत्तर:
(A) [1,3,5]