Python Flashcards
What is the Python interpreter and what’s its primary function?
The Python interpreter is a program that executes Python code. Its main function is to read, interpret, and run Python scripts and interactive commands. It works similarly to Node.js for JavaScript, providing an environment to execute your code.
What is the REPL in the context of the Python interpreter?
REPL stands for Read-Eval-Print Loop. It’s an interactive mode of the Python interpreter that reads user input, evaluates it, prints the result, and loops back to read more input. It’s useful for quick testing and experimentation.
How do you execute a Python script from the command line?
You can execute a Python script (e.g., my_script.py) by using the command python my_script.py in your terminal.
What is the significance of file encoding in Python, and what is the recommended encoding?
File encoding ensures that characters are correctly interpreted by the Python interpreter. The recommended encoding is UTF-8, which supports a wide range of characters, including Unicode.
How can you enter interactive mode after running a Python script?
Use the -i option when running the script: python -i my_script.py. This will execute the script and then drop you into the interactive interpreter.
What is PYTHONSTARTUP environment variable used for?
The PYTHONSTARTUP environment variable specifies a file that the Python interpreter will execute when it starts in interactive mode. This allows you to customize your Python environment. It is similar to .bashrc or Node.js initialization scripts.
How do you run optimized code in Python?
You can use the -O flag when executing your code. For example: python -O my_script.py.
What is Python?
Python is a high-level, versatile programming language that, like JavaScript, supports multiple programming paradigms but is particularly renowned for its simplicity, readability, and extensive use in backend web development, data science, and machine learning, offering a complementary skillset to JavaScript for full-stack development.
How does Python’s syntax compare to JavaScript’s?
Python emphasizes readability through indentation (instead of curly braces) and a more natural language-like syntax. While both are dynamically typed, Python’s syntax requires adapting to its unique style for loops, conditionals, and function definitions.
What are Python’s key data structures, and how do they relate to JavaScript? (4)
Python’s key data structures include lists (similar to JavaScript arrays), tuples (immutable lists), dictionaries (similar to JavaScript objects), and sets (collections of unique elements). Understanding these is crucial for efficient data manipulation in Python.
What are Python modules and packages?
Modules are files containing Python code that can be imported and used in other programs. Packages are collections of modules organized in a directory hierarchy. They allow you to organize and reuse code effectively.
What are Python virtual environments, and why are they important?
Virtual environments isolate project dependencies, preventing conflicts between different projects that might require different versions of the same library. This is essential for maintaining project stability.
What are some popular Python web frameworks, and what problems do they solve?
Popular frameworks include Flask (microframework, unopinionated) and Django (full-featured, batteries-included). They provide tools and structure for building web applications, handling routing, database interactions, and more, similar to how Next.js helps with React development.
What Are Python’s Basic Data Types?
Basic data types in Python include numbers (integers and floats), strings (immutable sequences of characters), and lists (mutable collections of items).
How Are Strings Manipulated in Python?
Strings in Python are immutable and can be enclosed in single or double quotes. They can be concatenated with +, repeated with *, and indexed/sliced.
What Are Lists in Python?
Lists are mutable collections of items enclosed in square brackets. They support indexing, slicing, concatenation, and modification through methods like append.
What Is the Difference Between / and // in Python?
The / operator performs floating-point division, while the // operator performs floor division, returning an integer result by discarding the fractional part.
What Is the Role of the % Operator?
The % operator calculates the remainder of an integer division operation in Python.
print(‘C:\some\name’)
vs
print(r’C:\some\name’)
print(‘C:\some\name’) # here \n means newline!
C:\some
ame
print(r’C:\some\name’) # note the r before the quote
C:\some\name
print(“””\
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
“””)
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
3 * ‘un’ + ‘ium’
‘unununium’
How to get characters from position 2 (included) to 5 (excluded)
word[2:5]
How to get characters from position 4 (included) to the end
word[4:]
How to get characters from the second-last (included) to the end
‘on’
word[-2:]
How simple assignments (=) works in python in terms of coping data and references?
Simple assignment in Python never copies data. When you assign a list to a variable, the variable refers to the existing list. Any changes you make to the list through one variable will be seen through all other variables that refer to it.:
rgb = [“Red”, “Green”, “Blue”]
rgba = rgb
id(rgb) == id(rgba) # they reference the same object
True
rgba.append(“Alph”)
rgb
[“Red”, “Green”, “Blue”, “Alph”]
How to shallow copy the list in python?
correct_rgba = rgba[:]
correct_rgba[-1] = “Alpha”
correct_rgba
[“Red”, “Green”, “Blue”, “Alpha”]
rgba
[“Red”, “Green”, “Blue”, “Alph”]
How range() function works?
list(range(5, 10))
[5, 6, 7, 8, 9]
list(range(0, 10, 3))
[0, 3, 6, 9]
list(range(-10, -100, -30))
[-10, -40, -70]
What is Iterable in Python?
An object capable of returning its members one at a time. Examples of iterables include all sequence types (such as list, str, and tuple) and some non-sequence types like dict, file objects, and objects of any classes you define with an __iter__() method or with a __getitem__() method that implements sequence semantics.
What are f-strings?
f-string evaluates at runtime of the program. It’s swift compared to the previous methods.
print(f”{name} is an {type_of_company} company.”)
When loop else executes?
In a for or while loop the break statement may be paired with an else clause. If the loop finishes without executing the break, the else clause executes.
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, ‘equals’, x, ‘*’, n//x)
break
else:
# loop fell through without finding a factor
print(n, ‘is a prime number’)
What is pass statement?
The pass statement does nothing. It can be used when a statement is required syntactically but the program requires no action.
This is commonly used for creating minimal classes:
class MyEmptyClass:
pass
How keyword arguments works?
def parrot(voltage, state=’a stiff’, action=’voom’):
print(“This parrot wouldn’t”, action, “if you put”, voltage, “volts through it.”)
parrot(voltage=1000000, action=’VOOOOOM’)
What is Python’s equivalent to JavaScript’s switch statement?
Python’s match statement (introduced in Python 3.10) is similar to JavaScript’s switch but more powerful, supporting pattern matching, destructuring, and guards.
How do default def parameters work in Python functions?
Default parameters in Python are defined in the function signature: def function(param=default_value):. Be careful: mutable default values (lists, dictionaries) are created only once and shared between calls.
What are keyword arguments in Python?
Keyword arguments allow you to specify which parameter you’re passing a value to by using the parameter name: function(param_name=value). This makes function calls more readable and allows skipping optional parameters.
How can you define a function that accepts any number of arguments in Python?
Use args for variable positional arguments: def function(args):. The arguments will be accessible as a tuple named args. This is similar to JavaScript’s rest parameters.
def concat(*args, sep=”/”):
return sep.join(args)
concat(“earth”, “mars”, “venus”)
‘earth/mars/venus’
How do lambda expressions work in Python?
Lambda expressions create small anonymous functions: lambda arguments: expression. They are limited to a single expression and are similar to JavaScript’s arrow functions but more restricted since they can’t contain statements.
What naming convention does Python use for variables and functions?
Python uses snake_case for variables and functions (lowercase with underscores) and PascalCase (UpperCamelCase) for class names, which differs from JavaScript’s common camelCase convention.
How do you unpack arguments in Python function calls?
Use the * operator to unpack a list/tuple into positional arguments and ** to unpack a dictionary into keyword arguments: function(*rest_list, **rest_dict). This is similar to JavaScript’s spread operator.
What are Python lists and how do they compare to JavaScript arrays?
Python lists are ordered, mutable sequences similar to JavaScript arrays but with additional built-in methods. Unlike JavaScript arrays, Python lists can hold mixed data types by default and offer powerful features like list comprehensions for creating new lists based on existing ones.
What is a list comprehension in Python?
A list comprehension is a concise way to create lists based on existing iterables. The syntax [expression for item in iterable if condition] allows you to transform and filter data in a single line, similar to map() and filter() in JavaScript but with more readable syntax.
How do Python dictionaries compare to JavaScript objects?
Python dictionaries are mutable, unordered collections of key-value pairs similar to JavaScript objects. However, dictionary keys must be immutable (strings, numbers, tuples, etc.), whereas JavaScript allows any primitive value. Dictionaries support powerful operations like dictionary comprehensions and merging with the | operator.
What are tuples in Python and when should you use them?
Tuples are immutable sequences in Python with no JavaScript equivalent. Use tuples when you need an ordered collection that shouldn’t change after creation, such as coordinates, RGB values, or database records. Their immutability makes them hashable, allowing them to be used as dictionary keys or set elements.
How do sets work in Python and what are they useful for?
Sets are unordered collections of unique elements with no direct JavaScript equivalent (though Set objects are similar). They’re useful for removing duplicates, membership testing (in operator is O(1)), and mathematical operations like union (|), intersection (&), difference (-), and symmetric difference (^).
How can you use a Python list as a stack or queue?
Lists can function as stacks (LIFO) using append() and pop() methods. For queues (FIFO), while you can use insert(0,x) and pop(), the collections.deque class is more efficient with its popleft() method, providing O(1) operations at both ends.
What is the difference between mutable and immutable data structures in Python?
Mutable data structures (lists, dictionaries, sets) can be modified after creation, while immutable ones (tuples, frozensets) cannot. This distinction affects how they’re used: immutable structures can be dictionary keys or set elements; mutable structures allow in-place modifications but may lead to unexpected behavior when shared between variables.
How do you check if an element exists in a Python collection?
Use the in operator for all collections: if x in my_list/my_dict/my_set/my_tuple. This is O(n) for lists/tuples, but O(1) for dictionaries/sets, making the latter more efficient for large collections.
What are dictionary comprehensions?
Dictionary comprehensions allow creation of dictionaries using a concise syntax: {key_expr: value_expr for item in iterable if condition}. This is similar to list comprehensions but produces key-value pairs, offering a powerful way to transform data into dictionaries in a single line.
How does Python handle comparison and sorting of collections?
Python compares sequences lexicographically (item by item), stopping at the first difference. For sorting, use the built-in sorted() function or .sort() method for lists, which accept a key function parameter for custom sorting criteria, similar to JavaScript’s Array.sort() but with a cleaner approach to custom sorting.
Lists vs sets
Python lists are ordered, mutable collections that allow duplicates and support indexing. They are created using square brackets [] or the list() constructor.
Python sets are unordered, mutable collections of unique elements. They are created using curly braces {} or the set() constructor.
What is a Python module?
A Python module is simply a file containing Python code (definitions and statements) that can be imported and used in other Python scripts. It serves as the basic unit of code organization and reusability in Python, similar to how JavaScript modules work in frontend development.
How do you import a Python module?
You can import a Python module using the import statement. For example: import module_name. After importing, you access the module’s contents using dot notation: module_name.function(). Alternatively, you can use from module_name import specific_item to import specific components.
What is a Python package?
A Python package is a directory containing multiple Python modules and a special __init__.py file (optional in Python 3.3+) that marks it as a package. Packages allow for hierarchical organization of modules, similar to how you might organize components in a frontend application.
What is the purpose of __init__.py files?
The __init__.py file marks a directory as a Python package, making it possible to import modules from that directory. It can be empty or contain initialization code that runs when the package is imported. In modern Python (3.3+), __init__.py is optional for basic package functionality but still useful for package-level initialization.
How does Python’s module search path work?
Python searches for modules in locations specified in the sys.path list, which includes: the directory of the current script, PYTHONPATH environment variable locations, standard library directories, and site-packages directories. This is conceptually similar to module resolution in frontend bundlers but follows Python-specific conventions.
What’s the significance of the __name__ variable in Python modules?
The __name__ variable is set to the module’s name when imported, but equals “__main__” when the module is run as a script. This allows for a common pattern: if __name__ == “__main__”: which executes code only when the file is run directly, not when imported. This enables modules to serve as both libraries and executable scripts.
How do relative imports work in Python?
Relative imports use dots to specify location relative to the current module: from . import module1 imports from the same package, while from .. import module1 imports from the parent package. They’re useful for maintaining package independence but should be used carefully to maintain readability.
How can you reload a module during development in Python?
You can reload a module without restarting the Python interpreter using importlib.reload(module_name). This is useful during development when you’re making changes to a module and want to test them in an ongoing session, similar in concept to hot module replacement in frontend development.
What are namespace packages in Python?
Namespace packages (introduced in Python 3.3) are packages that don’t require an __init__.py file and can span multiple directories. They allow for distributed packages where different parts come from different locations. This is an advanced feature that provides flexibility for large-scale package organization.
How do Python modules compare to JavaScript modules?
Python modules and JavaScript modules serve similar purposes (code organization and reusability) but differ in syntax and mechanics. Python uses import module and from module import item patterns, while modern JavaScript uses import { item } from ‘module’. Python’s package system with __init__.py files has no direct equivalent in JavaScript, though it conceptually resembles directory-based organization in frontend projects.
What are f-strings in Python?
F-strings are Python’s most modern string formatting method (introduced in Python 3.6) that allow embedding expressions inside string literals using curly braces, similar to JavaScript’s template literals. Example: f”Hello, {name}. You are {age} years old.”
How do you properly open and close files in Python?
Use the with statement to automatically handle file closing: with open(‘filename.txt’, ‘r’) as f:. This ensures the file is properly closed even if exceptions occur, eliminating the need for explicit try/finally blocks.
What’s the difference between read() and readlines() in Python?
read() returns the entire file content as a single string, while readlines() returns a list of strings, each representing a line in the file (with newline characters preserved).
How do you convert between Python objects and JSON?
Use json.dumps(data) to convert Python objects to JSON strings and json.loads(json_string) to parse JSON strings into Python objects. For file operations, use json.dump(data, file) and json.load(file).
How does Python’s error handling compare to JavaScript’s?
Python uses try/except/finally blocks instead of JavaScript’s try/catch/finally. Specific exceptions can be caught with except ExceptionType: and the exception object can be accessed with except ExceptionType as e:.
What are the main string formatting methods in Python?
Python offers three main string formatting methods: f-strings (f”Value: {var}”), str.format method (“Value: {}”.format(var)), and old-style % formatting (“Value: %s” % var). F-strings are recommended for modern Python code.
How do you write data to a file in Python?
Open the file in write mode with with open(‘filename.txt’, ‘w’) as f:, then use f.write(‘content’) for single strings or f.writelines([‘line1\n’, ‘line2\n’]) for multiple lines.
What’s the difference between syntax errors and exceptions in Python?
Syntax errors occur during parsing when Python detects an incorrect statement and prevents code execution, while exceptions are raised during runtime when syntactically correct code encounters problems during execution, similar to how JavaScript handles parsing errors versus runtime errors.
How does Python’s try-except syntax differ from JavaScript’s try-catch?
Python uses try-except blocks instead of try-catch, allows catching specific exception types without using if-statements on error objects, and includes additional else and finally clauses that provide more structured control flow options than JavaScript’s error handling.
What is the purpose of the “else” clause in Python’s try-except blocks?
The else clause contains code that executes only if no exceptions were raised in the try block, providing a clean separation between normal operations and exception handling code, with no direct equivalent in JavaScript’s try-catch structure.
How do you create a custom exception class in Python?
Create a custom exception by defining a class that inherits from Exception (or a more specific exception class), typically implementing an init method that accepts parameters for custom error data such as status codes, error messages, or other context-specific information.
class ApiError(Exception):
“"”Exception raised for API-related errors”””
def __init__(self, status_code, message):
self.status_code = status_code
self.message = message
super().__init__(self.message)
What is the “with” statement in Python and why is it useful for error handling?
The “with” statement implements context management, automatically handling resource acquisition and release (like opening and closing files) even if exceptions occur, eliminating the need for explicit try-finally blocks and preventing resource leaks with cleaner syntax than JavaScript alternatives.
How can you catch multiple exception types in Python?
Create a custom exception by defining a class that inherits from Exception (or a more specific exception class), typically implementing an init method that accepts parameters for custom error data such as status codes, error messages, or other context-specific information.
How do you deliberately throw an error in Python?
Use the raise statement followed by an exception instance or class (which Python will instantiate), optionally providing arguments for the exception constructor, similar to JavaScript’s throw but with Python’s exception class hierarchy.
def validate_age(age):
if age < 0:
raise ValueError(“Age cannot be negative”)
What is the difference between except: and except Exception:?
except: catches all exceptions including system exits and keyboard interrupts, while except Exception: catches only exceptions that inherit from Exception, excluding BaseException subclasses like SystemExit and KeyboardInterrupt, making it a safer general-purpose handler.
What is an iterable in Python?
An iterable is any Python object capable of returning its members one at a time, permitting it to be iterated over in a for-loop. Technically, an iterable is an object that implements the __iter__() method or the __getitem__() method with sequence semantics.
How can you easily identify if an object is iterable?
If you can loop through it using a for-loop, it’s an iterable.
If you can pass it to the iter() function without raising an error, it’s an iterable.
What are the four primary built-in iterable types in Python?
list - an ordered, mutable collection of elements
dict - an unordered, mutable collection of key-value pairs
tuple - an ordered, immutable collection of elements
set - an unordered, mutable collection of unique elements
Are strings iterable in Python? If so, what elements do they yield?
Yes, strings are iterable objects in Python. When iterated, they yield individual characters from the string. For example, iterating through “banana” would yield ‘b’, ‘a’, ‘n’, ‘a’, ‘n’, ‘a’ one character at a time.
How can you convert different iterable types to a list?
You can convert any iterable to a list using the list() constructor. For example:
list(“Hello”) returns [‘H’, ‘e’, ‘l’, ‘l’, ‘o’]
list((1, 2, 3)) returns [1][2][3]
list({1, 2, 3}) returns [1][2][3]
What is the iterator protocol in Python?
The iterator protocol consists of two methods:
__iter__(): Returns the iterator object itself
__next__(): Returns the next value in the iteration; raises StopIteration when there are no more values
What are some built-in Python functions that accept iterables as arguments?
Several built-in Python functions work with iterables, including:
list(), tuple(), dict(), set(): Convert iterables to these types
sum(): Sum the contents of an iterable
sorted(): Return a sorted list from an iterable
any(): Return True if any element is True
all(): Return True if all elements are True
max(): Return the largest value
min(): Return the smallest value
How do you define a class in Python?
class Car:
def __init__(self, make, model):
self.make = make
self.model = model
What is the purpose of the __init__ method in Python classes?
The __init__ method is the constructor in Python classes. It initializes a new object’s attributes and is automatically called when you create a new instance of the class.
What is the self parameter in Python methods?
The self parameter refers to the instance of the class and must be the first parameter of any instance method. It’s similar to JavaScript’s this but explicitly passed as a parameter.
How do you implement inheritance in Python?
class Animal:
def __init__(self, name):
self.name = name
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name)
self.breed = breed
What’s the difference between class variables and instance variables in Python?
Class variables are shared by all instances of a class and defined outside methods. Instance variables are unique to each instance and typically defined in the __init__ method.
class User:
count = 0 # Class variable
def \_\_init\_\_(self, username):
self.username = username # Instance variable
User.count += 1
What are special methods (dunder methods) in Python classes?
Special methods, surrounded by double underscores, define behavior for built-in operations. They allow classes to implement operator overloading and customize behavior.
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def \_\_add\_\_(self, other):
return Vector(self.x + other.x, self.y + other.y)
def \_\_str\_\_(self):
return f"Vector({self.x}, {self.y})"
Which object attributes are deletable and how in Python?
Writable attributes may also be deleted with the del statement. For example:
del modname.the_answer
will remove the attribute the_answer from the object named by modname.
What is a namespace in Python?
A namespace is a mapping from names to objects. It’s essentially a dictionary that stores variable names and their corresponding objects in memory.
What are the main types of namespaces in Python?
Python has three main types of namespaces: built-in namespace (containing built-in functions), global namespace (created for each module), and local namespace (created when a function is called).
What will be printed and why?
class Warehouse:
purpose = ‘storage’
region = ‘west’
w1 = Warehouse()
print(w1.purpose, w1.region)
storage west
w2 = Warehouse()
w2.region = ‘east’
print(w2.purpose, w2.region)
“storage east”
If the same attribute name occurs in both an instance and in a class, then attribute lookup prioritizes the instance.
isinstance() Python
Use isinstance() to check an instance’s type: isinstance(obj, int) will be True only if obj.__class__ is int or some class derived from int.
issubclass() Python
Use issubclass() to check class inheritance: issubclass(bool, int) is True since bool is a subclass of int. However, issubclass(float, int) is False since float is not a subclass of int.
Multiple Inheritance Python
Python supports a form of multiple inheritance as well. A class definition with multiple base classes looks like this:
class DerivedClassName(Base1, Base2, Base3):
For most purposes, in the simplest cases, you can think of the search for attributes inherited from a parent class as depth-first, left-to-right, not searching twice in the same class where there is an overlap in the hierarchy. Thus, if an attribute is not found in DerivedClassName, it is searched for in Base1, then (recursively) in the base classes of Base1, and if it was not found there, it was searched for in Base2, and so on.
Private Variables Python
“Private” instance variables that cannot be accessed except from inside an object don’t exist in Python. However, there is a convention that is followed by most Python code: a name prefixed with an underscore (e.g. _spam) should be treated as a non-public part of the API (whether it is a function, a method or a data member). It should be considered an implementation detail and subject to change without notice.
What is dataclasses in Python?
The @dataclass decorator will add various “dunder” methods to the class, described below. If any of the added methods already exist in the class, the behavior depends on the parameter, as documented below. The decorator returns the same class that it is called on; no new class is created.
If true (the default), a __init__() method will be generated.
That is, these three uses of @dataclass are equivalent:
@dataclass
class C:
…
@dataclass()
class C:
…
@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False,
match_args=True, kw_only=False, slots=False, weakref_slot=False)
class C:
…
Generators Python
Generators are a simple and powerful tool for creating iterators. They are written like regular functions but use the yield statement whenever they want to return data. Each time next() is called on it, the generator resumes where it left off (it remembers all the data values and which statement was last executed). An example shows that generators can be trivially easy to create:
def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]
for char in reverse(‘golf’):
print(char)
f
l
o
g
In addition to automatic method creation and saving program state, when generators terminate, they automatically raise StopIteration. In combination, these features make it easy to create iterators with no more effort than writing a regular function.
Generator Expressions in Python
Some simple generators can be coded succinctly as expressions using a syntax similar to list comprehensions but with parentheses instead of square brackets.
sum(i*i for i in range(10)) # sum of squares
285
xvec = [10, 20, 30]
yvec = [7, 5, 3]
sum(x*y for x,y in zip(xvec, yvec)) # dot product
260
unique_words = set(word for line in page for word in line.split())
valedictorian = max((student.gpa, student.name) for student in graduates)
data = ‘golf’
list(data[i] for i in range(len(data)-1, -1, -1))
[‘f’, ‘l’, ‘o’, ‘g’]
How do you interact with the operating system in Python?
Use the os module for basic OS operations and shutil for higher-level file operations.
import os
import shutil
Get current working directory
current_dir = os.getcwd()
Create a new directory
os.mkdir(‘new_folder’)
Copy a file
shutil.copyfile(‘original.txt’, ‘copy.txt’)
How do you handle file pattern matching in Python?
Use the glob module to find files matching a specific pattern.
import glob
Find all JavaScript files in current directory
js_files = glob.glob(‘*.js’)
Find all Python files in any subdirectory
python_files = glob.glob(‘**/*.py’, recursive=True)
How do you process command line arguments in Python?
Use sys.argv for simple cases or argparse for more complex command-line interfaces.
import argparse
parser = argparse.ArgumentParser(description=’Process some integers.’)
parser.add_argument(‘integers’, metavar=’N’, type=int, nargs=’+’,
help=’an integer for the accumulator’)
parser.add_argument(‘–sum’, dest=’accumulate’, action=’store_const’,
const=sum, default=max,
help=’sum the integers (default: find the max)’)
args = parser.parse_args()
print(args.accumulate(args.integers))
How do you work with regular expressions in Python?
Use the re module for pattern matching and string manipulation.
import re
Find all words starting with ‘p’
text = “Python is a programming language”
p_words = re.findall(r’\bp\w+’, text, re.IGNORECASE) # [‘Python’, ‘programming’]
Replace repeated words
corrected = re.sub(r’(\b\w+)\s+\1’, r’\1’, ‘hello hello world’) # ‘hello world’
How do you generate random values in Python?
Use the random module for various random operations.
import random
Random choice from a list
random_fruit = random.choice([‘apple’, ‘banana’, ‘cherry’])
Random number between 1 and 100
random_number = random.randint(1, 100)
Random sample without replacement
random_sample = random.sample(range(1, 50), 6) # Lottery numbers
How do you work with dates and times in Python?
Use the datetime module for date and time manipulation.
from datetime import datetime, timedelta
Current date and time
now = datetime.now()
Date arithmetic
one_week_later = now + timedelta(days=7)
Formatting dates
formatted_date = now.strftime(“%Y-%m-%d %H:%M:%S”)
Parsing dates
parsed_date = datetime.strptime(“2025-03-18”, “%Y-%m-%d”)
How do you measure code performance in Python?
Use the timeit module to benchmark code execution time.
import timeit
Compare two approaches
list_comp_time = timeit.timeit(‘[x2 for x in range(1000)]’, number=10000)
map_time = timeit.timeit(‘list(map(lambda x: x2, range(1000)))’, number=10000)
print(f”List comprehension: {list_comp_time}”)
print(f”Map function: {map_time}”)
How do you write tests with standard libs in Python?
Use unittest for test classes or doctest for testing examples in documentation.
import unittest
def add(a, b):
return a + b
class TestAddFunction(unittest.TestCase):
def test_numbers(self):
self.assertEqual(add(1, 2), 3)
def test_strings(self):
self.assertEqual(add('hello ', 'world'), 'hello world')
if __name__ == ‘__main__’:
unittest.main()
How to terminate Python script in code?
The most direct way to terminate a script is to use sys.exit().
What is the simplest Python lib to retrieving data from URL?
urllib.request
from urllib.request import urlopen
with urlopen(‘http://worldtimeapi.org/api/timezone/etc/UTC.txt’) as response:
for line in response:
line = line.decode() # Convert bytes to a str
if line.startswith(‘datetime’):
print(line.rstrip()) # Remove trailing newline
datetime: 2022-01-01T01:36:47.689215+00:00
What is the simplest Python lib for sending mails?
smtplib
import smtplib
server = smtplib.SMTP(‘localhost’)
server.sendmail(‘soothsayer@example.org’, ‘jcaesar@example.org’,
“"”To: jcaesar@example.org
From: soothsayer@example.org
Beware the Ides of March.
“””)
server.quit()
Python Template class
The string module includes a versatile Template class with a simplified syntax suitable for editing by end-users. This allows users to customize their applications without having to alter the application.
from string import Template
t = Template(‘${village}folk send $$10 to $cause.’)
t.substitute(village=’Nottingham’, cause=’the ditch fund’)
‘Nottinghamfolk send $10 to the ditch fund.’
Multi-threading in Python
Threading is a technique for decoupling tasks which are not sequentially dependent. Threads can be used to improve the responsiveness of applications that accept user input while other tasks run in the background. A related use case is running I/O in parallel with computations in another thread.
import threading, zipfile
class AsyncZip(threading.Thread):
def __init__(self, infile, outfile):
threading.Thread.__init__(self)
self.infile = infile
self.outfile = outfile
def run(self):
f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
f.write(self.infile)
f.close()
print('Finished background zip of:', self.infile)
background = AsyncZip(‘mydata.txt’, ‘myarchive.zip’)
background.start()
print(‘The main program continues to run in foreground.’)
background.join() # Wait for the background task to finish
print(‘Main program waited until background was done.’)
List out logging functions in Python
import logging
logging.debug(‘Debugging information’)
logging.info(‘Informational message’)
logging.warning(‘Warning:config file %s not found’, ‘server.conf’)
logging.error(‘Error occurred’)
logging.critical(‘Critical error – shutting down’)
By default, informational and debugging messages are suppressed and the output is sent to standard error.
WARNING:root:Warning:config file server.conf not found
ERROR:root:Error occurred
CRITICAL:root:Critical error – shutting down
How does garbage collection works in Python?
The process of freeing memory when it is not used anymore. Python performs garbage collection via reference counting and a cyclic garbage collector that is able to detect and break reference cycles. The garbage collector can be controlled using the gc module.
What for are weak references in Python?
Python does automatic memory management (reference counting for most objects and garbage collection to eliminate cycles). The memory is freed shortly after the last reference to it has been eliminated.
This approach works fine for most applications but occasionally there is a need to track objects only as long as they are being used by something else. Unfortunately, just tracking them creates a reference that makes them permanent. The weakref module provides tools for tracking objects without creating a reference. When the object is no longer needed, it is automatically removed from a weakref table and a callback is triggered for weakref objects. Typical applications include caching objects that are expensive to create.
When to use weak references in Python?
Implementing Caches
One of the primary uses for weak references is building caches for large objects. Using weak references ensures that objects aren’t kept alive solely because they appear in the cache. This allows the garbage collector to reclaim memory when the object is no longer used elsewhere in your program.
Breaking Reference Cycles
Weak references can help break reference cycles, which occur when two or more objects reference each other. While Python’s garbage collector can eventually break these cycles, using weak references prevents them from forming in the first place, which is more efficient in terms of both space and time.
Observer Pattern Implementation
When implementing the observer pattern (particularly for event handling), weak references prevent the “lapsed listener problem.” Without weak references, observed objects would keep their observers alive indefinitely unless explicitly unregistered, potentially causing memory leaks.
Associative Arrays with Object Keys
When using objects as keys in dictionaries or other mapping structures, weak references prevent keeping these objects alive just because they’re used as keys. Python provides WeakKeyDictionary and WeakValueDictionary for these scenarios.
What to use to create FIFO lists in Python?
The collections module provides a deque object that is like a list with faster appends and pops from the left side but slower lookups in the middle. These objects are well suited for implementing queues and breadth first tree searches:
from collections import deque
d = deque([“task1”, “task2”, “task3”])
d.append(“task4”)
print(“Handling”, d.popleft())
Handling task1
What is the Python module for manipulating sorted lists?
bisect
import bisect
scores = [(100, ‘perl’), (200, ‘tcl’), (400, ‘lua’), (500, ‘python’)]
bisect.insort(scores, (300, ‘ruby’))
scores
[(100, ‘perl’), (200, ‘tcl’), (300, ‘ruby’), (400, ‘lua’), (500, ‘python’)]
What is the Python module that optimize lists for getting lowest value, but not sortign all values?
heapq
from heapq import heapify, heappop, heappush
data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
heapify(data) # rearrange the list into heap order
heappush(data, -5) # add a new entry
[heappop(data) for i in range(3)] # fetch the three smallest entries
[-5, 0, 1]
How to get as much precision as needed in decimal operation?
Use decimal package
from decimal import *
round(Decimal(‘0.70’) * Decimal(‘1.05’), 2)
Decimal(‘0.74’)
round(.70 * 1.05, 2)
0.73
What is a Python virtual environment?
A self-contained directory that contains a Python installation for a particular version of Python, plus additional packages, allowing different projects to have their own dependencies regardless of what dependencies other projects have, similar to how node_modules works in JavaScript projects.
How do you create a Python virtual environment?
python -m venv my_environment_name
How do you activate a Python virtual environment?
On Windows:
.venv\Scripts\activate
On macOS/Linux:
source .venv/bin/activate
How do you install a package in a Python virtual environment?
Using pip, which is Python’s package manager (similar to npm in JavaScript):
python -m pip install package_name
For a specific version:
python -m pip install package_name==1.2.3
What is requirements.txt?
requirements.txt lists the Python packages and their versions required for a project, similar to how dependencies are listed in package.json. However, it doesn’t contain project metadata or scripts like package.json does. It’s generated using:
python -m pip freeze > requirements.txt
And dependencies are installed from it using:
python -m pip install -r requirements.txt
How do you deactivate a Python virtual environment?
deactivate
How do you upgrade a package in a Python virtual environment?
python -m pip install –upgrade package_name
How do you view installed packages in a Python virtual environment?
Using the pip list command:
python -m pip list
Or for more detailed information about a specific package:
python -m pip show package_name
What’s the Python equivalent of npm’s package-lock.json?
Python doesn’t have a direct equivalent built into pip. However, tools like pip-tools with its pip-compile command can generate a “locked” requirements file with exact versions and hashes, similar to package-lock.json’s purpose of ensuring reproducible installations.
Why use .venv as the name for your virtual environment directory?
Using .venv is a common convention that:
1) keeps the directory hidden in your shell,
2) clearly indicates its purpose, and
3) prevents conflicts with .env files used for environment variables. This is similar to how node_modules is a standard directory name in JavaScript projects.
