What Python questions are asked in TCS, Wipro, Infosys interviews for freshers?

TCS, Wipro, and Infosys fresher Python interviews in 2026 consistently cover six topic clusters: (1) Python fundamentals - data types, operators, type system, mutability; (2) Control flow - loops, conditionals, comprehensions; (3) Functions and modules - args/kwargs, scoping, decorators, closures; (4) Data structures - lists, tuples, dicts, sets, when to use which; (5) OOP - classes, inheritance, MRO, dunder methods, descriptors; (6) Pythonic idioms - list/dict/set comprehensions, generators, context managers. Most companies also ask at least one coding question (FizzBuzz, factorial, palindrome, two-sum, anagram group) and one scenario question (mutable default argument trap, list vs tuple, GIL impact). TCS National Qualifier Test and Wipro NLTH typically include 10-15 Python questions in their coding sections with time limits; Infosys HackWithInfy and InfyTQ add two-three harder HackerRank-style problems.

What is the difference between a list and a tuple in Python?

Lists and tuples are both sequence types in Python, but they have different design purposes. Lists are mutable (can be modified after creation), defined with square brackets [1, 2, 3], use slightly more memory, and are intended for homogeneous collections of items that change over time. Tuples are immutable (cannot be modified after creation), defined with parentheses (1, 2, 3), use less memory, are hashable (can be used as dictionary keys or set elements when containing only hashable items), and signal intent that the collection should not change. Lists have methods like append, extend, insert, remove, pop, sort, reverse; tuples have only count and index. In practice, use lists for collections that grow or change, and tuples for fixed records (like a database row or a coordinate) and for returning multiple values from a function.

What is the Python Global Interpreter Lock (GIL)?

The GIL is a mutex in CPython (the standard Python implementation) that allows only one thread to execute Python bytecode at a time, even on multi-core machines. This simplifies memory management (the reference counting in CPython is not thread-safe without the GIL) but limits CPU-bound parallelism in threaded Python code. The GIL does NOT limit I/O-bound concurrency - threads release the GIL during I/O waits, so threading works well for network, file, and database tasks. For CPU-bound parallelism, use multiprocessing (separate processes with their own Python interpreters and GILs) or native extensions like NumPy, Cython, or PyO3 that release the GIL. Python 3.13 introduced experimental free-threaded CPython (no GIL) build, available with the `python3.13t` or `python3.13-nogil` interpreter. For most fresher interviews, the practical answer is: threading for I/O, multiprocessing for CPU, and understand why the GIL exists.

What is the difference between is and == in Python?

The == operator compares the values (equality of contents) of two objects by calling the __eq__ method, while the is operator compares the identities (whether two variables point to the same object in memory) by comparing id() values. Two different list objects with the same contents will compare equal with == but will not be the same with is. Example: [1, 2, 3] == [1, 2, 3] returns True, but [1, 2, 3] is [1, 2, 3] returns False because each literal creates a new list object. The `is` operator is the correct way to compare with None: `if x is None` is the Pythonic style; `if x == None` works but is less precise. Common fresher interview trap: small integers (-5 to 256) and short strings are cached by CPython, so `a = 256; b = 256; a is b` returns True but the same is not guaranteed for larger numbers.

What are Python decorators?

A decorator is a function that takes another function (or class) as input and returns a modified version - it wraps the original to add behavior without changing its source. Decorators use the @decorator_name syntax placed above the function definition. Common built-in decorators are @property (turn a method into a read-only attribute), @staticmethod (define a method that doesn't receive self), @classmethod (define a method that receives the class as cls instead of the instance), and @functools.wraps (preserve the original function's __name__ and __doc__ when writing custom decorators). Custom decorators are used heavily in web frameworks (Flask @app.route, Django login_required), testing (pytest fixtures), and for cross-cutting concerns like logging, caching, and authentication. A simple decorator example: def my_decorator(func): def wrapper(*args, **kwargs): print('before'); result = func(*args, **kwargs); print('after'); return result; return wrapper. Apply with @my_decorator above the function you want to wrap.

What are *args and **kwargs in Python functions?

*args and **kwargs let a function accept a variable number of arguments. *args collects extra positional arguments into a tuple - def func(*args) means func(1, 2, 3) makes args = (1, 2, 3). **kwargs collects extra keyword arguments into a dictionary - def func(**kwargs) means func(a=1, b=2) makes kwargs = {'a': 1, 'b': 2}. They can be combined with required parameters: def func(required, *args, **kwargs). The names args and kwargs are convention only - the asterisks are what matters. *args and **kwargs are heavily used in decorators (to wrap functions with any signature), in class __init__ methods (to pass through to parent constructors via super().__init__(*args, **kwargs)), and in function wrappers that need to be signature-agnostic.

How do you handle exceptions in Python?

Python exception handling uses try / except / else / finally. Wrap the risky code in try:, catch specific exceptions in except ExceptionType as e:, use else: for code that should run only if no exception occurred, and finally: for cleanup code that must always run (closing files, releasing locks, closing database connections). Best practices: catch specific exception types (never bare `except:` which catches everything including SystemExit and KeyboardInterrupt); use `except Exception:` only at the top-level boundary where you want to log and continue; use multiple except blocks ordered from most specific to least specific; use `raise` (without arguments) inside an except block to re-raise the original exception after logging; use exception chaining with `raise NewException from original` to preserve the original traceback. Custom exceptions are created by subclassing Exception. Context managers (with statements) are the modern way to handle setup/cleanup; the contextlib.contextmanager decorator lets you write a generator-based context manager for custom cleanup logic.

What is the difference between shallow copy and deep copy in Python?

A shallow copy creates a new object but inserts references to the same items that the original contains - so if the original contains a mutable object (like a list), modifying that nested object through the copy affects the original. A deep copy creates a new object AND recursively copies all nested objects, so the copy is fully independent of the original. Use the copy module: copy.copy(x) for shallow, copy.deepcopy(x) for deep. Practical example: shallow copy of a list of lists - the outer list is new, but the inner lists are shared; modifying an inner list via the copy also modifies the original. Deep copy creates fresh inner lists. Deep copy also handles cycles and deep object graphs, and respects __copy__ and __deepcopy__ dunder methods on custom classes. For most interview questions, the answer is: shallow copies the structure but shares nested objects, deep copy duplicates everything.

Python Interview Questions 2026 for Freshers: Top 40

Quick Answer: Python Interview Questions for Freshers 2026

The top 40 Python interview questions asked at TCS, Wipro, Infosys, Cognizant, Accenture, and HCL in 2026 cover six clusters: Python fundamentals (data types, mutability, operators), control flow (loops, comprehensions), functions and modules (args, kwargs, decorators, closures), data structures (lists, tuples, dicts, sets), OOP (classes, MRO, dunder methods, descriptors), and Pythonic idioms (generators, context managers). Most fresher interviews include 10-15 Python MCQs in the screening test (TCS NQT, Wipro NLTH, Infosys InfyTQ), 2-3 live coding questions (FizzBuzz, factorial, palindrome, two-sum), and 1-2 scenario questions (mutable default argument, list vs tuple, GIL impact). Prepare by practicing 30-40 coding problems on HackerRank or LeetCode, building 2-3 small projects, and reviewing the official Python documentation. For the full Q&A collection with 25 curated questions at all difficulty levels, see the TutorsBot Python Interview Questions hub.

The 6 Topic Clusters TCS/Wipro/Infosys Actually Test

Cluster 1: Python Fundamentals

The first round of every fresher Python interview. Expect questions on data types, mutability, the type system, and operators. Common questions include: What is the difference between a list and a tuple? Which data types are mutable vs immutable? What is the difference between is and ==? What is dynamic typing? What are the key data types in Python (int, float, str, list, tuple, dict, set, bool, None, bytes)? What is the difference between bytes and str? How does Python handle integer overflow (hint: arbitrary precision integers, but float overflow gives inf)? What is None and how is it used? How do you convert between data types (int(), str(), float(), list(), tuple(), dict(), set())? Most TCS NQT and Wipro NLTH Python sections have 3-5 questions on this cluster alone.

Cluster 2: Control Flow and Comprehensions

Second-round basics. Questions on for/while loops, if/elif/else, break/continue/pass, and the Pythonic comprehensions. Common questions: What is the difference between a for loop and a while loop? When would you use else in a for loop (hint: the else clause runs only if the loop completes without break - useful for search patterns)? What are list, dict, and set comprehensions? How do you write a nested comprehension? What is the difference between a generator expression and a list comprehension (hint: generator uses parentheses and is lazy, list uses brackets and is eager)? What is enumerate and when would you use it? What is zip and how does it differ from itertools.zip_longest? TCS NQT and Infosys InfyTQ frequently ask comprehension-based questions because they test both syntax knowledge and Python idiom awareness.

Cluster 3: Functions, Modules, and Scope

Where most freshers lose points. Questions cover function definition, *args/**kwargs, default arguments, scoping (LEGB rule), closures, decorators, and modules/packages. The classic traps: mutable default arguments (def add(item, lst=[]): lst.append(item); return lst - the list is shared across calls), late binding in closures, and the difference between module-level and function-level imports. Decorator questions are nearly universal - be ready to write a timing decorator, a memoization decorator, or explain @property and @staticmethod. Cognizant GenC and Accenture AASS often include a live coding question asking you to write a decorator or generator function.

Cluster 4: Data Structures

Lists, tuples, dicts, sets - and when to use which. The most common interview question: explain the difference between a list, a tuple, a set, and a dictionary, with time complexity for the key operations (list/append O(1), list/insert O(n), dict/lookup O(1) average, set/membership O(1) average). Other questions: How do you merge two dicts (Python 3.9+ uses | operator; 3.5+ uses {**a, **b})? What is the difference between a shallow copy and a deep copy? How do you sort a list of dicts by a specific key (sorted(items, key=lambda x: x['price']))? What is a defaultdict and how does it differ from a regular dict? How do you iterate over a dict (keys, values, items)? Wipro NLTH and TCS Digital interviews include 2-3 questions on this cluster.

Cluster 5: Object-Oriented Programming

Heavy at Cognizant GenC Next and Infosys Power Program. Questions cover class definition, __init__, self, instance vs class variables, inheritance, MRO (Method Resolution Order, especially for multiple inheritance), dunder methods (__str__, __repr__, __len__, __eq__, __hash__, __getitem__, __setitem__, __iter__), properties, static and class methods, abstract base classes, and the descriptor protocol. The classic fresher trap: explain the difference between an instance method, a class method (cls as first parameter, @classmethod), and a static method (no implicit first parameter, @staticmethod). Other classics: What is the diamond problem and how does Python's C3 linearization solve it? What is the difference between __str__ and __repr__? When would you use __slots__? Be ready to write a simple class with inheritance, override a dunder method, and use @property.

Cluster 6: Pythonic Idioms and Standard Library

What separates a good Python developer from a mediocre one. Questions on generators and iterators (yield, __iter__, __next__, StopIteration), context managers (with statements, __enter__, __exit__, contextlib.contextmanager), decorators (already mentioned but tested separately too), the collections module (Counter, defaultdict, OrderedDict, namedtuple, deque), the itertools module (chain, islice, groupby, count, cycle, accumulate), and file handling (open with mode, with statement, read/write/append modes, encoding). Common question: explain the difference between a list and a generator, with examples. Infosys HackWithInfy frequently tests generator-based and context-manager-based problems.

Common Fresher Pitfalls to Avoid

Mutable default argument: def f(lst=[]): lst.append(1); return lst - calling f() twice returns [1, 1], not [1]. Use def f(lst=None): if lst is None: lst = []
Confusing is and ==: Use is for None comparison (if x is None), == for value comparison
Modifying a list while iterating: Don't add or remove items from a list while iterating over it - iterate over a copy, or build a new list
Late binding in closures: In a loop, closures capture the variable not the value - use default arguments (i=i) to bind the value at definition time
Integer division: / is float division (returns float even for whole numbers), // is integer division (returns int)
String immutability: You cannot modify a string in place; every string operation returns a new string
Confusing append and extend: append adds one element (even if it's a list); extend adds each element of the iterable
Off-by-one in range(): range(10) gives 0-9, range(1, 11) gives 1-10

How to Prepare in 30 Days

The strongest 30-day fresher Python interview preparation plan:

Week 1 - Foundations: Work through the official Python tutorial (docs.python.org/3/tutorial), practice 30 basic MCQs from a Python quiz site, complete the HackerRank Python domain (Easy track)
Week 2 - Data structures and OOP: Practice 30-40 list/dict/set problems on LeetCode Easy, build a small project that uses classes and inheritance (a library system, a banking account system, a Tic-Tac-Toe game)
Week 3 - Advanced Python and company patterns: Practice decorators, generators, and context managers; review 5-10 recent interview questions from each target company (TCS, Wipro, Infosys, Cognizant, Accenture, HCL) from GeeksforGeeks, PrepInsta, or IndiaBix
Week 4 - Mock interviews: Take 2-3 timed mock tests (TCS NQT pattern, Wipro NLTH pattern), review the Python Interview Questions hub for the full Q&A collection, refine your answers to the top 10 scenario questions

For a structured, project-based path from Python fundamentals to interview-ready, the TutorsBot Data Science training covers Python, statistics, SQL, and machine learning foundations that map to data analyst and ML engineer roles.

Frequently Asked Questions

How many Python questions are asked in TCS NQT?

TCS NQT typically includes 10-15 Python questions in the coding/technical section for Digital and Prime profiles, plus 1-2 advanced coding problems. For Ninja profiles, the count is lower (5-10 MCQs, 1 coding problem). TCS Digital and TCS Prime have separate tougher coding sections.

Is Python enough to get placed in TCS/Wipro/Infosys?

Python alone is rarely enough - companies test a combination of Python fundamentals, data structures and algorithms (DSA), SQL, and aptitude/reasoning. The strongest fresher profile combines: Python proficiency (interview-ready), DSA (50-100 problems on LeetCode Easy/Medium), SQL (intermediate joins, window functions), communication skills, and 2-3 small projects on GitHub. Infosys InfyTQ and Cognizant GenC require stronger DSA than TCS NQT or Wipro NLTH.

What is the salary for Python freshers at these companies in 2026?

Salary bands for freshers with Python skills in 2026: TCS Ninja ₹3.36 LPA, TCS Digital ₹7-8 LPA, TCS Prime ₹9-11 LPA. Wipro ₹3.5-5 LPA. Infosys (InfyTQ Power Programmer) ₹6.5-9.5 LPA, regular InfyTQ ₹3.6 LPA. Cognizant GenC ₹4.5-6 LPA, GenC Next ₹7-12 LPA. Accenture AASE ₹4.5-6 LPA, AASS ₹6-9 LPA. HCL ₹3.5-5.5 LPA. Product companies (Flipkart, Razorpay, PhonePe) pay 2-3x these bands for strong Python + DSA candidates.

Is Python enough for product company interviews at Flipkart, Razorpay, PhonePe?

Yes, but with much stronger DSA requirements. Product companies test Python fluency plus deep DSA (arrays, strings, hash maps, trees, graphs, dynamic programming, recursion, BFS/DFS), system design basics, and behavioral interviews. Practice 100-150 LeetCode Medium problems, build 2-3 production-grade projects with clean code on GitHub, and prepare system design (caching, databases, API design). The interview loop is typically 4-6 rounds spanning coding, system design, and behavioral.

What is the best resource for Python interview preparation?

The strongest resources are: the official Python tutorial (docs.python.org/3/tutorial - covers everything precisely), Real Python tutorials (realpython.com - in-depth articles on specific topics), HackerRank Python domain (hands-on coding practice), LeetCode Easy and Medium problems (interview-level problem solving), Python Morsels (subtle Python idioms), Fluent Python by Luciano Ramalho (deep dive into Pythonic patterns - best for mid-level to senior engineers), and the TutorsBot Python Interview Questions hub for curated 25 questions at all difficulty levels. Combine the official documentation for correctness, Real Python for depth, HackerRank/LeetCode for coding practice, and a curated interview question set for company-specific patterns.

Resources and Next Steps

The authoritative sources listed (Python official documentation, Real Python, HackerRank, LeetCode, PEP 8) are the canonical references for Python fundamentals and interview preparation. For the full 25-question curated Q&A collection at all difficulty levels (Level 1 foundational, Level 2 intermediate, Level 3 advanced), see the TutorsBot Python Interview Questions hub. For related interview prep, see our SQL interview questions, Java interview questions, and DBMS interview questions guides.