Mapping Type

This task teaches how to create a dictionary, add a new key-value pair, and print the dictionary structure. It emphasizes how to use user input to dynamically populate a mapping and introduces dictionary assignment syntax.

• Use input() twice to get the name and phone number.
• Declare an empty dictionary before adding data.
• Use square brackets to assign the value: phone_book[name] = number.

1. Forgetting to initialize the dictionary: Trying to assign a value without creating the dictionary first leads to a NameError.
2. Using parentheses instead of square brackets: dict(name) = number is invalid. Always use dict[key] syntax for assignment.
3. Reusing the same variable name: Overwriting the dictionary by assigning a string or number to the same variable can destroy your structure.
4. Not using strings for keys: Be consistent and treat names as strings. Avoid using numbers as keys unless necessary.
5. Printing values only: Beginners often print just the value. Use print(dict) or iterate over items() to see both key and value.

You’re building a simple key-value lookup. Think of it as adding a record to a notebook where a name points to a phone number.

1. Ask the user for a name and store it in a variable
2. Ask the user for a phone number and store it
3. Create an empty dictionary named phone_book
4. Add the name and number as a key-value pair
5. Print the dictionary to verify it works

• Ask for multiple entries using a loop
• Check if a name already exists and update it if needed
• Format the output nicely when displaying the dictionary

This task teaches how to retrieve values using a key and how to check for key existence in a dictionary. It also covers basic use of the in operator and conditional logic for user-friendly programs.

• Define a dictionary with a few key-value pairs manually
• Use input() to get the country name
• Use if country in dict to check for a match
• Use dict[key] or get() to access the value

1. Checking for a capital instead of the country: Make sure the user input is matched against the keys, not the values.
2. Not handling wrong input: If the user types an unknown country and you try to access it directly, it may cause a KeyError. Use in to check first.
3. Misspelling keys or mismatching case: "France" is different from "france". Normalize input with .title() or .lower() as needed.
4. Confusing key and value syntax: Remember: dict[country] gives you the capital, not the other way around.
5. Hardcoding too much: Beginners sometimes rewrite if conditions for every country. Use the dictionary lookup instead.

Think of the dictionary as a world atlas. You’re asking the user to name a country and looking up its capital in your reference.

1. Create a dictionary like {"France": "Paris", "Italy": "Rome", "Japan": "Tokyo"}
2. Ask the user to type a country name
3. Check if the country is in the dictionary
4. If it is, print the capital city
5. If not, show a message like “Country not found”

• Allow the user to keep searching until they type “exit”
• Make the check case-insensitive
• Let users add new country-capital pairs to the dictionary

This task strengthens your ability to loop through elements, conditionally update dictionary values, and use dictionaries as counters. You will also work with string methods to split and clean user input.

• Use .split() to turn the sentence into words.
• Loop through each word and check if it’s already in the dictionary.
• If the word exists, increment its count; otherwise, set it to 1.
• Use dict.get(word, 0) + 1 as a shortcut to update counts.

1. Forgetting to initialize counts: If you don't check whether a word is already in the dictionary, you’ll get a KeyError when trying to increment a non-existent key.
2. Case sensitivity issues: Words like "Hello" and "hello" are treated as different keys. Normalize all words using .lower() before counting.
3. Including punctuation: Words like "hello!" and "hello" will be treated differently. Strip punctuation before counting.
4. Using a list instead of a dictionary: Some beginners try to store counts in a list. That doesn’t work - you need key-value pairing.
5. Not printing the result clearly: Always show the final dictionary in a readable format to confirm your logic worked.

Imagine a word counter tool that tracks how often each word is spoken. That's exactly what your program will simulate.

1. Ask the user for a sentence and store it as a string
2. Split the sentence into individual words
3. Initialize an empty dictionary to store word counts
4. Loop through each word in the list
5. Use get() to update the count or initialize it at 1
6. Print the dictionary with word frequencies

• Remove punctuation using string.punctuation and translate()
• Sort the result by word or frequency
• Ignore common stop words like "the", "and", "is", etc.

This exercise develops your skill in validating dictionary keys, building simple lookup systems, and responding to user input in an informative way. It also reinforces the idea that dictionaries can model real-life databases or configurations.

• Predefine the dictionary with several key-value pairs
• Use input() to get the product name
• Normalize the input with .lower() to match keys
• Check for existence with if name in dict
• Print the price if found; otherwise print a message

1. Incorrect casing: The user might type "Milk" while your key is "milk". Always normalize the case before checking.
2. Using [] instead of get() without a check: Accessing a missing key with brackets will raise an error. Use get() or check with in.
3. Returning the wrong value: Ensure you’re accessing the price (value), not printing the whole dictionary or a key.
4. Forgetting to define the dictionary first: You must create and fill the product-price mapping before using it.
5. Not handling empty or invalid input: Always prepare for cases where the user doesn’t type anything or enters a typo.

Think of this task like using a store’s product scanner. The user provides a name, and you search your "database" to return the price.

1. Create a dictionary with product names and their prices
2. Ask the user to input the product name
3. Convert input to lowercase (if needed)
4. Check if the product exists in the dictionary
5. If it exists, print the price
6. If it doesn’t, print “Product not found”

• Allow the user to check multiple products in a loop
• Format prices with 2 decimal places using format()
• Let the user add new products to the dictionary during runtime

This task develops your understanding of grouped data processing and dictionary-based data aggregation. It strengthens your use of dict.setdefault() or conditional logic to build lists as dictionary values.

• Start with an empty dictionary.
• Loop through each (name, grade) tuple.
• Check if the grade already exists as a key.
• If it does, append the student; if not, create a new list.

1. Overwriting values instead of appending: Many beginners mistakenly assign dict[grade] = name instead of appending to a list, which causes data loss.
2. Forgetting to initialize the list: If you don’t check for the key before appending, you'll get a KeyError.
3. Confusing key and value roles: Ensure the grade is used as the dictionary key and the name is added to the list, not vice versa.
4. Not using unpacking: Beginners often loop through the list incorrectly. Use for name, grade in list to avoid index confusion.
5. Printing the dictionary too early: Be sure to build the entire dictionary before printing the final result.

You're grouping students by their results - similar to how schools organize performance reports. The same principle applies to data clustering in analytics.

1. Start with a list of (name, grade) tuples
2. Create an empty dictionary called grade_groups
3. Loop over each tuple
4. Check if the grade already exists in the dictionary
5. If yes, append the name to the list
6. If no, create a new list with that name
7. Print the dictionary once all items are processed

• Sort the list of students alphabetically inside each grade group
• Convert all grades to uppercase before grouping
• Use collections.defaultdict for cleaner logic

This task teaches dictionary merging logic, how to manage conflicts between keys, and how to preserve and update important data. You’ll learn how to use update() method and dictionary unpacking with clarity and intent.

• Use .update() or dictionary unpacking to merge
• Be aware of which values take precedence
• Print the dictionary after merging to check the result
• Copy user1 first if you don’t want to modify the original

1. Not copying before updating: If you use user1.update(user2) directly, you lose the original state of user1.
2. Wrong precedence direction: Make sure that user2 values overwrite user1 - not the reverse.
3. Trying to use addition: Dictionaries cannot be added using +. Use update() or unpacking instead.
4. Not checking key existence: You may want to log or alert when overwriting important fields like email.
5. Accidentally merging into user2: Be clear about which object holds the final merged result.

Think of this as combining profile data from two systems. You want to retain the most up-to-date info without losing important fields.

1. Start with two dictionaries: user1 and user2
2. Create a copy of user1 to preserve the original
3. Use .update(user2) to merge the two
4. Verify that user2's values overwrite where keys overlap
5. Print the merged dictionary

• Track which fields were overwritten using a loop
• Only overwrite if the new value is not None or empty
• Support deep merge for nested dictionaries