Python Language

Python is a high-level, interpreted, general-purpose programming language created by Guido van Rossum and first released in 1991. Python emphasizes code readability and simplicity, using indentation to define code blocks instead of curly braces. It supports multiple programming paradigms including procedural, object-oriented, and functional programming. Python is widely used in web development, data science, machine learning, artificial intelligence, automation, scripting, and scientific computing.

Python's philosophy is captured in "The Zen of Python" — Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Readability counts. Python's syntax is clean and beginner-friendly, making it the most popular first programming language worldwide. It is also one of the most in-demand languages in industry today.

1. Easy to Learn and Read: Python's syntax closely resembles English. Code blocks are defined by indentation, not braces, making programs visually clean.

2. Interpreted Language: Python code is executed line by line at runtime, making debugging easier. No separate compilation step needed.

3. Dynamically Typed: No need to declare variable types. Python determines types at runtime — x = 5 (int), x = "hello" (str), x = 3.14 (float).

4. Object-Oriented: Supports classes, objects, inheritance, polymorphism, and encapsulation. Everything in Python is an object.

5. Vast Standard Library: Python ships with a rich standard library and thousands of third-party packages — NumPy, Pandas, Django, Flask, TensorFlow, PyTorch, etc.

6. Cross-platform: Python programs run on Windows, Linux, macOS, and many other platforms without modification.

7. Free and Open Source: Python is developed under an OSI-approved open-source license and is free to use and distribute.

8. Multipurpose: Used in web development, data science, AI/ML, automation, networking, scientific computing, game development, and more.

Python has several built-in data types. Unlike C or Java, you don't need to declare a variable's type — Python infers it automatically at runtime. The built-in type() function returns the type of any variable.

int: Integer numbers with no size limit in Python. x = 100, y = -50, z = 999999999999999

float: Decimal numbers. pi = 3.14159. Scientific notation: 1.5e10. Use round(x, n) to round to n decimal places.

str: Immutable sequence of characters. Created with single, double, or triple quotes. Supports slicing, indexing, and many built-in methods.

list: Ordered, mutable collection. Can contain mixed types. my_list = [1, "hello", 3.14, True]

tuple: Ordered, immutable collection. Faster than list. Used for fixed data. coords = (10, 20)

dict: Unordered key-value pairs. Keys must be unique and immutable. person = {"name": "Alice", "age": 25}

set: Unordered collection of unique elements. Supports mathematical set operations (union, intersection, difference).

bool: Boolean type — True or False. Subclass of int (True == 1, False == 0).

None: Represents absence of a value. Similar to null in other languages. Used as default function return value.

Python control flow statements direct the execution path of a program. Python uses indentation (4 spaces) to define code blocks — there are no curly braces. Control flow includes conditional statements (if/elif/else), loops (for/while), and jump statements (break, continue, pass).

if/elif/else: Python uses elif (not else if) for chained conditions. No parentheses needed around conditions. Ternary operator: value = x if condition else y

for loop: Iterates over any iterable — list, tuple, string, dict, range, set. for i in range(start, stop, step). The else clause on a for loop executes after the loop finishes normally (without break).

while loop: Repeats while condition is True. while True: creates an infinite loop — always include a break condition. The while-else clause also works similarly to for-else.

break: Immediately exits the current loop. break in nested loops only exits the innermost loop.

continue: Skips the rest of the current iteration and moves to the next one.

pass: A placeholder that does nothing. Used when a code block is syntactically required but you don't want to execute anything yet — useful in empty functions, classes, or loops during development.

A function in Python is a reusable block of code defined with the def keyword. Functions help break programs into modular, reusable pieces. Python functions support default arguments, keyword arguments, variable-length arguments (*args and **kwargs), and can return multiple values.

Recursion: Python supports recursive functions. def factorial(n): return 1 if n==0 else n*factorial(n-1). Default recursion limit is 1000. Use sys.setrecursionlimit() to change it.

Scope (LEGB Rule): Python looks up names in this order — Local → Enclosing → Global → Built-in. Use global keyword to modify a global variable inside a function. Use nonlocal to modify an enclosing scope variable.

Decorators: Functions that modify the behavior of another function. Defined with @decorator_name syntax. Common built-in decorators: @staticmethod, @classmethod, @property. Example: @functools.lru_cache for memoization.

Generators: Functions that use yield instead of return. They produce values lazily one at a time, saving memory. def gen(): yield 1; yield 2; yield 3. Iterate with next() or a for loop.

A list in Python is an ordered, mutable collection that can hold elements of different data types. Lists are one of the most versatile and commonly used data structures in Python. They are created using square brackets and support indexing, slicing, and many built-in methods.

List Methods: append(x) — add to end. insert(i, x) — insert at index. remove(x) — remove first occurrence. pop(i) — remove and return at index. sort() — sort in place. reverse() — reverse in place. extend(lst) — add all elements of another list. index(x) — find first index. count(x) — count occurrences. clear() — remove all elements. copy() — shallow copy.

List Comprehension: A concise way to create lists. [expression for item in iterable if condition]. Examples: evens = [x for x in range(20) if x%2==0]. Names uppercased: [n.upper() for n in names].

Nested Lists (2D): matrix = [[1,2,3],[4,5,6],[7,8,9]]. Access with matrix[row][col]. matrix[1][2] = 6. Use nested list comprehension for 2D operations.

A tuple in Python is an ordered, immutable sequence. Once created, its elements cannot be changed, added, or removed. Tuples are faster than lists, use less memory, and are hashable (can be used as dictionary keys or set elements). Created with parentheses or just commas.

Creating tuples: t = (1, 2, 3) or t = 1, 2, 3 (parentheses optional). Single-element tuple: t = (5,) — the comma is mandatory. t = (5) is just an integer, not a tuple.

Tuple unpacking: a, b, c = (1, 2, 3) — assigns each element to a variable. Extended unpacking: first, *rest = (1, 2, 3, 4) — first=1, rest=[2, 3, 4]. Swap variables: a, b = b, a

Named tuples: from collections import namedtuple. Point = namedtuple('Point', ['x', 'y']). p = Point(10, 20). Access as p.x, p.y or p[0], p[1]. Useful for readable, self-documenting code.

Tuple methods: Only two — count(x) (count occurrences) and index(x) (find first index). Tuples support all sequence operations: len(), max(), min(), sum(), in, slicing, concatenation (+), repetition (*).

When to use tuples vs lists: Use tuples for fixed, unchangeable data (coordinates, RGB values, database records). Use lists for collections that need to grow or change. Tuples are safer — accidental modification is prevented by immutability.

A dictionary in Python is an ordered (Python 3.7+), mutable collection of key-value pairs. Keys must be unique and immutable (strings, numbers, tuples). Values can be any type. Dictionaries use hash tables internally, giving O(1) average-time lookup.

Creating dictionaries: d = {} (empty), d = dict(name="Alice", age=25), dict.fromkeys(["a","b"], 0) creates {a:0, b:0}.

Nested dictionaries: Dictionaries can contain other dictionaries as values. students = {"Alice": {"marks": 95, "grade": "A"}, "Bob": {"marks": 82, "grade": "B"}}. Access: students["Alice"]["marks"]

defaultdict: from collections import defaultdict. Never raises KeyError — returns a default value. dd = defaultdict(list). dd["new_key"].append(1). Useful for grouping and counting.

Counter: from collections import Counter. Counts elements in an iterable. c = Counter("hello") → {'l':2, 'h':1, 'e':1, 'o':1}. most_common(n) returns top-n elements.

A set in Python is an unordered, mutable collection of unique elements. Sets do not allow duplicates and are not indexed. They are implemented using hash tables, making membership tests O(1). Sets support mathematical set operations — union, intersection, difference, and symmetric difference.

Creating sets: s = {1, 2, 3} or s = set([1, 2, 2, 3]) → {1, 2, 3} (duplicates removed). Empty set must use set() — not {} which creates an empty dict.

Set Operations: a | b or a.union(b) — all elements from both. a & b or a.intersection(b) — common elements. a - b or a.difference(b) — in a but not b. a ^ b or a.symmetric_difference(b) — in either but not both. a <= b — is a subset of b. a >= b — is a superset of b.

Set Methods: add(x) — add element. remove(x) — remove (raises KeyError if not found). discard(x) — remove without error. pop() — remove random element. clear() — remove all. update(s) — add all elements from another set.

frozenset: An immutable version of a set. Can be used as a dictionary key or stored in another set. fs = frozenset([1, 2, 3]). Supports all set read operations but not add/remove.

Python is a fully object-oriented language — everything in Python is an object, including integers, strings, functions, and modules. Python OOP is built on the same four pillars as other OOP languages: Encapsulation, Abstraction, Inheritance, and Polymorphism.

Inheritance in Python: class Child(Parent): — child inherits all methods and attributes of parent. super() calls the parent class method. Python supports multiple inheritance: class C(A, B):. Method Resolution Order (MRO) determines which parent's method to call — use ClassName.__mro__ to see it.

Magic/Dunder Methods: Special methods with double underscores. __str__ (string representation for print), __repr__ (official representation), __len__ (len()), __add__ (+ operator), __eq__ (== comparison), __lt__ (< comparison), __getitem__ (indexing), __iter__ and __next__ (iteration).

Encapsulation: Single underscore _var (convention: protected). Double underscore __var (name mangling: private). No true private members in Python — convention is respected by the community.

@property decorator: Creates getter/setter/deleter for class attributes, allowing clean attribute-style access while running validation logic. @name.setter and @name.deleter work alongside @property.

Abstract Classes: from abc import ABC, abstractmethod. class Animal(ABC): @abstractmethod def speak(self): pass. Any class inheriting from Animal must implement speak(). Cannot instantiate Animal directly.

Exception handling in Python allows programs to handle runtime errors gracefully without crashing. Python uses try, except, else, finally, and raise. Python has a rich hierarchy of built-in exceptions, all inheriting from BaseException.

Common Python Exceptions: ValueError (invalid value), TypeError (wrong type), KeyError (key not in dict), IndexError (index out of range), AttributeError (attribute not found), FileNotFoundError (file missing), ZeroDivisionError, NameError (variable not defined), ImportError, StopIteration, OverflowError, MemoryError.

Multiple except blocks: try: ... except TypeError: ... except ValueError: ... except (KeyError, IndexError) as e: ... — catches multiple types in one block. except Exception as e: catches all non-system exceptions.

Custom Exceptions: class InsufficientFundsError(Exception): def __init__(self, amount): super().__init__(f"Need {amount} more"). raise InsufficientFundsError(500). Inherit from Exception for application errors, from ValueError/TypeError for type-related custom errors.

Context Managers (with statement): with open("file.txt") as f: — automatically calls f.close() even if exception occurs. Better than try/finally for resource management. Create custom context managers using __enter__ and __exit__ or the @contextmanager decorator.

File handling in Python allows reading from and writing to files on disk. Python uses the built-in open() function to open files and returns a file object. Always close files after use — best done using the with statement which automatically closes the file.

Opening files — open(filename, mode): "r" (read), "w" (write/create), "a" (append), "x" (create, error if exists), "b" (binary mode — rb, wb), "t" (text mode, default), "+" (read and write — r+, w+).

Reading files: f.read() — reads entire file as string. f.read(n) — reads n characters. f.readline() — reads one line. f.readlines() — returns list of all lines. for line in f: — most memory-efficient way to iterate line by line.

Writing files: f.write("text") — writes string. f.writelines(list) — writes a list of strings. Always use "w" to overwrite or "a" to append.

Best practice with 'with': with open("data.txt", "r") as f: content = f.read() — file is automatically closed when the with block exits, even on exceptions.

os and pathlib modules: os.path.exists(path), os.mkdir(path), os.remove(path), os.rename(src, dst), os.listdir(path). Modern alternative — from pathlib import Path. p = Path("data.txt"). p.read_text(), p.write_text(), p.exists(), p.suffix, p.stem, p.parent.

JSON and CSV files: import json — json.dump(data, f), json.load(f). import csv — csv.reader(f), csv.writer(f), csv.DictReader(f). Both are extremely common in Python data processing workflows.

A module in Python is a file containing Python code (functions, classes, variables) that can be imported and reused. A package is a directory containing multiple modules and an __init__.py file. Python's ecosystem has hundreds of thousands of packages available via pip (Python's package installer).

Important Standard Library Modules: os (operating system), sys (system info), math (math functions), random (random numbers), datetime (dates/times), re (regular expressions), json, csv, collections, itertools, functools, pathlib, threading, multiprocessing, socket, http, urllib.

Popular Third-Party Packages: NumPy (numerical computing), Pandas (data analysis), Matplotlib/Seaborn (visualization), Scikit-learn (machine learning), TensorFlow/PyTorch (deep learning), Django/Flask (web frameworks), Requests (HTTP), SQLAlchemy (database ORM), FastAPI (modern web API), BeautifulSoup (web scraping).

Virtual Environments: python -m venv myenv creates an isolated environment. Activate: source myenv/bin/activate (Linux/Mac) or myenv\Scripts\activate (Windows). pip freeze > requirements.txt saves dependencies. pip install -r requirements.txt installs them.

__name__ == "__main__": Every Python file has a __name__ attribute. When a file is run directly, __name__ is "__main__". When imported as a module, __name__ is the module name. Use if __name__ == "__main__": to prevent code from running when imported.

1. Hello World:
print("Hello, World!")

2. Fibonacci Series:
a, b = 0, 1
for _ in range(10):
    print(a, end=" ")
    a, b = b, a + b
# Output: 0 1 1 2 3 5 8 13 21 34

3. Factorial (recursion):
def factorial(n):
    return 1 if n == 0 else n * factorial(n-1)
print(factorial(5)) # 120

4. Palindrome check:
s = "racecar"
print("Palindrome" if s == s[::-1] else "Not Palindrome")

5. List Comprehension — squares:
squares = [x**2 for x in range(1, 11)]
print(squares) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

6. Count word frequency:
from collections import Counter
words = "the cat sat on the mat the cat".split()
print(Counter(words)) # Counter({'the': 3, 'cat': 2, ...})

7. Class with inheritance:
class Animal:
    def __init__(self, name): self.name = name
    def speak(self): return "..."
class Dog(Animal):
    def speak(self): return f"{self.name} says Woof!"
print(Dog("Rex").speak()) # Rex says Woof!

8. Read/Write JSON file:
import json
data = {"name": "Alice", "age": 25}
with open("data.json", "w") as f: json.dump(data, f)
with open("data.json") as f: print(json.load(f))

9. Decorator example:
def timer(func):
    import time
    def wrapper(*args):
        start = time.time()
        result = func(*args)
        print(f"Time: {time.time()-start:.4f}s")
        return result
    return wrapper
@timer
def slow(): time.sleep(1)
slow() # Time: 1.0001s

10. Generator for infinite sequence:
def count_up(start=0):
    while True:
        yield start
        start += 1
gen = count_up(5)
print(next(gen), next(gen), next(gen)) # 5 6 7

Q1. What is the difference between list and tuple in Python?
Ans: Lists are mutable (can change), created with []. Tuples are immutable (cannot change), created with (). Tuples are faster and use less memory. Tuples are hashable and can be used as dictionary keys. Lists are preferred when data changes; tuples for fixed data.

Q2. What are Python decorators?
Ans: Decorators are functions that modify the behavior of another function without changing its source code. Applied using @decorator syntax. They work by wrapping the original function inside another. Common uses: logging, timing, access control, memoization, input validation.

Q3. What is the difference between deep copy and shallow copy?
Ans: Shallow copy (copy.copy() or list.copy()) creates a new object but references the same nested objects. Deep copy (copy.deepcopy()) creates a completely independent clone — all nested objects are also copied. For lists of lists or dicts of dicts, always use deepcopy to avoid unexpected mutations.

Q4. What are *args and **kwargs?
Ans: *args allows a function to accept any number of positional arguments — collected as a tuple. **kwargs allows any number of keyword arguments — collected as a dict. Order in function signature: regular params → *args → keyword-only params → **kwargs.

Q5. What is a generator in Python?
Ans: A generator is a function that uses yield instead of return. It produces values one at a time (lazily), making it memory-efficient for large sequences. Generators maintain their state between calls. Generator expressions: (x**2 for x in range(1000000)) — much better than a list for large data.

Q6. What is the GIL in Python?
Ans: The Global Interpreter Lock (GIL) is a mutex in CPython that allows only one thread to execute Python bytecode at a time. This limits true multi-threading for CPU-bound tasks. Use multiprocessing (multiple processes) for CPU-bound parallelism. threading works well for I/O-bound tasks. Python 3.13+ is working on removing the GIL.

Q7. What are Python's mutable and immutable types?
Ans: Immutable (cannot be changed): int, float, complex, bool, str, tuple, frozenset, bytes. Mutable (can be changed): list, dict, set, bytearray, custom class objects. When you "change" an immutable value, Python creates a new object — the variable just points to the new one.

Q8. What is list comprehension and when to use it?
Ans: List comprehension is a concise, readable way to create lists: [expression for item in iterable if condition]. Faster than equivalent for loop (C-level optimized). Use when: one-line transformation is clear. Avoid when: logic is complex (multiple if/else, nested loops — use regular loop for readability).

Q9. What is the difference between is and == in Python?
Ans: == checks value equality — are the values the same? is checks identity equality — are they the exact same object in memory? Example: a = [1,2,3]; b = [1,2,3] — a==b is True (same values), a is b is False (different objects). a = b — now a is b is also True.

Q10. Explain Python's memory management.
Ans: Python uses automatic garbage collection via reference counting (every object tracks how many references point to it) and a cyclic garbage collector for circular references. The memory allocator uses private heap space. Small integers (-5 to 256) and short strings are interned (cached) for efficiency. del keyword removes a reference. gc module provides manual control over the garbage collector.

Q1. What is the output of print(type([]))?
a) b) c) d)
Answer: b)

Q2. Which of the following is immutable in Python?
a) list b) dict c) set d) tuple
Answer: d) tuple

Q3. What does len("Python") return?
a) 5 b) 6 c) 7 d) Error
Answer: b) 6

Q4. What is the output of print(2 ** 10)?
a) 20 b) 100 c) 1024 d) 512
Answer: c) 1024 — ** is the exponentiation operator.

Q5. Which keyword is used to create a generator function?
a) return b) generate c) yield d) async
Answer: c) yield

Q6. What is the correct way to create an empty set?
a) s = {} b) s = set() c) s = [] d) s = (,)
Answer: b) s = set() — {} creates an empty dict.

Q7. What does the // operator do in Python?
a) Division b) Modulus c) Floor division d) Exponentiation
Answer: c) Floor division — 7//2 = 3 (discards decimal).

Q8. What is the output of [1,2,3][::-1]?
a) [1,2,3] b) [3,2,1] c) [2,1,3] d) Error
Answer: b) [3,2,1] — [::-1] reverses the list.

Q9. Which built-in function converts a string to integer?
a) str() b) float() c) int() d) num()
Answer: c) int() — int("42") returns 42.

Q10. What is the output of print("Python"[1:4])?
a) "Pyt" b) "yth" c) "ytho" d) "ython"
Answer: b) "yth" — slicing is start-inclusive, stop-exclusive: index 1,2,3 = y,t,h.

Q11. Which of the following is NOT a valid Python data type?
a) int b) char c) bool d) complex
Answer: b) char — Python has no char type; single characters are strings of length 1.

Q12. What does the enumerate() function return?
a) A list of values b) An enumerate object of (index, value) pairs c) A dictionary d) A tuple
Answer: b) enumerate object of (index, value) pairs — for i, v in enumerate(["a","b","c"]) gives (0,"a"), (1,"b"), (2,"c").