Scribd Logo
Upload

Welcome to Scribd!

  • 4 views

    python assignment

    Uploaded by

    karthika20805

    Copyright:

    © All Rights Reserved
    Download as TXT, PDF, TXT or read online from Scribd

    python assignment

    Uploaded by

    karthika20805
    4 views6 pages

    Copyright

    © © All Rights Reserved

    Available Formats

    TXT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Copyright:

    © All Rights Reserved
    Download as TXT, PDF, TXT or read online from Scribd
    Download as txt, pdf, or txt
    4 views6 pages

    python assignment

    Uploaded by

    karthika20805

    Copyright:

    © All Rights Reserved
    Download as TXT, PDF, TXT or read online from Scribd
    Download as txt, pdf, or txt
    You are on page 1of 6

    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',)]
    ```

    You might also like