Module 1:
Lesson Reflection
Summary of Lesson:
This lesson covers working with variables, types, conditionals (if, else), exceptions, and
handling errors in Python. Key concepts include variable assignment, reassigning
variables, string formatting, type conversions, comparison operators, try/except blocks,
and catching multiple exception types.
Top 3 Key Points:
Variables don't need explicit types, values can be dynamically reassigned
F-strings provide readable string formatting using variables
Try/except blocks catch and handle exceptions gracefully
5 Reflection Questions:
1. When might you want to reassign variables versus creating new variables?
2. How could you use f-strings to create a customized print output?
3. What is a scenario where try/except would lead to cleaner code than checking
return codes?
4. What might cause a TypeError during string concatenation?
5. Why catch specific exception types instead of generic Exception blocks?
Answers:
When to Reassign Variables vs. Create New Variables
Reassign when you want to update a value while keeping the same reference (e.g.,
updating a loop counter or modifying a configuration setting).
Create a New Variable when preserving the original value is important for
debugging, immutability, or readability (e.g., when transforming data without
losing the original state).
2: Using f-strings for Customized Print Output
f-strings allow you to embed expressions directly in strings using {}.
This makes the code more readable and efficient compared to
concatenation or .format()
3: Using try/except for Cleaner Code
Instead of checking return codes, which can clutter the code with
conditionals, try/except simplifies error handling.
Key Terms
List - An ordered collection of values enclosed in square brackets []. Useful for
storing sequences of items.
Index - The numeric position of an item in a list. Starts at 0 for first item. Used to
access items by position.
Iteration - Repeated execution of code on successive list items. Done in Python
with a for-in loop.
Dictionary - Unordered collection of key-value pairs denoted with curly braces
{}. Keys map to associated values.
Key - Unique identifier that is used to look up values in a dictionary. Looks up are
very fast.
Value - Data associated with a given key in a dictionary. Values can be any
Python data type.
Tuple - Fixed-size, immutable ordered collection similar to a list. Denoted with ().
Useful when data shouldn't change.
Set - Unordered collection of unique objects. Helpful for removing duplicates and
set operations.
Membership - Ability to check if a value is contained in a collection like lists,
dictionaries, tuples, or sets.
Methods - Built-in functions that allow manipulating and interacting with data
structures.
Iteration - The process of repeatedly executing code on each item in a collection
one by one.
Reflection Questions
1. When would you want to use a tuple over a list?
2. What real-world examples can be modeled with dictionaries?
3. How could sets help improve the efficiency of a program?
4. What issues can arise from nested data structures?
5. Why is proper data structure selection important when coding?
Challenge Exercises
1. Implement a phone book as a dictionary.
2. Find the most frequent words in a text file using sets.
3. Filter user-submitted comments stored in a list for profanity.
4. Build a histogram from word counts using dictionaries.
5. Convert a deeply nested list to a flat list.
When would you want to use a tuple over a list?
• Tuples are immutable, meaning they can’t be changed after creation.
• Use a tuple when you need to ensure data integrity (e.g., coordinates, database keys).
• Tuples are slightly faster than lists due to immutability.
2. What real-world examples can be modeled with dictionaries?
• A phone book (name → phone number).
• Student grades (student ID → grade).
• API responses (JSON-like key-value data).
3. How could sets help improve the efficiency of a program?
• Sets store only unique values, preventing duplicates automatically.
• Membership checks (x in set) are faster than lists due to hashing.
• Useful for operations like intersection, union, and difference.
4. What issues can arise from nested data structures?
• Increased complexity and harder debugging.
• More memory usage and potential performance bottlenecks.
• Difficult traversal and access if deeply nested.
5. Why is proper data structure selection important when coding?
• Optimizes speed, memory, and readability.
• Prevents unnecessary complexity.
• Ensures code scalability and maintainability.
When would you want to use a tuple over a list?
• Tuples are immutable, meaning they can’t be changed after creation.
• Use a tuple when you need to ensure data integrity (e.g., coordinates, database keys).
• Tuples are slightly faster than lists due to immutability.
2. What real-world examples can be modeled with dictionaries?
• A phone book (name → phone number).
• Student grades (student ID → grade).
• API responses (JSON-like key-value data).
3. How could sets help improve the efficiency of a program?
• Sets store only unique values, preventing duplicates automatically.
• Membership checks (x in set) are faster than lists due to hashing.
• Useful for operations like intersection, union, and difference.
4. What issues can arise from nested data structures?
• Increased complexity and harder debugging.
• More memory usage and potential performance bottlenecks.
• Difficult traversal and access if deeply nested.
5. Why is proper data structure selection important when coding?
• Optimizes speed, memory, and readability.
• Prevents unnecessary complexity.
• Ensures code scalability and maintainability.
Lesson Reflection
Top 4 Key Points
Lists index starting at 0 and preserve order when appending items
Dictionaries map keys to values for efficient lookup time
Tuples act like immutable lists useful when data shouldn't change
Sets only allow unique elements, automatically removing duplicates
When would using a dictionary for lookups be more efficient than searching a list?
• Dictionaries provide O(1) average-time complexity for lookups using hashing, while lists
require O(n) time in worst cases.
• If frequent lookups are needed (e.g., user authentication, config settings), a dictionary is
significantly faster.
2. How could tuples ensure code doesn’t unintentionally alter data?
• Since tuples are immutable, they prevent accidental modifications.
• Useful for fixed data like GPS coordinates ((latitude, longitude)) or database keys.
3. What real-world data would best fit sets that required uniqueness?
• Email addresses in a mailing list.
• Unique product IDs in an inventory.
• Hashtags used in a social media post.
4. Why is order important for some use cases but irrelevant for others?
• Important when dealing with sequential operations (e.g., processing a queue, maintaining
historical data).
• Irrelevant when checking membership or uniqueness (e.g., user permissions, category
tags).
5. What built-in methods did you find most useful for data structures?
• [Link](key, default): Avoids KeyErrors when fetching dictionary values.
• [Link](value): Ensures unique values without duplicates.
• [Link]() / sorted(iterable): Helps maintain ordered lists efficiently.
• [Link](value): Useful for checking frequency in immutable collections.
KEY ITEMS:
loop: A keyword used for an indefinite loop that runs forever until it is broken out
of using a break statement or another control flow mechanism.
if let: A construct allowing assignment and conditional execution based on the
result of an expression, such as checking if an optional value contains a specific
type (e.g., an integer).
shadowing: The practice of redefining a variable with the same name in the
same scope to take on new characteristics or values.
type annotations: Explicitly specifying the data type for variables,
expressions, and other elements within Rust code to ensure proper compilation
and execution.
option: A wrapper over an optional value that can contain either a concrete value
(e.g., integer) or None.
sum: An enum used as a wrapper over an option in the context of this lesson; it
provides a convenient way to work with options, especially when combined with
pattern matching and if let statements.
while loop: A control flow mechanism that continues executing while a specific
condition is met.
for loop: A control flow mechanism used for iterating over sequences (e.g.,
ranges or vectors) in Rust.
continue: A keyword allowing skipping to the next iteration of a loop when
certain conditions are met, such as an odd number in this lesson's example.
break: A keyword that allows breaking out of loops and other control flow
mechanisms once specific criteria have been satisfied (e.g., finding a seven).