Python ऑनलाइन कंपाइलर (Interpreter) - तुरंत Python कोड चलाएँ और निष्पादित करें

1. वेरिएबल्स और कॉन्स्टेंट्स घोषित करना

पायथन डायनामिकली टाइप्ड है, इसलिए आपको प्रकारों को स्पष्ट रूप से घोषित करने की आवश्यकता नहीं है। कोई बिल्ट-इन कॉन्स्टेंट कीवर्ड नहीं है, लेकिन परंपरा से, कॉन्स्टेंट्स को सभी अक्षरों में लिखा जाता है।

# वेरिएबल्स
x = 10
pi = 3.14
name = "Alice"
is_active = True

# कॉन्स्टेंट्स (परंपरा से)
MAX_USERS = 100
APP_NAME = "CodeUtility"

# कॉन्स्टेंट्स को फिर से असाइन किया जा सकता है (अनिवार्य नहीं)
MAX_USERS = 200  # ⚠️ तकनीकी रूप से अनुमति है, लेकिन हतोत्साहित किया जाता है

2. कंडीशनल्स

if, elif, और else ब्लॉक्स के साथ नियंत्रण लॉजिक। पायथन 3.10+ में, आप match-case का उपयोग स्विच-केस विकल्प के रूप में कर सकते हैं।

# पारंपरिक if-elif-else
x = 2
if x == 1:
    print("One")
elif x == 2:
    print("Two")
else:
    print("Other")

वैकल्पिक: match-case (पायथन 3.10+)

# पायथन 3.10+ की आवश्यकता है
x = 2
match x:
    case 1:
        print("One")
    case 2:
        print("Two")
    case _:
        print("Other")

3. लूप्स

for का उपयोग अनुक्रमों पर इटरेट करने के लिए किया जाता है, while तब तक चलता है जब तक कि कोई शर्त सही है।

for i in range(3):
    print(i)

count = 3
while count > 0:
    print(count)
    count -= 1

4. सूचियाँ

सूचियाँ क्रमबद्ध, परिवर्तनीय संग्रह हैं। आप तत्वों को इंडेक्स द्वारा एक्सेस कर सकते हैं।

fruits = ["apple", "banana"]
print(fruits[0])
print(len(fruits))

5. सूची हेरफेर

सूचियों को जोड़ें, हटाएं, स्लाइस करें, और उल्टा करें। सूची समग्रता कॉम्पैक्ट इटरेशन की अनुमति देती है।

fruits.append("cherry")
fruits.insert(1, "kiwi")
fruits.remove("banana")
fruits.pop()

print(fruits[1:3])
print(fruits[::-1])

squares = [x*x for x in range(5)]

6. कंसोल इनपुट/आउटपुट

input() का उपयोग उपयोगकर्ताओं से पढ़ने के लिए और print() का उपयोग आउटपुट प्रदर्शित करने के लिए करें।

आप \n (न्यूलाइन कैरेक्टर) का उपयोग करके या print() को कई बार कॉल करके कई पंक्तियाँ प्रिंट कर सकते हैं।

# इनपुट पढ़ें
name = input("अपना नाम दर्ज करें: ")
print("नमस्ते", name)

# कई पंक्तियाँ प्रिंट करें
print("पंक्ति 1\nपंक्ति 2\nपंक्ति 3")

# या कई प्रिंट स्टेटमेंट्स का उपयोग करें
print("पंक्ति A")
print("पंक्ति B")
print("पंक्ति C")

7. फंक्शन्स

फंक्शन्स कोड को व्यवस्थित करने और पुन: उपयोग की अनुमति देते हैं। पैरामीटर्स और रिटर्न वैल्यूज़ का उपयोग करें।

def greet(name):
    return "नमस्ते " + name

print(greet("Alice"))

8. डिक्शनरीज़

कुंजी-मूल्य जोड़े संग्रहीत करें। कुंजियाँ अद्वितीय होती हैं और मूल्यों को कुंजियों के माध्यम से एक्सेस किया जा सकता है।

person = {"name": "Bob", "age": 25}
print(person["name"])
print(person.get("email", "प्रदान नहीं किया गया"))

9. अपवाद प्रबंधन

try और except का उपयोग करके त्रुटियों को पकड़ें और उन्हें सुचारू रूप से संभालें।

try:
    x = 1 / 0
except ZeroDivisionError:
    print("शून्य से विभाजित नहीं कर सकते")

10. फ़ाइल इनपुट/आउटपुट

open() का उपयोग करके फ़ाइलों से पढ़ें और लिखें।

with open("data.txt", "w") as f:
    f.write("नमस्ते दुनिया")

with open("data.txt", "r") as f:
    print(f.read())

11. स्ट्रिंग हेरफेर

पायथन स्ट्रिंग्स में शक्तिशाली मेथड्स होते हैं जैसे strip(), replace(), और split().

text = "  नमस्ते दुनिया  "
print(text.strip())
print(text.upper())
print(text.replace("नमस्ते", "हाय"))
print(text.split())

12. क्लासेस और ऑब्जेक्ट्स

क्लासेस के साथ पुन: प्रयोज्य ब्लूप्रिंट्स परिभाषित करें। ऑब्जेक्ट्स को इनिशियलाइज़ करने के लिए __init__ का उपयोग करें।

class Person:
    def __init__(self, name):
        self.name = name

    def greet(self):
        return "हाय, मैं " + self.name + " हूँ"

p = Person("Alice")
print(p.greet())