Python for AI interview questions & answers

Programming languages ko bolne wali languages ki tarah socho. Kuch languages ka pronunciation mushkil hota hai, grammar tedhi hoti hai; kuch natural aur padhne me easy lagti hai. Python wahi easy-to-read wali hai — Python ki ek line aksar plain English jaisi dikhti hai. Isi wajah se poori AI duniya ne ise chuna.

Python me tu kam likh ke zyada kaam karta hai. Na curly braces {} hote hain, na line ke end me semicolon ; — bas apne code ko indent (thoda andar) karta hai aur Python structure samajh jaata hai. Ek beginner Python program padh ke lagbhag guess kar sakta hai ki kya ho raha hai, language seekhne se pehle bhi. Ye low barrier AI seekhte waqt superpower hai, kyunki teri energy ideas pe lagti hai, syntax se ladne me nahi.

Par readability aadhi kahani hai. AI Python pe chalne ka asli reason hai ecosystem: lagbhag har AI tool, model provider, aur library sabse pehle Python SDK deti hai. OpenAI, Anthropic (Claude), Google Gemini, Hugging Face, LangChain, PyTorch — sab Python-first. Python aata hai toh poore Gen AI universe me plug ho sakta hai.

🌍 Real-world example: AI model se sawaal poochhne ke liye, Python me sirf 3 lines lag sakti hain: library import karo, client banao, message bhejo. Wahi kaam Java jaisi language me bahut zyada boilerplate lines lega. Kam lines = kam bugs = fast learning.

💡 SDK = Software Development Kit — ek ready-made library jo tere code ko kisi service (jaise AI model) se baat karne deti hai, bina tere low-level networking khud likhe.

💡 Ecosystem = ek language ke around bani poori libraries, tools aur community. Python ka AI ecosystem duniya ka sabse bada hai.

AI apps banane ke liye Python expert hona zaroori NAHI hai. Basics chahiye — variables, functions, lists/dicts, aur ek API call karna. Ye chapter tujhe wahi deta hai, zero se.

Python kab sahi chunaav hai: har us cheez me jo AI ecosystem ko chhuti hai — model libraries, data ke auzaar, notebooks, research code. Aap libraries aur community chun rahe hain, syntax nahi.

Kab doosri bhasha behtar hai: high-throughput API parat me, CPU-bound service me, ya jab team kahin aur pehle se tez ho. Zyadatar production AI systems model ke kaam ke liye Python hote hain aur serving ke liye kuch aur — aur ye aam architecture hai, koi samjhauta nahi.

Trade-off kya hai: Python kachche hisaab me slow hai aur lagbhag kabhi adchan nahi banta, kyunki bhaari kaam un C/CUDA libraries ke andar hota hai jinhe wo sirf chala raha hai. Uska kharcha kinaron par hai — packaging, environment ka dobara-wahi banna aur deployment ka size sach me zyadatar ecosystems se mushkil hai.

Standard definition (interview me bolo): Python is a high-level, readable, interpreted programming language, and it is the default language for AI/ML because every major model provider and framework ships a Python-first SDK.

from openai import OpenAI

client = OpenAI()  # reads your API key from the environment

response = client.responses.create(
    model="gpt-4o-mini",  # model IDs change — check the provider's current list
    input="Explain what an LLM is in one line."
)

print(response.output_text)

Ek recipe card soch. Usme labeled ingredients hote hain ("sugar = 2 cups"), aur steps ek ke niche ek likhe hote hain, kuch steps ek condition ke andar nested hote hain ("agar batter runny hai, toh aur flour daalo"). Python code bhi waise hi padhta hai — tu values ko naam deta hai, aur steps line by line likhta hai, jaha nested steps indent (andar) hoke likhe jaate hain.

Python me, ek variable bas ek labeled box hota hai kisi value ke liye: name = "Riya" "Riya" text ko name naam ke box me daal deta hai. Type pehle se declare karne ki zaroorat nahi — Python value se khud samajh leta hai. Core building-block types hain int (whole numbers jaise 25), float (decimals jaise 3.14), str (text jaise "hello"), bool (True/False), aur None (Python ka "yaha kuch nahi hai" bolne ka tareeka). Kisi value ko text ke saath mila ke print karne ke liye f-string use karo: f"Hi {name}" — quotes se pehle wala f Python ko batata hai ki {name} ki jagah us variable ki value bhardo. print(...) screen pe output dikhata hai.

Decisions ke liye if / elif / else use hota hai, aur repetition ke liye for (kisi known sequence pe loop, jaise for i in range(5):) ya while (jab tak condition True rahe, tab tak loop). Har beginner ko trip karne wala sabse bada rule: Python me { } braces nahi hote block mark karne ke liye — indentation hi block hoti hai. if, for, ya while ke niche jitni bhi lines same indent level pe hain, wo sab us block ka hissa hain; jaise hi tu un-indent karta hai, tu us block se bahar ho jaata hai.

🌍 Real-world example: Jab tu ek AI chat app banayega, tu kuch aisa likhega: user ka message ek variable me read karo, if message empty hai, error print karo; else, for se har word pe loop karke roughly tokens count karo. Har AI script inhi basic pieces se bani hoti hai.

💡 Variable = ek named box jo ek value hold karta hai, jo baad me change ("vary") ho sakti hai.

💡 f-string = ek text string jiske aage f lagta hai, jisse tu {variable} values seedhe usme daal sakta hai.

💡 Indentation = line ke start ki spaces; Python me ye sirf style nahi hai, ye define karta hai ki konsi lines kis block ke andar hain.

Har indent level ke liye 4 spaces use karo (Python community standard) aur kabhi tabs aur spaces mix mat karo — inhe mix karna confusing IndentationError ki #1 wajah hai. Comments # se shuru hote hain aur Python inhe ignore karta hai — inhe kya nahi, kyun explain karne ke liye use karo.

f-strings kab sahi auzaar hain: lagbhag har jagah jahan string banti hai, is course ke har prompt samet. Ye padhne laayak hain aur tez hain.

Kab NAHI: SQL ya shell command banate waqt. f-string jo diya jaye use waise ka waisa daal deta hai, aur theek isi tarah injection hota hai — usi ke liye parameterised queries hain.

Trade-off kya hai: Python me indentation hi syntax hai — isse code padhne laayak banta hai aur whitespace ek asli error ki kism ban jaati hai: tab aur space milaana crash hai, aur galat indent ki hui line chupchaap ek alag program hai. Isiliye har Python project bahes ki jagah ek formatter tay kar leta hai.

Standard definition (interview me bolo): Python defines code blocks (for if, for, while, functions, etc.) purely through consistent indentation rather than braces or keywords, and it is dynamically typed — a variable's type is inferred from the value it's assigned, not declared upfront.

# A tiny script using every basic piece
name = "Riya"          # str
age = 21                # int
height = 5.4             # float
is_student = True        # bool
mentor = None             # None = nothing assigned yet

print(f"{name} is {age} years old.")

if age >= 18:
    print("Adult")
elif age >= 13:
    print("Teenager")
else:
    print("Child")

for i in range(3):
    print(f"Loop iteration {i}")

count = 0
while count < 2:
    print(f"While count = {count}")
    count = count + 1

Kya bana rahe hain: Ek chhota, complete script — shaayad 12 real lines — jo ek real AI model se baat karta hai. Ye wahi moment hai jab Chapter 1 ka har piece ek saath click karta hai: variables tumhari key aur prompt rakhte hain, ek dict request aur response ko shape karta hai, ek file (.env) tumhara secret safe rakhti hai, aur requests/openai SDK tumhara message network pe le jaata hai aur jawab wapas laata hai. End tak tumne Python se apni pehli real AI call chala di hogi.

---

Step 0 — Mental model (pehle padho, 30 second)

Har AI API call same paanch-beat dance hai, chaahe koi bhi library use karo:

1. Secret load karo — apni API key, code se BAAHAR, .env file se padhi hui.
2. Request banao — ek chhota dict jo batata hai tumhe kya chahiye (model, tumhara input/prompt).
3. Bhej do — HTTPS pe, provider ke server ko (is project mein, OpenAI).
4. Response wapas lo — server JSON se reply karta hai; tumhara code use Python dict mein badalta hai.
5. Dict se answer nikaalo aur print karo.

💡 API key = ek secret password jo prove karta hai ki request tumse aa rahi hai (aur provider ko tumhara account bill karne deta hai). Kabhi hardcode mat karo, kabhi git mein commit mat karo.

Ye paanch beats dimaag mein rakho — neeche har step bas ek beat hai, code mein.

---

Step 1 — Secret ko .env file mein store karo

Apne project folder mein .env naam ki file banao (apni .py file ke ANDAR nahi):

OPENAI_API_KEY=sk-your-real-key-here

Ho ye raha hai: .env bas ek plain text file hai jismein KEY=value lines hain — koi magic nahi. Ye tumhare script ke bagal mein rehti hai par kabhi import ya hardcode nahi hoti. .env ko apne .gitignore mein daalo taaki wo kabhi GitHub tak na pahunche — leaked key ka matlab hai koi aur tumhara paisa kharch kare.

🌍 Real-world example: har real AI startup bilkul yahi karti hai — apni machine ke liye local .env, aur production mein hosting dashboard (Vercel, Render, etc.) mein wahi variable set "Environment Variable" ke roop mein. Code kabhi nahi badalta; sirf key kahaan se aati hai wo badalta hai.

---

Step 2 — python-dotenv se key ko Python mein load karo

import os
from dotenv import load_dotenv

load_dotenv()
api_key = os.environ["OPENAI_API_KEY"]

Line-by-line ho ye raha hai:

• import os — standard library module jo environment variables padhta hai.
• from dotenv import load_dotenv — python-dotenv package se (pip install python-dotenv).
• load_dotenv() — current folder mein .env open karta hai aur har KEY=value line ko process ke environment variables mein copy karta hai. Ye ek file read hi hai, bilkul with open(...) jaisa, bas tumhare liye automated.
• os.environ["OPENAI_API_KEY"] — os.environ ek dict jaisa behave karta hai: square brackets se key lookup hoti hai aur value milti hai. api_key ab bas ek normal Python string variable hai jo memory mein hai — kabhi print, kabhi log nahi hota.

💡 Environment variable = ek value jo tumhare code ke bahar, use chalane wale process mein rehti hai. .env + load_dotenv() local development ke liye ek beginner-friendly tarika hai isse set karne ka.

---

Step 3 — Client banao

Pehle SDK install karo: pip install openai

from openai import OpenAI

client = OpenAI(api_key=api_key)

Ho ye raha hai: OpenAI(...) ek function call hai jo object return karta hai — client. Ye tumhara api_key store karta hai aur provider ka base URL jaanta hai, to client se ki gayi har call already authenticated hoti hai. Tumne exactly ek object banaya aur ise is poore script mein reuse karoge (aur ek bade app mein, poore program ki lifetime ke liye).

---

Step 4 — Request banao

Under the hood, har AI API call ko ek chhota dict chahiye jo lagbhag aisa dikhta hai:

{
  "model": "gpt-4o-mini",  # model IDs change — check the provider's current list
  "input": "What is one interesting fact about the Moon?"
}

Ho ye raha hai: model chunta hai kaunsa AI model jawab dega; input tumhara prompt hai — plain text, wahi string type jo tum is chapter ke Step 1 se use kar rahe ho. SDK is dict ko tumhare liye HTTPS POST request ke JSON body mein badal dega — tumhe kabhi raw JSON haath se nahi likhna padta.

💡 Payload = wo data jo tum request ke body mein bhejte ho — yahaan, tumhara model choice + prompt, ek dict ke roop mein jo wire pe JSON ban jaata hai.

---

Step 5 — Bhej do aur response wapas lo

response = client.responses.create(
    model="gpt-4o-mini",  # model IDs change — check the provider's current list
    input="What is one interesting fact about the Moon?"
)

Ho ye raha hai — network round trip trace karo:

1. client.responses.create(...) model + input ko us dict mein pack karta hai, JSON text mein convert karta hai, aur OpenAI ke servers ko HTTPS POST request ke body mein bhej deta hai, headers mein tumhara api_key daal ke prove karta hai ki ye tum ho.
2. Tumhara script yahaan pause hota hai — ye ek blocking, synchronous call hai — jab tak request internet pe travel karti hai, model jawab generate karta hai, aur reply wapas aata hai. (Chapter 1 ke async lesson mein tumne dekha tha ki await isliye hota hai taaki isi tarah block na ho; ek waqt mein ek call ke liye, blocking theek hai.)
3. Server ka reply raw JSON text ke roop mein aata hai. SDK use automatically parse karta hai aur tumhe wapas ek Python response object deta hai — isne tumhare liye json.loads() wala step already kar diya.

---

Step 6 — Response ko dict mein parse karo

data = response.model_dump()
answer = data["output"][0]["content"][0]["text"]

Ho ye raha hai: response ek rich Python object hai, par uske neeche wo bas structured data hai — bilkul us JSON jaisi shape jo server ne bheja. .model_dump() ise ek plain dict mein convert karta hai (nested dicts aur lists, bilkul waisi jaisi json.loads() raw JSON text se deta). Fir data["output"][0]["content"][0]["text"] uske andar chalta hai: "output" message blocks ki ek list hai, [0] pehla leta hai, "content" uski content pieces ki list hai, [0] pehla piece leta hai, aur "text" asli answer string hai. Ye bilkul wahi list/dict-indexing hai jo tumne working-with-json mein practice ki thi — real API responses bilkul aise hi nest hote hain.

💡 Practically, SDK tumhe ek shortcut bhi deta hai — response.output_text — jo ye exact walk tumhare liye kar deta hai. Manually kaise karte hain (jaise upar) ye jaanna hi tumhe debug karne deta hai jab response unexpected lage, ya jab tum kisi provider pe switch karo jiska shortcut na ho.

---

Step 7 — Answer print karo

print("AI says:", answer)

Ho ye raha hai: answer ab bas ek plain str hai — saari API machinery ho chuki. print ise terminal pe le jaata hai, bilkul har print() jaisa jo tumne is chapter ke Step 1 se likha hai. AI ka reply ab tumhari screen pe hai.

---

🔁 Raw requests alternative

Tumhe openai SDK ki zaroorat nahi — ye ek convenience wrapper hai. Yahaan wahi call hai plain requests ke saath (pehle install karo: pip install requests), jo JSON parsing ko poori tarah visible bana deta hai:

import requests

url = "https://api.openai.com/v1/responses"
headers = {"Authorization": f"Bearer {api_key}"}
payload = {
    "model": "gpt-4o-mini",  # model IDs change — check the provider's current list
    "input": "What is one interesting fact about the Moon?"
}

resp = requests.post(url, headers=headers, json=payload)
data = resp.json()  # <-- ye line tumhare liye json.loads() karti hai
answer = data["output"][0]["content"][0]["text"]
print("AI says:", answer)

Kya alag hai: requests.post(url, headers=headers, json=payload) bilkul wahi HTTPS request banata aur bhejta hai jo SDK ne Step 5 mein tumhare liye banaya tha — json=payload requests ko batata hai ki tumhara dict khud JSON body bana de. resp.json() wo line hai jo notice karni hai: ye server ka bheja raw JSON text padhta hai aur seedha Python dict mein convert kar deta hai — SDK ne jo automatically kiya uska manual version. Same paanch beats, end mein same dict-walking. openai SDK isliye hai taaki tumhe URL, headers, ya endpoint shape haath se yaad na rakhna pade.

---

🔎 Poora flow (wiring ka recap)

1. .env file disk pe OPENAI_API_KEY=... rakhti hai — ek secret, kabhi tumhari .py file mein nahi.
2. load_dotenv() us file ko padhta hai aur environment variables mein copy karta hai; os.environ["OPENAI_API_KEY"] use ek Python string variable mein khinch leta hai.
3. OpenAI(api_key=api_key) ek client object banata hai jo already authenticate karna jaanta hai.
4. model + input ek chhota dict banate hain — request payload.
5. client.responses.create(...) us payload ko JSON ke roop mein HTTPS pe bhejta hai, model ke reply tak block karta hai, aur JSON reply ko automatically wapas Python object mein parse karta hai.
6. .model_dump() us object ko plain dict mein badalta hai; dict/list indexing (data["output"][0]["content"][0]["text"]) answer string nikaalta hai.
7. print(...) use tumhari screen pe daal deta hai.

Har ek piece — variables, dicts, files, functions, requests/SDKs, JSON — jo tumne is chapter mein seekha, in 12 lines mein dikhta hai. Yahi hai Chapter 1, assembled.

---

✅ Jo tumne abhi seekha — aur aage kya hai

• Secrets .env mein rehte hain, python-dotenv se load hote hain — kabhi hardcode nahi, kabhi commit nahi.
• os.environ dict jaisa behave karta hai — key se square-bracket lookup.
• Ek "client" object tumhari key + provider ki connection details wrap karta hai, taaki har call pre-authenticated ho.
• Har AI request ek dict hai (model + input/prompt) jo JSON body ban jaata hai.
• Har AI response JSON hai, jo Python dict mein parse hota hai (.model_dump() ya resp.json()) — fir tum usmein index karte ho kisi bhi nested dict/list ki tarah.
• requests (raw HTTP) aur openai SDK (convenience wrapper) dono same underlying HTTPS POST + JSON parse karte hain — SDK bas details tumhare liye yaad rakhta hai.

Tumne abhi apna pehla real AI script likha aur chalaya. Chapter 2 (LLM Foundations) isi pe seedha banta hai: "prompt" asal mein kya hota hai, models tokens kaise use karte hain, system vs. user messages, temperature, aur reliable answers dilaane wale prompts kaise design karte hain — sab usi client.responses.create(...) shape se bheje jaate hain jo tumne abhi use kiya.

Standard definition (interview me bolo): A minimal AI script loads an API key from environment configuration (never hardcoded), builds a request payload as a dict, sends it to the provider's HTTPS endpoint (via an SDK or raw requests), parses the JSON reply into a dict, and reads the answer out of it — the same five-step pattern behind every LLM API integration.

import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()  # reads .env and loads it into environment variables

api_key = os.environ["OPENAI_API_KEY"]
client = OpenAI(api_key=api_key)

response = client.responses.create(
    model="gpt-4o-mini",  # model IDs change — check the provider's current list
    input="What is one interesting fact about the Moon?"
)

data = response.model_dump()  # response object -> plain Python dict
answer = data["output"][0]["content"][0]["text"]

print("AI says:", answer)