Computer Science: Class 11 — Chapter 10: Tuples and Dictionaries

Tuples can be created with mixed data types, nested lists, or nested tuples. A sequence without parenthesis is also treated as a tuple by default.

  
    >>> tuple1 = (1, 2, 3, 4, 5)
    >>> tuple2 = ('Economics', 87, 'Accountancy', 89.6)
    >>> tuple3 = (10, 20, 30, [40, 50])
    >>> tuple4 = (1, 2, 3, 4, 5, (10, 20))
  

Critical Rule for Single Element Tuples: If there is only a single element in a tuple, it must be followed by a trailing comma. Otherwise, Python treats it as a regular scalar type (e.g., integer or string).

  
    >>> tuple5 = (20) # Treated as integer
    >>> type(tuple5)
    <class 'int'>
    >>> tuple5 = (20,) # Correct single-element tuple
    >>> type(tuple5)
    <class 'tuple'>
  

Elements of a tuple are accessed using zero-based indexing and slicing, similar to lists and strings. Negative indexing is also supported.

  
    >>> tuple1 = (2, 4, 6, 8, 10, 12)
    >>> tuple1[0]
    2
    >>> tuple1[-1]
    12
  

Immutability: Tuples are immutable . Once created, their elements cannot be changed or reassigned. Attempting to do so raises a TypeError .

  
    >>> tuple1[4] = 10
    TypeError: 'tuple' object does not support item assignment
  

However, if a tuple contains a mutable element (like a list ), the contents of that mutable element can be modified in-place.

  
    >>> tuple2 = (1, 2, 3, [8, 9])
    >>> tuple2[3][1] = 10
    >>> tuple2
    (1, 2, 3, [8, 10])
  

• Concatenation ( + ): Joins two tuples to create a new tuple. Both operands must be tuples.
• Repetition ( * ): Repeats the elements of a tuple a specified number of \times. One operand must be a tuple, and the other must be an integer.
• Membership ( in / not in ): Checks if an element exists within the tuple, returning a boolean value.
• Slicing: Extracts a subpart of the tuple using [start:stop:step] .

  
    >>> t1 = (1, 3, 5)
    >>> t2 = (2, 4)
    >>> t1 + t2
    (1, 3, 5, 2, 4)
    >>> t2 * 3
    (2, 4, 2, 4, 2, 4)
    >>> 3 in t1
    True
  

The following built-in functions are commonly used with tuples:

• len() : Returns the total number of elements in the tuple.
• tuple() : Creates an empty tuple or converts a sequence (string, list, range) into a tuple.
• count() : Returns the number of \times a given element appears in the tuple.
• index() : Returns the index of the first occurrence of a specified element. Raises ValueError if not found.
• sorted() : Takes elements of the tuple and returns a new sorted list (does not modify the original tuple).
• min() , max() , sum() : Compute the minimum, maximum, and sum of elements in a numeric tuple.

Tuple assignment allows a tuple of variables on the left side of an assignment operator to be assigned values from a tuple on the right side. The number of variables must match the number of elements in the tuple.

  
    >>> (num1, num2) = (10, 20)
    >>> record = ("Pooja", 40, "CS")
    >>> (name, rollNo, subject) = record
  

Keys in a dictionary must be unique and of an immutable data type (e.g., number, string, or tuple). Values can be of any data type and can be repeated.

  
    >>> dict1 = {} # Empty dictionary
    >>> dict2 = dict() # Using built-in function
    >>> dict3 = {'Mohan': 95, 'Ram': 89, 'Suhel': 92}
  

Items are accessed via their keys rather than relative positions or indices. Attempting to access a non-existent key raises a KeyError .

  
    >>> dict3['Ram']
    89
    >>> dict3['Shyam']
    KeyError: 'Shyam'
  

Dictionaries are mutable . You can add new key-value pairs or modify existing ones by direct assignment.

  
    >>> dict3['Meena'] = 78 # Adding a new item
    >>> dict3['Suhel'] = 93.5 # Modifying an existing item
  

Membership Operators: The in and not in operators check for the presence of a key in the dictionary (not the value).

  
    >>> 'Suhel' in dict3
    True
  

Dictionaries can be traversed using a for loop in two primary ways:

Method 1: Iterating over keys directly

  
    for key in dict1:
    print(key, ':', dict1[key])
  

Method 2: Iterating over key-value pairs using items()

  
    for key, value in dict1.items():
    print(key, ':', value)