Assignment 5

Author: Pulkit1822

add_key_to_dictionary/add_key_to_dictionary.md

@@ -0,0 +1,24 @@
+## Summary
+This code snippet allows the user to input a key and a value, and then adds the key-value pair to a dictionary. Finally, it prints the updated dictionary.
+
+## Example Usage
+```python
+Enter key: 2
+Enter value: 30
+{0: 10, 1: 20, 2: 30}
+```
+
+## Code Analysis
+### Inputs
+- `key`: an integer representing the key to be added to the dictionary.
+- `value`: an integer representing the value to be associated with the key in the dictionary.
+___
+### Flow
+1. Prompt the user to enter a key.
+2. Prompt the user to enter a value.
+3. Add the key-value pair to the dictionary.
+4. Print the updated dictionary.
+___
+### Outputs
+- `d`: the updated dictionary with the new key-value pair added.
+___

add_key_to_dictionary/add_key_to_dictionary.py

@@ -0,0 +1,5 @@
+d = {0: 10, 1: 20}
+key = int(input("Enter key: "))
+value = int(input("Enter value: "))
+d[key] = value
+print(d)

check_key_in_dictionary/check_key_in_dictionary.md

@@ -0,0 +1,23 @@
+## Summary
+This code snippet checks if a given key exists in a dictionary.
+
+## Example Usage
+```python
+Enter a key: 'a'
+Key already exists.
+```
+
+## Code Analysis
+### Inputs
+- `key`: a string representing the key to be checked in the dictionary.
+___
+### Flow
+1. Prompt the user to enter a key.
+2. Check if the entered key exists in the dictionary.
+3. If the key exists, print 'Key already exists.'
+4. If the key does not exist, print 'Key does not exist.'
+___
+### Outputs
+- 'Key already exists.' if the entered key exists in the dictionary.
+- 'Key does not exist.' if the entered key does not exist in the dictionary.
+___

check_key_in_dictionary/check_key_in_dictionary.py

@@ -0,0 +1,6 @@
+d = {'a': 1, 'b': 2, 'c': 3}
+key = input("Enter a key: ")
+if key in d:
+    print('Key already exists.')
+else:
+    print('Key does not exist.')

combine_dicts_to_list_values/combine_dicts_to_list_values.md

@@ -0,0 +1,37 @@
+## Summary
+The code snippet is a function called `combine_dicts_to_list_values` that takes in multiple dictionaries as arguments and combines them into a single dictionary where the values for each key are stored in a list.
+
+## Example Usage
+```python
+dict1 = {"w": 50, "x": 100, "y": "Green", "z": 400}
+dict2 = {"x": 300, "y": "Red", "z": 600}
+combine_dicts_to_list_values(dict1, dict2)
+```
+Expected Output:
+```
+Original dictionaries:
+{'w': 50, 'x': 100, 'y': 'Green', 'z': 400}
+{'x': 300, 'y': 'Red', 'z': 600}
+
+Combined dictionaries, creating a list of values for each key:
+{'w': [50], 'x': [100, 300], 'y': ['Green', 'Red'], 'z': [400, 600]}
+```
+
+## Code Analysis
+### Inputs
+- `dict1`: A dictionary containing key-value pairs.
+- `*dict_list`: Variable number of dictionaries.
+___
+### Flow
+1. The function takes in a dictionary `dict1` and a variable number of dictionaries `*dict_list`.
+2. It prints the original dictionaries.
+3. It initializes an empty dictionary `combined_dict`.
+4. It iterates over each dictionary in `[dict1, *dict_list]`.
+5. For each key-value pair in the dictionary, it checks if the key already exists in `combined_dict`.
+6. If the key does not exist, it creates a new list with the value and assigns it to the key in `combined_dict`.
+7. If the key already exists, it appends the value to the existing list for that key in `combined_dict`.
+8. Finally, it prints the combined dictionary.
+___
+### Outputs
+- `combined_dict`: A dictionary where the values for each key are stored in a list.
+___

combine_dicts_to_list_values/combine_dicts_to_list_values.py

@@ -0,0 +1,20 @@
+def combine_dicts_to_list_values(dict1, *dict_list):
+    print("Original dictionaries:\n")
+    for dictionary in [dict1, *dict_list]:
+        print(dictionary)
+    print("\nCombined dictionaries, creating a list of values for each key:")
+    combined_dict = {}
+    for dictionary in [dict1, *dict_list]:
+        for key, value in dictionary.items():
+            if key not in combined_dict:
+                combined_dict[key] = [value]  # Create a new list for the key if it doesn't exist
+            else:
+                combined_dict[key].append(value)  # Append the value to the existing list for the key
+    print(combined_dict)
+
+
+if __name__ == "__main__":
+    dict1 = {"w": 50, "x": 100, "y": "Green", "z": 400}
+    dict2 = {"x": 300, "y": "Red", "z": 600}
+    combine_dicts_to_list_values(dict1, dict2)
+

combine_dicts_to_list_values/tempCodeRunnerFile.py

@@ -0,0 +1,19 @@
+def get_user_input():
+    dict1 = {}
+    dict2 = {}
+
+    # Get user input for dict1
+    dict1_input = input("Enter key-value pairs for dict1 (separated by commas): ")
+    dict1_pairs = dict1_input.split(',')
+    for pair in dict1_pairs:
+        key, value = pair.split(':')
+        dict1[key.strip()] = int(value.strip())
+
+    # Get user input for dict2
+    dict2_input = input("Enter key-value pairs for dict2 (separated by commas): ")
+    dict2_pairs = dict2_input.split(',')
+    for pair in dict2_pairs:
+        key, value = pair.split(':')
+        dict2[key.strip()] = int(value.strip())
+
+    return dict1, dict2

concatenate_dictionaries/concatenate_dictionaries.md

@@ -0,0 +1,31 @@
+## Summary
+This code snippet prompts the user to enter the number of keys for a dictionary and then asks for the key-value pairs. It creates a dictionary with the entered key-value pairs and prints the resulting dictionary.
+
+## Example Usage
+```python
+Enter the number of keys: 3
+Enter the key: 1
+Enter the value: 10
+Enter the key: 2
+Enter the value: 20
+Enter the key: 3
+Enter the value: 30
+{1: 10, 2: 20, 3: 30}
+```
+
+## Code Analysis
+### Inputs
+- `num_keys`: an integer representing the number of keys for the dictionary
+- `key`: an integer representing the key for each key-value pair
+- `value`: an integer representing the value for each key-value pair
+___
+### Flow
+1. The code prompts the user to enter the number of keys for the dictionary.
+2. It then iterates over the range of keys.
+3. For each key, it prompts the user to enter the key and value.
+4. It adds the key-value pair to the `new_dict` dictionary.
+5. Finally, it prints the resulting dictionary.
+___
+### Outputs
+- `new_dict`: a dictionary containing the entered key-value pairs.
+___

concatenate_dictionaries/concatenate_dictionaries.py

@@ -0,0 +1,12 @@
+new_dict = {}
+
+# Prompt the user for input
+num_keys = int(input("Enter the number of keys: "))
+
+# Iterate over the range of keys
+for i in range(num_keys):
+    key = int(input("Enter the key: "))
+    value = int(input("Enter the value: "))
+    new_dict[key] = value
+
+print(new_dict)

filter_student_height_weight/filter_student_height_weight.md

@@ -0,0 +1,33 @@
+## Summary
+The code snippet is a function called `filter_data` that takes a dictionary of students' names as keys and tuples of their height and weight as values. It filters the students based on the condition that their height is greater than or equal to 6.0 and their weight is greater than or equal to 70. The function returns a new dictionary with the filtered students.
+
+## Example Usage
+```python
+Original Dictionary:
+{
+    'Cierra Vega': (6.2, 70),
+    'Alden Cantrell': (5.9, 65),
+    'Kierra Gentry': (6.0, 68),
+    'Pierre Cox': (5.8, 66)
+}
+
+Height > 6ft and Weight > 70kg:
+{
+    'Cierra Vega': (6.2, 70)
+}
+```
+
+## Code Analysis
+### Inputs
+- `students`: A dictionary where the keys are the names of the students and the values are tuples representing their height and weight.
+___
+### Flow
+1. The function `filter_data` takes the `students` dictionary as input.
+2. It uses a dictionary comprehension to iterate over the items in the `students` dictionary.
+3. For each key-value pair, it checks if the height (first element of the tuple) is greater than or equal to 6.0 and the weight (second element of the tuple) is greater than or equal to 70.
+4. If the condition is true, it adds the key-value pair to a new dictionary called `result`.
+5. Finally, it returns the `result` dictionary.
+___
+### Outputs
+- `result`: A dictionary containing the filtered students where the height is greater than or equal to 6.0 and the weight is greater than or equal to 70.
+___

filter_student_height_weight/filter_student_height_weight.py

@@ -0,0 +1,16 @@
+def filter_data(students):
+    result = {k: s for k, s in students.items() if s[0] >= 6.0 and s[1] >= 70}
+    return result
+    
+students = {
+    'Cierra Vega': (6.2, 70),
+    'Alden Cantrell': (5.9, 65),
+    'Kierra Gentry': (6.0, 68),
+    'Pierre Cox': (5.8, 66)
+}
+
+print("Original Dictionary:")
+print(students)
+
+print("\nHeight > 6ft and Weight > 70kg:")
+print(filter_data(students))

generate_square_dict/generate_square_dict.md

@@ -0,0 +1,28 @@
+## Summary
+The code snippet creates a dictionary called 'squares' that contains the squares of numbers from 1 to 15. It then prints the dictionary.
+
+## Example Usage
+```python
+squares = {}
+for i in range(1, 16):
+    squares[i] = i ** 2
+print(squares)
+```
+Expected Output:
+```
+{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225}
+```
+
+## Code Analysis
+### Inputs
+- None
+___
+### Flow
+1. Initialize an empty dictionary called 'squares'.
+2. Iterate over the range from 1 to 15 (excluding 16).
+3. For each number in the range, calculate its square and assign it as the value in the 'squares' dictionary with the number as the key.
+4. Print the 'squares' dictionary.
+___
+### Outputs
+- The 'squares' dictionary containing the squares of numbers from 1 to 15.
+___

generate_square_dict/generate_square_dict.py

@@ -0,0 +1,4 @@
+squares = {}
+for i in range(1, 16):
+    squares[i] = i ** 2
+print(squares)

group_pairs_into_dict_of_lists/group_pairs_into_dict_of_lists.md

@@ -0,0 +1,43 @@
+## Summary
+This code snippet defines a function called `group_pairs_into_dict_of_lists` that takes a list of key-value pairs and groups them into a dictionary of lists based on the keys. It then prompts the user to enter the number of pairs and the key-value pairs, and prints the original list and the grouped dictionary.
+
+## Example Usage
+```python
+Enter the number of pairs: 5
+Enter the key: yellow
+Enter the value: 1
+Enter the key: blue 
+Enter the value: 2
+Enter the key: yellow
+Enter the value: 3
+Enter the key: blue
+Enter the value: 4
+Enter the key: red
+Enter the value: 1
+Original list:
+[('yellow', '1'), ('blue', '2'), ('yellow', '3'), ('blue', '4'), ('red', '1')]
+
+Grouping a sequence of key-value pairs into a dictionary of lists:
+{'yellow': ['1', '3'], 'blue': ['2', '4'], 'red': ['1']}
+```
+
+## Code Analysis
+### Inputs
+- `pairs`: A list of key-value pairs.
+___
+### Flow
+1. The function `group_pairs_into_dict_of_lists` is defined.
+2. The function initializes an empty dictionary called `result`.
+3. The function iterates over each key-value pair in the `pairs` list.
+4. For each pair, the function checks if the key already exists in the `result` dictionary. If not, it adds the key to the dictionary with an empty list as the value.
+5. The function then appends the value to the list associated with the key in the `result` dictionary.
+6. After iterating through all the pairs, the function returns the `result` dictionary.
+7. The code prompts the user to enter the number of pairs.
+8. The code then prompts the user to enter the key and value for each pair and appends them to the `pairs` list.
+9. The code prints the original list of pairs.
+10. The code calls the `group_pairs_into_dict_of_lists` function with the `pairs` list and prints the resulting grouped dictionary.
+___
+### Outputs
+- The original list of key-value pairs.
+- The grouped dictionary where the keys are unique and the values are lists of corresponding values.
+___

group_pairs_into_dict_of_lists/group_pairs_into_dict_of_lists.py

@@ -0,0 +1,20 @@
+def group_pairs_into_dict_of_lists(pairs):
+    result = {}
+    for key, value in pairs:
+        result.setdefault(key, []).append(value)
+    return result
+
+pairs = []
+
+num_pairs = int(input("Enter the number of pairs: "))
+
+for i in range(num_pairs):
+    key = input("Enter the key: ")
+    value = input("Enter the value: ")
+    pairs.append((key, value))
+
+print("Original list:")
+print(pairs)
+
+print("\nGrouping a sequence of key-value pairs into a dictionary of lists:")
+print(group_pairs_into_dict_of_lists(pairs))

remove_duplicates_from_dictionary/remove_duplicates_from_dictionary.md

@@ -0,0 +1,49 @@
+## Summary
+The code snippet creates a dictionary called `student_data` with information about students. It then iterates over the items in the dictionary and checks if the current value is already present in the `result` dictionary. If not, it adds the key-value pair to the `result` dictionary. Finally, it prints the `result` dictionary.
+
+## Example Usage
+```python
+student_data = {
+    'id1': {
+        'name': ['Sara'],
+        'class': ['V'],
+        'subject_integration': ['english, math, science']
+    },
+    'id2': {
+        'name': ['David'],
+        'class': ['V'],
+        'subject_integration': ['english, math, science']
+    },
+    'id3': {
+        'name': ['Sara'],
+        'class': ['V'],
+        'subject_integration': ['english, math, science']
+    },
+    'id4': {
+        'name': ['Surya'],
+        'class': ['V'],
+        'subject_integration': ['english, math, science']
+    }
+}
+
+result = {}
+for key, value in student_data.items():
+    if value not in result.values():
+        result[key] = value
+print(result)
+```
+
+## Code Analysis
+### Inputs
+- `student_data`: a dictionary containing information about students. Each key represents a unique student ID, and each value is a dictionary containing the student's name, class, and subject integration.
+___
+### Flow
+1. Create an empty dictionary called `result`.
+2. Iterate over the items in the `student_data` dictionary.
+3. For each item, check if the value is already present in the `result` dictionary.
+4. If the value is not present, add the key-value pair to the `result` dictionary.
+5. Print the `result` dictionary.
+___
+### Outputs
+- `result`: a dictionary containing unique student data, where each key represents a unique student ID and each value is a dictionary containing the student's name, class, and subject integration.
+___