Advanced Python Flashcards
\d
matches a digit (0-9)
?
matches 0 or 1 of previous character
+
matches 1 or more of previous character
*
Matchest any character 0 or more times
[]
matches any character inside of the brackets
Visualize tuple unpacking
you can use tuple unpacking
mylist = [(1,2),(3,4),(5,6),(7,8)]
for item in mylist:
print(item)
Visualize printing out the items of a dictionary
d = {‘k1’:1, ‘k2’:2,’K3’:3}
# for default you iterate through the keys
for item in d:
print(item)
What does this print?
d = {‘k1’:1, ‘k2’:2,’K3’:3}
for item in d.items():
print(item)
(‘k1’, 1)
(‘k2’, 2)
(‘K3’, 3)
What is the impact of continue?
for letter in mystring:
if letter == ‘a’:
continue #go back to the loop
print(letter)
It continues pass a, and prints the next characters
Smmy
Enumerate()
allows you to iterate over an iterable (like a list, string, or tuple) while keeping track of the index and value of each element.
What is the output?
words = [‘apple’, ‘banana’, ‘cherry’]
for index, value in enumerate(words):
print(f”Index: {index}, Value: {value}”)
Index: 0, Value: apple
Index: 1, Value: banana
Index: 2, Value: cherry
What is the output?
words = [‘apple’, ‘banana’, ‘cherry’]
indexed_words = list(enumerate(words))
print(indexed_words)
[(0, ‘apple’), (1, ‘banana’), (2, ‘cherry’)]
What is the output?
index_count = 0
for letter in “abcde”:
print(‘At index {} the letter is {}.’.format(index_count,letter))
index_count +=1
At index 0 the letter is a.
At index 1 the letter is b.
At index 2 the letter is c.
At index 3 the letter is d.
At index 4 the letter is e.
zip()
Combines multiple iterables (like lists, tuples, or strings) element-wise into pairs (tuples
What is the output of this?
names = [“Alice”, “Bob”, “Charlie”]
ages = [25, 30, 35]
zipped = zip(names, ages)
print(list(zipped))
[(‘Alice’, 25), (‘Bob’, 30), (‘Charlie’, 35)]
What is the output of this?
for name, age in zip(names, ages):
print(f”{name} is {age} years old.”)
Alice is 25 years old.
Bob is 30 years old.
Charlie is 35 years old.
How would you unzip this?
zipped_data = [(‘Alice’, 25), (‘Bob’, 30), (‘Charlie’, 35)]
names, ages = zip(*zipped_data)
print(list(names)) # [‘Alice’, ‘Bob’, ‘Charlie’]
print(list(ages)) # [25, 30, 35]
List Comprehensions
allow you to generate a new list by applying an expression to each item in an existing iterable (like a list, range, or tuple)
new_list = [expression for item in iterable if condition]
Use a list comprehension to: Create a list of squares of numbers from 1 to 5.
squares = [x**2 for x in range(1, 6)]
print(squares) # Output: [1, 4, 9, 16, 25]
Use a list comprehension to generate a list of all combinations of numbers and letters:
combinations = [(x, y) for x in range(2) for y in ‘AB’]
Use a function with tuple unpacking to increase the stock prices by 10 percent.
stock_prices = [(‘APPL’, 200), (‘GOOG’,400), (‘MSFT’, 100)]
for ticker,price in stock_prices:
print(price+(0.1*price))
*args
args allows you to pass a tuple of parameters coming in.
arg is an arbitrary choice as long as followed by *.
But you should always use *args for style
**kwargs
**kwargs returns a dictionary.
Visualize how to use *args
def myfunc(*args): #the user can pass in as many arguments as wanted
return sum(args) * 0.05
myfunc(40,60,100,1,34)
Visualize how to use **kwargs
def myfruit(**kwargs):
if ‘fruit’ in kwargs:
print(‘My fruit of choice is {}’.format(kwargs[‘fruit’]))
else:
print(“No fruit here”)
myfruit(fruit=’apple’, veggie=’lettuce’)
Visualize how to use both *args and **kwargs
def use_both(*args,**kwargs): #this has to go in the order
print(args)
print(kwargs)
print(‘I would like {} {}’.format(args[0],kwargs[‘food’]))
use_both(10,20,30, fruit=’orange’,food=’eggs’)
What are four general formulas for exponents?
r3 = r³
r2 = r²
r0.5 = √r (square root)
r-1 = 1/r (reciprocal)
map()
Takes a function and an iterable (like a list).
Applies the function to each element in the iterable.
Returns a map object (convert it to a list using list()).
Apply map to the below and tell the output:
numbers = [1, 2, 3, 4, 5]
# Using map() with a function
def square(x):
return x**2
squared = list(map(square, numbers))
print(squared)
Output:
[1, 4, 9, 16, 25]
Alternate is:
squared = list(map(lambda x: x**2, numbers))
T or F: map() does not need a function to execute.
False. map() requires a function.
If you already have a function (def my_function()), you can just pass it to map().
If you don’t want to define a separate function, lambda lets you write a function inline for quick, one-time use.
Use filter() to extract only even numbers from this list:
nums = [5, 10, 15, 20, 25, 30]
nums = [5, 10, 15, 20, 25, 30]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens) # Output: [10, 20, 30]
Use map() to capitalize the first letter of each word:
fruits = [“mango”, “orange”, “peach”]
fruits = [“mango”, “orange”, “peach”]
capitalized = list(map(str.capitalize, fruits))
print(capitalized) # Output: [‘Mango’, ‘Orange’, ‘Peach’]
filter()
Takes a function that returns True or False.
Filters the iterable, keeping only the elements where the function returns True.
lambda: Anonymous Inline Functions
A small one-line function with no name (anonymous).
Used when you need a function just once (e.g., inside map() or filter()).
Visualize using a lambda to add two numbers
add = lambda x, y: x + y
print(add(3, 5))
Explain the LEGB Rule: Understanding Scope in Python
L - Local: Variables defined inside the current function.
E - Enclosing: Variables in the enclosing (outer) function, used in nested functions.
G - Global: Variables defined at the top level of a script or module.
B - Built-in: Names from Python’s built-in functions and libraries (like len, print, range).
What are key concepts in Object Oriented Programming?
Classes → A blueprint for creating objects.
Objects → An instance of a class.
Attributes → Variables inside a class that store data.
Methods → Functions inside a class that operate on the object’s data.
self → Refers to the current instance of the class.
what are class object attributes?
Class Object Attributes are defined outside of __init__().
All instances of the class share this attribute.
In this case, every Dog instance will have species = “mammal”.
How do you create a class in python?
class Name():
What is the method constructor?
__init__() is a constructor method that runs automatically when a new object is created.
self refers to the instance being created.
The attributes breed, name, and spots are passed as arguments.
Why is the self keyword important to an object?
Passed inside the __init__() along with the class attributes, the self keyword is assigned to attributes.
The self keyword allows each instance to have its own unique values
Visualize passing attributes to a class
def __init__(self, attr1, attr2, attr3)
self.attr1 = value
self.attr2 = value
self.attr3
What are methods
Methods are functions inside a class that operate on instances.
self must always be the first parameter in instance methods.
any additional parameters do not.
T or F: you must reference attributes and methods with self in a Class
False. you don’t need self for parameters because they exist only inside the method while it runs
Method
identifies the behaviors and actions that an object created from the class can perform with its data.
Classes
Defines a function and acts like a blueprint to create user-defined data structures.
Instance
An object that’s built from a class and contains real data.
Encapsulation
Allows you to bundle data (attributes) and behaviors (methods) within a class to create a cohesive unit.
Inheritance
enables the creation of hierarchical relationships between classes, allowing a subclass to inherit attributes and methods from a parent class.
Abstraction
focuses on hiding implementation details and exposing only the essential functionality of an object.
Polymorphism
allows you to treat objects of different types as instances of the same base type, as long as they implement a common interface or behavior.
__init__()
Sets the initial state of the object by assigning the values of the object’s properties. That is, .__init__() initializes each new instance of the class.
parameter self
the self parameter is passed in .__init__() so that Python can define the new attributes on the object.
instantiating
Creating a new object from a class
class attributes
attributes that have the same value for all class instances. You can define a class attribute by assigning a value to a variable name outside of .__init__().
class Dog:
species = “Canis familiaris”
def \_\_init\_\_(self, name, age):
self.name = name
self.age = age
Instance methods
functions that you define inside a class and can only call on an instance of that class.
Visualize an instance method
class Dog:
species = “Canis familiaris”
def \_\_init\_\_(self, name, age):
self.name = name
self.age = age
# Instance method
def description(self):
return f"{self.name} is {self.age} years old"
# Another instance method
def speak(self, sound):
return f"{self.name} says {sound}"
How do you use inheritance in Python
You inherit from a parent class by creating a new class and putting the name of the parent class into parentheses:
class Parent:
hair_color = “brown”
class Child(Parent):
pass
Visualize using super()
…
class JackRussellTerrier(Dog):
def speak(self, sound=”Arf”):
return super().speak(sound)
…
Visualize unpacking the items iterable inside an f-string (*items), separating the elements with a default space.
print(“Items are: “, *items, sep=”\n”)
What is an instance variable?
Defined using self.variable_name
Unique to each object
Exists as long as the object exists
When do you use an instance variable?
✅ When each object needs to store unique data
✅ When the value needs to persist across multiple method calls
✅ When multiple methods in the class need to use the same data
When do you use a local variable in OOP?
✅ When you only need the value temporarily inside a method
✅ When the variable does not need to be used in other methods
✅ When you want to avoid storing unnecessary data in the object
What is a local variable in OOP?
It only exists inside the method where it is defined
It does not persist between method calls
It cannot be accessed outside the method
What is a class variable?
Defined outside __init__ but inside the class
Same for every object of the class
Accessed using ClassName.variable_name or self.variable_name
When to Use a Class Variable
✅ When you want to share data across all instances
✅ When you want a default value for all objects
✅ When the variable is not supposed to change per instance
What is traversing a list
Accessing each list element in sequence
Suppose you have a long list and want to know if it contains the value 22, how would you do it
count = 0
list = [x,x,x,x,22,xx,x,x,x]
for element in numbers:
if element == 22:
count +=1
Visualize the logic of a tic-tac-toe board
board = []
if board[0][0] != “ “ and board[0][0] == board[0][1] == board[0][02]:
print(“Winner”)
else:
print(“No win”)
visualize using the .keys method
Allows you to access the keys as an iterative sequence.
dictionary = {“a”: 1, “b”:2, “c”:3}
store = dictionary.keys()
print(store)
OUTPUT:
1,2,3
abstract base class
You can do this using an abstract base class, which contains a method that raises an error if not implemented.
Dunder Methods
allow classes to have built-in behaviors similar to Python’s native types.
__len__()
__del__()
Modules
a Python file (.py) that contains functions, classes, or variables that you can reuse in other scripts.
Packages
a folder that contains multiple modules and an \_\_init\_\_.py file
Subpackages
A package inside another package
__name__ = “__main_”
If a Python file is imported as a module, Python sets \_\_name\_\_ to the module’s filename (without .py)
How is it useful?
Sometimes, you want a script to run certain code only when executed directly, but not when it’s imported.
To do this, use an if statement to check whether \_\_name\_\_ == "\_\_main\_\_".
Visualize how to use try-except
try:
# Code that may cause an error
result = 10 / 0
except:
# Runs if an exception occurs
print(“An error occurred!”)
What is try-except
- Prevents your program from crashing when an error occurs.
- Allows you to handle errors gracefully.
- Lets you log, debug, or recover from exceptions.
Visualize how to specify which error type to catch
try:
num = int(“hello”) # Trying to convert a string to an integer
except ValueError:
print(“Oops! That was not a valid number.”)
__str__()
This method defines what gets printed when you use print(object).
class Book:
def __init__(self, title, author, pages):
self.title = title
self.author = author
self.pages = pages
def \_\_str\_\_(self):
return f"{self.title} by {self.author}"
__len__()
Defines the behavior of len(object).
class Book:
def __init__(self, title, author, pages):
self.title = title
self.author = author
self.pages = pages
def \_\_len\_\_(self):
return self.pages
Importing Modules from a Package
from MyMainPackage import someMainScript
Visualize importing a subpackage
from MyMainPackage.SubPackage import mySubScript
Visualize using else with try-except
try:
num = int(input(“Enter a number: “)) # User input
except ValueError:
print(“Invalid input! Please enter a number.”)
else:
print(f”Great! You entered {num}.”) # Runs if no errors occur
finally block always runs whether an error occurs or not.
try:
f = open(“example.txt”, “r”) # Try opening a file
except FileNotFoundError:
print(“File not found!”)
finally:
print(“Execution completed.”) # Runs no matter what
Visualize how to keep prompting a user until getting correct output with try/except
while True:
try:
num = int(input(“Enter a number: “))
break # Exit loop if input is valid
except ValueError:
print(“Invalid input! Please enter a number.”)
pylint and unitest
is Python’s built-in testing framework, and it’s great for writing test cases to validate your code.
Visualize passing a function to another function.
def greet(name):
return f”Hello, {name}!”
def function_caller(func, argument):
return func(argument)
print(function_caller(greet, “Alice”)) # Output: Hello, Alice!
What is a python decorator? @new_decorator
A decorator is a special function that wraps another function to change its behavior without modifying the original function.
Visualize using a decorator
def order_pizza():
return “Here is your pizza! 🍕”
def extra_cheese_decorator(original_function):
def wrapper():
return original_function() + “ + extra cheese 🧀”
return wrapper
@extra_cheese_decorator
def order_pizza():
return “Here is your pizza! 🍕”
Generators
Generators are a special type of iterator that generate values on the fly instead of storing them in memory. This makes them more memory-efficient than regular lists.
yield
is what makes a function a generator. Instead of returning a value and ending the function, yield pauses the function and allows it to continue from where it left off when called again.
return vs. yield
return → Ends the function and returns a value once
yield → Pauses the function and remembers its state, so it can keep producing values
Visualize using a generator
def gen_fibon(n):
a, b = 1, 1
for _ in range(n):
yield a # Instead of storing in a list, we “pause” and return a
a, b = b, a + b # Update Fibonacci numbers
# Example: Generating first 5 Fibonacci numbers
fib = gen_fibon(5)
print(list(fib)) # Output: [1, 1, 2, 3, 5]
How do you pull values one at a time in a generator?
With next()
fib = gen_fbon(5)
print(next(fib)) # 1
iterator
is an object that can be iterated one value at a time (like generators)
iter()
function turns an iterable into an iterator.
Visualize using iter() with next()
my_list = [10, 20, 30]
my_iterator = iter(my_list) # Convert list to an iterator
print(next(my_iterator)) # 10
print(next(my_iterator)) # 20
print(next(my_iterator)) # 30
print(next(my_iterator)) # ERROR! StopIteration
Visualize reading large files with generators
def read_file_generator(filename):
with open(filename, “r”) as file:
for line in file:
yield line # Yields one line at a time instead of storing everything
lines = read_file_generator(“big_data.txt”)
print(next(lines)) # Reads only the first line
print(next(lines)) # Reads the next line
Opening a file
open(“file.txt”, access_mode)
T/F: You can open files that are already opened.
False. An error will occur, so use a try-except
try:
file_var = open(“file.txt.”, “r”)
except:
print(“Already opened.”)
Visualize how to create a readline() method
file_var = open(“file.txt.”, “r”)
contents = []
line = file_var.readline()
while line != “ “:
contents.append(line)
line = file_var.readline()
visualize closing a file
file_var.close()
Visualize turning a text file that is seperated by commas into tables
file_var = open(“file.txt”, “r”)
artist_idx = 0
song_idx=1
rating_idx = 2
contents = file_var.read()
split_by_line = contents.split(\n”)
split_by_comma = [x.split(“,”) for x in split_by_line if x != “ “]
print(“Artist:”, split_by_comma[0] [artist_idx])
print(“Song:”, split_by_comma[1] [song_idx])
print(“Rating:”, split_by_comma[2] [rating_idx])
Visualize using with and as to open and close files
with open(“file.txt”,”r”) as file_var:
contents = file_var.read()
Visualize reading from one file and writing to a new file
with open(“file.txt”, “r”) as input_file, open(“fav_file.txt”, “w”) as output_file
artist_idx = 0
song_idx=1
rating_idx = 2
contents = input_file.read()
split_by_line = contents.split(\n”)
split_by_comma = [x.split(“,”) for x in split_by_line if x != “ “]
final_tab = [[line[artist_idx],line[song_idx], int(line[artist_idx]) for line in split_by_comma]]
for record in final_tab:
if record[rating_idx] >4:
output_file.write(record[artist_idx] + “,” + record[song_idx] + “,” + str(record[rating_idx] + “\n”))
Recursion
the problem-solving approach that divides large problems into smaller, identical problems.
Recursive function
calls itself at least once. At each function call, recursive functions use modified parameters to shrink the size of the problem.
Questions to ask when using recursion?
Can this problem be broken down into smaller problems?
Are the smaller problems identical to the larger problems?
Is there a way to divide the problem into smaller subproblems that are easy to solve?
What is the difference
def sum_num(current_num):
if current_num == 0:
return 0
else:
sum_tot = sum_nums (current_num-1)
return current_num + sum_tot
sum_num(10)
def sum_num(sum_tot, current_num):
if current_num == 0:
return 0
else:
sum_tot = sum_tot + current_num
return sum_num(csum_tot, current_num -1)
sum_num(0,10)
Both sets of code sum the numbers from 10 to 1 . The tail recursive code passes the sum_total variable to the recursive function call instead of using a local variable. With this approach, the computer does not need to remember anything, so it does not use additional memory.
