Certainly!
Here are the solutions to the assignment problems without using custom
functions:
### 1. Extend a List with a Sublist
**Code:**
```python
# Given List
list1 = ["a", "b", ["c", ["d", "e", ["f", "g"], "k"], "1"], "m", "n"]
# Sub list to add
sub_list = ["h", "i", "j"]
# Adding sub_list to the appropriate location
list1[2][1][2].extend(sub_list)
print("Extended List:", list1)
```
**Explanation:**
1. `list1[2][1][2]` accesses the list `["f", "g"]`.
2. `extend()` method adds the elements of `sub_list` to this list.
**Output:**
```
Extended List: ['a', 'b', ['c', ['d', 'e', ['f', 'g', 'h', 'i', 'j'], 'k'], '1'],
'm', 'n']
```
### 2. Replace Occurrences of the First Character
**Code:**
```python
# Sample String
string = 'restart'
# Replace occurrences of the first character
first_char = string[0]
result = first_char + string[1:].replace(first_char, '$')
print("Result:", result)
```
**Explanation:**
1. `first_char` stores the first character of the string.
2. `replace()` method replaces all occurrences of `first_char` with '$' in the
substring from the second character onward.
**Output:**
```
Result: resta$t
```
### 3. Replace Substrings 'not'...'poor' with 'good'
**Code:**
```python
# Sample Strings
string1 = 'The lyrics is not that poor!'
string2 = 'The lyrics is poor!'
# Find positions of 'not' and 'poor'
not_pos1 = string1.find('not')
poor_pos1 = string1.find('poor')
# Replace if 'not' follows 'poor'
if not_pos1 != -1 and poor_pos1 != -1 and not_pos1 > poor_pos1:
result1 = string1[:poor_pos1] + 'good' + string1[not_pos1 + 3:]
else:
result1 = string1
print("Result 1:", result1)
# Repeat for second string
not_pos2 = string2.find('not')
poor_pos2 = string2.find('poor')
if not_pos2 != -1 and poor_pos2 != -1 and not_pos2 > poor_pos2:
result2 = string2[:poor_pos2] + 'good' + string2[not_pos2 + 3:]
else:
result2 = string2
print("Result 2:", result2)
```
**Explanation:**
1. `find()` method is used to locate the positions of 'not' and 'poor'.
2. If 'not' follows 'poor', replace the substring with 'good'.
**Output:**
```
Result 1: The lyrics is good!
Result 2: The lyrics is poor!
```
### 4. Check Circularly Identical Lists
**Code:**
```python
# Input Lists
list1 = [10, 10, 0, 0, 10]
list2 = [10, 10, 10, 0, 0]
list3 = [1, 10, 10, 0, 0]
# Check circularly identical
double_list1 = list1 + list1
is_identical_list1_list2 = any(double_list1[i:i + len(list2)] == list2 for i in
range(len(list1)))
is_identical_list1_list3 = any(double_list1[i:i + len(list3)] == list3 for i in
range(len(list1)))
print("List1 and List2 are circularly identical:", is_identical_list1_list2)
print("List1 and List3 are circularly identical:", is_identical_list1_list3)
```
**Explanation:**
1. Concatenate `list1` with itself to handle circular shifts.
2. Check if `list2` and `list3` appear in this concatenated list.
**Output:**
```
List1 and List2 are circularly identical: True
List1 and List3 are circularly identical: False
```
### 5. Move All Zero Digits to the End
**Code:**
```python
# Original List
original_list = [3, 4, 0, 0, 0, 6, 2, 0, 6, 7, 6, 0, 0, 0, 9, 10, 7, 4, 4, 5, 3, 0,
0, 2, 9, 7, 1]
# Move zeros to the end
non_zero_elements = [x for x in original_list if x != 0]
zero_elements = [x for x in original_list if x == 0]
result = non_zero_elements + zero_elements
print("Moved List:", result)
```
**Explanation:**
1. Separate non-zero and zero elements.
2. Concatenate these lists.
**Output:**
```
Moved List: [3, 4, 6, 2, 6, 7, 6, 9, 10, 7, 4, 4, 5, 3, 2, 9, 7, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0]
```
### 6. Swap First Two Characters of Each String
**Code:**
```python
# Sample Strings
string1 = 'abc'
string2 = 'xyz'
# Swap first two characters and concatenate
result = string2[:2] + string1[2:] + ' ' + string1[:2] + string2[2:]
print("Result:", result)
```
**Explanation:**
1. Swap the first two characters of `string1` and `string2`.
2. Concatenate them with a space.
**Output:**
```
Result: xyc abz
```
### 7. Create a Dictionary of Squares
**Code:**
```python
# Create dictionary with keys as numbers 1 to 15 and values as their squares
squares_dict = {}
for x in range(1, 16):
squares_dict[x] = x**2
print("Dictionary of Squares:", squares_dict)
```
**Explanation:**
1. Use a loop to create key-value pairs where each key is a number and its value is
the square of the number.
**Output:**
```
Dictionary of Squares: {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}
```
### 8. Print Distinct Values in a Dictionary
**Code:**
```python
# Sample Data
data = [{"V": "S001"}, {"V": "S002"}, {"VI": "S001"}, {"VI": "S005"}, {"VII":
"S005"}, {"V": "S009"}, {"VIII": "S007"}]
# Collect all unique values
unique_values = set()
for d in data:
unique_values.update(d.values())
print("Unique Values:", unique_values)
```
**Explanation:**
1. Use a loop to collect all values from the list of dictionaries into a set to
ensure uniqueness.
**Output:**
```
Unique Values: {'S005', 'S002', 'S007', 'S001', 'S009'}
```
### 9. Explain Operators and Expressions in Python
**Explanation:**
**Operators** in Python are special symbols or keywords that perform operations on
operands.
**Types of Operators:**
- **Arithmetic Operators:** Used for basic math operations.
- `+` (Addition), `-` (Subtraction), `*` (Multiplication), `/` (Division), `//`
(Floor Division), `%` (Modulus), `**` (Exponentiation)
- Example:
```python
a = 5
b = 3
print(a + b) # 8
print(a ** b) # 125
```
- **Comparison Operators:** Used to compare values.
- `==` (Equal), `!=` (Not equal), `>` (Greater than), `<` (Less than), `>=`
(Greater than or equal), `<=` (Less than or equal)
- Example:
```python
a = 10
b = 20
print(a < b) # True
print(a == b) # False
```
- **Logical Operators:** Used to combine conditional statements.
- `and`, `or`, `not`
- Example:
```python
a = True
b = False
print(a and b) # False
print(not a) # False
```
- **Assignment Operators:** Used to assign values to variables.
- `=`, `+=`, `-=`, `*=`, `/=`
- Example:
```python
a = 10
a += 5
# a = a + 5
print(a) # 15
```
- **Bitwise Operators:** Operate on binary representations of integers.
- `&` (AND), `|` (OR), `^` (XOR), `~` (NOT), `<<` (Left Shift), `>>` (Right
Shift)
- Example:
```python
a = 5 # 0101 in binary
b = 3 # 0011 in binary
print(a & b) # 1 (0001 in binary)
```
### 10. Create a Dictionary Grouping Key-Value Pairs into Lists
**Code:**
```python
# Original list
pairs = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
# Create dictionary grouping values into lists
grouped_dict = {}
for key, value in pairs:
if key in grouped_dict:
grouped_dict[key].append(value)
else:
grouped_dict[key] = [value]
print("Grouped Dictionary:", grouped_dict)
```
**Explanation:**
1. Use a loop to iterate through key-value pairs.
2. Add values to lists in the dictionary, grouping by the key.
**Output:**
```
Grouped Dictionary: {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]}
```
### 11. Remove Empty Tuples from a List of Tuples
**Code:**
```python
# Sample data
data = [(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d',)]
# Remove empty tuples
result = [t for t in data if t]
print("Filtered List:", result)
```
**Explanation:**
1. Use a list comprehension to filter out empty tuples.
**Output:**
```
Filtered List: [('',), ('a', 'b'), ('a', 'b', 'c'), ('d',)]
```
