else<\/code> statements work?<\/strong> These are Python\u2019s conditional blocks. Example:<\/p>\nif condition1:\n # code block A\nelif condition2:\n # code block B\nelse:\n # code block C\n<\/pre>\nThe first true condition\u2019s block executes, and the rest are skipped. Indentation is mandatory to delimit the blocks. Comparison operators (==<\/code>, <<\/code>, ><\/code>, etc.) and logical operators (and<\/code>, or<\/code>, not<\/code>) are used in the condition expressions.<\/p>\nWhat loops are available in Python?<\/strong> Python has for<\/code> loops and while<\/code> loops. A for<\/code> loop iterates over a sequence (list, string, tuple, dict keys, etc.), for example:<\/p>\nfor x in [1,2,3]:\n print(x)\n<\/pre>\nA while<\/code> loop repeats as long as a condition is true:<\/p>\ni = 0\nwhile i < 5:\n print(i)\n i += 1\n<\/pre>\nInside loops, break<\/code> exits the loop, and continue<\/code> skips to the next iteration.<\/p>\nHow do you use the range()<\/code> function in loops?<\/strong> The range(start, stop, step)<\/code> function generates an integer sequence. It\u2019s commonly used with for<\/code>. For example, range(5)<\/code> yields 0,1,2,3,4. You can specify a start<\/code> (default 0) and a step<\/code>. Example: for i in range(2, 10, 2):<\/code> iterates over 2, 4, 6, 8. The stop<\/code> value is exclusive.<\/p>\nWhy is indentation important in Python?<\/strong> Unlike languages with braces, Python uses significant indentation<\/strong> to define code blocks. All statements within the same block must have the same indentation. Mis-indented code will raise an IndentationError<\/code>. Proper indentation improves readability, which is part of Python\u2019s design philosophy.<\/p>\nWhat is __init__()<\/code> in a Python class?<\/strong> The __init__<\/code> method is the class initializer (often called the constructor). It\u2019s automatically invoked when an instance is created. In __init__<\/code>, you typically assign attributes. For example:<\/p>\nclass Dog:\n def __init__(self, name):\n self.name = name\n<\/pre>\nHere, creating d = Dog(\"Fido\")<\/code> automatically calls Dog.__init__(d, \"Fido\")<\/code>, setting d.name<\/code>. The __init__<\/code> method can take additional parameters for initialization.<\/p>\nWhat is self<\/code> in Python class methods?<\/strong> In Python, self<\/code> refers to the current instance of the class. It is used inside methods to access attributes and other methods on the object. You always include self<\/code> as the first parameter of instance methods. For example:<\/p>\nclass Example:\n def __init__(self, value):\n self.value = value # 'self.value' is an attribute of this object\n def show(self):\n print(self.value) # using 'self' to access the attribute\n<\/pre>\nWhen you call obj = Example(5); obj.show()<\/code>, Python automatically passes obj<\/code> as self<\/code>.<\/p>\nHow does exception handling work?<\/strong> Python uses try<\/code>\/except<\/code> blocks to catch and handle errors. Example:<\/p>\ntry:\n risky_operation()\nexcept (TypeError, ValueError) as e:\n print(\"Error:\", e)\nfinally:\n print(\"Cleanup code runs no matter what\")\n<\/pre>\nCode in the try<\/code> block is attempted; if an exception occurs, control jumps to the matching except<\/code>. You can catch specific exceptions. The optional finally<\/code> block executes regardless of whether an error occurred. This prevents crashes and allows graceful error handling.<\/p>\nWhat is a module and what is a package?<\/strong> A module<\/strong> is a single Python file (.py<\/code>) that contains definitions (functions, classes, variables) which you can import into other code. A package<\/strong> is a directory containing a special __init__.py<\/code> file and possibly multiple modules or subpackages. Packages help organize related modules. You import them using import module_name<\/code> or from package import submodule<\/code>.<\/p>\nWhat are positional vs keyword arguments in functions?<\/strong> In function definitions, parameters can be passed positionally<\/strong> or by keyword<\/strong>. For example, given def f(x, y=2): ...<\/code>, you can call f(10)<\/code> (positional only, so x=10, y=2) or f(10, y=3)<\/code>, or with keywords f(y=3, x=10)<\/code>. Keyword arguments specify the parameter name. You can also define default values (y=2<\/code> above). Additionally, *args<\/code> collects extra positional arguments into a tuple, and **kwargs<\/code> collects extra keyword arguments into a dict, allowing flexible argument lists.<\/p>\nWhat is a list comprehension?<\/strong> A list comprehension is a concise way to create lists using a single expression. Syntax example: [expr(x) for x in iterable if condition(x)]<\/code>. For instance, [n*n for n in range(5)]<\/code> produces [0,1,4,9,16]<\/code>. It is generally more readable and often faster than an equivalent for<\/code> loop. Comprehensions can include an optional if<\/code> to filter items, e.g. [n for n in range(10) if n%2==0]<\/code> for even numbers.<\/p>\nWhat is a generator expression and how is it different from a list comprehension?<\/strong> A generator expression is similar to a list comprehension but uses parentheses instead of brackets. For example: gen = (x*x for x in range(5))<\/code>. This creates a generator object that yields<\/strong> values one at a time, instead of building the entire list in memory. In contrast, a list comprehension would build and return the full list immediately. Generator expressions are memory-efficient for large data. In short, list comprehensions return a full list, while generator expressions return an iterator that produces items on demand.<\/p>\nWhat are map()<\/code>, filter()<\/code>, and reduce()<\/code>?<\/strong> These are built-in functions (with reduce<\/code> in functools<\/code>) from functional programming.<\/p>\n\nmap(function, iterable)<\/code> applies the function to each item of the iterable and returns an iterator of results.<\/li>\nfilter(function, iterable)<\/code> yields only the items for which the function returns True.<\/li>\nfunctools.reduce(function, sequence)<\/code> applies a binary function cumulatively to the items of the sequence, reducing it to a single value (e.g. summing a list). They allow concise data transformations without explicit loops.<\/li>\n<\/ul>\nWhich testing tools\/frameworks are available in Python?<\/strong> The standard library provides unittest<\/code>, a rich framework for unit testing (with test cases and suites). A popular third-party tool is pytest<\/strong>, which has a simpler syntax (just write assert<\/code> statements) and powerful features like fixtures. There\u2019s also nose<\/code> (less maintained) and doctest<\/code> (inline tests in docstrings). In practice, many developers use pytest<\/code> for its ease of use.<\/p>\nWhat is __name__ == \"__main__\"<\/code> used for?<\/strong> In a Python file, the special variable __name__<\/code> is set to \"__main__\"<\/code> when the file is executed as the main program, and to the module name when imported. So you often see:<\/p>\nif __name__ == \"__main__\":\n main()\n<\/pre>\nThis ensures that the code under this if<\/code> only runs when the script is executed directly, not when it is imported as a module. It\u2019s a common pattern to allow a file to be both used as a script and as an importable module.<\/p>\nWhat is dir()<\/code> and help()<\/code>?<\/strong> dir(object)<\/code> is a built-in that lists the attributes and methods of an object (module, class, instance, etc.). It\u2019s useful for introspection. help(object)<\/code> or help(\"keywords\")<\/code> invokes Python\u2019s help system, showing documentation for the object or topic. These interactive functions help explore code and find available methods or documentation.<\/p>\nWhat is slicing in Python?<\/strong> Slicing allows you to extract a subsequence from sequences (lists, strings, tuples). The syntax is sequence[start:stop:step]<\/code>. For example, s = \"Hello\"; s[1:4]<\/code> gives \"ell\"<\/code> (indices 1 through 3). Leaving out indices means default start\/end, and a negative step (e.g. s[::-1]<\/code>) can reverse the sequence. Slicing is a concise way to manipulate parts of sequences and is very efficient.<\/p>\nWhat is the difference between ==<\/code> and is<\/code>?<\/strong> The ==<\/code> operator checks equality of value<\/em>, i.e., whether two objects have the same value. The is<\/code> operator checks identity<\/em>, i.e., whether two references point to the exact same object in memory. For example, two separate lists with identical contents are ==<\/code> but not is<\/code>. Generally use ==<\/code> for value comparison and is<\/code> only to check for the same object (often used for None<\/code>, e.g. if x is None<\/code>).<\/p>\nWhat are *args and **kwargs in function definitions?<\/strong> In a function signature, *args<\/code> collects extra positional arguments into a tuple, and **kwargs<\/code> collects extra keyword arguments into a dict. For example:<\/p>\ndef f(a, *args, **kwargs):\n print(a, args, kwargs)\nf(1,2,3,x=4,y=5) # a=1, args=(2,3), kwargs={'x':4,'y':5}\n<\/pre>\nThis allows functions to accept a variable number of arguments.<\/p>\n
What is a Python package index (PyPI)?<\/strong> PyPI is the Python Package Index, the official repository of third-party Python libraries. The pip<\/code> tool installs packages from PyPI by default. You can publish your own packages to PyPI so others can install them via pip install yourpackage<\/code>.<\/p>\nHow do you comment code in Python?<\/strong> A single-line comment starts with #<\/code> and continues to the end of the line. For multi-line comments, you can use consecutive #<\/code> lines or a multi-line string (usually triple quotes \"\"\"...\"\"\"<\/code>) that is not assigned to any variable. (Note: Python does not have a special multi-line comment syntax, only the convention of unused multi-line strings.)<\/p>\nWhat is PEP 8?<\/strong> PEP 8 is the Python Enhancement Proposal<\/em> that describes the official Style Guide for Python Code<\/strong>. It provides conventions on code layout, naming, indentation (4 spaces), maximum line length (79 characters), and more. Adhering to PEP 8 makes Python code more readable and uniform. Many developers use tools like flake8<\/code> or