49 Google Python Developer Interview Questions & Answers

Truth value testing is how Python decides whether an object acts as true or false in a condition. None, False, numeric zero, and empty containers are falsy. Most other objects are truthy. For a custom object, Python checks __bool__ first and then __len__ when __bool__ is absent. In production code, I use value is None when zero or an empty value must remain valid.

Truth value testing is how Python decides whether an object acts as true or false in if, while, not, bool, and Boolean expressions. None, False, numeric zero, and empty containers are falsy. Most other objects are truthy.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

For a custom object, Python first calls __bool__ if the class defines it. That method must return True or False. Returning another type raises TypeError. If __bool__ is absent, Python calls __len__. A length of zero means false. A positive length means true. A negative length raises ValueError. If neither method exists, the object is truthy by default. Any exception raised during the test is passed to the caller.

Use a simple truth test when missing and empty values should follow the same path. Use value is None when None has a separate meaning from zero, False, or an empty container. The cost of the test depends on the method that runs. Built in length checks are normally constant time, but custom methods can do expensive work. Truth testing normally uses constant extra memory and does not copy the object. Custom truth methods should therefore be fast, predictable, and free from side effects.

A common mistake is using if value when the code only wants to detect None. That test also rejects zero, False, empty strings, and empty containers. Another mistake is assuming and and or always return True or False. They return one of their operands after short circuit evaluation. Custom classes are also incorrect when __bool__ returns a value that is not a bool or when __len__ returns a negative number. Slow work, state changes, or external calls inside these methods can make ordinary conditions expensive or surprising.

Start with the common falsy values. Then give the exact order of __bool__, __len__, and the default truthy result. Finish by explaining why value is None is safer when other falsy values are valid.

Use str for text, bytes for fixed binary data, and bytearray for binary data that must change in place. A str contains Unicode characters. bytes and bytearray contain integer byte values from 0 to 255. I use encode to convert str to bytes and decode to convert binary data back to str.

Use str for human readable text. A str contains Unicode characters and is immutable, so changing it creates a new object. Indexing a str returns a one character str.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

Use bytes for fixed binary data, such as file content, network messages, images, or encoded text. bytes is immutable. Indexing bytes returns an integer from 0 to 255, not a one byte bytes object.

Use bytearray when binary data must be edited in place. It stores the same byte values as bytes, but it is mutable. An indexed position can be replaced with an integer from 0 to 255.

Calling text.encode("utf8") creates bytes. Calling data.decode("utf8") creates str. The encoding must match the real data. Otherwise decoding can raise UnicodeDecodeError. Some binary data is not text and should never be decoded.

Repeated changes to str or bytes usually allocate new objects and copy data. bytearray can reduce that work when many binary updates are required. However, converting between these types still creates new objects. In production, keep application text as str and encode or decode only at clear system boundaries.

Common mistakes include joining or comparing str and bytes directly, assuming bytes indexing returns a one byte bytes object, and trying to modify bytes in place. Another mistake is decoding binary data with the wrong encoding or assuming every byte sequence represents text. Developers may also use bytearray for normal text processing, even though str is the correct type for text.

Start with the practical rule: str is text, bytes is fixed binary data, and bytearray is editable binary data. Then explain mutability, indexing results, and encode and decode. Finish with one production example, such as converting text before sending it through a socket.

A Python range is an immutable sequence of integers that stores its start, stop, and step rules instead of storing every value. The start is included, the stop is excluded, and the step cannot be zero. Integer membership, indexing, and slicing are efficient, and slicing returns another range. Converting a large range to a list removes its memory advantage.

Use range when you need a predictable integer sequence without building a full list. For example, range(2, 10, 2) represents 2, 4, 6, and 8. The start is included. The stop is excluded. The step controls the direction and distance between values. A zero step raises ValueError.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

A range is an immutable and reusable sequence, not an iterator. It stores only start, stop, and step information, so its memory use does not grow with the number of represented values. Very large integer arguments may still require more space to store those integers.

For integer values, membership testing uses bounds and arithmetic instead of scanning the sequence. Index access is also calculated directly. Slicing returns another range, so range(2, 10, 2)[1:3] represents 4 and 6 without creating a list.

Negative steps support descending sequences. For example, range(10, 2, -2) represents 10, 8, 6, and 4. A step that moves away from the stop creates an empty range. Use list(range(...)) only when stored or mutable values are truly required.

Common mistakes include expecting the stop value to be included, passing a zero step, using a step that moves away from the stop, and assuming that range stores every represented integer. Another mistake is calling range an iterator. A range is a reusable sequence that creates an iterator when iteration begins. Developers may also assume that slicing returns a list or convert a very large range to a list without considering the resulting allocation. Range arguments must be integers or objects that provide an integer index value, so ordinary float arguments are not accepted.

Begin by saying that range is an immutable reusable integer sequence that stores rules rather than all values. Then explain included start, excluded stop, step direction, arithmetic membership testing, slicing to another range, and the allocation caused by converting it to a list.

The practical rule is to keep text as str inside the program and convert only at system boundaries. I call encode with an explicit character encoding, usually UTF 8, to convert str into bytes. I call decode with the matching encoding to convert bytes back into str. Python keeps these types separate because it cannot safely guess which encoding should be used.

The practical rule is to keep text as str inside the application and convert it only at input and output boundaries. A str contains Unicode characters. A bytes object contains raw integer byte values. Calling text.encode("utf 8") reads the characters and creates a new bytes object. Calling data.decode("utf 8") reads the byte sequence and creates a new str object.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

The decoder must use the encoding defined by the file format, protocol, or system contract. Using the wrong encoding may raise UnicodeDecodeError. It may also produce incorrect text if that encoding accepts the same bytes.

The default error strategy is strict. Encoding can raise UnicodeEncodeError when the selected encoding cannot represent a character. Decoding can raise UnicodeDecodeError for an invalid byte sequence. Other strategies include replace, ignore, backslashreplace, and surrogateescape. Each changes behavior, so production code should choose one deliberately. Ignore can silently lose data.

Python does not implicitly convert between str and bytes because there is no universally correct encoding. Encoding and decoding normally take time proportional to the input length and allocate a new result object. Decode incoming bytes once, process str internally, and encode once when sending or storing data.

Common mistakes include treating bytes as if they were already text, using a different encoding for decoding than was used for encoding, relying on an environment dependent default encoding, and combining str and bytes without an explicit conversion. Joining str values with bytes, or writing the wrong type to a text or binary stream, raises TypeError. Comparing str and bytes does not decode either value and normally returns False for equality. Using ignore can silently remove invalid data. Repeated conversions also create unnecessary work and temporary objects.

Start with the main boundary rule. State that str represents Unicode text and bytes represents binary data. Then explain encode, decode, matching encodings, strict errors, allocation cost, and why explicit conversion prevents silent corruption.

functools.lru_cache saves a function result and returns it again when the function receives the same arguments. It builds a cache key from the arguments, so every argument must be hashable. When a limited cache becomes full, it removes the least recently used entry. I use it for repeated deterministic work, but I avoid it when results can change unless I have a clear way to clear or replace stale entries.

Use functools.lru_cache when repeated calls with the same hashable arguments should produce the same result. It performs memoization, which means it stores a completed result and reuses it later.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

Python builds a cache key from positional and keyword arguments. Lists and dictionaries cannot be direct arguments because they are not hashable. Calls that are logically similar can still create separate entries when their argument forms differ, such as different keyword argument orders.

maxsize limits how many entries are kept. When the limit is reached, the least recently used entry is removed. maxsize=None disables eviction, so the cache can keep growing. maxsize=0 records misses but does not store results.

cache_info() reports hits, misses, maxsize, and current size. cache_clear() removes all entries and resets the statistics. The public interface does not provide a way to remove only one selected key.

The cache keeps references to arguments and return values until entries are removed. This can increase memory use. Its internal state remains consistent across threads, but the wrapped function can still run more than once for the same key during simultaneous misses. Use it for deterministic calculations and stable lookups, not important side effects or frequently changing external data.

The function uses maxsize=2, so it keeps at most two results. The first keyboard call is a miss and runs the function body. The second keyboard call is a hit and returns the saved result. The mouse and monitor calls are misses. Adding monitor removes keyboard because keyboard is then the least recently used entry. The first cache_info() call reports one hit, three misses, a maximum size of two, and a current size of two. cache_clear() then removes all entries and resets the statistics to zero.

Common mistakes include passing lists or dictionaries as arguments, caching functions with side effects, assuming cached data refreshes automatically, and using maxsize=None without considering memory growth. Another mistake is expecting cache_clear() to remove only one entry. Developers may also assume that thread safe cache bookkeeping means the wrapped function can never run twice for the same missing key.

Start by saying that lru_cache memoizes results by argument key. Then explain hashability, maxsize eviction, cache inspection, full cache clearing, stale data, memory retention, and duplicate work during simultaneous misses.

Python loggers form a hierarchy from dot separated names. A logger such as app.service is a child of app and ultimately of the root logger. After the originating logger accepts a logging call, it creates one LogRecord, sends it to its own handlers, and then passes the same record to ancestor handlers while propagate is true. I usually place shared handlers on the root logger and avoid attaching equivalent handlers to child loggers because that often causes duplicate output.

The practical rule is to configure shared handlers near the root logger and let module loggers propagate records upward. Logger names use dots to form a hierarchy. For example, app.service is a child of app, and app is below the root logger. A logging call first checks whether it is enabled by the originating logger's effective level. An effective level may come from that logger or from the nearest ancestor with a level other than NOTSET. If enabled, Python creates one LogRecord. The originating logger applies its filters, then offers the record to its handlers. Each handler checks its own level and filters before formatting and emitting the record. If propagate is true, Python passes the same record directly to handlers on each ancestor. Ancestor logger levels and ancestor logger filters are not checked during this step. A formatter belongs to a handler and converts the record into text or another output form. Duplicate lines usually appear when a child handler and an ancestor handler both emit the same propagated record. Setting propagate to false stops the ancestor walk. In production, configure logging once during application startup, use logging.getLogger(__name__) in modules, and avoid adding handlers repeatedly.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

Common mistakes include attaching handlers to both a child logger and the root logger, which can emit the same record more than once. Another mistake is expecting an ancestor logger level to reject a propagated record. During propagation, Python calls ancestor handlers directly, so handler levels and handler filters control those records. Developers also sometimes add handlers every time a module is imported, attach a formatter to a logger instead of a handler, forget that propagate is true by default, or set propagate to false without giving the logger a handler that can emit the record.

Explain the runtime path in order. The originating logger checks its effective level, creates one record, applies its filters, calls its handlers, and then passes the same record to ancestor handlers while propagation remains enabled. Clearly mention that ancestor logger levels and filters are skipped, but ancestor handler levels and filters still apply.

The main rule is that I only unpickle data from a trusted source. Pickle writes instructions that describe how Python should rebuild an object graph, including object types, state, and shared references. Classes can customize this process with hooks such as __getstate__, __setstate__, and __reduce__. Unpickling is dangerous because reconstruction instructions can import objects and call functions, so malicious pickle data can execute arbitrary code.

The practical rule is simple. Never load pickle data from an untrusted source. Pickle does not store only plain values. It writes a stream of instructions that tells Python how to rebuild an object graph. The stream can describe object types, attribute state, containers, and shared references.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

A normal instance can save its state automatically. A class can customize saved state with __getstate__ and restore it with __setstate__. More advanced classes can use __reduce__ or __reduce_ex__ to provide a reconstruction callable, its arguments, and optional state. During loading, Python normally finds classes and functions by module and name. The object is commonly created without calling __init__.

Python defines protocol versions zero through five. A newer protocol may reduce data size or improve speed, but an older Python version may not support it. Protocol five can also place large binary buffers outside the main pickle stream.

Pickle is useful for trusted Python systems, but it is not a stable language neutral storage format. Renamed classes and changed definitions can break old data. Saving and loading take time and memory related to the object graph and serialized data. For untrusted input, use a safer data format such as JSON.

The example serializes a trusted Session object with protocol five. The __getstate__ hook copies the instance dictionary and removes the temporary connection value, so the live resource is not stored. During loading, Python creates the object and passes the saved state to __setstate__. That hook restores the saved attributes and creates a new connection value. The result keeps the user name and roles while replacing the temporary resource. This trusted round trip demonstrates serialization hooks, but it does not make untrusted pickle data safe.

Common mistakes include treating pickle as a plain data format, loading pickle data from a network or uploaded file, assuming validation after loading prevents code execution, and believing encryption alone makes unknown data safe. Other mistakes include expecting __init__ to run during reconstruction, moving or renaming a class without considering stored data, choosing a protocol that an older Python version cannot read, and trying to serialize live resources such as sockets, locks, open files, or database connections. A signature can detect unauthorized changes only when the signing key is protected, but it does not make data from an untrusted signer safe.

Start with the security rule. Then explain that pickle stores reconstruction instructions, describe the main hooks, mention protocol compatibility, and state clearly that unpickling malicious data can execute code.

Counter is the better choice when the values represent counts. A missing key accessed with square brackets returns zero without adding that key. defaultdict is better when a missing key should create and store a value from a factory, such as a new list, set, or integer. Counter also provides counting methods and arithmetic between counters, while defaultdict mainly provides normal dictionary behavior with automatic value creation.

Use Counter for frequencies and defaultdict for automatic value creation. Counter is a dictionary subclass for counting hashable objects. It can count an iterable, add counts with update, subtract counts, return common items, calculate the total, and combine counters with arithmetic. Square bracket access for a missing key returns zero without inserting the key. Counter can still store zero or negative counts after assignment, update, or subtract.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

A defaultdict stores a default factory. When square bracket access requests a missing key, Python calls that factory with no arguments, inserts the returned value, and returns it. For example, defaultdict(list) creates a separate empty list for each new key. If the factory is None, missing square bracket access raises KeyError.

The get method does not trigger either special missing key behavior. It returns the supplied default, or None. Both types use normal dictionary storage for their entries. A defaultdict can allocate memory and grow during a missing square bracket read. Counter arithmetic scans stored keys and normally removes results whose counts are zero or negative. ([docs.python.org](https://docs.python.org/3/library/collections.html?utm_source=chatgpt.com))

The example counts letters with Counter and groups names with defaultdict. Reading a missing Counter key with square brackets returns zero and leaves the mapping unchanged. Reading a missing defaultdict key with square brackets calls list, stores a new empty list, and returns that list. The example also shows that get does not call the default factory. Counter addition combines matching counts and keeps only positive results, while defaultdict has no specialized counting arithmetic.

A common mistake is assuming both types insert a value when a missing key is read. Counter returns zero without inserting the key, while defaultdict inserts a factory result during square bracket access. Another mistake is expecting get to call the defaultdict factory or return zero for a missing Counter key. It does neither unless an explicit default is supplied. Developers may also use defaultdict(int) for simple counting when Counter would express the purpose more clearly. Counter arithmetic is sometimes misunderstood because its result normally omits counts of zero or less, even though a Counter can store such counts. Another mistake is forgetting that zero and negative Counter entries remain stored until they are deleted or removed by an operation such as unary plus. A factory that returns the same shared mutable object can also make several defaultdict keys refer to one object.

Start with the decision rule: use Counter to count and defaultdict to create missing values. Then explain whether square bracket access inserts a missing key, mention get behavior, and give one small counting example and one grouping example.

A weak reference lets me access an object without keeping it alive. I create one with weakref.ref and call it to get the object. It returns the object while the object is alive, then returns None after the object is collected. This is useful for caches and registries that should not control object lifetime.

Use a weak reference when code needs to observe an object but must not keep it alive. The weakref.ref function creates a reference object. Calling it returns the target while that target still exists. When no strong references remain, the target becomes eligible for collection. After collection, the weak reference returns None.

1. Should I focus on Python language behavior, or also explain the runtime and standard library?
2. Which Python version and execution environment should I assume?
3. Would you like a small code example together with production tradeoffs and edge cases?

In CPython, many objects are destroyed as soon as their reference count reaches zero. Objects in reference cycles may remain until cyclic garbage collection runs. Other Python implementations may collect objects at different times, so production code must not depend on exact timing.

A callback may be passed to weakref.ref. Python calls it when the target is finalized. The callback receives the weak reference, not the destroyed target.

Most user defined class instances support weak references. Some built in types, including list and dict, do not support them directly, although subclasses can. Classes that define slots must include __weakref__ to support them.

WeakKeyDictionary, WeakValueDictionary, WeakSet, and WeakMethod provide common weak reference patterns. They are useful for caches, metadata, registries, and bound method callbacks. They add object and lookup overhead, and entries may disappear whenever their targets are collected.

Common mistakes include expecting a weak reference to keep its target alive, using its result without checking for None, and assuming every Python object supports weak references. Another mistake is forgetting __weakref__ in a class that defines slots. Developers may also rely on callback timing, treat a weak cache as permanent storage, or use weakref.ref for a bound method instead of WeakMethod. A callback must not expect access to the destroyed target because it receives only the weak reference.

Start by contrasting strong and weak references. State that a weak reference does not extend object lifetime and returns None after collection. Then mention callbacks, supported types, weak containers, collection timing, and the cache retention tradeoff.